pom.xml结构分析

最新推荐文章于 2023-11-01 10:21:16 发布

yu15050186065

最新推荐文章于 2023-11-01 10:21:16 发布

阅读量801

点赞数 1

分类专栏： maven 文章标签： java

本文链接：https://blog.csdn.net/yu15050186065/article/details/108709532

版权

maven 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

POM 项目对象模型
pom是Maven项目保存在名为的文件中的XML表示形式pom.xml。在Maven人士在场的情况下，谈论项目是从哲学的意义上讲，而不仅仅是包含代码的文件集合。一个项目包含配置文件，以及所涉及的开发人员及其扮演的角色，缺陷跟踪系统，组织和许可证，项目所在的URL，项目的依存关系以及所涉及的所有其他小部分玩以赋予代码生命。它是与该项目有关的所有事情的一站式服务。实际上，在Maven世界中，一个项目根本不需要包含任何代码，只需包含一个pom.xml。

<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">
  <modelVersion>4.0.0</modelVersion>
 
  <!-- The Basics -->
  <groupId>...</groupId>
  <artifactId>...</artifactId>
  <version>...</version>
  <packaging>...</packaging>
  <dependencies>...</dependencies>
  <parent>...</parent>
  <dependencyManagement>...</dependencyManagement>
  <modules>...</modules>
  <properties>...</properties>
 
  <!-- Build Settings -->
  <build>...</build>
  <reporting>...</reporting>
 
  <!-- More Project Information -->
  <name>...</name>
  <description>...</description>
  <url>...</url>
  <inceptionYear>...</inceptionYear>
  <licenses>...</licenses>
  <organization>...</organization>
  <developers>...</developers>
  <contributors>...</contributors>
 
  <!-- Environment Settings -->
  <issueManagement>...</issueManagement>
  <ciManagement>...</ciManagement>
  <mailingLists>...</mailingLists>
  <scm>...</scm>
  <prerequisites>...</prerequisites>
  <repositories>...</repositories>
  <pluginRepositories>...</pluginRepositories>
  <distributionManagement>...</distributionManagement>
  <profiles>...</profiles>
</project>

Maven 坐标（Coordinates）

groupId：这在组织或项目中通常是唯一的。例如，所有核心Maven工件都可以（当然，应该）位于groupId下org.apache.maven。组ID不一定使用点表示法，例如junit项目。注意，点号groupId不必与项目包含的包结构相对应。但是，遵循这种做法是一种很好的做法。当存储在存储库中时，该组的行为非常类似于Java打包结构在操作系统中的行为。点被操作系统特定的目录分隔符（例如Unix中的“ /”）替换，该分隔符成为基础存储库中的相对目录结构。在给出的示例中，该org.codehaus.mojo组位于目录中$M2_REPO/org/codehaus/mojo。
artifactId：artifactId通常是已知项目的名称。尽管groupId很重要，但组内的人很少在讨论中提及groupId（他们通常都是相同的ID，例如MojoHaus项目的groupId ：）org.codehaus.mojo。它与groupId一起创建了一个密钥，该密钥将该项目与世界上其他所有项目分开（至少，它应该:)）。与groupId一起，artifactId完全定义了存储库中工件的居住区。对于上述项目，my-project在$M2_REPO/org/codehaus/mojo/my-project。
version：这是命名难题的最后一部分。groupId:artifactId表示一个项目，但无法描述我们正在谈论的那个项目的具体化身。我们要junit:junit2018年版（4.12版）还是2007年版（3.8.2版）？简而言之：代码更改，应该对这些更改进行版本控制，并且此元素使这些版本保持一致。它还在工件的存储库中使用，以将版本彼此分开。my-project版本1.0文件位于目录结构中$M2_REPO/org/codehaus/mojo/my-project/1.0。

packaging
现在我们有了地址结构groupId:artifactId:version，再有一个标准标签可以使我们真正地了解一下：这就是项目的包装。在我们的情况下，org.codehaus.mojo:my-project:1.0上面定义的示例POM 将打包为jar。我们可以war通过声明不同的包装使其成为一个包装：

<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“ >
  ...
  <packaging>war</ packaging>
  ...
</ project>

