Maven的pom.xml介绍

最新推荐文章于 2024-07-18 17:41:08 发布
最新推荐文章于 2024-07-18 17:41:08 发布
阅读量616 收藏 1
点赞数 1
分类专栏： java maven pom 文章标签： maven pom pom配置 pom配置详情
java 同时被 3 个专栏收录
4 篇文章 0 订阅
订阅专栏
maven
1 篇文章 0 订阅
订阅专栏
pom
1 篇文章 0 订阅
订阅专栏

6.1  简介

       pom.xml文件是Maven进行工作的主要配置文件。在这个文件中我们可以配置Maven项目的groupId、artifactId和version等Maven项目必须的元素；可以配置Maven项目需要使用的远程仓库；可以定义Maven项目打包的形式；可以定义Maven项目的资源依赖关系等等。对于一个最简单的pom.xml的定义必须包含modelVersion、groupId、artifactId和version这四个元素，当然这其中的元素也是可以从它的父项目中继承的。在Maven中，使用groupId、artifactId和version组成groupdId:artifactId:version的形式来唯一确定一个项目。

6.2     pom.xml的继承、聚合与依赖

       我们知道Maven在建立项目的时候是基于Maven项目下的pom.xml进行的，我们项目依赖的信息和一些基本信息都是在这个文件里面定义的。那如果当我们有多个项目要进行，这多个项目有些配置内容是相同的，有些是要彼此关联的，那如果按照传统的做法的话我们就需要在多个项目中都定义这些重复的内容。这无疑是非常耗费时间和不易维护的。好在Maven给我们提供了一个pom的继承和聚合的功能。

       对于使用java的人而言，继承这个词大家应该都不陌生。要继承pom就需要有一个父pom，在Maven中定义了超级pom.xml，任何没有申明自己父pom.xml的pom.xml都将默认继承自这个超级pom.xml。

       先来看一下这个超级pom.xml的定义：

