Maven

此文档还需完善图片问题请留言或联系作者

Maven 的介绍和安装配置

Maven 是一个跨平台的项目管理工具；Maven 主要服务于基于 Java 平台的项目构建、依赖管理和项目信息管理。（Apache 组织的开源项目）

Maven 是基于项目对象模型（POM project object model）,可以通过一小段描述信息来管理项目的构建、报告和文档的软件项目管理工具

构建(Build)：编译、运行单元测试、生成文档、打包和部署等工作。

Make 和 Ant 是过程式的，开发者需要显示指定每一个目标，以及完成该目标所需要执行的任务。 Maven 是声明式的，项目构建过程和各个阶段所需的工作都由插件实现，并且大部分插件都是现成的，开发者只需要声明项目的基本元素，Maven 就执行内置的、完整的构建过程。

Maven 的几个核心概念：

POM (Project Object Model)
Maven 插件
Maven 生命周期
Maven 依赖管理
Maven 库

Maven 安装

Ubuntu 16 安装 Maven：

sudo apt install maven

查看 Maven 信息，运行:

mvn -v

Windows 安装 Maven：

下载：官网：Maven – Welcome to Apache Maven 下载二进制压缩包
安装：Maven – Installing Apache Maven

另外也可通过 scoop 安装

1

scoop install maven

配置 Maven 环境变量：
MAVEN_HOME : D:\server\maven\apache-maven-3.5.0
PATH : %MAVEN_HOME%\bin;
MAVEN_OPTS : -Xms128m -Xmx512m -Duser.language=zh -Dfile.encoding=UTF-8
使用 mvn -v会看到如下内容：
Default locale: zh_CN, platform encoding: GBK
-Dfile.encoding=UTF-8应该可以设置编码。

Setting 配置文件：Maven – Settings Reference

镜像仓库：Maven – Guide to Mirror Settings

本地仓库配置

从中央仓库下载的 jar 包，都会统一存放到本地仓库中。

可以在全局配置文件中通过设置 localRepository 来设置本地仓库路径：

1
2
3
4
5
6


  <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  -->
  <localRepository>D:\PortableSoftware\Maven\repository</localRepository>

设置 HTTP 代理

先检测代理服务器地址(218…)和相关端口(3128)是否畅通： telnet 218... 3128 。如果连接正确，输入ctrl + ] 然后 q ，回车退出。

复制Maven home: /usr/share/maven /conf/settings.xml文件到~/.m2/settings.xml 编辑<proxies>下的<proxy>标签即可；默认第一个被激活的 proxy 会生效。其中 active 的值为 true 表示激活该代理，用户和密码等可以注释掉；其中 nonProxyHost 元素用来指定哪些主机名不需要代理，使用 |分隔多个主机名并支持通配符。

Maven 镜像网站

Maven 镜像(更改vim ~/.m2/settings.xml文件)：

