【maven】pom文件详解和延伸知识

【一】maven项目的pom文件详解

【1】maven项目的目录结构

pom文件定于了一个maven项目的maven配置，一般pom文件的放在项目或者模块的根目录下。

【2】根元素和必要配置

<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">
 
    <!--（1）模型版本 -->
    <modelVersion>4.0.0</modelVersion>
    <!--（2）公司或者组织的唯一标志，也是打包成jar包路径的依据 -->
    <!-- 例如com.companyname.project-group，maven打包jar包的路径：/com/companyname/project-group -->
    <groupId>com.companyname.project-group</groupId>
 
    <!--（3）项目的唯一ID，一个groupId下面可能多个项目，就是靠artifactId来区分的 -->
    <artifactId>project</artifactId>
 
    <!--（4）项目当前版本，格式为:主版本.次版本.增量版本-限定版本号 -->
    <version>1.0</version>
 
    <!--（5）项目产生的构件类型，包括jar、war、ear、pom等 -->
    <packaging>jar</packaging>
</project>

project是pom文件的根元素，project下有modelVersion、groupId、artifactId、version、packaging等重要的元素。其中，groupId、artifactId、version三个元素用来定义一个项目的坐标，也就是说，一个maven仓库中，完全相同的一组groupId、artifactId、version，只能有一个项目。

（1）project：整个pom配置文件的根元素，所有的配置都是写在project元素里面的；
（2）modelVersion：指定了当前POM模型的版本，对于Maven2及Maven 3来说，它只能是4.0.0；
（3）groupId：这是项目组的标识。它在一个组织或者项目中通常是唯一的。
（4）artifactId：这是项目的标识，通常是工程的名称。它在一个项目组（group）下是唯一的。
（5）version：这是项目的版本号，用来区分同一个artifact的不同版本。
（6）packaging：这是项目产生的构件类型，即项目通过maven打包的输出文件的后缀名，包括jar、war、ear、pom等。

【3】父项目和parent元素

<!--（1）父项目的坐标，坐标包括group ID，artifact ID和version。 -->
<!--如果项目中没有规定某个元素的值，那么父项目中的对应值即为项目的默认值 -->
<parent>
    <!--（2）被继承的父项目的构件标识符 -->
    <artifactId>com.companyname.project-group</artifactId>
    <!--（3）被继承的父项目的全球唯一标识符 -->
    <groupId>base-project</groupId>
    <!--（4）被继承的父项目的版本 -->
    <version>1.0.1-RELEASE</version>

    <!--（5）父项目的pom.xml文件的相对路径,默认值是../pom.xml。 -->
    <!-- 寻找父项目的pom：构建当前项目的地方--)relativePath指定的位置--)本地仓库--)远程仓库 -->
    <relativePath>../pom.xml</relativePath>
</parent>

所有的pom都继承自一个父pom（Super POM）。父pom包含了一些可以被继承的默认设置，如果项目的pom中没有设置这些元素，就会使用父pom中设置。例如，Super POM中配置了默认仓库http://repo1.maven.org/maven2，这样哪怕项目的pom中没有配置仓库，也可以去这个默认仓库中去下载依赖。实际上，maven pom文件约定大于配置的原则，就是通过在Super POM中预定义了一些配置信息来实现的。

Maven使用effective pom（Super pom加上工程自己的配置）来执行相关的目标，它帮助开发者在pom.xml中做尽可能少的配置。当然，这些配置也可以被重写。

parent元素可以指定父pom。用户可以通过增加parent元素来自定义一个父pom，从而继承该pom的配置。parent元素中包含一些子元素，用来定位父项目和父项目的pom文件位置。

（1）parent：用于指定父项目；
（2）groupId：parent的子元素，父项目的groupId，用于定位父项目；
（3）artifactId：parent的子元素，父项目的artifactId，用于定位父项目；
（4）version：parent的子元素，父项目的version，用于定位父项目；
（5）relativePath：parent的子元素，用于定位父项目pom文件的位置。