Xml代码   收藏代码
  1. <project>  
  2.   <modelVersion>4.0.0</modelVersion>  
  3.   <name>Maven Default Project</name>  
  4.    
  5.   <repositories>  
  6.     <repository>  
  7.       <id>central</id>  
  8.       <name>Maven Repository Switchboard</name>  
  9.       <layout>default</layout>  
  10.       <url>http://repo1.maven.org/maven2</url>  
  11.       <snapshots>  
  12.         <enabled>false</enabled>  
  13.       </snapshots>  
  14.     </repository>  
  15.   </repositories>  
  16.    
  17.   <pluginRepositories>  
  18.     <pluginRepository>  
  19.       <id>central</id>  
  20.       <name>Maven Plugin Repository</name>  
  21.       <url>http://repo1.maven.org/maven2</url>  
  22.       <layout>default</layout>  
  23.       <snapshots>  
  24.         <enabled>false</enabled>  
  25.       </snapshots>  
  26.       <releases>  
  27.         <updatePolicy>never</updatePolicy>  
  28.       </releases>  
  29.     </pluginRepository>  
  30.   </pluginRepositories>  
  31.    
  32.   <build>  
  33.     <directory>${project.basedir}/target</directory>  
  34.     <outputDirectory>${project.build.directory}/classes</outputDirectory>  
  35.     <finalName>${project.artifactId}-${project.version}</finalName>  
  36.     <testOutputDirectory>${project.build.directory}/test-classes</testOutputDirectory>  
  37.     <sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>  
  38.     <!-- TODO: MNG-3731 maven-plugin-tools-api < 2.4.4 expect this to be relative... -->  
  39.     <scriptSourceDirectory>src/main/scripts</scriptSourceDirectory>  
  40.     <testSourceDirectory>${project.basedir}/src/test/java</testSourceDirectory>  
  41.     <resources>  
  42.       <resource>  
  43.         <directory>${project.basedir}/src/main/resources</directory>  
  44.       </resource>  
  45.     </resources>  
  46.     <testResources>  
  47.       <testResource>  
  48.         <directory>${project.basedir}/src/test/resources</directory>  
  49.       </testResource>  
  50.     </testResources>  
  51.    <pluginManagement>  
  52.        <plugins>  
  53.          <plugin>  
  54.            <artifactId>maven-antrun-plugin</artifactId>  
  55.            <version>1.3</version>  
  56.          </plugin>        
  57.          <plugin>  
  58.            <artifactId>maven-assembly-plugin</artifactId>  
  59.            <version>2.2-beta-2</version>  
  60.          </plugin>          
  61.          <plugin>  
  62.            <artifactId>maven-clean-plugin</artifactId>  
  63.            <version>2.2</version>  
  64.          </plugin>  
  65.          <plugin>  
  66.            <artifactId>maven-compiler-plugin</artifactId>  
  67.            <version>2.0.2</version>  
  68.          </plugin>  
  69.          <plugin>  
  70.            <artifactId>maven-dependency-plugin</artifactId>  
  71.            <version>2.0</version>  
  72.          </plugin>  
  73.          <plugin>  
  74.            <artifactId>maven-deploy-plugin</artifactId>  
  75.            <version>2.4</version>  
  76.          </plugin>  
  77.          <plugin>  
  78.            <artifactId>maven-ear-plugin</artifactId>  
  79.            <version>2.3.1</version>  
  80.          </plugin>  
  81.          <plugin>  
  82.            <artifactId>maven-ejb-plugin</artifactId>  
  83.            <version>2.1</version>  
  84.          </plugin>  
  85.          <plugin>  
  86.            <artifactId>maven-install-plugin</artifactId>  
  87.            <version>2.2</version>  
  88.          </plugin>  
  89.          <plugin>  
  90.            <artifactId>maven-jar-plugin</artifactId>  
  91.            <version>2.2</version>  
  92.          </plugin>  
  93.          <plugin>  
  94.            <artifactId>maven-javadoc-plugin</artifactId>  
  95.            <version>2.5</version>  
  96.          </plugin>  
  97.          <plugin>  
  98.            <artifactId>maven-plugin-plugin</artifactId>  
  99.            <version>2.4.3</version>  
  100.          </plugin>  
  101.          <plugin>  
  102.            <artifactId>maven-rar-plugin</artifactId>  
  103.            <version>2.2</version>  
  104.          </plugin>         
  105.          <plugin>                 
  106.            <artifactId>maven-release-plugin</artifactId>  
  107.            <version>2.0-beta-8</version>  
  108.          </plugin>  
  109.          <plugin>                  
  110.            <artifactId>maven-resources-plugin</artifactId>  
  111.            <version>2.3</version>  
  112.          </plugin>  
  113.          <plugin>  
  114.            <artifactId>maven-site-plugin</artifactId>  
  115.            <version>2.0-beta-7</version>  
  116.          </plugin>  
  117.          <plugin>  
  118.            <artifactId>maven-source-plugin</artifactId>  
  119.            <version>2.0.4</version>  
  120.          </plugin>          
  121.          <plugin>  
  122.             <artifactId>maven-surefire-plugin</artifactId>  
  123.             <version>2.4.3</version>  
  124.          </plugin>  
  125.          <plugin>  
  126.            <artifactId>maven-war-plugin</artifactId>  
  127.            <version>2.1-alpha-2</version>  
  128.          </plugin>  
  129.        </plugins>  
  130.      </pluginManagement>  
  131.   </build>  
  132.    
  133.   <reporting>  
  134.     <outputDirectory>${project.build.directory}/site</outputDirectory>  
  135.   </reporting>  
  136.   <profiles>  
  137.     <profile>  
  138.       <id>release-profile</id>  
  139.    
  140.       <activation>  
  141.         <property>  
  142.           <name>performRelease</name>  
  143.           <value>true</value>  
  144.         </property>  
  145.       </activation>  
  146.    
  147.       <build>  
  148.         <plugins>  
  149.           <plugin>  
  150.             <inherited>true</inherited>  
  151.             <groupId>org.apache.maven.plugins</groupId>  
  152.             <artifactId>maven-source-plugin</artifactId>  
  153.             <executions>  
  154.               <execution>  
  155.                 <id>attach-sources</id>  
  156.                 <goals>  
  157.                   <goal>jar</goal>  
  158.                 </goals>  
  159.               </execution>  
  160.             </executions>  
  161.           </plugin>  
  162.           <plugin>  
  163.             <inherited>true</inherited>  
  164.             <groupId>org.apache.maven.plugins</groupId>  
  165.             <artifactId>maven-javadoc-plugin</artifactId>  
  166.             <executions>  
  167.               <execution>  
  168.                 <id>attach-javadocs</id>  
  169.                 <goals>  
  170.                   <goal>jar</goal>  
  171.                 </goals>  
  172.               </execution>  
  173.             </executions>  
  174.           </plugin>  
  175.           <plugin>  
  176.             <inherited>true</inherited>  
  177.             <groupId>org.apache.maven.plugins</groupId>  
  178.             <artifactId>maven-deploy-plugin</artifactId>  
  179.             <configuration>  
  180.               <updateReleaseInfo>true</updateReleaseInfo>  
  181.             </configuration>  
  182.           </plugin>  
  183.         </plugins>  
  184.       </build>  
  185.     </profile>  
  186.   </profiles>  
  187.    
  188. </project>  

 

       对于一个pom.xml来说有几个元素是必须定义的，一个是project根元素，然后就是它里面的modelVersion、groupId、artifactId和version。由上面的超级pom.xml的内容我们可以看到pom.xml中没有groupId、artifactId和version的定义，所以我们在建立自己的pom.xml的时候就需要定义这三个元素。和java里面的继承类似，子pom.xml会完全继承父pom.xml中所有的元素，而且对于相同的元素，一般子pom.xml中的会覆盖父pom.xml中的元素，但是有几个特殊的元素它们会进行合并而不是覆盖。这些特殊的元素是：

