玩转微服务-基础篇-maven_maven和微服务

第一节 maven 的概念

一. 介绍

Maven 是 Apache 软件基金会组织维护的一款自动化构建工具，专注服务于 Java 平台的项目构建和 依赖管理。将项目开发和管理过程抽象成一个项目对象模型(POM)。

下载地址：Maven – Download Apache Maven

二. 目录结构

• bin：该目录包含了mvn运行的脚本，这些脚本用来配置Java命令，准备好classpath和相关的Java系统属性，然后执行Java命令。
  其中mvn是基于UNIX平台的shell脚本，mvn.bat是基于Windows平台的bat脚本。在命令行输入任何一条mvn命令时，实际上就是在调用这些脚本。
  该目录还包含了mvnDebug和mvnDebug.bat两个文件，同样，前者是UNIX平台的shell脚本，后者是Windows平台的bat脚本。
• boot：该目录只包含一个文件，以maven 3.0为例，该文件为plexus-classworlds-2.2.3.jar。plexus-classworlds是一个类加载器框架，相对于默认的java类加载器，它提供了更丰富的语法以方便配置，Maven使用该框架加载自己的类库。
• conf：该目录包含了一个非常重要的文件settings.xml。直接修改该文件，就能在机器上全局地定制Maven的行为。一般情况下，我们更偏向于复制该文件至～/.m2/目录下（～表示用户目录），然后修改该文件，在用户范围定制Maven的行为。
• lib：该目录包含了所有Maven运行时需要的Java类库，Maven本身是分模块开发的，因此用户能看到诸如maven-core-3.0.jar、maven-model-3.0.jar之类的文件。此外，这里还包含一些Maven用到的第三方依赖，如common-cli-1.2.jar、google-collection-1.0.jar等。对于Maven 2来说，该目录只包含一个如maven-2.2.1-uber.jar的文件，原本各为独立JAR文件的Maven模块和第三方类库都被拆解后重新合并到了这个JAR文件中。可以说，lib目录就是真正的Maven。

三. 环境配置

maven 的使用需要在系统中配置，如下环境变量，这些配置可以在：bin目录下的mvn文件中看到：

JAVA_HOME：

MAVEN_HOME

第二节 项目构建工具

1. Ant

Ant是第一个所谓的“现代构建工具”，用于自动化构建过程。它是用Java实现的，主要用于Java项目。Ant的第一个公开发行版是在2000年，它很快成为Java项目最流行的构建工具，这要归功于它的平台独立性(如Java)，设置门槛低，并提供可重复的构建。后来，它还获得了接受插件的能力。

2. Maven

Maven于2004年首次发布，旨在改进开发人员在使用Ant和其他构建工具时遇到的一些问题。Maven最大的成就被认为是引入了项目结构约定、依赖关系管理和一个中心工件库Maven central。

​ Maven仍然使用XML来编写构建文件(pom.XML)，但是结构非常不同，因为它变成了声明性的。现在，开发人员不必写下导致某些目标的所有命令，而是描述项目的结构(如果它与约定不同的话)，Maven本身提供了程序员可以调用的可用目标。另外，Maven能够通过网络下载依赖项。

3. Gradle

Gradle是三个构建工具中最年轻的一个，它的开发人员试图将Ant的能力和灵活性与Maven的依赖关系管理和约定结合起来，以创建漂亮而闪亮的构建工具。经过几年的开发，GradleV1.0于2012年发布，并迅速开始流行起来。它发展得非常快，已经被一些大企业采用——例如，Gradle被选为谷歌Android操作系统的构建工具。

第三节 maven的优缺点

优点：

• 对第三方依赖库进行统一的版本管理
• 统一项目的目录结构
• 统一软件构建阶段
• 便于项目升级，无论是项目本身升级还是项目使用的依赖升级。
• 有助于多模块项目的开发，一个模块开发好后，发布到仓库，依赖该模块时可以直接从仓库更新，而不用自己去编译。
• maven有很多插件，便于功能扩展，比如生产站点，自动发布版本等
• 自动生成项目网站和报表

缺点：

• maven是一个庞大的构建系统，学习难度大
• maven采用约定优于配置的策略（convention over configuration），虽然上手容易，但是一旦出了问题，难于调试。
• 由于需要下载，导入等，导致加载缓慢，或者出现错误，和不稳定
• 缺少对Maven的文档描述(网上一大堆，但是没有标准)
• 中央存储库中的元数据不佳
• POM.xml做为项目元数据的来源，xml技术文件庞大，不便于理解和维护。

第四节 maven的基本命令

• mvn archetype:generate ：创建 Maven 项目
• mvn compile ：编译源代码
• mvn test-compile ：编译测试代码
• mvn test ： 运行应用程序中的单元测试
• mvn site ： 生成项目相关信息的网站
• mvn clean ：清除目标目录中的生成结果
• mvn package ： 依据项目生成 jar 文件
• mvn install ：在本地 Repository 中安装 jar
• mvn deploy：将jar包发布到远程仓库