【4】项目构建需要的信息

    <!--构建项目需要的信息 -->
    <build>
        <!--------------------- 路径管理（在遵循约定大于配置原则下，不需要配置） --------------------->
        <!--项目源码目录，当构建项目的时候，构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。 -->
        <sourceDirectory />
        <!--该元素设置了项目单元测试使用的源码目录。该路径是相对于pom.xml的相对路径 -->
        <testSourceDirectory />
        <!--被编译过的应用程序class文件存放的目录。 -->
        <outputDirectory />
        <!--被编译过的测试class文件存放的目录。 -->
        <testOutputDirectory />        
        <!--项目脚本源码目录，该目录下的内容，会直接被拷贝到输出目录，因为脚本是被解释的，而不是被编译的 -->
        <scriptSourceDirectory />
 
        <!--------------------- 资源管理 --------------------->
        <!--这个元素描述了项目相关的所有资源路径列表，例如和项目相关的属性文件，这些资源被包含在最终的打包文件里。 -->
        <resources>
            <!--这个元素描述了项目相关或测试相关的所有资源路径 -->
            <resource>
                <!-- 描述了资源的目标输出路径。该路径是相对于target/classes的路径 -->
                <!-- 如果是想要把资源直接放在target/classes下，不需要配置该元素 -->
                <targetPath />
                <!--是否使用参数值代替参数名。参数值取自文件里配置的属性，文件在filters元素里列出。 -->
                <filtering />
                <!--描述存放资源的目录，该路径相对POM路径 -->
                <directory />
                <!--包含的模式列表，例如**/*.xml，只有符合条件的资源文件才会在打包的时候被放入到输出路径中 -->
                <includes />
                <!--排除的模式列表，例如**/*.xml，符合的资源文件不会在打包的时候会被过滤掉 -->
                <excludes />
            </resource>
        </resources>
        <!--这个元素描述了单元测试相关的所有资源路径，例如和单元测试相关的属性文件。 -->
        <testResources>
            <!--这个元素描述了测试相关的所有资源路径，子元素说明参考build/resources/resource元素的说明 -->
            <testResource>
                <targetPath />
                <filtering />
                <directory />
                <includes />
                <excludes />
            </testResource>
        </testResources>
 
        <!--------------------- 插件管理 --------------------->
        <!-- 子项目可以引用的默认插件信息。pluginManagement中的插件直到被引用时才会被解析或绑定到生命周期 -->
        <!-- 这里只是做了声明，并没有真正的引入。给定插件的任何本地配置都会覆盖这里的配置-->
        <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>
 
        <!--------------------- 构建扩展 --------------------->
        <!--使用来自其他项目的一系列构建扩展 -->
        <extensions>
            <!--每个extension描述一个会使用到其构建扩展的一个项目，extension的子元素是项目的坐标 -->
            <extension>
                <!--项目坐标三元素：groupId + artifactId + version -->
                <groupId />
                <artifactId />
                <version />
            </extension>
        </extensions>
 
        <!--------------------- 其他配置 --------------------->
        <!--当项目没有规定目标（Maven2 叫做阶段）时的默认值 -->
        <defaultGoal />
        <!--构建产生的所有文件存放的目录 -->
        <directory />
        <!--产生的构件的文件名，默认值是${artifactId}-${version}。 -->
        <finalName />
        <!--当filtering开关打开时，使用到的过滤器属性文件列表 -->
        <filters />
    </build>

build标签定义了构建项目需要的信息，这部分信息对于定制化项目构建是非常重要的。这里会根据build的子元素的特点，简单地分类讲解。

【5】项目依赖相关信息

pom文件中通过dependencyManagement来声明依赖，通过dependencies元素来管理依赖。dependencyManagement下的子元素只有一个直接的子元素dependencice，其配置和dependencies子元素是完全一致的；而dependencies下只有一类直接的子元素：dependency。一个dependency子元素表示一个依赖项目。

    <!--该元素描述了项目相关的所有依赖。 这些依赖自动从项目定义的仓库中下载 -->
    <dependencies>
        <dependency>
            <!------------------- 依赖坐标 ------------------->
            <!--依赖项目的坐标三元素：groupId + artifactId + version -->
            <groupId>org.apache.maven</groupId>
            <artifactId>maven-artifact</artifactId>
            <version>3.8.1</version>
 
            <!------------------- 依赖类型 ------------------->
            <!-- 依赖类型，默认是jar。通常表示依赖文件的扩展名，但有例外。一个类型可以被映射成另外一个扩展名或分类器 -->
            <!-- 类型经常和使用的打包方式对应，尽管这也有例外，一些类型的例子：jar，war，ejb-client和test-jar -->
            <!-- 如果设置extensions为true，就可以在plugin里定义新的类型 -->
            <type>jar</type>
            <!-- 依赖的分类器。分类器可以区分属于同一个POM，但不同构建方式的构件。分类器名被附加到文件名的版本号后面 -->
            <!-- 如果想将项目构建成两个单独的JAR，分别使用Java 4和6编译器，就可以使用分类器来生成两个单独的JAR构件 -->
            <classifier></classifier>
 
            <!------------------- 依赖传递 ------------------->
            <!--依赖排除，即告诉maven只依赖指定的项目，不依赖该项目的这些依赖。此元素主要用于解决版本冲突问题 -->
            <exclusions>
                <exclusion>
                    <artifactId>spring-core</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
            </exclusions>
            <!-- 可选依赖，用于阻断依赖的传递性。如果在项目B中把C依赖声明为可选，那么依赖B的项目中无法使用C依赖 -->
            <optional>true</optional>
            
            <!------------------- 依赖范围 ------------------->
            <!--依赖范围。在项目发布过程中，帮助决定哪些构件被包括进来
                - compile：默认范围，用于编译;  - provided：类似于编译，但支持jdk或者容器提供，类似于classpath 
                - runtime: 在执行时需要使用;    - systemPath: 仅用于范围为system。提供相应的路径 
                - test: 用于test任务时使用;    - system: 需要外在提供相应的元素。通过systemPath来取得 
                - optional: 当项目自身被依赖时，标注依赖是否传递。用于连续依赖时使用 -->
            <scope>test</scope>
            <!-- 该元素为依赖规定了文件系统上的路径。仅供scope设置system时使用。但是不推荐使用这个元素 -->
            <!-- 不推荐使用绝对路径，如果必须要用，推荐使用属性匹配绝对路径，例如${java.home} -->
            <systemPath></systemPath>
        </dependency>
    </dependencies>
 
    <!-- 继承自该项目的所有子项目的默认依赖信息，这部分的依赖信息不会被立即解析。 -->
    <!-- 当子项目声明一个依赖，如果group ID和artifact ID以外的一些信息没有描述，则使用这里的依赖信息 -->
    <dependencyManagement>
        <dependencies>
            <!--参见dependencies/dependency元素 -->
            <dependency>
                ......
            </dependency>
        </dependencies>
    </dependencyManagement>