Ø  dependencies

Ø  developers

Ø  contributors

Ø  plugin列表，包括plugin下面的reports

Ø  resources

6.2.1继承

6.2.1.1被继承项目与继承项目是父子目录关系

       现在假设我们有一个项目projectA，它的pom.xml定义如下：

Xml代码   收藏代码
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
  3.   <modelVersion>4.0.0</modelVersion>  
  4.   <groupId>com.tiantian.mavenTest</groupId>  
  5.   <artifactId>projectA</artifactId>  
  6.   <packaging>jar</packaging>  
  7.   <version>1.0-SNAPSHOT</version>  
  8. </project>  

 

       然后我们有另一个项目projectB，而且projectB是跟projectA的pom.xml文件处于同一个目录下，这时候如果projectB需要继承自projectA的话我们可以这样定义projectB的pom.xml文件。

Xml代码   收藏代码
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
  3.   <parent>  
  4.     <groupId>com.tiantian.mavenTest</groupId>  
  5.     <artifactId>projectA</artifactId>  
  6.     <version>1.0-SNAPSHOT</version>  
  7.   </parent>  
  8.   <modelVersion>4.0.0</modelVersion>  
  9.   <groupId>com.tiantian.mavenTest</groupId>  
  10.   <artifactId>projectB</artifactId>  
  11.   <packaging>jar</packaging>  
  12.   <version>1.0-SNAPSHOT</version>  
  13. </project>  

 

       由projectB的pom.xml文件的定义我们可以知道，当需要继承指定的一个Maven项目时，我们需要在自己的pom.xml中定义一个parent元素，在这个元素中指明需要继承项目的groupId、artifactId和version。

6.2.1.2被继承项目与继承项目的目录结构不是父子关系

       当被继承项目与继承项目的目录结构不是父子关系的时候，我们再利用上面的配置是不能实现Maven项目的继承关系的，这个时候我们就需要在子项目的pom.xml文件定义中的parent元素下再加上一个relativePath元素的定义，用以描述父项目的pom.xml文件相对于子项目的pom.xml文件的位置。

       假设我们现在还是有上面两个项目，projectA和projectB，projectB还是继承自projectA，但是现在projectB不在projectA的子目录中，而是与projectA处于同一目录中。这个时候projectA和projectB的目录结构如下：

       ------projectA

              ------pom.xml

       ------projectB

              ------pom.xml

       这个时候我们可以看出projectA的pom.xml相对于projectB的pom.xml的位置是“../projectA/pom.xml”，所以这个时候projectB的pom.xml的定义应该如下所示：

Xml代码   收藏代码
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
  3.   <parent>  
  4.     <groupId>com.tiantian.mavenTest</groupId>  
  5.     <artifactId>projectA</artifactId>  
  6.     <version>1.0-SNAPSHOT</version>  
  7.        <relativePath>../projectA/pom.xml</relativePath>  
  8.   </parent>  
  9.   <modelVersion>4.0.0</modelVersion>  
  10.   <groupId>com.tiantian.mavenTest</groupId>  
  11.   <artifactId>projectB</artifactId>  
  12.   <packaging>jar</packaging>  
  13.   <version>1.0-SNAPSHOT</version>  
  14. </project>  

 