Dependencies
POM的基础是其依赖项列表。大多数项目都依赖于其他项目来正确构建和运行。如果Maven为您所做的全部工作就是管理此列表，那么您会收获很多。Maven下载并链接了对编译以及依赖它们的其他目标的依赖。作为一个额外的好处，Maven引入了那些依赖项（传递性依赖项）的依赖项，使您的列表可以仅专注于项目所需的依赖项。

groupId，artifactId：直接依赖项的对应坐标，
version：依赖版本要求规范，用于计算依赖的有效版本。
1.0：1.0的软要求。如果没有其他版本出现在依赖关系树中，请使用1.0。
[1.0]：1.0的严格要求。仅使用1.0和1.0。
(,1.0]：任何<= 1.0版本的硬性要求。
[1.2,1.3]：严格要求1.2和1.3之间的任何版本。
[1.0,2.0)：1.0 <= x <2.0; 硬性要求介于1.0到2.0之间的任何版本。
[1.5,)：大于或等于1.5的任何版本的硬性要求。
(,1.0],[1.2,)：对于小于或等于1.0或大于或等于1.2而不是1.1的任何版本的硬性要求。多个要求用逗号分隔。
(,1.1),(1.1,)：除1.1以外的任何版本的硬性要求；例如，因为1.1具有严重漏洞。
Maven选择每个项目的最高版本，该版本可以满足该项目依赖项的所有严格要求。如果没有任何版本可以满足所有严格要求，则构建将失败。
classifier：分类器区分从相同POM构建但内容不同的工件。它是一些可选的任意字符串，如果存在，则在版本号之后附加到工件名称。例如，考虑一个提供针对Java 11的工件的项目，同时提供仍支持Java 1.8的工件。第一个工件可以配备分类器jdk11，第二个工件可以配备分类器，jdk8以便客户可以选择使用哪个分类器。
type：对应于所选的依赖类型。默认为jar。尽管它通常表示依赖项文件名的扩展名，但并非总是如此：可以将类型映射到其他扩展名和分类器。类型通常对应于所使用的包装，value(type,pom,jar,test-jar,maven-plugin,ejb,ejb-client,war,ear,rar,java-source,javadoc)
scope：该元素引用手头任务的类路径（编译和运行时，测试等），以及如何限制依赖项的可传递性。
1.compile -这是默认范围，如果未指定则使用。编译依赖项在所有类路径中均可用。此外，这些依赖项会传播到相关项目。
2 provided -这很像编译，表明JDK或容器在运行时提供它。它仅在编译和测试类路径上可用，并且不可传递。
3.runtime -此作用域指示依赖关系不是编译所必需的，而是执行所必需的。它在运行时和测试类路径中，而不在编译类路径中。
4.test -此范围表明依赖关系对于正常使用应用程序不是必需的，并且仅在测试编译和执行阶段可用。它不是可传递的。
5.system -此范围类似于，provided除了必须提供显式包含它的JAR之外，并且不会在存储库中查找。
systemPath：仅当依赖项为system才使用。否则，如果设置了此元素，构建将失败。该路径必须是绝对路径，因此建议使用属性来指定机器特定的路径（在下面有更多说明）。由于假定系统范围依赖项是先验安装的，因此Maven不会检查项目的存储库，而是会检查以确保文件存在。如果不是，Maven将使构建失败，并建议您手动下载并安装它。scopesystemproperties${java.home}/lib
optional：当此项目本身是依赖项时，将依赖项标记为可选。例如，假设有一个项目A依赖于项目B来编译一部分可能在运行时未使用的代码，那么我们可能不需要B所有项目的项目。因此，如果项目X将项目添加A为自己的依赖项，那么Maven根本不需要安装项目B。象征性地，if =>表示必需的依赖项，并且–>表示可选的，尽管A=>B在构建A时可能是这种情况，而在构建时X=>A–>B可能是这种情况X。
简而言之，optional让其他项目知道，当您使用此项目时，不需要此依赖关系即可正常工作。
排除项告诉Maven不要包括作为该依赖项的依赖项（即，其传递性依赖项）的指定项目。例如，maven-embedderrequire maven-core和我们不希望使用它依赖的其他jar，那么我们将其添加为exclusion。
import仅pom在本dependencyManagement节中的类型依赖项上支持此作用域。它指示将在指定的POM dependencyManagement部分中将依赖关系替换为有效的依赖关系列表。由于已替换它们，因此范围为的依赖项import实际上不会参与限制依赖项的可传递性。

 <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
                          https://maven.apache.org/xsd/maven-4.0.0.xsd">
      ...
      <dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
          <type>jar</type>
          <scope>test</scope>
          <optional>true</optional>
          <exclusions>
            <exclusion>
              <groupId>org.apache.maven</groupId>
              <artifactId>maven-core</artifactId>
            </exclusion>
         </exclusions>
        </dependency>
        <dependencies>
    <dependency>
      <groupId>javax.sql</groupId>
      <artifactId>jdbc-stdext</artifactId>
      <version>2.0</version>
      <scope>system</scope>
      <systemPath>${java.home}/lib/rt.jar</systemPath>
    </dependency>
  </dependencies>
        ...
      </dependencies>
      ...
    </project>