这里也是根据元素的作用，简单的对dependency的子元素做了一下分类。下面按分类来看一下dependency的子元素：

（1）依赖坐标

依然是通过groupId + artifactId + version来在仓库中定位一个项目：

（1）groupId：parent的子元素，父项目的groupId，用于定位父项目；
（2）artifactId：parent的子元素，父项目的artifactId，用于定位父项目；
（3）version：parent的子元素，父项目的version，用于定位父项目；

（2）依赖类型

这个分类主要包括两个元素，分别是依赖类型和依赖的分类器。同一个项目，即使打包成同一种类型，也可以有多个文件同时存在，因为它们的分类器可能是不同的。
（1）type：依赖类型，默认是jar。通常表示依赖文件的扩展名，但也有例外。一个类型可以被映射成另外一个扩展名或分类器。类型经常和使用的打包方式对应，尽管这也有例外，一些类型的例子：jar，war，ejb-client和test-jar。如果设置extensions为true，就可以在plugin里定义新的类型。
（2）classifier：依赖的分类器。分类器可以区分属于同一个POM，但不同构建方式的构件。分类器名被附加到文件名的版本号后面，如果想将项目构建成两个单独的JAR，分别使用Java 4和6编译器，就可以使用分类器来生成两个单独的JAR构件

（3）依赖传递

依赖传递相关的子元素主要有两个，用于依赖排除的exclusions和设置依赖是否可选的optional。
（1）exclusions：排除该项目中的一些依赖，即本项目A依赖该dependency指示的项目B，但是不依赖项目B中依赖的这些依赖；
（2）optional：可选依赖，用于阻断依赖的传递性，即本项目不会依赖父项目中optional设置为true的依赖。

（4）依赖范围

还有一些其他元素：
（1）scope：依赖范围。在项目发布过程中，帮助决定哪些构件被包括进来
（2）compile：默认范围，用于编译; - provided：类似于编译，但支持jdk或者容器提供，类似于classpath
（3）runtime: 在执行时需要使用; - systemPath: 仅用于范围为system，提供相应的路径
（4）test: 用于test任务时使用; - system: 需要外在提供相应的元素，通过systemPath来取得
（5）optional: 当项目自身被依赖时，标注依赖是否传递。用于连续依赖时使用
（6）systemPath：该元素为依赖规定了文件系统上的绝对路径。仅在scope设置成system时才会使用。不推荐使用这个元素。不推荐使用绝对路径，如果必须要用，推荐使用属性匹配绝对路径，例如${java.home}

【6】生成文档相关的元素

<!--项目的名称, Maven生成文档使用 -->
<name>project-maven</name>

<!--项目主页的URL, Maven生成文档使用 -->
<url>http://123.a.b/nsnxs</url>

<!-- 项目的详细描述, Maven生成文档使用。当这个元素能够用HTML格式描述时，不鼓励使用纯文本描述 -->
<!--如果你需要修改生成的web站点的索引页面，你应该修改你自己的索引页文件，而不是调整这里的文档 -->
<description>Description of this maven project</description>

备注：maven可以通过mvn site命令生成项目的相关文档。

和生成文档相关的元素，包括name，url，和description。
（1）name：项目名称，maven生成文档会使用项目名；
（2）url：项目主页的地址，maven生成文档的时候使用。
（3）description：项目描述。如果可以使用HTML格式进行描述的时候，不推荐使用纯文本的描述。

【7】远程仓库列表

远程仓库列表的配置，包括依赖和扩展的远程仓库配置，以及插件的远程仓库配置。在本地仓库找不到的情况下，maven下载依赖、扩展和插件就是从这里配置的远程仓库中进行下载。

需要注意的是release和snapshot两者的区别。release是稳定版本，一经发布不再修改，想发布修改后的项目，只能升级项目版本再进行发布；snapshot是不稳定的，一个snapshot的版本可以不断改变。项目在开发期间一般会使用snapshot，更方便进行频繁的代码更新；一旦发布到外部，或者开发基本完成，代码迭代不再频繁，则推荐使用release。