6.2.2聚合

       对于聚合这个概念搞java的人应该都不会陌生。先来说说我对聚合和被聚合的理解，比如说如果projectA聚合到projectB，那么我们就可以说projectA是projectB的子模块， projectB是被聚合项目，也可以类似于继承那样称为父项目。对于聚合而言，这个主体应该是被聚合的项目。所以，我们需要在被聚合的项目中定义它的子模块，而不是像继承那样在子项目中定义父项目。具体做法是：

Ø  修改被聚合项目的pom.xml中的packaging元素的值为pom

Ø  在被聚合项目的pom.xml中的modules元素下指定它的子模块项目

对于聚合而言，当我们在被聚合的项目上使用Maven命令时，实际上这些命令都会在它的子模块项目上使用。这就是Maven中聚合的一个非常重要的作用。假设这样一种情况，你同时需要打包或者编译projectA、projectB、projectC和projectD，按照正常的逻辑我们一个一个项目去使用mvn compile或mvn package进行编译和打包，对于使用Maven而言，你还是这样使用的话是非常麻烦的。因为Maven给我们提供了聚合的功能。我们只需要再定义一个超级项目，然后在超级项目的pom.xml中定义这个几个项目都是聚合到这个超级项目的。之后我们只需要对这个超级项目进行mvn compile，它就会把那些子模块项目都进行编译。

6.2.2.1被聚合项目和子模块项目在目录结构上是父子关系

还拿上面定义的projectA和projectB来举例子，现在假设我们需要把projectB聚合到projectA中。projectA和projectB的目录结构如下所示：

------projectA

       ------projectB

              -----pom.xml

       ------pom.xml

这个时候projectA的pom.xml应该这样定义：

 

Xml代码   收藏代码
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.   <modelVersion>4.0.0</modelVersion>  
  4.   <groupId>com.tiantian.mavenTest</groupId>  
  5.   <artifactId>projectA</artifactId>  
  6.   <version>1.0-SNAPSHOT</version>  
  7.   <packaging>pom</packaging>  
  8.   <modules>  
  9.        <module>projectB</module>  
  10.   </modules>  
  11. </project>  
 

 

由上面的定义我们可以看到被聚合的项目的packaging类型应该为pom，而且一个项目可以有多个子模块项目。对于聚合这种情况，我们使用子模块项目的artifactId来作为module的值，表示子模块项目相对于被聚合项目的地址，在上面的示例中就表示子模块projectB是处在被聚合项目的子目录下，即与被聚合项目的pom.xml处于同一目录。这里使用的module值是子模块projectB对应的目录名projectB，而不是子模块对应的artifactId。这个时候当我们对projectA进行mvn package命令时，实际上Maven也会对projectB进行打包。

6.2.2.2被聚合项目与子模块项目在目录结构上不是父子关系

那么当被聚合项目与子模块项目在目录结构上不是父子关系的时候，我们应该怎么来进行聚合呢？还是像继承那样使用relativePath元素吗？答案是非也，具体做法是在module元素中指定以相对路径的方式指定子模块。我们来看下面一个例子。

继续使用上面的projectA和projectB，还是需要把projectB聚合到projectA，但是projectA和projectB的目录结构不再是父子关系，而是如下所示的这种关系：

------projectA

       ------pom.xml

------projectB

       ------pom.xml

这个时候projectA的pom.xml文件就应该这样定义：

 

Xml代码   收藏代码
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.   <modelVersion>4.0.0</modelVersion>  
  4.    
  5.   <groupId>com.tiantian.mavenTest</groupId>  
  6.   <artifactId>projectA</artifactId>  
  7.   <version>1.0-SNAPSHOT</version>  
  8.   <packaging>pom</packaging>  
  9.   <modules>  
  10.        <module>../projectB</module>  
  11.   </modules>  
  12. </project>  
 

 

注意看module的值是“../projectB”，我们知道“..”是代表当前目录的上层目录，所以它表示子模块projectB是被聚合项目projectA的pom.xml文件所在目录（即projectA）的上层目录下面的子目录，即与projectA处于同一目录层次。注意，这里的projectB对应的是projectB这个项目的目录名称，而不是它的artifactId。

6.2.2.3聚合与继承同时进行

       假设有这样一种情况，有两个项目，projectA和projectB，现在我们需要projectB继承projectA，同时需要把projectB聚合到projectA。然后projectA和projectB的目录结构如下：

       ------projectA

              ------pom.xml

       ------projectB

              ------pom.xml

       那么这个时候按照上面说的那样，projectA的pom.xml中需要定义它的packaging为pom，需要定义它的modules，所以projectA的pom.xml应该这样定义：