注意：运行Maven命令时一定要进入pom.xml文件所在的目录！

第五节 仓库

在maven世界中，任何一个依赖，插件或者项目构建的输出，都可以成为构件。
maven在某个位置统一存储所有Maven项目共享的构建，这个统一的位置就是仓库。
maven项目只需要声明这些依赖的坐标，在需要的时候（如：编译时）maven会自动根据坐标找到仓库中的构件，并使用他们。

为了实现重用，项目构建完毕后生成的构建也可以安装或部署到仓库中，供其他项目使用。

一. 仓库

当maven根据坐标寻找构件的时候，它首先会查看本地仓库，如果本地仓库存在此构件，就直接使用。如果本地不存在此构件，或者需要查看是否有更新的构建版本，maven就会去远程仓库中寻找，发现需要的构件之后下载到本地仓库之后再使用。如果本地和远程都没有需要的构建maven就会报错。

中央仓库是maven自带的远程仓库，它包含了绝大部分开源的构建。在默认配置中，当本地仓库没有maven需要的构件的时候，他就会从中央仓库下载。

私服：私服是另一种特殊的远程仓库，为了节省时间和宽带。应该在局域网内架设一个私有的仓库服务器，用于代理所有外部的远程仓库。内部的项目还能部署到私服上供其他项目使用。

二. 私服构建

参考：Maven私服仓库配置-Nexus详解_nexus 仓库配置

第六节 maven的特性

一. 依赖管理

依赖管理系统 maven为java世界引入了一个新的依赖管理系统jar包管理jar升级时修改配置文件即可，在java世界中，可以用groupid，artifactid，version组成的Coordination（做标）唯一标识一个依赖。

任何基于Maven构建的项目自身也必须定义这三项属性，生成的包可以是jar包，也可以是war包或者jar包。

①groupId：定义当前Maven项目隶属的实际项目–公司名称。

②artifactId：该元素定义实际项目中的一个Maven模块–项目名。推荐的做法是使用实际项目名称作为artifactId的前缀。比如：spring-bean，spring-webmvc等。

③version：该元素定义maven项目当前所处的版本。

二. 多模块构建

多模块构建 项目复查时dao service controller 层分离将一个项目分解为多个模块已经是很通用的一种方式。

在maven中需要定义一个parent POM作为一组module的聚合POM，在该POM中可以标签来定义一组子模块，parent POM不会有什么实际构建产生。而parent POM中的build配置以及依赖配置都会自动继承给子module。

三. 一致的项目构建

一致的项目构建 主要解决了我们在idea中和eclipse中创建的项目，目录可能不一样，但是如果使用了maven后，我们创建的项目目录都是一样的。 Maven在设计之初的理念就是Conversion over configuration（约定大于配置） ，其制定了一套项目目录结构作为标准的java项目结构，解决不同ide带来的文件目录不一致问题。

四. 一致的构建模型和插件机制

通过统一的pom.xml文件来配置tomcat、jetty等插件，非常方便。比如之前构建一个web项目还要各种配置tomcat服务器等的，就很麻烦。

<plugin>
	<!--这里是所有添加插件配置的地方-->
	<groupId>org.mortbay.jetty</groupId>
	<artifactId>maven-jetty-plugin</artifactId>
	<version>6.1.25</version>
	<configuration>
	<scanIntervalSeconds>10</scanIntervalSeconds>
	<contextPath>/test</contextPath>
</configuration>
</plugin>
1
2
3
4
5
6
7
8
9
10

第七节 maven的生命周期

一. 构建

构建就是以我们编写的 Java 代码、框架配置文件、国际化等其他资源文件、如：页面和图片等静态资源作为“原材料”，去“生产”出一个可以运行的项目的过程。

构建过程的几个主要环节

①清理：删除以前的编译结果，为重新编译做好准备。
②编译：将 Java 源程序编译为字节码文件。
③测试：针对项目中的关键点进行测试，确保项目在迭代开发过程中关键点的正确性。
④报告：在每一次测试后以标准的格式记录和展示测试结果。
⑤打包：将一个包含诸多文件的工程封装为一个压缩文件用于安装或部署。Java 工程对应 jar 包，Web 工程对应 war 包。
⑥安装：在 Maven 环境下特指将打包的结果——jar 包或 war 包安装到本地仓库中。
⑦部署：将打包的结果部署到远程仓库或将 war 包部署到服务器上运行。

二. 生命周期简介

Maven的生命周期是一个抽象的概念，并不具体指某个操作，是Maven经过长时间思考和分析后总结出来的。它包括了一个项目的清理、初始化、编译、测试、打包、集成测试、验证、部署和站点生成等一系列的构建流程。