maven 默认的远程库(http://repo1.maven.org/maven2)

Maven 阿里云中央仓库(国内快)：

1
2
3
4
5
6
7
8


  <mirrors>
    <mirror>
      <id>alimaven</id>
      <name>aliyun maven</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
      <mirrorOf>central</mirrorOf>
    </mirror>
  </mirrors>

Maven 国外镜像

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


<mirror>
      <id>ibiblio</id>
      <mirrorOf>central</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
     <url>http://mirrors.ibiblio.org/pub/mirrors/maven2/</url>
</mirror>
<mirror>
      <id>repo2</id>
      <mirrorOf>central</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://repo2.maven.org/maven2/</url>
</mirror>
<mirror>
      <id>ui</id>
      <mirrorOf>central</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
     <url>http://uk.maven.org/maven2/</url>
</mirror>
<mirror>
      <id>jboss-public-repository-group</id>
      <mirrorOf>central</mirrorOf>
      <name>JBoss Public Repository Group</name>
     <url>http://repository.jboss.org/nexus/content/groups/public</url>
</mirror>

Maven 项目结构

Maven 使用惯例优于配置的原则 。它要求在没有定制之前，所有的项目都有如下的结构：

目录	目的
`${basedir}`	存放 pom.xml 和所有的子目录
`${basedir}/src/main/java`	项目的 java 源代码
`${basedir}/src/main/resources`	项目的资源，比如说 property 文件
`${basedir}/src/test/java`	项目的测试类，比如说 JUnit 代码
`${basedir}/src/test/resources`	测试使用的资源

另外：编译后的 classes 会放在 ${basedir}/target/classes 下面， JAR 文件会放在 ${basedir}/target 下面。

Maven 项目中配置文件的读取和写入

配置文件需要放置在： ${basedir}/src/main/resources 目录。

比如下面的代码读取的都是该目录下的配置文件：

1
2
3


//示例一： c3p0 的配置文件 c3p0-config.xml
//自动读取 src/main/resources目录下的c3p0-config.xml中的默认配置，获取c3p0的连接池
ComboPooledDataSource ds = new ComboPooledDataSource();

1
2
3
4
5
6
7


//示例二：读取properties配置文件
Properties properties = new Properties();
//这里注意： 对于maven项目，配置文件需要放在 src/main/resources 目录下
InputStream is = DruidDemo.class.getClassLoader()
    .getResourceAsStream("druid.properties");

properties.load(is);

测试 class.getClassLoader().getResource()和 class.getResource()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


    // 测试 getClassLoader().getResource() 和 getResource()
  // 当前类为 DruidDemo
  @Test
    public void test3(){
        /*
        测试路径问题 (在 maven 项目中)
        之前由于路径问题，一直找不到  druid.properties 配置文件
         */
        System.out.println("Class Loader");
        System.out.println(DruidDemo.class.getClassLoader());
        System.out.println(DruidDemo.class.getClassLoader().getResource(""));
//        System.out.println(DruidDemo.class.getClassLoader().getResource("\\"));
        System.out.println(DruidDemo.class.getClassLoader().getResource("/"));
        //需先在 src/main/resources 目录下添加一个名为 123 的文件进行测试
        System.out.println(DruidDemo.class.getClassLoader().getResource("123"));

        System.out.println("\nThis Class");
        System.out.println(DruidDemo.class);
        System.out.println(DruidDemo.class.getResource(""));
        System.out.println(DruidDemo.class.getResource("/"));
//        System.out.println(DruidDemo.class.getResource("\\"));
        //需先在 src/main/resources 目录下添加一个名为 123 的文件进行测试
        System.out.println(DruidDemo.class.getResource("123"));

        //DruidDemo.class.getClassLoader().getResource("");  等于
        //DruidDemo.class.getResource("/");
    }

注意：DruidDemo.class.getClassLoader().getResource(""); 输出内容等于 DruidDemo.class.getResource("/"); 的输出内容.

输出内容：

Class Loader
jdk.internal.loader.ClassLoaders$AppClassLoader@4629104a
file:/C:/Users/Fan%20Dean/Documents/IdeaProjects/02_mysql/web05_datasource/target/classes/
null
file:/C:/Users/Fan%20Dean/Documents/IdeaProjects/02_mysql/web05_datasource/target/classes/123

This Class
class com.itheima.druid.DruidDemo
file:/C:/Users/Fan%20Dean/Documents/IdeaProjects/02_mysql/web05_datasource/target/classes/com/itheima/druid/
file:/C:/Users/Fan%20Dean/Documents/IdeaProjects/02_mysql/web05_datasource/target/classes/
null

Java 目录总结（七.路径的获取二——ClassLoader 的使用） - - ITeye 博客

IDEA maven 打成 jar 包后使用 ClassLoader 获取不到资源文件 - CSDN 博客

加载其它目录下的文件：

需要在 pom.xml 文件中配置编译时查找所有目录下的配置文件。示例在 pom.xm 文件中加入下面内容：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


 <build>
        <!--将其他目录的配置文件打包-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

Maven 安装最佳实践

设置 MAVEN_OPTS 环境变量：

运行 mvn 命令实际上是执行 Java 命令，那么运行 Java 命令可用的参数也可应用在 mvn 命令上，可以利用MAVEN_OPTS来做到这一点。通常设置MAVEN_OPTS的值为 -Xms128m -xmx512m因为 Java 默认的最大可用内存往往不能满足 Maven 运行的需要，在项目较大时如果没有此配置，很容易得到java.lang.OutOfMemeoryError。

配置用户范围 settings.xml：

全局范围：Maven home: /usr/share/maven /conf/settings.xml文件
用户范围：~/.m2/settings.xml

不要使用 IDE 内嵌的 Maven：

因为内嵌的 Maven 版本较新，会有各种问题。

在 Eclipse 中的更改方法：Windows -- Preferences -- Maven -- Installation， Add -- 输入Maven Home目录，并取消内嵌Maven。

Idea 内嵌的 Maven 见后文。

测试配置

运行下面的命令

mvn help:system

这条命令的目的是让 Maven 执行一个真正的任务，它会下载相关文件（下载 maven-help-plugin），这些文件被下载到了 Maven 本地仓库中。~/.m2文件夹中放置了 Maven 本地仓库，所有的 Maven 构件都被放到该仓库中，以方便重用。可到~/.m2/repository/org/apache/maven/plugins/maven-help-plugins/下找到 maven-help-plugin 的 pom 文件和 jar 文件。

Maven 仓库

Maven Repository: Search/Browse/Explore 可以在上的仓库中寻找你需要的 jar 包。

jar 包之间的依赖问题：

比如：你想要找 c3p0 的 jar 包，在该网站搜索框中输入 c3p0，选择第一个，点击进入 c3p0 页面；在 Central 标签页中的 version 列中有 c3p0 的各种版本，选择一个版本，点击进入，复制 maven 标签页下的文本内容，粘贴到 pom.xml 文件的 dependencies 下，这里需要注意的是：在该网页中，滚动到页面下面会看到 Compile Dependencies (1)，这说明该 jar 包需要依赖另一个 jar 包，在使用时需要同时添加该依赖。

对于 Spring 框架中的包 maven 可以自行解决依赖问题？

比如我只在 pom.xml 文件中添加 spring-jdbc 依赖，但是我查看项目依赖时发现已经包含了其它几个必要依赖。

![maven repository dependencies](./assets/maven repository dependencies.png)

Maven 使用入门

编写 POM

POM（Project Object Model，项目对象模型）定义了项目的基本信息，用于描述项目如何构建，声明项目依赖，等等。

为 Hello World 项目编辑一个最简单的 pom.xml，先创建一个名为 hello-world 的文件夹，再新建 pom.xml 文件：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


<?xml version = "1.0" encoding="UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http:www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
        http://maven.apache.org/maven-v4_0_0.xsd">
        <!-- 指定POM模型的版本，Maven 3 是 4.0.0 -->
        <modelVersion>4.0.0</modelVersion>
        <!-- 指定项目属于哪个组。比如在googlecode上建立了一个myapp项目，那么它就是 com.googlecode.myapp  -->
        <groupId>com.juvenxu.mvnbook</groupId>
        <!-- 当前Maven项目在组中的唯一ID -->
        <artifactId>hello-world</artifactId>
        <!-- SNAPSHOT意为快照，说明该项目还在开发中，不稳定 -->
        <version>1.0-SNAPSHOT</version>
        <!-- 声明一个对用户更为友好的项目名称（可选） -->
        <name>Maven Hello World Project</name>
        <!--  以下依赖在 <编写测试代码> 章节处才添加 -->
        <dependencies>
            <!-- 声明项目的依赖 -->
            <dependency>
                    <groupId>junit</groupId>
                    <artifactId>junit</artifactId>
                    <version>4.10</version>
                    <!-- 依赖仍然包含上面的三个最基本的坐标，有了它们Maven就可以自动从中央仓库下载junit-4.10.jar -->

                    <!-- 指定依赖范围为test，表示该依赖只对测试有效 -->
                    <scope>test</scope>
            </dependency>
    </dependencies>

</project>

groupId、artifactId、version 这三个元素定义了这个项目基本的坐标；在 Maven 的世界，任何 jar、pom、war 都是以基于这些基本的坐标进行区分的。

编写主代码

项目的主代码会被打包到最终的构件中（如 jar)。默认情况，Maven 假设项目主代码位于 src/main/java目录，创建该目录然后在该目录下创建文件 com/juvenxu/mvnbook/helloworld/HelloWorld.java，Java 类的包名是com.juvenxu.mvnbook.helloworld这与之前在 POM 中定义的 groupId 和 artifactId 相符合。一般来说，项目中的 Java 类的包都应该基于项目的 groupId 和 artifactId。

