(十四)Maven聚合与继承

编程爱好者联盟 2016-12-22

1.Maven聚合

我们在平时的开发中，项目往往会被划分为好几个模块，比如common公共模块、system系统模块、log日志模块、reports统计模块、monitor监控模块等等。这时我们肯定会出现这么一个需要，我们需要一次构件多个模块，而不用每个模块都去mvn clean install一次，Maven聚合就是用来实现这个需求的。

我们需要构建另外一个模块，假设是UidpWeb，然后通过该模块来构件整个项目的所有模块，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/maven-v4_0_0.xsd">
   <modelVersion>4.0.0</modelVersion>
 
   <groupId>com.uidp</groupId>
   <artifactId>UidpWeb</artifactId>
   <packaging>pom</packaging>
   <version>0.0.1-SNAPSHOT</version>
   <name>UidpWeb</name>
   <url>http://maven.apache.org</url>
 
     <modules>
     
         <!-- parent pom -->
         <module>parent</module>
         
         <!-- 公共资源文件，第三方js库，图片等媒体资源 -->
         <module>ThirdParty</module>
         
         <!-- 公共依赖，工具包 -->
         <module>common</module>
 
         <!-- 日志模块 -->
         <module>log/pom-pack.xml</module>
         
         <!-- 第三方客户定制服务模块 -->
         <module>biz/pom-pack.xml</module>
             
         <!-- 客户管理 -->
         <module>customer/pom-pack.xml</module>
         
         <!-- 策略模块-->
         <module>strategy/pom-pack.xml</module>
         
         <!-- 统计报表 -->
         <module>reports/pom-pack.xml</module>
         
         <!-- 监控统计 -->
         <module>monitor/pom-pack.xml</module>
         
         <!-- 系统管理模块 -->
         <module>sysmgr/pom-pack.xml</module>
         
         <!-- 统一打war包 -->
         <module>/pom-app.xml</module>
 
     </modules>
 
 </project>

注释：

<packaging>pom</packaging>：对于聚合模块UidpWeb来说，packaging的类型必须为pom，否则无法构建。

<name>UidpWeb</name>：提供一个更容易阅读的名称，没什么其他太大作用。

<modules>......</modules>：这是实现聚合的标签，其下可包含多个module元素。

<module>...</module>：用来指定实现聚合的模块或者实现聚合的POM。

为了方便用户构建项目，通常将聚合模块放在项目目录的最顶层，其他模块则作为聚合模块的子目录存在，这时聚合的时候便可如我这般指定路径：

<module>parent</module>

<module>log/pom-pack.xml</module>

这就表示聚合模块下面的parent目录，聚合模块下面的log目录下的pom-pack.xml。

聚合模块下的内容只需要POM文件，它不像其他模块那样有src/main/java、src/test/java等目录。他只是用来帮助聚合其他模块构建，他本身并不会有过多的实质内容。

关于目录结构要注意的是，聚合模块既可以作为其他模块的父目录，也可以与其他模块处于平行的目录，如图：

DbhVozhcEZvQGMfR6Pkc-A33RMAoVqH3kdctdDxLPixt8BQ5CIJxrwKZMacVtVD2O6ZPxPY9RkI2YzvYD92oI58_IOEDkEoE6_-MHnuUryDmqA_z70tvMV5edL2RiSTf.png

如果使用平行目录，聚合模块的POM要做相应的修改，以指向正确的模块目录：

<module>../parent</module>

<module>../log/pom-pack.xml</module>

最后运行mvn clean install命令，Maven会分析聚合模块的POM、分析要构建的模块、并计算出一个反应堆构建顺序，然后根据这个顺序依次构建各个模块，这样便可以一次性构建所有聚合的模块。

2.Maven继承

如果多个模块出现相同的依赖包，这样在pom.xml文件的内容出现了冗余、重复的内容，解决这个问题其实使用Maven的继承机制即可，就像Java的继承一样，父类就像一个模板，子类继承自父类，那么有些通用的方法、变量都不必在子类中再重复声明了。Maven的继承机制类似，在一个父级别的Maven的pom文件中定义了相关的常量、依赖、插件等等配置后，实际项目模块可以继承此父项目 的pom文件，重复的项不必显示的再声明一遍了，相当于父Maven项目就是个模板，等着其他子模块去继承。不过父Maven项目要高度抽象，高度提取公共的部分（交集），做到一处声明，多处使用。