但它仅仅是抽象而已，并不执行具体操作，它的具体操作是交给Maven的各种插件来实现，所以说生命周期和插件是密不可分的。

三. maven的生命周期

Maven的生命周期并不像我们所想的是一条线，它实际上有3套相互独立的生命周期，分别是：clean、default和site。

而这三套生命周期，又各自都有一些不同的阶段（phase），这些阶段就是生命周期中最细化的操作，当然它仍然是抽象概念，具体操作是给插件做的。

下面具体的说明这3个生命周期的各个阶段，注意是有顺序的，各个阶段之间的顺序也是如下的顺序

1. clean

用于清理项目，clean 生命周期包括以下 3 个阶段：

1. pre-clean： 清理前的准备工作；
2. clean：清理上一次构建的结果；
3. post-clean：清理结束后需要完成的工作。

2. default

default 生命周期定义了项目真正构建时所需要的所有步骤，它是所有生命周期中最核心，最重要的部分.

各阶段如下表：

3. site生命周期

site生命周期的目的是建立和发布项目站点，maven能够基于POM所包含的信息，自动生成一个友好的站点，方便团队交流和发布项目信息。

site 生命周期包含以下 4 个阶段：

1. pre-site：准备阶段。在生成站点前所需要做的工作；
2. site：生成站点阶段；
3. post-site：结束阶段。生成站点结束后所需要做的工作；
4. site-deploy：发布阶段。我们可以将上面生成的站点发布到对应服务器中。

四. 生命周期执行规则

每套生命周期包含一系列的构建阶段（phase），这些阶段是有顺序的，且后面的阶段依赖于前面的阶段。用户与 Maven 最直接的交互方式就是调用这些生命周期阶段。

以 clean 生命周期为例，它包含 pre-clean、clean 以及 post-clean 三个阶段，当用户调用 pre-clean 阶段时，则只有 pre-clean 阶段执行；当用户调用 clean 阶段时，pre-clean 和 clean 阶段都会执行。当用户调用 post-clean 阶段时，则 pre-clean、clean 以及 post-clean 三个阶段都会执行。

三套生命周期本身是相互独立的，用户可以只调用 clean 生命周期的某个阶段，也可以只调用 default 生命周期的某个阶段，而不会对其他生命周期造成任何影响。当然也可以同时调用两套生命周期的某个阶段。

通过将阶段名传递给 mvn 命令，就可以调用构建阶段，例如：
mvn clean，就是调用clean生命周期的clean阶段，当前项目的target目录会被清空。

如下图：

第八节 maven的属性体系

一. maven 中 有六种类型的属性

1. 内置属性

maven 中内置的预定义,用户可以直接使用 常见于项目的根配置文件，这里说的是顶级根，如：

${basedir}表示项目根目录,即包含pom.xml文件的目录;

${version}表示项目版本;

${project.basedir}同${basedir};

${project.baseUri}表示项目文件地址;

${maven.build.timestamp}表示项目构件开始时间;

${maven.build.timestamp.format}表示属性${maven.build.timestamp}的展示格式,默认值为yyyyMMdd-HHmm,可自定义其格式,其类型可参考java.text.SimpleDateFormat。用法如下：
  <properties>
    <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss</maven.build.timestamp.format>
  </properties>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. POM属性

pom 中对应元素的值

常用的pom属性值有：

${project.build.directory}表示主源码路径;

${project.build.sourceEncoding}表示主源码的编码格式;

${project.build.sourceDirectory}表示主源码路径;

${project.build.finalName}表示输出文件名称;

${project.version}表示项目版本,与${version}相同;
1
2
3
4
5
6
7
8
9

3. 自定义属性

在pom.xml文件的标签下定义的Maven属性

<project>

  <properties>

    <name>xiaoming</name>

  </properties>

</project>
1
2
3
4
5
6
7
8
9

在其他地方使用${my.pro}使用该属性值。

4. Settings属性

与pom属性同理,用户使用以settings.开头的属性引用settings.xml文件中的XML元素值)

${settings.localRepository}表示本地仓库的地址;

5. Java系统属性

所有Java系统属性都可以使用Maven属性引用，例如{user.home}指向了用户目录。可以通过命令行mvn help:system查看所有的Java系统属性。

在Java代码中引用Maven属性

在Java代码中，我们可以使用System.getProperty()方法来获取Maven属性的值。System.getProperty()方法接受一个字符串参数，该参数是要获取的属性的键。

例如，要获取在pom.xml中定义的java.version属性的值，可以使用以下代码：

String javaVersion = System.getProperty("java.version");
System.out.println("Java版本：" + javaVersion);
1
2

6. 环境变量属性

所有环境变量都可以使用以env.开头的Maven属性引用。例如${env.JAVA_HOME}指代了JAVA_HOME环境变量的值。也可以通过命令行mvn help:system查看所有环境变量。

二. 配置文件加载属性

1. 在pom中自定义属性