编写一个输出 “Hello World"的程序。

[fan 22:00:49]~/workspace/test/maven/hello-world$ mvn clean compile
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Hello World Project 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ hello-world ---               # clean清除输出目录 target/
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ hello-world ---
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory /home/fan/workspace/test/maven/hello-world/src/main/resources
[INFO]
[INFO] --- maven-compiler-plugin:3.2:compile (default-compile) @ hello-world ---            # 编译项目主代码至target/classes目录
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding UTF-8, i.e. build is platform dependent!
[INFO] Compiling 1 source file to /home/fan/workspace/test/maven/hello-world/target/classes
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1.901 s
[INFO] Finished at: 2017-03-05T22:01:06+08:00
[INFO] Final Memory: 14M/195M
[INFO] ------------------------------------------------------------------------
[fan 22:01:06]~/workspace/test/maven/hello-world$ ls        # 多了个target目录
pom.xml  src/  target/

编写测试代码

为了使项目结构保持清晰，主代码与测试代码应该分别位于独立的目录中。 Maven 项目中默认的测试代码目录是 src/test/java

JUnit 是事实上的单元测试标准。要使用 JUnit，首先需要为 Hello World 项目添加一个 JUnit 依赖；更改项目的 POM：

最终修改的 POM 见"编写 POM"章节的示例。