DependencyManagement：POM使用它来帮助管理其所有子级中的依赖项信息。如果my-parent项目用于dependencyManagement在上定义依赖项junit:junit:4.12，则从该继承项继承的POM可以仅通过groupId= junit和artifactId= 设置其依赖项，junit而Maven将由version父项填充该集合。这种方法的好处是显而易见的。可以在一个中央位置设置依赖项详细信息，该位置会传播到所有继承的POM。
注意，如果统一个依赖在多个parent出现，那么它将继承最近的parent中dependencyManagement的version,pom可以继承parent的dependencyManagement,也可以导入其他pom的dependencyManagement

<!--依赖管理，用于管理spring-cloud的依赖-->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Finchley.M8</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.33</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.11</version>
        </dependency>
    </dependencies>
</dependencyManagement>

Properties
属性是了解POM基础知识的最后必需的部分。Maven属性是值占位符，就像Ant中的属性一样。通过使用记号${X}，X该属性可以在POM中的任何位置访问它们的值。或者它们可以被插件用作默认值，例如：

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

它们有五种不同的样式：

env.X：在变量前加上“ env”。将返回外壳的环境变量。例如， $e n v . P A T H 包含 P A T H 环境变量。注意：虽然环境变量本身在 W i n d o w s 上不区分大小写，但属性的查找区分大小写。换句话说，尽管 W i n d o w s S h e l l 为$ {env.PATH}和${env.Path}。为了可靠起见，将环境变量的名称标准化为全部大写。
project.x：POM中带点号（.）的路径将包含相应元素的值。例如：1.0可通过访问${project.version}。
settings.x：中的点号（.）表示的路径settings.xml将包含相应元素的值。例如：false可通过访问${settings.offline}。
Java系统属性：所有可通过java.lang.System.getProperties()访问的属性都可以作为POM属性使用，例如${java.home}。
x：在POM中的元素内设置。的值value可以用作${someVar}。

Modules
具有模块的项目称为多模块或聚合器项目。模块是此POM列出的项目，并作为一个组执行。一个pom包装的项目可以通过它们列为模块，这是对目录或这些项目的POM文件的相对路径聚集了一组项目的构建。
列出模块时，您无需自己考虑模块间的依赖关系。也就是说，POM给定的模块顺序并不重要。Maven将对模块进行拓扑排序，以便始终在依赖模块之前构建依赖关系。
要查看实际的聚合，请查看基于Maven或Maven Core Plugins的 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
                          https://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
     
      <groupId>org.codehaus.mojo</groupId>
      <artifactId>my-parent</artifactId>
      <version>2.0</version>
      <packaging>pom</packaging>
     
      <modules>
        <module>my-project</module>
        <module>another-project</module>
        <module>third-project/pom-example.xml</module>
      </modules>
    </project>

Base build
build元素的另一个功能是指定项目中资源的位置。资源不是（通常）代码。它们不是经过编译的，而是要捆绑在项目中或用于各种其他原因（例如代码生成）的项目。
如项目需要一个configuration.xml文件（该文件指定容器的组件配置）才能位于META-INF/plexus目录中。尽管我们可以很容易地将该文件放入其中src/main/resources/META-INF/plexus，但我们希望给Plexus自己的目录src/main/plexus。为了使JAR插件正确捆绑资源，您可以指定类似于以下内容的资源

