精华内容
参与话题
问答
  • maven核心,pom.xml详解

    千次阅读 2014-03-26 17:22:13
    什么是pom?  pom作为项目对象模型。通过xml表示maven项目,使用pom.xml来实现。主要描述了项目:包括配置文件;开发者需要遵循的规则,缺陷管理系统,组织和licenses,项目的url,项目的依赖性,以及其他所有的...

    什么是pom?
        pom作为项目对象模型。通过xml表示maven项目,使用pom.xml来实现。主要描述了项目:包括配置文件;开发者需要遵循的规则,缺陷管理系统,组织和licenses,项目的url,项目的依赖性,以及其他所有的项目相关因素。

     

     

    快速察看:
    <project>
      <modelVersion>4.0.0</modelVersion>
    <!--maven2.0必须是这样写,现在是maven2唯一支持的版本-->
      <!-- 基础设置 -->
      <groupId>...</groupId>
      <artifactId>...</artifactId>
      <version>...</version>
      <packaging>...</packaging>

      <name>...</name>

      <url>...</url>
      <dependencies>...</dependencies>
      <parent>...</parent>
      <dependencyManagement>...</dependencyManagement>
      <modules>...</modules>
      <properties>...</properties>

      <!--构建设置 -->
      <build>...</build>
      <reporting>...</reporting>

      <!-- 更多项目信息 -->
      <name>...</name>
      <description>...</description>
      <url>...</url>
      <inceptionYear>...</inceptionYear>
      <licenses>...</licenses>
      <organization>...</organization>
      <developers>...</developers>
      <contributors>...</contributors>

      <!-- 环境设置-->
      <issueManagement>...</issueManagement>
      <ciManagement>...</ciManagement>
      <mailingLists>...</mailingLists> 
      <scm>...</scm>
      <prerequisites>...</prerequisites>
      <repositories>...</repositories>
      <pluginRepositories>...</pluginRepositories>
      <distributionManagement>...</distributionManagement>
      <profiles>...</profiles>
    </project>

     

    基本内容:

    POM包括了所有的项目信息

    groupId:项目或者组织的唯一标志,并且配置时生成路径也是由此生成,如org.myproject.mojo生成的相对路径为:/org/myproject/mojo

    artifactId:项目的通用名称

    version:项目的版本

    packaging:打包机制,如pom,jar,maven-plugin,ejb,war,ear,rar,par

    name:用户描述项目的名称,无关紧要的东西,可选

    url:应该是只是写明开发团队的网站,无关紧要,可选

    classifer:分类

    其中groupId,artifactId,version,packaging这四项组成了项目的唯一坐标。一般情况下,前面三项就可以组成项目的唯一坐标了。

     

    POM关系:主要为依赖,继承,合成

    依赖关系:

    <dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.0</version>
          <type>jar</type>
          <scope>test</scope>
          <optional>true</optional>
        </dependency>

     

        <dependency>

            <groupId>com.alibaba.china.shared</groupId>

            <artifactId>alibaba.apollo.webx</artifactId>

            <version>2.5.0</version>

            <exclusions>

              <exclusion>

                <artifactId>org.slf4j.slf4j-api</artifactId>

                <groupId>com.alibaba.external</groupId>

              </exclusion>

              ....

            </exclusions>

    ......

    </dependencies>

    其中groupId, artifactId, version这三个组合标示依赖的具体工程,而且 这个依赖工程必需是maven中心包管理范围内的,如果碰上非开源包,maven支持不了这个包,那么则有有三种 方法处理:

    1.本地安装这个插件install plugin

    例如:mvn install:intall-file -Dfile=non-maven-proj.jar -DgroupId=som.group -DartifactId=non-maven-proj -Dversion=1

    2.创建自己的repositories并且部署这个包,使用类似上面的deploy:deploy-file命令,

    3.设置scope为system,并且指定系统路径。

     

    dependency里属性介绍:

    type:默认为jar类型,常用的类型有:jar,ejb-client,test-jar...,可设置plugins中的extensions值为true后在增加 新的类型,

    scope:是用来指定当前包的依赖范围,maven的依赖范围

    optional:设置指依赖是否可选,默认为false,即子项目默认都继承,为true,则子项目必需显示的引入,与dependencyManagement里定义的依赖类似 。

    exclusions:如果X需要A,A包含B依赖,那么X可以声明不要B依赖,只要在exclusions中声明exclusion.

    exclusion:是将B从依赖树中删除,如上配置,alibaba.apollo.webx不想使用com.alibaba.external  ,但是alibaba.apollo.webx是集成了com.alibaba.external,r所以就需要排除掉.

     

    如果一个工程是parent或者aggregation(即mutil-module的)的,那么必须在packing赋值为pom,child工程从parent继承的包括:dependencies,developers,contributors,plugin lists,reports lists,plugin execution with matching ids,plugin configuration

    parent的使用方法如下:

    <parent> 
        <groupId>org.codehaus.mojo</groupId> 
        <artifactId>my-parent</artifactId> 
        <version>2.0</version> 
        <relativePath>../my-parent</relativePath> 
      </parent>

    relativePath是可选的,maven会首先搜索这个地址,在搜索本地远程repositories之前.

     

    dependencyManagement:是用于帮助管理chidren的dependencies的。例如如果parent使用dependencyManagement定义了一个dependencyon junit:junit4.0,那么 它的children就可以只引用 groupId和artifactId,而version就可以通过parent来设置,这样的好处就是可以集中管理 依赖的详情

     

    modules:对于多模块的project,outer-module没有必需考虑inner-module的dependencies,当列出modules的时候,modules的顺序是不重要的,因为maven会自动根据依赖关系来拓扑排序,

    modules例子如下 :

    <module>my-project</module>

    <module>other-project</module>

     

    properties:是为pom定义一些常量,在pom中的其它地方可以直接引用。

    定义方式如下:

     

    <properties>

          <file.encoding>UTF-8</file_encoding>

          <java.source.version>1.5</java_source_version>

          <java.target.version>1.5</java_target_version>

    </properties>

    使用方式 如下 :

    ${file.encoding}

     

    还可以使用project.xx引用pom里定义的其它属性:如$(project.version} 

     

    build设置:

    defaultGoal:默认的目标,必须跟命令行上的参数相同,如:jar:jar,或者与时期parse相同,例如install

    directory:指定build target目标的目录,默认为$(basedir}/target,即项目根目录下的target

    finalName:指定去掉后缀的工程名字,例如:默认为${artifactId}-${version}

    filters:用于定义指定filter属性的位置,例如filter元素赋值filters/filter1.properties,那么这个文件里面就可以定义name=value对,这个name=value对的值就可以在工程pom中通过${name}引用,默认的filter目录是${basedir}/src/main/fiters/

    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>

     

    targetPath:指定build资源到哪个目录,默认是base directory

    filtering:指定是否将filter文件(即上面说的filters里定义的*.property文件)的变量值在这个resource文件有效,例如上面就指定那些变量值在configuration文件无效。

    directory:指定属性文件的目录,build的过程需要找到它,并且将其放到targetPath下,默认的directory是${basedir}/src/main/resources

    includes:指定包含文件的patterns,符合样式并且在directory目录下的文件将会包含进project的资源文件。

    excludes:指定不包含在内的patterns,如果inclues与excludes有冲突,那么excludes胜利,那些符合冲突的样式的文件是不会包含进来的。

    testResources:这个模块包含测试资源元素,其内容定义与resources类似,不同的一点是默认的测试资源路径是${basedir}/src/test/resources,测试资源是不部署的。

     

    plugins配置:

    <plugin> 
            <groupId>org.apache.maven.plugins</groupId> 
            <artifactId>maven-jar-plugin</artifactId> 
            <version>2.0</version> 
            <extensions>false</extensions> 
            <inherited>true</inherited> 
            <configuration> 
              <classifier>test</classifier> 
            </configuration> 
            <dependencies>...</dependencies> 
            <executions>...</executions> 
          </plugin>

    extensions:true or false, 决定是否要load这个plugin的extensions,默认为true.

    inherited:是否让子pom继承,ture or false 默认为true.

    configuration:通常用于私有不开源的plugin,不能够详细了解plugin的内部工作原理,但使plugin满足的properties

    dependencies:与pom基础的dependencies的结构和功能都相同,只是plugin的dependencies用于plugin,而pom的denpendencies用于项目本身。在plugin的dependencies主要用于改变plugin原来的dependencies,例如排除一些用不到的dependency或者修改dependency的版本等,详细请看pom的denpendencies.

    executions:plugin也有很多个目标,每个目标具有不同的配置,executions就是设定plugin的目标,

    <execution> 
                <id>echodir</id> 
                <goals> 
                  <goal>run</goal> 
                </goals> 
                <phase>verify</phase> 
                <inherited>false</inherited> 
                <configuration> 
                  <tasks> 
                    <echo>Build Dir: ${project.build.directory}</echo> 
                  </tasks> 
                </configuration> 
              </execution> 

    id:标识符

    goals:里面列出一系列的goals元素,例如上面的run goal

    phase:声明goals执行的时期,例如:verify

    inherited:是否传递execution到子pom里。

    configuration:设置execution下列表的goals的设置,而不是plugin所有的goals的设置

     

    pluginManagement配置:

    pluginManagement的作用类似于denpendencyManagement,只是denpendencyManagement是用于管理项目jar包依赖,pluginManagement是用于管理plugin。与pom build里的plugins区别是,这里的plugin是列出来,然后让子pom来决定是否引用。

    例如:

    <pluginManagement> 

          <plugins> 
            <plugin> 
              <groupId>org.apache.maven.plugins</groupId> 
              <artifactId>maven-jar-plugin</artifactId> 
              <version>2.2</version> 
              <executions> 
                <execution> 
                  <id>pre-process-classes</id> 
                  <phase>compile</phase> 
                  <goals> 
                    <goal>jar</goal> 
                  </goals> 
                  <configuration> 
                    <classifier>pre-process</classifier> 
                  </configuration> 
                </execution> 
              </executions> 
            </plugin> 
          </plugins> 
        </pluginManagement> 
    子pom引用方法: 
    在pom的build里的plugins引用: 
        <plugins> 
          <plugin> 
            <groupId>org.apache.maven.plugins</groupId> 
            <artifactId>maven-jar-plugin</artifactId> 
          </plugin> 
        </plugins>

     

    build里的directories:

     

    <sourceDirectory>${basedir}/src/main/java</sourceDirectory> 
        <scriptSourceDirectory>${basedir}/src/main/scripts</scriptSourceDirectory> 
        <testSourceDirectory>${basedir}/src/test/java</testSourceDirectory> 
        <outputDirectory>${basedir}/target/classes</outputDirectory> 
        <testOutputDirectory>${basedir}/target/test-classes</testOutputDirectory>

    这几个元素只在parent build element里面定义,他们设置多种路径结构,他们并不在profile里,所以不能通过profile来修改

     

    build 里面的Extensions: 
    它们是一系列build过程中要使用的产品,他们会包含在running bulid‘s classpath里面。他们可以开启extensions,也可以通过提供条件来激活plugins。简单来讲,extensions是在build过程被激活的产品 
        <extensions> 
          <extension> 
            <groupId>org.apache.maven.wagon</groupId> 
            <artifactId>wagon-ftp</artifactId> 
            <version>1.0-alpha-3</version> 
          </extension> 
        </extensions> 

     

    reporting设置:

    reporting包含site生成阶段的一些元素,某些maven plugin可以生成reports并且在reporting下配置。例如javadoc,maven site等,在reporting下配置的report plugin的方法与build几乎一样,最不同的是build的plugin goals在executions下设置,而reporting的configures goals在reporttest。

    excludeDefaults:是否排除site generator默认产生的reports

    outputDirectory,默认的dir变成:${basedir}/target/site

    report sets:设置execution goals,相当于build里面的executions,不同的是不能够bind a report to another phase,只能够是site

    <reporting> 
        <plugins> 
          <plugin> 
            ... 
            <reportSets> 
              <reportSet> 
                <id>sunlink</id> 
                <reports> 
                  <report>javadoc</report> 
                </reports> 
                <inherited>true</inherited> 
                <configuration> 
                  <links> 
                    <link>http://java.sun.com/j2se/1.5.0/docs/api/</link> 
                  </links> 
                </configuration> 
              </reportSet> 
            </reportSets> 
          </plugin> 
        </plugins> 
      </reporting> 
    reporting里面的厄reportSets和build里面的executions的作用都是控制pom的不同粒度去控制build的过程,我们不单要配置plugins,还要配置那些plugins单独的goals。

     

    更多项目信息:

    name:项目除了artifactId外,可以定义多个名称
    description: 项目描述
    url: 项目url
    inceptionYear:创始年份

     

    Licenses
    <licenses>
      <license>
        <name>Apache 2</name>
        <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
        <distribution>repo</distribution>
        <comments>A business-friendly OSS license</comments>
      </license>
    </licenses>

    列出本工程直接的licenses,而不要列出dependencies的licenses

     

    配置组织信息:
      <organization>
        <name>Codehaus Mojo</name>
        <url>http://mojo.codehaus.org</url>
      </organization>

     

    很多工程都受到某些组织运行,这里设置基本信息

     

    配置开发者信息:

    例如:一个开发者可以有多个roles,properties是 
    <developers>
        <developer>
          <id>eric</id>
          <name>Eric</name>
          <email>eredmond@codehaus.org</email>
          <url>http://eric.propellors.net</url>
          <organization>Codehaus</organization>
          <organizationUrl>http://mojo.codehaus.org</organizationUrl>
          <roles>
            <role>architect</role>
            <role>developer</role>
          </roles>
          <timezone>-6</timezone>
          <properties>
            <picUrl>http://tinyurl.com/prv4t</picUrl>
          </properties>
        </developer>
      </developers>

     

    环境设置:

    issueManagement:bug跟踪管理系统,定义defect tracking system缺陷跟踪系统,比如有(bugzilla,testtrack,clearquest等).

    例如:

      <issueManagement> 
        <system>Bugzilla</system> 
        <url>http://127.0.0.1/bugzilla/</url> 
      </issueManagement> 

     

    仓库:

    Repositories:pom里面的仓库与setting.xml里的仓库功能是一样的。主要的区别在于,pom里的仓库是个性化的。比如一家大公司里的setting文件是公用 的,所有项目都用一个setting文件,但各个子项目却会引用不同的第三方库,所以就需要在pom里设置自己需要的仓库地址。

    repositories:要成为maven2的repository artifact,必须具有pom文件在$BASE_REPO/groupId/artifactId/version/artifactId-version.pom 
    BASE_REPO可以是本地,也可以是远程的。repository元素就是声明那些去查找的repositories 
    默认的central Maven repository在http://repo1.maven.org/maven2/

    <repositories> 
        <repository> 
          <releases> 
            <enabled>false</enabled> 
            <updatePolicy>always</updatePolicy> 
            <checksumPolicy>warn</checksumPolicy> 
          </releases> 
          <snapshots> 
            <enabled>true</enabled> 
            <updatePolicy>never</updatePolicy> 
            <checksumPolicy>fail</checksumPolicy> 
          </snapshots> 
          <id>codehausSnapshots</id> 
          <name>Codehaus Snapshots</name> 
          <url>http://snapshots.maven.codehaus.org/maven2</url> 
          <layout>default</layout> 
        </repository> 
      </repositories> 

    release和snapshots:是artifact的两种policies,pom可以选择那种政策有效。 
    enable:本别指定两种类型是否可用,true or false 
    updatePolicy:说明更新发生的频率always 或者 never 或者 daily(默认的)或者 interval:X(X是分钟数) 

    checksumPolicy:当Maven的部署文件到仓库中,它也部署了相应的校验和文件。您可以选择忽略,失败,或缺少或不正确的校验和警告。

    layout:maven1.x与maven2有不同的layout,所以可以声明为default或者是legacy(遗留方式maven1.x)。

     

    插件仓库:

    pluginRepositories:与Repositories具有类似的结构,只是Repositories是dependencies的home,而这个是plugins 的home。

     

    分发管理:

    distributionManagement :管理distribution和supporting files。 

    downloadUrl:是其他项目为了抓取本项目的pom’s artifact而指定的url,就是说告诉pom upload的地址也就是别人可以下载的地址。 
    status:这里的状态不要受到我们的设置,maven会自动设置project的状态,有效的值:none:没有声明状态,pom默认的;converted:本project是管理员从原先的maven版本convert到maven2的;partner:以前叫做synched,意思是与partner repository已经进行了同步;deployed:至今为止最经常的状态,意思是制品是从maven2 instance部署的,人工在命令行deploy的就会得到这个;verified:本制品已经经过验证,也就是已经定下来了最终版。 
    repository:声明deploy过程中current project会如何变成repository,说明部署到repository的信息。 
        <repository> 
          <uniqueVersion>false</uniqueVersion> 
          <id>corp1</id> 
          <name>Corporate Repository</name> 
          <url>scp://repo1/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> 
    id, name::唯一性的id,和可读性的name 
    uniqueVersion:指定是否产生一个唯一性的version number还是使用address里的其中version部分。true or false 
    url:说明location和transport protocol 
    layout:default或者legacy

     

    profiles:pom4.0的一个新特性就是具有根据environment来修改设置的能力

    它包含可选的activation(profile的触发器)和一系列的changes。例如test过程可能会指向不同的数据库(相对最终的deployment)或者不同的dependencies或者不同的repositories,并且是根据不同的JDK来改变的。那么结构如下: 

      <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> 
    Activation: 
    触发这个profile的条件配置如下例:(只需要其中一个成立就可以激活profile,如果第一个条件满足了,那么后面就不会在进行匹配。 
        <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>mavenVersion</name> 
              <value>2.0.3</value> 
            </property> 
            <file> 
              <exists>${basedir}/file2.properties</exists> 
              <missing>${basedir}/file1.properties</missing> 
            </file> 
          </activation> 

     

    激活profile的方法有多个:setting文件的activeProfile元素明确指定激活的profile的ID,在命令行上明确激活Profile用-P flag 参数 
    查看某个build会激活的profile列表可以用:mvn help:active-profiles 

    展开全文
  • POM文件完整解释

    千次阅读 2019-07-24 09:47:46
    POM文件完整解释 <project xmlns="http://maven.apache.org/POM/4.0.0 "       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance "     ...

    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/maven-v4_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.baidu.com/banseon</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>banseon@126.com</post>  
                <!--订阅邮件的地址或链接,如果是邮件地址,创建文档时,mailto: 链接会被自动创建-->  
                <subscribe>banseon@126.com</subscribe>   
                <!--取消订阅邮件的地址或链接,如果是邮件地址,创建文档时,mailto: 链接会被自动创建-->  
                <unsubscribe>banseon@126.com</unsubscribe>  
                <!--你可以浏览邮件信息的URL-->
                <archive>http:/hi.baidu.com/banseon/demo/dev/</archive>  
            </mailingList>  
        </mailingLists>  
        <!--项目开发者列表-->  
        <developers>  
         <!--某个项目开发者的信息-->
            <developer>  
             <!--SCM里项目开发者的唯一标识符-->
                <id>HELLO WORLD</id>   
                <!--项目开发者的全名-->
                <name>banseon</name>  
                <!--项目开发者的email-->
                <email>banseon@126.com</email>  
                <!--项目开发者的主页的URL-->
                <url/> 
                <!--项目开发者在项目中扮演的角色,角色元素描述了各种角色-->
                <roles>  
                    <role>Project Manager</role>  
                    <role>Architect</role>  
                </roles> 
                <!--项目开发者所属组织--> 
                <organization>demo</organization>  
                <!--项目开发者所属组织的URL-->
                <organizationUrl>http://hi.baidu.com/banseon</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://www.baidu.com/banseon/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.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>  
        <!--描述项目所属组织的各种属性。Maven产生的文档用-->  
        <organization>  
         <!--组织的全名-->
            <name>demo</name>   
            <!--组织主页的URL-->
            <url>http://www.baidu.com/banseon</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>x86</arch> 
         <!--激活profile的操作系统版本-->
         <version>5.1.2600</version>
        </os> 
        <!--如果Maven检测到某一个属性(其值可以在POM中通过${名称}引用),其拥有对应的名称和值,Profile就会被激活。如果值
        字段是空的,那么存在属性名称字段就会激活profile,否则按区分大小写方式匹配属性值字段-->
        <property> 
         <!--激活profile的属性的名称-->
         <name>mavenVersion</name> 
         <!--激活profile的属性的值-->
         <value>2.0.3</value>
        </property> 
        <!--提供一个文件名,通过检测该文件的存在或不存在来激活profile。missing检查文件是否存在,如果不存在则激活
        profile。另一方面,exists则会检查文件是否存在,如果存在则激活profile。-->
        <file> 
         <!--如果指定的文件存在,则激活profile。-->
         <exists>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</exists> 
         <!--如果指定的文件不存在,则激活profile。-->
         <missing>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</missing>
        </file>
       </activation> 
       <!--构建项目所需要的信息。参见build元素-->
       <build>
        <defaultGoal/>
        <resources>
         <resource>
          <targetPath/><filtering/><directory/><includes/><excludes/>
         </resource>
        </resources>
        <testResources>
         <testResource>
          <targetPath/><filtering/><directory/><includes/><excludes/>
         </testResource>
        </testResources>
        <directory/><finalName/><filters/>
        <pluginManagement>
         <plugins> 
          <!--参见build/pluginManagement/plugins/plugin元素-->
          <plugin>
           <groupId/><artifactId/><version/><extensions/>
           <executions>
            <execution>
             <id/><phase/><goals/><inherited/><configuration/>
            </execution>
           </executions>
           <dependencies> 
            <!--参见dependencies/dependency元素-->
            <dependency>
             
            </dependency>
           </dependencies>
           <goals/><inherited/><configuration/>
          </plugin>
         </plugins>
        </pluginManagement>
        <plugins> 
         <!--参见build/pluginManagement/plugins/plugin元素-->
         <plugin>
          <groupId/><artifactId/><version/><extensions/>
          <executions>
           <execution>
            <id/><phase/><goals/><inherited/><configuration/>
           </execution>
          </executions>
          <dependencies> 
           <!--参见dependencies/dependency元素-->
           <dependency>
            
           </dependency>
          </dependencies>
          <goals/><inherited/><configuration/>
         </plugin>
        </plugins>
       </build> 
       <!--模块(有时称作子项目) 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径-->
       <modules/> 
       <!--发现依赖和扩展的远程仓库列表。-->
       <repositories> 
        <!--参见repositories/repository元素-->
        <repository>
         <releases>
          <enabled/><updatePolicy/><checksumPolicy/>
         </releases>
         <snapshots>
          <enabled/><updatePolicy/><checksumPolicy/>
         </snapshots>
         <id/><name/><url/><layout/>
        </repository>
       </repositories> 
       <!--发现插件的远程仓库列表,这些插件用于构建和报表-->
       <pluginRepositories> 
        <!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素-->    
        <pluginRepository>
         <releases>
          <enabled/><updatePolicy/><checksumPolicy/>
         </releases>
         <snapshots>
          <enabled/><updatePolicy/><checksumPolicy/>
         </snapshots>
         <id/><name/><url/><layout/>
        </pluginRepository>
       </pluginRepositories> 
       <!--该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息,请看项目依赖机制。-->
       <dependencies> 
        <!--参见dependencies/dependency元素-->
        <dependency>
         
        </dependency>
       </dependencies> 
       <!--不赞成使用. 现在Maven忽略该元素.-->
       <reports/>    
       <!--该元素包括使用报表插件产生报表的规范。当用户执行“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://192.168.1.169:9999/repository/</url>  
                <!--用于定位和排序构件的仓库布局类型-可以是default(默认)或者legacy(遗留)。Maven 2为其仓库提供了一个默认的布局;然而,Maven 1.x有一种不同的布局。我们可以使用该元素指定布局是default(默认)还是legacy(遗留)。-->
                <layout>default</layout>            
            </repository>  
        </repositories> 
        <!--发现插件的远程仓库列表,这些插件用于构建和报表-->
        <pluginRepositories> 
         <!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素-->
      <pluginRepository>
       
      </pluginRepository>
     </pluginRepositories> 
        
        <!--该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息,请看项目依赖机制。-->  
        <dependencies>  
            <dependency>
       <!--依赖的group ID-->
                <groupId>org.apache.maven</groupId>  
                <!--依赖的artifact ID-->
                <artifactId>maven-artifact</artifactId>  
                <!--依赖的版本号。 在Maven 2里, 也可以配置成版本号的范围。-->
                <version>3.8.1</version>  
                <!--依 赖类型,默认类型是jar。它通常表示依赖的文件的扩展名,但也有例外。一个类型可以被映射成另外一个扩展名或分类器。类型经常和使用的打包方式对应,尽 管这也有例外。一些类型的例子:jar,war,ejb-client和test-jar。如果设置extensions为 true,就可以在 plugin里定义新的类型。所以前面的类型的例子不完整。-->
                <type>jar</type> 
                <!--依赖的分类器。分类器可以区分属于同一个POM,但不同构建方式的构件。分类器名被附加到文件名的版本号后面。例如,如果你想要构建两个单独的构件成JAR,一个使用Java 1.4编译器,另一个使用Java 6编译器,你就可以使用分类器来生成两个单独的JAR构件。-->
                <classifier></classifier> 
                <!--依赖范围。在项目发布过程中,帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。 
                    - compile :默认范围,用于编译   
                    - provided:类似于编译,但支持你期待jdk或者容器提供,类似于classpath   
                    - runtime: 在执行时需要使用   
                    - test:    用于test任务时使用   
                    - system: 需要外在提供相应的元素。通过systemPath来取得   
                    - systemPath: 仅用于范围为system。提供相应的路径   
                    - optional:   当项目自身被依赖时,标注依赖是否传递。用于连续依赖时使用-->  
                <scope>test</scope>     
                <!--仅供system范围使用。注意,不鼓励使用这个元素,并且在新的版本中该元素可能被覆盖掉。该元素为依赖规定了文件系统上的路径。需要绝对路径而不是相对路径。推荐使用属性匹配绝对路径,例如${java.home}。--> 
                <systemPath></systemPath>  
                <!--当计算传递依赖时, 从依赖构件列表里,列出被排除的依赖构件集。即告诉maven你只依赖指定的项目,不依赖项目的依赖。此元素主要用于解决版本冲突问题--> 
                <exclusions>
                 <exclusion>  
                        <artifactId>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>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> 
        <!--以值替代名称,Properties可以在整个POM中使用,也可以作为触发条件(见settings.xml配置文件里activation元素的说明)。格式是<name>value</name>。-->
        <properties/>
    </project>
    

    转载自:https://blog.csdn.net/weirongneng/article/details/84481068

    展开全文
  • 史上最全的 pom.xml 文件详解

    千次阅读 多人点赞 2019-02-25 15:25:07
    一、什么是POM Project Object Model,项目对象模型。通过xml可扩展标记语言(EXtensible Markup Language)格式保存的pom.xml文件。作用类似ant的build.xml文件,功能更强大。该文件用于管理:源代码、配置文件、...

    一、什么是POM

    Project Object Model,项目对象模型。通过xml可扩展标记语言(EXtensible Markup Language)格式保存的pom.xml文件。作用类似ant的build.xml文件,功能更强大。该文件用于管理:源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目授权、项目的url、项目的依赖关系等等。
    一个完整的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/maven-v4_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>
    

    二、基本设置

    1、头信息

    <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"   -->
    
    字段 说明
    xmlns 命名空间,类似包名,因为xml的标签可自定义,需要命名空间来
    xmlns:xsi xml遵循的标签规范
    xsi:schemaLocation 用来定义xmlschema的地址,也就是xml书写时需要遵循的语法

    粘来即用,详细说明可以参考这篇博文 《XML文档中的xmlns、xmlns:xsi和xsi:schemaLocation理解》

    2、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
                          http://maven.apache.org/maven-v4_0_0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>com.funtl</groupId>
        <artifactId>itoken-dependencies</artifactId>
        <version>1.0.0</version>
        <packaging>war</packaging>
        <name>itoken dependencies</name>
        <url>www.funtl.com</url>
    </project>
    
    字段 说明
    modelVersion 声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变,虽然如此,但它仍然是必不可少的,
    这是为了当Maven引入了新的特性或者其他模型变更的时候,确保稳定性。
    groupId 公司或者组织的唯一标志,并且配置时生成的路径也是由此生成,
    如com.winner.trade,maven会将该项目打成的jar包放本地路径:/com/winner/trade
    artifactId 本项目的唯一ID,一个groupId下面可能多个项目,就是靠artifactId来区分的
    version 本项目目前所处的版本号
    packaging 打包类型,可取值:pom , jar , maven-plugin , ejb , war , ear , rar , par等等
    name 项目的名称, Maven产生的文档用,可省略
    url 项目主页的URL, Maven产生的文档用 ,可省略

    等等还好好多属性,具体参见博客末尾的 完整版pom.xml
    其中groupId,artifactId,version,packaging这四项组成了项目的唯一坐标。一般情况下,前面三项就足矣。

    3、POM之间的关系

    主要用于POM文件的复用和依赖。

    a)依赖关系:依赖关系列表

    该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。

     <dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.0</version>
          <scope>test</scope>
          <optional>true</optional>
          <exclusions>
          	<exclusion>  
              <groupId>xxx</groupId>
              <artifactId>xxx</artifactId>
            </exclusion>
          </exclusions>
        </dependency></dependencies>
    
    字段 说明
    groupId 依赖项的组织名
    artifactId 依赖项的子项目名
    version 依赖项的版本
    type 依赖类型一般省略,默认类型是jar,其他还有jar,war,ejb-client和test-jar
    scope 依赖项的适用范围 ,包括compile,provided,runtime,test,system,exclusions [^1]
    optional 可选依赖,如果你在项目B中把C依赖声明为可选,你就需要在依赖于B的项目(例如项目A)中显式的引用对C的依赖。
    exclusions 排除项目中的依赖冲突时使用,不依赖该项目

    [^1]scope 依赖项的适用范围

    • compile,缺省值,适用于所有阶段,会随着项目一起发布。
    • provided,类似compile,期望JDK、容器或使用者会提供这个依赖。如servlet.jar。
    • runtime,只在运行时使用,如JDBC驱动,适用运行和测试阶段。
    • test,只在测试时使用,用于编译和运行测试代码。不会随项目发布。
    • system,类似provided,需要显式提供包含依赖的jar,Maven不会在Repository中查找它。
    • optional: 当项目自身被依赖时,标注依赖是否传递。用于连续依赖时使用

    我们知道,maven的依赖关系是有传递性的。如:A–>B,B–>C。但有时候,项目A可能不是必需依赖C,因此需要在项目A中排除对A的依赖。在maven的依赖管理中,有两种方式可以对依赖关系进行,分别是可选依赖(Optional Dependencies)以及依赖排除(Dependency Exclusions)

    可选依赖 Optional Dependencies

    当一个项目A依赖另一个项目B时,项目A可能用到了项目B很少一部分功能,此时就可以在A中配置对B的可选依赖。举例来说,项目B类似hibernate,它支持对mysql、oracle等各种数据库的支持,但是在引用这个项目时,我们可能只用到其对mysql的支持,此时就可以在A项目中配置对项目B的可选依赖。

    配置可选依赖的原因:1、节约磁盘、内存等空间;2、避免license许可问题;3、避免类路径问题,等等。
    

    示例:

    <project>
      ...
      <dependencies>
        <!-- declare the dependency to be set as optional -->
        <dependency>
          <groupId>sample.ProjectB</groupId>
          <artifactId>Project-B</artifactId>
          <version>1.0</version>
          <scope>compile</scope>
          <optional>true</optional> <!-- value will be true or false only -->
        </dependency>
      </dependencies>
    </project>
    

    假设以上配置是项目A的配置,即:Project-A <-- Project-B。在编译项目A时,是可以正常通过的。

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

    依赖排除 Dependency Exclusions

    第一种情况

    当一个项目A依赖项目B,而项目B同时依赖项目C,如果项目A中因为各种原因不想引用项目C,在配置项目B的依赖时,可以排除对C的依赖。

    示例(假设配置的是A的pom.xml,依赖关系为:A<–B<–C):

    <project>
      ...
      <dependencies>
        <dependency>
          <groupId>sample.ProjectB</groupId>
          <artifactId>Project-B</artifactId>
          <version>1.0</version>
          <scope>compile</scope>
          <exclusions>
            <exclusion>  <!-- declare the exclusion here -->
              <groupId>sample.ProjectC</groupId>
              <artifactId>Project-C</artifactId>
            </exclusion>
          </exclusions> 
        </dependency>
      </dependencies>
    </project>
    

    当然,对于多重依赖,配置也很简单,参考如下示例:

    Project-A
    -> Project-B
    -> Project-D
    -> Project-E <! – This dependency should be excluded -->
    -> Project-F
    -> Project C
    A对于E相当于有多重依赖,我们在排除对E的依赖时,只需要在配置B的依赖中进行即可:

    <project>
      <modelVersion>4.0.0</modelVersion>
      <groupId>sample.ProjectA</groupId>
      <artifactId>Project-A</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>jar</packaging>
      ...
      <dependencies>
        <dependency>
          <groupId>sample.ProjectB</groupId>
          <artifactId>Project-B</artifactId>
          <version>1.0-SNAPSHOT</version>
          <exclusions>
            <exclusion>
              <groupId>sample.ProjectE</groupId> <!-- Exclude Project-E from Project-B -->
              <artifactId>Project-E</artifactId>
            </exclusion>
          </exclusions>
        </dependency>
      </dependencies>
    </project>
    
    第二种情况

    如果我们的项目有两个依赖项:A & B,而且A和B同时依赖了C,但不是同一个版本。那么我们怎么办呢?

    1 添加检查插件
    <reporting>
    	<plugins>
    		<plugin>
    			<groupId>org.apache.maven.plugins</groupId>
    			<artifactId>maven-project-info-reports-plugin</artifactId>
    		</plugin>
    	</plugins>
    </reporting>
    

    然后运行:mvn project-info-reports:dependencies,来查看依赖项报告。

    2 去除依赖项
    <dependency>
          <groupId>org.apache.struts</groupId>
          <artifactId>struts2-core</artifactId>
          <version>${struts.version}</version>
          <exclusions>
              <exclusion>
                  <groupId>org.freemarker</groupId>
                  <artifactId>freemarker</artifactId>
              </exclusion>
          </exclusions>
    </dependency>
    

    b)继承关系:继承其他pom.xml配置的机制。

    在我们已经聚合的项目中,有很多重复的配置,有相同的groupId和version,有相同的spring-core, spring-beans, spring-context和juit依赖,造成大量的浪费也会引发问题,所以如何使用继承机制来统一配置这些重复的信息,做到”一处声明,处处使用“呢?

    思路:创建POM的父子结构,在父POM中声明一些配置供子POM继承、

    父 pom.xml

    <project>
      [...]
      <dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.4</version>
          <scope>test</scope>
        </dependency>
      </dependencies>
      [...]
    </project>
    

    子 pom.xml

    [...]
    <parent>
      <groupId>com.devzuz.mvnbook.proficio</groupId>
      <artifactId>proficio</artifactId>
      <version>1.0-SNAPSHOT</version>
      <relativePath>../ParentProject/pom.xml</relativePath>   
    </parent>
    [...]
    

    relativePath默认为…/pom.xml,如果路径不一样需要手动指定

    c)聚合关系:用于将多个maven项目聚合为一个大的项目。

    我们想要一次构建两个项目,而不是到两个模块的目录下分别执行mvn命令 – Maven的聚合就是为该需求服务的。

    为了能够使用一条命令就能构建account-email和account-persist两个模块,需要创建一个额外的名为account-aggregator的模块,然后通过该模块构建整个项目的所有模块。

    account-aggregator也有它自己的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.maven-v4_0_0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>com.park.mvnDemo.account</groupId>
        <artifactId>account-aggregator</artifactId>
        <version>1.0.0-SNAPSHOT</version>
        <packaging>pom</packaging>
        <name>Account Aggregator</name>
        <modules>
            <module>account-email</module>
            <module>account-persist<module>
        </modules>
    </project>
    

    在上面的xml文件中,packaging的方式为pom。对于聚合模块来说, 其打包方式必须为pom,否则无法构建!

    modules: 这里是实现聚合的最核心的配置,可以声明任意数量的module元素来实现元素的聚合;
    其中,每个module的值为当前聚合POM的相对路径;
    如:
    当前的聚合POM位于D:\m2\code\account-aggregator\
    另有一个项目A位于D:\m2\code\account-aggregator\account-email\
    一个项目B位于D:\m2\code\-aggregatoraccount\account-persist\
    与上面聚合pom内的的module值相对应。也可写成/account-email
    为了方便用户构建项目,通常将聚合模块放在项目目录的最顶层,其他模块则作为聚合模块的子目录存在。
    当然,你也可以手动指定路径

    4、 Maven的六类属性

    1) maven内置属性

    主要有两个常用内置属性:

    属性 说明
    ${basedir} 项目的根目录(包含pom.xml文件的目录)
    ${version} 项目版本

    2) POM属性

    用户可以使用该属性引用POM文件中对应元素的值,常用的POM属性包括:

    属性 说明
    ${project.build.sourceDirectory} 项目的主源码目录,默认为 src/main/java
    ${project.build.testSourceDirectory} 项目的测试源码目录,默认为 src/test/java
    ${project.build.directory} 项目构件输出目录,默认为 target/
    ${project.outputDirectory} 项目主代码编译输出目录,默认为 target/classes/
    ${project.testOutputDirectory} 项目测试代码编译输出目录,默认为 target/test-classes/
    ${project.groupId} 项目的 groupId
    ${project.artifactId} 项目的 artifactId
    ${project.version} 项目的 version,与${version}等价
    ${project.build.fianlName} 项目打包输出文件的名称,默认为"${project.artifactId} - ${project.version}"

    3) 自定义属性

    用户可以在POM的元素下自定义Maven属性

     <!--配置依赖版本-->
     <properties>
         <!-- Environment Settings -->
         <java.version>1.8</java.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    
         <!-- Spring cloud Settings   -->
         <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
         <spring-boot-admin.version>2.0.1</spring-boot-admin.version>
         <zipkin.version>2.10.1</zipkin.version>
     </properties>
    

    然后在pom文件中通过${zipkin.version}来使用他们

    dependencies 和 dependencyManagement 标签

    在通常情况下,由于我们的模块很多,我们需要一个itoken-denpendencies的项目来管理子项目的公共的依赖。

    为了项目的正确运行,必须让所有的子项目使用依赖项的统一版本,必须确保应用的各个项目的依赖项和版本一致,才能保证测试的和发布的是相同的结果。

    在我们项目顶层的POM文件中,我们会看到dependencyManagement元素。通过它元素来管理jar包的版本,让子项目中引用一个依赖而不用显示的列出版本号。

    结合maven的自定义属性,我们来看看项目中的具体应用:

    itoken-denpendencies 中的 pom.xml

    在父项目中用dependencyManagement声明依赖的版本,需要

    <dependencyManagement>
    	<dependencies>
    	    <!--spring cloud-->
    	    <dependency>
    	        <groupId>org.springframework.cloud</groupId>
    	        <artifactId>spring-cloud-dependencies</artifactId>
    	        <version>${spring-cloud.version}</version>
    	        <type>pom</type>
    	        <scope>import</scope>
    	    </dependency>
    	    <!--zipkin-->
    	    <dependency>
    	        <groupId>io.zipkin.java</groupId>
    	        <artifactId>zipkin</artifactId>
    	        <version>${zipkin.version}</version>
    	    </dependency>
    	    [...]
    	<dependencies>
    </dependencyManagement>            
    
    itoken-zipkin 中的 pom.xml

    在子项目中,Maven会沿着父子层次向上走,直到找到一个拥有dependencyManagement元素的项目,然后它就会使用在这个dependencyManagement元素中指定的版本号。

    <dependencies>
        <!--spring cloud-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
        </dependency>
        <!--zipkin-->
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin</artifactId>
        </dependency>
        [...]
    <dependencies>
    
    需要注意的是:

    dependencyManagement里只是声明依赖,并不实现引入。如果不在子项目中声明依赖,是不会从父项目中继承下来的;只有在子项目中写了该依赖项,并且没有指定具体版本,才会从父项目中继承该项,并且version和scope都读取自父pom。

    如果子项目中指定了版本号,那么会使用子项目中指定的jar版本。

    4) Settings属性

    用户使用${settings.}开头的属性可以引用 maven settings.xml 文件中XML元素的值

    属性 说明
    settings.localRepository 自定义本地库路径,默认在 ${user.home}/.m2中;
    settings.interactiveMode 交互模式,Maven是否应该尝试与用户输入交互,默认是true,如果不是false。
    settings.offline 是否每次编译都去查找远程中心库, 如果此构建系统应以离线模式运行,则为true,默认为false。由于网络设置或安全原因,此元素对于构建无法连接到远程存储库的服务器非常有用。
    settings.pluginGroups 插件组,例如org.mortbay.jetty;

    5) Java系统属性

    所有Java系统属性都可以使用Maven属性引用,这里列举一些常用的java系统属性

    属性 说明
    java.version Java 运行时环境版本
    java.vendor Java 运行时环境供应商
    java.vendor.url Java 供应商的 URL
    java.home Java 安装目录
    java.vm.specification.version Java 虚拟机规范版本
    java.vm.specification.vendor Java 虚拟机规范供应商
    java.vm.specification.name Java 虚拟机规范名称
    java.vm.version Java 虚拟机实现版本
    java.vm.vendor Java 虚拟机实现供应商
    java.vm.name Java 虚拟机实现名称
    java.specification.version Java 运行时环境规范版本
    java.specification.vendor Java 运行时环境规范供应商
    java.specification.name Java 运行时环境规范名称
    java.class.version Java 类格式版本号
    java.class.path Java 类路径
    java.library.path 加载库时搜索的路径列表
    java.io.tmpdir 默认的临时文件路径
    java.compiler 要使用的 JIT 编译器的名称
    java.ext.dirs 一个或多个扩展目录的路径
    os.name 操作系统的名称
    os.arch 操作系统的架构
    os.version 操作系统的版本
    file.separator 文件分隔符(在 UNIX 系统中是“/”)
    path.separator 路径分隔符(在 UNIX 系统中是“:”)
    line.separator 行分隔符(在 UNIX 系统中是“/n”)
    user.name 用户的账户名称
    user.home 用户的主目录
    user.dir 用户的当前工作目录

    6) 环境变量属性

    所有环境变量都可以使用以env.开头的Maven属性引用
    ${env.JAVA_HOME}表示JAVA_HOME环境变量的值;

    5、构建设置

    <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/maven-v4_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中的主要标签:Resources和Plugins。

    Resources:资源文件管理

    用于引用或排除资源文件

    <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>
    
    属性 说明
    targetPath 资源的打包路径,该路径相对target/classes目录
    filtering 主要用来替换项目中的资源文件(* .xml、* . properties)当中的$ {…}属性值如$ {db.url}
    如果filtering=tru 在resources目录中存在资源文件并且 配置了db.url=aaa的话,
    在项目编译的时候,就会自动的把pom文件中的${db.url}替换为aaa
    directory 描述存放资源的目录,该路径相对POM路径
    includes 包含的模式列表,例如**/*.xml
    excludes 排除的模式列表,例如**/*.xml

    Plugins:设置构建的插件

    为什么我们需要插件?
    1.需要某个特殊的 jar包,但是有不能直接通过maven依赖获取,或者说在其他环境的maven仓库内不存在,那么如何将我们所需要的jar包打入我们的生产jar包中。
    2.某个jar包内部包含的文件是我们所需要的,或者是我们希望将它提取出来放入指定的位置 ,那么除了复制粘贴,如何通过maven插件实现呢。

    plugins 和 pluginmanagement

    maven 通过 pluginspluginmanagement 来管理插件,类似 dependenciesdependencyment
    但需要注意的是,pluginspluginmanagement 隶属于 build 标签下,而不是最外层的 project

    在父项目中声明插件和版本信息

    同样pluginmanagement也不会直接引入插件

    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <attach>true</attach>
                </configuration>
                <executions>
                    <execution>
                        <phase>compile</phase>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </pluginManagement>
    
    在子项目中引入插件

    同样,子项目继承父项目的plugin设置,并可以自由定义

    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>
        </plugin>
    </plugins>
    

    6、maven仓库配置

    什么是Maven仓库?
    Maven仓库就是放置所有JAR文件(WAR,ZIP,POM等等)的地方,所有Maven项目可以从同一个Maven仓库中获取自己所需要的依赖JAR,这节省了磁盘资源。此外,由于Maven仓库中所有的JAR都有其自己的坐标,该坐标告诉Maven它的组ID,构件ID,版本,打包方式等等,因此Maven项目可以方便的进行依赖版本管理。你也不在需要提交JAR文件到SCM仓库中,你可以建立一个组织层次的Maven仓库,供所有成员使用。
    简言之,Maven仓库能帮助我们管理构件(主要是JAR)。

    maven寻找仓库的顺序大致可以理解为:

    • 1,在本地仓库中寻找,如果没有则进入下一步。
    • 2,在全局应用的私服仓库中寻找,如果没有则进入下一步。
    • 3,在项目自身的私服仓库中寻找,如果没有则进入下一步。
    • 4,在中央仓库中寻找,如果没有则终止寻找。

    补充:
    1,如果在找寻的过程中,如果发现该仓库有镜像设置,则用镜像的地址代替。
    2,如果仓库的id设置成“central”,则该配置会覆盖maven默认的中央仓库配置。

    本地仓库

    Maven缺省的本地仓库地址为${user.home}/.m2/repository 。也就是说,一个用户会对应的拥有一个本地仓库。
    你也可以自定义本地仓库的位置,修改${user.home}/.m2/settings.xml

      <!-- localRepository
       | The path to the local repository maven will use to store artifacts.
       |
       | Default: ${user.home}/.m2/repository-->
      <localRepository>D:/.m2/repository</localRepository>
    

    还可以在运行时指定本地仓库位置:

    mvn clean install -Dmaven.repo.local=/home/juven/myrepo/
    

    中央仓库

    3.xxx版本之后,在: maven安装目录下的:/lib/maven-model-builder-${version}.jar
    打开该文件,能找到超级POM\org\apache\maven\model\pom-4.0.0.xml,它是所有Maven POM的父POM,所有Maven项目继承该配置,你可以在这个POM中发现如下配置:

      <repositories>
        <repository>
          <id>central</id>
          <name>Central Repository</name>
          <url>https://repo.maven.apache.org/maven2</url>
          <layout>default</layout>
          <snapshots>
            <enabled>false</enabled>
          </snapshots>
        </repository>
      </repositories>
    

    中央仓库的id为central,远程url地址为http://repo.maven.apache.org/maven2,它关闭了snapshot 快照版本构件下载的支持。

    在POM中配置远程仓库

    前面我们看到超级POM配置了ID为central的远程仓库,我们可以在POM中配置其它的远程仓库。这样做的原因有很多,比如你有一个局域网的远程仓库,使用该仓库能大大提高下载速度,继而提高构建速度,也有可能你依赖的一个jar在central中找不到,它只存在于某个特定的公共仓库,这样你也不得不添加那个远程仓库的配置。
    这里我配置一个远程仓库指向中央仓库的中国镜像:

    <project>
    ...
      <repositories>
        <repository>
          <id>maven-net-cn</id>
          <name>Maven China Mirror</name>
          <url>http://maven.net.cn/content/groups/public/</url>
          <releases>
            <enabled>true</enabled>
          </releases>
          <snapshots>
            <enabled>false</enabled>
          </snapshots>
        </repository>
      </repositories>
      <pluginRepositories>
        <pluginRepository>
          <id>maven-net-cn</id>
          <name>Maven China Mirror</name>
          <url>http://maven.net.cn/content/groups/public/</url>
          <releases>
            <enabled>true</enabled>
          </releases>
          <snapshots>
            <enabled>false</enabled>
          </snapshots>    
        </pluginRepository>
      </pluginRepositories>
    ...
    </project>
    

    我们先看一下的配置,你可以在它下面添加多个 ,每个都有它唯一的ID,一个描述性的name,以及最重要的,远程仓库的url。
    此外,

    <releases><enabled>true</enabled></releases>   告诉Maven可以从这个仓库下载releases版本的构件
    
    <snapshots><enabled>false</enabled></snapshots>告诉Maven不要从这个仓库下载snapshot版本的构件。
    

    禁止从公共仓库下载snapshot构件是推荐的做法,因为这些构件不稳定,且不受你控制,你应该避免使用。当然,如果你想使用局域网内组织内部的仓库,你可以激活snapshot的支持。

    文章结束,等待后续更详细的补充······

    展开全文
  • Maven之(七)pom.xml配置文件详解

    万次阅读 多人点赞 2016-05-24 09:53:25
    鉴于CSDN对**版权保护的不作为**以及落后的运营手段,本博客将于近期关闭,并清空全部文章。 原有文章将会经过再次的校对、整理,转移至本人在**简书**的[博客空间](https://www.jianshu.com/u/3ec23ef9a408)... ...


    鉴于CSDN对**版权保护的不作为**以及落后的运营手段,本博客将于近期关闭,并清空全部文章。

    原有文章将会经过再次的校对、整理,转移至本人在**简书**的[博客空间](https://www.jianshu.com/u/3ec23ef9a408)。

    展开全文
  • Maven pom.xml 配置详解

    万次阅读 多人点赞 2013-08-01 00:08:04
    什么是pompom作为项目对象模型。通过xml表示maven项目,使用pom.xml来实现。主要描述了项目:包括配置文件;开发者需要遵循的规则,缺陷管理系统,组织和licenses,项目的url,项目的依赖性,以及其他所有的项目...
  • pom大全

    2019-02-26 17:43:00
    springboot集合 父模块 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2...
  • POM 标签大全详解

    2019-06-09 12:59:32
    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.0http://maven.apache.org/maven-v4_0...
  • NULL 博文链接:https://bruce008.iteye.com/blog/1668348
  • pom文件详解

    万次阅读 2018-10-23 14:46:10
    pom文件详解 父级常用POM &lt;!-- 声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变,虽然如此,但它仍然是必不可少的, 这是为了当Maven引入了新的特性或者其他模型变更的时候,确保稳定性。 --&...
  • pom文件报错

    2020-02-21 22:07:37
    背景:eclipse拉取svn中maven项目,pom文件第一行报错 错误如下: org.apache.maven.archiver.MavenArchiver.getManifest(org.apache.maven.project.MavenProject,org.apache.maven.archiver....
  • Maven项目pom文件报错解决方案

    万次阅读 2018-07-04 17:15:18
    引入maven项目后,有时会出现pom文件报错的情况,其中几种报错的解决方案如下一、 报错信息:org.apache.maven.archiver.MavenArchiver.getManifest(org.apache.maven.project.MavenProject,org.apach解决方案:1、...
  • 新建maven项目,pom文件报错

    万次阅读 2014-03-19 11:56:52
    在IDE中新建maven项目,pom文件报错! bug描述: Failure to transfer org.apache.maven.plugins:maven-surefire-plugin:pom:2.10 from http://repo.maven.apache.org/maven2 was cached in the local repository, ...
  • Maven的pom文件报错

    2020-08-12 21:37:40
    问题描述: 今天把项目导入客户服务器的时候...然后发现这个pom文件(该工程下是Service层代码)不报错了,但是和它关联依赖的的另一个工程下的pom文件报错了,(Controller层的代码在这个工程下)这次pom并没有明显的
  • 我认为可能是导入项目的次数多了,然后maven仓库里的jar包有缓存之类的,pom文件一直有一个叹号,然后提示说XX.jar包不存在之类的。解决办法: 1. 找到你的maven仓库所在的位置,然后检索.jar.lastUpdated全部都...
  • springBoot引入项目pom文件报错

    千次阅读 2019-08-03 10:34:30
    pom文件报如下错误: org.apache.maven.archiver.MavenArchiver.getManifest(org.apache.maven.project.MavenProject, org.apache.maven.archiver.MavenArchiveConfiguration) 2。我在SpringBoot启动项目中遇到了...
  • 1,版本报红 这种情况是groupId可以找到,但是版本报红 那可能是网络的问题,换个源,开个加速器 实在不行把maven里关于这个groupID的所有jar包全删了...也有可能根本不存在这个文件 等我找到解决办法再补充把! ...
  • pom文件报错,依赖报错,build中的plugin报红,不管是让maven工程 Reimport 还是 Download Sources 最后删除项目再重新建都不行 解决: 进入C盘用户目录的 .m2\repository\org\apache\maven\plugins\maven-surefire-...
  • http://blog.csdn.net/maosijunzi/article/details/21160965 1:环境 eclipse indigo, JDK1.6, maven 3.2.1, tomcat7.0.42 ...第一种方法:从网上下载m2eclipse,这个网上有很多下
  • 软件版本: Eclipse :
  • pom文件报错 unknow error

    2019-10-18 14:46:05
    1. 换父项目2.1.8.RELEASE换成别的 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId>...version&g...

空空如也

1 2 3 4 5 ... 20
收藏数 390,667
精华内容 156,266
关键字:

pom