Maven小结

参考 https://blog.csdn.net/yaerfeng/article/details/26448417

Maven下载安装

配置Java运行环境

Maven 依赖 Java运行环境，因此使用 Maven 之前需要配置 Java的运行环境。

安装Maven

Maven下载地址：http://maven.apache.org/download.cgi

下载Maven最新版本的二进制zip压缩包就可以，如:apache-maven-3.5.3-bin.zip
下载完成后，解压，例如我们把解压后的文件夹放在D:\Dev\Tool\目录下。
然后，将Maven的bin目录添加到path环境变量中，我们这里就是这个目录：D:\Dev\Tool\apache-maven-3.5.3\bin

在Windows命令提示符下，输入mvn -v测试一下

Apache Maven 3.5.0 (ff8f5e7444045639af65f6095c62210b5713f426; 2017-04-04T03:39:0
6+08:00)
Maven home: D:\Program Files\apache-maven-3.5.0\bin\..
Java version: 1.8.0_131, vendor: Oracle Corporation
Java home: C:\Program Files\Java\jre1.8.0_131
Default locale: zh_CN, platform encoding: GBK
OS name: "windows 7", version: "6.1", arch: "amd64", family: "windows"

这样，maven就安装完成了。

测试创建Maven项目

D:\>mvn archetype:generate -DgroupId=com.os -DartifactId=demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Maven依赖管理

Maven要求每一个jar包都必须明确定义自己的坐标，Maven就是通过这个坐标来查找管理这些jar包的。

在Maven中，一个jar包的坐标是由它的groupId、artifactId、version这些元素来定义的。例如：

<project>
    ...
    <dependencies>
       <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.0.3.RELEASE</version>
        </dependency>
    </dependencies>
    ...
</project>

Maven的配置文件中dependencies元素包含了所有依赖的jar包，每一个jar包依赖使用dependency元素定义。

在声明一个jar包依赖时，除了指定groupId、artifactId、version这三项基本坐标外，还可以使用使用以下元素进行配置：

scope元素：指定依赖的范围

Maven有以下6种依赖范围：