<build>
    <!--项目源码目录,该路径是相对于pom.xml的相对路径。-->
    <sourceDirectory/>
    <!--项目脚本源码目录，该目录和源码目录不同：绝大多数情况下，该目录下的内容 会被拷贝到输出目录,如发布脚本-->
    <scriptSourceDirectory/>
    <!--单元测试使用的源码目录，当测试项目的时候，该路径是相对于pom.xml的相对路径。-->
    <testSourceDirectory/>
    <!--被编译过的应用程序class，resource文件存放的目录。-->
    <outputDirectory/>
    <!--被编译过的测试class,resource文件存放的目录。-->
    <testOutputDirectory/>
    <!-- 项目的一系列构建扩展,它们是一系列build过程中要使用的产品，会包含在running bulid‘s classpath里面。
        他们可以开启extensions，也可以通过提供条件来激活plugins。
        简单来讲，extensions是在build过程被激活的产品--> 
    <extensions>
        <!--描述使用到的构建扩展。-->
        <extension>
            <!--构建扩展的groupId-->
            <groupId/>
            <!--构建扩展的artifactId-->
            <artifactId/>
            <!--构建扩展的版本-->
            <version/>
        </extension>
    </extensions>
    <!--如果未给出目标或阶段，则默认执行。如果给出了目标，则应按命令行中的定义（例如jar:jar）-->
    <defaultGoal/>
    <!--所有资源路径列表，例如和项目相关的属性文件，这些资源被包含在最终的打包文件里。-->
    <resources>
        <!--这个元素描述了项目相关或测试相关的所有资源路径-->
        <resource>
            <!-- 资源编译后存放的目录。该目录默认target/classes目录（例如${project.build.outputDirectory}）-->
            <targetPath/>
            <!--true,false是否使用参数值代替参数名，参数值取自pom.xml的properties元素或filter文件列表里配置的属性，pom.xml里的属性高于filter文件，也就是如果统一变量在pom.xm的properties和filter文件同时配置，那么proeperties的值将被使用-->
            <filtering/>
            <!--资源的源文件存放目录，该路径相对POM路径-->
            <directory/>
            <!--包含的文件列表，例如**/*.xml.-->
            <includes/>
            <!--排除的文件列表，例如**/*.xml-->
            <excludes/>
        </resource>
    </resources>
    <!--单元测试资源文件目录，例如和单元测试相关的属性文件。-->
    <testResources>
        <testResource>
            <targetPath/>
            <filtering/>
            <directory/>
            <includes/>
            <excludes/>
        </testResource>
    </testResources>
    <!--构建产生的所有文件存放的目录，默认target-->
    <directory/>
    <!--产生的构件的文件名，默认值是${project.artifactId}-${project.version}-->
    <finalName/>
    <!--当filtering开关打开时，使用到的过滤器属性文件列表-->
    <filters/>
    <!--子项目可以引用的默认插件信息。该插件配置项直到被引用时才会被解析或绑定到生命周期。给定插件的任何本地配置都会覆盖这里的配置-->
    <pluginManagement>
        <!--使用的插件列表 。-->
        <plugins>
            <!--plugin元素包含描述插件所需要的信息。-->
            <plugin>
                <!--插件在仓库里的group ID-->
                <groupId/>
                <!--插件在仓库里的artifact ID-->
                <artifactId/>
                <!--被使用的插件的版本（或版本范围）-->
                <version/>
                <!--true,false是否从该插件下载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>

Repository
是遵循Maven存储库目录布局的工件集合。为了成为Maven存储库工件，POM文件必须存在于结构中 $BASE_REPO/groupId/artifactId/version/artifactId-version.pom。$ BASE_REPO可以是本地（文件结构）或远程（基本URL）；其余布局将相同。存储库是收集和存储工件的地方。只要项目依赖工件，Maven就会首先尝试使用指定工件的本地副本。如果本地存储库中不存在该工件，则它将尝试从远程存储库下载。POM中的存储库元素指定要搜索的那些备用存储库。
该存储库是Maven社区最强大的功能之一。默认情况下，Maven在https://repo.maven.apache.org/maven2/中搜索中央存储库。可以在pom.xmlrepositories元素中配置其他存储库。