测试用例编写完毕后，运行 mvn clean test 执行测试。

打包和运行

默认打包类型为 jar。简单的执行命令 mvn clean package 进行打包。

jar 插件将项目主代码打包成一个 jar 文件，该文件位于 target/ 输出目录下；它是根据 artifact-version.jar 规则进行命名的。

如果有需要的话，可以复制这个 jar 文件到其他项目的 Classpath 中从而使用该 jar 包里面的 java 类。

如何让其他的 Maven 项目直接引用这个 jar？

可以执行： mvn clean install 将项目输出的 jar 安装到 Maven 本地仓库中（只有构件被下载到本地仓库后，才能被所有 Maven 项目使用）。

清除未下载成功的文件

当网络出错时，可能会有未下载完成的文件，这些文件中包含 lastUpdated，可以使用下面的脚本清除 maven 未下载完成的文件。

注意：先将 REPOSITORY_PATH设置为你的 maven 的本地仓库的路径。

对应的 bat 脚本文件：

1
2
3
4
5
6
7


set REPOSITORY_PATH="D:\Portable Software\Maven\repository"
rem 正在搜索...
for /f "delims=" %%i in ('dir /b /s "%REPOSITORY_PATH%\*lastUpdated*"') do (
    del /s /q %%i
)
rem 搜索完毕
pause

在 IDEA 中使用 Maven

创建 maven 项目：不使用原型

Create from archetype ：从原型创建

可以不选原型

IntellIJ IDEA 配置 Maven 以及修改默认 Repository - phpdragon - 博客园

Maven 环境配置及 idea 建 Maven 工程 - CSDN 博客

设置 Idea：

Setting > build, Execution，Deployment > Maven 指定 Maven home directory、User setting file 和 Local repository
Setting > build, Execution，Deployment >Remote Jar Repositories 下的 Maven Jar Repositories 下配置 maven 远程仓库。
新建 Maven 项目
跳过选择原型
设置项目的 GroupId：定义了项目属于哪个组，一般来说这个网网和公司或组织关联，比如说，你所在的公司为 mycom，那就应该定义为 com.mycom.mymaven ，其中 mymaven 为项目名称。

设置 ArtifactId：定义了当前 Maven 项目在组中的唯一 id，例如 HelloMaven 这个项目，我则把他定义为 hello-maven

Version 版本：这里使用默认值
Project name：会自动使用上一步中的 ArtifactId 值作为项目名
还可展开"More Setting"查看更多设置

groupId：定义了项目属于哪个组，一般来说这个网网和公司或组织关联，比如说，你所在的公司为 mycom.那就应该定义为 com.mycom.mymaven，mymaven 为项目名称 artifactId：定义了当前 Maven 项目在组中的唯一 id，例如 HelloMaven 这个项目，我则把他定义为 hello-maven。

在 idea 中设置默认 maven

设置默认 Maven home directory ：

每次在 Setting > build, Execution，Deployment > Maven 手动设置了 “Maven home directory” 后下次，创建项目或模块时，又会默认使用 idea 自带的 maven 【Bundled(Maven 3)】。

如何修改 Idea 中默认的 Maven？需要到 idea 的默认设置界面取进行设置：

从这里 File > Other Setting > Default Setting 即可打开默认设置界面，在这里进行配置就好了。