Xml代码   收藏代码
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.   <modelVersion>4.0.0</modelVersion>  
  4.   <groupId>com.tiantian.mavenTest</groupId>  
  5.   <artifactId>projectA</artifactId>  
  6.   <version>1.0-SNAPSHOT</version>  
  7.   <packaging>pom</packaging>  
  8.   <modules>  
  9.        <module>../projectB</module>  
  10.   </modules>  
  11. </project>  

 

       而projectB是继承自projectA的，所以我们需要在projectB的pom.xml文件中新增一个parent元素，用以定义它继承的项目信息。所以projectB的pom.xml文件的内容应该这样定义：

Xml代码   收藏代码
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.   <modelVersion>4.0.0</modelVersion>  
  4.   <parent>  
  5.        <groupId>com.tiantian.mavenTest</groupId>  
  6.        <artifactId>projectA</artifactId>  
  7.        <version>1.0-SNAPSHOT</version>  
  8.        <relativePath>../projectA/pom.xml</relativePath>  
  9.   </parent>  
  10.   <groupId>com.tiantian.mavenTest</groupId>  
  11.   <artifactId>projectB</artifactId>  
  12.   <version>1.0-SNAPSHOT</version>  
  13.   <packaging>jar</packaging>  
  14. </project>  

 

6.2.3依赖Dependency

       项目之间的依赖是通过pom.xml文件里面的dependencies元素下面的dependency元素进行的。一个dependency元素定义一个依赖关系。在dependency元素中我们主要通过依赖项目的groupId、artifactId和version来定义所依赖的项目。

       先来看一个简单的项目依赖的示例吧，假设我现在有一个项目projectA，然后它里面有对junit的依赖，那么它的pom.xml就类似以下这个样子：

Xml代码   收藏代码
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.   <modelVersion>4.0.0</modelVersion>  
  4.   <groupId>com.tiantian.mavenTest</groupId>  
  5.   <artifactId>projectB</artifactId>  
  6.   <version>1.0-SNAPSHOT</version>  
  7.   <packaging>jar</packaging>  
  8.    
  9.   <dependencies>  
  10.     <dependency>  
  11.       <groupId>junit</groupId>  
  12.       <artifactId>junit</artifactId>  
  13.       <version>3.8.1</version>  
  14.       <scope>test</scope>  
  15.               <optional>true</optional>  
  16.     </dependency>  
  17.   </dependencies>  
  18. </project>  

 

       在dependency元素中除了可以指定依赖项目的groupId、artifactId和version之外，还可以指定以下元素：

Ø  type：对应于依赖项目的packaging类型，默认是jar

Ø  scope：表示依赖项目的一个作用范围。scope的主要取值范围如下（还有一个是在Maven2.0.9以后版本才支持的import，关于import作用域将在后文《Dependency介绍》中做介绍）：

n  compile：这是它的默认值，这种类型很容易让人产生误解，以为只有在编译的时候才是需要的，其实这种类型表示所有的情况都是有用的，包括编译和运行时。而且这种类型的依赖性是可以传递的。

n  provided：这个跟compile很类似，但是它表示你期望这个依赖项目在运行时由JDK或者容器来提供。这种类型表示该依赖只有在测试和编译的情况下才有效，在运行时将由JDK或者容器提供。这种类型的依赖性是不可传递的。

n  runtime：这种类型表示该依赖在编译的时候不是必须的，只有在运行的时候才是必须的。

n  test：这表示这种依赖只有测试的时候才需要，正常情况下是不需要的。

n  system：这种类型跟provided类似，唯一不同的就是这种类型的依赖我们要自己提供jar包，这需要与另一个元素systemPath来结合使用。systemPath将指向我们系统上的jar包的路径，而且必须是给定的绝对路径。

Ø  systemPath：上面已经说过了这个元素是在scope的值为system的时候用于指定依赖的jar包在系统上的位置的，而且是绝对路径。该元素必须在依赖的 jar包的scope为system时才能使用，否则Maven将报错。