releases，snapshots：这些是每种工件，Release或snapshot的策略。通过这两组，POM可以更改单个存储库中每种类型的策略，而与另一种类型无关。例如，可能出于开发目的而决定仅启用快照下载。
enabled：true或者false是否针对相应的类型（releases或snapshots）启用了此存储库。
updatePolicy：此元素指定应该尝试进行更新的频率。Maven会将本地POM的时间戳（存储在存储库的maven-metadata文件中）与远程进行比较。选项包括：always，daily（默认），interval:X（其中X是分钟内的整数）或never。
checksumPolicy：当Maven将文件部署到存储库时，它还会部署相应的校验和文件。你的选择是ignore，fail或者warn在丢失或不正确的校验。
layout：在以上对存储库的描述中，提到它们都遵循相同的布局。这基本上是正确的。Maven 2引入的布局是Maven 2和3使用的存储库的默认布局。但是，Maven 1.x具有不同的布局。使用此元素可以指定是default还是legacy。

 <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
                      https://maven.apache.org/xsd/maven-4.0.0.xsd">
  ...
  <pluginRepositories>
     <repository>
      <releases>
        <enabled>false</enabled>
        <updatePolicy>always</updatePolicy>
        <checksumPolicy>warn</checksumPolicy>
      </releases>
      <snapshots>
        <enabled>true</enabled>
        <updatePolicy>never</updatePolicy>
        <checksumPolicy>fail</checksumPolicy>
      </snapshots>
      <name>Nexus Snapshots</name>
      <id>snapshots-repo</id>
      <url>https://oss.sonatype.org/content/repositories/snapshots</url>
      <layout>default</layout>
    </repository>
  </pluginRepositories>
  ...
</project>

pluginRepositories
是两种主要类型的工件的所在地。第一个是用作其他工件依赖项的工件。这些是位于中央的大部分工件。另一种工件是插件。Maven插件本身就是一种特殊的工件。因此，插件存储库可能与其他存储库分开了（尽管我还没有听到有说服力的说法）。无论如何，pluginRepositories元素块的结构与元素相似repositories。在pluginRepository每个元素指定的地方Maven可以找到新的插件远程位置。

<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
                      https://maven.apache.org/xsd/maven-4.0.0.xsd">
  ...
  <pluginRepositories>
     <repository>
      <releases>
        <enabled>false</enabled>
        <updatePolicy>always</updatePolicy>
        <checksumPolicy>warn</checksumPolicy>
      </releases>
      <snapshots>
        <enabled>true</enabled>
        <updatePolicy>never</updatePolicy>
        <checksumPolicy>fail</checksumPolicy>
      </snapshots>
      <name>Nexus Snapshots</name>
      <id>snapshots-repo</id>
      <url>https://oss.sonatype.org/content/repositories/snapshots</url>
      <layout>default</layout>
    </repository>
  </pluginRepositories>
  ...
</project>

distributionManagement
mvn install 会将项目生成的构件安装到本地Maven仓库，mvn deploy 用来将项目生成的构件分发到远程Maven仓库。本地Maven仓库的构件只能供当前用户使用，在分发到远程Maven仓库之后，所有能访问该仓库的用户都能使用你的构件。

downloadUrl：其它的Maven项目可以通过该URL下载并引用当前Maven项目的构件.
status：其它的Maven项目可以通过该URL下载并引用当前Maven项目的构件.
none：无特殊状态。这是POM的默认设置。
convert：存储库的经理将此POM从较早版本转换为Maven 2。
partner：此工件已与伙伴存储库同步。
deployed：该Maven项目的构件是通过Maven 2或Maven 3发布的，最常用的值
verified：该项目已经过验证，应视为已完成。

<project xmlns = “ http://maven.apache.org/POM/4.0.0” 
  xmlns：xsi = “ http://www.w3.org/001/XMLSchema-instance”
  xsi：schemaLocation = “ http://maven.apache.org/POM/4.0.0
                      https://maven.apache.org/xsd/maven-4.0.0.xsd“ >
  ...
  <distributionManagement>
    ...
    <downloadUrl> http://mojo.codehaus.org/my-project </ downloadUrl>
    <status> 部署</ status>
  </ distributionManagement>
  ...
