# Maven pom 详解

# 什么是 POM?

就像 Make 的 MakeFile、Ant 的 build.xml 一样,Maven 项目的核心是 pom.xml。POM( Project Object Model,项目对象模型 ) 定义了项目的基本信息,用于描述项目如何构建,声明项目依赖,等等。

# 快速上手

一个完整的 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>

# POM 元素详解

# The Basics

# 坐标( Coordinate )

概述

在 Maven 中坐标是构件的唯一标识,Maven 坐标的元素包括groupIdartifactIdversionpackagingclassifier

其中 groupIdartifactIdversion 是必须的.

详解

  • groupId:组织标识.
    • 一般为:公司网址的反写+项目名
  • artifactId:项目名称.
    • 一般为:项目名-模块名
  • version:版本号
    • 一般形式为: 0.0.1-SNAPSHOT
      • 第一个 0 表示大版本号,第二个 0 表示分支版本号,第三个 0 表示小版本号
      • SNAPSHOT -- 快照版本,ALPHA -- 内侧版本,BETA -- 公测版本,RELEASE -- 稳定版本,GA -- 正式发布
  • packaging:打包的方式.
    • 如:pom, jar, maven-plugin, ejb, war, ...
  • clissifier:用来帮助定义构件输出的一些附属构件。

示例

<!-- 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">
  <modelVersion>4.0.0</modelVersion>

  <!-- 项目的全球唯一标识符,通常使用全限定的包名区分该项目和其他项目。并且构建时生成的路径也是由此生成, 如com.seyvoue.demo生成的相对路径为:/com/seyvoue/demo--> 
  <groupId>com.seyvoue.demo</groupId>
  <!-- 构件的标识符,它和 groupId 一起唯一标识一个构件。换句话说,你不能有两个不同的项目拥有同样的 artifactId 和 groupId;在某个特定的 groupId 下,artifactId也必须是唯一的。-->
  <artifactId>demo-maven</artifactId>
  <!-- 项目当前版本,格式为:主版本.次版本.增量版本-限定版本号-->
  <version>1.0.0-SNAPSHOT</version>
  <!-- 项目产生的构件类型,例如 jar、war、pom 等。插件可以创建他们自己的构件类型,所以前面列的不是全部构件类型-->
  <packaging>jar</packaging>

  ...
</project>

# 依赖( dependencies )

概述

dependencies 标签是用于导入其他依赖时使用的标签. dependencies 是个依赖包, 内部含有一个或多个 dependencie 依赖.

dependencie 标签含有 groupId artifactId version scope type optional exclusions 等标签.

其中 groupId artifactId version 是必须的.

详解

