[TOC]

前言

本文可以帮助你加深对Maven的整体认识，不是一篇基础文章。如果你现在还没有用 Maven 跑过 HelloWorld，那么本文可能不适合你。

一、Maven简介

Maven 官网：https://maven.apache.org
Maven 3.3.9版本文档：http://maven.apache.org/ref/3...

Maven是一个项目管理工具，它包含了一个项目对象模型 (Project Object Model)，一组标准集合，一个项目生命周期(Project Lifecycle)，一个依赖管理系统(Dependency Management System)，和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。

版本：maven有自己的版本定义和规则
构建：可以完成编译，打包，部署等。
依赖管理：方便引入所需依赖 Jar 包，不需手动下载
文档生成：maven的site命令支持各种文档信息的发布，包括构建过程的各种输出，javadoc，产品文档等。
项目关系：一个大型的项目通常有几个小项目或者模块组成，用maven可以很方便地管理

二、Maven生命周期

maven把项目的构建划分为不同的生命周期(lifecycle)。粗略一点的话，它这个过程(phase)包括：

验证（validate）:验证项目是否正确
编译（compile）: 编译项目的源代码
测试（test）：使用合适的单元测试框架测试编译的源代码。这些测试不应该要求代码被打包或部署
打包（package）
验证（verify）
安装（install）
部署（deploy）

maven中所有的执行动作(goal)都需要指明自己在这个过程中的执行位置，然后maven执行的时候，就依照过程的发展依次调用这些goal进行各种处理。

这个也是maven的一个基本调度机制。一般来说，位置稍后的过程都会依赖于之前的过程。当然，maven同样提供了配置文件，可以依照用户要求，跳过某些阶段。

三、Maven 版本规范

maven使用如下几个要素来唯一定位某一个输出物： groupId:artifactId:packaging:version 。比如org.springframework:spring:2.5 。每个部分的解释如下：

groupId 公司，团体等。如Apache Software的项目有以org.apache开头的groupId。
artifactId 项目的唯一标识符。比如一个helloworld项目就叫helloworld。
packaging 项目打包输出的类型，默认是jar。类型为war的项目产生一个web应用。
version 一个项目的特定版本。发布的项目有一个固定的版本标识来指向该项目的某一个特定的版本。而正在开发中的项目可以用一个特殊的标识，这种标识给版本加上一个"SNAPSHOT"的标记。
- maven有自己的版本规范，一般是如下定义 <major version>.<minor version>.<incremental version>-<qualifier> ，比如1.2.3-beta-01。要说明的是，maven自己判断版本的算法是major,minor,incremental部分用数字比较，qualifier部分用字符串比较，所以要小心 alpha-2和alpha-15的比较关系，最好用 alpha-02的格式。
- maven在版本管理时候可以使用几个特殊的字符串 SNAPSHOT ,LATEST ,RELEASE 。比如"1.0-SNAPSHOT"。各个部分的含义和处理逻辑如下说明：

四、Maven插件机制

1. Maven默认插件

不配置Plugin时，Maven默认会使用以下插件。如果针对各个 plugin 有特殊配置的话，需要显示指定 plugin 和属性配置。

plugin	function	life cycle phase
maven-clean-plugin	清理上一次执行创建的target文件	clean
maven-resources-plugin	处理资源文件	resources,testResources
maven-compiler-plugin	编译Java代码	compile、testCompile
maven-surefire-plugin	执行单元测试文件	test
maven-jar-plugin	创建 jar	package
maven-install-plugin	拷贝jar到本地的maven仓库 .m2/repository 下面	install
maven-deploy-plugin	发布 jar	deploy
maven-site-plugin	生成文档	site

maven-site-plugin：将工程所有文档生成网站，生成的网站界面默认和apache的项目站点类似，但是其文档用doxia格式写的，目前不支持docbook，需要用其他插件配合才能支持。需要指出的是，在maven 2.x系列中和maven3.x的site命令处理是不同的，在旧版本中，用 mvn site 命令可以生成reporting节点中的所有报表，但是在maven3中，reporting过时了，要把这些内容作为 maven-site-plugin的configuration的内容才行。详细内容可以参考 http://www.wakaleo.com/blog/2...