设置默认 Remote Jar Repositories：

Maven jar Repositories 每次新建项目也都会恢复到默认值，使用上面同样的方法更改就行。

当选择了本地 maven 后 localRepository 可以从本地 Maven 的 setting.xml 文件自动检测到，但是 Remote Repositories 为啥检测不到？

Idea 修改默认的 Maven 配置 - CSDN 博客

使用 Maven 创建 web 工程

**新方法：**先新建一个没有使用模板的 maven 项目，创建好后选择该模块右键 > Add Framework Support > Web Application (Versions 选择 4.0，取消勾选 “Create web.xml”) 为其添加 web 框架的支持。然后就可以了。

服务器为 tomcat

手动： IntelliJ IDEA 17 创建 maven 项目-博客-云栖社区-阿里云最开始使用这个方法

IntelliJ IDEA 14 创建 maven 项目二 - Angelaboy - 博客园

另一种方法：使用 Intellij IDEA 和 maven 创建 web 项目 webapp 全过程 - CSDN 博客

使用 IDEA 将普通 MAVEN 项目转为 WEB 项目 - CSDN 博客

手动创建的缺点，不能自动添加相关注解，不能自动添加要覆盖的方法。

直接新建一个 servlet 即可。

Facts: 表示当前项目的适配服务组件

Aftifacts: 这个 Aftifacts 描述了当前项目发布的信息。

好像还可以通过 tomcat 的管理员… 配置 maven，然后 maven 自动部署应用到 tomcat 中

[转]Maven 实现直接部署 Web 项目到 Tomcat7 - dorothychai - 博客园

IDEA——Maven Web 工程：无法创建 Java Class 文件 - CSDN 博客

Idea 新建 Maven 项目时没有 servlet 选项 - CSDN 博客

将 WEB-INF/lib 中的 jar 添加到 Library

在 lib 目录右键选择 add Library

错误： tomcat 找不到类

java.lang.NoClassDefFoundError: org/springframework/jdbc/core/JdbcTemplate

Maven 管理的 jar 没有发布到WEB-INF/lib下的解决方案

Intellij idea 下使用 maven 管理 web 项目，部署运行时发现并没有将 lib 包部署

使用 eclipse j2ee IDE 时,会将 WEB-INF/lib 中所有的 lib 自动加入到 library 中

Maven 管理的 jar 没有发布到 WEB-INF/lib 下的解决方案 - CSDN 博客

解决办法：

另见图：

Tomcat 部署时 war 和 war exploded 区别

war 模式：将 WEB 工程以包的形式上传到服务器；
war exploded 模式：将 WEB 工程以当前文件夹的位置关系上传到服务器；

（1）war 模式这种可以称之为是发布模式，看名字也知道，这是先打成 war 包，再发布；

（2）war exploded 模式是直接把文件夹、jsp 页面、classes 等等移到 Tomcat 部署文件夹里面，进行加载部署。因此这种方式支持热部署，一般在开发的时候也是用这种方式。

（3）在平时开发的时候，使用热部署的话，应该对 Tomcat 进行相应的设置，这样的话修改的 jsp 界面什么的东西才可以及时的显示出来。

Tomcat 部署时 war 和 war exploded 区别以及平时踩得坑 - CSDN 博客

intelliJ Idea 自带热部署和 Jrebel 实现热部署 - CSDN 博客

创建 Maven 项目：使用原型

优先使用本地 archetype-catalog.xml 文件，从而加快创建速度：

解决 IntelliJ IDEA 创建 Maven 项目速度慢问题 DarchetypeCatalog - 记性这么差 - 博客园

在 Default Settings > Build,Execution... > Maven > Runner > VM Options中添加如下选项：-DarchetypeCatalog=internal

创建 Java 项目：

选择maven-archetype-quickstart原型。

idea-maven-java

创建之后会缺少resources目录，需要手动创建该目录，并将其添加为资源的根目录: 右键目录 > Mark Directory as > Resources Root。

idea-maven-add-resources

pom.xml 文件中部分内容：

1
2
3
4
5


  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

可根据需要更改使用到的 JDK 的版本，比如更改为 1.8 .

创建 Web 项目：

选择maven-archetype-webapp原型。如果想要通过添加一个新的模型的形式来创建一个 Maven 项目，在选择原型后的下一步中需要确保： Add as module to 和 Parent 都为 <none>。