</ project>
 <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
                          https://maven.apache.org/xsd/maven-4.0.0.xsd">
      ...
      <distributionManagement>
        <repository>
          <uniqueVersion>false</uniqueVersion>
          <id>corp1</id>
          <name>Corporate Repository</name>
          <url>scp://repo/maven2</url>
          <layout>default</layout>
        </repository>
        <snapshotRepository>
          <uniqueVersion>true</uniqueVersion>
          <id>propSnap</id>
          <name>Propellors Snapshots</name>
          <url>sftp://propellers.net/maven</url>
          <layout>legacy</layout>
        </snapshotRepository>
        ...
      </distributionManagement>
      ...
    </project>

distributionManagement
repository元素在POM中指定了Maven可以下载远程项目以供当前项目使用的位置和方式，而distributionManagement指定了该项目在部署时将在何处（以及如何）到达远程仓库。如果未定义snapshotRepository，则存储库元素将用于快照分发。

id，name：id用于在许多存储库中唯一标识该存储库，并且name是易于阅读的形式。
uniqueVersion：唯一版本采用true或false值来表示部署到此存储库的工件应获取唯一生成的版本号，还是使用定义为地址一部分的版本号。
url：这是存储库元素的核心。它指定了位置和用于将构建的工件（以及POM文件和校验和数据）传输到存储库的传输协议。
layout：这些类型和用途与存储库元素中定义的layout元素相同。他们是default和legacy。

<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
                          https://maven.apache.org/xsd/maven-4.0.0.xsd">
      ...
      <distributionManagement>
        <repository>
          <uniqueVersion>false</uniqueVersion>
          <id>corp1</id>
          <name>Corporate Repository</name>
          <url>scp://repo/maven2</url>
          <layout>default</layout>
        </repository>
        <snapshotRepository>
          <uniqueVersion>true</uniqueVersion>
          <id>propSnap</id>
          <name>Propellors Snapshots</name>
          <url>sftp://propellers.net/maven</url>
          <layout>legacy</layout>
        </snapshotRepository>
        ...
      </distributionManagement>
      ...
    </project>

Site
除了分发到存储库外，distributionManagement它还负责定义如何部署项目的站点和文档。

id，name，url：这些元素与元素中上面的对应元素相似distributionManagement repository。

 <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
                      https://maven.apache.org/xsd/maven-4.0.0.xsd“ >
  ...
  <distributionManagement>
    ...
    <site>
      <id> mojo.website </ id>
      <name> Mojo site</ name>
      <url> scp：//beaver.codehaus.org/home/projects/mojo/public_html/ </ url>
    </ site>
    ...
  </ distributionManagement>
  ...
</ project>

Relocation
如果构件有了新的group ID和artifact ID（构件移到了新的位置），这里列出构件的重定位信息。可能需要重新发布到新的库。可以将当前Maven项目以新的构件的形式发布到另一个库。

<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
                      https://maven.apache.org/xsd/maven-4.0.0.xsd">
  ...
  <distributionManagement>
    ...
    <relocation>
      <groupId>org.apache</groupId>
      <artifactId>my-project</artifactId>
      <version>1.0</version>
      <message>We have moved the Project under Apache</message>
    </relocation>
    ...
  </distributionManagement>
  ...
</project>

profile
POM 4.0的一项新功能是项目可以根据其构建环境来更改设置。它将根据不同条件对pom组件进行扩展，如添加一些dependency,build,repositories, profile元件同时包含一个可选的活化（轮廓触发器）和设定变化的向POM制成如果所选择的文档已被激活。例如，为测试环境构建的项目可能指向与最终部署不同的数据库。或者可以根据使用的JDK版本从不同的存储库中提取依赖项。概要文件的元素如下：

<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
                      https://maven.apache.org/xsd/maven-4.0.0.xsd">
  ...
  <profiles>
    <profile>
      <id>test</id>
      <activation>...</activation>
      <build>...</build>
      <modules>...</modules>
      <repositories>...</repositories>
      <pluginRepositories>...</pluginRepositories>
      <dependencies>...</dependencies>
      <reporting>...</reporting>
      <dependencyManagement>...</dependencyManagement>
      <distributionManagement>...</distributionManagement>
    </profile>
  </profiles>
</project>