Ø  optional：当该项目本身作为其他项目的一个依赖时标记该依赖为可选项。假设现在projectA有一个依赖性projectB，我们把projectB这个依赖项设为optional，这表示projectB在projectA的运行时不一定会用到。这个时候如果我们有另一个项目projectC，它依赖于projectA，那么这个时候因为projectB对于projectA是可选的，所以Maven在建立projectC的时候就不会安装projectB，这个时候如果projectC确实需要使用到projectB，那么它就可以定义自己对projectB的依赖。当一个依赖是可选的时候，我们把optional元素的值设为true，否则就不设置optional元素。

Ø  exclusions：考虑这样一种情况，我们的projectA依赖于projectB，然后projectB又依赖于projectC，但是在projectA里面我们不需要projectB依赖的projectC，那么这个时候我们就可以在依赖projectB的时候使用exclusions元素下面的exclusion排除projectC。这个时候我们可以这样定义projectA对projectB的依赖：

Xml代码   收藏代码
  1. <dependencies>  
  2.      <dependency>  
  3.             <groupId>com.tiantian.mavenTest</groupId>  
  4.             <artifactId>projectB</artifactId>  
  5.             <version>1.0-SNAPSHOT</version>  
  6.             <exclusions>  
  7.                    <exclusion>  
  8.                           <groupId>com.tiantian.mavenTest</groupId>  
  9.                           <artifactId>projectC</artifactId>  
  10.                    </exclusion>  
  11.             </exclusions>  
  12.      </dependency>  
  13. </dependencies>  

 

 

6.3     属性

在pom.xml文件中我们可以使用${propertyName}的形式引用属性。这个propertyName有以下几种形式：

Ø  env.propertyName：这种形式表示引用的是环境变量，比如我们需要引用当前系统的环境变量PATH的时候，就可以使用${env.PATH}。

Ø  project.propertyName：这种形式表示引用的是当前这个pom.xml中project根元素下面的子元素的值。比如我们需要引用当前project下面的version的时候，就可以使用${project.version}。

Ø  settings.propertyName：这种形式引用的是Maven本地配置文件settings.xml或本地Maven安装目录下的settings.xml文件根元素settings下的元素。比如我们需要引用settings下的本地仓库localRepository元素的值时，我们可以用${settings.localRepository}

Ø  java的系统属性，所有在java中使用java.lang.System.getProperties()能够获取到的属性都可以在pom.xml中引用，比如${java.home}。

Ø  pom.xml中properties元素下面的子元素作为属性。假如在pom.xml中有如下一段代码<properties><hello.world>helloWorld</hello.world></properties>，那么我们就可以使用${hello.world}引用到对应的helloWorld。

