Maven入门-5.Maven的聚合和继承

1、Maven的聚合
1.1 聚合的配置
2、Maven的继承
2.1 可被继承的POM元素
2.2 POM中使用继承
2.3 继承dependency

1、Maven的聚合

在Maven入门-4.Maven的依赖中，我们创建了2个以上的模块，每个模块都是一个独立的maven project，在开始的时候我们可以独立的编译和测试运行每个模块，但是随着项目的不断变大和复杂化，模块会越来越多，就不能每一个都编译测试了，这时Maven给出了聚合的配置方式。
所谓聚合，顾名思义，就是把多个模块或项目聚合到一起
现在新建一个专门负责聚合工作的Maven project(user-aggregator)
新建好之后的项目是如下状态：

这时我们可以把里面的所有内容都删掉，只保留pom.xml即可。

1.1 聚合的配置

在pom.xml中使用modules来聚合其它模块。
user-aggregator的pom.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.fz.user</groupId>
  5.     <artifactId>user-aggregator</artifactId>
  6.     <version>0.0.1-SNAPSHOT</version>
  7.     <!--这里的打包方式需要为pom-->
  8.     <packaging>pom</packaging>
  9.     <modules>
  10.         <module>../user-core</module>
  11.         <module>../user-dao</module>
  12.         <module>../user-log</module>
  13.         <module>../user-service</module>
  14.     </modules>
  15. </project>

聚合完成后就可以使用clean test 等命令来统一编译聚合进来的几个模块了，它的好处就是在一个项目中把其他项目都一次编译了。。

2、Maven的继承

在刚才的项目中，有很多重复的配置，有相同的groupId和version，有相同的log4j、juit等等的依赖，Maven中可以声明一个父POM供子POM继承。
可以把父pom理解为Java中的一个父类，然后pom.xml中的一些groupId，version，相同的依赖之类的都可以理解味Java父类的一些共有属性。子POM继承了该父POM，就继承了这些属性（groupId，version，相同的依赖）