<properties>
   <jdbc.url>jdbc:mysql://127.1.1.1:3306/ssm_db</jdbc.url>
</properties>
1
2
3

2. jdbc.properties文件中引用属性

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=${jdbc.url}
jdbc.username=root
jdbc.password=root
1
2
3
4

3. 设置maven过滤文件范围

Maven在默认情况下是从当前项目的src\main\resources下读取文件进行打包。

<build>
    <resources>
        <!--设置资源目录-->
        <resource>
            <directory>${project.basedir}/src/main/resources</directory>
            <!--设置能够解析${}，默认是false -->
            <filtering>true</filtering>
        </resource>
    </resources>
</build>
1
2
3
4
5
6
7
8
9
10

module 项目方式时，可在顶级pom 下统一配置。

第九节 maven的版本管理

在我们jar包的版本定义中，有两个工程版本用的比较多:

• SNAPSHOT（快照版本）

​ 1. 项目开发过程中临时输出的版本，称为快照版本

​ 2. 快照版本会随着开发的进展不断更新

• RELEASE（发布版本）

​ 1. 项目开发到一定阶段里程碑后，向团队外部发布较为稳定的版本，这种版本所对应的构件文件是稳定的

​ 2. 即便进行功能的后续开发，也不会改变当前发布版本内容，这种版本称为发布版本

第十节 maven 的核心概念

一. POM文件的介绍