创建之后会缺少java和resources目录，需要手动创建，并将它们分别设置为相应目录： 右键目录 > Mark Directory as > Sources Root和 右键目录 > Mark Directory as > Resources Root。但是 idea 可能会并没有在对应的模块的 .iml 文件中正确生成 <sourceRoot>标签，这时如果想直接新建一个 servlet 可能发现并没有 servlet 这个选项，我们可以重启 Idea（不可能）或者手动更改模块 .iml 文件，设置源码根目录，使其能够在 new 右键列表中出现 servlet。

1
2
3
4


        <sourceRoots>
          <root url="file://$MODULE_DIR$/src/main/java" />
          <root url="file://$MODULE_DIR$/src/main/resources" />
        </sourceRoots>

使用原型的好处之一是：无需手动添加 WEB-INF/lib，但是缺点也很明显；那么能否自定义原型？

Idea 中 maven 相关技巧

在 Idea 中可以通过点击 Maven 侧边栏中的 Execute Maven Goal图标来执行 maven 的任意命令。

在 Idea 中搜索依赖：

如果搜索不到任何结果，则需要更新一下仓库索引：

创建骨架（原型）：

使用 Maven Archetype 插件构建 Maven 工程原型模板的实例java脚本之家

1
2
3
4


  <groupId>com.fan.maven.archetypes</groupId>
  <artifactId>fan-webapp-archetype</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>maven-archetype</packaging>

Maven 的 Mybatis 插件

mybatis-generator-maven-plugin 插件：

利用 mybatis-generator 自动生成代码 - 菩提树下的杨过 - 博客园

mybatis-generator-maven-plugin 在 idea 中使用 - 简书

Maven 相关命令

Maven 生命周期（lifecycle）由各个阶段组成，每个阶段由 maven 的插件 plugin来执行完成。生命周期（lifecycle）主要包括 clean、resources、complie、install、package、testResources、testCompile 等，其中带 test 开头的都是用业编译测试代码或运行单元测试用例的。

一些基本的操作，编译，构建，单元测试，安装，网站生成和基于 Maven 部署项目。

使用 Maven 构建项目 “mvn package” 来构建项目
使用 Maven 清理项目 “mvn clean” 来清理项目
使用 Maven 运行单元测试 “mvn test” 来执行单元测试
将项目安装到 Maven 本地资源库 “mvn install” 打包和部署项目到本地资源库
生成基于 Maven 的项目文档站点 “mvn site” 来为您的项目生成信息文档站点
使用"mvn site-deploy"部署站点（WebDAV 例子） “mvn site-deploy” 通过 WebDAV 部署自动生成的文档站点到服务器
部署基于 Maven 的 war 文件到 Tomcat “mvn tomcat:deploy” 以 WAR 文件部署到 Tomcat

这些命令的常见用法在运行各命令前先执行 clean ，比如：

1
2
3


mvn clean package
mvn clean install
mvn clean deploy

这里：

mvn clean package 依次执行了 clean、resources、compile、testResources、testCompile、test、jar(打包)等７个阶段。
mvn clean install 依次执行了 clean、resources、compile、testResources、testCompile、test、jar(打包)、install（部署到本地仓库）等 8 个阶段。
mvn clean deploy 依次执行了 clean、resources、compile、testResources、testCompile、test、jar(打包)、install、deploy 等９个阶段。

每个阶段由 maven 的插件 plugin 来执行完成，比如mvn clean package 中执行的插件的顺序：

1、使用清理插件：maven-clean-plugin:2.5 执行清理删除已有 target 目录（版本 2.5）；

2、使用资源插件：maven-resources-plugin:2.6 执行资源文件的处理（版本 2.6）；

3、使用编译插件：maven-compiler-plugin:3.1 编译所有源文件生成 class 文件至 target\classes 目录下（版本 3.1）；

4、使用资源插件：maven-resources-plugin:2.6 执行测试资源文件的处理（版本 2.6）；

5、使用编译插件：maven-compiler-plugin:3.1 编译测试目录下的所有源代码（版本 3.1）；

6、使用插件：maven-surefire-plugin:2.12 运行测试用例（版本 2.12）；

7、使用插件：maven-jar-plugin:2.4 对编译后生成的文件进行打包，包名称默认为：“artifactId-version”，包文件保存在 target 目录下