2.1 可被继承的POM元素

  1. groupId:项目组ID,项目坐标的核心元素
  2. version: 项目版本, 项目坐标的核心元素
  3. description: 项目的描述信息
  4. organization: 项目的组织信息
  5. inceptionYear: 项目的创始年份
  6. url: 项目的URL地址
  7. developers: 项目开发者信息
  8. contributors: 项目的贡献者信息
  9. distributionManagement: 项目的部署配置
  10. issueManagement: 项目的缺陷跟踪系统信息
  11. ciManagement: 项目的持续集成系统信息
  12. scm: 项目的[版本控制](http://lib.csdn.net/base/git "Git知识库")系统信息
  13. mailingLists: 项目的邮件列表信息
  14. properties: 自定义的maven属性
  15. dependencies: 项目的依赖配置
  16. dependencyManagement: 项目的依赖管理配置
  17. repositories: 项目的仓库配置
  18. build: 包括项目的源码目录配置、输出目录配置、插件配置、插件管理配置等
  19. reporting: 包括项目的报告输出目录配置、报告插件配置等

下面开始
新建一个父POM项目(user-parent)，用于管理子POM中重复的”属性”。同样也是删除掉src/java/main等无用的目录。只留下pom.xml即可。
也可以把聚合的配置也放到该继承pom.xml文件中
新建好的结构如下：

user-parent中的pom.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.fz.user</groupId>
  5.     <artifactId>user-parent</artifactId>
  6.     <version>0.0.1-SNAPSHOT</version>
  7.     <!--这里的打包方式需要为pom-->
  8.     <packaging>pom</packaging>
  9.     <modules>
  10.         <module>../user-core</module>
  11.         <module>../user-dao</module>
  12.         <module>../user-log</module>
  13.         <module>../user-service</module>
  14.     </modules>
  15. </project>

2.2 POM中使用继承

user-core模块的pom.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.fz.user</groupId>
  5.     <artifactId>user-core</artifactId>
  6.     <version>0.0.1-SNAPSHOT</version>
  7.     <packaging>jar</packaging>
  8.     <name>user-core</name>
  10.     <url>http://maven.apache.org</url>
  11.     <properties>
  12.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  13.     </properties>
  15.     <dependencies>
  16.         <dependency>
  17.             <groupId>junit</groupId>
  18.             <artifactId>junit</artifactId>
  19.             <version>4.10</version>
  20.         </dependency>
  21.         <dependency>
  22.             <groupId>log4j</groupId>
  23.             <artifactId>log4j</artifactId>
  24.             <version>1.2.17</version>
  25.         </dependency>
  26.         <dependency>
  27.             <groupId>org.hamcrest</groupId>
  28.             <artifactId>hamcrest-core</artifactId>
  29.             <version>1.3</version>
  30.         </dependency>
  31.     </dependencies>
  32. </project>

这里我们可以把以下内容添加到user-parent的pom.xml中，让子POM来继承。

  1.     <groupId>com.fz.user</groupId>
  2.     <version>0.0.1-SNAPSHOT</version>
  3.     <packaging>jar</packaging>
  5.     <url>http://maven.apache.org</url>
  6.     <properties>
  7.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  8.     </properties>

修改user-parent模块中的pom.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.fz.user</groupId>
  5.     <artifactId>user-parent</artifactId>
  6.     <version>0.0.1-SNAPSHOT</version>
  7.     <packaging>pom</packaging>
  8.     <url>http://maven.apache.org</url>
  9.     <properties>
  10.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  11.         <!--properties中可以自定义属性-->
  12.         <junit.version>4.10</junit.version>
  13.         <log4j.version>1.2.17</log4j.version>
  14.         <hamcrest.version>1.3</hamcrest.version>
  15.     </properties>
  16.     <modules>
  17.         <module>../user-core</module>
  18.         <module>../user-dao</module>
  19.         <module>../user-log</module>
  20.         <module>../user-service</module>
  21.     </modules>
  22. </project>

然后在user-core模块中使用parent元素来实现继承，修改后的pom.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.     <parent>
  6.         <groupId>com.fz.user</groupId>
  7.         <artifactId>user-parent</artifactId>
  8.         <version>0.0.1-SNAPSHOT</version>
  9.         <!-- 这里要加上relativePath来指定user-parent的pom.xml文件的绝对路径 -->
  10.         <relativePath>../user-parent/pom.xml</relativePath>
  11.     </parent>
  13.     <artifactId>user-core</artifactId>
  14.     <name>user-core</name>
  16.     <dependencies>
  17.         <dependency>
  18.             <groupId>junit</groupId>
  19.             <artifactId>junit</artifactId>
  20.             <!--这里使用自定义属性 -->
  21.             <version>${junit.version}</version>
  22.         </dependency>
  23.         <dependency>
  24.             <groupId>log4j</groupId>
  25.             <artifactId>log4j</artifactId>
  26.             <!--这里使用自定义属性 -->
  27.             <version>${log4j.version}</version>
  28.         </dependency>
  29.         <dependency>
  30.             <groupId>org.hamcrest</groupId>
  31.             <artifactId>hamcrest-core</artifactId>
  32.             <!--这里使用自定义属性 -->
  33.             <version>${hamcrest.version}</version>
  34.         </dependency>
  35.     </dependencies>
  36. </project>

2.3 继承dependency

除了普通属性可以被继承，dependency也可以被继承下来。我们把user-core中的dependency放到user-parent中。
dependency的继承需要用dependencyManagement来管理。如果不使用dependencyManagement，每一个子POM都会把父POM中的dependency继承下来。也就是说，每个子模块中都会有全部的jar包，这肯定是不行的
下面可以把user-core,user-log,user-dao,user-service几个模块中的所有dependency都加到user-parent中，然后在各个子POM中使用该dependency即可。
修改后的user-parent的pom.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.fz.user</groupId>
  5.     <artifactId>user-parent</artifactId>
  6.     <version>0.0.1-SNAPSHOT</version>
  7.     <packaging>pom</packaging>
  8.     <url>http://maven.apache.org</url>
  9.     <properties>
  10.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  11.         <!--properties中可以自定义属性-->
  12.         <junit.version>4.10</junit.version>
  13.         <log4j.version>1.2.17</log4j.version>
  14.         <hamcrest.version>1.3</hamcrest.version>
  15.     </properties>
  16.     <!-- 继承中需要使用dependencyManagement来管理依赖 -->
  17.     <dependencyManagement>
  18.         <dependencies>
  19.             <dependency>
  20.                 <groupId>junit</groupId>
  21.                 <artifactId>junit</artifactId>
  22.                 <!--这里使用自定义属性-->
  23.                 <version>${junit.version}</version>
  24.             </dependency>
  25.             <dependency>
  26.                 <groupId>log4j</groupId>
  27.                 <artifactId>log4j</artifactId>
  28.                 <!--这里使用自定义属性-->
  29.                 <version>${log4j.version}</version>
  30.             </dependency>
  31.             <dependency>
  32.                 <groupId>org.hamcrest</groupId>
  33.                 <artifactId>hamcrest-core</artifactId>
  34.                 <!--这里使用自定义属性-->
  35.                 <version>${hamcrest.version}</version>
  36.             </dependency>
  37.             <dependency>
  38.                 <groupId>com.fz.user</groupId>
  39.                 <artifactId>user-core</artifactId>
  40.                 <version>0.0.1-SNAPSHOT</version>
  41.             </dependency>
  42.             <dependency>
  43.                 <groupId>com.fz.user</groupId>
  44.                 <artifactId>user-dao</artifactId>
  45.                 <version>0.0.1-SNAPSHOT</version>
  46.             </dependency>
  47.             <dependency>
  48.                 <groupId>com.fz.user</groupId>
  49.                 <artifactId>user-log</artifactId>
  50.                 <version>0.0.1-SNAPSHOT</version>
  51.                 <exclusions>
  52.                     <exclusion>
  53.                         <groupId>log4j</groupId>
  54.                         <artifactId>log4j</artifactId>
  55.                     </exclusion>
  56.                 </exclusions>
  57.             </dependency>
  58.         </dependencies>
  59.     </dependencyManagement>
  60.     <modules>
  61.         <module>../user-core</module>
  62.         <module>../user-dao</module>
  63.         <module>../user-log</module>
  64.         <module>../user-service</module>
  65.     </modules>
  66. </project>

然后在user-core,user-log,user-dao,user-service几个模块中继承这些依赖。这里以user-core为例，user-core的pom.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.     <parent>
  6.         <groupId>com.fz.user</groupId>
  7.         <artifactId>user-parent</artifactId>
  8.         <version>0.0.1-SNAPSHOT</version>
  9.         <!-- 这里要加上relativePath来指定user-parent的pom.xml文件的绝对路径 -->
  10.         <relativePath>../user-parent/pom.xml</relativePath>
  11.     </parent>
  13.     <artifactId>user-core</artifactId>
  14.     <name>user-core</name>
  16.     <!-- 子POM继承父POM的dependency时需要什么依赖就添加什么依赖就行了
  17.     但是要去掉version。只保留groupId和artifactId即可 
  18.     -->
  19.     <dependencies>
  20.         <dependency>
  21.             <groupId>junit</groupId>
  22.             <artifactId>junit</artifactId>
  23.         </dependency>
  24.         <dependency>
  25.             <groupId>log4j</groupId>
  26.             <artifactId>log4j</artifactId>
  27.         </dependency>
  28.         <dependency>
  29.             <groupId>org.hamcrest</groupId>
  30.             <artifactId>hamcrest-core</artifactId>
  31.         </dependency>
  32.     </dependencies>
  33. </project>

这样一来，每个模块中就只会引用到自己定义的dependency中的依赖了。
例子：
现在想加入mysql的jar包，但是这个jar包只会在user-dao中使用，其他模块中不会用到。可以在user-parent和user-dao中分别增加一条dependency

然后查看user-dao模块中的jar包

上图中，user-log和user-core中没有mysql的依赖，由于user-service依赖了user-dao,所以也同样会有mysql-connector-java的依赖。

posted @ 2017-02-19 22:14  Python魔法师  阅读(746)  评论(0)  编辑  收藏  举报