<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/xsd/maven-4.0.0.xsd">  
    <!--父项目的坐标。如果项目中没有规定某个元素的值，那么父项目中的对应值即为项目的默认值。 坐标包括group ID，artifact ID和 version。 -->  
    <parent>  
        <!--被继承的父项目的构件标识符 -->  
        <artifactId />  
        <!--被继承的父项目的全球唯一标识符 -->  
        <groupId />  
        <!--被继承的父项目的版本 -->  
        <version />  
        <!--父项目的pom.xml文件的相对路径。相对路径允许你选择一个不同的路径。默认值是../pom.xml。Maven首先在构建当前项目的地方寻找父项目的pom，其次在文件系统的这个位置（relativePath位置），然后在本地仓库，最后在远程仓库寻找父项目的pom。 -->  
        <relativePath />  
    </parent>  
    <!--声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变，虽然如此，但它仍然是必不可少的，这是为了当Maven引入了新的特性或者其他模型变更的时候，确保稳定性。 -->  
    <modelVersion>4.0.0</modelVersion>  
    <!--项目的全球唯一标识符，通常使用全限定的包名区分该项目和其他项目。并且构建时生成的路径也是由此生成， 如com.mycompany.app生成的相对路径为：/com/mycompany/app -->  
    <groupId>asia.banseon</groupId>  
    <!--构件的标识符，它和group ID一起唯一标识一个构件。换句话说，你不能有两个不同的项目拥有同样的artifact ID和groupID；在某个特定的group   
        ID下，artifact ID也必须是唯一的。构件是项目产生的或使用的一个东西，Maven为项目产生的构件包括：JARs，源码，二进制发布和WARs等。 -->  
    <artifactId>banseon-maven2</artifactId>  
    <!--项目产生的构件类型，例如jar、war、ear、pom。插件可以创建他们自己的构件类型，所以前面列的不是全部构件类型 -->  
    <packaging>jar</packaging>  
    <!--项目当前版本，格式为:主版本.次版本.增量版本-限定版本号 -->  
    <version>1.0-SNAPSHOT</version>  
    <!--项目的名称, Maven产生的文档用 -->  
    <name>banseon-maven</name>  
    <!--项目主页的URL, Maven产生的文档用 -->  
    <url>http://www.baidu.com/banseon</url>  
    <!--项目的详细描述, Maven 产生的文档用。 当这个元素能够用HTML格式描述时（例如，CDATA中的文本会被解析器忽略，就可以包含HTML标签），   
        不鼓励使用纯文本描述。如果你需要修改产生的web站点的索引页面，你应该修改你自己的索引页文件，而不是调整这里的文档。 -->  
    <description>A maven project to study maven.</description>  
    <!--描述了这个项目构建环境中的前提条件。 -->  
    <prerequisites>  
        <!--构建该项目或使用该插件所需要的Maven的最低版本 -->  
        <maven />  
    </prerequisites>  
    <!--项目的问题管理系统(Bugzilla, Jira, Scarab,或任何你喜欢的问题管理系统)的名称和URL，本例为 jira -->  
    <issueManagement>  
        <!--问题管理系统（例如jira）的名字， -->  
        <system>jira</system>  
        <!--该项目使用的问题管理系统的URL -->  
        <url>http://jira.xxxx.com/xxxx</url>  
    </issueManagement>  
    <!--项目持续集成信息 -->  
    <ciManagement>  
        <!--持续集成系统的名字，例如continuum -->  
        <system />  
        <!--该项目使用的持续集成系统的URL（如果持续集成系统有web接口的话）。 -->  
        <url />  
        <!--构建完成时，需要通知的开发者/用户的配置项。包括被通知者信息和通知条件（错误，失败，成功，警告） -->  
        <notifiers>  
            <!--配置一种方式，当构建中断时，以该方式通知用户/开发者 -->  
            <notifier>  
                <!--传送通知的途径 -->  
                <type />  
                <!--发生错误时是否通知 -->  
                <sendOnError />  
                <!--构建失败时是否通知 -->  
                <sendOnFailure />  
                <!--构建成功时是否通知 -->  
                <sendOnSuccess />  
                <!--发生警告时是否通知 -->  
                <sendOnWarning />  
                <!--不赞成使用。通知发送到哪里 -->  
                <address />  
                <!--扩展配置项 -->  
                <configuration />  
            </notifier>  
        </notifiers>  
    </ciManagement>  
    <!--项目创建年份，4位数字。当产生版权信息时需要使用这个值。 -->  
    <inceptionYear />  
    <!--项目相关邮件列表信息 -->  
    <mailingLists>  
        <!--该元素描述了项目相关的所有邮件列表。自动产生的网站引用这些信息。 -->  
        <mailingList>  
            <!--邮件的名称 -->  
            <name>Demo</name>  
            <!--发送邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->  
            <post>Demo@126.com</post>  
            <!--订阅邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->  
            <subscribe>Demo@126.com</subscribe>  
            <!--取消订阅邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->  
            <unsubscribe>Demo@126.com</unsubscribe>  
            <!--你可以浏览邮件信息的URL -->  
            <archive>http://localhost:8080/demo/dev/</archive>  
        </mailingList>  
    </mailingLists>  
    <!--项目开发者列表 -->  
    <developers>  
        <!--某个项目开发者的信息 -->  
        <developer>  
            <!--SCM里项目开发者的唯一标识符 -->  
            <id>HELLO WORLD</id>  
            <!--项目开发者的全名 -->  
            <name>youname</name>  
            <!--项目开发者的email -->  
            <email>youname@qq.com</email>  
            <!--项目开发者的主页的URL -->  
            <url />  
            <!--项目开发者在项目中扮演的角色，角色元素描述了各种角色 -->  
            <roles>  
                <role>Project Manager</role>  
                <role>Architect</role>  
            </roles>  
            <!--项目开发者所属组织 -->  
            <organization>demo</organization>  
            <!--项目开发者所属组织的URL -->  
            <organizationUrl>http://www.xxx.com/</organizationUrl>  
            <!--项目开发者属性，如即时消息如何处理等 -->  
            <properties>  
                <dept>No</dept>  
            </properties>  
            <!--项目开发者所在时区， -11到12范围内的整数。 -->  
            <timezone>+8</timezone>  
        </developer>  
    </developers>  
    <!--项目的其他贡献者列表 -->  
    <contributors>  
        <!--项目的其他贡献者。参见developers/developer元素 -->  
        <contributor>  
            <name />  
            <email />  
            <url />  
            <organization />  
            <organizationUrl />  
            <roles />  
            <timezone />  
            <properties />  
        </contributor>  
    </contributors>  
    <!--该元素描述了项目所有License列表。 应该只列出该项目的license列表，不要列出依赖项目的 license列表。如果列出多个license，用户可以选择它们中的一个而不是接受所有license。 -->  
    <licenses>  
        <!--描述了项目的license，用于生成项目的web站点的license页面，其他一些报表和validation也会用到该元素。 -->  
        <license>  
            <!--license用于法律上的名称 -->  
            <name>Apache 2</name>  
            <!--官方的license正文页面的URL -->  
            <url>http://www.xxxx.com/LICENSE-2.0.txt</url>  
            <!--项目分发的主要方式： repo，可以从Maven库下载 manual， 用户必须手动下载和安装依赖 -->  
            <distribution>repo</distribution>  
            <!--关于license的补充信息 -->  
            <comments>A business-friendly OSS license</comments>  
        </license>  
    </licenses>  
    <!--SCM(Source Control Management)标签允许你配置你的代码库，供Maven web站点和其它插件使用。 -->  
    <scm>  
        <!--SCM的URL,该URL描述了版本库和如何连接到版本库。欲知详情，请看SCMs提供的URL格式和列表。该连接只读。 -->  
        <connection>  
            scm:svn:http://svn.xxxx.com/maven/xxxxx-maven2-trunk(dao-trunk)     
        </connection>  
        <!--给开发者使用的，类似connection元素。即该连接不仅仅只读 -->  
        <developerConnection>  
            scm:svn:http://svn.xxxx.com/maven/dao-trunk     
        </developerConnection>  
        <!--当前代码的标签，在开发阶段默认为HEAD -->  
        <tag />  
        <!--指向项目的可浏览SCM库（例如ViewVC或者Fisheye）的URL。 -->  
        <url>http://svn.xxxxx.com/</url>  
    </scm>  
    <!--描述项目所属组织的各种属性。Maven产生的文档用 -->  
    <organization>  
        <!--组织的全名 -->  
        <name>demo</name>  
        <!--组织主页的URL -->  
        <url>http://www.xxxxxx.com/</url>  
    </organization>  
    <!--构建项目需要的信息 -->  
    <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>x64</arch>  
                    <!--激活profile的操作系统版本 -->  
                    <version>6.1.7100</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/xxxx/xxxx-home/tomcat/maven-guide-zh-to-production/workspace/  
                    </exists>  
                    <!--如果指定的文件不存在，则激活profile。 -->  
                    <missing>/usr/local/xxxx/xxxx-home/tomcat/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 />  
            <!--该元素包括使用报表插件产生报表的规范。当用户执行“mvn site”，这些报表就会运行。 在页面导航栏能看到所有报表的链接。参见reporting元素 -->  
            <reporting>......</reporting>  
            <!--参见dependencyManagement元素 -->  
            <dependencyManagement>  
                <dependencies>  
                    <!--参见dependencies/dependency元素 -->  
                    <dependency>......</dependency>  
                </dependencies>  
            </dependencyManagement>  
            <!--参见distributionManagement元素 -->  
            <distributionManagement>......</distributionManagement>  
            <!--参见properties元素 -->  
            <properties />  
        </profile>  
    </profiles>  
    <!--模块（有时称作子项目） 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径 -->  
    <modules />  
    <!--发现依赖和扩展的远程仓库列表。 -->  
    <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>banseon-repository-proxy</id>  
            <!--远程仓库名称 -->  
            <name>banseon-repository-proxy</name>  
            <!--远程仓库URL，按protocol://hostname/path形式 -->  
            <url>http://10.10.10.123:8080/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>spring-core</artifactId>  
                    <groupId>org.springframework</groupId>  
                </exclusion>  
            </exclusions>  
            <!--可选依赖，如果你在项目B中把C依赖声明为可选，你就需要在依赖于B的项目（例如项目A）中显式的引用对C的依赖。可选依赖阻断依赖的传递性。 -->  
            <optional>true</optional>  
        </dependency>  
    </dependencies>  
    <!--不赞成使用. 现在Maven忽略该元素. -->  
    <reports></reports>  
    <!--该元素描述使用报表插件产生报表的规范。当用户执行“mvn site”，这些报表就会运行。 在页面导航栏能看到所有报表的链接。 -->  
    <reporting>  
        <!--true，则，网站不包括默认的报表。这包括“项目信息”菜单中的报表。 -->  
        <excludeDefaults />  
        <!--所有产生的报表存放到哪里。默认值是${project.build.directory}/site。 -->  
        <outputDirectory />  
        <!--使用的报表插件和他们的配置。 -->  
        <plugins>  
            <!--plugin元素包含描述报表插件需要的信息 -->  
            <plugin>  
                <!--报表插件在仓库里的group ID -->  
                <groupId />  
                <!--报表插件在仓库里的artifact ID -->  
                <artifactId />  
                <!--被使用的报表插件的版本（或版本范围） -->  
                <version />  
                <!--任何配置是否被传播到子项目 -->  
                <inherited />  
                <!--报表插件的配置 -->  
                <configuration />  
                <!--一组报表的多重规范，每个规范可能有不同的配置。一个规范（报表集）对应一个执行目标 。例如，有1，2，3，4，5，6，7，8，9个报表。1，2，5构成A报表集，对应一个执行目标。2，5，8构成B报表集，对应另一个执行目标 -->  
                <reportSets>  
                    <!--表示报表的一个集合，以及产生该集合的配置 -->  
                    <reportSet>  
                        <!--报表集合的唯一标识符，POM继承时用到 -->  
                        <id />  
                        <!--产生报表集合时，被使用的报表的配置 -->  
                        <configuration />  
                        <!--配置是否被继承到子POMs -->  
                        <inherited />  
                        <!--这个集合里使用到哪些报表 -->  
                        <reports />  
                    </reportSet>  
                </reportSets>  
            </plugin>  
        </plugins>  
    </reporting>  
    <!--继承自该项目的所有子项目的默认依赖信息。这部分的依赖信息不会被立即解析,而是当子项目声明一个依赖（必须描述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>xxx-maven2</id>  
            <name>xxx maven2</name>  
            <url>file://${basedir}/target/deploy</url>  
            <layout />  
        </repository>  
        <!--构件的快照部署到哪里？如果没有配置该元素，默认部署到repository元素配置的仓库，参见distributionManagement/repository元素 -->  
        <snapshotRepository>  
            <uniqueVersion />  
            <id>xxx-maven2</id>  
            <name>xxx-maven2 Snapshot Repository</name>  
            <url>scp://svn.xxxx.com/xxx:/usr/local/maven-snapshot</url>  
            <layout />  
        </snapshotRepository>  
        <!--部署项目的网站需要的信息 -->  
        <site>  
            <!--部署位置的唯一标识符，用来匹配站点和settings.xml文件里的配置 -->  
            <id>banseon-site</id>  
            <!--部署位置的名称 -->  
            <name>business api website</name>  
            <!--部署位置的URL，按protocol://hostname/path形式 -->  
            <url>  
                scp://svn.baidu.com/xxx:/var/www/localhost/web     
            </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 />  