Maven 常用命令： - 艺意 - 博客园

Maven 教程™

安装第三方 jar 包

Maven 两种方法解决本地第三方 jar 包引用问题 - CSDN 博客

mvn install:install-file -Dfile=<path-to-file> -DgroupId=<group-id> \
    -DartifactId=<artifact-id> -Dversion=<version> -Dpackaging=<packaging>

示例安装 ojdbc8 到本地仓库：

mvn install:install-file -Dfile="D:\Portable Software\Database\sql-JDBC\ojdbc8-oracle18.3.jar" -DgroupId=com.oracle \
    -DartifactId=ojdbc -Dversion=8 -Dpackaging=jar

如果在 idea 中使用，运行上上面的命令后，可能需要更新一下本地 maven 仓库， Setting > Build.. > Maven > respositories > Update

mvn install:install-file -Dfile="D:\Portable Software\Database\sql-JDBC\ojdbc6-oracle11.2.0.4.jar" -DgroupId=com.oracle \
    -DartifactId=ojdbc -Dversion=6 -Dpackaging=jar

1
2
3
4
5
6
7
8


    <!-- 数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="driverClassName" value="oracle.jdbc.OracleDriver"/>
        <!--<property name="driverClassName" value="com.oracle.jdbc.OracleDriver"/>-->
        <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1522:XE"/>
        <property name="username" value="itheima"/>
        <property name="password" value="fan123"/>
    </bean>

Maven Wrapper

mvnw 全名是 Maven Wrapper,它的原理是在 maven-wrapper.properties 文件中记录你要使用的 Maven 版本，当用户执行 mvnw clean 命令时，发现当前用户的 Maven 版本和期望的版本不一致，那么就下载期望的版本，然后用期望的版本来执行 mvn 命令。

Maven Wrapper 官方项目主页： maven-wrapper: The easiest way to integrate Maven into your project!

为项目添加 mvnw 支持很简单，有两种方式：

方法一，在 pom.Xml 中添加 Plugin 声明：

1
2
3
4
5


<plugin>
<groupId>com.rimerosolutions.maven.plugins</groupId>
<artifactId>wrapper-maven-plugin</artifactId>
<version>0.0.4</version>
</plugin>

这样当我们执行mvn wrapper:wrapper 时，会帮我们生成mvnw.bat, mvnw, maven/maven-wrapper.jar, maven/maven-wrapper.properties这些文件。然后我们就可以使用mvnw代替mvn命令 执行所有的 maven 命令，比如mvnw clean package

方法二，直接执行 Goal（推荐）

mvn -N io.takari:maven:wrapper -Dmaven=3.5.4 表示我们期望使用的 maven 的版本为 3.5.4

产生的内容和第一种方式是一样的，只是目录结构不一样，maven-wrapper.jar 和 maven-wrapper.properties 在 “.mvn/wrapper” 目录下（位于当前项目中）

使用的注意事项：

1、由于我们使用了新的 maven ,如果你的 settings.xml 没有放在当前用户下的.m2 目录下，那么执行 mvnw 时不会去读取你原来的 settings.xml 文件 2、在 mvnw.bat 中有如下的一段脚本 if exist "%M2_HOME%\bin\mvn.cmd" goto init 意思是如果找到 mvn.cmd 就执行初始化操作，但是 maven 早期版本不叫 mvn.cmd,而是叫 mvn.bat,所以会报"Error: M2_HOME is set to an invalid directory"错误，改成你本地的 maven 的匹配后缀就好了。（可能没有）

Maven 是一个常用的构建工具，但是 Maven 的版本和插件的配合并不是那么完美，有时候你不得不切换到一个稍微旧一些的版本，以保证所有东西正常工作。

而 Gradle 提供了一个 Wrapper，可以很好解决版本切换的问题，当然更重要的是不需要预安装 Gradle。

Maven 虽然没有官方的 Wrapper，但是有一个第三方的 Wrapper 可以使用。

安装很简单 mvn -N io.takari:maven:wrapper

使用的时候直接 ./mvnw clean install即可，它会自动下载最新版本来执行。如果需要指定版本则可以使用相关参数：mvn -N io.takari:maven:wrapper -Dmaven=3.3.3 表示我们期望使用的 Maven 的版本为 3.3.3。