与聚合一样我们需要构建另外一个模块，假设是parent，在聚合模块UidpWeb下面创建parent模块，然后通过该模块来作为所有模块的父POM，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>
 
     <groupId>com.uidp</groupId>
     <artifactId>UidpParent</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <packaging>pom</packaging>
 
     <name>UidpParent</name>
     <url>http://maven.apache.org</url>
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 
         <repository-url>http://192.168.0.70:8081/content/groups/public/</repository-url>
 
         <maven-compiler-plugin.version>3.1</maven-compiler-plugin.version>
         <maven-war-plugin.version>2.4</maven-war-plugin.version>
         <maven-javadoc-plugin.version>2.9.1</maven-javadoc-plugin.version>
         <maven-release-plugin.version>2.4.1</maven-release-plugin.version>
         <maven-deploy-plugin.version>2.7</maven-deploy-plugin.version>
 
 
 
         <junit.version>4.11</junit.version>
         <oracle.version>10.2.0.4</oracle.version>
         <springframework.version>3.2.8.RELEASE</springframework.version>
         <mybatis.version>3.2.2</mybatis.version>
         <mybatis-spring.version>1.2.0</mybatis-spring.version>
         <mysql-driver.version>5.1.25</mysql-driver.version>
         <aspectjweaver.version>1.7.3</aspectjweaver.version>
 
         <commons-dbcp.version>1.4</commons-dbcp.version>
         <commons-pool.version>1.5.5</commons-pool.version>
         <commons-fileupload.version>1.2.2</commons-fileupload.version>
 
         <log4j.version>1.2.17</log4j.version>
         <slf4j-api.version>1.7.5</slf4j-api.version>
         <slf4j-log4j12.version>1.7.5</slf4j-log4j12.version>
 
         <freemarker.version>2.3.19</freemarker.version>
 
         <jackson-core.version>2.5.0</jackson-core.version>
         <jackson-mapper-asl.version>1.9.7</jackson-mapper-asl.version>
 
         <javax.servlet-api.version>3.0.1</javax.servlet-api.version>
         <jsp-api.version>2.2</jsp-api.version>
         <kryo.version>1.04</kryo.version>
         <snakeyaml.version>1.8</snakeyaml.version>
         <jedis.version>2.0.0</jedis.version>
         <commons-lang.version>2.6</commons-lang.version>
 
 
         <mockito-core.version>1.8.5</mockito-core.version>
         <powermock-core.version>1.4.9</powermock-core.version>
         <powermock-api-mockito.version>1.4.9</powermock-api-mockito.version>
         <powermock-module-junit4.version>1.4.9</powermock-module-junit4.version>
 
 
     </properties>
 
     <dependencyManagement>
         <dependencies>
 
             <dependency>
                 <groupId>junit</groupId>
                 <artifactId>junit</artifactId>
                 <version>${junit.version}</version>
                 <scope>test</scope>
             </dependency>
 
             <!-- spring jar begin -->
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-web</artifactId>
                 <version>${springframework.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-webmvc</artifactId>
                 <version>${springframework.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-beans</artifactId>
                 <version>${springframework.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-context</artifactId>
                 <version>${springframework.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-context-support</artifactId>
                 <version>${springframework.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-core</artifactId>
                 <version>${springframework.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-jdbc</artifactId>
                 <version>${springframework.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-tx</artifactId>
                 <version>${springframework.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-test</artifactId>
                 <version>${springframework.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-expression</artifactId>
                 <version>${springframework.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-aop</artifactId>
                 <version>${springframework.version}</version>
             </dependency>
             <!-- spring jar end -->
 
             <dependency>
                 <groupId>org.mybatis</groupId>
                 <artifactId>mybatis</artifactId>
                 <version>${mybatis.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>org.mybatis</groupId>
                 <artifactId>mybatis-spring</artifactId>
                 <version>${mybatis-spring.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>mysql</groupId>
                 <artifactId>mysql-connector-java</artifactId>
                 <version>${mysql-driver.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>com.oracle</groupId>
                 <artifactId>ojdbc14</artifactId>
                 <version>${oracle.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>org.aspectj</groupId>
                 <artifactId>aspectjweaver</artifactId>
                 <version>${aspectjweaver.version}</version>
             </dependency>
 
 
             <dependency>
                 <groupId>commons-dbcp</groupId>
                 <artifactId>commons-dbcp</artifactId>
                 <version>${commons-dbcp.version}</version>
             </dependency>
             <dependency>
                 <groupId>commons-pool</groupId>
                 <artifactId>commons-pool</artifactId>
                 <version>${commons-pool.version}</version>
             </dependency>
             <dependency>
                 <groupId>commons-fileupload</groupId>
                 <artifactId>commons-fileupload</artifactId>
                 <version>${commons-fileupload.version}</version>
             </dependency>
 
 
             <!-- log jar -->
             <dependency>
                 <groupId>log4j</groupId>
                 <artifactId>log4j</artifactId>
                 <version>${log4j.version}</version>
             </dependency>
             <dependency>
                 <groupId>org.slf4j</groupId>
                 <artifactId>slf4j-api</artifactId>
                 <version>${slf4j-api.version}</version>
             </dependency>
             <dependency>
                 <groupId>org.slf4j</groupId>
                 <artifactId>slf4j-log4j12</artifactId>
                 <version>${slf4j-log4j12.version}</version>
             </dependency>
 
             <!-- freemarker -->
             <dependency>
                 <groupId>org.freemarker</groupId>
                 <artifactId>freemarker</artifactId>
                 <version>${freemarker.version}</version>
             </dependency>
 
 
             <!-- jackson -->
             <dependency>
                 <groupId>com.fasterxml.jackson.core</groupId>
                 <artifactId>jackson-core</artifactId>
                 <version>${jackson-core.version}</version>
             </dependency>
             <dependency>
                 <groupId>org.codehaus.jackson</groupId>
                 <artifactId>jackson-mapper-asl</artifactId>
                 <version>${jackson-mapper-asl.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>javax.servlet</groupId>
                 <artifactId>javax.servlet-api</artifactId>
                 <version>${javax.servlet-api.version}</version>
                 <scope>provided</scope>
             </dependency>
 
             <dependency>
                 <groupId>javax.servlet.jsp</groupId>
                 <artifactId>jsp-api</artifactId>
                 <version>${jsp-api.version}</version>
                 <scope>provided</scope>
             </dependency>
 
             <dependency>
                 <groupId>com.googlecode</groupId>
                 <artifactId>kryo</artifactId>
                 <version>${kryo.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>org.yaml</groupId>
                 <artifactId>snakeyaml</artifactId>
                 <version>${snakeyaml.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>redis.clients</groupId>
                 <artifactId>jedis</artifactId>
                 <version>${jedis.version}</version>
             </dependency>
 
             <dependency>
                 <groupId>commons-lang</groupId>
                 <artifactId>commons-lang</artifactId>
                 <version>${commons-lang.version}</version>
             </dependency>
 
 
             <dependency>
                 <groupId>org.mockito</groupId>
                 <artifactId>mockito-core</artifactId>
                 <version>${mockito-core.version}</version>
                 <scope>test</scope>
             </dependency>
 
             <dependency>
                 <groupId>org.powermock</groupId>
                 <artifactId>powermock-core</artifactId>
                 <version>${powermock-core.version}</version>
                 <scope>test</scope>
             </dependency>
 
             <dependency>
                 <groupId>org.powermock</groupId>
                 <artifactId>powermock-api-mockito</artifactId>
                 <version>${powermock-api-mockito.version}</version>
                 <scope>test</scope>
             </dependency>
 
             <dependency>
                 <groupId>org.powermock</groupId>
                 <artifactId>powermock-module-junit4</artifactId>
                 <version>${powermock-module-junit4.version}</version>
                 <scope>test</scope>
             </dependency>
 
 
         </dependencies>
     </dependencyManagement>
     
     <distributionManagement>
         <repository>
             <id>releases</id>
             <name>public</name>
             <url>http://59.50.95.66:8081/nexus/content/repositories/releases</url>
         </repository>
         <snapshotRepository>
             <id>snapshots</id>
             <name>Snapshots</name>
             <url>http://59.50.95.66:8081/nexus/content/repositories/snapshots</url>
         </snapshotRepository>
     </distributionManagement>
     
     
     
 <build>
     <plugins>
 
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-compiler-plugin</artifactId>
             <version>${maven-compiler-plugin.version}</version>
             <configuration>
                 <source>1.7</source> <!-- 源代码使用的开发版本 -->
                 <target>1.7</target> <!-- 需要生成的目标class文件的编译版本 -->
             </configuration>
         </plugin>
 
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-javadoc-plugin</artifactId>
             <version>${maven-javadoc-plugin.version}</version>
         </plugin>
 
 
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-release-plugin</artifactId>
             <version>${maven-release-plugin.version}</version>
         </plugin>
 
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-deploy-plugin</artifactId>
             <version>${maven-deploy-plugin.version}</version>
             <configuration>
                 <updateReleaseInfo>true</updateReleaseInfo>
             </configuration>
         </plugin>
 
 
 
     </plugins>
 </build>
 
 
     <pluginRepositories>
         <pluginRepository>
             <id>nexus</id>
             <name>nexus</name>
             <url>http://192.168.0.70:8081/content/groups/public/</url>
             <releases>
                 <enabled>true</enabled>
             </releases>
             <snapshots>
                 <enabled>true</enabled>
             </snapshots>
         </pluginRepository>
     </pluginRepositories>
 
     
 </project>

需要注意的是，他的packaging和聚合一样为pom，作为父模块的pom，其打包类型必须为pom。父模块只是为了帮助消除配置的重复，因此他本身不包含除POM的项目文件，也就不需要src/main/java之类的文件夹了。

有了父模块，就需要让其他模块来继承它，我们来看个实际的例子：

<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/maven-v4_0_0.xsd">
   <modelVersion>4.0.0</modelVersion>
 
     <parent>
         <groupId>com.uidp</groupId>
         <artifactId>UidpParent</artifactId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>
 
   <groupId>com.uidp</groupId>
   <artifactId>log</artifactId>
   <packaging>war</packaging>
   <version>0.0.1-SNAPSHOT</version>
   <name>log</name>
   <url>http://maven.apache.org</url>
 
     <dependencies>
 
         <dependency>
             <artifactId>ThirdParty</artifactId>
             <version>0.0.1-SNAPSHOT</version>
             <groupId>${project.parent.groupId}</groupId>
             <type>war</type>
         </dependency>
 
         <dependency>
             <groupId>com.uidp</groupId>
             <artifactId>WebCommon</artifactId>
             <version>0.0.1-SNAPSHOT</version>
         </dependency>
 
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <scope>test</scope>
         </dependency>
 
         <dependency>
             <groupId>org.aspectj</groupId>
             <artifactId>aspectjweaver</artifactId>
         </dependency>
 
         <!-- spring jar begin -->
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-web</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-webmvc</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-beans</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context-support</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-core</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-jdbc</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-tx</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-test</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-expression</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-aop</artifactId>
         </dependency>
         <!-- spring jar end -->
         
         <!-- Quartz 框架 -->
         <dependency>
             <groupId>org.quartz-scheduler</groupId>
             <artifactId>quartz</artifactId>
             <version>1.8.6</version>
         </dependency>
 
         <!-- mybatis db -->
         <dependency>
             <groupId>org.mybatis</groupId>
             <artifactId>mybatis</artifactId>
         </dependency>
 
         <dependency>
             <groupId>org.mybatis</groupId>
             <artifactId>mybatis-spring</artifactId>
         </dependency>
 
         <!-- mysql驱动依赖包 -->
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
         </dependency>
 
         <!-- 数据库连接池 jar -->
         <dependency>
             <groupId>commons-dbcp</groupId>
             <artifactId>commons-dbcp</artifactId>
         </dependency>
         <dependency>
             <groupId>commons-pool</groupId>
             <artifactId>commons-pool</artifactId>
         </dependency>
         <dependency>
             <groupId>commons-fileupload</groupId>
             <artifactId>commons-fileupload</artifactId>
         </dependency>
 
         <!-- jackson -->
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>
         </dependency>
         <dependency>
             <groupId>org.codehaus.jackson</groupId>
             <artifactId>jackson-mapper-asl</artifactId>
         </dependency>
 
         <!-- log jar -->
         <dependency>
             <groupId>log4j</groupId>
             <artifactId>log4j</artifactId>
         </dependency>
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>
         </dependency>
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-log4j12</artifactId>
         </dependency>
 
         <!-- freemarker -->
         <dependency>
             <groupId>org.freemarker</groupId>
             <artifactId>freemarker</artifactId>
         </dependency>
 
         <dependency>
             <groupId>com.oracle</groupId>
             <artifactId>ojdbc14</artifactId>
         </dependency>
 
         <!--因为api是打jar包的，所以这里用compile，如果是正常情况打war包，用private-->
         <dependency>
             <groupId>javax.servlet</groupId>
             <artifactId>javax.servlet-api</artifactId>
             <scope>compile</scope>
         </dependency>
 
         <dependency>
             <groupId>javax.servlet.jsp</groupId>
             <artifactId>jsp-api</artifactId>
             <scope>compile</scope>
         </dependency>
 
         <dependency>
             <groupId>commons-lang</groupId>
             <artifactId>commons-lang</artifactId>
             <version>2.6</version>
         </dependency>
 
     </dependencies>
     <build>
         <plugins>
 
             <plugin>
                 <groupId>org.mortbay.jetty</groupId>
                 <artifactId>jetty-maven-plugin</artifactId>
                 <version>7.2.2.v20101205</version>
                 <configuration>
                     <stopKey>foo</stopKey>
                     <stopPort>9999</stopPort>
                     <webAppConfig>
                         <contextPath>/</contextPath>
                     </webAppConfig>
                     <!-- 指定额外需要监控变化的文件或文件夹，主要用于热部署中的识别文件更新 -->
                     <scanTargetPatterns>
                         <scanTargetPattern>
                             <directory>src</directory>
                             <!-- <includes> <include>**/*.java</include> <include>**/*.properties</include>
                                 </includes> -->
                             <!-- <excludes> <exclude>**/*.xml</exclude> <exclude>**/myspecial.properties</exclude>
                                 </excludes> -->
                         </scanTargetPattern>
                     </scanTargetPatterns>
                     <scanIntervalSeconds>1</scanIntervalSeconds>
                     <webAppSourceDirectory>${basedir}/src/main/webapp</webAppSourceDirectory><!--
                         指定web页面的文件夹 -->
                 </configuration>
             </plugin>
 
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-war-plugin</artifactId>
                 <version>${maven-war-plugin.version}</version>
                 <configuration>
                     <failOnMissingWebXml>false</failOnMissingWebXml>
                     <warName>${project.artifactId}</warName>
                 </configuration>
             </plugin>
         </plugins>
     </build>
 </project>

上述POM中使用parent元素声明父模块，parent下的子元素groupId、artifactId和version指定了父模块的坐标，这三个元素是必须的。relativePath元素是可选的，我这里用的默认值所以并没有配置，relativePath元素的默认值为../pom.xml，也就是说，Maven默认父POM在上一层目录下。当项目构建时，Maven会首先根据relativePath检查父POM，如果找不到，再从本地仓库找。所以像我这里如果本地仓库中也没有父POM的话构建就会失败了，所以最好的做法是配置relativePath为../parent/pom.xml表示父POM的位置与在log/目录平行的parent/下。这样就算本地仓库没有父POM构建的时候也不会报错了。

大家有木有发现log的groupId和version元素是与父POM一样的，所以这里其实是可以省略不要的，但是如果log有自己专门的groupId和version，那么就显示的配置一个就好了。对于artifactId元素来说，子模块应该显式的声明，避免造成坐标冲突和混淆。

对于依赖的继承，我们可以把依赖放入<dependencyManagement>元素当中，这样的依赖就成了可选的，我们只要在项目中继承我们所需的依赖即可，比如：

<dependency>
　　<groupId>junit</groupId>
　　<artifactId>junit</artifactId>
　　<scope>test</scope>
</dependency>

我们不需要进行版本的声明，这样就可以根据自己的需要引入需要的包，而不会继承全部的包。

对于每个项目都需要继承的依赖则不放在<dependencyManagement>元素当中，不过个人觉得没什么必要，都放在<dependencyManagement>元素当中，需要的时候引入一下就好了。

插件的继承与依赖的继承是类似的，这里不过多的说明，插件也有一个<pluginManagement></pluginManagement>元素，放在下面的插件也表示为可选的。

在使用父POM的时候也要在聚合模块中加入：

<module>parent</module>

应该是放在最前面，大家可以看看上面的聚合POM。

3.可继承的POM元素

groupId和version是可以被继承的，那么还有哪些POM元素可以被继承呢？以下是一个完整的列表，并附带了简单的说明：

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

4.聚合与继承的关系

区别 ：

1.对于聚合模块来说，它知道有哪些被聚合的模块，但那些被聚合的模块不知道这个聚合模块的存在。

2.对于继承关系的父POM来说，它不知道有哪些子模块继承于它，但那些子模块都必须知道自己的父POM是什么。

共同点 ：

1.聚合POM与继承关系中的父POM的packaging都是pom。

2.聚合模块与继承关系中的父模块除了POM之外都没有实际的内容。

图示：

DbhVozhcEZvQGMfR6Pkc-A33RMAoVqH3kdctdDxLPixt8BQ5CIJxrwKZMacVtVD2O6ZPxPY9RkI2YzvYD92oI6EeoXEbH-tUE9xf3_wQ3FBFN3KKPaEbBkSORdk4THDM.png

5.有关版本的简单说明

对于用过svn或者cvs的朋友们，都会知道，每次修改都会提交一个版本到服务器上，对于我们平常所搭建的项目，大家可能没有注意到版本这个概念。其实版本对于叠加式开发的项目是个很重要的概念，通过上面的依赖，我们就可以清楚地看到一个version，这个就是引入依赖包的版本。

那么版本一共可以分为几个层次，一般来说，版本可以分为：总版本号.分支版本号.小版本号-里程碑版本。

总版本号：一般表示框架的变动。

分支版本号：一般表示增加了一些功能。

小版本号：在分支版本上面进行bug的修复。

里程碑：SNAPSHOT-->alpha-->beta-->release-->GA

结束语：关于继承所包含的内容比较多，不是三言两语就能描述的很清楚的，所以再次强烈建议大家可以购买许晓斌老师的《Maven实战》，这本书会介绍的比较详细，个人觉得最好的投资就是投资自己的学习，所以如果你是Maven的初学者，应该和我一样购买这本书籍，如果是大神，那么也就没必要看这篇博文了，营养价值并不高。

可爱博主：AlanLee

博客地址：http://www.cnblogs.com/AlanLee

本文出自开发小组，欢迎大家加入开发小组。

编程爱好者联盟

编程爱好者联盟

相关推荐

Spring+SpringMVC+Mybatis(SSM) maven 配置

--数据库连接池-->

咻pur慢 / 0评论 2020-05-29

springboot整合mybatis

<?xml version="1.0" encoding="UTF-8"?>. <modelVersion>4.0.0</modelVersion>. <parent>

kevincheung / 0评论 2020-05-17

springboot 框架 - 探究-pom文件

</dependency>spring-boot-starter：spring-boot场景启动器，导入了web模块正常运行所依赖的组建Spring Boot将所有的功能场景抽取出来，做成一个个的starters（启动器），只需要在项目里面引入

也许不会看见 / 0评论 2020-01-28

maven的pom文件

pom.xml打jar包时加入依赖的包：。-- NOTE: We don't need a groupId specification because the group is

fujing / 0评论 2014-07-10

03_Maven核心_POM_坐标与依赖

POM文件定义了项目的基础信息，用于描述项目如何构建，声明项目依赖等等。第一行指定XML文档的版本和编码方式。后面三行就比较重要了，它定义了项目的基本坐标。我们知道在这个世界上有海量的构件，如果没有一个唯一的标识，Maven将很难定位。Maven就能定位唯

ApachePHPMySQL / 0评论 2014-07-10

mybatis的HELLOWORD

--在build中配置resources，来防止我们资源导出失败的问题-->

dongxurr / 0评论 2019-12-26

docker初体验：Docker部署SpringCloud项目eureka-server

<?xml version="1.0" encoding="UTF-8"?>. <artifactId>spring-boot-starter-parent</artifactId>

糊一笑 / 0评论 2019-12-18

SpringCloud分布式微服务云架构 第一篇： 服务的注册与发现Eureka(Finchley版

spring cloud 为开发人员提供了快速构建分布式系统的一些工具包括配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等。另外说明spring cloud是基于springboot的所以需要开发中对springboot

ithzhang / 0评论 2019-12-12

spring boot pom demo

<modelVersion>4.0.0</modelVersion>. <parent>. <artifactId>spring-boot-starter-parent</artifactId>.

登峰小蚁 / 0评论 2019-10-24

Maven基础教程之继承

但是，通过总结上一篇文章，大家可能会发现这么个问题，Project-A和Project-B项目的POM文件，有很多相同的部分。在Maven的世界里，也有类似的机制能让我们提取出重复的配置，这就是POM的继承，而这篇文章就对Maven中的POM继承进行详细的

在旅途 / 0评论 2019-10-06

myeclipse 搭建模块化 maven项目

在工作的时候，大多时候都是用Maven来管理项目，可是一般我们都知道怎么用maven管理工程，却不知道通过Maven自己来建立多模块工程。于是自己抽时间，在网上找些资料，做了起来。项目工程的依赖关系：mv-core依赖mv-lib,mv-xml;mv-we

wangzhe00 / 0评论 2016-04-19

Rainbond Java Maven 多模块源码构建

Maven 多模块项目是根据 pom.xml 文件来划分的, Rainbond 对它的识别也是建立在 pom 的基础上的. 主要是识别出具体模块的构建命令和启动命令. 构建命令的作用是指定需要构建的模块, 是类似于 "mvn install -p

keyxiaodj / 0评论 2019-09-05

常用Maven配置

<?xml version="1.0" encoding="UTF-8"?>. <modelVersion>4.0.0</modelVersion>. <artifactId

xiaoxin0 / 0评论 2017-07-09

maven错误收集

收集自己遇到的maven问题。导入Maven工程到eclipse中时，发生上面错误，时因为pom.xml文件存在不能解析的内容，解决办法：。将pom.xml中的内容删减，然后再导入，等到导入成功，然后再将原内容复制过来即可。在M2对应目录里发现maven-

LJ / 0评论 2016-02-25

maven项目中如何在properties文件中读取pom文件的键值对

都知道使用properties能够把项目相关的配置的以key-value的形式存到一起，需要修改的时候也能够很快定位，替换。比如项目当中的数据库链接相关的配置即使如此

fuel / 0评论 2017-09-25

Maven入门指南

Maven是用Java开发的一个强大的Java项目构建工具。这篇教程的目的是帮助你理解Maven的工作机制。因此教程主要关注Maven的核心概念。自动化构建过程的好处是将手动构建过程中犯错的风险降到最低。显示Maven错误信息说明Maven已经安装好了。注

yangxiaobo / 0评论 2014-08-21

maven 教程二 深入

这三个元素定义了一个项目基本的坐标，在Maven的世界，任何的jar、pom或者war都是以基于这些基本的坐标进行区分的。本例中artifactId 为 my-app 3.3：version 顾名思义，version指定了项目当前的版本。

Selier / 0评论 2015-03-11

在jenkins中使用findbugs并自定义错误类型

2.在maven的pom文件中增加构建插件maven-site-plugin和报表插件findbugs-maven-plugin

HaleyJenkins / 0评论 2014-01-08

工程管理之四：Maven工程管理配置

最近经常使用Maven管理工程，于是总结一下使用过的Maven pom.xml配置。我本地使用的Maven版本是apache-maven-3.0.3。工程为普通java application打成jar包形式部署，web工程配置在后面也会做简要介绍。--

xiaoxin0 / 0评论 2013-04-20

Spring 3.0 maven的pom配置

-- Core utilities used by other modules. Define this if you use Spring. -- Expression Language Define this if you use. this if

周太郎 / 0评论 2012-03-03

SpringMVC使用pom.xml定义的变量

</properties>2.pom.xml配置，使用变量替换

明亮的技术 / 0评论 2016-06-20

pom.xml

-- ************************依赖配置 ******************************** --> <!-- maven resource 将资源打包进jar中 --> <dependency

Geogrewu / 0评论 2015-07-26

spring security (-) helloWorld

<modelVersion>4.0.0</modelVersion>. <groupId>com.family168</groupId>. <artifactId>springsecuritybo

iamlihongwei / 0评论 2015-07-16

MyEclipse10使用Maven创建项目时报错 解决方法

使用MyEclipse10自带的Maven插件创建Web项目时报错：

yixiaoqi00 / 0评论 2015-07-15

pom.xml详解

ProjectObjectModel，项目对象模型。通过xml格式保存的pom.xml文件。作用类似ant的build.xml文件，功能更强大。该文件用于管理：源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目授权、项目的url、项目的依赖

直须看尽洛城花 / 0评论 2015-01-21

Intellij maven

<?xmlversion="1.0"encoding="UTF-8"?>

XingKai / 0评论 2014-10-09

03_Maven核心_POM_坐标与依赖

POM文件定义了项目的基础信息，用于描述项目如何构建，声明项目依赖等等。</project>第一行指定XML文档的版本和编码方式。Maven就能定位唯一构件。小明和小红协同开发，小红开发的B模块是依赖小明开发的A模块。如果一个版本包含字符串“S

XHuiLin / 0评论 2014-07-10

[maven + spring]SpringInAction【pom.xml】dependency配置

<modelVersion>4.0.0</modelVersion>. <groupId>com.lh</groupId>. <artifactId>springtest02</artifa

小高 / 0评论 2014-03-28

jersey 1.17+spring 3.1.0.RELEASE+hibernate 3.3.1.GA maven 配置文

忙了一天，终于把框架搭建起来了，很高兴。公司要求使用 jersey 1.17+spring 3.1.0.RELEASE+hibernate 3.3.1.GA 来完成框架，以前都用springmvc的。今天新东西就当学些了。下面把配置文件及源代码部署出来，供

ErixHao / 0评论 2013-09-14

jersey 2.2 +spring 3.1.0.RELEASE+hibernate 3.3.1.GA maven 配置文件

最近公司要求搭建一个jersey 2 +spring 3.1.0.RELEASE+hibernate 3.3.1.GA 的平台项目，费了九牛二虎之力终于把冲突包去掉，搭建完成，这里把maven配置文件发布出来供大家吐槽一下。

直须看尽洛城花 / 0评论 2013-09-14

myeclipse 搭建模块化 maven项目

在工作的时候，大多时候都是用Maven来管理项目，可是一般我们都知道怎么用maven管理工程，却不知道通过Maven自己来建立多模块工程。于是自己抽时间，在网上找些资料，做了起来。项目工程的依赖关系：mv-core依赖mv-lib,mv-xml;mv-we

oldboy / 0评论 2016-04-19

CXF开通用户认证

假设以上环境已经安装完毕，各软件能独立正确运行。在适当的地方建立一个cxftest目录,然后在此目录再建一个cxftest_build目录。在cxftest_build目录中建立pom.xml文件,输入一下内容:

apacheuk / 0评论 2016-03-28

mybatis

pom. <modelVersion>4.0.0</modelVersion>. <groupId>com.xuewen.demo</groupId>. <artifactId>study3<

zhangbeizhen / 0评论 2015-04-08

maven使用一个小技巧（排除不同兄弟依赖中版本的不同的问题）

---关于项目的唯一标示-->. ---关于项目的依赖jar--><dependencies>. ----定义公共的项目中在类库中排除json类库--->

XingKai / 0评论 2009-12-12

T5+spring2.0+hibernate3.2+xfire使用类库列表

在eclipse3.2中新建maven项目，项目依赖maven库，maven的搭建前面有讲解。将如下内容拷贝进去替换原来的文件内容就可以支持T5+spring2.0+hibernate3.2，同时支持xfire做webservice开发。保存文件后，有些类

jacky的部落 / 0评论 2008-06-17

MAVEN依赖整个SPRING

<!-- spring -->. <dependency>. <artifactId>spring-framework-bom</artifactId>. <version>${spring.ve

kunzai / 0评论 2019-03-19

pom.xml

<modelVersion>4.0.0</modelVersion>. <parent>. <groupId>com.xxx.xx</groupId>. <artifactId>xxx

mituan / 0评论 2016-08-22

Maven项目的目录结构

刚接触Maven没多长时间，实习时在的小公司很不规范，所有web项目都是dynamic web project搭建，没有用到项目构建，管理工具，导致了非常多的重复工作与低效。Maven 除了以程序构建能力为特色之外，还提供高级项目管理工具。由于 Maven

daidaizhuzhu / 0评论 2015-03-14

maven+testng+eclipse

--添加插件 关联testNg.xml -->

BitTigerio / 0评论 2018-05-07

Spring Cloud Config

<?xml version="1.0" encoding="UTF-8"?>. <description>Demo project for Spring Boot</descriptio

出版圈郭志敏 / 0评论 2017-12-15

关于maven-基本

笔记Maven项目对象模型，可以通过一小段描述信息来管理项目的构建，报告和文档的软件项目管理工具。当你使用Maven的时候，你用一个明确定义的项目对象模型来描述你的项目，然后Maven可以应用横切的逻辑，这些逻辑来自一组共享的插件。所以，总体来说，pom是

BitTigerio / 0评论 2017-11-29

Maven 引用本地 jar 到 pom.xml

[INFO] ------------------------------------------------------------------------. [INFO] ----------------------------------------

编程爱好者联盟 / 0评论 2017-03-05