</project>   
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643

二.setting文件的介绍

参见：【精选】Maven的settings.xml配置详解_maven setting配置-CSDN博客

三.依赖

1. 类型

直接依赖和间接依赖

A依赖B，B依赖于C

A和B之间就是直接依赖；

A和C之间就是间接依赖；

依赖关系具有传递性。

依赖传递可能造成的问题

通过依赖传递关系，可以使依赖关系树迅速增长到一个很大的量级，但很有可能会出现依赖重复，依赖冲突等情况，Maven针对这些情况提供了如下功能进行处理：

• 依赖范围（Dependency scope）
• 依赖调解（Dependency mediation）
• 可选依赖（Optional dependencies）
• 排除依赖（Excluded dependencies）
• 依赖管理（Dependency management）

2. 依赖的原则（依赖调解）

• 路径最短者优先
• 路径相同时先声明者优先（这里“声明”的先后顺序指的是dependency标签配置的先后顺序。）
• 特殊优先，当资源配置了相同资源的不同版本，后配置的覆盖先配置的

3. 依赖的排除

A项目依赖于B项目，B项目中所依赖的jar包是compile范围；B项目中的依赖jar包就可以传递A项目中；

注意：scope定义了依赖的范围，默认是compile，即使不指定默认也是compile

使用exclusions进行排除，如：