duan19056
关注
专栏目录
maven项目pom.xml最详细配置
07-25
maven的pom.xml的最详细配置，内含pom的依赖、jdk配置等
Maven pom.xml与settings.xml详解
08-31
在Maven的世界里，`pom.xml`和`settings.xml`是两个至关重要的配置文件，它们共同决定了Maven项目的构建过程和环境配置。`pom.xml`（Project Object Model）文件是每个Maven项目的核心，它包含了项目的基本信息、...
Maven简介（五）——pom.xml
Elim的博客
04-26 869
6       Maven的pom.xml介绍 6.1     简介        pom.xml文件是Maven进行工作的主要配置文件。在这个文件中我们可以配置Maven项目的groupId、artifactId和version等Maven项目必须的元素；可以配置Maven项目需要使用的远程仓库；可以定义Maven项目打包的形式；可以定义Maven项目的资源依赖关系等等。对于一个...
Maven项目pom.xml配置详解
weixin_33712987的博客
11-29 287
maven项目pom.xml文件配置详解，需要时可以用作参考： <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org...
maven项目中pom.xml
vivian_zw的专栏
03-10 2573
利用maven在搭建spring3++Struts2+hibernate4的框架,记录pom.xml文件以便备忘.
maven项目中的pom.xml文件
泡泡菜叶的博客
08-19 399
在使用maven开发时，在pom.xml文件中有这样两个标签<dependencyManagement>和<pluginManagement>对引入的依赖包和插件进行管理<!-- 集中定义依赖版本号 --> <properties> <junit.version>4.10</junit.version> <spring.version>4.1.3.RELEAS
Maven的pom.xml配置文件详细配置说明
06-07
Maven的pom.xml配置文件详细配置说明 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=...
maven的本地仓库配置文件settings.xml和项目中文件pom.xml.zip
09-08
一、Idea关联的maven本地仓库配置文件settings.xml （1）必须使用默认文件名 D:\developsoft\javaweb\commonPlugins\maven\apache-maven-3.8.1_first\conf\settings.xml ...pom-maven-spring-CusConfigV1不推荐使用.xml
maven pom.xml 动态读取变量值插件
08-26
该jar包功能，可以在一个properties文件里面定义jdbc.url=${url},在另一个properties文件定义具体的值，通过该jar可以获取到哪个具体的值。下载之后，自行安装到本地...具体pom.xml配置使用可以参考网络其他博文，谢谢
Maven pom.xml 添加本地jar包依赖以及打包方法
09-07
本篇文章将详细介绍如何在Maven的pom.xml文件中添加本地jar包依赖以及如何进行打包。 首先，我们来看一下两种主要的方法： 1. **安装到本地仓库** 这种方法适用于含有pom文件的jar包，因为Maven需要依赖pom文件...
Maven中的pom.xml文件模块对应的作用 文件结构、项目构建配置、应用打包插件
最新发布
2301_77358195的博客
07-18 1353
pom.xml是Maven项目的核心配置文件，它是 项目对象模型 - Project Object Model（POM）的缩写。它使用 XML 格式定义了项目的基本信息、依赖项、构建插件和任务等。使用pom.xml，我们可以轻松地管理项目的构建和依赖关系，让我们能够更专注于业务逻辑的开发。
MAVEN项目pom.xml基本配置文件
知来者犹可追
03-17 330
4.0.0 com.zw test war 0.0.1-SNAPSHOT zwshop Maven Webapp http://maven.apache.org &lt;properties&gt; &lt;srping.version&gt;4.3.7.RELEASE&lt;/srping.version&gt; &lt;mybatis.version&gt;3.2.8&lt;/my...
Maven 之 pom.xml 文件详解
流华追梦的专栏
11-16 2400
POM是项目对象模型（Project Object Model）的简称，它是Maven项目中的文件，XML格式，名称为 pom.xml，作用类似 ant 的 build.xml 文件，功能则更强大。该文件用于管理：源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目授权、项目的url、项目的依赖关系等等。事实上，在Maven的世界中，一个项目可以什么都没有，甚至没有代码，但是必须包含pom.xml文件。关于Maven的详细介绍请参见《Maven 从入门到精通》。
Maven项目pom.xml报错
君知君不知
12-05 779
Maven项目报错pom.xml每刷新：手动刷新
maven配置文件pom.xml详解
lyglostangel的专栏
07-16 515
4.0.0              asia.banseon               banseon-maven2               jar               1.0-SNAPSHOT              banseon-maven              http://www.baidu.c
聚合与继承以及继承的依赖管理
m0_64219700的博客
01-16 405
聚合与继承以及继承的依赖管理
maven的pom.xml中repositories 和 distributionManagement 详解
weixin_41003771的博客
03-24 8087
repositories 远程仓库配置 在maven中pom.xml是Maven进行工作的主要配置文件，它的作用包括：配置Maven项目中需要使用的远程仓库，Maven项目的资源依赖关系等。其中pom是Project Object Model（项目对象模型）的简称。 在pom.xml中repositories标签的作用是用来配置maven项目的远程仓库。示例如下: <repository> <id>nexus</id><!--远程仓库唯一标识符 -->
maven核心，pom.xml详解
潘达小新
06-08 383
什么是pom? pom作为项目对象模型。通过xml表示maven项目，使用pom.xml来实现。主要描述了项目：包括配置文件；开发者需要遵循的规则，缺陷管理系统，组织和licenses，项目的url，项目的依赖性，以及其他所有的项目相关因素。 快速察看： <project> <modelVersion>4.0.0</modelVersion> <!—maven2.0必须是这样写，现在是maven2唯一支持的版本—> <!— 基...
maven仓库配置
热门推荐
温水青蛙
06-22 7万+
1.两类仓库 1.1本地仓库（local repository） 可以自定义本地仓库的位置，修改${user.home}/.m2/settings.xml ： Xml代码  settings>     ...     localRepository>D:\java\repositorylocalRepository>     ...   settings>
Maven pom.xml配置详解
"本文将深入解析基于Maven的pom.xml文件，揭示其核心结构和重要元素，帮助读者理解和掌握如何有效地使用Maven构建Java项目。" Maven的pom.xml文件是项目对象模型（Project Object Model）的中心，它是每个Maven项目...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值