精华内容
下载资源
问答
  • 转载于:https://www.cnblogs.com/heyboom/p/11351613.html

     

    转载于:https://www.cnblogs.com/heyboom/p/11351613.html

    展开全文
  • Maven首先在构建当前项目的地方寻找父项 目的pom,其次在文件系统的这个位置(relativePath位置),然后在本地仓库,最后在远程仓库寻找父项目的pom。--> <relativePath/> </parent> <!--声明项目描述符遵循哪...

    转载地址:
    https://blog.csdn.net/zcl1199/article/details/53096698

    <span style="padding:0px; margin:0px"><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_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>  </span>
    
    展开全文
  • maven POM文件详解

    千次阅读 2019-04-22 22:43:50
    http://www.blogjava.net/hellxoul/archive/2013/05/16/399345.html ...1.前言 Maven,发音是[`meivin],"专家"的意思。它是一个很好的项目管理工具,很早就进入了我的必备工具行列,但是这次为了把project1项...

    http://www.blogjava.net/hellxoul/archive/2013/05/16/399345.html

    http://blog.csdn.net/houpengfei111/article/details/9142869

    1.前言

    Maven,发音是[`meivin],"专家"的意思。它是一个很好的项目管理工具,很早就进入了我的必备工具行列,但是这次为了把project1项目完全迁移并应用maven,所以对maven进行了一些深入的学习。写这个学习笔记的目的,一个是为了自己备忘,二则希望能够为其他人学习使用maven 缩短一些时间。

    2.命令
    
    mvn pom.xml文件配置详解
    http://maven.apache.org/ref/2.0.8/maven-model/maven.html
    
    mvn -version/-v 显示版本信息
    mvn archetype:generate   创建mvn项目
    mvn archetype:create -DgroupId=com.oreilly -DartifactId=my-app   创建mvn项目
    
    mvn package    生成target目录,编译、测试代码,生成测试报告,生成jar/war文件
    mvn jetty:run    运行项目于jetty上,
    mvn compile      编译
    mvn test      编译并测试
    mvn clean      清空生成的文件
    mvn site      生成项目相关信息的网站
    mvn -Dwtpversion=1.0 eclipse:eclipse   生成Wtp插件的Web项目
    mvn -Dwtpversion=1.0 eclipse:clean   清除Eclipse项目的配置信息(Web项目)
    mvn eclipse:eclipse     将项目转化为Eclipse项目
    
    在应用程序用使用多个存储库
    <repositories>    
    <repository>      
       <id>Ibiblio</id>      
       <name>Ibiblio</name>      
       <url>http://www.ibiblio.org/maven/</url>    
    </repository>    
    <repository>      
       <id>PlanetMirror</id>      
       <name>Planet Mirror</name>      
       <url>http://public.planetmirror.com/pub/maven/</url>    
    </repository> 
    </repositories>
    
    
    mvn deploy:deploy-file -DgroupId=com -DartifactId=client -Dversion=0.1.0 -Dpackaging=jar -Dfile=d:\client-0.1.0.jar -DrepositoryId=maven-repository-inner -Durl=ftp://xxxxxxx/opt/maven/repository/
    
    
    发布第三方Jar到本地库中:
    
    mvn install:install-file -DgroupId=com -DartifactId=client -Dversion=0.1.0 -Dpackaging=jar -Dfile=d:\client-0.1.0.jar
    
    
    -DdownloadSources=true
    
    -DdownloadJavadocs=true
    
    mvn -e    显示详细错误 信息.
    
    mvn validate   验证工程是否正确,所有需要的资源是否可用。 
    mvn test-compile 编译项目测试代码。 。 
    mvn integration-test 在集成测试可以运行的环境中处理和发布包。 
    mvn verify   运行任何检查,验证包是否有效且达到质量标准。 
    mvn generate-sources 产生应用需要的任何额外的源代码,如xdoclet。
    
    1. maven概要

    首先我把maven的概念快速的梳理一下,让我们快速地建立起一个比较精确的maven应用场景。
    2.1 maven不是什么

    读书时候要先限定范围,避免一些有害的遐想。要说maven不是什么,我们可以从如下几个要点来展开

    maven不是ant,也不是make。 
    我们以前接触的构建工具,需要写一些详细的步骤,比如: compile project1/src/*.java 等类似的语句。这些语句正是我们使用ant和make所要编写的东西。maven采用了"约定优于配置"的方法,一些开发常用的操作和步骤已经固化在 maven中,所以使用者不再需要去编写那些烦人的语句了。同时,maven内置了开发流程的支持,它不仅能够编译,同样能够打包、发布,也能够一气呵成做完这些所有的步骤。
    maven不是ivy 
    依赖管理是maven的功能之一,虽然很多人包括我以前都是只用它的依赖管理功能,但是要深入运用的话,我们就可以看到更多的内容。更重要的是,maven在依赖关系中加入了scope的概念,进一步细化了依赖关系的划分。
    

    2.2 maven是什么

    maven将自己定位为一个项目管理工具。它负责管理项目开发过程中的几乎所有的东西:

    版本 
    maven有自己的版本定义和规则
    构建 
    maven支持许多种的应用程序类型,对于每一种支持的应用程序类型都定义好了一组构建规则和工具集。
    输出物管理 
    maven可以管理项目构建的产物,并将其加入到用户库中。这个功能可以用于项目组和其他部门之间的交付行为。
    依赖关系 
    maven对依赖关系的特性进行细致的分析和划分,避免开发过程中的依赖混乱和相互污染行为
    文档和构建结果 
    maven的site命令支持各种文档信息的发布,包括构建过程的各种输出,javadoc,产品文档等。
    项目关系 
    一个大型的项目通常有几个小项目或者模块组成,用maven可以很方便地管理
    移植性管理 
    maven可以针对不同的开发场景,输出不同种类的输出结果。
    

    2.3 maven的生命周期

    maven把项目的构建划分为不同的生命周期(lifecycle),在我看来,划分的已经是非常仔细了,大家可以参考这里。粗略一点的话,它这个过程(phase)包括:编译、测试、打包、集成测试、验证、部署。maven中所有的执行动作(goal)都需要指明自己在这个过程中的执行位置,然后maven执行的时候,就依照过程的发展依次调用这些goal进行各种处理。

    这个也是maven的一个基本调度机制。一般来说,位置稍后的过程都会依赖于之前的过程。当然,maven同样提供了配置文件,可以依照用户要求,跳过某些阶段。
    2.4 maven的"约定优于配置"

    所谓的"约定优于配置",在maven中并不是完全不可以修改的,他们只是一些配置的默认值而已。但是使用者除非必要,并不需要去修改那些约定内容。maven默认的文件存放结构如下:

    /项目目录
        pom.xml 用于maven的配置文件
        /src 源代码目录
            /src/main 工程源代码目录
                /src/main/java 工程java源代码目录
            /src/main/resource 工程的资源目录
            /src/test 单元测试目录
                /src/test/java
        /target 输出目录,所有的输出物都存放在这个目录下
            /target/classes 编译之后的class文件
    

    每一个阶段的任务都知道怎么正确完成自己的工作,比如compile任务就知道从src/main/java下编译所有的java文件,并把它的输出class文件存放到target/classes中。

    对maven来说,采用"约定优于配置"的策略可以减少修改配置的工作量,也可以降低学习成本,更重要的是,给项目引入了统一的规范。
    2.5 maven的版本规范

    maven使用如下几个要素来唯一定位某一个输出物: groupId:artifactId:packaging:version 。比如org.springframework:spring:2.5 。每个部分的解释如下:

    groupId 
    团体,公司,小组,组织,项目,或者其它团体。团体标识的约定是,它以创建这个项目的组织名称的逆向域名(reverse domain name)开头。来自Sonatype的项目有一个以com.sonatype开头的groupId,而Apache Software的项目有以org.apache开头的groupId。
    artifactId 
    在groupId下的表示一个单独项目的唯一标识符。比如我们的tomcat, commons等。不要在artifactId中包含点号(.)。
    version 
    一个项目的特定版本。发布的项目有一个固定的版本标识来指向该项目的某一个特定的版本。而正在开发中的项目可以用一个特殊的标识,这种标识给版本加上一个"SNAPSHOT"的标记。 
    虽然项目的打包格式也是Maven坐标的重要组成部分,但是它不是项目唯一标识符的一个部分。一个项目的 groupId:artifactId:version使之成为一个独一无二的项目;你不能同时有一个拥有同样的groupId, artifactId和version标识的项目。
    packaging 
    项目的类型,默认是jar,描述了项目打包后的输出。类型为jar的项目产生一个JAR文件,类型为war的项目产生一个web应用。
    classifier 
    很少使用的坐标,一般都可以忽略classifiers。如果你要发布同样的代码,但是由于技术原因需要生成两个单独的构件,你就要使用一个分类器(classifier)。例如,如果你想要构建两个单独的构件成JAR,一个使用Java 1.4编译器,另一个使用Java 6编译器,你就可以使用分类器来生成两个单独的JAR构件,它们有同样的groupId:artifactId:version组合。如果你的项目使用本地扩展类库,你可以使用分类器为每一个目标平台生成一个构件。分类器常用于打包构件的源码,JavaDoc或者二进制集合。
    

    maven有自己的版本规范,一般是如下定义 ..- ,比如1.2.3-beta-01。要说明的是,maven自己判断版本的算法是major,minor,incremental部分用数字比较,qualifier部分用字符串比较,所以要小心 alpha-2和alpha-15的比较关系,最好用 alpha-02的格式。

    maven在版本管理时候可以使用几个特殊的字符串 SNAPSHOT ,LATEST ,RELEASE 。比如"1.0-SNAPSHOT"。各个部分的含义和处理逻辑如下说明:

    SNAPSHOT 
    如果一个版本包含字符串"SNAPSHOT",Maven就会在安装或发布这个组件的时候将该符号展开为一个日期和时间值,转换为UTC时间。例如,"1.0-SNAPSHOT"会在2010年5月5日下午2点10分发布时候变成1.0-20100505-141000-1。 
    这个词只能用于开发过程中,因为一般来说,项目组都会频繁发布一些版本,最后实际发布的时候,会在这些snapshot版本中寻找一个稳定的,用于正式发布,比如1.4版本发布之前,就会有一系列的1.4-SNAPSHOT,而实际发布的1.4,也是从中拿出来的一个稳定版。
    LATEST 
    指某个特定构件的最新发布,这个发布可能是一个发布版,也可能是一个snapshot版,具体看哪个时间最后。
    RELEASE 
    指最后一个发布版。
    

    2.6 maven的组成部分

    maven把整个maven管理的项目分为几个部分,一个部分是源代码,包括源代码本身、相关的各种资源,一个部分则是单元测试用例,另外一部分则是各种maven的插件。对于这几个部分,maven可以独立管理他们,包括各种外部依赖关系。
    2.7 maven的依赖管理

    依赖管理一般是最吸引人使用maven的功能特性了,这个特性让开发者只需要关注代码的直接依赖,比如我们用了spring,就加入spring依赖说明就可以了,至于spring自己还依赖哪些外部的东西,maven帮我们搞定。

    任意一个外部依赖说明包含如下几个要素:groupId, artifactId, version, scope, type, optional。其中前3个是必须的,各自含义如下:

    groupId 必须
    artifactId 必须
    version 必须。 
    这里的version可以用区间表达式来表示,比如(2.0,)表示>2.0,[2.0,3.0)表示2.0<=ver<3.0;多个条件之间用逗号分隔,比如[1,3),[5,7]。
    scope 作用域限制
    type 一般在pom引用依赖时候出现,其他时候不用
    optional 是否可选依赖
    

    maven认为,程序对外部的依赖会随着程序的所处阶段和应用场景而变化,所以maven中的依赖关系有作用域(scope)的限制。在maven中,scope包含如下的取值:

    compile(编译范围) 
    compile是默认的范围;如果没有提供一个范围,那该依赖的范围就是编译范围。编译范围依赖在所有的classpath中可用,同时它们也会被打包。
    provided(已提供范围) 
    provided依赖只有在当JDK或者一个容器已提供该依赖之后才使用。例如,如果你开发了一个web应用,你可能在编译classpath中需要可用的Servlet API来编译一个servlet,但是你不会想要在打包好的WAR中包含这个Servlet API;这个Servlet API JAR由你的应用服务器或者servlet容器提供。已提供范围的依赖在编译classpath(不是运行时)可用。它们不是传递性的,也不会被打包。
    runtime(运行时范围) 
    runtime依赖在运行和测试系统的时候需要,但在编译的时候不需要。比如,你可能在编译的时候只需要JDBC API JAR,而只有在运行的时候才需要JDBC驱动实现。
    test(测试范围) 
    test范围依赖 在一般的 编译和运行时都不需要,它们只有在测试编译和测试运行阶段可用。测试范围依赖在之前的???中介绍过。
    system(系统范围) 
    system范围依赖与provided类似,但是你必须显式的提供一个对于本地系统中JAR文件的路径。这么做是为了允许基于本地对象编译,而这些对象是系统类库的一部分。这样的构件应该是一直可用的,Maven也不会在仓库中去寻找它。 如果你将一个依赖范围设置成系统范围,你必须同时提供一个systemPath元素 。注意该范围是不推荐使用的(你应该一直尽量去从公共或定制的Maven仓库中引用依赖)。
    

    另外,代码有代码自己的依赖,各个maven使用的插件也可以有自己的依赖关系。依赖也可以是可选的,比如我们代码中没有任何cache依赖,但是hibernate可能要配置cache,所以该cache的依赖就是可选的。
    2.8 多项目管理

    maven的多项目管理也是非常强大的。一般来说,maven要求同一个工程的所有子项目都放置到同一个目录下,每一个子目录代表一个项目,比如

    总项目/
        pom.xml 总项目的pom配置文件
        子项目1/
            pom.xml 子项目1的pom文件
        子项目2/
            pom.xml 子项目2的pom文件
    

    按照这种格式存放,就是继承方式,所有具体子项目的pom.xml都会继承总项目pom的内容,取值为子项目pom内容优先。

    要设置继承方式,首先要在总项目的pom中加入如下配置

    simple-weather
    simple-webapp

    其次在每个子项目中加入

    org.sonatype.mavenbook.ch06
    simple-parent
    1.0

    即可。

    当然,继承不是唯一的配置文件共用方式,maven还支持引用方式。引用pom的方式更简单,在依赖中加入一个type为pom的依赖即可。

    This is a project requiring JDBC ... ... org.sonatype.mavenbook persistence-deps 1.0 pom

    2.9 属性

    用户可以在maven中定义一些属性,然后在其他地方用${xxx}进行引用。比如:

    4.0.0 ... value1 maven提供了三个隐式的变量,用来访问系统环境变量、POM信息和maven的settings:
    env 
    暴露操作系统的环境变量,比如env.PATH
    project 
    暴露POM中的内容,用点号(.)的路径来引用POM元素的值,比如${project.artifactId}。另外,java的系统属性比如user.dir等,也暴露在这里。
    settings 
    暴露maven的settings的信息,也可以用点号(.)来引用。maven把系统配置文件存放在maven的安装目录中,把用户相关的配置文件存放在~/.m2/settings.xml(unix)或者%USERPROFILE%/.m2/settings.xml(windows)中。
    

    2.10 maven的profile

    profile是maven的一个重要特性,它可以让maven能够自动适应外部的环境变化,比如同一个项目,在linux下编译linux的版本,在win下编译win的版本等。一个项目可以设置多个profile,也可以在同一时间设置多个profile被激活(active)的。自动激活的 profile的条件可以是各种各样的设定条件,组合放置在activation节点中,也可以通过命令行直接指定。profile包含的其他配置内容可以覆盖掉pom定义的相应值。如果认为profile设置比较复杂,可以将所有的profiles内容移动到专门的 profiles.xml 文件中,不过记得和pom.xml放在一起。

    activation节点中的激活条件中常见的有如下几个:

    os 
    判断操作系统相关的参数,它包含如下可以自由组合的子节点元素
        message - 规则失败之后显示的消息
        arch - 匹配cpu结构,常见为x86
        family - 匹配操作系统家族,常见的取值为:dos,mac,netware,os/2,unix,windows,win9x,os/400等
        name - 匹配操作系统的名字
        version - 匹配的操作系统版本号
        display - 检测到操作系统之后显示的信息
    jdk 
    检查jdk版本,可以用区间表示。
    property 
    检查属性值,本节点可以包含name和value两个子节点。
    file 
    检查文件相关内容,包含两个子节点:exists和missing,用于分别检查文件存在和不存在两种情况。
    
    1. maven的操作和使用

    maven的操作有两种方式,一种是通过mvn命令行命令,一种是使用maven的eclipse插件。因为使用eclipse的maven插件操作起来比较容易,这里就只介绍使用mvn命令行的操作。
    3.1 maven的配置文件

    maven的主执行程序为mvn.bat,linux下为mvn.sh,这两个程序都很简单,它们的共同用途就是收集一些参数,然后用 java.exe来运行maven的Main函数。maven同样需要有配置文件,名字叫做settings.xml,它放在两个地方,一个是maven 安装目录的conf目录下,对所有使用该maven的用户都起作用,我们称为主配置文件,另外一个放在 %USERPROFILE%/.m2/settings.xml下,我们成为用户配置文件,只对当前用户有效,且可以覆盖主配置文件的参数内容。还有就是项目级别的配置信息了,它存放在每一个maven管理的项目目录下,叫pom.xml,主要用于配置项目相关的一些内容,当然,如果有必要,用户也可以在 pom中写一些配置,覆盖住配置文件和用户配置文件的设置参数内容。

    一般来说,settings文件配置的是比如repository库路径之类的全局信息,具体可以参考官方网站的文章 。
    3.2 创建新工程

    要创建一个新的maven工程,我们需要给我们的工程指定几个必要的要素,就是maven产品坐标的几个要素:groupId, artifactId,如果愿意,你也可以指定version和package名称。我们先看一个简单的创建命令:

    d:\work\temp>mvn archetype:create -DgroupId=com.abc -DartifactId=product1 -DarchetypeArtifactId=maven-archetype-webapp

    首先看这里的命令行参数的传递结构,怪异的 -D参数=值 的方式是 java.exe 要求的方式。这个命令创建一个web工程,目录结构是一个标准的maven结构,如下:
    D:.
    └─mywebapp
    │ pom.xml

    └─src
    └─main
    ├─resources
    └─webapp
    │ index.jsp

    └─WEB-INF
    web.xml

    大家要注意,这里目录结构的布局实际上是由参数 archetypeArtifactId 来决定的,因为这里传入的是 maven-archetype-webapp 如果我们传入其他的就会创建不同的结构,默认值为 maven-archetype-quickstart ,有兴趣的读者可以参考更详细的列表 ,我把部分常用的列表在这里:
    Artifact Group Version Repository Description
    maven-archetype-j2ee-simple org.apache.maven.archetypes A simple J2EE Java application
    maven-archetype-marmalade-mojo org.apache.maven.archetypes A Maven plugin development project using marmalade
    maven-archetype-plugin org.apache.maven.archetypes A Maven Java plugin development project
    maven-archetype-portlet org.apache.maven.archetypes A simple portlet application
    maven-archetype-profiles org.apache.maven.archetypes
    maven-archetype-quickstart org.apache.maven.archetypes
    maven-archetype-simple org.apache.maven.archetypes
    maven-archetype-site-simple org.apache.maven.archetypes A simple site generation project
    maven-archetype-site org.apache.maven.archetypes A more complex site project
    maven-archetype-webapp org.apache.maven.archetypes A simple Java web application
    maven-archetype-har net.sf.maven-har 0.9 Hibernate Archive
    maven-archetype-sar net.sf.maven-sar 0.9 JBoss Service Archive

    大家可以参考更详细的 archetype:create 帮助 和 archtype参考信息 。
    3.3 maven的多项目管理

    多项目管理是maven的主要特色之一,对于一个大型工程,用maven来管理他们之间复杂的依赖关系,是再好不过了。maven的项目配置之间的关系有两种:继承关系和引用关系。
    maven默认根据目录结构来设定pom的继承关系,即下级目录的pom默认继承上级目录的pom。要设定两者之间的关系很简单,上级pom如下设置:

    ABCCommon
    ABCCore
    ABCTools

    要记住的是,这里的module是目录名,不是子工程的artifactId。子工程如下设置:

    com.abc.product1 abc-product1 1.0.0-SNAPSHOT abc-my-module2 jar

    这样两者就相互关联起来了,继承关系就设定完毕,所有父工程的配置内容都会自动在子工程中生效,除非子工程有相同的配置覆盖。如果你不喜欢层层递进的目录结构来实现继承,也可以在parent中加入…/a-parent/pom.xml 来制定parent项目的相对目录。继承关系通常用在项目共同特性的抽取上,通过抽取公共特性,可以大幅度减少子项目的配置工作量。

    引用关系是另外一种复用的方式,maven中配置引用关系也很简单,加入一个 type 为 pom 的依赖即可。

    org.sonatype.mavenbook
    persistence-deps
    1.0
    pom

    但是无论是父项目还是引用项目,这些工程都必须用 mvn install 或者 mvn deploy 安装到本地库才行,否则会报告依赖没有找到,eclipse编译时候也会出错。

    需要特别提出的是复用过程中,父项目的pom中可以定义 dependencyManagement 节点,其中存放依赖关系,但是这个依赖关系只是定义,不会真的产生效果,如果子项目想要使用这个依赖关系,可以在本身的 dependency 中添加一个简化的引用

    org.springframework
    spring

    这种方法可以避免版本号满天飞的情况。
    3.4 安装库文件到maven库中

    在maven中一般都会用到安装库文件的功能,一则是我们常用的hibernate要使用jmx库,但是因为sun的license限制,所以无法将其直接包含在repository中。所以我们使用mvn命令把jar安装到我们本地的repository中

    mvn install:install-file -DgroupId=com.sun.jdmk -DartifactId=jmxtools -Dversion=1.2.1 -Dpackaging=jar -Dfile=/path/to/file

    如果我们想把它安装到公司的repository中,需要使用命令

    mvn deploy:deploy-file -DgroupId=com.sun.jdmk -DartifactId=jmxtools -Dversion=1.2.1 -Dpackaging=jar -Dfile=/path/to/file -Durl=http://xxx.ss.com/sss.xxx -DrepositoryId=release-repo

    对于我们的工程输出,如果需要放置到公司的repository中的话,可以通过配置pom来实现


    mycompany-repository
    MyCompany Repository
    scp://repository.mycompany.com/repository/maven2

    这里使用的scp方式提交库文件,还有其他方式可以使用,请参考faq部分。然后记得在你的settings.xml中加入这一内容





    mycompany-repository
    jvanzyl

    /path/to/identity
    my_key_passphrase



    3.5 maven的变量

    maven定义了很多变量属性,参考这里 http://docs.codehaus.org/display/MAVENUSER/MavenPropertiesGuide

    内置属性
        ${basedir } represents the directory containing pom.xml
        ${version } equivalent to ${project.version } or ${pom.version }
    Pom/Project properties 
    所有pom中的元素都可以用 project. 前缀进行引用,以下是部分常用的
        ${project.build.directory } results in the path to your "target" dir, this is the same as ${pom.project.build.directory }
        ${project.build. outputD irectory } results in the path to your "target/classes" dir
        ${project.name } refers to the name of the project.
        ${project.version } refers to the version of the project.
        ${project.build.finalName } refers to the final name of the file created when the built project is packaged
    本地用户设定 
    所有用的的 settings.xml 中的设定都可以通过 settings. 前缀进行引用
        ${settings.localRepository } refers to the path of the user's local repository.
        ${maven.repo.local } also works for backward compatibility with maven1 ??
    环境变量 
    系统的环境变量通过 env. 前缀引用
        ${env.M2_HOME } returns the Maven2 installation path.
        ${java.home } specifies the path to the current JRE_HOME environment use with relative paths to get for example: 
        <jvm>${java.home}../bin/java.exe</jvm>
    java系统属性 
    所有JVM中定义的java系统属性.
    用户在pom中定义的自定义属性
    <project> 
        ... 
        <properties> 
            <my.filter.value>hello</my.filter.value> 
        </properties> 
        ... 
    </project> 
    则引用 ${my.filter.value } 就会得到值 hello 
    上级工程的变量 
    上级工程的pom中的变量用前缀 ${project.parent } 引用. 上级工程的版本也可以这样引用:${parent.version }.
    

    3.6 maven的使用

    我们已经知道maven预定义了许多的阶段(phase),每个插件都依附于这些阶段,并且在进入某个阶段的时候,调用运行这些相关插件的功能。我们先来看完整的maven生命周期:
    生命周期 阶段描述
    validate 验证项目是否正确,以及所有为了完整构建必要的信息是否可用
    generate-sources 生成所有需要包含在编译过程中的源代码
    process-sources 处理源代码,比如过滤一些值
    generate-resources 生成所有需要包含在打包过程中的资源文件
    process-resources 复制并处理资源文件至目标目录,准备打包
    compile 编译项目的源代码
    process-classes 后处理编译生成的文件,例如对Java类进行字节码增强(bytecode enhancement)
    generate-test-sources 生成所有包含在测试编译过程中的测试源码
    process-test-sources 处理测试源码,比如过滤一些值
    generate-test-resources 生成测试需要的资源文件
    process-test-resources 复制并处理测试资源文件至测试目标目录
    test-compile 编译测试源码至测试目标目录
    test 使用合适的单元测试框架运行测试。这些测试应该不需要代码被打包或发布
    prepare-package 在真正的打包之前,执行一些准备打包必要的操作。这通常会产生一个包的展开的处理过的版本(将会在Maven 2.1+中实现)
    package 将编译好的代码打包成可分发的格式,如JAR,WAR,或者EAR
    pre-integration-test 执行一些在集成测试运行之前需要的动作。如建立集成测试需要的环境
    integration-test 如果有必要的话,处理包并发布至集成测试可以运行的环境
    post-integration-test 执行一些在集成测试运行之后需要的动作。如清理集成测试环境。
    verify 执行所有检查,验证包是有效的,符合质量规范
    install 安装包至本地仓库,以备本地的其它项目作为依赖使用
    deploy 复制最终的包至远程仓库,共享给其它开发人员和项目(通常和一次正式的发布相关)

    maven核心的插件列表可以参考 http://maven.apache.org/plugins/index.html 。这里仅列举几个常用的插件及其配置参数:

    clean插件 
    只包含一个goal叫做 clean:clean ,负责清理构建时候创建的文件。 默认清理的位置是如下几个变量指定的路径 project.build.directory, project.build.outputDirectory, project.build.testOutputDirectory, and project.reporting.outputDirectory 。
    compiler插件 
    包含2个goal,分别是 compiler:compile 和 compiler:testCompile 。可以到这里查看两者的具体参数设置:compile , testCompile 。
    surefire插件 
    运行单元测试用例的插件,并且能够生成报表。包含一个goal为 surefire:test 。主要参数testSourceDirectory用来指定测试用例目录,参考完整用法帮助
    jar 
    负责将工程输出打包到jar文件中。包含两个goal,分别是 jar:jar , jar:test-jar 。两个goal负责从classesDirectory或testClassesDirectory中获取所有资源,然后输出jar文件到outputDirectory中。
    war 
    负责打包成war文件。常用goal有 war:war ,负责从warSourceDirectory(默认${basedir}/src/main/webapp)打包所有资源到outputDirectory中。
    resources 
    负责复制各种资源文件,常用goal有 resources:resources ,负责将资源文件复制到outputDirectory中,默认为${project.build.outputDirectory}。
    install 
    负责将项目输出(install:install)或者某个指定的文件(install:install-file)加入到本机库%USERPROFILE%/.m2/repository中。可以用 install:help 寻求帮助。
    deploy 
    负责将项目输出(deploy:deploy)或者某个指定的文件(deploy:deploy-file)加入到公司库中。
    site 
    将工程所有文档生成网站,生成的网站界面默认和apache的项目站点类似,但是其文档用doxia格式写的,目前不支持docbook,需要用其他插件配合才能支持。需要指出的是,在maven 2.x系列中和maven3.x的site命令处理是不同的,在旧版本中,用 mvn site 命令可以生成reporting节点中的所有报表,但是在maven3中,reporting过时了,要把这些内容作为 maven-site-plugin的configuration的内容才行。详细内容可以参考http://www.wakaleo.com/blog/292-site-generation-in-maven-3 
    
    1. maven的使用问答

    除了以下的几个faq条目之外,还有一些faq可以参考

    maven 自己的FAQ
    

    兄弟们如果有其他问题,欢迎跟帖提问!
    4.1 依赖关系

    1. 问:如何增加删除一个依赖关系?

    答:直接在pom文件中加入一个dependency节点,如果要删除依赖,把对应的dependency节点删除即可。
    2) 问:如何屏蔽一个依赖关系?比如项目中使用的libA依赖某个库的1.0版,libB以来某个库的2.0版,现在想统一使用2.0版,如何去掉1.0版的依赖?

    答:设置exclusion即可。

    org.hibernate
    hibernate
    3.2.5.ga


    javax.transaction
    jta



    3) 问:我有一些jar文件要依赖,但是我又不想把这些jar去install到mvn的repository中去,怎么做配置?

    答:加入一个特殊的依赖关系,使用system类型,如下:

    com.abc
    my-tools
    2.5.0
    jar
    system
    ${basedir}/lib/mylib1.jar

    但是要记住,发布的时候不会复制这个jar。需要手工配置,而且其他project依赖这个project的时候,会报告警告。如果没有特殊要求,建议直接注册发布到repository。

    1. 问:在eclipse环境中同时使用maven builder和eclipse builder,并且设置项目依赖关系之后,为什么编译会出现artifact找不到错误,但是直接使用命令行mvn构建则一切正常?

    答:在project属性中去掉java build path中对其他 project 的依赖关系,直接在pom中设置依赖关系即可

    com.abc.project1 abc-project1-common ${project.version} 另外,保证没有其他错误。 5) 问:我想让输出的jar包自动包含所有的依赖

    答:使用 assembly 插件即可。

    maven-assembly-plugin


    jar-with-dependencies


    1. 问:我的测试用例依赖于其他工程的测试用例,如何设置?

    答:maven本身在发布的时候,可以发布单纯的jar,也可以同时发布xxx-tests.jar和xxx-javadoc.jar(大家经常在repository中可以看到类似的东西)。我们自己的项目A要同时输出test.jar可以做如下的设置

    org.apache.maven.plugins maven-jar-plugin test-jar 然后在其他需要引用的工程B中做如下的dependency设置 com.abc.XXX 工程A ${project.version} test-jar test 7)如何让maven将工程依赖的jar复制到WEB-INF/lib目录下?

    8)我刚刚更新了一下我的nexus库,但是我无法在eclipse中用m2eclipse找到我新增的库文件

    修改pom.xml文件,将旧版jar的依赖内容中的版本直接修改为新版本即可。

    9)我要的jar最新版不在maven的中央库中,我怎么办?

    将依赖的文件安装到本地库,用如下命令可以完成:

    mvn install:install-file
    -Dfile=
    -DgroupId=
    -DartifactId=
    -Dversion=
    -Dpackaging=
    -DgeneratePom=true

    Where: the path to the file to load
    the group that the file should be registered under
    the artifact name for the file
    the version of the file
    the packaging of the file e.g. jar

    10)
    4.2 变量

    1. 问:如何使用变量替换?项目中的某个配置文件比如jdbc.properties使用了一些pom中的变量,如何在发布中使用包含真实内容的最终结果文件?

    答:使用资源过滤功能,比如:



    <jdbc.driverClassName>com.mysql.jdbc.Driver</jdbc.driverClassName>
    <jdbc.url>jdbc:mysql://localhost:3306/development_db</jdbc.url>
    <jdbc.username>dev_user</jdbc.username>
    <jdbc.password>s3cr3tw0rd</jdbc.password>





    src/main/resources
    true






    production

    <jdbc.driverClassName>oracle.jdbc.driver.OracleDriver</jdbc.driverClassName>
    <jdbc.url>jdbc:oracle:thin:@proddb01:1521:PROD</jdbc.url>
    <jdbc.username>prod_user</jdbc.username>
    <jdbc.password>s00p3rs3cr3t</jdbc.password>




    2) 问: maven-svn-revision-number-plugin 插件说明

    答: maven-svn-revision-number-plugin 可以从 SVN 中获取版本号,并将其变成环境变量,交由其他插件或者profile使用,详细帮助在这里 。一般和resource的filter机制同时使用


    com.google.code.maven-svn-revision-number-plugin
    maven-svn-revision-number-plugin
    1.3



    revision






    prefix




    这段代码负责把resource文件中的内容替换成适当内容
    repository = ${prefix.repository}
    path = ${prefix.path}
    revision = ${prefix.revision}
    mixedRevisions = ${prefix.mixedRevisions}
    committedRevision = ${prefix.committedRevision}
    status = ${prefix.status}
    specialStatus = ${prefix.specialStatus}
    3)我的程序有些单元测试有错误,如何忽略测试步骤?

    有好几种方法都可以实现跳过单元测试步骤,一种是给mvn增加命令行参数 -Dmaven.test.skip=true 或者 -DskipTests=true ;另外一种是给surefire插件增加参数,如下:

    [...] org.apache.maven.plugins maven-surefire-plugin 2.8 true [...]
    1. 如果只想运行单个测试用例,能否实现?

    可以,运行时候增加命令行参数 -Dtest=MyTest 即可,其中MyTest是所需要运行的单元测试用例名称,但是不需要包含package部分。
    4.3 编译

    1. 问:如何给插件指派参数?比如我要设置一些编译参数

    答:以下内容设定编译器编译java1.5的代码






    maven-compiler-plugin

    1.5
    1.5







    要设置其他插件的参数也可以,请参考对应插件的帮助信息
    2) 问:我的目录是非标准的目录结构,如何设置让maven支持?

    答:指定source目录和test-source目录即可。

    target
    src
    js/scripts
    test
    bin
    bin

    这个例子把源代码设置成了src目录,测试代码在test目录,所以输出到bin目录。这里要注意,directory如果也设置成bin目录的话,maven打包的时候会引起死循环,因为directory是所有工作存放的地方,默认包含outputDirectory定义的目录在内。
    3) 我源代码是UTF8格式的,我如何在maven中指定?

    设置一个变量即可



    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>



    {color:blue}以上是官方给出的解决方案,但是经过尝试这样只能影响到resource处理时候的编码{color},真正有用的是如下配置:

    {code:xml}



    maven-compiler-plugin

    UTF-8




    {code}

    . 问:我的项目除了main/java目录之外,还加了其他的c++目录,想要一并编译,如何做?
    答:使用native插件,具体配置方法参考[http://mojo.codehaus.org/maven-native/native-maven-plugin/]

    {code:xml}

    org.codehaus.mojo
    native-maven-plugin
    true


    {code}

    . 问:我想要把工程的所有依赖的jar都一起打包,怎么办?
    答:首先修改maven的配置文件,给maven-assembly-plugin增加一个jar-with-dependencies的描述。

    {code:xml}

    […]



    maven-assembly-plugin


    jar-with-dependencies





    […]

    {code}

    然后使用命令打包即可:

    mvn assembly:assembly

    . 问:我想把main/scripts中的内容一起打包发布,如何做?
    答:在pom中配置额外的资源目录。如果需要的话,还可以指定资源目录的输出位置

    {code:xml}




    true
    src/main/command

    run.bat
    run.sh

    /abc


    src/main/scripts




    {code}

    . 问:我有多个源代码目录,但是maven只支持一个main src和一个test src,怎么办?
    答:使用另外一个插件,并仿照如下配置pom

    {code:xml}

    org.codehaus.mojo
    build-helper-maven-plugin
    1.1


    add-source
    generate-sources

    add-source



    src/config/java
    src/main/java
    src/member/java





    {code}

    . 问:我的源代码目录中有一部分文件我不想让maven编译,怎么做?
    答:使用一个maven插件,然后使用includes和excludes。同理,也可以处理资源的过滤。

    {code:xml}

    http://www.cnblogs.com/src/java


    com.sun.enterprise
    hk2-maven-plugin


    com/sun/logging/LogDomains.
    com/sun/enterprise/util/OS.java
    com/sun/enterprise/util/io/FileUtils.java
    com/sun/enterprise/util/zip/
    com/sun/enterprise/util/i18n/
    com/sun/enterprise/deployment/backend/IASDeploymentException.java


    com/sun/enterprise/config/ConfigBeansFactory.java
    com/sun/enterprise/config/clientbeans/






    http://www.cnblogs.com/src/java

    /.properties




    {code}

    . 问:我的项目是一个纯的html组成的项目,没有任何的java代码,怎么跳过编译过程?
    答:配置如下

    {code:xml}

    src/java


    com.sun.enterprise
    hk2-maven-plugin



    {code}

    . 问:我的工程里用hibernate,想在编译时候自动生成ddl,如何做?
    答:添加插件

    hibernate3-maven-plugin

    ,按照如下配置:

    {code:xml}

    org.codehaus.mojo
    hibernate3-maven-plugin
    2.1



    hbm2ddl
    annotationconfiguration





    hsqldb
    hsqldb
    ${hsqldb.version}



    {code}

    . 问:我能用maven支持eclipse RCP项目吗?

    答:当然可以,你可以使用插件 Tycho,详细内容可以参考这里[http://mattiasholmqvist.se/2010/02/building-with-tycho-part-1-osgi-bundles/].

    org.sonatype.tycho target-platform-configuration 0.7.0 p2 另外,老牌的pde-maven-plugin就不要用了,已经好几年没见更新了。

    4.4 ant互动

    1. 如何在maven编译时候运行ant脚本?

    使用专门的antrun插件,并且在target标签内部加入ant的代码

      <plugin>
        <artifactId>maven-antrun-plugin</artifactId>
        <version>1.6</version>
        <executions>
          <execution>
            <phase> <!-- 生命周期阶段 --> </phase>
            <configuration>
              <target>
                <!-- 加入target内部的代码 -->
              </target>
            </configuration>
            <goals>
              <goal>run</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    

    2)如何在ant脚本中引用maven的classpath?

    maven给每一个依赖都生成了一个属性,格式为"groupId:artifactId[:classifier]:type",比如,如果一下例子就显示依赖的org.apache.common-util的jar文件路径

    另外,maven还预定义了四个classpath的引用,他们是

    maven.compile.classpath
    maven.runtime.classpath
    maven.test.classpath
    maven.plugin.classpath
    

    3)如何使用antrun插件运行外部的build文件?

    很简单,直接在antrun里边使用ant指令即可,如下:

    org.apache.maven.plugins maven-antrun-plugin 1.6 compile compile
                    <ant antfile="${basedir}/build.xml">
                        <target name="test"/>
                    </ant>
                </target>
            </configuration>
            <goals>
                <goal>run</goal>
            </goals>
        </execution>
    </executions>
    

    . 问:如何在ant中使用maven的功能?
    答:使用ant的[maven task|http://maven.apache.org/ant-tasks/index.html],不过只有ant 1.6以上和jdk 1.5环境才支持。
    h4. 测试相关
    . 问:如何忽略某个阶段的结果?比如单元测试不一定要全正确
    答:给插件增加testFailureIgnore参数,并设置为false。如果要屏蔽该阶段,则用

    true

    {code:xml}

    […]



    org.apache.maven.plugins
    maven-surefire-plugin

    true




    […]

    {code}

    . 问:我如何在maven中加入PMD,CheckStyle,JDepend等检查功能?
    答:加入PMD检查,以下代码如果在

    reporting

    节点中加入则在

    mvn site

    中执行,如果在

    build

    节点中加入,则在build的时候自动运行检查。详细配置参考[pmd插件使用说明|http://maven.apache.org/plugins/maven-pmd-plugin/]

    {code:xml}


    org.apache.maven.plugins
    maven-pmd-plugin
    2.5


    {code}

    加入 checkstyle 检查,详细配置参考[checkstyle插件使用说明|http://maven.apache.org/plugins/maven-checkstyle-plugin/],同样注意放置在reporting和build节点中的区别(所有报表类插件都要同样注意):

    {code:xml}

    org.apache.maven.plugins
    maven-checkstyle-plugin
    2.5

    {code}

    加入 simian 的支持,simian是一个支持代码相似度检查的工具,目前有maven插件,也有checkstyle的插件。它不仅可以检查java,甚至可以支持文本文件的检查。详细帮助信息参考[这里|http://www.redhillconsulting.com.au/products/simian/]。simian 的 maven插件在[这里|http://mojo.codehaus.org/simian-report-maven-plugin/introduction.html]

    {code:xml}



    org.codehaus.mojo
    simian-maven-plugin
    1.6.1




    {code}

    加入 jdepend 检查,详细配置参考[jdepend使用说明|http://mojo.codehaus.org/jdepend-maven-plugin/],

    {code:xml}

    org.codehaus.mojo
    jdepend-maven-plugin
    2.0-beta-2

    {code}

    加入 findbugz 检查,详细配置参考[findbugz使用说明|http://mojo.codehaus.org/findbugs-maven-plugin/usage.html],

    {code:xml}

    org.codehaus.mojo
    findbugs-maven-plugin
    2.0.1

    {code}

    加入javadoc生成,详细配置参考[javadoc usage|http://maven.apache.org/plugins/maven-javadoc-plugin/usage.html]

    {code:xml}

    org.apache.maven.plugins
    maven-javadoc-plugin
    2.7




    {code}

    加入 jxr 支持,JXR是一个生成java代码交叉引用和源代码的html格式的工具,详细配置信息参考[jxr usage|http://maven.apache.org/plugins/maven-jxr-plugin/]。注意,jxr没有必要在build阶段运行。

    {code:xml}



    org.apache.maven.plugins
    maven-jxr-plugin
    2.1



    {code}

    加入 Cobertura 支持,它是一个代码覆盖率工具,可以用来评估具有相应测试的源代码的比率。详细帮助在[这里|http://mojo.codehaus.org/cobertura-maven-plugin/index.html]。另外一个功能相似的软件是[EMMA|http://emma.sourceforge.net/samples.html],详细的帮助在[这里|http://mojo.codehaus.org/emma-maven-plugin/usage.html]。两个产品的比较文章在[这里|http://www.topcoder.com/tc?module=Static&d1=features&d2=030107],个人倾向于都要用,因为给出的指标不一样,都有参考作用。

    {code:xml|title=Cobertura }

    org.codehaus.mojo
    cobertura-maven-plugin
    2.4


    85
    85
    true
    85
    85
    85
    85


    com.example.reallyimportant.
    90
    80


    com.example.boringcode.
    40
    30







    clean
    check




    {code}

    {code:xml|title=EMMA}





    org.codehaus.mojo
    emma-maven-plugin
    1.0-alpha-3-SNAPSHOT





    {code}

    添加 javaNCSS 插件,它是一个java代码的度量工具,详细参考在[这里|http://mojo.codehaus.org/javancss-maven-plugin/]。

    {code:xml}



    org.codehaus.mojo
    javancss-maven-plugin
    2.0-beta-2



    {code}

    h4. profile相关
    . 问:profile能够设置为某个变量不存在的条件下激活?
    答:使用!前缀,请看示例:

    {code:xml}


    !environment.type


    {code}

    h4. 部署相关
    . 问:其他部署到服务器的方式和配置怎么配?
    答:本文摘自 [http://blog.csdn.net/zyxnetxz/archive/2009/05/18/4199348.aspx]{panel} Distribution Management 用于配置分发管理,配置相应的产品发布信息,主要用于发布,在执行mvn deploy后表示要发布的位置 *# 配置到文件系统

    {code:xml}


    proficio-repository
    Proficio Repository
    file://${basedir}/target/deploy


    {code}

    *# 使用ssh2配置

    {code:xml}


    proficio-repository
    Proficio Repository
    scp://sshserver.yourcompany.com/deploy


    {code}

    *# 使用sftp配置

    {code:xml}


    proficio-repositoryi
    Proficio Repository
    sftp://ftpserver.yourcompany.com/deploy


    {code}

    *# 使用外在的ssh配置编译扩展用于指定使用wagon外在ssh提供,用于提供你的文件到相应的远程服务器。

    {code:xml}


    proficio-repository
    Proficio Repository
    scpexe://sshserver.yourcompany.com/deploy





    org.apache.maven.wagon
    wagon-ssh-external
    1.0-alpha-6



    {code}

    *# 使用ftp配置

    {code:xml}


    proficio-repository
    Proficio Repository
    ftp://ftpserver.yourcompany.com/deploy





    org.apache.maven.wagongroupId>
    wagon-ftpartifactId>
    1.0-alpha-6version>



    {code}

    {panel} h4. 插件配置
    . 问:我用maven输出site,如何设置输出为utf8编码?
    答: 配置site插件的编码设置

    {code:xml}


    org.apache.maven.plugins
    maven-site-plugin
    2.0-beta-6

    UTF-8



    {code}

    展开全文
  • Maven Pom文件标签详解及使用

    千次阅读 2018-07-04 16:21:40
    Maven首先在构建当前项目的地方寻找父项目的pom,其次在文件系统的这个位置(relativePath位置),然后在本地仓库,最后在远程仓库寻找父项目的pom。-->          <!--引用的默认插件信息。该插件配置项直到被...
     <!--父项目的坐标。如果项目中没有规定某个元素的值,那么父项目中的对应值即为项目的默认值。 坐标包括group ID,artifact ID和 version。-->
    
        <parent>
         <!--被继承的父项目的构件标识符-->
         <artifactId/>
         <!--被继承的父项目的全球唯一标识符-->
         <groupId/>
         <!--被继承的父项目的版本-->
         <version/>
         <!--父项目的pom.xml文件的相对路径。相对路径允许你选择一个不同的路径。默认值是../pom.xml。Maven首先在构建当前项目的地方寻找父项目的pom,其次在文件系统的这个位置(relativePath位置),然后在本地仓库,最后在远程仓库寻找父项目的pom。-->
         <relativePath/>
     </parent>  
     
     <!--引用的默认插件信息。该插件配置项直到被引用时才会被解析或绑定到生命周期。给定插件的任何本地配置都会覆盖这里的配置-->
     <buid>
     <!--使用的插件列表 。-->
       <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>
     </buid>
     <!--该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息,请看项目依赖机制。-->  
        <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> 

    ---------------------------------------

    在pom.xml中添加依赖时语法如下
    <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-core</artifactId>
     <version>1.2.6</version>
    </dependency>
    <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-aop</artifactId>
     <version>1.2.6</version>
    </dependency>
     
    以上内容没错,但有这样一个问题,在spring的依赖中,我们需要引用一系列版本的spring,如版本1.2.6。每次都写不利于维护。
     
    二 解决办法
    在pom.xml定义properties标签
    <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <spring.version>1.2.6</spring.version>
     <developer.organization><![CDATA[xy公司]]></developer.organization>
    </properties>
    以上内容就改成了
    <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-core</artifactId>
     <version>${spring.version}</version>
    </dependency>
    <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-aop</artifactId>
     <version>${spring.version}</version>

    </dependency>

    1. <span style="padding:0px; margin:0px"><project xmlns="http://maven.apache.org/POM/4.0.0"     
    2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     
    3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0http://maven.apache.org/maven-v4_0_0.xsd">     
    4.     <!--父项目的坐标。如果项目中没有规定某个元素的值,那么父项目中的对应值即为项目的默认值。 坐标包括group ID,artifact ID和 version。-->    
    5.     <parent>    
    6.      <!--被继承的父项目的构件标识符-->    
    7.      <artifactId/>    
    8.      <!--被继承的父项目的全球唯一标识符-->    
    9.      <groupId/>    
    10.      <!--被继承的父项目的版本-->    
    11.      <version/>    
    12.      <!-- 父项目的pom.xml文件的相对路径。相对路径允许你选择一个不同的路径。默认值是../pom.xml。Maven首先在构建当前项目的地方寻找父项 目的pom,其次在文件系统的这个位置(relativePath位置),然后在本地仓库,最后在远程仓库寻找父项目的pom。-->    
    13.      <relativePath/>    
    14.  </parent>    
    15.  <!--声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变,虽然如此,但它仍然是必不可少的,这是为了当Maven引入了新的特性或者其他模型变更的时候,确保稳定性。-->       
    16.     <modelVersion>4.0.0</modelVersion>     
    17.     <!--项目的全球唯一标识符,通常使用全限定的包名区分该项目和其他项目。并且构建时生成的路径也是由此生成, 如com.mycompany.app生成的相对路径为:/com/mycompany/app-->     
    18.     <groupId>asia.banseon</groupId>     
    19.     <!-- 构件的标识符,它和group ID一起唯一标识一个构件。换句话说,你不能有两个不同的项目拥有同样的artifact ID和groupID;在某个 特定的group ID下,artifact ID也必须是唯一的。构件是项目产生的或使用的一个东西,Maven为项目产生的构件包括:JARs,源 码,二进制发布和WARs等。-->     
    20.     <artifactId>banseon-maven2</artifactId>     
    21.     <!--项目产生的构件类型,例如jar、war、ear、pom。插件可以创建他们自己的构件类型,所以前面列的不是全部构件类型-->     
    22.     <packaging>jar</packaging>     
    23.     <!--项目当前版本,格式为:主版本.次版本.增量版本-限定版本号-->     
    24.     <version>1.0-SNAPSHOT</version>     
    25.     <!--项目的名称, Maven产生的文档用-->     
    26.     <name>banseon-maven</name>     
    27.     <!--项目主页的URL, Maven产生的文档用-->     
    28.     <url>http://www.baidu.com/banseon</url>     
    29.     <!-- 项目的详细描述, Maven 产生的文档用。  当这个元素能够用HTML格式描述时(例如,CDATA中的文本会被解析器忽略,就可以包含HTML标 签), 不鼓励使用纯文本描述。如果你需要修改产生的web站点的索引页面,你应该修改你自己的索引页文件,而不是调整这里的文档。-->     
    30.     <description>A maven project to study maven.</description>     
    31.     <!--描述了这个项目构建环境中的前提条件。-->    
    32.  <prerequisites>    
    33.   <!--构建该项目或使用该插件所需要的Maven的最低版本-->    
    34.     <maven/>    
    35.  </prerequisites>    
    36.  <!--项目的问题管理系统(Bugzilla, Jira, Scarab,或任何你喜欢的问题管理系统)的名称和URL,本例为 jira-->     
    37.     <issueManagement>    
    38.      <!--问题管理系统(例如jira)的名字,-->     
    39.         <system>jira</system>     
    40.         <!--该项目使用的问题管理系统的URL-->    
    41.         <url>http://jira.baidu.com/banseon</url>     
    42.     </issueManagement>     
    43.     <!--项目持续集成信息-->    
    44.  <ciManagement>    
    45.   <!--持续集成系统的名字,例如continuum-->    
    46.   <system/>    
    47.   <!--该项目使用的持续集成系统的URL(如果持续集成系统有web接口的话)。-->    
    48.   <url/>    
    49.   <!--构建完成时,需要通知的开发者/用户的配置项。包括被通知者信息和通知条件(错误,失败,成功,警告)-->    
    50.   <notifiers>    
    51.    <!--配置一种方式,当构建中断时,以该方式通知用户/开发者-->    
    52.    <notifier>    
    53.     <!--传送通知的途径-->    
    54.     <type/>    
    55.     <!--发生错误时是否通知-->    
    56.     <sendOnError/>    
    57.     <!--构建失败时是否通知-->    
    58.     <sendOnFailure/>    
    59.     <!--构建成功时是否通知-->    
    60.     <sendOnSuccess/>    
    61.     <!--发生警告时是否通知-->    
    62.     <sendOnWarning/>    
    63.     <!--不赞成使用。通知发送到哪里-->    
    64.     <address/>    
    65.     <!--扩展配置项-->    
    66.     <configuration/>    
    67.    </notifier>    
    68.   </notifiers>    
    69.  </ciManagement>    
    70.  <!--项目创建年份,4位数字。当产生版权信息时需要使用这个值。-->    
    71.     <inceptionYear/>    
    72.     <!--项目相关邮件列表信息-->     
    73.     <mailingLists>    
    74.      <!--该元素描述了项目相关的所有邮件列表。自动产生的网站引用这些信息。-->     
    75.         <mailingList>     
    76.          <!--邮件的名称-->    
    77.             <name>Demo</name>     
    78.             <!--发送邮件的地址或链接,如果是邮件地址,创建文档时,mailto: 链接会被自动创建-->     
    79.             <post>banseon@126.com</post>     
    80.             <!--订阅邮件的地址或链接,如果是邮件地址,创建文档时,mailto: 链接会被自动创建-->     
    81.             <subscribe>banseon@126.com</subscribe>     
    82.             <!--取消订阅邮件的地址或链接,如果是邮件地址,创建文档时,mailto: 链接会被自动创建-->     
    83.             <unsubscribe>banseon@126.com</unsubscribe>     
    84.             <!--你可以浏览邮件信息的URL-->    
    85.             <archive>http:/hi.baidu.com/banseon/demo/dev/</archive>     
    86.         </mailingList>     
    87.     </mailingLists>     
    88.     <!--项目开发者列表-->     
    89.     <developers>     
    90.      <!--某个项目开发者的信息-->    
    91.         <developer>     
    92.          <!--SCM里项目开发者的唯一标识符-->    
    93.             <id>HELLO WORLD</id>     
    94.             <!--项目开发者的全名-->    
    95.             <name>banseon</name>     
    96.             <!--项目开发者的email-->    
    97.             <email>banseon@126.com</email>     
    98.             <!--项目开发者的主页的URL-->    
    99.             <url/>    
    100.             <!--项目开发者在项目中扮演的角色,角色元素描述了各种角色-->    
    101.             <roles>     
    102.                 <role>Project Manager</role>     
    103.                 <role>Architect</role>     
    104.             </roles>    
    105.             <!--项目开发者所属组织-->    
    106.             <organization>demo</organization>     
    107.             <!--项目开发者所属组织的URL-->    
    108.             <organizationUrl>http://hi.baidu.com/banseon</organizationUrl>     
    109.             <!--项目开发者属性,如即时消息如何处理等-->    
    110.             <properties>     
    111.                 <dept>No</dept>     
    112.             </properties>    
    113.             <!--项目开发者所在时区, -11到12范围内的整数。-->    
    114.             <timezone>-5</timezone>     
    115.         </developer>     
    116.     </developers>     
    117.     <!--项目的其他贡献者列表-->     
    118.     <contributors>    
    119.      <!--项目的其他贡献者。参见developers/developer元素-->    
    120.      <contributor>    
    121.    <name/><email/><url/><organization/><organizationUrl/><roles/><timezone/><properties/>    
    122.      </contributor>         
    123.     </contributors>       
    124.     <!--该元素描述了项目所有License列表。 应该只列出该项目的license列表,不要列出依赖项目的 license列表。如果列出多个license,用户可以选择它们中的一个而不是接受所有license。-->     
    125.     <licenses>    
    126.      <!--描述了项目的license,用于生成项目的web站点的license页面,其他一些报表和validation也会用到该元素。-->     
    127.         <license>    
    128.          <!--license用于法律上的名称-->    
    129.             <name>Apache 2</name>     
    130.             <!--官方的license正文页面的URL-->    
    131.             <url>http://www.baidu.com/banseon/LICENSE-2.0.txt</url>     
    132.             <!--项目分发的主要方式:    
    133.               repo,可以从Maven库下载    
    134.               manual, 用户必须手动下载和安装依赖-->    
    135.             <distribution>repo</distribution>     
    136.             <!--关于license的补充信息-->    
    137.             <comments>A business-friendly OSS license</comments>     
    138.         </license>     
    139.     </licenses>     
    140.     <!--SCM(Source Control Management)标签允许你配置你的代码库,供Maven web站点和其它插件使用。-->     
    141.     <scm>     
    142.         <!--SCM的URL,该URL描述了版本库和如何连接到版本库。欲知详情,请看SCMs提供的URL格式和列表。该连接只读。-->     
    143.         <connection>     
    144.             scm:svn:http://svn.baidu.com/banseon/maven/banseon/banseon-maven2-trunk(dao-trunk)      
    145.         </connection>     
    146.         <!--给开发者使用的,类似connection元素。即该连接不仅仅只读-->    
    147.         <developerConnection>     
    148.             scm:svn:http://svn.baidu.com/banseon/maven/banseon/dao-trunk      
    149.         </developerConnection>    
    150.         <!--当前代码的标签,在开发阶段默认为HEAD-->    
    151.         <tag/>           
    152.         <!--指向项目的可浏览SCM库(例如ViewVC或者Fisheye)的URL。-->     
    153.         <url>http://svn.baidu.com/banseon</url>     
    154.     </scm>     
    155.     <!--描述项目所属组织的各种属性。Maven产生的文档用-->     
    156.     <organization>     
    157.      <!--组织的全名-->    
    158.         <name>demo</name>     
    159.         <!--组织主页的URL-->    
    160.         <url>http://www.baidu.com/banseon</url>     
    161.     </organization>    
    162.     <!--构建项目需要的信息-->    
    163.     <build>    
    164.      <!--该元素设置了项目源码目录,当构建项目的时候,构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。-->    
    165.   <sourceDirectory/>    
    166.   <!--该元素设置了项目脚本源码目录,该目录和源码目录不同:绝大多数情况下,该目录下的内容 会被拷贝到输出目录(因为脚本是被解释的,而不是被编译的)。-->    
    167.   <scriptSourceDirectory/>    
    168.   <!--该元素设置了项目单元测试使用的源码目录,当测试项目的时候,构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。-->    
    169.   <testSourceDirectory/>    
    170.   <!--被编译过的应用程序class文件存放的目录。-->    
    171.   <outputDirectory/>    
    172.   <!--被编译过的测试class文件存放的目录。-->    
    173.   <testOutputDirectory/>    
    174.   <!--使用来自该项目的一系列构建扩展-->    
    175.   <extensions>    
    176.    <!--描述使用到的构建扩展。-->    
    177.    <extension>    
    178.     <!--构建扩展的groupId-->    
    179.     <groupId/>    
    180.     <!--构建扩展的artifactId-->    
    181.     <artifactId/>    
    182.     <!--构建扩展的版本-->    
    183.     <version/>    
    184.    </extension>    
    185.   </extensions>    
    186.   <!--当项目没有规定目标(Maven2 叫做阶段)时的默认值-->    
    187.   <defaultGoal/>    
    188.   <!--这个元素描述了项目相关的所有资源路径列表,例如和项目相关的属性文件,这些资源被包含在最终的打包文件里。-->    
    189.   <resources>    
    190.    <!--这个元素描述了项目相关或测试相关的所有资源路径-->    
    191.    <resource>    
    192.     <!-- 描述了资源的目标路径。该路径相对target/classes目录(例如${project.build.outputDirectory})。举个例 子,如果你想资源在特定的包里(org.apache.maven.messages),你就必须该元素设置为org/apache/maven /messages。然而,如果你只是想把资源放到源码目录结构里,就不需要该配置。-->    
    193.     <targetPath/>    
    194.     <!--是否使用参数值代替参数名。参数值取自properties元素或者文件里配置的属性,文件在filters元素里列出。-->    
    195.     <filtering/>    
    196.     <!--描述存放资源的目录,该路径相对POM路径-->    
    197.     <directory/>    
    198.     <!--包含的模式列表,例如**/*.xml.-->    
    199.     <includes/>    
    200.     <!--排除的模式列表,例如**/*.xml-->    
    201.     <excludes/>    
    202.    </resource>    
    203.   </resources>    
    204.   <!--这个元素描述了单元测试相关的所有资源路径,例如和单元测试相关的属性文件。-->    
    205.   <testResources>    
    206.    <!--这个元素描述了测试相关的所有资源路径,参见build/resources/resource元素的说明-->    
    207.    <testResource>    
    208.     <targetPath/><filtering/><directory/><includes/><excludes/>    
    209.    </testResource>    
    210.   </testResources>    
    211.   <!--构建产生的所有文件存放的目录-->    
    212.   <directory/>    
    213.   <!--产生的构件的文件名,默认值是${artifactId}-${version}。-->    
    214.   <finalName/>    
    215.   <!--当filtering开关打开时,使用到的过滤器属性文件列表-->    
    216.   <filters/>    
    217.   <!--子项目可以引用的默认插件信息。该插件配置项直到被引用时才会被解析或绑定到生命周期。给定插件的任何本地配置都会覆盖这里的配置-->    
    218.   <pluginManagement>    
    219.    <!--使用的插件列表 。-->    
    220.    <plugins>    
    221.     <!--plugin元素包含描述插件所需要的信息。-->    
    222.     <plugin>    
    223.      <!--插件在仓库里的group ID-->    
    224.      <groupId/>    
    225.      <!--插件在仓库里的artifact ID-->    
    226.      <artifactId/>    
    227.      <!--被使用的插件的版本(或版本范围)-->    
    228.      <version/>    
    229.      <!--是否从该插件下载Maven扩展(例如打包和类型处理器),由于性能原因,只有在真需要下载时,该元素才被设置成enabled。-->    
    230.      <extensions/>    
    231.      <!--在构建生命周期中执行一组目标的配置。每个目标可能有不同的配置。-->    
    232.      <executions>    
    233.       <!--execution元素包含了插件执行需要的信息-->    
    234.       <execution>    
    235.        <!--执行目标的标识符,用于标识构建过程中的目标,或者匹配继承过程中需要合并的执行目标-->    
    236.        <id/>    
    237.        <!--绑定了目标的构建生命周期阶段,如果省略,目标会被绑定到源数据里配置的默认阶段-->    
    238.        <phase/>    
    239.        <!--配置的执行目标-->    
    240.        <goals/>    
    241.        <!--配置是否被传播到子POM-->    
    242.        <inherited/>    
    243.        <!--作为DOM对象的配置-->    
    244.        <configuration/>    
    245.       </execution>    
    246.      </executions>    
    247.      <!--项目引入插件所需要的额外依赖-->    
    248.      <dependencies>    
    249.       <!--参见dependencies/dependency元素-->    
    250.       <dependency>    
    251.        ......    
    252.       </dependency>    
    253.      </dependencies>         
    254.      <!--任何配置是否被传播到子项目-->    
    255.      <inherited/>    
    256.      <!--作为DOM对象的配置-->    
    257.      <configuration/>    
    258.     </plugin>    
    259.    </plugins>    
    260.   </pluginManagement>    
    261.   <!--使用的插件列表-->    
    262.   <plugins>    
    263.    <!--参见build/pluginManagement/plugins/plugin元素-->    
    264.    <plugin>    
    265.     <groupId/><artifactId/><version/><extensions/>    
    266.     <executions>    
    267.      <execution>    
    268.       <id/><phase/><goals/><inherited/><configuration/>    
    269.      </execution>    
    270.     </executions>    
    271.     <dependencies>    
    272.      <!--参见dependencies/dependency元素-->    
    273.      <dependency>    
    274.       ......    
    275.      </dependency>    
    276.     </dependencies>    
    277.     <goals/><inherited/><configuration/>    
    278.    </plugin>    
    279.   </plugins>    
    280.  </build>    
    281.  <!--在列的项目构建profile,如果被激活,会修改构建处理-->    
    282.  <profiles>    
    283.   <!--根据环境参数或命令行参数激活某个构建处理-->    
    284.   <profile>    
    285.    <!--构建配置的唯一标识符。即用于命令行激活,也用于在继承时合并具有相同标识符的profile。-->    
    286.    <id/>    
    287.    <!--自动触发profile的条件逻辑。Activation是profile的开启钥匙。profile的力量来自于它    
    288.    能够在某些特定的环境中自动使用某些特定的值;这些环境通过activation元素指定。activation元素并不是激活profile的唯一方式。-->    
    289.    <activation>    
    290.     <!--profile默认是否激活的标志-->    
    291.     <activeByDefault/>    
    292.     <!--当匹配的jdk被检测到,profile被激活。例如,1.4激活JDK1.4,1.4.0_2,而!1.4激活所有版本不是以1.4开头的JDK。-->    
    293.     <jdk/>    
    294.     <!--当匹配的操作系统属性被检测到,profile被激活。os元素可以定义一些操作系统相关的属性。-->    
    295.     <os>    
    296.      <!--激活profile的操作系统的名字-->    
    297.      <name>Windows XP</name>    
    298.      <!--激活profile的操作系统所属家族(如 'windows')-->    
    299.      <family>Windows</family>    
    300.      <!--激活profile的操作系统体系结构 -->    
    301.      <arch>x86</arch>    
    302.      <!--激活profile的操作系统版本-->    
    303.      <version>5.1.2600</version>    
    304.     </os>    
    305.     <!--如果Maven检测到某一个属性(其值可以在POM中通过${名称}引用),其拥有对应的名称和值,Profile就会被激活。如果值    
    306.     字段是空的,那么存在属性名称字段就会激活profile,否则按区分大小写方式匹配属性值字段-->    
    307.     <property>    
    308.      <!--激活profile的属性的名称-->    
    309.      <name>mavenVersion</name>    
    310.      <!--激活profile的属性的值-->    
    311.      <value>2.0.3</value>    
    312.     </property>    
    313.     <!--提供一个文件名,通过检测该文件的存在或不存在来激活profile。missing检查文件是否存在,如果不存在则激活    
    314.     profile。另一方面,exists则会检查文件是否存在,如果存在则激活profile。-->    
    315.     <file>    
    316.      <!--如果指定的文件存在,则激活profile。-->    
    317.      <exists>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</exists>    
    318.      <!--如果指定的文件不存在,则激活profile。-->    
    319.      <missing>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</missing>    
    320.     </file>    
    321.    </activation>    
    322.    <!--构建项目所需要的信息。参见build元素-->    
    323.    <build>    
    324.     <defaultGoal/>    
    325.     <resources>    
    326.      <resource>    
    327.       <targetPath/><filtering/><directory/><includes/><excludes/>    
    328.      </resource>    
    329.     </resources>    
    330.     <testResources>    
    331.      <testResource>    
    332.       <targetPath/><filtering/><directory/><includes/><excludes/>    
    333.      </testResource>    
    334.     </testResources>    
    335.     <directory/><finalName/><filters/>    
    336.     <pluginManagement>    
    337.      <plugins>    
    338.       <!--参见build/pluginManagement/plugins/plugin元素-->    
    339.       <plugin>    
    340.        <groupId/><artifactId/><version/><extensions/>    
    341.        <executions>    
    342.         <execution>    
    343.          <id/><phase/><goals/><inherited/><configuration/>    
    344.         </execution>    
    345.        </executions>    
    346.        <dependencies>    
    347.         <!--参见dependencies/dependency元素-->    
    348.         <dependency>    
    349.          ......    
    350.         </dependency>    
    351.        </dependencies>    
    352.        <goals/><inherited/><configuration/>    
    353.       </plugin>    
    354.      </plugins>    
    355.     </pluginManagement>    
    356.     <plugins>    
    357.      <!--参见build/pluginManagement/plugins/plugin元素-->    
    358.      <plugin>    
    359.       <groupId/><artifactId/><version/><extensions/>    
    360.       <executions>    
    361.        <execution>    
    362.         <id/><phase/><goals/><inherited/><configuration/>    
    363.        </execution>    
    364.       </executions>    
    365.       <dependencies>    
    366.        <!--参见dependencies/dependency元素-->    
    367.        <dependency>    
    368.         ......    
    369.        </dependency>    
    370.       </dependencies>    
    371.       <goals/><inherited/><configuration/>    
    372.      </plugin>    
    373.     </plugins>    
    374.    </build>    
    375.    <!--模块(有时称作子项目) 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径-->    
    376.    <modules/>    
    377.    <!--发现依赖和扩展的远程仓库列表。-->    
    378.    <repositories>    
    379.     <!--参见repositories/repository元素-->    
    380.     <repository>    
    381.      <releases>    
    382.       <enabled/><updatePolicy/><checksumPolicy/>    
    383.      </releases>    
    384.      <snapshots>    
    385.       <enabled/><updatePolicy/><checksumPolicy/>    
    386.      </snapshots>    
    387.      <id/><name/><url/><layout/>    
    388.     </repository>    
    389.    </repositories>    
    390.    <!--发现插件的远程仓库列表,这些插件用于构建和报表-->    
    391.    <pluginRepositories>    
    392.     <!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素-->        
    393.     <pluginRepository>    
    394.      <releases>    
    395.       <enabled/><updatePolicy/><checksumPolicy/>    
    396.      </releases>    
    397.      <snapshots>    
    398.       <enabled/><updatePolicy/><checksumPolicy/>    
    399.      </snapshots>    
    400.      <id/><name/><url/><layout/>    
    401.     </pluginRepository>    
    402.    </pluginRepositories>    
    403.    <!--该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息,请看项目依赖机制。-->    
    404.    <dependencies>    
    405.     <!--参见dependencies/dependency元素-->    
    406.     <dependency>    
    407.      ......    
    408.     </dependency>    
    409.    </dependencies>    
    410.    <!--不赞成使用. 现在Maven忽略该元素.-->    
    411.    <reports/>       
    412.    <!--该元素包括使用报表插件产生报表的规范。当用户执行“mvn site”,这些报表就会运行。 在页面导航栏能看到所有报表的链接。参见reporting元素-->    
    413.    <reporting>    
    414.     ......    
    415.    </reporting>    
    416.    <!--参见dependencyManagement元素-->    
    417.    <dependencyManagement>    
    418.     <dependencies>    
    419.      <!--参见dependencies/dependency元素-->    
    420.      <dependency>    
    421.       ......    
    422.      </dependency>    
    423.     </dependencies>    
    424.    </dependencyManagement>    
    425.    <!--参见distributionManagement元素-->    
    426.    <distributionManagement>    
    427.     ......    
    428.    </distributionManagement>    
    429.    <!--参见properties元素-->    
    430.    <properties/>    
    431.   </profile>    
    432.  </profiles>    
    433.  <!--模块(有时称作子项目) 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径-->    
    434.  <modules/>    
    435.     <!--发现依赖和扩展的远程仓库列表。-->     
    436.     <repositories>     
    437.      <!--包含需要连接到远程仓库的信息-->    
    438.         <repository>    
    439.          <!--如何处理远程仓库里发布版本的下载-->    
    440.          <releases>    
    441.           <!--true或者false表示该仓库是否为下载某种类型构件(发布版,快照版)开启。 -->    
    442.     <enabled/>    
    443.     <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是:always(一直),daily(默认,每日),interval:X(这里X是以分钟为单位的时间间隔),或者never(从不)。-->    
    444.     <updatePolicy/>    
    445.     <!--当Maven验证构件校验文件失败时该怎么做:ignore(忽略),fail(失败),或者warn(警告)。-->    
    446.     <checksumPolicy/>    
    447.    </releases>    
    448.    <!-- 如何处理远程仓库里快照版本的下载。有了releases和snapshots这两组配置,POM就可以在每个单独的仓库中,为每种类型的构件采取不同的 策略。例如,可能有人会决定只为开发目的开启对快照版本下载的支持。参见repositories/repository/releases元素 -->    
    449.    <snapshots>    
    450.     <enabled/><updatePolicy/><checksumPolicy/>    
    451.    </snapshots>    
    452.    <!--远程仓库唯一标识符。可以用来匹配在settings.xml文件里配置的远程仓库-->    
    453.    <id>banseon-repository-proxy</id>     
    454.    <!--远程仓库名称-->    
    455.             <name>banseon-repository-proxy</name>     
    456.             <!--远程仓库URL,按protocol://hostname/path形式-->    
    457.             <url>http://192.168.1.169:9999/repository/</url>     
    458.             <!-- 用于定位和排序构件的仓库布局类型-可以是default(默认)或者legacy(遗留)。Maven 2为其仓库提供了一个默认的布局;然 而,Maven 1.x有一种不同的布局。我们可以使用该元素指定布局是default(默认)还是legacy(遗留)。-->    
    459.             <layout>default</layout>               
    460.         </repository>     
    461.     </repositories>    
    462.     <!--发现插件的远程仓库列表,这些插件用于构建和报表-->    
    463.     <pluginRepositories>    
    464.      <!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素-->    
    465.   <pluginRepository>    
    466.    ......    
    467.   </pluginRepository>    
    468.  </pluginRepositories>    
    469.        
    470.     <!--该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息,请看项目依赖机制。-->     
    471.     <dependencies>     
    472.         <dependency>    
    473.    <!--依赖的group ID-->    
    474.             <groupId>org.apache.maven</groupId>     
    475.             <!--依赖的artifact ID-->    
    476.             <artifactId>maven-artifact</artifactId>     
    477.             <!--依赖的版本号。 在Maven 2里, 也可以配置成版本号的范围。-->    
    478.             <version>3.8.1</version>     
    479.             <!-- 依赖类型,默认类型是jar。它通常表示依赖的文件的扩展名,但也有例外。一个类型可以被映射成另外一个扩展名或分类器。类型经常和使用的打包方式对应, 尽管这也有例外。一些类型的例子:jar,war,ejb-client和test-jar。如果设置extensions为 true,就可以在 plugin里定义新的类型。所以前面的类型的例子不完整。-->    
    480.             <type>jar</type>    
    481.             <!-- 依赖的分类器。分类器可以区分属于同一个POM,但不同构建方式的构件。分类器名被附加到文件名的版本号后面。例如,如果你想要构建两个单独的构件成 JAR,一个使用Java 1.4编译器,另一个使用Java 6编译器,你就可以使用分类器来生成两个单独的JAR构件。-->    
    482.             <classifier></classifier>    
    483.             <!--依赖范围。在项目发布过程中,帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。    
    484.                 - compile :默认范围,用于编译      
    485.                 - provided:类似于编译,但支持你期待jdk或者容器提供,类似于classpath      
    486.                 - runtime: 在执行时需要使用      
    487.                 - test:    用于test任务时使用      
    488.                 - system: 需要外在提供相应的元素。通过systemPath来取得      
    489.                 - systemPath: 仅用于范围为system。提供相应的路径      
    490.                 - optional:   当项目自身被依赖时,标注依赖是否传递。用于连续依赖时使用-->     
    491.             <scope>test</scope>       
    492.             <!--仅供system范围使用。注意,不鼓励使用这个元素,并且在新的版本中该元素可能被覆盖掉。该元素为依赖规定了文件系统上的路径。需要绝对路径而不是相对路径。推荐使用属性匹配绝对路径,例如${java.home}。-->    
    493.             <systemPath></systemPath>     
    494.             <!--当计算传递依赖时, 从依赖构件列表里,列出被排除的依赖构件集。即告诉maven你只依赖指定的项目,不依赖项目的依赖。此元素主要用于解决版本冲突问题-->    
    495.             <exclusions>    
    496.              <exclusion>     
    497.                     <artifactId>spring-core</artifactId>     
    498.                     <groupId>org.springframework</groupId>     
    499.                 </exclusion>     
    500.             </exclusions>       
    501.             <!--可选依赖,如果你在项目B中把C依赖声明为可选,你就需要在依赖于B的项目(例如项目A)中显式的引用对C的依赖。可选依赖阻断依赖的传递性。-->     
    502.             <optional>true</optional>    
    503.         </dependency>    
    504.     </dependencies>    
    505.     <!--不赞成使用. 现在Maven忽略该元素.-->    
    506.     <reports></reports>    
    507.     <!--该元素描述使用报表插件产生报表的规范。当用户执行“mvn site”,这些报表就会运行。 在页面导航栏能看到所有报表的链接。-->    
    508.  <reporting>    
    509.   <!--true,则,网站不包括默认的报表。这包括“项目信息”菜单中的报表。-->    
    510.   <excludeDefaults/>    
    511.   <!--所有产生的报表存放到哪里。默认值是${project.build.directory}/site。-->    
    512.   <outputDirectory/>    
    513.   <!--使用的报表插件和他们的配置。-->    
    514.   <plugins>    
    515.    <!--plugin元素包含描述报表插件需要的信息-->    
    516.    <plugin>    
    517.     <!--报表插件在仓库里的group ID-->    
    518.     <groupId/>    
    519.     <!--报表插件在仓库里的artifact ID-->    
    520.     <artifactId/>    
    521.     <!--被使用的报表插件的版本(或版本范围)-->    
    522.     <version/>    
    523.     <!--任何配置是否被传播到子项目-->    
    524.     <inherited/>    
    525.     <!--报表插件的配置-->    
    526.     <configuration/>    
    527.     <!--一组报表的多重规范,每个规范可能有不同的配置。一个规范(报表集)对应一个执行目标 。例如,有1,2,3,4,5,6,7,8,9个报表。1,2,5构成A报表集,对应一个执行目标。2,5,8构成B报表集,对应另一个执行目标-->    
    528.     <reportSets>    
    529.      <!--表示报表的一个集合,以及产生该集合的配置-->    
    530.      <reportSet>    
    531.       <!--报表集合的唯一标识符,POM继承时用到-->    
    532.       <id/>    
    533.       <!--产生报表集合时,被使用的报表的配置-->    
    534.       <configuration/>    
    535.       <!--配置是否被继承到子POMs-->    
    536.       <inherited/>    
    537.       <!--这个集合里使用到哪些报表-->    
    538.       <reports/>    
    539.      </reportSet>    
    540.     </reportSets>    
    541.    </plugin>    
    542.   </plugins>    
    543.  </reporting>    
    544.  <!-- 继承自该项目的所有子项目的默认依赖信息。这部分的依赖信息不会被立即解析,而是当子项目声明一个依赖(必须描述group ID和 artifact ID信息),如果group ID和artifact ID以外的一些信息没有描述,则通过group ID和artifact ID 匹配到这里的依赖,并使用这里的依赖信息。-->    
    545.  <dependencyManagement>    
    546.   <dependencies>    
    547.    <!--参见dependencies/dependency元素-->    
    548.    <dependency>    
    549.     ......    
    550.    </dependency>    
    551.   </dependencies>    
    552.  </dependencyManagement>       
    553.     <!--项目分发信息,在执行mvn deploy后表示要发布的位置。有了这些信息就可以把网站部署到远程服务器或者把构件部署到远程仓库。-->     
    554.     <distributionManagement>    
    555.         <!--部署项目产生的构件到远程仓库需要的信息-->    
    556.         <repository>    
    557.          <!--是分配给快照一个唯一的版本号(由时间戳和构建流水号)?还是每次都使用相同的版本号?参见repositories/repository元素-->    
    558.    <uniqueVersion/>    
    559.    <id>banseon-maven2</id>     
    560.    <name>banseon maven2</name>     
    561.             <url>file://${basedir}/target/deploy</url>     
    562.             <layout/>    
    563.   </repository>    
    564.   <!--构件的快照部署到哪里?如果没有配置该元素,默认部署到repository元素配置的仓库,参见distributionManagement/repository元素-->     
    565.   <snapshotRepository>    
    566.    <uniqueVersion/>    
    567.    <id>banseon-maven2</id>    
    568.             <name>Banseon-maven2 Snapshot Repository</name>    
    569.             <url>scp://svn.baidu.com/banseon:/usr/local/maven-snapshot</url>     
    570.    <layout/>    
    571.   </snapshotRepository>    
    572.   <!--部署项目的网站需要的信息-->     
    573.         <site>    
    574.          <!--部署位置的唯一标识符,用来匹配站点和settings.xml文件里的配置-->     
    575.             <id>banseon-site</id>     
    576.             <!--部署位置的名称-->    
    577.             <name>business api website</name>     
    578.             <!--部署位置的URL,按protocol://hostname/path形式-->    
    579.             <url>     
    580.                 scp://svn.baidu.com/banseon:/var/www/localhost/banseon-web      
    581.             </url>     
    582.         </site>    
    583.   <!--项目下载页面的URL。如果没有该元素,用户应该参考主页。使用该元素的原因是:帮助定位那些不在仓库里的构件(由于license限制)。-->    
    584.   <downloadUrl/>    
    585.   <!--如果构件有了新的group ID和artifact ID(构件移到了新的位置),这里列出构件的重定位信息。-->    
    586.   <relocation>    
    587.    <!--构件新的group ID-->    
    588.    <groupId/>    
    589.    <!--构件新的artifact ID-->    
    590.    <artifactId/>    
    591.    <!--构件新的版本号-->    
    592.    <version/>    
    593.    <!--显示给用户的,关于移动的额外信息,例如原因。-->    
    594.    <message/>    
    595.   </relocation>    
    596.   <!-- 给出该构件在远程仓库的状态。不得在本地项目中设置该元素,因为这是工具自动更新的。有效的值有:none(默认),converted(仓库管理员从 Maven 1 POM转换过来),partner(直接从伙伴Maven 2仓库同步过来),deployed(从Maven 2实例部 署),verified(被核实时正确的和最终的)。-->    
    597.   <status/>           
    598.     </distributionManagement>    
    599.     <!--以值替代名称,Properties可以在整个POM中使用,也可以作为触发条件(见settings.xml配置文件里activation元素的说明)。格式是<name>value</name>。-->    
    600.     <properties/>    
    601. </project>  </span> 

    展开全文
  • 官方关于pom文件的说明 下面是在中的可直接使用的标签表 对于各标签的解释和使用,文档下面有官方的详细说明,最后结合实际项目中的pom文件学习
  • 本文转载至 https://www.cnblogs.com/yuanpeng-java/p/10218822.html <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLoca...
  • Maven pom文件基本结构一

    千次阅读 2019-01-01 11:53:20
    POM文件结构 Project Object Model是Maven2项目的基础所在,简单来说它就是一个XML文件,Maven2用它来描述一个工程的整个生命周期所需要执行的一系列功能和特性。 最小配置 任何项目都最少要包含以下几个标签。 ...
  • mavenpom文件详解

    万次阅读 多人点赞 2019-06-15 16:59:29
    pom文件定于了一个maven项目的maven配置,一般pom文件的放在项目或者模块的根目录下。 maven的遵循约定大于配置,约定了如下的目录结构: 目录 目的 ${basedir} 存放pom.xml和所有的子目录 ${basedir}...
  • maven pom.xml配置文件中的packaging标签

    千次阅读 2020-04-09 15:12:53
    标签,它默认是jar类型。 pom:父类型都为pom类型 <packaging>pom</packaging> jar:内部调用或者是作服务使用 <packaging>jar</packaging> war:打包项目,用于在容器(Tomcat、...
  • maven POM.xml 标签详解

    万次阅读 多人点赞 2014-06-21 17:00:45
    <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
  • groupId:项目或组织的唯一标识,并且配置时生成的路径也是由此生成 ...url:哪个网站可以找到这个项目,提示如果 Maven 资源列表没有,可以直接上该网站寻找, Maven 产生的文档用 description:项目的描...
  • maven pom文件标签含义

    2019-06-14 14:41:00
    1、dependency里面的scope dependency里面的classifier dependency里面的type dependency里面的systemPath dependency里面的optional: ...mavenpom.xml有些依赖为什么可以不写版本号。因为他的...
  • 主要描述了:项目的 maven 坐标、依赖关系、开发者需要遵循的规则、缺陷管理系统、组织和 licenses、项目的 url、项目的依赖性,以及其他所有的项目相关因素。 一、基础配置 <project xmlns=...
  • 本人在进行项目开发时进行进行一些pom依赖的配置,总结一下常用标签,方便自己以后开发。 目录 modelVersion parent groupId artifactId version relativePath packaging modules name、url、description ...
  • Maven项目POM文件参数详解

    千次阅读 2019-11-12 15:49:50
    内容源自网上,留做笔记 <project xmlns="http://maven.apache.org/POM/4.0.0 " xmlns:xsi=... xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.a...
  • Maven pom.xml标签详解

    2020-02-18 18:08: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_...
  • 因为自己在pom文件上花费了很长时间解决问题,因为自己对pom文件不是很熟悉和了解,然后就自己找了一些标签,来进一步让自己理解pom文件pom文件中书写的标签的详解: pom文件的作用: Maven 是专门用于构建和管理...
  • Maven POM文件中依赖与插件的配置

    万次阅读 多人点赞 2017-08-27 23:21:51
    POM(Project Object Model)是 Maven 工程的工作基础,以 pom.xml 的形式存在于项目中,在这里配置构建工程的详细信息。它为大多数项目都预先配置了一些默认值,如构建目录 build,源码目录 src/main/java,测试...
  • maven pom文件标签详解

    千次阅读 2018-04-26 23:46:56
    ** 转载自https://www.cnblogs.com/sharpest/p/7738444.html ** &amp;lt;span style=&quot;padding:0px;...http://maven.apache.org/POM/4.0.0&quot; xmlns:xsi=&quot;http://ww
  • Maven配置文件POM属性最全详解

    千次阅读 2018-08-20 10:42:25
    &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="... xsi:schemaLocation="http://maven.apache.org/POM/4.0.0http://maven.apache....
  • Mavenpom文件详细解析

    千次阅读 2018-03-23 10:47:50
    &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="... xsi:schemaLocation="http://maven.apache.org/POM/4.0.0http://maven.apache.org/maven-v4_0_0.xs...
  • maven pom文件详解

    千次阅读 2018-06-13 17:23:43
    http://www.blogjava.net/hellxoul/archive/2013/05/16/399345.html...前言Maven,发音是[`meivin],"专家"的意思。它是一个很好的项目管理工具,很早就进入了我的必备工具行列,但是这次为了把project1项...
  • com.xxx.yy dip-dubbo-api 1.0 dip-dubbo-api 平台接口定义模块 http://maven.apache.org jar 4.0.0
  • Linux安装MavenPOM及配置文件详解

    千次阅读 2020-06-02 12:10:21
    下载Maven 下载地址 https://maven.apache.org/download.cgi 下载maven安装包 [root@oahzero]# wget https://mirrors.tuna.tsinghua.edu.cn/apache/maven/maven-3/3.6.3/binaries/apache-maven-3.6.3-bin.tar.gz ...
  • 目录   一:Maven的概述 1:maven的概念 2:maven的作用 ...五:pom.xml文件 1:jar包依赖 2:jar包的作用范围 3:插件 六.自定义骨架步骤 一:Maven的概述 1:maven的概念 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/xsd/maven-4.0.0.
  • MAVEN pom.xml标签详解

    2018-10-22 16:33:40
    pom文件作为MAVEN中重要的配置文件,对于它的配置是相当重要。文件中包含了开发者需遵循的规则、缺陷管理系统、组织、licenses、项目信息、项目依赖性等。下面将重点介绍一下该文件的基本组成与功能。 标签预览 &...
  • mavenpom.xml文件标签的含义

    千次阅读 2018-01-31 20:22:00
    通过xml表示maven项目,使用pom.xml来实现。主要描述了项目:包括配置文件;开发者需要遵循的规则,缺陷管理系统,组织和licenses,项目的url,项目的依赖性,以及其他所有的项目相关因素。 [xml] view plain copy ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,348
精华内容 10,939
关键字:

mavenpom文件的url标签