<dependency>
 
    <groupId>com.mqf.maven</groupId>

    <artifactId>Hello</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <scope>compile</scope>

    <exclusions>

        <exclusion>

            <groupId>commons-logging</groupId>

            <artifactId>commons-logging</artifactId>

        </exclusion>                                

    </exclusions>
 
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3. 依赖的范围

• compile：默认。编译范围，编译，测试，运行都有效。参与打包，安装。
• test：测试范围，只有在test范围下才能用，不参与打包，安装。
• provided：编译和测试，不参与打包，安装。
• runtime：运行，只参与运行。
• system：废弃。系统。
• import：废弃。引入。

主要从对主程序是否有效、对测试程序是否有效、是否参与打包与部署三个方面对比以上三种依赖范围：

4. 依赖的传递

optional表示是否会传递依赖，有两个可填值（假如不声明optional标签，默认就是false）：

• false: 传递依赖
• true：不传递依赖

特点：

• 将依赖设置为true不仅代表着依赖不会传递，就连打包的时候都不会将该jar打包进去，一旦使用到调用该jar包的方法就会异常。
• 在父工程设置optional为true，并不会影响子工程继承该依赖。
• 不管是当前项目引用的，还是间接引用的，所有依赖jar包都存放在jar解压后的BOOT-INF下/jar目录下，只要这下面没有jar，那当前项目就不能用。

什么时候将optional设置为true？

谁用谁引入

四. 继承

多个子工程中依赖同样的jar包，但是采用test范围；由于test范围没有传递性；所以，每一个工程都需要对test范围的jar包进行单独依赖；

而如果希望修改多个工程中所依赖test范围的jar包版本，那么，一个一个项目去修改太麻烦，这时可以应用继承解决。

(1)定义一个父工程，父工程packaging必须是pom

pom

项目的打包类型：pom、jar、war

packing默认是jar类型，

pom ---------> 父类型都为pom类型

jar ---------> 普通项目打jar包，一般普通项目设置jar

war ---------> web项目一般都是打war包，web项目的话设置war

(2)在父工程中定义依赖的jar包，属于test范围：

<packaging>pom</packaging>
 
       <dependencyManagement>
 
              <dependencies>
 
                     <dependency>
 
                            <groupId>junit</groupId>
 
                            <artifactId>junit</artifactId>
 
                            <version>4.0</version>
 
<!-- test范围表示测试的依赖范围，这个范围的依赖，我们的test中的程序是可以使用；而main中的程序是
不可使用的； 如果是部署到Tomcat下的应用程序，依赖的jar包不能部署到Tomcat环境下的 -->
 
                            <scope>test</scope>
 
                     </dependency>
 
              </dependencies>
 
</dependencyManagement>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

(3)在各个子工程中对父工程进行继承：

<parent>

    <groupId>com.mqf.maven</groupId>

    <artifactId>MavenParent</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <relativePath>../MavenParent/pom.xml</relativePath>