<!--发现依赖和扩展的远程仓库列表。 -->
<repositories>
    <!--包含需要连接到远程仓库的信息 -->
    <repository>
        <!--如何处理远程仓库里发布版本的下载 -->
        <releases>
            <!--值为true或者false，表示该仓库是否为下载某种类型构件（发布版，快照版）开启。 -->
            <enabled />
            <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳 -->
            <!--选项：always，daily（默认），interval：X（X单位为分钟），或者never。 -->
            <updatePolicy />
            <!--当Maven验证构件校验文件失败时该怎么做。选项：ignore，fail，或者warn -->
            <checksumPolicy />
        </releases>
        <!-- 如何处理远程仓库里快照版本的下载 -->
        <!-- 有了releases和snapshots这两组配置，就可以在每个单独的仓库中，为每种类型的构件采取不同的策略 -->
        <snapshots>
            <enabled />
            <updatePolicy />
            <checksumPolicy />
        </snapshots>

        <!--远程仓库唯一标识符。可以用来匹配在settings.xml文件里配置的远程仓库 -->
        <id>nanxs-repository-proxy</id>
        <!--远程仓库名称 -->
        <name>nanxs-repository-proxy</name>
        <!--远程仓库URL，按protocol://hostname/path形式 -->
        <url>http://192.168.1.169:9999/repository/</url>
        <!-- 用于定位和排序构件的仓库布局类型。可以是default或者legacy -->
        <layout>default</layout>
    </repository>
</repositories>

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

【8】项目分发信息相关元素

<!--项目分发信息，在执行mvn deploy后表示要发布的位置。用于把网站部署到远程服务器或者把构件部署到远程仓库 -->
<distributionManagement>
    <!--部署项目产生的构件到远程仓库需要的信息 -->
    <repository>
        <!-- 是分配给快照一个唯一的版本号 -->
        <uniqueVersion />
        <!-- 其他配置参见repositories/repository元素 -->
        <id>nanxs-maven2</id>
        <name>nanxsmaven2</name>
        <url>file://${basedir}/target/deploy</url>
        <layout />
    </repository>
    <!--构件的快照部署的仓库。默认部署到distributionManagement/repository元素配置的仓库 -->
    <snapshotRepository>
        <uniqueVersion />
        <id>nanxs-maven2</id>
        <name>Nanxs-maven2 Snapshot Repository</name>
        <url>scp://svn.baidu.com/nanxs:/usr/local/maven-snapshot</url>
        <layout />
    </snapshotRepository>
    <!--部署项目的网站需要的信息 -->
    <site>
        <!--部署位置的唯一标识符，用来匹配站点和settings.xml文件里的配置 -->
        <id>nanxs-site</id>
        <!--部署位置的名称 -->
        <name>business api website</name>
        <!--部署位置的URL，按protocol://hostname/path形式 -->
        <url>scp://svn.baidu.com/nanxs:/var/www/localhost/nanxs-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>

项目分发信息的相关配置，在distributionManagement中设置。设置的内容包括：
（1）repository和snapshotRepository：项目产生的构建/快照构建部署的远程仓库。如果不配置
（2）snapshotRepository，快照也会部署到repository中；
（3）site：部署项目的网站需要的信息；
（4）downloadUrl：项目下载页面的URL，这是为不在仓库中的构建提供的；
（5）relocation：如果构件有了新的group ID和artifact ID（移到了新的位置），这里列出构件的新的信息；
（6）status：给出该构件在远程仓库的状态，本地项目中不能设置该元素，这是工具自动更新的。

【9】报表规范

报表规范描述的是使用mvn site命令时使用的一些配置。

<!-- 该元素描述使用报表插件产生报表的规范 -->
<!-- 当用户执行"mvn site"，这些报表就会运行，在页面导航栏能看到所有报表的链接 -->
<reporting>
    <!--网站是否排除默认的报表。这包括"项目信息"菜单中的报表。 -->
    <excludeDefaults />
    <!--所有产生的报表存放到哪里。默认值是${project.build.directory}/site。 -->
    <outputDirectory />
    <!--使用的报表插件和他们的配置。 -->
    <plugins>
        <!--plugin元素包含描述报表插件需要的信息 -->
        <plugin>
            <!--报表插件定位：groupId + artifactId + version -->
            <groupId />
            <artifactId />
            <version />

            <!--任何配置是否被传播到子项目 -->
            <inherited />
            <!--报表插件的配置 -->
            <configuration />
            <!-- 一组报表的多重规范，每个规范可能有不同的配置。一个规范（报表集）对应一个执行目标 -->
            <!-- 例如，有1~9这9个报表。1，2构成A报表集，对应一个执行目标；2，5构成B报表集，对应另一个执行目标 -->
            <reportSets>
                <!--表示报表的一个集合，以及产生该集合的配置 -->
                <reportSet>
                    <!--报表集合的唯一标识符，POM继承时用到 -->
                    <id />
                    <!--产生报表集合时，被使用的报表的配置 -->
                    <configuration />
                    <!--配置是否被继承到子POMs -->
                    <inherited />
                    <!--这个集合里使用到哪些报表 -->
                    <reports />
                </reportSet>
            </reportSets>
        </plugin>
    </plugins>
</reporting>

【10】profile配置

