乐虎游戏|乐虎国际登录|欢迎你

Maven pom 详明

日期:2020-03-13编辑作者:计算机资讯
<Resources>...</Resources>

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

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

Maven pom 详解

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

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

  ------projectA

    ------projectB

      -----pom.xml

    ------pom.xml

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  <modelVersion>4.0.0</modelVersion>  
  <groupId>com.tiantian.mavenTest</groupId>  
  <artifactId>projectA</artifactId>  
  <version>1.0-SNAPSHOT</version>  
  <packaging>pom</packaging>  
  <modules>  
       <module>projectB</module>  
  </modules>  
</project>  

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

<plugins>...</plugins>

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

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

属性 properties 和 &{}

简介

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

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

Maven 的 properties 加载顺序:

  • <build><filters> 中的配置

  • pom.xml 中的 <properties>

  • mvn -Dproperty=value 中定义的 property

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

概览

下面是一个POM项目中的pom.xml文件中包含的元素。注意,其中的modelVersion是4.0.0,这是当前仅有的可以被Maven2&3同时支持的POM版本,它是必须的。

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
            http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- 基本设置 The Basics -->
    <groupId>...</groupId>
    <artifactId>...</artifactId>
    <version>...</version>
    <packaging>...</packaging>
    <dependencies>...</dependencies>
    <parent>...</parent>
    <dependencyManagement>...</dependencyManagement>
    <modules>...</modules>
    <properties>...</properties>

    <!-- 构建过程的设置 Build Settings -->
    <build>...</build>
    <reporting>...</reporting>

    <!-- 项目信息设置 More Project Information -->
    <name>...</name>
    <description>...</description>
    <url>...</url>
    <inceptionYear>...</inceptionYear>
    <licenses>...</licenses>
    <organization>...</organization>
    <developers>...</developers>
    <contributors>...</contributors>

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

The Basics

1.2.3 依赖关系:依赖关系列表(dependency list)是POM的重要部分

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

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  <modelVersion>4.0.0</modelVersion>  
  <groupId>com.tiantian.mavenTest</groupId>  
  <artifactId>projectB</artifactId>  
  <version>1.0-SNAPSHOT</version>  
  <packaging>jar</packaging>  

  <dependencies>  
    <dependency>  
      <groupId>junit</groupId>  
      <artifactId>junit</artifactId>  
      <version>3.8.1</version>  
      <scope>test</scope>  
      <optional>true</optional>  
    </dependency>  
  </dependencies>  
</project>  

groupId, artifactId, version:描述了依赖的项目唯一标志。

type:对应于依赖项目的packaging类型,默认是jar。