groupId artifactId version 在坐标中已经讲解过了. 不同的是, 上面是我们自己定义, 而这里是填写别人定义好的值. 引入 jar 包的 dependencie 可在 Maven 中央库 查询.

  • scope 是 dependency 下一个控制作用域的子元素,控制该依赖包在什么情况下会被加到 classpath 中。

    • scope 共 6 种,包括:compileprovidedruntimetestsystemimport
  • optional 依赖传递的控制。

    • 假设有 A, B, C 三个项目, 其依赖管辖为 B 依赖 A (B —> A), C 依赖 B (C —> B). 如果 B 的 optional 为 true. 则 C 引入 B 的时候还必须显示的引入 A 。
    • 依赖传递 optional 的默认值为 false.
  • exclusions

    • 依赖传递:如果我们的项目引用了一个 Jar 包,而该 Jar 包又引用了其他 Jar 包,那么在默认情况下项目编译时,Maven 会把直接引用和间接引用的 Jar 包都下载到本地。
      排除依赖:如果我们只想下载直接引用的 Jar包,那么需要在 pom.xml 将需要排除的 Jar 包的坐标写在其中。

    • 示例:

      <dependency>
      
        ...     
      
        <exclusions>
      
          <exclusion>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
          </exclusion>
      
        </exclusions>
      
        ...
      
      </dependency>
      

      ​```

    • 依赖冲突:若项目中多个 Jar 同时引用了相同的 Jar 时,会产生依赖冲突,但 Maven 采用了两种避免冲突的策略,因此在 Maven 中是不存在依赖冲突的。

      • 短路优先

        本项目——>A.jar——>B.jar——>X.jar 本项目——>C.jar——>X.jar 若本项目引用了 A.jar,A.jar 又引用了 B.jar,B.jar 又引用了 X.jar,并且 C.jar 也引用了X.jar。 在此时,Maven 只会引用引用路径最短的Jar。

      • 声明优先

        若引用路径长度相同时,在pom.xml中谁先被声明,就使用谁。

# 聚合(modules)

通过 <modules>...<modules> 元素可将多个模块聚合在同一个 project 下。

<project>  
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.seyvoue.account</groupId>
    <artifactId>account-aggregator</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    ...

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

# 继承(parent 和 dependencyManagement)

在聚合多个项目时,如果这些被聚合的项目中需要引入相同的 Jar,那么可以将这些 Jar 写入 父pom 中,各个子项目继承该pom即可。类似与 java 中的继承。

简单示例

  • 父级 pom.xml

    <project>
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.seyvoue.demo</groupId>
      <artifactId> demo-maven </artifactId>
      <version>1.0.0-SNAPSHOT</version>
      <!-- packageing 属性必须为 pom -->
      <packaging>pom</packaging>
    
      ...
    
      <!-- 继承自该项目的所有子项目的默认依赖信息。
    	这部分的依赖信息不会被立即解析,而是当子项目声明一个依赖(必须描述group ID和 artifact ID信息)时, 才被解析. 
    	如果 group ID 和 artifact ID 以外的一些信息没有描述,则通过group ID和artifact ID 匹配到这里的依赖,并使用这里的依赖信息。否则, 则会引入新的依赖 -->
      <dependencyManagement>
        <dependencies>
          <dependency>
                <groupId>com.github.brevy</groupId>
                <artifactId>shiro-spring</artifactId>
                <version>1.2.2</version>
          </dependency>
          ...
        </dependencies>
      </dependencyManagement>
      ...
    
    </project>
    
  • 子集 pom.xml

    <project>  
        <modelVersion>4.0.0</modelVersion> 
        ... 
        <parent>  
            <groupId>com.seyvoue.demo</groupId>  
            <artifactId> demo-maven </artifactId>  
            <version>1.0.0-SNAPSHOT</version>
            <!-- 父pom.xml文件的相对路径。相对路径允许你选择一个不同的路径。默认值是../
            pom.xml。Maven首先在构建当前项目的地方寻找父pom.xml,其次在文件系统的这个位置(relativePath位置),然后在本地仓库,最后在远程仓库寻找父项目的pom。-->
            <relativePath>...</relativePath>  
        </parent>
    
        <!-- 子 POM 若引用父 POM 在 dependencyManagement 中定义过的依赖,则只需填写 groupId 和 artifactid,其它的信息则会从父 POM 中继承 -->
        <dependencies>
            <dependency>
                 <groupId>com.github.brevy</groupId>
                 <artifactId>shiro-spring</artifactId>
            </dependency>
            ...
        </dependencies>
    
        ...
    </project>
    

Maven 可继承的 pom 元素

groupId :项目组 ID ,项目坐标的核心元素;  
version :项目版本,项目坐标的核心元素;  
description :项目的描述信息;  
organization :项目的组织信息;  
inceptionYear :项目的创始年份;  
url :项目的 url 地址  
develoers :项目的开发者信息;  
contributors :项目的贡献者信息;  
distributionManagerment :项目的部署信息;  
issueManagement :缺陷跟踪系统信息;  
ciManagement :项目的持续继承信息;  
scm :项目的版本控制信息;  
mailingListserv :项目的邮件列表信息;  
properties :自定义的 Maven 属性;  
dependencies :项目的依赖配置;  
dependencyManagement :醒目的依赖管理配置;  
repositories :项目的仓库配置;  
build :包括项目的源码目录配置、输出目录配置、插件配置、插件管理配置等;  
reporting :包括项目的报告输出目录配置、报告插件配置等。

# 属性 properties 和 &{}

简介

通过 properties 元素用户可以定义一个或多个 maven 属性,然后在 maven 的其他地方使用 ${属性名称} 的方式引用该属性,这种做法的意义在于消除重复和统一管理。比如,需要在多个地方重复声明同样的 SpringFramework 版本,现在只需要在一个地方声明就可以.

Maven 共有6种属性(根据引用的来源不同):内置属性、POM 属性、自定义属性、Settings 属性、环境变量属性等,引用方式是类似的,下面介绍其中的几种

Maven 的 properties 加载顺序:

  • <build><filters> 中的配置

  • pom.xml 中的 <properties>

  • mvn -Dproperty=value 中定义的 property

    相同 key 的 property,以最后一个文件中的配置为最终配置。

# 内置属性

两个常用内置属性:

  • ${basedir} 表示项目根目录
  • ${version} 表示项目版本
# POM 属性

用户可以使用该类属性引用 pom.xml 中对应元素的值.

${project.artifactId} 就对应了 <project><artifactId></artifactId></project> 中的值。

常用属性:

  • ${project.build.sourceDirectory} 项目的主源码目录,默认为 src/main/java
  • ${project.build.testDirectory} 项目的测试源码目录,默认为 src/test/java
  • ${project.build.directory} 项目项目构建输出目录,默认为 /target
  • ${project.outputDirectory} 项目主代码编译输出目录,默认为 /target/classes
  • ${project.build.filename} 项目打包输出文件的名称,默认为 ${project.artifactId}-${project.version}
# 自定义属性

用户可以在 pom.xml 的<properties/> 元素下定义自己的 Maven 属性。

例如:

<project>
   ...
   <properties>
       <my.group>hello</my.group>
   </properties>
   ...
</project>

使用的时候直接用 ${my.group} 即可

# settings 属性

与 POM 属性同理。maven settings.xml (一般在 localUser/.m2/settings.xml )中定义的内容,可以通过 settings 前缀进行引用。

${settings.localRepository} 表示 maven 本地仓库的路径
${settings.offline} 表示构建系统是否在离线模式下工作

# Build Settings

根据 POM 4.0.0 XSD,build 元素概念性的划分为两个部分:

  1. BaseBuild(包含 poject build 和 profile build 的公共部分)
  2. poject build 包含的一些高级特性。
<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">  
    ...  
    <!-- "Project Build" contains more elements than just the BaseBuild set -->  
    <build>...</build>  


    <profiles>  
        <profile>  
            <!-- "Profile Build" contains a subset of "Project Build"s elements -->  
            <build>...</build>  
        </profile>  
    </profiles>  
</project>

# build

# 基础属性

示例

<build>  
    <defaultGoal>install</defaultGoal>  
    <directory>${basedir}/target</directory>  
    <finalName>${artifactId}-${version}</finalName>  
    <filters>  
        <filter>filters/filter1.properties</filter>  
    </filters>  
    ...  
</build>

详解

  • defaultGoal:执行build任务时,如果没有指定目标,将使用的默认值,如:在命令行中执行mvn,则相当于执行mvn install;
  • directory:build目标文件的存放目录,默认在 ${basedir}/target目录
  • finalName:build目标文件的文件名,默认情况下为${artifactId}-${version}
  • filter:定义*.properties文件,包含一个properties列表,该列表会应用的支持filter的resources中。
    • 也就是说,定义在filter的文件中的"name=value"值对会在build时代替 ${name} 值应用到 resources 中。
    • Maven的默认filter文件夹是 ${basedir}/src/main/filters/
# resources

Maven 属性默认只有在 pom.xml 中才会被解析,对于放在 src/main/resources/ 目录下的文件,maven 是需要通过 maven-resources-plugin 插件帮忙处理的,它默认的行为是将项目资源文件复制到代码编译输出目录中,不过只要通过一些简单的 POM 配置,该插件就能解析资源文件中的 Maven 属性,即开启资源过滤。 resources(通常)不是代码,他们不被编译,但是被绑定在你的项目或者用于其它什么原因,例如代码生成。

示例

<build>  
    ...  
    <resources>  
         <resource>  
            <targetPath>META-INF/plexus</targetPath>  
            <filtering>false</filtering>  
            <directory>${basedir}/src/main/plexus</directory>  
            <includes>  
                <include>configuration.xml</include>  
            </includes>  
            <excludes>  
                <exclude>**/*.properties</exclude>  
            </excludes>  
         </resource>  
    </resources>  
    <testResources>  
        ...  
    </testResources>  
    ...  
</build>

详解

  • resources :一个 resource 元素的列表,每一个都描述与项目关联的文件是什么和在哪里;
  • targetPath :指定 build 后的 resource 存放的文件夹。该路径默认是 basedir。通常被打包在 JAR 中的 resources 的目标路径为 META-INF
  • filtering :true/false,表示为这个 resource,filter 是否激活。
  • directory :定义 resource 所在的文件夹,默认为 ${basedir}/src/main/resources
  • includes :指定作为 resource 的文件的匹配模式,用 * 作为通配符;
  • excludes :指定哪些文件被忽略,如果一个文件同时符合 includes 和 excludes,则 excludes 生效;
  • testResources :定义和 resource 类似,但只在 test 时使用,默认的 test resource 文件夹路径是 ${basedir}/src/test/resources,test resource 不被部署。
# plugins

<plugins>...<plugins/> 给出构建过程中所用到的插件,以及可以在这个元素下对插件进行配置。

示例

<build>  
 ...  
 <plugins>  
   <plugin>  
     <groupId>org.apache.maven.plugins</groupId>  
     <artifactId>maven-jar-plugin</artifactId>  
     <version>2.6</version>  
     <extensions>false</extensions>  
     <inherited>true</inherited>  
     <configuration>  
       <classifier>test</classifier>  
     </configuration>  
     <dependencies>...</dependencies>  
     <executions>
       <excution>
         <id>echodir</id>
         <goals>
           <goal>run</goal>
         </goals>
         <phase>verify</phase>
         <inherited>false</inherited>
         <configuration>
           <task>
             <echo>Build Dir: ${project.build.directory}</echo>
           </task>
         </configuration>
       </excution>
     </executions>  
   </plugin>  
 </plugins>  
</build>
  • extensions :是否加载该插件的扩展,默认false
  • inherited :该插件的 configuration 中的配置是否可以被(继承该POM的其他Maven项目)继承,默认true
  • configuration :该插件所需要的特殊配置,在父子项目之间可以覆盖或合并
  • dependencies :该插件所特有的依赖类库
  • executions :plugin 可以有多个目标,每一个目标都可以有一个分开的配置,甚至可以绑定一个 plugin 的目标到一个不同的阶段。executions 配置一个 plugin 的目标的 execution。一个 execution 有如下设置:
    • id,唯一标识
    • goals,要执行的插件的 goal(可以有多个),如 run
    • phase,目标执行的阶段,具体值看Maven的生命周期列表
    • inherited,该 execution 是否可被子项目继承
    • configuration,该 execution 的其他配置参数
# pluginManagement

<build> 中,<pluginManagement><plugins> 并列,两者之间的关系类似于 <dependencyManagement><dependencies> 之间的关系。

<pluginManagement> 中也配置 <plugin>,其配置参数与 <plugins> 中的 <plugin> 完全一致。只是,<pluginManagement> 往往出现在父项目中,其中配置的 <plugin> 往往通用于子项目。

子项目中只要在 <plugins> 中以 <plugin> 声明该插件,该插件的具体配置参数则继承自父项目中 <pluginManagement> 对该插件的配置,从而避免在子项目中进行重复配置。

# reporting

<reporting> 中的配置作用于 Maven 的 site 阶段( 见 Maven 生命周期),用于生成报表。<reporting> 中也可以配置插件 <plugins>,并通过一个 <plugin><reportSet> 为该插件配置参数。

注意,对于同时出现在 <build><reporting> 中的插件,<reporting> 中对该插件的配置也能够在构建过程中生效,即该插件的配置是 <build><reporting> 中的配置的合并。

# Environment Settings

//待完善

# SCM

//待完善

# distributionManagement

//待完善

# profiles

//待完善

# 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">
  <modelVersion>4.0.0</modelVersion>

  <!-- 项目的全球唯一标识符,通常使用全限定的包名区分该项目和其他项目。并且构建时生成的路径也是由此生成, 如com.seyvoue.demo生成的相对路径为:/com/seyvoue/demo--> 
  <groupId>com.seyvoue.demo</groupId>
  <!-- 构件的标识符,它和 groupId 一起唯一标识一个构件。换句话说,你不能有两个不同的项目拥有同样的 artifactId 和 groupId;在某个特定的 groupId 下,artifactId也必须是唯一的。-->
  <artifactId>demo-maven</artifactId>
  <!-- 项目当前版本,格式为:主版本.次版本.增量版本-限定版本号-->
  <version>1.0.0-SNAPSHOT</version>
  <!-- 项目产生的构件类型,例如 jar、war、pom 等。插件可以创建他们自己的构件类型,所以前面列的不是全部构件类型-->
  <packaging>jar</packaging>
  <!-- 项目的名称,Maven产生的文档用-->     
  <name>project-demo</name>
  <!-- 项目主页的URL,Maven产生的文档用-->
  <url>http://demo.seyvoue.com</url>
  <!-- 项目的详细描述, Maven 产生的文档用。当这个元素能够用HTML格式描述时(例如,CDATA中的文本会被解析器忽略,就可以包含HTML标签), 不鼓励使用纯文本描述。如果你需要修改产生的web站点的索引页面,你应该修改你自己的索引页文件,而不是调整这里的文档。-->
  <description>A demo of maven project to study maven.</description>



  <parent>    
    <!--被继承的父项目的构件标识符-->    
    <artifactId/>    
    <!--被继承的父项目的全球唯一标识符-->    
    <groupId/>    
    <!--被继承的父项目的版本-->    
    <version/>    
    <!-- 父项目的pom.xml文件的相对路径。相对路径允许你选择一个不同的路径。默认值是../pom.xml。Maven首先在构建当前项目的地方寻找父项目的pom,其次在文件系统的这个位置(relativePath位置),然后在本地仓库,最后在远程仓库寻找父项目的pom。-->    
    <relativePath/>    
 </parent>


  <!-- 继承自该项目的所有子项目的默认依赖信息。这部分的依赖信息不会被立即解析,而是当子项目声明一个依赖(必须描述group ID和 artifact ID信息),如果group ID和artifact ID以外的一些信息没有描述,则通过group ID和artifact ID 匹配到这里的依赖,并使用这里的依赖信息。-->    
  <dependencyManagement>    
    <dependencies>    
      <!--参见dependencies/dependency元素-->    
      <dependency>    
      ...    
      </dependency>    
    </dependencies>    
 </dependencyManagement>



  <!--该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息,请看项目依赖机制。-->     
  <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    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>




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





  <scm>     
      <!--SCM的URL,该URL描述了版本库和如何连接到版本库。欲知详情,请看SCMs提供的URL格式和列表。该连接只读。-->     
      <connection>     
          scm:svn:http://svn.baidu.com/banseon/maven/banseon/banseon-maven2-trunk(dao-trunk)      
      </connection>     
      <!--给开发者使用的,类似connection元素。即该连接不仅仅只读-->    
      <developerConnection>     
          scm:svn:http://svn.baidu.com/banseon/maven/banseon/dao-trunk      
      </developerConnection>    
      <!--当前代码的标签,在开发阶段默认为HEAD-->    
      <tag/>           
      <!--指向项目的可浏览SCM库(例如ViewVC或者Fisheye)的URL。-->     
      <url>http://svn.baidu.com/banseon</url>     
  </scm> 


  <!--项目分发信息,在执行mvn deploy后表示要发布的位置。有了这些信息就可以把网站部署到远程服务器或者把构件部署到远程仓库。-->     
  <distributionManagement>    
    <!--部署项目产生的构件到远程仓库需要的信息-->    
      <repository>    
        <!--是分配给快照一个唯一的版本号(由时间戳和构建流水号)?还是每次都使用相同的版本号?参见repositories/repository元素-->    
        <uniqueVersion/>    
        <id>banseon-maven2</id>     
        <name>banseon maven2</name>     
          <url>file://${basedir}/target/deploy</url>     
          <layout/>    
      </repository>    
      <!--构件的快照部署到哪里?如果没有配置该元素,默认部署到repository元素配置的仓库,参见distributionManagement/repository元素-->     
      <snapshotRepository>    
        <uniqueVersion/>    
        <id>banseon-maven2</id>    
          <name>Banseon-maven2 Snapshot Repository</name>    
          <url>scp://svn.baidu.com/banseon:/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/banseon:/var/www/localhost/banseon-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>

  
  
  <build>
    <!--当项目没有规定目标(Maven2 叫做阶段)时的默认值-->
    <defaultGoal>install</defaultGoal>
    <!--build目标文件的存放目录,默认在 ${basedir}/target 目录-->
    <directory>${basedir}/target</directory>
    <finalName>${artifactId}-${version}</finalName>
    <filters>
      <filter>filters/filter1.properties</filter>
    </filters>


    <!--这个元素描述了项目相关的所有资源路径列表,例如和项目相关的属性文件,这些资源被包含在最终的打包文件里。-->    
    <resources>    
      <!--这个元素描述了项目相关或测试相关的所有资源路径-->    
      <resource>    
        <!-- 描述了资源的目标路径。该路径相对target/classes目录(例如${project.build.outputDirectory})。举个例 子,如果你想资源在特定的包里(   org.apache.maven.message,你就必须该元素设置为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>


    <plugins>
      <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-release-plugin</artifactId>
          <version>2.5.3</version>
          <configuration>
              <tagBase>${git.conn}</tagBase>
              <branchBase>${git.conn}</branchBase>
              <username>${git.username}</username>
              <password>${git.password}</password>
          </configuration>
      </plugin>
      ...
    </plugins>

    <!--子项目可以引用的默认插件信息。该插件配置项直到被引用时才会被解析或绑定到生命周期。给定插件的任何本地配置都会覆盖这里的配置-->
    <pluginManagement>
      <plugins>
        ...
      </plugins>
    </pluginManagement>


  </build>
</project>

# 参考

Maven POM 详解

上次更新时间: 2020/6/13 下午7:51:31