<!--在列的项目构建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/abcd/abcd-home/jobs/maven-guide-zh-to-production/workspace/
                </exists>
                <!--如果指定的文件不存在，则激活profile。 -->
                <missing>/usr/local/abcd/abcd-home/jobs/maven-guide-zh-to-production/workspace/
                </missing>
            </file>
        </activation>

        <!--构建项目所需要的信息。参见build元素 -->
        <build />
        <!--发现依赖和扩展的远程仓库列表。详情参见repositories元素 -->
        <repositories />
        <!--发现插件的远程仓库列表，这些插件用于构建和报表。详情参见pluginRepositories元素 -->
        <pluginRepositories />
        <!--该元素描述了项目相关的所有依赖。 详细配置参见dependencies -->
        <dependencies />
        <!--该元素包括使用报表插件产生报表的规范。当用户执行"mvn site"，这些报表就会运行。在页面导航栏能看到所有报表的链接。参见reporting元素 -->
        <reporting />
        <!--参见dependencyManagement元素 -->
        <dependencyManagement />
        <!--参见distributionManagement元素 -->
        <distributionManagement />

        <!--不赞成使用. 现在Maven忽略该元素. -->
        <reports />
        <!--模块（有时称作子项目） 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径 -->
        <modules />
        <!--参见properties元素 -->
        <properties />
    </profile>
</profiles>

【11】邮件列表和持续集成配置

<!--项目持续集成信息 -->
<ciManagement>
    <!--持续集成系统的名字，例如continuum -->
    <system />
    <!--该项目使用的持续集成系统的URL（如果持续集成系统有web接口的话）。 -->
    <url />
    <!--构建完成时，需要通知的开发者/用户的配置项。包括被通知者信息和通知条件（错误，失败，成功，警告） -->
    <notifiers>
        <!--配置一种方式，当构建中断时，以该方式通知用户/开发者 -->
        <notifier>
            <!--传送通知的途径 -->
            <type />
            <!--发生错误时是否通知 -->
            <sendOnError />
            <!--构建失败时是否通知 -->
            <sendOnFailure />
            <!--构建成功时是否通知 -->
            <sendOnSuccess />
            <!--发生警告时是否通知 -->
            <sendOnWarning />
            <!--不赞成使用。通知发送到哪里 -->
            <address />
            <!--扩展配置项 -->
            <configuration />
        </notifier>
    </notifiers>
</ciManagement>

<!--项目相关邮件列表信息 -->
<mailingLists>
    <!--该元素描述了项目相关的所有邮件列表。自动产生的网站引用这些信息。 -->
    <mailingList>
        <!--邮件的名称 -->
        <name>Demo</name>
        <!--发送邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
        <post>nanxs@123.com</post>
        <!--订阅邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
        <subscribe>nanxs@123.com</subscribe>
        <!--取消订阅邮件的地址或链接，如果是邮件地址，创建文档时，mailto: 链接会被自动创建 -->
        <unsubscribe>nanxs@123.com</unsubscribe>
        <!--你可以浏览邮件信息的URL -->
        <archive>http:/a.b.c/nanxs/demo/dev/</archive>
    </mailingList>
</mailingLists>

【12】项目的描述性信息

    <!--项目的问题管理系统(Bugzilla, Jira, Scarab,或任何你喜欢的问题管理系统)的名称和URL -->
    <issueManagement>
        <!--问题管理系统（例如jira）的名字， -->
        <system>jira</system>
        <!--该项目使用的问题管理系统的URL -->
        <url>http://jira.baidu.com/nanxs</url>
    </issueManagement>
 
    <!--项目创建年份，4位数字。当产生版权信息时需要使用这个值。 -->
    <inceptionYear />
 
    <!--项目开发者列表 -->
    <developers>
        <!--某个项目开发者的信息 -->
        <developer>
            <!--SCM里项目开发者的唯一标识符 -->
            <id>HELLO WORLD</id>
            <!--项目开发者的全名 -->
            <name>nanxs</name>
            <!--项目开发者的email -->
            <email>123@abc.com</email>
            <!--项目开发者的主页的URL -->
            <url />
            <!--项目开发者在项目中扮演的角色，角色元素描述了各种角色 -->
            <roles>
                <role>Project Manager</role>
                <role>Architect</role>
            </roles>
            <!--项目开发者所属组织 -->
            <organization>demo</organization>
            <!--项目开发者所属组织的URL -->
            <organizationUrl>http://a.b.com/nanxs</organizationUrl>
            <!--项目开发者属性，如即时消息如何处理等 -->
            <properties>
                <dept>No</dept>
            </properties>
            <!--项目开发者所在时区， -11到12范围内的整数。 -->
            <timezone>-5</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://a.b.com/nanxs/LICENSE-1.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描述了版本库和如何连接到版本库。该连接只读 -->
        <connection>scm:svn:http://a.b.com/nanxs</connection>
        <!--给开发者使用的，类似connection元素。即该连接不仅仅只读 -->
        <developerConnection>scm:svn:http://a.b.com/nanxs</developerConnection>
        <!--当前代码的标签，在开发阶段默认为HEAD -->
        <tag />
        <!--指向项目的可浏览SCM库（例如ViewVC或者Fisheye）的URL。 -->
        <url>http://a.b.com/nanxs</url>
    </scm>
 
    <!--描述项目所属组织的各种属性。Maven产生的文档用 -->
    <organization>
        <!--组织的全名 -->
        <name>demo</name>
        <!--组织主页的URL -->
        <url>http://a.b.com/nanxs</url>
    </organization>

