04_Maven核心_POM_聚合与继承

这节将要描述一下聚合和继承。

首先看个问题：如果项目A和项目B是两个单独的项目组开发的，但是这两个项目又是从属于一个顶层项目。项目A和项目B都有自己的POM文件，怎样才能整合两个项目呢？

答：聚合

一、聚合

其实聚合就是从新建立一个空的Maven项目，通过POM文件来整合项目A和项目B

因为在实际应用中，我没有怎么使用过，所以这里仅仅介绍如何实现

聚合项目实现的pom文件代码  

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.sinosoft</groupId>  
5.     <artifactId>all</artifactId>  
6.     <version>0.0.1-SNAPSHOT</version>  
7.     <packaging>pom</packaging>  
8.     <name>has a b</name>  
9.     <modules>  
10.         <module>A_pom</module>  
11.         <module>B_pom</module>  
12.     </modules>  
13. </project>  

新建了一个all项目。在all项目中的POM文件大体上和上一节描述的POM文件类似。主要有两个地方不一样：

1.这个all项目的打包方式<packaging>pom</packaging>不是jar也不是war而是pom。通过在一个打包方式为pom的Maven项目中声明任意数量的module元素来实现模块聚合。

2.含有一个<modules>元素，里面含有两个<module>的子元素。<modle>来聚合任意个项目。里面的value值表示POM的路径。

聚合类型

父子项目聚合

平行项目聚合

二、继承

场景描述一：我公司开发的第四代架构采用SSH框架作为基础，在此之上加入我们自己需要的代码控制，例如校验控制，数据访问控制，数据传递控制等等。以后，我公司开发的所有项目都必须在第四代架构之上去开发。为了避免各个分公司在开发过程中使用不同的jar包依赖，造成项目不可控。所有分公司开发的新项目必须使用Maven，并且统一继承第四代架构的POM文件。这样操作后，以后开发的所有项目都会继承第四代架构的jar包，也不会造成jar包依赖错误等问题。

场景描述二：项目A要使用到：spring-core,spring-beans,spring-content,struts-core

项目B需要使用：spring-core,spring-beans,spring-content,struts-core,junit
那么在A的POM中和B的POM中共同含有spring-core,spring-beans,spring-content的依赖配置。这样就导致重复配置，出现冗余。这是程序员的大忌。在面向对象设计中，类是有父子结构的，父类声明的属性或者方法，子类可以得到继承，这样可以减少开发。类似的，POM中也可以继承。
场景描述完后，来看看怎么定义一个父POM文件。

定义父POM

Xml代码  

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
4.     <modelVersion>4.0.0</modelVersion>  
5.     <groupId>com.sinosoft.one</groupId>  
6.     <artifactId>parent</artifactId>  
7.     <packaging>pom</packaging>  
8.     <version>1.0.0</version>  
9.     <name>My Parent</name>  
10. </project>  

 可以看到定义父POM的语法和定义聚合的语法类似，打包方式<packaging>pom</packaging>为pom。但是没有<module>。

子项目如何来继承这个父POM呢？

子POM

子pom文件代码  

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.sinosoft</groupId>  
5.     <artifactId>MyBolg</artifactId>  
6.     <version>0.0.1-SNAPSHOT</version>  
7.     <packaging>war</packaging>  
8.   
9.     <parent>  
10.         <groupId>com.sinosoft.one</groupId>  
11.         <artifactId>parent</artifactId>  
12.         <version>1.0.0</version>  
13.     </parent>  
14.       
15. </project>  

通过parent元素来定义继承关系。这样父POM中的所有依赖就被子类所拥有。这样就减少了子类的配置。
在parent元素中还有一个子元素：relativePath用来指定父POM的位置。如果缺省，默认值为：../pom.xml。
我们在类的继承中也有私有，保护，公共这样的访问修饰符。私有的属性或者方法，子类是无法得到。那么POM中的继承能够得到那些数据呢？
groupId：项目组ID，项目坐标的核心元素； 
version：项目版本，项目坐标的核心元素； 
description：项目的描述信息； 
organization：项目的组织信息； 
inceptionYear：项目的创始年份； 
url：项目的url地址 
develoers：项目的开发者信息； 
contributors：项目的贡献者信息； 
distributionManagerment：项目的部署信息； 
issueManagement：缺陷跟踪系统信息； 
ciManagement：项目的持续继承信息； 
scm：项目的版本控制信息； 
mailingListserv：项目的邮件列表信息； 
properties：自定义的Maven属性； 
dependencies：项目的依赖配置； 
dependencyManagement：项目的依赖管理配置； 
repositories：项目的仓库配置； 
build：包括项目的源码目录配置、输出目录配置、插件配置、插件管理配置等； 
reporting：包括项目的报告输出目录配置、报告插件配置等。
看起来很多，但是我们只要关注几个就够了。
1.dependencies：有了这个元素，那么子POM将拥有父POM所有的依赖。如果所有的子POM都含有相同的依赖（jar）你可以将依赖放在这个里面。但是Maven也提供了依赖管理的元素。
2.dependenciesManagement：依赖管理元素，如果父POM定义的依赖在这个元素里面，那么子类如果不声明，将不会被继承。
下面举例说明：
父POM

父pom文件代码  

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
4.     <modelVersion>4.0.0</modelVersion>  
5.     <groupId>com.sinosoft.one</groupId>  
6.     <artifactId>parent</artifactId>  
7.     <packaging>pom</packaging>  
8.     <version>1.0.0</version>  
9.     <name>My Parent</name>  
10.   
11.     <properties>  
12.         <spring.version>3.1.1.RELEASE</spring.version>  
13.     </properties>  
14.   
15.   <dependencies>  
16.             <dependency>  
17.                 <groupId>org.springframework</groupId>  
18.                 <artifactId>spring-context-support</artifactId>  
19.                 <version>${spring.version}</version>  
20.             </dependency>  
21.    </dependencies>        
22.   
23.     <dependencyManagement>  
24.         <dependencies>  
25.                         <dependency>  
26.                 <groupId>org.springframework</groupId>  
27.                 <artifactId>spring-aop</artifactId>  
28.                 <version>${spring.version}</version>  
29.             </dependency>  
30.   
31.         </dependencies>  
32.     </dependencyManagement>  
33.   
34. </project>  

如果子POM继承这个POM。那么子类不管有没有声明org.springframework:spring-context-support都将含有这个依赖
但是如果子类没有声明org.springframework:spring-aop，那么子类将不会依赖这个jar包。子类在使用这个依赖时，方式也不一样。只需要引用groupId:artifactId不需要带上版本号。这样子类就会使用父POM相同版本的org.springframework:spring-aop
子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.sinosoft</groupId>  
5.     <artifactId>MyBolg</artifactId>  
6.     <version>0.0.1-SNAPSHOT</version>  
7.     <packaging>war</packaging>  
8.   
9.     <parent>  
10.         <groupId>com.sinosoft.one</groupId>  
11.         <artifactId>parent</artifactId>  
12.         <version>1.0.0</version>  
13.     </parent>  
14.     <dependencies>  
15.             <dependency>  
16.                 <groupId>org.springframework</groupId>  
17.                 <artifactId>spring-aop</artifactId>  
18.             </dependency>  
19.         </dependencies>  
20. </project>  

这样子POM就引用org.springframework:spring-context-support和org.springframework:spring-aop
使用：dependenciesManagement来管理依赖更好。如果直接使用dependencies来实现继承，那么表示子项目将不得已使用父pom中的所有依赖，有时这是没有必要的。