activation
profile的activation是配置文件的关键。配置文件的强大之处在于它仅在某些情况下才可以修改基本POM。这些情况是通过activation元素指定的。
在Maven 3.2.2之前，激活已满足一个或多个指定条件。遇到第一个肯定结果时，处理将停止并将配置文件标记为活动状态。从Maven 3.2.2开始，在满足所有指定条件时发生激活。
此外activation元素不是profile激活a的唯一方法。该settings.xml文件的activeProfile元素可以包含个人资料的id。也可以在命令行后通过-P标记后的逗号分隔列表显式激活它们（例如-P codecoverage）,
要查看将在特定版本中激活的配置文件，请使用 maven-help-plugin。

jdk：activation在jdk元素中具有以Java为中心的内置检查。如果测试在与给定前缀匹配的jdk版本号下运行，则将激活此功能。在上面的示例中，1.5.0_06将匹配。也支持范围。有关受支持范围的更多详细信息，请参见maven-enforcer-plugin。
os：os元素可以定义上面显示的某些操作系统特定的属性。有关OS值的更多详细信息，请参见maven-enforcer-plugins RequireOS规则。
property：profile如果Maven检测到${name}相应name=value对的属性（可以在POM中通过取消引用的值），它将激活。
file：最后，给定的文件名可能会profile通过existence文件的或激活文件的missing。注意：此元素的插值限于${basedir}，系统属性和请求属性。

<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
                      https://maven.apache.org/xsd/maven-4.0.0.xsd">
  ...
  <profiles>
    <profile>
      <id>test</id>
      <activation>
        <activeByDefault>false</activeByDefault>
        <jdk>1.5</jdk>
        <os>
          <name>Windows XP</name>
          <family>Windows</family>
          <arch>x86</arch>
          <version>5.1.2600</version>
        </os>
        <property>
          <name>sparrow-type</name>
          <value>African</value>
        </property>
        <file>
          <exists>${basedir}/file2.properties</exists>
          <missing>${basedir}/file1.properties</missing>
        </file>
      </activation>
      ...
    </profile>
  </profiles>
</project>

Reporting
包含专门针对site生成阶段的元素。某些Maven插件可以生成在报表元素下定义和配置的报表，例如：生成Javadoc报表。就像构建元素配置插件的功能一样，报告命令也具有相同的功能。明显的区别在于，报表不是在执行块内对插件目标进行细粒度的控制，而是在reportSet元素内配置目标。和微妙的区别是，元素configuration下的插件reporting可以用作build插件configuration，尽管事实并非如此（build插件configuration不会影响reporting插件）。
可能是该reporting元素下唯一对理解该build元素的人不熟悉的项目是Boolean excludeDefaults元素。此元素表示网站生成器排除默认情况下通常生成的报告。通过site构建周期生成站点时，“ 项目信息”部分将放置在左侧菜单中，其中充满了各种报告，例如“ 项目团队”报告或“ 依赖项”列表报告。这些报告目标由生成maven-project-info-reports-plugin。作为任何其他插件，也可以通过以下更详细的方式将其删除，从而有效地关闭项目信息报告。

    <project>
      ...
      <reporting>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-project-info-reports-plugin</artifactId>
            <version>2.6</version>
            <reportSets>
              <reportSet>
                <reports><!-- select reports -->
                  <report>index</report>
                </reports>
              </reportSet>
            </reportSets>
          </plugin>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-javadoc-plugin</artifactId>
            <version>2.9</version>
            <reportSets>
              <reportSet><!-- by default, id = "default" -->
                <reports><!-- select non-aggregate reports -->
                  <report>javadoc</report>
                  <report>test-javadoc</report>
                </reports>
              </reportSet>
              <reportSet><!-- aggregate reportSet, to define in poms having modules -->
                <id>aggregate</id>
                <inherited>false</inherited><!-- don't run aggregate in child modules -->
                <reports>
                  <report>aggregate</report>
                </reports>
              </reportSet>
            </reportSets>
          </plugin>
        </plugins>
      </reporting>
      ...
    </project>

Licenses
是定义如何使用和何时使用项目（或项目的一部分）的法律文件。请注意，项目应仅列出可直接应用于此项目的许可证，而不列出适用于此项目的依赖项的许可证。Maven目前除了在已生成的站点上显示它们之外，几乎不处理这些文档。但是，有一种说法是灵活使用不同类型的许可证，迫使用户接受某些类型（非开源）项目的许可证协议。
name，url和comments：自我解释，并且以前以其他身份遇到过。建议使用SPDX标识符作为许可证名称。第四个许可证元素是：
发行：描述如何合法地分发项目。声明的两种方法是repo（可以从Maven存储库下载）或手动（必须手动安装）