【13】其他配置

    <!--描述了这个项目构建环境中的前提条件。 -->
    <prerequisites>
        <!--构建该项目或使用该插件所需要的Maven的最低版本 -->
        <maven />
    </prerequisites>
 
    <!--模块（有时称作子项目） 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径 -->
    <modules />
 
    <!--以值替代名称，Properties可以在整个POM中使用，也可以作为触发条件（见settings.xml中activation元素的说明） -->
    <!-格式是<name>value</name>。 -->
    <properties />
 
    <!--不推荐使用，现在Maven忽略该元素. -->
    <reports></reports>

【二】pom的dependencyManagement使用详解

【1】使用场景

通常我们把各个子项目通用的依赖都放在父项目的pom里进行管理，子项目的依赖会全部继承父项目的依赖。但是有些子项目不通用的依赖，我们可以在子项目中单独引入，但是依赖多了又会出现版本多且乱的情况，如果也想对这部分不通用的依赖进行统一的版本管理，就可以使用dependencyManagement在父项目中管理不通用的依赖。

子项目依旧单独引入想用的依赖，但是不指定版本，版本会从父项目的dependencyManagement里获取，这样不管多少子项目引用这个依赖，都能保障版本的一致。

【2】举例

在父项目的POM.xml中配置：

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>1.2.3.RELEASE</version>
        </dependency>
    </dependencies>
</dependencyManagement>

此配置即声明了spring-boot的版本信息。

子项目在引用的时候则无需指定版本信息：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

【3】使用优点

如果有多个子项目都引用同一样依赖，则可以避免在每个使用的子项目里都声明一个版本号。当想升级或切换到另一个版本时，只需要在顶层父容器里更新，而不需要逐个修改子项目；另外如果某个子项目需要另外的一个版本，只需要声明version即可。

【4】注意事项

dependencyManagement中定义的只是依赖的声明，并不实现引入，因此子项目需要显式的声明需要用的依赖。

【三】pom依赖的版本管理

   
<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <spring-boot-version>2.2.2.RELEASE</spring-boot-version>
</properties>

<dependencyManagement>
    <dependencies>
         <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot-version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

没使用版本管理之前：

使用了spring-boot-dependencies 依赖之后：

【四】pom和starter的用法

【1】什么是SpringBoot Starter

SpringBoot中的starter是一种非常重要的机制(自动化配置)，能够抛弃以前繁杂的配置，将其统一集成进starter，应用者只需要在maven中引入starter依赖，SpringBoot就能自动扫描到要加载的信息并启动相应的默认配置。starter让我们摆脱了各种依赖库的处理，需要配置各种信息的困扰。

SpringBoot会自动通过classpath路径下的类发现需要的Bean，并注册进IOC容器。SpringBoot提供了针对日常企业应用研发各种场景的spring-boot-starter依赖模块。

所有这些依赖模块都遵循着约定成俗的默认配置，并允许我们调整这些配置，即遵循“约定大于配置”的理念。

【2】怎么使用SpringBoot Starter

在我们的日常开发工作中，经常会有一些独立于业务之外的配置模块，我们经常将其放到一个特定的包下，然后如果另一个工程需要复用这块功能的时候，需要将代码硬拷贝到另一个工程，重新集成一遍，麻烦至极。如果我们将这些可独立于业务代码之外的功能配置模块封装成一个个starter，复用的时候只需要将其在pom中引用依赖即可， SpringBoot为我们完成自动装配，简直不要太爽。

【3】使用超场景

在我们的日常开发工作中，可能会需要开发一个通用模块，以供其它工程复用。SpringBoot就为我们提供这样的功能机制，我们可以把我们的通用模块封装成一个个starter，这样其它工程复用的时候只需要在pom中引用依赖即可，由SpringBoot为我们完成自动装配。

常见的使用场景如下
（1）通用模块-短信发送模块
（2）基于AOP技术实现日志切面
（3）分布式雪花ID，Long转String，解决精度问题
（4）微服务项目的数据库连接池配置
（5）微服务项目的每个模块都要访问redis数据库，每个模块都要配置redisTemplate

【4】自动加载核心注解说明

【5】短信发送模板的案例

（1）搭建SpringBoot环境

首先我们搭建一个SpringBoot项目，需要注意的是以下图片内容，有关后期导入依赖
导入一个注解处理器，用于处理 Spring Boot 配置类的注解，并生成配置属性的元数据。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

开发过程中起到以下几个重要的作用：