如果需要指定版本,重新生成 mvnw 文件在运行即可
mvn -N io.takari:maven:wrapper -Dmaven=3.1.0
./mvnw clean install

Maven Wrapper - 为程序员服务

mvnw 是什么（Maven Wrapper/Maven 保持构建工具版本一直的工具） - EasonJim - 博客园

Maven 插件

maven compiler plugin

各配置说明：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-compiler-plugin</artifactId>
  <version>3.1</version>
  <configuration>
    <source>1.6</source>
    <!-- 源代码使用的开发版本 -->
    <target>1.6</target>
    <!-- 需要生成的目标class文件的编译版本 -->
    <!-- 一般而言，target与source是保持一致的，但是，有时候为了让程序能在其他版本的jdk中运行(对于低版本目标jdk，源代码中需要没有使用低版本jdk中不支持的语法)，会存在target不同于source的情况 -->
    <!-- 指定项目编码为utf-8 -->
    <encoding>UTF-8</encoding>
    <!-- 这下面的是可选项 -->
    <meminitial>128m</meminitial>
    <maxmem>512m</maxmem>
    <fork>true</fork>
    <!-- fork is enable,用于明确表示编译版本配置的可用 -->
    <compilerVersion>1.3</compilerVersion>
    <!-- 这个选项用来传递编译器自身不包含但是却支持的参数选项 -->
    <!-- <compilerArgument>-verbose -bootclasspath ${java.home}\lib\rt.jar</compilerArgument> -->
    <compilerArguments>
      <verbose />
      <!-- 这个选项用来传递编译器自身不包含但是却支持的参数选项 -->
      <!-- <bootclasspath>${java.home}/lib/rt.jar:${java.home}/jre/lib/jce.jar</bootclasspath> -->
    </compilerArguments>
    <!--  传递参数给 javac -->
    <compilerArgs>
      <arg>-verbose</arg>
      <arg>-Xlint:all,-options,-path</arg>
    </compilerArgs>
  </configuration>
</plugin>

这里只是为了介绍各种用法而拼凑的内容

也可以这样配置：

1
2
3
4
5
6


<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!-- 配置 maven compiler 插件-->
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

Docker

另见 Docker Idea 相关文章

Maven 私服

Nexus

在 maven 中的配置

Nexus 的安装和配置见相关文章

Maven

Maven 的介绍和安装配置

Maven 安装

本地仓库配置

设置 HTTP 代理

Maven 镜像网站

Maven 项目结构

Maven 项目中配置文件的读取和写入

Maven 安装最佳实践

测试配置

Maven 仓库

Maven 使用入门

编写 POM

编写主代码

编写测试代码

打包和运行

清除未下载成功的文件

在 IDEA 中使用 Maven

创建 maven 项目：不使用原型

在 idea 中设置默认 maven

相关设置

相关问题

1. 警告 1 - 使用的 jdk 版本问题

使用 Maven 创建 web 工程

将 WEB-INF/lib 中的 jar 添加到 Library

错误： tomcat 找不到类

Tomcat 部署时 war 和 war exploded 区别

创建 Maven 项目：使用原型

Idea 中 maven 相关技巧

Maven 的 Mybatis 插件

Maven 相关命令

安装第三方 jar 包

Maven Wrapper

Maven 插件

maven compiler plugin

Docker

Maven 私服

Nexus

目录

Maven

Maven 的介绍和安装配置

Maven 安装

本地仓库配置

设置 HTTP 代理

Maven 镜像网站

Maven 项目结构

Maven 项目中配置文件的读取和写入

Maven 安装最佳实践

测试配置

Maven 仓库

Maven 使用入门

编写 POM

编写主代码

编写测试代码

打包和运行

清除未下载成功的文件

在 IDEA 中使用 Maven

创建 maven 项目：不使用原型

在 idea 中设置默认 maven

相关设置

相关问题

1. 警告 1 - 使用的 jdk 版本问题

使用 Maven 创建 web 工程

将 WEB-INF/lib 中的 jar 添加到 Library

错误： tomcat 找不到类

Tomcat 部署时 war 和 war exploded 区别

创建 Maven 项目：使用原型

Idea 中 maven 相关技巧

Maven 的 Mybatis 插件

Maven 相关命令

安装第三方 jar 包

Maven Wrapper

Maven 插件

maven compiler plugin

Docker

Maven 私服

Nexus

相关内容

目录