compile     编译依赖范围(默认值），依赖在编译、测试、运行期间都有效。
test        测试依赖范围，只对测试的classpath有效，在编译或运行时无法使用指定为test的依赖包。
provided    已提供的依赖范围，只对编译和测试的classpath有效，运行期间不会使用这个依赖。例如servlet-api，在运行时容器已经提供，不需要再重复引入。 
runtime     运行时依赖范围，编译时无效，只在测试和运行时使用这个依赖。
system      系统依赖范围，和provided范围一致，但是provided是使用容器提供依赖，system是使用系统提供依赖，需要指定依赖文件路径。
import      它只使用在<dependencyManagement>中，表示从其它的pom中导入dependency的配置。比如说B项目引用A项目的jar，使用import后B项目将导入A项目中的包配置

exclusions元素：排除传递性依赖

传递性依赖，是指依赖包对其他包的依赖，比如，我们依赖spring-boot-starter，而spring-boot-starter需要依赖spring-boot-starter-logging等，Maven会将这些传递性依赖同时引入项目之中。这也是Maven的一大优点，简化了我们对jar包依赖的管理。而有时我们希望替换某个传递性依赖时，就需要使用exclusions排除掉这个传递性依赖，然后再添加我们自己要替换的依赖包。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
        <!-- 排除默认日志框架 -->
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

Maven仓库

Maven 通过项目定义的坐标来管理这些依赖，而这些依赖的物理文件是通过 Maven的仓库来统一管理的。

对于一个依赖坐标，它会按照如下方式反映到Maven的仓库中。

1. 将 groupId 转化为路径：将 groupId 中的包名分隔符(.)转换成路径分隔符(/)。例如： org.springframework.boot -> org/springframework/boot
2. 将 artifactId 转化为路径：在 groupId 转化的路径基础上连接 artifactId。生成路径为： org/springframework/boot/spring-boot-starter
3. 将 verion 转化为路径：在 artifactId 转化的路径基础上连接 version。生成路径为： org/springframework/boot/spring-boot-starter/2.0.1.RELEASE
4. 根据 artifactId 和 version 生成依赖包文件名：上例就是 spring-boot-starter-2.0.1.RELEASE
5. 根据依赖的打包方式确定文件的扩展名。对于上例它的扩展名就是.jar

Maven的仓库分为本地仓库和远程仓库。

本地仓库：是Maven在我们本机设置的仓库目录，默认目录为当前用户目录下的.m2/repository。

远程仓库包括中央仓库、私服、其他公共仓库。
中央仓库是Maven提供的远程仓库，地址是：http://repo.maven.apache.org/maven2
私服是我们为了节省带宽和时间，提升效率，在局域网架设的私有Maven仓库。
其他公共库有Java.net的maven库(http://download.java.net/maven/2/)和JBoss Maven库(http://repository.jboss.com/)等。

Maven在根据依赖坐标查找依赖时，首先会从本地仓库查找该依赖包，当本地仓库中没有这个依赖包时，Maven会从中央仓库查找依赖，并下载到本地仓库。最后，在我们项目的classpath中引用本地仓库的依赖包路径。

聚合与继承

聚合：Maven聚合（或者称为多模块），通过Maven配置文件可以把多个模块聚合在一起进行编译发布，并且它的聚合非常简单只需要使用元素添加模块就可以完成聚合。其中module的路径为相对路径，如下

<modules>
    <module>模块一</module>
    <module>模块二</module>
    <module>模块三</module>
</modules>

继承：
项目的个各模块间通常是存在引用关系，并且每个模块会引用一些相同的依赖，Maven也提供了继承的机制来管理这些共同的依赖。你可以编写一个pom.xml文件作为父级pom配置，各个模块在自己的pom.xml中继承父级pom文件，就像上面的示例那样，使用元素标识继承的父级pom文件。

父级pom文件的编写：

1、父级pom文件的packaging必须是pom，它需要作为pom文件发布以便子pom继承
2、在父级pom可以使用<dependencyManagement>配置依赖管理。在<dependencyManagement>下的依赖声明不会引入实际依赖，但是可以让子模块继承依赖配置。例如，在子模块中我们只标识依赖的groupId和artifactId，它就可以根据父类的依赖管理获取这个依赖的version及exclussions等配置。
3、在父级pom中可以使用<pluginManagement>配置插件管理。作用和<dependencyManagement>类似，只不过一个管理依赖一个管理插件。

子模块pom文件的编写：

1、需要使用<parent>元素标识继承的父pom
2、可以使用<relativePath>标识父级pom的物理路径，子模块会直接从指定的路径加载父级pom文件，未指定该元素时，子模块将根据父级pom的坐标从Maven仓库查找
3、子模块pom可以继承父级pom中除artifactId之外的大部分配置，因此子模块的groupId、version以及依赖的version都可以省略。

生命周期

一个典型的 Maven 构建生命周期是由以下几个通用phase组成的：

validate: 检查工程配置是否正确，完成构建过程的所有必要信息是否能够获取到
compile: 编译工程源码
test: 测试编译后的代码，即执行单元测试代码
package: 获取编译后的代码，并按照可发布的格式在target目录下生成package文件，例如 JAR、WAR 或者 EAR 文件
integration-test: 处理和部署必须的工程包到集成测试能够运行的环境中
verify: 运行检查操作来验证工程包是有效的，并满足质量要求
install: 安装package到本地仓库，方便本地其它项目使用
deploy: 部署，拷贝最终的package到远程仓库和替他开发这或项目共享，在集成或发布环境完成

除了上面的默认列表之外，还有另外两个Maven生命周期。他们是

clean: 清理由先前构建创建的文件
site: 生成项目相关信息的网站

以上的phase是有序的（注意实际两个相邻phase之间还有其他phase被省略，完整phase见lifecycle），下面一个phase的执行必须在上一个phase完成后

若直接以某一个phase为goal，将先执行完它之前的phase，如mvn install，将会先validate、compile、test、package、integration-test、verify最后再执行install phase

maven 常用命令

mvn archetype:generate 创建maven项目
mvn package 打包，上面已经介绍过了
mvn package -Prelease打包，并生成部署用的包，比如deploy/*.tgz
mvn install 打包并安装到本地库
mvn eclipse:eclipse 生成eclipse项目文件
mvn eclipse:clean 清除eclipse项目文件
mvn site 生成项目相关信息的网站

Clean Lifecycle

生命周期阶段	描述
pre-clean	在实际项目清理之前执行所需的流程
clean	删除上一次构建产生的所有文件
post-clean	执行完成项目清理所需的过程

Default Lifecycle

生命周期阶段	描述
validate	检查工程配置是否正确，完成构建过程的所有必要信息是否能够获取到。
initialize	初始化构建状态，例如设置属性。
generate-sources	生成编译阶段需要包含的任何源码文件。
process-sources	处理源代码，例如，过滤任何值（filter any value）。
generate-resources	生成工程包中需要包含的资源文件。
process-resources	拷贝和处理资源文件到目的目录中，为打包阶段做准备。
compile	编译工程源码。
process-classes	处理编译生成的文件，例如 Java Class 字节码的加强和优化。
generate-test-sources	生成编译阶段需要包含的任何测试源代码。
process-test-sources	处理测试源代码，例如，过滤任何值（filter any values)。
generate-test-resources	为测试创建资源。
process-test-resources	将资源复制并处理到测试目的地目录中。
test-compile	编译测试源代码到测试目的目录。
process-test-classes	处理测试代码文件编译后生成的文件。
test	使用适当的单元测试框架（例如JUnit）运行测试。
prepare-package	在真正打包之前，为准备打包执行任何必要的操作。
package	获取编译后的代码，并按照可发布的格式进行打包，例如 JAR、WAR 或者 EAR 文件。
pre-integration-test	在集成测试执行之前，执行所需的操作。例如，设置所需的环境变量。
integration-test	处理和部署必须的工程包到集成测试能够运行的环境中。
post-integration-test	在集成测试被执行后执行必要的操作。例如，清理环境。
verify	运行检查操作来验证工程包是有效的，并满足质量要求。
install	安装工程包到本地仓库中，该仓库可以作为本地其他工程的依赖。
deploy	拷贝最终的工程包到远程仓库中，以共享给其他开发人员和工程。

Site Lifecycle

生命周期阶段	描述
pre-site	在实际的项目站点生成之前执行所需的过程。
site	生成项目的站点文档。
post-site	执行完成站点生成所需的过程，并为站点部署做好准备。
site-deploy	将生成的站点文档部署到指定的web服务器。

配置

资源文件的配置

<!--配置一、pom文件配置-->
<!--<properties>-->
<!--    <my.filter.value>filter1</my.filter.value>-->
<!--</properties>-->

<build>
<!--配置二、外部文件-->
    <filters>
        <filter>src/main/filters/filter.properties</filter>
    </filters>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

application.properties

message = ${my.filter.value}

filter.properties

my.filter.value = filter2

profile

profile可以让我们定义一系列的配置信息，然后指定其激活条件。这样我们就可以定义多个profile，然后每个profile对应不同的激活条件和配置信息，从而达到不同环境使用不同配置信息的效果。

profile定义的位置

1、针对于特定项目的profile配置我们可以定义在该项目的pom.xml中。（下面举例是这种方式）
2、针对于特定用户的profile配置，我们可以在用户的settings.xml文件中定义profile。该文件在用户家目录下的“.m2”目录下。
3、全局的profile配置。全局的profile是定义在Maven安装目录下的“conf/settings.xml”文件中的。

配置profile

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

在src/main/filters/创建三个文件，filter-dev.properties、filter-release.properties、filter-beta.properties,然后再pom加载环境文件

<build>
    <finalName>admin</finalName>
    <!-- 定义了变量配置文件的地址 -->
    <filters>
        <filter>src/main/filters/filter-${env}.properties</filter>
    </filters>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

通过判断文件是否存在激活

<profiles>
  <profile>
    <activation>
      <file>
        <missing>/path/to/missing/file</missing>
        <exists>/path/to/exists/file</exists>
      </file>
    </activation>
    ...
  </profile>
</profiles>

optional

<dependency>  
    <groupId>sample.ProjectB</groupId>  
    <artifactId>Project-B</artifactId>  
    <version>1.0</version>  
    <scope>compile</scope>  
    <optional>true</optional> <!-- value will be true or false only -->  
</dependency>  

假如你的Project A的某个依赖B添加了<optional>true</optional>，当别人通过pom依赖Project A的时候，B不会被传递依赖进来，即Project-A --> Project-B。在编译项目A时，是可以正常通过的。

如果有一个新的项目X依赖A，即：Project-X -> Project-A。此时项目X就不会依赖项目B了。如果项目X用到了涉及项目B的功能，那么就需要在pom.xml中重新配置对项目B的依赖。

当你依赖某各工程很庞大或很可能与其他工程的jar包冲突的时候建议加上该选项，可以节省开销，同时减少依赖冲突。

finalName 文件名（用于指定jar、war等文件的名字）

常用插件

插件列表 http://maven.apache.org/plugins/index.html

<!--配置详见-->
<!--http://maven.apache.org/plugins/maven-compiler-plugin/compile-mojo.html-->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.7.0</version>
    <configuration>
        <!--编码设置，默认使用${project.build.sourceEncoding}-->
        <encoding>UTF-8</encoding>
        <!--是否debug，默认true-->
        <debug>true</debug>
        <!--指定源码jdk版本，默认值${maven.compiler.source}-->
        <source>1.8</source>
        <!--指定生成编译后的jdk版本，默认值${maven.compiler.target}-->
        <target>1.8</target>
        <!--存在错误将编译失败，默认true-->
        <failOnError>true</failOnError>
        <!--存在警告将编译失败，默认false-->
        <failOnWarning>false</failOnWarning>
        <!--编译占用最大内存，设置即生效-->
        <maxmem>128m</maxmem>
        <!--初始内存大小，设置即生效-->
        <meminitial>128m</meminitial>
        <!--是否传递依赖，默认false-->
        <optimize>false</optimize>
        <!--显示描述，默认false-->
        <showDeprecation>false</showDeprecation>
        <!--显示警告，默认false-->
        <showWarnings>false</showWarnings>
        <!--是否打印编译器在做的消息，默认false-->
        <verbose>false</verbose>
    </configuration>
</plugin>

<!--配置详见-->
<!--http://maven.apache.org/plugins/maven-resources-plugin/resources-mojo.html-->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-resources-plugin</artifactId>
    <version>3.1.0</version>
    <configuration>
        <!--配置文件过滤-->
        <filters>
            <filter>src/main/filters/dev.properties</filter>
        </filters>
        <!--引入资源文件（也可放build标签下），用于给资源文件中的${}变量赋值,并将资源文件打入jar或war-->
        <resources>
            <resource>
                <!--资源文件夹，默认src/main/resources-->
                <directory>src/main/resources</directory>
                <!--是否开启变量替换-->
                <filtering>true</filtering>
                <!--引入的资源文件-->
                <includes>
                    <include>*.properties</include>
                    <include>*.txt</include>
                </includes>
                <!--剔除的资源文件-->
                <excludes>
                    <exclude>**/*.bmp</exclude>
                    <exclude>**/*.jpg</exclude>
                    <exclude>**/*.jpeg</exclude>
                    <exclude>**/*.gif</exclude>
                </excludes>
                <!--生成路径-->
                <targetPath>${project.build.directory}/conf</targetPath>
            </resource>
        </resources>
        <!--设置编码，默认值${project.build.sourceEncoding}-->
        <encoding>UTF-8</encoding>
        <!--复制资源文件到配置目录下，如：d://outDorectory，默认${project.build.outputDirectory}-->
        <outputDirectory>${project.build.outputDirectory}</outputDirectory>
        <!--隐藏等文件.gitignore, .cvsignore，默认true-->
        <addDefaultExcludes>true</addDefaultExcludes>
        <!--变量分隔符设置，默认配置如下-->
        <delimiters>
            <!--类似${my.filter.value}-->
            <delimiter>${*}</delimiter>
            <!--类似@my.filter.value@-->
            <delimiter>#</delimiter>
        </delimiters>
        <!--支付window路径反斜杠，默认true-->
        <escapeWindowsPaths>true</escapeWindowsPaths>
        <!--是否复制空文件夹，默认false-->
        <includeEmptyDirs>false</includeEmptyDirs>
        <!--不使用过滤的文件集合-->
        <nonFilteredFileExtensions>
            <nonFilteredFileExtension>exe</nonFilteredFileExtension>
            <nonFilteredFileExtension>zip</nonFilteredFileExtension>
            <nonFilteredFileExtension>vbs</nonFilteredFileExtension>
            <nonFilteredFileExtension>sh</nonFilteredFileExtension>
        </nonFilteredFileExtensions>
        <!--是否实时覆盖生成文件，默认false-->
        <overwrite>true</overwrite>
        <!--build/filters配置是否生效，默认true-->
        <useBuildFilters>true</useBuildFilters>
        <!--使用自定义分隔符后是否继续使用默认分隔符，默认true-->
        <useDefaultDelimiters>false</useDefaultDelimiters>
    </configuration>
</plugin>

<!--配置详见-->
<!--http://maven.apache.org/plugins/maven-war-plugin/war-mojo.html-->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>3.2.1</version>
    <configuration>
        <!--生成war文件路径，默认${project.build.directory}-->
        <outputDirectory>${project.build.directory}</outputDirectory>
        <!--war源文件路径，默认${basedir}/src/main/webapp-->
        <warSourceDirectory>${basedir}/src/main/webapp</warSourceDirectory>
        <!--资源编码,默认${project.build.sourceEncoding}-->
        <resourceEncoding>utf-8</resourceEncoding>
        <webResources>
            <resource>
                <!-- 将资源文件打进war包，相对于pom.xml的文件夹路径 -->
                <directory>src/main/resources</directory>
                <!--引入资源文件-->
                <includes>
                    <include>**.img</include>
                </includes>
                <!--剔除资源文件文件夹-->
                <excludes>
                    <exclude>**/image2</exclude>
                </excludes>
            </resource>
        </webResources>
        <!--排除指定文件-->
        <packagingExcludes>WEB-INF/lib/*.jar1</packagingExcludes>
        <!--缺少web.xml文件是否保存，默认true-->
        <failOnMissingWebXml>false</failOnMissingWebXml>
        <!--配置web.xml位置-->
        <webXml>src/web.xml</webXml>
    </configuration>
</plugin>

<!--测试运行，验证单元测试-->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
     <version>2.21.0</version>
    <configuration>
        <!--跳过测试-->
        <skipTests>true</skipTests>
    </configuration>
</plugin>

<!--将所有jar源代码打成一个jar-->
<!--配置详见-->
<!--http://maven.apache.org/plugins/maven-shade-plugin/shade-mojo.html-->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.1.1</version>
    <configuration>
        <!-- put your configurations here -->
    </configuration>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
        </execution>
    </executions>
</plugin>

<!--将项目源码打成jar-->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-source-plugin</artifactId>
    <version>3.0.1</version>
    <executions>
        <execution>
            <!-- 定义一个阶段，这个阶段是package -->
            <phase>package</phase>
            <goals>
                <goal>jar-no-fork</goal>
            </goals>
        </execution>
    </executions>
</plugin>

<!--定制化打包方式-->
<!--详细配置 https://maven.apache.org/plugins/maven-assembly-plugin/single-mojo.html-->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.6</version>
    <executions>
        <execution>
            <id>make-jar</id>
            <!-- 绑定到package生命周期阶段上 -->
            <phase>package</phase>
            <goals>
                <!--只运行一次-->
                <goal>single</goal>
            </goals>
            <configuration>
                <!--是否跳过Assembly,默认false-->
                <skipAssembly>false</skipAssembly>
                <!--是否在生成的文件名上追加id属性-->
                <appendAssemblyId>true</appendAssemblyId>
                <!--生成输出文件夹-->
                <outputDirectory>${project.build.directory}/${project.build.finalName}/WEB-INF/lib</outputDirectory>
                <descriptors>
                    <!--描述文件路径-->
                    <descriptor>src/assembly/assembly.xml</descriptor>
                </descriptors>
            </configuration>
        </execution>
    </executions>
</plugin>

<assembly>
    <!--详细配置 https://maven.apache.org/plugins/maven-assembly-plugin/single-mojo.html-->
    
    <!--id 标识符，添加到生成文件名称的后缀符。如果指定 id 的话，目标文件则是 ${artifactId}-${id}.tar.gz-->
    <id>release</id>
    <!--支持的打包格式如下，可以同时指定多个打包格式-->
    <!--"zip" - Creates a ZIP file format-->
    <!--"tar" - Creates a TAR format-->
    <!--"tar.gz" or "tgz" - Creates a gzip'd TAR format-->
    <!--"tar.bz2" or "tbz2" - Creates a bzip'd TAR format-->
    <!--"tar.snappy" - Creates a snappy'd TAR format-->
    <!--"tar.xz" or "txz" - Creates a xz'd TAR format-->
    <!--"jar" - Creates a JAR format-->
    <!--"dir" - Creates an exploded directory format-->
    <!--"war" - Creates a WAR format-->
    <formats>
        <format>jar</format>
        <format>zip</format>
    </formats>
    <!--是否引入父文件夹，默认true-->
    <includeBaseDirectory>false</includeBaseDirectory>
    <!--引入文件-->
    <fileSets>
        <!--引入项目代码生成的classes-->
        <fileSet>
            <!--源文件件-->
            <directory>${project.build.directory}/classes</directory>
            <!--目标文件夹-->
            <outputDirectory>classes</outputDirectory>
            <includes>
                <include>com/**</include>
            </includes>
            <excludes>
                <exclude>*.txt</exclude>
            </excludes>
        </fileSet>
        <!--引入配置文件-->
        <fileSet>
            <directory>bin</directory>
            <outputDirectory>/conf</outputDirectory>
            <includes>
                <include>*.xml</include>
            </includes>
            <excludes>
                <exclude>*.txt</exclude>
            </excludes>
        </fileSet>
    </fileSets>

    <!--引入依赖的jar-->
    <dependencySets>
        <dependencySet>
            <outputDirectory>/lib</outputDirectory>
            <excludes>
                <exclude>*.txt</exclude>
            </excludes>
        </dependencySet>
    </dependencySets>
</assembly>

<plugin>
    <groupId>org.apache.tomcat.maven</groupId>
    <artifactId>tomcat7-maven-plugin</artifactId>
    <version>2.2</version>
    <configuration>
        <!--访问应用的路径-->
        <path>/</path>
        <!--端口号-->
        <port>80</port>
        <uriEncoding>UTF-8</uriEncoding>
        <!-- Tomcat Manager 的URL,用于部署和取消部署的web应用程序,默认使用manager实例  -->
        <url>http://127.0.0.1/manager</url>
        <!--指定tomcat名称-->
        <server>tomcat7</server>
        <!--实现热部署 -->
        <contextReloadable>true</contextReloadable>
        <!--war资源文件夹-->
        <warSourceDirectory>src/main/webapp</warSourceDirectory>
    </configuration>
</plugin>

<!-- 本插件用于指定本项目生成的jar包中的MANIFEST.MF文件中的配置，如Class-Path和Main-Class -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
        <archive>
            <manifest>
                <!-- 指定添加项目中使用的外部jar的classpath项 -->
                <addClasspath>true</addClasspath>
                <!--指定外部jar所在的路径，添加的classpath为 [路径]/jar文件名 -->
                <!-- Maven自动解析文件名，使用本项目生成的jar包时，当前目录下有lib文件夹，lib文件夹中有本项目使用的外部jar文件即可 -->
                <classpathPrefix>lib/</classpathPrefix>
                <!-- 指定本项目jar包的Main-Class -->
                <mainClass>com.pipi.cloud.order.OrderApplication</mainClass>
            </manifest>
        </archive>
    </configuration>
</plugin>

<plugin>
    <!-- 这个插件就是把依赖的jar包复制出来放到编译后的target/lib目录，并且在打包时候排除内部依赖 -->
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
        <execution>
            <id>copy-dependencies</id>
            <phase>prepare-package</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <outputDirectory>${project.build.directory}/lib</outputDirectory>
                <overWriteReleases>false</overWriteReleases>
                <overWriteSnapshots>false</overWriteSnapshots>
                <overWriteIfNewer>true</overWriteIfNewer>
            </configuration>
        </execution>
    </executions>
</plugin>

Maven内置隐式变量

Maven提供了三个隐式的变量可以用来访问环境变量，POM信息，和Maven Settings

env

env变量，暴露了你操作系统或者shell的环境变量。便 如在Maven POM中一个对$env.PATH的引用将会被${PATH}环境变量替换，在Windows中为%PATH%.

projetc

详见：http://maven.apache.org/ref/3.2.2/maven-model-builder/

project变量暴露了POM。可以使用点标记(.)的路径来引用POM元素的值。例如

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.sonatype.mavenbook</groupId>
    <artifactId>project-a</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <build>
        <finalName>${project.groupId}-${project.artifactId}</finalName>
    </build>
</project>

当你使用mvn help:effective-pom 查看时,你会看到<finalName>org.sonatype.mavenbook-project-a</finalName>

${basedir} 项目根目录
${project.build.directory} 构建目录，缺省为target
${project.build.outputDirectory} 构建过程输出目录，缺省为target/classes
${project.build.finalName} 产出物名称，缺省为${project.artifactId}-${project.version}
${project.packaging} 打包类型，缺省为jar
${project.xxx} 当前pom文件的任意节点的内容

settings

settings变量暴露了Maven settings信息。可以使用点标记(.)的路径来引用settings.xml文件中元素的值。例如${settings.offline}会引用~/.m2/settings.xml文件中offline元素的值。

添加jar到本地仓库

 D:\>mvn install:install-file -Dfile=包地址 -DgroupId=包groupId -DartifactId=包artifactId -Dversion=包版本 -Dpackaging=jar

maven下载包慢解决

现在maven项目非常流行，因为它对jar实行了一个非常方便的管理，我们可以通过在pom.xml文件中做对应的配置即可将所需要的jar包与自己的项目形成依赖。

但是通常我们会因为下载jar包速度缓慢而苦恼，这十分影响开发效率，以及程序员的心情，在IDE下载jar时，无法对IDE做任何动作，只能大眼对小眼。

下载jar速度慢究其原因就是因为很多资源都是国外的，我们下载一个小文件几乎就跨越了一个太平洋那么远，那么有什么方法可以让下载速度变快呢？

其实方法很简单：maven是支持镜像的，我们可以在maven的conf文件加下的setting.xml文件中找到标签

<mirrors>  
    <!-- mirror  
     | Specifies a repository mirror site to use instead of a given repository. The repository that  
     | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used  
     | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.  
     |  
    <mirror>  
      <id>mirrorId</id>  
      <mirrorOf>repositoryId</mirrorOf>  
      <name>Human Readable Name for this Mirror.</name>  
      <url>http://my.repository.com/repo/path</url>  
    </mirror>  
     -->  
      
  </mirrors>  

在这个标签中加入国内的镜像即可，在这里推荐阿里云的镜像，下载速度有明显的加快

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

如果.m2目录下没有setting.xml，可以在maven安装目录下的conf下复制一份。

如果搭建了nexus的话，可以指向自己的maven私服

<mirror>
    <id>my</id>
    <name>My Central</name>
    <url>http://私服IP/nexus/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>
</mirror>

实例

<mirror> 
    <id>nexus-aliyun</id>
    <mirrorOf>*</mirrorOf> 
    <name>Nexus aliyun</name> 
    <url>http://maven.aliyun.com/nexus/content/groups/public</url> 
</mirror>

<mirror> 
    <id>mynexus</id>
    <mirrorOf>*</mirrorOf> 
    <name>mynexus</name> 
    <url>http://47.93.89.159:8081/nexus/content/groups/public</url> 
</mirror>

POM解析

<!-- 声明项目描述符遵循哪一个POM模型版本。
模型本身的版本很少改变，虽然如此，但它仍然是必不可少的，这是为了当Maven引入了新的特性或者其他模型变更的时候，确保稳定性。 --> 
<modelVersion> 4.0.0 </modelVersion> 
<!-- 项目的唯一标识符，通常使用全限定的包名区分该项目和其他项目。并且构建时生成的路径也是由此生成， 如com.mycompany.app生成的相对路径为：/com/mycompany/app --> 
<groupId> xxx </groupId> 
<!-- 构件的标识符，它和group ID一起唯一标识一个构件。
换句话说，你不能有两个不同的项目拥有同样的artifact ID和groupID；在某个特定的group ID下，artifact ID也必须是唯一的。构件是项目产生的或使用的一个东西，Maven为项目产生的构件包括：JARs，源码，二进制发布和WARs等。 --> 
<artifactId> xxx </artifactId> 
<!-- 项目产生的构件类型，例如jar、war、ear、pom。插件可以创建他们自己的构件类型，所以前面列的不是全部构件类型 --> 
<packaging> jar </packaging> 
<!-- 项目当前版本，格式为:主版本.次版本.增量版本-限定版本号 --> 
<version> 1.0-SNAPSHOT </version> 
<!-- 项目的名称, Maven产生的文档用 --> 
<name> xxx </name> 
<!-- 项目主页的URL, Maven产生的文档用 --> 
<url> http://www.baidu.com/ </url> 
<!-- 项目的详细描述, Maven 产生的文档用。 --> 
<description> A maven project to study maven. </description> 

<!-- 描述了这个项目构建环境中的前提条件。 --> 
<prerequisites> 
    <!-- 构建该项目或使用该插件所需要的Maven的最低版本 --> 
    <maven /> 
</prerequisites> 

<!-- 父项目的坐标。如果项目中没有规定某个元素的值，那么父项目中的对应值即为项目的默认值。 坐标包括group ID，artifact ID和 version。 --> 
<parent> 
    <!-- 被继承的父项目的构件标识符 --> 
    <artifactId /> 
    <!-- 被继承的父项目的唯一标识符 --> 
    <groupId /> 
    <!-- 被继承的父项目的版本 --> 
    <version /> 
    <!-- 父项目的pom.xml文件的相对路径。
    相对路径允许你选择一个不同的路径。默认值是../pom.xml。
    Maven首先在构建当前项目的地方寻找父项目的pom，其次在文件系统的这个位置（relativePath位置），然后在本地仓库，最后在远程仓库寻找父项目的pom。 --> 
    <relativePath /> 
</parent>

<!-- 模块（有时称作子项目） 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径 --> 
<modules /> 

<!-- 构建项目需要的信息 --> 
<build> 

    <!-- 该元素设置了项目源码目录，当构建项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。 --> 
    <sourceDirectory /> 
    <!-- 该元素设置了项目脚本源码目录，该目录和源码目录不同：绝大多数情况下，该目录下的内容 会被拷贝到输出目录(因为脚本是被解释的，而不是被编译的)。 --> 
    <scriptSourceDirectory /> 
    <!-- 该元素设置了项目单元测试使用的源码目录，当测试项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。 --> 
    <testSourceDirectory /> 
    <!-- 被编译过的应用程序class文件存放的目录。 --> 
    <outputDirectory /> 
    <!-- 被编译过的测试class文件存放的目录。 --> 
    <testOutputDirectory /> 
    
    <!-- 使用来自该项目的一系列构建扩展 --> 
    <extensions> 
        <!-- 描述使用到的构建扩展。 --> 
        <extension> 
            <!-- 构建扩展的groupId --> 
            <groupId /> 
            <!-- 构建扩展的artifactId --> 
            <artifactId /> 
            <!-- 构建扩展的版本 --> 
            <version /> 
        </extension> 
    </extensions> 
    <!-- 当项目没有规定目标（Maven2 叫做阶段）时的默认值 --> 
    <defaultGoal /> 

    <!-- 这个元素描述了项目相关的所有资源路径列表，例如和项目相关的属性文件，这些资源被包含在最终的打包文件里。 --> 
    <resources> 
        <!-- 这个元素描述了项目相关或测试相关的所有资源路径 --> 
        <resource> 
            <!-- 描述了资源的目标路径。该路径相对target/classes目录（例如${project.build.outputDirectory}）。举个例子，如果你想资源在特定的包里(org.apache.maven.messages)，你就必须该元素设置为org/apache/maven/messages。然而，如果你只是想把资源放到源码目录结构里，就不需要该配置。 --> 
            <targetPath /> 
            <!-- 是否使用参数值代替参数名。参数值取自properties元素或者文件里配置的属性，文件在filters元素里列出。 --> 
            <filtering /> 
            <!-- 描述存放资源的目录，该路径相对POM路径 --> 
            <directory /> 
            <!-- 包含的模式列表，例如**/*.xml. --> 
            <includes /> 
            <!-- 排除的模式列表，例如**/*.xml --> 
            <excludes /> 
        </resource> 
    </resources> 

    <!-- 这个元素描述了单元测试相关的所有资源路径，例如和单元测试相关的属性文件。 --> 
    <testResources> 
        <!-- 这个元素描述了测试相关的所有资源路径，参见build/resources/resource元素的说明 --> 
        <testResource> 
            <targetPath />
            <filtering />
            <directory />
            <includes />
            <excludes /> 
        </testResource> 
    </testResources> 

    <!-- 构建产生的所有文件存放的目录 --> 
    <directory /> 
    <!-- 产生的构件的文件名，默认值是${artifactId}-${version}。 --> 
    <finalName /> 
    <!-- 当filtering开关打开时，使用到的过滤器属性文件列表 --> 
    <filters /> 

    <!-- 子项目可以引用的默认插件信息。该插件配置项直到被引用时才会被解析或绑定到生命周期。给定插件的任何本地配置都会覆盖这里的配置 --> 
    <pluginManagement> 
        <!-- 使用的插件列表 。 --> 
        <plugins> 
            <!-- plugin元素包含描述插件所需要的信息。 --> 
            <plugin> 
                <!-- 插件在仓库里的group ID --> 
                <groupId /> 
                <!-- 插件在仓库里的artifact ID --> 
                <artifactId /> 
                <!-- 被使用的插件的版本（或版本范围） --> 
                <version /> 
                <!-- 是否从该插件下载Maven扩展（例如打包和类型处理器），由于性能原因，只有在真需要下载时，该元素才被设置成enabled。 --> 
                <extensions /> 
                <!-- 在构建生命周期中执行一组目标的配置。每个目标可能有不同的配置。 --> 
                <executions> 
                    <!-- execution元素包含了插件执行需要的信息 --> 
                    <execution> 
                        <!-- 执行目标的标识符，用于标识构建过程中的目标，或者匹配继承过程中需要合并的执行目标 --> 
                        <id /> 
                        <!-- 绑定了目标的构建生命周期阶段，如果省略，目标会被绑定到源数据里配置的默认阶段 --> 
                        <phase /> 
                        <!-- 配置的执行目标 --> 
                        <goals /> 
                        <!-- 配置是否被传播到子POM --> 
                        <inherited /> 
                        <!-- 作为DOM对象的配置 --> 
                        <configuration /> 
                    </execution> 
                </executions> 
                <!-- 项目引入插件所需要的额外依赖 --> 
                <dependencies> 
                    <!-- 参见dependencies/dependency元素 --> 
                    <dependency> 
                    </dependency> 
                </dependencies> 
                <!-- 任何配置是否被传播到子项目 --> 
                <inherited /> 
                <!-- 作为DOM对象的配置 --> 
                <configuration /> 
            </plugin> 
        </plugins> 
    </pluginManagement> 
    
    <!-- 使用的插件列表 --> 
    <plugins> 
        <!-- 参见build/pluginManagement/plugins/plugin元素 --> 
        <plugin> 
            <groupId /><artifactId /><version /><extensions /> 
            <executions> 
                <execution> 
                    <id />
                    <phase />
                    <goals />
                    <inherited />
                    <configuration /> 
                </execution> 
            </executions> 
            <dependencies> 
                <!-- 参见dependencies/dependency元素 --> 
                <dependency> 
                </dependency> 
            </dependencies> 
            <goals />
            <inherited />
            <configuration /> 
        </plugin> 
    </plugins> 

</build> 

<!-- 在列的项目构建profile，如果被激活，会修改构建处理 --> 
<profiles> 
    <!-- 根据环境参数或命令行参数激活某个构建处理 --> 
    <profile> 
        <!-- 构建配置的唯一标识符。即用于命令行激活，也用于在继承时合并具有相同标识符的profile。 --> 
        <id /> 
        <!-- 自动触发profile的条件逻辑。Activation是profile的开启钥匙。profile的力量来自于它 
        能够在某些特定的环境中自动使用某些特定的值；这些环境通过activation元素指定。activation元素并不是激活profile的唯一方式。 --> 
        <activation> 
            <!-- profile默认是否激活的标志 --> 
            <activeByDefault /> 
            <!-- 当匹配的jdk被检测到，profile被激活。例如，1.4激活JDK1.4，1.4.0_2，而!1.4激活所有版本不是以1.4开头的JDK。 --> 
            <jdk /> 
            <!-- 当匹配的操作系统属性被检测到，profile被激活。os元素可以定义一些操作系统相关的属性。 --> 
            <os> 
                <!-- 激活profile的操作系统的名字 --> 
                <name> Windows XP </name> 
                <!-- 激活profile的操作系统所属家族(如 'windows') --> 
                <family> Windows </family> 
                <!-- 激活profile的操作系统体系结构 --> 
                <arch> x86 </arch> 
                <!-- 激活profile的操作系统版本 --> 
                <version> 5.1.2600 </version> 
            </os> 
            <!-- 如果Maven检测到某一个属性（其值可以在POM中通过${名称}引用），其拥有对应的名称和值，Profile就会被激活。如果值 
            字段是空的，那么存在属性名称字段就会激活profile，否则按区分大小写方式匹配属性值字段 --> 
            <property> 
                <!-- 激活profile的属性的名称 --> 
                <name> mavenVersion </name> 
                <!-- 激活profile的属性的值 --> 
                <value> 2.0.3 </value> 
            </property> 
            
            <!-- 提供一个文件名，通过检测该文件的存在或不存在来激活profile。missing检查文件是否存在，如果不存在则激活 
            profile。另一方面，exists则会检查文件是否存在，如果存在则激活profile。 --> 
            <file> 
                <!-- 如果指定的文件存在，则激活profile。 --> 
                <exists> /usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/ </exists> 
                <!-- 如果指定的文件不存在，则激活profile。 --> 
                <missing> /usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/ </missing> 
            </file> 
        </activation> 
        
        <!-- 构建项目所需要的信息。参见build元素 --> 
        <build> 
            <defaultGoal /> 
            <resources> 
                <resource> 
                    <targetPath /><filtering /><directory /><includes /><excludes /> 
                </resource> 
            </resources> 
            <testResources> 
                <testResource> 
                    <targetPath /><filtering /><directory /><includes /><excludes /> 
                </testResource> 
            </testResources> 
            <directory />
            <finalName />
            <filters /> 
            <pluginManagement> 
                <plugins> 
                    <!-- 参见build/pluginManagement/plugins/plugin元素 --> 
                    <plugin> 
                        <groupId /><artifactId /><version /><extensions /> 
                        <executions> 
                            <execution> 
                                <id /><phase /><goals /><inherited /><configuration /> 
                            </execution> 
                        </executions> 
                        <dependencies> 
                            <!-- 参见dependencies/dependency元素 --> 
                            <dependency> 
                            </dependency> 
                        </dependencies> 
                        <goals /><inherited /><configuration /> 
                    </plugin> 
                </plugins> 
            </pluginManagement> 
            <plugins> 
                <!-- 参见build/pluginManagement/plugins/plugin元素 --> 
                <plugin> 
                    <groupId /><artifactId /><version /><extensions /> 
                    <executions> 
                        <execution> 
                            <id /><phase /><goals /><inherited /><configuration /> 
                        </execution> 
                    </executions> 
                    <dependencies> 
                    <!-- 参见dependencies/dependency元素 --> 
                    <dependency> 
                    </dependency> 
                    </dependencies> 
                    <goals /><inherited /><configuration /> 
                </plugin> 
            </plugins> 
        </build> 
        <!-- 模块（有时称作子项目） 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径 --> 
        <modules /> 
        <!-- 发现依赖和扩展的远程仓库列表。 --> 
        <repositories> 
            <!-- 参见repositories/repository元素 --> 
            <repository> 
                <releases> 
                    <enabled /><updatePolicy /><checksumPolicy /> 
                </releases> 
                <snapshots> 
                    <enabled /><updatePolicy /><checksumPolicy /> 
                </snapshots> 
                <id /><name /><url /><layout /> 
            </repository> 
        </repositories> 
        <!-- 发现插件的远程仓库列表，这些插件用于构建和报表 --> 
        <pluginRepositories> 
            <!-- 包含需要连接到远程插件仓库的信息.参见repositories/repository元素 --> 
            <pluginRepository> 
                <releases> 
                    <enabled /><updatePolicy /><checksumPolicy /> 
                </releases> 
                <snapshots> 
                    <enabled /><updatePolicy /><checksumPolicy /> 
                </snapshots> 
                <id /><name /><url /><layout /> 
            </pluginRepository> 
        </pluginRepositories> 
        <!-- 该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息，请看项目依赖机制。 --> 
        <dependencies> 
            <!-- 参见dependencies/dependency元素 --> 
            <dependency> 
            </dependency> 
        </dependencies> 
        <!-- 不赞成使用. 现在Maven忽略该元素. --> 
        <reports /> 
        <!-- 参见dependencyManagement元素 --> 
        <dependencyManagement> 
            <dependencies> 
                <!-- 参见dependencies/dependency元素 --> 
                <dependency> 
                </dependency> 
            </dependencies> 
        </dependencyManagement> 
        <!-- 参见distributionManagement元素 --> 
        <distributionManagement> 
        </distributionManagement> 
        <!-- 参见properties元素 --> 
        <properties /> 
    </profile> 
</profiles> 


<!-- 发现依赖和扩展的远程仓库列表。 --> 
<repositories> 
    <!-- 包含需要连接到远程仓库的信息 --> 
    <repository> 
        <!-- 如何处理远程仓库里发布版本的下载 --> 
        <releases> 
            <!-- true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。 --> 
            <enabled /> 
            <!-- 该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 --> 
            <updatePolicy /> 
            <!-- 当Maven验证构件校验文件失败时该怎么做：ignore（忽略），fail（失败），或者warn（警告）。 --> 
            <checksumPolicy /> 
        </releases> 
        <!-- 如何处理远程仓库里快照版本的下载。有了releases和snapshots这两组配置，POM就可以在每个单独的仓库中，为每种类型的构件采取不同的策略。例如，可能有人会决定只为开发目的开启对快照版本下载的支持。参见repositories/repository/releases元素 --> 
        <snapshots> 
            <enabled /><updatePolicy /><checksumPolicy /> 
        </snapshots> 
        <!-- 远程仓库唯一标识符。可以用来匹配在settings.xml文件里配置的远程仓库 --> 
        <id> xxx-repository-proxy </id> 
        <!-- 远程仓库名称 --> 
        <name> xxx-repository-proxy </name> 
        <!-- 远程仓库URL，按protocol://hostname/path形式 --> 
        <url> http://192.168.1.169:9999/repository/ </url> 
        <!-- 用于定位和排序构件的仓库布局类型-可以是default（默认）或者legacy（遗留）。Maven 2为其仓库提供了一个默认的布局；然而，Maven 1.x有一种不同的布局。我们可以使用该元素指定布局是default（默认）还是legacy（遗留）。 --> 
        <layout> default </layout> 
    </repository> 
</repositories> 

<!-- 发现插件的远程仓库列表，这些插件用于构建和报表 --> 
<pluginRepositories> 
    <!-- 包含需要连接到远程插件仓库的信息.参见repositories/repository元素 --> 
    <pluginRepository> 
    </pluginRepository> 
</pluginRepositories> 

<!-- 该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息，请看项目依赖机制。 --> 
<dependencies> 
    <dependency> 
        <!-- 依赖的group ID --> 
        <groupId> org.apache.maven </groupId> 
        <!-- 依赖的artifact ID --> 
        <artifactId> maven-artifact </artifactId> 
        <!-- 依赖的版本号。 在Maven 2里, 也可以配置成版本号的范围。 --> 
        <version> 3.8.1 </version> 
        <!-- 依赖类型，默认类型是jar。它通常表示依赖的文件的扩展名，但也有例外。一个类型可以被映射成另外一个扩展名或分类器。类型经常和使用的打包方式对应，尽管这也有例外。一些类型的例子：jar，war，ejb-client和test-jar。如果设置extensions为 true，就可以在plugin里定义新的类型。所以前面的类型的例子不完整。 --> 
        <type> jar </type> 
        <!-- 依赖的分类器。分类器可以区分属于同一个POM，但不同构建方式的构件。分类器名被附加到文件名的版本号后面。例如，如果你想要构建两个单独的构件成JAR，一个使用Java 1.4编译器，另一个使用Java 6编译器，你就可以使用分类器来生成两个单独的JAR构件。 --> 
        <classifier></classifier> 
        <!-- 依赖范围。在项目发布过程中，帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。 
        - compile ：默认范围，用于编译 
        - provided：类似于编译，但支持你期待jdk或者容器提供，类似于classpath 
        - runtime: 在执行时需要使用 
        - test: 用于test任务时使用 
        - system: 需要外在提供相应的元素。通过systemPath来取得 
        - systemPath: 仅用于范围为system。提供相应的路径 
        - optional: 当项目自身被依赖时，标注依赖是否传递。用于连续依赖时使用 --> 
        <scope> test </scope> 
        <!-- 仅供system范围使用。注意，不鼓励使用这个元素，并且在新的版本中该元素可能被覆盖掉。该元素为依赖规定了文件系统上的路径。需要绝对路径而不是相对路径。推荐使用属性匹配绝对路径，例如${java.home}。 --> 
        <systemPath></systemPath> 
        <!-- 当计算传递依赖时， 从依赖构件列表里，列出被排除的依赖构件集。即告诉maven你只依赖指定的项目，不依赖项目的依赖。此元素主要用于解决版本冲突问题 --> 
        <exclusions> 
            <exclusion> 
                <artifactId />  
                <groupId /> 
            </exclusion> 
        </exclusions> 
        <!-- 可选依赖，如果你在项目B中把C依赖声明为可选，你就需要在依赖于B的项目（例如项目A）中显式的引用对C的依赖。可选依赖阻断依赖的传递性。 --> 
        <optional> true </optional> 
    </dependency> 
</dependencies> 

<!-- 不赞成使用. 现在Maven忽略该元素. --> 
<reports></reports> 

<!-- 继承自该项目的所有子项目的默认依赖信息。这部分的依赖信息不会被立即解析,而是当子项目声明一个依赖（必须描述group ID和artifact ID信息），如果group ID和artifact ID以外的一些信息没有描述，则通过group ID和artifact ID匹配到这里的依赖，并使用这里的依赖信息。 --> 
<dependencyManagement> 
    <dependencies> 
        <!-- 参见dependencies/dependency元素 --> 
        <dependency> 
        </dependency> 
    </dependencies> 
</dependencyManagement> 
<!-- 项目分发信息，在执行mvn deploy后表示要发布的位置。有了这些信息就可以把网站部署到远程服务器或者把构件部署到远程仓库。 --> 
<distributionManagement> 
    <!-- 部署项目产生的构件到远程仓库需要的信息 --> 
    <repository> 
        <!-- 是分配给快照一个唯一的版本号（由时间戳和构建流水号）？还是每次都使用相同的版本号？参见repositories/repository元素 --> 
        <uniqueVersion /> 
        <id /> <name /> <url /> <layout /> 
    </repository> 
    <!-- 构件的快照部署到哪里？如果没有配置该元素，默认部署到repository元素配置的仓库，参见distributionManagement/repository元素 --> 
    <snapshotRepository> 
        <uniqueVersion /> 
        <id /> <name /> <url /> <layout /> 
    </snapshotRepository> 
    <!-- 部署项目的网站需要的信息 --> 
    <site> 
        <!-- 部署位置的唯一标识符，用来匹配站点和settings.xml文件里的配置 --> 
        <id /> 
        <!-- 部署位置的名称 --> 
        <name /> 
        <!-- 部署位置的URL，按protocol://hostname/path形式 --> 
        <url> 
        </url> 
    </site> 
    <!-- 项目下载页面的URL。如果没有该元素，用户应该参考主页。使用该元素的原因是：帮助定位那些不在仓库里的构件（由于license限制）。 --> 
    <downloadUrl /> 
    <!-- 如果构件有了新的group ID和artifact ID（构件移到了新的位置），这里列出构件的重定位信息。 --> 
    <relocation> 
        <!-- 构件新的group ID --> 
        <groupId /> 
        <!-- 构件新的artifact ID --> 
        <artifactId /> 
        <!-- 构件新的版本号 --> 
        <version /> 
        <!-- 显示给用户的，关于移动的额外信息，例如原因。 --> 
        <message /> 
    </relocation> 
    <!-- 给出该构件在远程仓库的状态。不得在本地项目中设置该元素，因为这是工具自动更新的。有效的值有：none（默认），converted（仓库管理员从Maven 1 POM转换过来），partner（直接从伙伴Maven 2仓库同步过来），deployed（从Maven 2实例部署），verified（被核实时正确的和最终的）。 --> 
    <status /> 
</distributionManagement> 

<!-- 以值替代名称，Properties可以在整个POM中使用，也可以作为触发条件（见settings.xml配置文件里activation元素的说明）。格式是<name>value</name>。 --> 
<properties />