（1）生成配置属性的元数据: 当你使用 @ConfigurationProperties 注解来声明配置类时，spring-boot-configuration-processor 会解析该注解，并生成与配置属性相关的元数据。这些元数据包括属性的名称、类型、描述、默认值等信息。这些信息可以帮助 IDE 在开发过程中提供代码提示、自动补全和验证功能。
（2）提供配置属性的编译时验证: 使用 @ConfigurationProperties 注解时，你可以使用其他注解（如 @Value、@Valid 等）来描述配置属性的约束条件。spring-boot-configuration-processor 可以处理这些注解，并在编译时进行验证。这样，你可以在开发阶段及早发现配置属性的错误或不一致，而不是在运行时才遇到问题。
（3）简化配置类的编写: 通过使用 spring-boot-configuration-processor，你可以更轻松地编写配置类。它会自动处理 @ConfigurationProperties 注解及其相关注解，生成属性的 getter、setter 方法，并提供默认的配置文件映射规则。这样，你可以专注于定义配置属性的结构和业务逻辑，而不需要手动编写重复的代码。
（4）提升开发体验: spring-boot-configuration-processor 增强了开发工具的功能，例如在 IDE 中提供配置属性的智能提示、文档、类型检查等功能。这可以减少开发过程中的错误，并提高代码的可读性和可维护性。

（2）了解启动器与springboot官方提供的依赖有什么关系

SpringBoot官方命名方式：spring-boot-starter-{模块名}，例如：spring-boot-starter-web

自定义命名方式：{模块名}-spring-boot-starter，例如：mystarter-spring-boot-starter

（3）创建配置类Properties

/**
 * 短信服务配置类
 */
@Data
@ConfigurationProperties(prefix = "sms")
public class SmsProperties {
 
    private String key;//访问ID、即帐号
    private String secret;//访问凭证，即密钥
    private String enabled;//用于操作是否启用该模块
 
}

提供该配置类的set\get方法并且将配置文件中以sms为前缀的属性值绑定到该类对应的属性上。

（4）编写短信业务功能

ISmsService代码

public interface ISmsService {
 
    /**
     * 发送短信
     *
     * @param phone        要发送的手机号
     * @param data         要发送的内容
     */
    void send(String phone, String data);
 
}

SmsServiceImpl代码

public class SmsServiceImpl implements ISmsService {
 
    private SmsProperties smsProperties ;
 
    public SmsServiceImpl(SmsProperties smsProperties) {
        this.smsProperties=smsProperties;
    }
 
    @Override
    public void send(String phone, String data) {
        String key = smsProperties.getKey();
        String secret = smsProperties.getSecret();
        System.out.println("接入短信系统，Key=" + key + ",Secret=" + secret);
        System.out.println("短信发送，phone=" + phone + "data=" + data);
    }
 
}

（5）创建自动配置类

@Configuration
@EnableConfigurationProperties({SmsProperties.class})
@ConditionalOnProperty(prefix = "sms",name = "enable",havingValue = "true")
public class SmsConfig {
    @Autowired
    private SmsProperties smsProperties;
 
    //通过@Bean注解将其注入到Spring上下文中
    @Bean
    public ISmsService smsService(){
        //调用SMS短信服务接口时，必须通过账号和密码的方式进行调用。
        return new SmsServiceImpl(smsProperties);
    }
}

该类的作用是将这个类交与spring管理的同时也把SmsProperties这个类交给spring管理，并且将这个配置类放入spring容器让其他类可以获取到，这里还有个条件就是如果我sms.enable的值不为true，那么就都不会加入到spring中。

（1）@Configuration注解：用于定义该类是一个配置类，相当于传统Spring XML配置文件中的标签，表示其中包含有一个或多个@Bean注解的方法，用于构建bean对象并放入Spring容器中管理。
（2）@EnableConfigurationProperties({SmsProperties.class})注解：用于启用指定类型的配置属性（Configuration Properties）。在这里，它启用了SmsProperties类作为配置属性类，使得可以在SmsConfig类中通过@Autowired注解自动注入SmsProperties对象。

（3）@Bean注解：用于定义一个bean，并将其注入到Spring上下文中。在这个例子中，smsService方法返回的SmsServiceImpl对象会被纳入到Spring容器的管理范围内。

（4）@ConditionalOnProperty(prefix = “sms”, name = “enable”, havingValue = “true”)注解的作用是根据配置文件中的属性值来条件性地加载或禁用Bean。

具体而言，它基于以下三个条件进行判断：
prefix：指定属性的前缀，即在配置文件中以什么前缀开始的属性。
name：指定属性的名称，即需要判断的属性的具体名称。
havingValue：指定属性的期望值，当该属性的值与havingValue指定的值相等时，才满足条件。

（6）测试代码

我们在application.properties配置一下SmsProperties

sms：
    sms.key=j7fj8eoji92d
    sms.secret=8u8u8u

在测试类调用一下SmsServiceImpl的send方法

@SpringBootTest
class SmsApplicationTests {
 
    @Autowired
    private SmsProperties smsProperties ;
 
    @Test
    void contextLoads() {
        new SmsServiceImpl(smsProperties).send("110", "爱你");
    }
 
}

因为我们的自动装配类，启动的spring就会将本身以及配置类注入到spring中，而配置类又与配置文件也就是application.properties做了匹配，只要配置文件中填了sms.key和sms.secret就会将填写的内容注入到配置类中。

（7）其他模块导入短信模块

（1）首先需要编写spring.factories文件加载自动配置类
在resources下新建META-INF文件夹，然后创建spring.factories文件；

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.csdn.sms.Properties.SmsConfig

（2）打包安装
直接install即可
在本地仓库就会有你刚刚所打包的依赖
注意：打包的时候请注释application.properties，否则这里的配置就定死了，不会随着我们调用者的配置而改动！！！