scope:用于限制相应的依赖范围、传播范围。scope的主要取值范围如下(还有一个是在Maven2.0.9以后版本才支持的import,关于import作用域将在后文《Dependency介绍》中做介绍):

  • test:在测试范围有效,它在执行命令test的时候才执行,并且它不会传播给其他模块进行引入,比如 junit,dbunit 等测试框架。
  • compile(default 默认):这是它的默认值,这种类型很容易让人产生误解,以为只有在编译的时候才是需要的,其实这种类型表示所有的情况都是有用的,包括编译和运行时。而且这种类型的依赖性是可以传递的。
  • runtime:在程序运行的时候依赖,在编译的时候不依赖。
  • provided:这个跟compile很类似,但是它表示你期望这个依赖项目在运行时由JDK或者容器来提供。这种类型表示该依赖只有在测试和编译的情况下才有效,在运行时将由JDK或者容器提供。这种类型的依赖性是不可传递的。比如 javaee:

    • eclipse开发web环境中是没有javaee必须要手动添加。
    • myeclipse新建web项目会有JavaEE(servlet-api.jar,jsp-api.jar...)web容器依赖的jar包,一般都是做开发的时候才使用。但是myeclipse不会把这些 jar包发布的,lib下你是找不到javaee引入的jar包,因为myeclipse发布项目的时候会忽略它。为什么?因为tomcat容器bin/lib已经存在了这个jar包了。
  • 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的依赖:

      <dependencies>  
           <dependency>  
                  <groupId>com.tiantian.mavenTest</groupId>  
                  <artifactId>projectB</artifactId>  
                  <version>1.0-SNAPSHOT</version>  
                  <exclusions>  
                         <exclusion>  
                                <groupId>com.tiantian.mavenTest</groupId>  
                                <artifactId>projectC</artifactId>  
                         </exclusion>  
                  </exclusions>  
           </dependency>  
      </dependencies>
      
  • 前言
    • 什么是 POM
    • Quick Overview
  • POM 常用元素
    • The Basics(#11-the-basics)
      • Maven 坐标( Coordinate )
      • 依赖: <dependencies>...</dependencies>
      • 聚合: <modules>...</modules>
      • 继承: <parent>...</parent> 和 <dependencyManagement>...</dependencyManagement>
      • 属性:<properties>...</properties>
    • Build Settings
      • <build>...</build>
      • The BaseBuild Element Set
        • Basic Elements
        • <Resources>...</Resources>
        • <plugins>...</plugins>
        • <pluginManagement>...<pluginManagement>
      • <reporting>...</reporting>
    • Environment Settings
      • <SCM>...</SCM>
      • <distributionManagement>...</distributionManagement>
      • <profiles>...</profiles>
  • pom.xml 完整注释
  • 参考
resources

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

示例

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

详解

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

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

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

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

  ------projectA

    ------pom.xml

  ------projectB

    ------pom.xml

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  <modelVersion>4.0.0</modelVersion>  

  <groupId>com.tiantian.mavenTest</groupId>  
  <artifactId>projectA</artifactId>  
  <version>1.0-SNAPSHOT</version>  
  <packaging>pom</packaging>  
  <modules>  
       <module>../projectB</module>  
  </modules>  
</project>  

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

1.2 Build Settings

根据 POM 4.0.0 XSD,build 元素概念性的划分为两个部分:BaseBuild(包含 poject build 和 profile build 的公共部分,见下)和 poject build 包含的一些高级特性。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> ... <!-- "Project Build" contains more elements than just the BaseBuild set --> <build>...</build> <profiles> <profile> <!-- "Profile Build" contains a subset of "Project Build"s elements --> <build>...</build> </profile> </profiles> </project> 

build

1.2.1 继承

Quick Overview

一个完整的 pom.xml 如下,放置在项目的根目录下:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <!-- The Basics --> <groupId>...</groupId> <artifactId>...</artifactId> <version>...</version> <packaging>...</packaging> <dependencies>...</dependencies> <parent>...</parent> <dependencyManagement>...</dependencyManagement> <modules>...</modules> <properties>...</properties> <!-- Build Settings --> <build>...</build> <reporting>...</reporting> <!-- More Project Information --> <name>...</name> <description>...</description> <url>...</url> <inceptionYear>...</inceptionYear> <licenses>...</licenses> <organization>...</organization> <developers>...</developers> <contributors>...</contributors> <!-- Environment Settings --> <issueManagement>...</issueManagement> <ciManagement>...</ciManagement> <mailingLists>...</mailingLists> <scm>...</scm> <prerequisites>...</prerequisites> <repositories>...</repositories> <pluginRepositories>...</pluginRepositories> <distributionManagement>...</distributionManagement> <profiles>...</profiles></project>

tips:这里的 pom.xmlmodelVersion 为 4.0.

pluginManagement

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

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

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

1.3 属性

在pom.xml文件中我们可以使用${propertyName}的形式引用属性。是值的占位符,类似EL,类似ant的属性,比如${X},可用于pom文件任何赋值的位置。有以下分类:

  • 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 System Properties: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。

本文转自:234390216

本文出自:艺意

<pluginManagement>...<pluginManagement>

<build> 中,<pluginManagement><plugins> 并列,两者之间的关系类似于 <dependencyManagement><dependencies> 之间的关系。<pluginManagement> 中也配置 <plugin>,其配置参数与 <plugins> 中的 <plugin> 完全一致。只是,<pluginManagement> 往往出现在父项目中,其中配置的 <plugin> 往往通用于子项目。子项目中只要在 <plugins> 中以 <plugin> 声明该插件,该插件的具体配置参数则继承自父项目中 <pluginManagement> 对该插件的配置,从而避免在子项目中进行重复配置。

<reporting> 中的配置作用于 Maven 的 site 阶段( 见 Maven 生命周期),用于生成报表。<reporting> 中也可以配置插件 <plugins>,并通过一个 <plugin> 的 <reportSet>为该插件配置参数。注意,对于同时出现在 <build> 和 <reporting> 中的插件,<reporting> 中对该插件的配置也能够在构建过程中生效,即该插件的配置是<build>和<reporting>中的配置的合并。

POM 元素详解

1.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应该这样定义:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  <modelVersion>4.0.0</modelVersion>  
  <groupId>com.tiantian.mavenTest</groupId>  
  <artifactId>projectA</artifactId>  
  <version>1.0-SNAPSHOT</version>  
  <packaging>pom</packaging>  
  <modules>  
       <module>../projectB</module>  
  </modules>  
</project>  

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  <modelVersion>4.0.0</modelVersion>  
  <parent>  
       <groupId>com.tiantian.mavenTest</groupId>  
       <artifactId>projectA</artifactId>  
       <version>1.0-SNAPSHOT</version>  
       <relativePath>../projectA/pom.xml</relativePath>  
  </parent>  
  <groupId>com.tiantian.mavenTest</groupId>  
  <artifactId>projectB</artifactId>  
  <version>1.0-SNAPSHOT</version>  
  <packaging>jar</packaging>  
</project>  

什么是 POM?

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

基础属性

示例

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

详解

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

什么是POM?

POM是项目对象模型(Project Object Model)的简称,它是Maven项目中的文件,使用XML表示,名称叫做pom.xml。作用类似ant的build.xml文件,功能更强大。该文件用于管理:源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目授权、项目的url、项目的依赖关系等等。事实上,在Maven世界中,project可以什么都没有,甚至没有代码,但是必须包含pom.xml文件。

1.1 The Basics

在 Maven 中坐标是构件的唯一标识,Maven 坐标的元素包括 groupIdartifactIdversionpackagingclassifier。上述5个元素中,groupIdartifactIdversion 是必须定义的,packaging 是可选的 ( 默认为 jar )。

  • groupId:组织标识,一般为:公司网址的反写+项目名
  • artifactId:项目名称,一般为:项目名-模块名
  • version:版本号
  • packaging:打包的方式,如:pom, jar, maven-plugin, ejb, war, ...
  • clissifier:用来帮助定义构件输出的一些附属构件。可参考此文

另外,关于 版本号 ,形式为0.0.1-SNAPSHOT

  • 第一个 0 表示大版本号,第二个 0 表示分支版本号,第三个 0 表示小版本号
  • SNAPSHOT -- 快照版本,ALPHA -- 内侧版本,BETA -- 公测版本,RELEASE -- 稳定版本,GA -- 正式发布

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

比如,我的项目 project-demo1 需要添加 junit 依赖:

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

dependencies元素,包括以下子元素:

  • groupId, artifactId, version

这三个是必须的,以下的那些子元素根据实际情况添加。

  • scope

scope 元素为 maven dependency 下一个控制作用域的子元素,控制该依赖包在什么情况下会被加到 classpath 中。共 6 种 scope,包括:compileprovidedruntimetestsystemimport。( 具体可参考@POM Dependency Scope )

  • type

对于于 <packaging>...</packaging> ,即指定依赖包的后缀,默认为 jar

  • optional

如果当前仙姑是 projectA,projectA 需要依赖 projectB,而 projectB 的 optional 为 true,表示依赖可选,那么之后所有声明依赖 projectA 的项目如果也依赖 projectB,就必须手动声明。比如,projectC 依赖 projectA 和 projectB,如果 projectC只声明了对 projectA 的依赖,那么 projectB 不会自动加入依赖,projectA 必须手动加入对 projectB 的依赖。也就是说依赖传递被打断了。

  • exclusions

依赖传递:如果我们的项目引用了一个 Jar 包,而该 Jar 包又引用了其他 Jar 包,那么在默认情况下项目编译时,Maven 会把直接引用和间接引用的 Jar 包都下载到本地。

排除依赖:如果我们只想下载直接引用的 Jar包,那么需要在 pom.xml 中做如下配置:(将需要排除的 Jar 包的坐标写在中)

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

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

  • 短路优先本项目——>A.jar——>B.jar——>X.jar本项目——>C.jar——>X.jar若本项目引用了 A.jar,A.jar 又引用了 B.jar,B.jar 又引用了 X.jar,并且 C.jar 也引用了X.jar。在此时,Maven 只会引用引用路径最短的Jar。
  • 声明优先若引用路径长度相同时,在pom.xml中谁先被声明,就使用谁。

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

<project> <modelVersion>4.0.0</modelVersion> <groupId>com.seyvoue.account</groupId> <artifactId>account-aggregator</artifactId> <version>1.0.0-SNAPSHOT</version> <packaging>pom</packaging> ... <!--模块 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径--> <modules> <module>account-email</module> <module>account-persist</module> </modules></project> 

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

如何实现继承? 示例如下:

  • 父 pom.xml:
  • <packaging>...</packaging> 必须配置为 pom
  • 将需要继承的 Jar 包的坐标放入<dependencyManagement>...</dependencyManagement> 内即可
<project> <modelVersion>4.0.0</modelVersion> <groupId>com.seyvoue.demo</groupId> <artifactId> demo-maven </artifactId> <version>1.0.0-SNAPSHOT</version> <packaging>pom</packaging> ... <properties> <spring.version>4.0.2.RELEASE</spring.version> <junit.versoin>4.7</junit.version> ... </properties> <!-- 继承自该项目的所有子项目的默认依赖信息。这部分的依赖信息不会被立即解析,而是当子项目声明一个依赖(必须描述group ID和 artifact ID信息),如果group ID和artifact ID以外的一些信息没有描述,则通过group ID和artifact ID 匹配到这里的依赖,并使用这里的依赖信息。--> <dependencyManagement> <dependencies> <dependency> <groupId>com.github.brevy</groupId> <artifactId>shiro-spring</artifactId> <version>1.2.2</version> </dependency> ... </dependencies> </dependencyManagement> ... </project> 
  • 子 pom.xml:

<parent>...</parent> 标签内添加 父pom.xml 的坐标

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

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

Maven 的 properties 加载顺序:

  • <build><filters> 中的配置
  • pom.xml 中的 <properties>
  • mvn -Dproperty=value 中定义的 property相同 key 的 property,以最后一个文件中的配置为最终配置。
<project> ... <properties> <maven.compiler.source>1.7<maven.compiler.source> <maven.compiler.target>1.7<maven.compiler.target> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> </properties> ...</project>

通过 properties元素用户可以定义一个或多个 maven 属性,然后在 maven 的其他地方使用 ${属性名称} 的方式引用该属性,这种做法的意义在于消除重复和统一管理。比如,需要在多个地方重复声明同样的 SpringFramework 版本,现在只需要在一个地方声明就可以。Maven 共有6种属性(根据引用的来源不同):内置属性、POM 属性、自定义属性、Settings 属性、环境变量属性等,引用方式是类似的,下面介绍其中的集中

  • 内置属性

两个常用内置属性:

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

用户可以使用该类属性引用 pom.xml 中对应元素的值,如 ${project.artifactId} 就对应了 <project><artifactId></artifactId></project> 中的值。常用的 POM 属性包括:

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

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

<project> ... <properties> <my.group>hello</my.group> </properties> ...</project>
  • settings 属性

与 POM 属性同理。maven settings.xml 中定义的内容,可以通过 settings 前缀进行引用。

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

Environment Settings

//待完善

一,基本配置

本文由乐虎游戏发布于计算机资讯,转载请注明出处:Maven pom 详明

关键词:

计算机:RxJava2.0(一)

Outline 特此声明:本文为转载文章!尊重原创的劳动果实,严禁剽窃 本文转载于:http://www.jianshu.com/p/464fa025229e 出自于...

详细>>

Rxjava2~zip~学渣带你扣rxjava2~ map操作符到底干了什么

prestatic ObservableString sampleObservable() {returnObservable.defer(new CallableObservableSource? extendsString() {@Overridepublic ObservableSource? ...

详细>>

RXJava的使用<二>

vankeservice 前言 RxJava和Retrofit也火了一段时间了,不过最近一直在学习ReactNative和Node相关的姿势,一直没有时间研究这...

详细>>

Android拾萃 - RxJava2之变换操作符及其demo

清汤寡水在Lacrossexjava中本人会用interval当放大计时器与flatmap结合发起互联网央浼.在类型中的实际须求是每四个钟头乞...

详细>>