<licenses>
  <license>
    <name>Apache License, Version 2.0</name>
    <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
    <distribution>repo</distribution>
    <comments>A business-friendly OSS license</comments>
  </license>
</licenses>

Organization 大多数项目由某种组织（业务，私人团体等）运行。这是设置最基本信息的地方。

 <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
                          https://maven.apache.org/xsd/maven-4.0.0.xsd">
      ...
      <organization>
        <name>Codehaus Mojo</name>
        <url>http://mojo.codehaus.org</url>
      </organization>
    </project>

Developers
所有项目都包含一个人有时创建的文件。像围绕项目的其他系统一样，与项目相关的人员也要参与项目。开发人员大概是项目核心开发的成员。请注意，尽管组织可能有许多开发人员（程序员）作为成员，但这并不是将所有人员都列为开发人员，而是仅列出直接对代码负责的人员的好形式。一个好的经验法则是，如果不应该就此项目与该人联系，则无需在此处列出他们。

id，name，email：这些对应于开发人员的ID（大概是整个组织中的某些唯一ID），开发人员的姓名和电子邮件地址。
organisation，organizationUrl：您可能已经猜到了，它们分别是开发人员的组织名称和URL。
roles：A role应指定人员负责的标准动作。就像一个人可以戴很多帽子一样，一个人可以戴多个帽子roles。
timezone：一个有效的时区ID等America/New_York或Europe/Berlin，或从UTC其中显影剂的生活，例如，数值以小时（和分数）偏移-5或+1。首选时区ID，因为它们不受DST和时区偏移的影响。有关官方时区数据库和Wikipedia中的列表，请参阅IANA。
properties：此元素是有关此人的其他任何属性的去向。例如，指向个人图像或即时Messenger句柄的链接。不同的插件可以使用这些属性，或者它们可能仅适用于阅读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
                      https://maven.apache.org/xsd/maven-4.0.0.xsd">
  ...
  <developers>
    <developer>
      <id>jdoe</id>
      <name>John Doe</name>
      <email>jdoe@example.com</email>
      <url>http://www.example.com/jdoe</url>
      <organization>ACME</organization>
      <organizationUrl>http://www.example.com</organizationUrl>
      <roles>
        <role>architect</role>
        <role>developer</role>
      </roles>
      <timezone>America/New_York</timezone>
      <properties>
        <picUrl>http://www.example.com/jdoe/pic</picUrl>
      </properties>
    </developer>
  </developers>
  ...
</project>

Contributors
贡献者就像开发人员一样，在项目的生命周期中扮演着辅助角色。也许贡献者发送了错误修复程序，或添加了一些重要的文档。一个健康的开源项目可能比开发人员拥有更多的贡献者。

<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
                      https://maven.apache.org/xsd/maven-4.0.0.xsd">
  ...
  <contributors>
    <contributor>
      <name>Noelle</name>
      <email>some.name@gmail.com</email>
      <url>http://noellemarie.com</url>
      <organization>Noelle Marie</organization>
      <organizationUrl>http://noellemarie.com</organizationUrl>
      <roles>
        <role>tester</role>
      </roles>
      <timezone>America/Vancouver</timezone>
      <properties>
        <gtalk>some.name@gmail.com</gtalk>
      </properties>
    </contributor>
  </contributors>
  ...
</project>

yu15050186065

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
pom.xml结构分析

POM 项目对象模型pom是Maven项目保存在名为的文件中的XML表示形式pom.xml。在Maven人士在场的情况下，谈论项目是从哲学的意义上讲，而不仅仅是包含代码的文件集合。一个项目包含配置文件，以及所涉及的开发人员及其扮演的角色，缺陷跟踪系统，组织和许可证，项目所在的URL，项目的依存关系以及所涉及的所有其他小部分玩以赋予代码生命。它是与该项目有关的所有事情的一站式服务。实际上，在Maven世界中，一个项目根本不需要包含任何代码，只需包含一个pom.xml。<project xmlns="
复制链接

扫一扫