</parent>
1
2
3
4
5
6
7
8
9
10
11

(4)在各个子工程中对父工程中的包进行依赖，但是，不需要配置版本号和范围（与父工程的版本号和范围一致）

<dependency>

    <groupId>junit</groupId>

    <artifactId>junit</artifactId>

</dependency>
1
2
3
4
5
6
7

(5)如果希望修改版本，只需要修改父工程中的依赖jar包版本就可以了，那么，各个子工程中的jar包版本就都变了

(6)一个子工程只能继承一个父工程.

第十一节 maven 的插件开发

一. 两种类型的插件

Maven 实际上是一个依赖插件执行的框架，它执行的每个任务实际上都由插件完成的。使用Maven打出来的包并不包含任何 Maven 插件，它们以独立构件的形式存在， 只有在 Maven 需要使用某个插件时，才会去仓库中下载。

如下表所示，Maven 提供了如下 2 种类型的插件：

二. 调用插件有两种方式

插件目标： 对于 Maven 插件而言，为了提高代码的复用性，通常一个 Maven 插件能够实现多个功能，每一个功能都是一个插件目标，即 Maven 插件是插件目标的集合。我们可以把插件理解为一个类，而插件目标是类中的方法，调用插件目标就能实现对应的功能。

使用的两种方式：

1. 引入到项目当中，然后将插件绑定到指定的生命周期，然后执行声明周期命令会自动调用该插件，例如：mvn clean、mvn install
2. 通过如下命令可以直接调用插件。
   • 使用 Maven 命令执行插件的目标，语法如：mvn [插件名]:[目标名]
   • 例如，调用 maven-compiler-plugin 插件的 compile 目标，命令如：mvn compiler:compile（注意不能使用插件的全名，一定是缩写名，不然会报找不到插件）

三. 插件绑定

为了完成某个具体的构建任务，Maven 生命周期的阶段需要和 Maven 插件的目标相互绑定。例如，代码编译任务对应了default 生命周期的 compile 阶段，而 maven-compiler-plugin 插件的 compile 目标能够完成这个任务，因此将它们进行绑定就能达到代码编译的目的。

内置绑定

Maven 默认为一些核心的生命周期阶段绑定了插件目标，当用户调用这些阶段时，对应的插件目标就会自动执行相应的任务。

表中，default 生命周期中只列出了绑定了插件目标的阶段，它还有很多其他的阶段，但这些阶段默认没有绑定任何插件目标，因此它们也没有任何实际的行为。

像这些内置绑定的插件我们也可以在项目当中去显示的声明然后修改配置，这时候内置绑定插件的默认配置将会被覆盖！

自定义绑定插件

除了内置绑定之外，用户也可以自己选择将某个插件目标绑定到 Maven 生命周期的某个阶段上，这种绑定方式就是自定义绑定。自定义绑定能够让 Maven 在构建过程中执行更多更丰富的任务。

例如，我们想要在 clean 生命周期的 clean 阶段中显示自定义文本信息，则只需要在项目的 POM 中 ，通过 build 元素的子元素 plugins，将 maven-antrun-plugin插件的run 目标绑定到 clean 阶段上，并使用该插件输出自定义文本信息即可。

<build>
	<plugins>
        <!-- 绑定插件 maven-antrun-plugin -->
        <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-antrun-plugin</artifactId>
              <version>3.0.0</version>
              <executions>
                  <execution>
                    <!--自定义 id -->
                    <id>custom clean</id>
                    <!--插件目标绑定的构建阶段 -->
                    <phase>clean</phase>
                    <!--插件目标 -->
                    <goals>
                    	<goal>run</goal>
                    </goals>
                    <!--配置 -->
                    <configuration>
                      	<!-- 执行的任务 -->
                    	<target>
                        	<!--自定义文本信息 -->
                        	<echo message="清理阶段"/>
                      </target>
                    </configuration>
                  </execution>
              </executions>
          </plugin>
	</plugins>
</build>

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

以上配置中除了插件的坐标信息之外，还通过 executions 元素定义了一些执行配置。executions 下的每一个 executin 子元素都可以用来配置执行一个任务。execution 下各个元素含义如下：

• id：任务的唯一标识。
• phase：插件目标需要绑定的生命周期阶段。
• goals：用于指定一组插件目标，其子元素 goal 用于指定一个插件目标。
• configuration：该任务的配置，其子元素 tasks 用于指定该插件目标执行的任务。

当插件目标绑定到生命周期的不同阶段时，其执行顺序由生命周期阶段的先后顺序决定。如果多个目标绑定到同一个生命周期阶段，其执行顺序与插件声明顺序一致，先声明的先执行，后声明的后执行。

四. 插件获取

官网：https://maven.apache.org/plugins/index.html

五. 插件的开发

参考：

https://blog.51cto.com/u_6346066/7000656

https://zhuanlan.zhihu.com/p/596857284