（8）引用并测试

（1）引入依赖

<dependency>
    <groupId>com.csdn</groupId>
    <artifactId>sms</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

（2）配置application.yml

（3）如果enable不为true,那么就不会注入javabean就会报错

（4）测试模块功能

@SpringBootTest
class BootApplicationTests {
    @Autowired
    private SmsProperties smsProperties;
 
    @Test
    void contextLoads() {
        new SmsServiceImpl(smsProperties).send("15574117565","其他模块");
    }
 
}

【6】基于AOP技术的Log日志模块

（1）Log日志模块

我现有一个基于AOP的Log日志功能，这个切面定义了一个切入点webLog()，它匹配所有以Controller结尾的类的所有方法。在这些方法执行之前和之后，分别执行了doBefore()和doAfterReturning()方法，这两个方法中包含了对请求信息的记录和处理。

@Component
@Slf4j
@Aspect
public class WebLogAspect {
    @Pointcut("execution(public * com.zking..controller.*.*(..))")
    @Pointcut("execution(* *..*Controller.*(..))")
    public void webLog(){}
 
    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes)
                RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
 
        // 记录下请求内容
        log.info("开始服务:{}", request.getRequestURL().toString());
        log.info("客户端IP :{}" , request.getRemoteAddr());
        log.info("参数值 :{}", Arrays.toString(joinPoint.getArgs()));
    }
 
    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret) throws Throwable {
        // 处理完请求，返回内容
        log.info("返回值 : {}" , ret);
    }
}

我现在要用刚刚的短信发送模块中的方式，通过yml配置enable的属性来控制是否开启日志模块

（2）创建配置类Properties

@Data
@ConfigurationProperties(prefix = "weblog")
public class WebLogProperties {
    private String enable;//控制是否开启切面
}

（3）编写自动配置类

@Configuration
@EnableConfigurationProperties({WebLogProperties.class})
@ConditionalOnProperty(prefix = "weblog", value="enable",havingValue = "true")
public class WebLogAutoConfig {
 
    @Bean
    @ConditionalOnMissingBean
    public WebLogAspect webLogAspect(){
        return new WebLogAspect();
    }
}

或者直接在切面类上加上注解

@ConditionalOnProperty(prefix = "weblog", value="enable",havingValue = "true")

【五】maven的生命周期

【1】说明

（1）Maven的生命周期（lifecycle）是对构建过程进行的抽象。每个生命周期的各个环节都是由各种插件完成
1-它包含了项目的清理、初始化、编译、测试、打包、集成测试、验证、部署和站点生成等几乎所有的构建步骤。
2-它将项目整体划分为一个个阶段，按顺序依次执行，也可以指定执行到某个阶段，然后结束。
3-因为Maven的生命周期是抽象的，因此它不做任何的实际工作，全部由插件（plugin）完成。
4-maven的默认插件

（2）Maven有三个相互独立的生命周期（Maven的这三个生命周期不能看成一个整体）！！！
1-mvn clean：清理编译的项目
2-mvn compile：编译项目
3-mvn test：测试项目（运行测试类）
4-mvn package：负责将我们的项目打包
5-mvn install：将这个项目安装到仓库中

【2】Clean生命周期（Clean LifeCycle）

Clean Lifecycle 在进行真正的构建之前进行一些清理工作。Clean生命周期一共包含了三个阶段：
（1）pre-clean 执行一些需要在clean之前完成的工作
（2）clean 移除所有上一次构建生成的文件
（3）post-clean 执行一些需要在clean之后立刻完成的工作

【3】Default生命周期（Default Lifecycle）

Default Lifecycle是构建的核心部分，编译，测试，打包，部署等等，Default生命周期是Maven生命周期中最重要的一个，绝大部分工作都发生在这个生命周期中。

一些比较重要和常用的阶段：
（1）compile 编译项目的源代码
（2）install 将包安装至本地仓库，以让其它项目依赖。
（3）deploy 将最终的包复制到远程的仓库，以让其它开发人员与项目共享
（4）process-test-resources 复制并处理资源文件，至目标测试目录
（5）process-resources 复制并处理资源文件，至目标目录，准备打包
（6）test-compile 编译测试源代码
（7）test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署
（8）package 接受编译好的代码，打包成可发布的格式，如 JAR
（9）validate
（10）generate-sources
（11）process-sources
（12）generate-resources
（13）process-classes
（14）generate-test-sources
（15）process-test-sources
（16）generate-test-resources
（17）process-test-classes
（18）prepare-package
（19）pre-integration-test
（20）integration-test
（21）post-integration-test
（22）verify

【4】Site生命周期（Site Lifecycle）

Site Lifecycle 生成项目报告，站点，发布站点，站点的文档（站点信息，依赖…）。Site生命周期，生成站点信息四个阶段：
（1）pre-site 执行一些需要在生成站点文档之前完成的工作
（2）site 生成项目的站点文档
（3）post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
（4）site-deploy 将生成的站点文档部署到特定的服务器上

【六】依赖引入包的加载过程和springboot的启动过程

【七】实际的使用案例