<build>
    <!-- resources 是 maven-resources-plugin 的-->
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <filtering>true</filtering> <!-- filtering 用来表示资源文件中的占位符是否需要被profiles中的属性动态替换，true为需要替换。 -->
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
            <includes>
                <include>**/*.properties</include>
                <include>*.xml</include>
                <include>*.dic</include>
                <include>*.txt</include>
            </includes>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>false</filtering>
            <includes>
                <include>*.p12</include>
            </includes>
        </resource>
    </resources>



    <plugins>
        <!-- 
            maven-compiler-plugin编译源代码。
            指定maven编译的jdk版本,如果不指定,maven3默认用jdk 1.5 maven2默认用jdk1.3 
            windows默认使用GBK编码，java项目经常编码为utf8，也需要在compiler插件中指出，否则中文乱码可能会出现编译错
        -->
        <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
        
        <!--
            maven-resources-plugin用来处理资源文件，默认的主资源文件目录是src/main/resources。
        -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-resources-plugin</artifactId>
            <version>2.6</version>
            <configuration>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
    </plugins>
</build>

2. Maven常用插件

2.1 Tomcat插件

tomcat插件有两种：tomcat-maven-plugin 和 tomcat7-maven-plugin，使用方式基本相同。

tomcat-maven-plugin 插件是org.codehaus.mojo组织提供的，里面的tomcat是6.0.29版本，没有更新了。
tomcat7-maven-plugin 插件是apache提供的，官网：http://tomcat.apache.org/mave...

tomcat7-maven-plugin 插件使用

<plugin>
    <groupId>org.apache.tomcat.maven</groupId>
    <artifactId>tomcat7-maven-plugin</artifactId>
    <version>2.2</version>
       <configuration>
          <path>/</path>
          <port>8080</port>
          <uriEncoding>UTF-8</uriEncoding>
          <server>tomcat7</server>
       </configuration>
        <executions>
            <execution>
                <phase>package</phase>
                <goals>
                    <goal>run</goal>
                </goals>
            </execution>
        </executions>
</plugin>

命令：

tomcat7:deploy  --部署一个web war包
tomcat7:reload  --重新加载web war包
tomcat7:start    --启动tomcat
tomcat7:stop    --停止tomcat
tomcat7:undeploy --停止一个war包
tomcat7:run --启动嵌入式tomcat ，并运行当前项目

tomcat-maven-plugin 插件使用

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>tomcat-maven-plugin</artifactId>
    <version>1.1</version>
    <configuration>
        <path>/helloworld</path>
        <port>8080</port>
        <uriEncoding>UTF-8</uriEncoding>
        <url>http://localhost:8080/manager/html</url>
        <server>tomcat6</server>
        <systemProperties>
            <JAVA_OPTS>-Xms256m -Xmx512m -XX:MaxPermSize=512m</JAVA_OPTS>
          </systemProperties>
    </configuration>
</plugin>

命令：

tomcat:deploy   --部署一个web war包
tomcat:reload   --重新加载web war包
tomcat:start    --启动tomcat
tomcat:stop    --停止tomcat
tomcat:undeploy --停止一个war包
tomcat:run  --启动嵌入式tomcat ，并运行当前项目

配置参数：
path：是访问应用的路径
port：是tomcat 的端口号
uriEncoding：URL按UTF-8进行编码，这样就解决了中文参数乱码。
Server：指定tomcat名称。

2.2 自动部署插件wagon

自动部署包含三个步骤：编译打包、上传到服务器、在服务器上执行linux命令

2.2.1 文件上传到服务器

Maven项目可使用 mvn install 指令打包，打包完成后包位于target目录下，要想在远程服务器上部署，首先要将包上传到服务器。

首先在本地的setting.xml中配置server的信息，包括id，用户名，密码。（当然也可以在pom.xml里面配置）

<servers>
    <server>
      <id>linux_server</id>
      <username>user</username>
      <password>password</password>
    </server>
</servers>

pom.xml

<build>
    <extensions>
        <extension>
            <groupId>org.apache.maven.wagon</groupId>
            <artifactId>wagon-ssh</artifactId>
            <version>2.8</version>
        </extension>
    </extensions>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>wagon-maven-plugin</artifactId>
            <version>1.0</version>
            <configuration>
                <serverId>linux_server</serverId>
                <fromFile>target/test.war</fromFile>
                <url>scp://user:password@192.168.20.128/home/tomcat7/webapps</url>
            </configuration>
        </plugin>
    </plugins>
</build>

<serverId>linux_server</serverId>：在setting.xml中配置的server的id名字
<fromFile>target/test.war</fromFile>：是要上传到服务器的文件，一般来说是jar或者war包 <url>scp://user:password@192.168.20.128/home/tomcat7/webapps</url>：配置服务器的用户、密码、地址以及文件上传的目录

命令：

# 对项目进行打包和上传操作
mvn clean install wagon:upload-single

如果觉的wagon命令太长，可以设置 excutions 来配置phase和goals来简化命令。

2.2.2 在服务器上执行linux命令

1. 运行jar文件

<build>
    <extensions>
        <extension>
            <groupId>org.apache.maven.wagon</groupId>
            <artifactId>wagon-ssh</artifactId>
            <version>2.8</version>
        </extension>
    </extensions>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>wagon-maven-plugin</artifactId>
            <version>1.0</version>
            
            <configuration>
                <fromFile>target/test.jar</fromFile>
                <url>scp://user:password@192.168.20.128/home/java/exe</url>
                <commands>
                    <command>pkill -f test.jar</command>  <!-- 杀死原来的进程 -->
                    <command>nohup java -jar /home/java/exe/test.jar</command> <!-- 重新启动test.jar-->
                </commands>
                <displayCommandOutputs>true</displayCommandOutputs> <!-- 显示运行命令的输出结果 -->
            </configuration>
        </plugin>
    </plugins>
</build>

命令

<!--install、wagon:upload-single、wagon:sshexec 分别对项目进行打包、上传、运行command命令的操作-->
mvn clean install wagon:upload-single wagon:sshexec

2. 上传war包并启动Tomcat

<build>
   <extensions>
       <extension>
           <groupId>org.apache.maven.wagon</groupId>
           <artifactId>wagon-ssh</artifactId>
           <version>2.8</version>
       </extension>
   </extensions>
   <plugins>
       <plugin>
           <groupId>org.codehaus.mojo</groupId>
           <artifactId>wagon-maven-plugin</artifactId>
           <version>1.0</version>
           
           <configuration>
               <fromFile>target/javawebdeploy.war</fromFile>
               <url>scp://user:password@192.168.20.128/home/tomcat7/webapps</url>
               <commands>
                   <!-- 重启Tomcat -->
                   <command>sh /home/tomcat7/bin/shutdown.sh</command>
                   <command>rm -rf /home/tomcat7/webapps/test</command>
                   <command>sh /home/tomcat7/bin/startup.sh</command>
               </commands>
               <displayCommandOutputs>true</displayCommandOutputs>
           </configuration>
       </plugin>
   </plugins>
</build>

命令

mvn clean install wagon:upload-single wagon:sshexec

2.2.3 配置execution

如果觉得 mvn clean package wagon:upload-single wagon:sshexec 命令太长了不好记，那么可以配置execution，在运行deploy的同时运行upload-single和sshexec。

<build>
    <extensions>
        <extension>
            <groupId>org.apache.maven.wagon</groupId>
            <artifactId>wagon-ssh</artifactId>
            <version>2.8</version>
        </extension>
    </extensions>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>wagon-maven-plugin</artifactId>
            <version>1.0</version>
            <executions>
                <execution>
                    <id>upload-deploy</id>
                    <!-- 运行deploy命令时同时运行upload-single和sshexec -->
                    <phase>deploy</phase>
                    <goals>
                        <goal>upload-single</goal>
                        <goal>sshexec</goal>
                    </goals>
                    
                    <configuration>
                        <fromFile>target/test.war</fromFile>
                        <url>scp://user:password@192.168.20.128/home/tomcat7/webapps</url>
                        <commands>
                            <command>sh /home/tomcat7/bin/shutdown.sh</command>
                            <command>rm -rf /coder/tomcat7/webapps/test</command>
                            <command>sh /coder/tomcat7/bin/startup.sh</command>
                        </commands>
                        <displayCommandOutputs>true</displayCommandOutputs>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

命令

<!-- 即可使用mvn clean package来代替mvn clean package wagon:upload-single wagon:sshexec -->
mvn clean deploy

2.2.4. 完整示例配置

首先在本地的setting.xml中配置server的信息，包括id，用户名，密码。（当然也可以在pom.xml里面配置）

<servers>
    <server>
      <id>linux_server</id>
      <username>user</username>
      <password>password</password>
    </server>
</servers>

pom.xml

<build>
    <extensions>
        <extension>
            <groupId>org.apache.maven.wagon</groupId>
            <artifactId>wagon-ssh</artifactId>
            <version>2.8</version>
        </extension>
    </extensions>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>wagon-maven-plugin</artifactId>
            <version>1.0</version>
            
            <configuration>
                <serverId>linux_server</serverId>
                <url>scp://user:password@192.168.20.128/home/tomcat7/webapps</url>
                <displayCommandOutputs>true</displayCommandOutputs> <!-- 显示运行命令的输出结果 -->
            </configuration>
            
            <executions>
                <!-- 将war包上传到服务器并重启服务器 -->
                <execution>
                    <id>upload-war-to-server</id>
                    <phase>deploy</phase>
                    <goals>
                        <goal>upload-single</goal>
                        <goal>sshexec</goal>
                    </goals>
                    <configuration>
                        <fromFile>target/test.war</fromFile>
                        <commands>
                            <command>datefilename=$(date +%Y%m%d-%H%M%S);cp /home/tomcat7/webapps/test.war /home/tomcat7/webapps/test.war.$datefilename</command>  <!--备份旧的war包-->
                            <command>ps -ef | grep /home/tomcat7/ | grep -v grep | awk {'print $2'} | sed -e "s/^/kill -9 /g" | sh</command> <!-- 关闭tomcat7 -->
                            <command>rm -rf /home/tomcat7/webapps/test</command> <!-- 删除test项目 -->
                            <command>export JAVA_HOME=/home/jdk/jdk1.8.0_91;sh /home/tomcat7/bin/startup.sh</command> <!-- 启动tomcat -->
                        </commands>
                    </configuration>
                </execution>
        </plugin>
    </plugins>
</build>

命令

mvn clean deploy

五、Maven 项目依赖

1. 多模块依赖和继承

项目结构图：

parent
    ├─childA(model层)
    │  └─pom.xml(jar)
    ├─childB(web层)
    │  └─pom.xml(war)
    └─pom.xml(pom)

parent中执行mvn install就能将 childA和childB 一起编译

parent的pom.xml做如下配置：

<groupId>com.song</groupId>
<artifactId>parent</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>    <!-- pom表示它是一个被继承的模块 -->

<modules>
    <module>childA</module>   <!-- 不加module则不会被联合编译 -->
    <module>childB</module>
</modules>

childA和childB的pom.xml都需要配置parent，防止引入的包冲突(如果不加parent，会分别去编译他们引入的依赖，会重复引入包):

<!-- childA 的 pom.xml-->
<parent>
    <artifactId>parent</artifactId>
    <groupId>com.song</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>childA</artifactId>
<packaging>jar</packaging>

<!-- childB 的 pom.xml-->
<parent>
    <artifactId>parent</artifactId>
    <groupId>com.song</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>childB</artifactId>
<packaging>war</packaging>

子pom间存在引用关系，比如childB引用到了childA的jar包

<dependency>
   <groupId>com.module</groupId>
   <artifactId>childA</artifactId>       <!--加上childA的依赖-->
   <version>1.0-SNAPSHOT</version>
</dependency>

2. 子项目继承父项目的依赖

parent中加上<dependencyManagement>，child项目就可以继承parent项目的依赖，并且在child中可以不用加version了。

<dependencyManagement>
   <dependencies>
      <dependency>
           <groupId>javax.servlet</groupId>
          <artifactId>servlet-api</artifactId>
          <version>2.5</version>
      </dependency>
   </dependencies>
</dependencyManagement>

3. 依赖范围

如果不显示执行 <scope> 属性时，默认 <scope>compile</scope>。
scope 属性包括：

compile（编译范围）：编译范围的<dependency>在所有的classpath中可用，同时它们也会被打包
provided（已提供范围）：表示部署的环境当中有某容器已经提供了该jar包，只在编译classpath（不是运行时）可用。它们不是传递性的，也不会被打包。例如，如果你开发了一个web应用，你可能在编译classpath中需要可用的Servlet API来编译一个servlet，但是你不会想要在打包好的WAR中包含这个Servlet API；这个Servlet API JAR由你的servlet容器（Tomcat）提供。
runtime（运行时范围）：只在运行和测试系统的时候需要，但在编译的时候不需要。
test（测试范围）：在一般的编译和运行时都不需要，它们只有在测试编译和测试运行阶段可用。
system （系统范围）：该范围不推荐使用（你应该一直尽量去从公共或定制的Maven仓库中引用依赖）

详细可参考：https://maven.apache.org/guid...

六、Maven profiles切换测试环境和正式环境

<profiles>
    <profile>
        <!-- 本地开发环境 -->
        <id>dev</id>
        <properties>
            <profiles.active>dev</profiles.active>
        </properties>
        <activation>
            <!-- 设置默认激活这个配置 -->
            <activeByDefault>true</activeByDefault>
        </activation>
    </profile>
    <profile>
        <!-- 发布环境 -->
        <id>release</id>
        <properties>
            <profiles.active>release</profiles.active>
        </properties>
    </profile>
    <profile>
        <!-- 测试环境 -->
        <id>beta</id>
        <properties>
            <profiles.active>beta</profiles.active>
        </properties>
    </profile>
</profiles> 



<build>
    <finalName>helloworld</finalName>
    <resources>
        <!-- 先全部不包含 -->
        <resource>
            <directory>src/main/resources</directory>
            <excludes>
                <exclude>config/</exclude>
            </excludes>
        </resource>
        <!-- 再指定需要包含的文件夹 -->
        <resource>
            <directory>src/main/resources/config/${profiles.active}</directory>
            <targetPath>.</targetPath>
        </resource>
    </resources>
</build>

id代表这个环境的唯一标识，在 mvn install -Pdev 来指定。
此properties定义了三个环境，分别是dev（开发环境）、beta（测试环境）、release（发布环境）
activeByDefault=true代表如果不指定某个固定id的profile，那么就使用这个环境

使用 mvn install -Pdev会将 id 为 dev 的 profile 中的<properties>定义的属性profiles.active自动替换${profiles.active}占位符的变量。最终build到classpath的资源文件由maven-resources-plugin来指定，为src/main/resources/config/dev文件下的所有文件。

七、Maven 变量

1. 内置属性

${basedir} represents the directory containing pom.xml
**${version}** equivalent to ${project.version } or ${pom.version }

2. Pom/Project properties

所有pom中的元素都可以用 project. 前缀进行引用,以下是部分常用的

**${project.build.directory}** results in the path to your "target" dir, this is the same as ${pom.project.build.directory}
${project.build.outputDirectory} results in the path to your "target/classes" dir
${project.name} refers to the name of the project.
${project.version} refers to the version of the project.
${project.build.finalName} refers to the final name of the file created when the built project is packaged

3. 本地用户设定

所有用的的 settings.xml 中的设定都可以通过 settings. 前缀进行引用

${settings.localRepository} refers to the path of the user's local repository.
${maven.repo.local} also works for backward compatibility with maven1

4. 环境变量

系统的环境变量通过 env. 前缀引用

${env.M2_HOME} returns the Maven2 installation path.
**${java.home}** specifies the path to the current JRE_HOME environment use with relative paths to get for example: <jvm>${java.home}../bin/java.exe</jvm>

5. java系统属性

所有JVM中定义的java系统属性.

6. pom.xml自定义变量

<project> 
    ... 
    <properties> 
        <project.build.finalName>hellowolrld</project.build.finalName> 
    </properties> 
    ... 
</project>

则引用 ${project.build.finalName} 就会得到值 hellowolrld

7. parent 工程的变量

parent工程的pom.xml中的变量用前缀 ${project.parent} 引用. 上级工程的版本也可以这样引用: ${parent.version }.

参考文章：
https://blog.csdn.net/wwbmyos...
https://blog.csdn.net/j080624...
http://xxgblog.com/2015/10/23...
https://blog.csdn.net/java_an...