（尊重劳动成果，转载请注明出处：https://blog.csdn.net/qq_25827845/article/details/83867717冷血之心的博客）
 
 
 
关注微信公众号（文强的技术小屋），学习更多技术知识，一起遨游知识海洋~
 
 
 
 
快速导航：
 
Maven基础概念和安装配置教程
 
Maven的仓库和settings.xml配置文件
 
Maven的坐标与依赖
 
Maven的生命周期和插件
 
Maven的聚合与继承
 
目录
 
聚合
 
继承
 
聚合和继承的关系
 
反应堆
 
裁剪反应堆
 
总结
 

         在上边的学习中，我们介绍了Maven是一种强大的构建工具，能够帮助我们自动下载构件，并且通过给每一个构件确定其坐标，实现了构件在仓库中的存储。正是Maven的生命周期和插件的互相绑定才使得我们可以非常愉快的完成项目的构建。在实际的项目中，我们往往会建立多个模块（module）。我们在本文中要介绍的聚合和继承就特别适合多个模块的协同工作。   
 
Maven的聚合特性可以帮助我们把项目的多个模块聚合在一起，使用一条命令进行构建，即一条命令实现构建多个项目；
 
Maven的继承特性可以将各个模块相同的依赖和插件配置提取出来，在简化POM的同时还可以促进各个模块配置的一致性。
 
聚合
 
      我们在一个项目中会存在模块A和模块B，在各自的项目目录下，我们可以分别通过命令 mvn clean package 来构建各个模块，但是如果我们想将这两个模块一起构建呢？
 
       答案是我们需要建立一个模块C做为一个聚合模块。
 
如下图（两个图一起看）所示：
 
 
 
从图中可以看出，passport是各个passport-xx的聚合模块，聚合模块也是一个模块，所以同样会有POM文件，其重要的的pom配置如下：
 
<?xml version="1.0" encoding="UTF-8"?>
<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.baidu</groupId>
    <artifactId>company</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    
    <modules>
        <module>company-agent</module>
        <module>company-java-core</module>
        <module>company-https</module>
        <module>company-http</module>
        <module>company-management</module>
        <module>company-security</module>
        <module>company-login</module>
        <module>company-sns</module>
        <module>company-mt</module>
        <module>company-message-scribe2mysql-storm</module>
        <module>company-activator</module>
        <module>company-activator-api</module>
        <module>company-recard</module>
        <module>company-zk-replicator</module>
        <module>company-app-auth</module>
        <module>company-app-auth-https</module>
        <module>company-app-auth-applier</module>
        <module>company-user-rights</module>
        <module>company-idc</module>
    </modules>
</project>
 
在配置中（此处将passport和company互换了下，为了不泄露公司数据，希望大家可以看懂即可），我们需要注意以下的标签：
 
<packaging>pom</packaging>
 
在前面的学习中，我们见过打包方式为jar和war的，但是聚合模块的打包方式必须为pom，否则无法完成构建。
 
在company聚合模块的目录下，我们执行 mvn clean package，结果如下：
 
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Build Order:
[INFO]
[INFO] company
[INFO] company-swift-common
[INFO] company-db-aio-common
[INFO] company-agent
[INFO] company-security
[INFO] company-captcha
[INFO] company-core
[INFO] company-sns
[INFO] company-request-check
[INFO] company-captcha-voice
[INFO] company-https
[INFO] company-http
[INFO] company-management
[INFO] company app auth https
[INFO] company-app-auth-applier
[INFO] company-user-rights
[INFO] company-idc
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building company 0.0.1-SNAPSHOT
 
可以看到maven给根据各个模块之间的依赖关系，给我们计算好了构建次序（也叫反应堆），接下来将会依次构建各个模块，实现了一条命令构建多个模块。
 
 
 
继承
 
        继承和聚合有相似的地方，继承的特性是指建立一个父模块，我们项目中的多个模块都做为该模块的子模块，将各个子模块相同的依赖和插件配置提取出来，从而简化配置文件，父模块的打包方式必须为pom，否则无法构建项目。父模块和聚合模块经常可以做到合二为一。
 
        通过在各个子模块中配置来表明其继承与哪一个父模块：
 
<parent>
        <groupId>com.baidu</groupId>
        <artifactId>miliao-rootpom</artifactId> 
        <version>2.0.3</version>
</parent>
 
可继承的POM元素如下：
 
groupId：项目组ID，项目坐标的核心元素
version：项目版本，项目坐标的核心因素
description：项目的描述信息
organization：项目的组织信息
inceptionYear：项目的创始年份
url：项目的URL地址
developers：项目的开发者信息
contributors：项目的贡献者信息
distributionManagement：项目的部署配置
issueManagement：项目的缺陷跟踪系统信息
ciManagement：项目的持续集成系统信息
scm：项目的版本控制系统
malilingLists：项目的邮件列表信息
properties：自定义的Maven属性
dependencies：项目的依赖配置
dependencyManagement：项目的依赖管理配置
repositories：项目的仓库配置
build：包括项目的源码目录配置、输出目录配置、插件配置、插件管理配置等
reporting：包括项目的报告输出目录配置、报告插件配置等
聚合和继承的关系
 
       虽然聚合模块和父模块经常合二为一，但是聚合和继承是两个不同的概念，其实是没有什么关系的。
 
聚合模块知道它聚合了哪些模块，但是被聚合的模块不知道聚合模块的存在；
 
父模块不知道子模块的存在，但是子模块都必须知道自己的父模块是谁。
 
可以用下图来表示这两个不同的概念：
 
 
 
 
反应堆
 
        在一个拥有多个模块的Maven项目中，反应堆（Reactor）是指所有模块组成的一个构建结构。对于单个模块的项目来说反应堆就是该模块本身，但是对于多模块的项目来说，反应堆就包含了各个模块之间的继承与依赖的关系，最后再根据各个模块在pom中声明的先后顺序，自动计算出合理的模块构建顺序。
 
在company聚合模块的目录下，我们执行 mvn clean package，在结果的前面就显示了构建顺序（反应堆）：
 
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Build Order:
[INFO]
[INFO] company
[INFO] company-swift-common
[INFO] company-db-aio-common
[INFO] company-agent
[INFO] company-security
[INFO] company-captcha
[INFO] company-core
[INFO] company-sns
[INFO] company-request-check
[INFO] company-captcha-voice
[INFO] company-https
[INFO] company-http
[INFO] company-management
[INFO] company app auth https
[INFO] company-app-auth-applier
[INFO] company-user-rights
[INFO] company-idc
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building company 0.0.1-SNAPSHOT
 
裁剪反应堆
 
      我们可以通过如下的命令来裁剪反应堆：
 
 
比如，我们可以在聚合模块的路径下执行：
 
mvn clean package -pl commpany-test,company-agent   表示我们指定要构建这两个模块。
mvn clean package -pl commpany-test  -am 表示我们要构建commpany-test，同时要构建该模块依赖的其余模块。
        这个裁剪反应堆还是很有作用的，比如我们有一个模块company-A，在该模块中我们依赖company-B模块并且version为0.0.2，如果我们单独构建company-A，那么将会从maven仓库（本地+远程）中去下载version为0.0.2的company-B，若该模块不存在，构建过程将报错。假如我们使用了 -am 参数，那么即使仓库中不存在version为0.0.2的company-B， maven将会自动从当前项目中打包构建version为0.0.2的company-B，前提是company-B的pom配置中version为0.0.2，这样company-A的构建过程将不会出错。
 
 
 
总结
 
      通过本文的介绍，我们学习了Maven的聚合与继承特性，可以更加方便的管理和构建项目了。到此，通过五节课的学习，我们基本完成了Maven的常见知识点的介绍与学习，学会这些基本可以让我们在日常的工作中愉快构建项目了。接下来便是更加高深的Maven用法了，有兴趣的同学可以和博主一起学习。
 
 
 
 
 
如果对你有帮助，记得点赞哦~欢迎大家关注我的博客，可以进群366533258一起交流学习哦~
 
 
本群给大家提供一个学习交流的平台，内设菜鸟Java管理员一枚、精通算法的金牌讲师一枚、Android管理员一枚、蓝牙BlueTooth管理员一枚、Web前端管理一枚以及C#管理一枚。欢迎大家进来交流技术。
 
 
 
 
关注微信公众号（文强的技术小屋），学习更多技术知识，一起遨游知识海洋~
 
 
 

概述
 
      在javaweb高速发展的今天，我们软件设计人员往往会用很多种方式对软件划分模块，目的就是为了能有清晰的设计和低耦合性的，高重用性的软件。Maven有很好的依赖管理系统（Dependency Management System）和项目生命周期的管理（Project Leftcycle）,而其中的依赖管理是本文阐述和做出实例的重点。
 
实例背景
 
       利用一个教程的上面的例子，给大家做讲解。Maven安装有两种方式，一种是直接到Maven官网下载自己电脑的操作系统相应的版本安装，不管是window，linux还是Max os同时官网安装教程也是挺不错的。另外一种是安装eclipse的maven插件，这个很多人都用过，eclipse上面的plugin也是琳琅满目，具体教程网上很多哈。我们今天讲解主要针对后面一种方式，在eclipse进行的搭建Maven项目的操作。对于刚刚接触Maven和不熟悉command行的同学来说，可以是直观的操作，很好。
 
       Maven是apache的一个项目，所以也是源于服务java项目的一个开源工具。所以很多概念也是和java中的基本概念很是相似，比如说继承。我们说java中的父类和子类的关系，子类可以引用父类中非private的变量和方法。反映到Maven项目的搭建也是一样的。Maven中的parent定义的dependency，其中继承者是可以直接使用parent中的Maven Dependencies的。
 
       被继承的Maven项目中的POM的部分定义是     
 
<groupId>com.company</groupId>
<artifactId>company-project-parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
 
      继承的Maven项目中的POM的关键部分就是
 
<parent>
<groupId>com.taotao</groupId>
<artifactId>company-project-parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<artifactId>company-project-children</artifactId>
 
 操作步骤
 
 
建立Maven的parent项目
 
 
填写group Id和artifact Id和选择Packaging
 
  
 
编辑web-parent中项目的pom文件
     其中<modelVersion>、<groupId>、<artifactId>、<version>、<packaging>是创建Maven项目的时候有了，但是<properties>、<dependencyManagement>、<build>中的内容是后面添加的。<dependencyManagement>是定义一个虚拟的资源，这个部分并不直接使用，而<dependencyManagement>中的<dependency>，它的<version>会直接引用到<properties>中的各个resource的版本号。由于<dependencyManagement>中的资源不会直接使用，我们会发现，即使我们定义完这些具体的资源，项目中也没有具体的Maven Dependencies的jar包出现。
 
<projectxmlns="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.company</groupId>
<artifactId>web-parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
<!-- 集中定义依赖版本号 -->
<properties>
<junit.version>4.12</junit.version>
<spring.version>4.1.3.RELEASE</spring.version>
<mybatis.version>3.2.8</mybatis.version>
<mybatis.spring.version>1.2.2</mybatis.spring.version>
<mybatis.paginator.version>1.2.15</mybatis.paginator.version>
<mysql.version>5.1.32</mysql.version>
<slf4j.version>1.6.4</slf4j.version>
<jackson.version>2.4.2</jackson.version>
<druid.version>1.0.9</druid.version>
<httpclient.version>4.3.5</httpclient.version>
<jstl.version>1.2</jstl.version>
<servlet-api.version>2.5</servlet-api.version>
<jsp-api.version>2.0</jsp-api.version>
<joda-time.version>2.5</joda-time.version>
<commons-lang3.version>3.3.2</commons-lang3.version>
<commons-io.version>1.3.2</commons-io.version>
<commons-net.version>3.3</commons-net.version>
<pagehelper.version>3.4.2-fix</pagehelper.version>
<jsqlparser.version>0.9.1</jsqlparser.version>
<commons-fileupload.version>1.3.1</commons-fileupload.version>
<jedis.version>2.7.2</jedis.version>
<solrj.version>4.10.3</solrj.version>
</properties>
<!-- 只定义依赖的版本，并不实际依赖 -->
<dependencyManagement>
<dependencies>
<!-- 时间操作组件 -->
<dependency>
<groupId>joda-time</groupId>
<artifactId>joda-time</artifactId>
<version>${joda-time.version}</version>
</dependency>
<!-- Apache工具组件 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>${commons-lang3.version}</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-io</artifactId>
<version>${commons-io.version}</version>
</dependency>
<dependency>
<groupId>commons-net</groupId>
<artifactId>commons-net</artifactId>
<version>${commons-net.version}</version>
</dependency>
<!-- Jackson Json处理工具包 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>${jackson.version}</version>
</dependency>
<!-- httpclient -->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>${httpclient.version}</version>
</dependency>
<!-- 单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<!-- 日志处理 -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!-- Mybatis -->
<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>com.github.miemiedev</groupId>
<artifactId>mybatis-paginator</artifactId>
<version>${mybatis.paginator.version}</version>
</dependency>
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>${pagehelper.version}</version>
</dependency>
<!-- MySql -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<!-- 连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>${druid.version}</version>
</dependency>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- JSP相关 -->
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>${jstl.version}</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>${servlet-api.version}</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jsp-api</artifactId>
<version>${jsp-api.version}</version>
<scope>provided</scope>
</dependency>
<!-- 文件上传组件 -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>${commons-fileupload.version}</version>
</dependency>
<!-- Redis客户端 -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>${jedis.version}</version>
</dependency>
<!-- solr客户端 -->
<dependency>
<groupId>org.apache.solr</groupId>
<artifactId>solr-solrj</artifactId>
<version>${solrj.version}</version>
</dependency>
</dependencies>
</dependencyManagemen>
<build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <!-- 资源文件拷贝插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.7</version>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!-- java编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
        <pluginManagement>
            <plugins>
                <!-- 配置Tomcat插件 -->
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <version>2.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>t>
</project>
 
        这个现象有点像java中interface，定义了变量和方法，但是不会直接使用，得有具体的class来实现。所以我们发现继承了的Maven项目如果在<dependencies>“实现”了parent maven的<dependency>，就会直接的出现改jar包。
 
       当然，如果第一次建立Maven项目，要等待很长时间去maven的网上资源库下载到相应的文件，所以不要着急。
 
2.创建子项目web-common
 
       创建一个子项目，packagin要选择jar，parent project要选择要继承的maven project。packaging中有三种选项，一种是pom，一种是jar，一种是war。无论选择哪一种，最后都是maven项目，所有都带有pom配置文件。但是jar和war是会有其他一些文件（jar中有libraries, resources and accessories files like property files，而war将会被部署在一些服务容器上面，所以war有jsp, html, javascript and other files necessary ）
 
 
web-common的pom的文件会如下
<projectxmlns="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.company</groupId>
<artifactId>web-parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<groupId>com.company</groupId>
<artifactId>web-common</artifactId>
<version>0.0.1-SNAPSHOT</version>
</project>
 
但是我们要添加部分内容
 
<dependencies>
<dependency>
<groupId>joda-time</groupId>
<artifactId>joda-time</artifactId>
</dependency>
<!-- Apache工具组件 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-io</artifactId>
</dependency>
<dependency>
<groupId>commons-net</groupId>
<artifactId>commons-net</artifactId>
</dependency>
<!-- Jackson Json处理工具包 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
<!-- httpclient -->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
</dependency>
<!-- 单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
<!-- 日志处理 -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
</dependency>
</dependencies>
 
Finish后，我们会看pom和war的Maven项目的不同
 
到这里我们就会讲完了继承的关系了，继续讲解聚合。
 现在我们新建一些工程来测试Maven聚合：
 

一、建立以pom为packaging的项目为，然后再以这一个项目为parent project来聚合其他子项目
 
新建立一个以pom的项目
 
       改写pom文件，依赖web-common，这样就可以将web-common中的jar包都实现过来，这个有点像 java中implement了一个接口后，在实现了吧。我们是packaging为pom的项目，所以也是给准备实现了该maven的project，做好铺垫吧。
 
<projectxmlns="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.company</groupId>
<artifactId>web-parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<groupId>com.company</groupId>
<artifactId>web-test</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
<dependencies>
<dependency>
<groupId>com.company</groupId>
<artifactId>web-common</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
 
所以我们会看到项目的初始文件目录，很简单
 
 
二、我们接下来要根据上面建立的项目实现聚合的例子
 
点击web-test这个项目，右键，新建一个maven的module
创建一个来存放pojo的module部分，packaging为jar（不要选择pom或者war，具体看上一篇）

点击finish
这个时候，我们会发现web-test中的pom文件多了下面的内容
<modules>
<module>web-test-pojo</module>
</modules>
 
说明我们把web-test-pojo已经聚合到web-test中去了。
同时web-test-pojo的内容是继承了web-common中的部分内容，而web-test-pojo的pom其实是不用修改的。

 
 
三、同时我们再建立以web-test为基础的web-test-mapper和web-test-service的module，这个和步骤二是一模一样的，唯一有区别的地方就是建立完后要在pom文件中加入每个模块自己单独需要的dependencies。另外一个就是web-test-mapper是依赖于web-test-pojo，所以web-test-mapper中的dependencies是含有web-test-pojo的dependency，而web-test-service则是依赖于web-test-mapper。所以下面将展示web-test-mapper和web-test-service的pom文件。
 
web-test-mapper的pom文件如下：
 
<projectxmlns="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.company</groupId>
<artifactId>web-test</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<artifactId>web-test-mapper</artifactId>
<!-- 依赖管理 -->
<dependencies>
<dependency>
<groupId>com.company</groupId>
<artifactId>web-test-pojo</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
</dependency>
<dependency>
<groupId>com.github.miemiedev</groupId>
<artifactId>mybatis-paginator</artifactId>
</dependency>
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
</dependency>
<!-- MySql -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- 连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
</dependency>
</dependencies>
</project>
 
web-test-service的pom文件
 
 
 
<projectxmlns="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.company</groupId>
<artifactId>web-test</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<artifactId>web-test-service</artifactId>
<dependencies>
<dependency>
<groupId>com.company</groupId>
<artifactId>web-test-mapper</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
</dependency>
</dependencies>
</project>
 
 
 
四、建立以war为基础的Maven项目，我们之前已经建立了三个以web-test为parent的Maven的jar的模块，但是要发布一个web项目，必须是有war包，war中才含有文件夹来存放前端的js，jsp等文件啦。和上面一样，在web-test上面创建module，不同的是，创建的packaging是war
 
创建一个module
选择war
在pom文件中加入自己想要的dependency
<projectxmlns="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.company</groupId>
<artifactId>web-test</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<artifactId>web-test-web</artifactId>
<packaging>war</packaging>
<!-- 依赖管理 -->
<dependencies>
<dependency>
<groupId>com.company</groupId>
<artifactId>web-test-service</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
<!-- JSP相关 -->
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jsp-api</artifactId>
<scope>provided</scope>
</dependency>
<!-- 文件上传组件 -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
</dependency>
</dependencies>
</project>
 
五、此时，我们可以看到web-test其实已经聚合四个module，四个module在web-test的基础建立起来，但是他们又是一个整体，所以，当项目发布的时候，其实以web-test为单位的。
 
<projectxmlns="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.company</groupId>
<artifactId>web-parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<groupId>com.company</groupId>
<artifactId>web-test</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
<dependencies>
<dependency>
<groupId>com.company</groupId>
<artifactId>web-common</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
</dependencies>
<modules>
<module>web-test-pojo</module>
<module>web-test-mapper</module>
<module>web-test-service</module>
<module>web-test-web</module>
</modules>
</project>
 
六、其实到了这里，我们就把一个项目的聚合和模块被聚合的例子讲完了，但是如果要跑这个项目也是可以的。
 
在web-test中pom的文件加入以下内容，将tomcat的插件配置到web-test中去
<build>
<!-- 配置插件 -->
<plugins>
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<configuration>
<port>8080</port>
<path>/</path>
</configuration>
</plugin>
</plugins>
</build>
 
另外在，web-parent和web-common安装到本地的仓库中去
 在web-parent项目上面右键，然后run as 
然后在goal 填入install
同样的步骤在web-common项目执行
执行后，在web-test这个主项目中run下面的代码  clean tomcat7:run


 最后就可以登陆看web-test中的首页了，继承与聚合实例测试完成。
 

 
文章目录
 
项目
Maven聚合
rpc 模块创建
继承
pom 依赖配置
relativePath元素
可以通过继承的元素有以下这些
    
    
依赖管理(dependencyManagement)
单继承问题
    
插件管理(pluginManagement)
案例
    
    
聚合与继承的关系
代码编译时文件编码配置
`mvn test` 命令
参考
  
 

 
项目
 
github 建个仓库
执行 git clone 克隆项目到本地
idea 新建项目
 
 
Maven聚合
 
<modules>
    <module>模块1</module>
    <module>模块2</module>
    <module>模块n</module>
</modules>
<package>pom</package>
 
 
 
新的项目中执行任何mvn命令，都会modules中包含的所有模块执行同样的命令，而被包含的模块不需要做任何特殊的配置，正常的maven项目就行
 
 
rpc 模块创建
 
不继承父pom, parent:None
 
 
继承
 
 
创建一个父maven构件，将依赖信息放在pom.xml中
 
<dependencies>
   <dependency>依赖的构件的坐标信息</dependency>
   <dependency>依赖的构件的坐标信息</dependency>
   <dependency>依赖的构件的坐标信息</dependency>
</dependencies>
 
 
将父构件的package元素的值置为pom
 
<packaging>pom</packaging>
 
 
在子构件的pom.xml引入父构件的配置：
 
<parent>
   <groupId>父构件groupId</groupId>
   <artifactId>父构件artifactId</artifactId>
   <version>父构件的版本号</version>
   <relativePath>父构件pom.xml路径</relativePath>
</parent>
 
 
 
 
relativePath表示父构件pom.xml相对路径，默认是../pom.xml，所以一般情况下父子结构的maven构件在目录结构上一般也采用父子关系。
 
 

 pom.xml 文 件
 
 
pom 依赖配置
 
 
 
mvn dependency:tree这个插件可以根据pom.xml的配置，列出构件的依赖树信息。
 
 
relativePath元素
 
父构件和子构件的目录结构刚好符合父子关系，如果父构件和子构件的目录不是父子关系，比如都位于同等级别的目录或者位于更复杂的目录的时候，此时我们需要在子pom.xml的parent元素中使用relativePath元素来指定父pom.xml相对路径位置，这个值我们上面没有指定，默认是../pom.xml，表示父pom.xml位于子pom.xml的上一级目录，我们的模块刚好符合这种关系，所以这个值省略了。
 
正确的设置relativePath是非常重要的，这个需要注意，子模块中执行mvn命令的时候，会去找父pom.xml的配置，会先通过relativePath指定的路径去找，如果找不到，会尝试通过坐标在本地仓库进行查找，如果本地找不到，会去远程仓库找，如果远程仓库也没有，会报错。
 
可以通过继承的元素有以下这些
 
groupId：项目组ID，项目坐标的核心元素
version：项目版本，项目坐标的核心元素
description：项目的描述信息
organization：项目的组织信息
inceptionYear：项目的创始年份
url：项目的url地址
developers：项目的开发者信息
contributors：项目的贡献者信息
distributionManagement：项目的部署配置信息
issueManagement：项目的缺陷跟踪系统信息
ciManagement：项目的持续集成系统信息
scm：项目的版本控制系统信息
mailingLists：项目的邮件列表信息
properties：自定义的maven属性配置信息
dependencyManagement：项目的依赖管理配置
repositories：项目的仓库配置
build：包括项目的源码目录配置、输出目录配置、插件管理配置等信息
reporting：包括项目的报告输出目录配置、报告插件配置等信息
 
依赖管理(dependencyManagement)
 
在新增一个子构件，都会默认从父构件中继承依赖的一批构建，父pom.xml中配置的这些依赖的构建可能是其他项目不需要的，可能某个子项目只是想使用其中一个构件，但是上面的继承关系却把所有的依赖都给传递到子构件中了，这种显然是不合适的。
 
maven提供的dependencyManagement元素既能让子模块继承到父模块的依赖配置，又能保证子模块依赖使用的灵活性，在dependencyManagement元素下声明的依赖不会引入实际的依赖，他只是声明了这些依赖，不过它可以对dependencies中使用的依赖起到一些约束作用。
 
子模块如果想用到这些配置，可以dependencies进行引用，引用之后，依赖才会真正的起效。并且版本号可以省略。
 
使用dependencyManagement来解决继承的问题，子pom.xml中只用写groupId,artifactId就可以了，其他信息都会从父dependencyManagement中声明的依赖关系中传递过来，通常我们使用这种方式将所有依赖的构建在父pom.xml中定义好，子构件中只需要通过groupId,artifactId就可以引入依赖的构建，而不需要写version，可以很好的确保多个子项目中依赖构件的版本的一致性，对应依赖构件版本的升级也非常方便，只需要在父pom.xml中修改一下就可以了。
 
单继承问题
 
dependencyManagement的使用，但是有个问题，只有使用继承的时候，dependencyManagement中声明的依赖才可能被子pom.xml用到，如果我的项目本来就有父pom.xml了，但是我现在想使用另外一个项目dependencyManagement中声明的依赖，此时我们怎么办？这就是单继承的问题.
 
当我们想在项目中使用另外一个构件中dependencyManagement声明的依赖，而又不想继承这个项目的时候，可以在我们的项目中使用加入下面配置：
 
     <dependencyManagement>
        <dependencies>
            <dependency>
                <!-- spring cloud 依赖-->
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.SR2</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
 
插件管理(pluginManagement)
 
maven中提供了dependencyManagement来解决继承的问题，同样也提供了解决插件继承问题的pluginManagement元素，在父pom中可以在这个元素中声明插件的配置信息，但是子pom.xml中不会引入此插件的配置信息，只有在子pom.xml中使用plugins->plugin元素正在引入这些声明的插件的时候，插件才会起效，子插件中只需要写groupId、artifactId，其他信息都可以从父构件中传递过来.
 
子pom.xml中写上插件的groupId、artifactId就可以了，其他信息会从父pom.xml中插件的定义中传递过来，而子pom.xml中也可以自定义插件的这些配置
 
案例
 
父pom.xml
 
 <pluginManagement>
            <plugins>
                <!--
                verify是在测试完成之后并将构件安装到本地仓库之前执行的阶段，
                在这个阶段我们生成源码
                -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-source-plugin</artifactId>
                    <version>3.2.1</version>
                    <executions>
                        <!-- 使用插件需要执行的任务 -->
                        <execution>
                            <!-- 任务id -->
                            <id>attach-source</id>
                            <!-- 任务中插件的目标，可以指定多个 -->
                            <goals>
                                <goal>jar-no-fork</goal>
                            </goals>
                            <!-- 绑定的阶段 -->
                            <phase>verify</phase>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </pluginManagement>
 
子pom.xml
 
 <!--
            生成源码
            其他信息会从父pom.xml中插件的定义中传递过来,
            但子pom.xml中也可以自定义插件的这些配置。
            父子pom.xml中插件配置信息会合并。

            可以通过 mvn help:effective-pom 命令解析得到这个构件最终 pom.xml 的内容。
            -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <executions>
                    <execution>
                        <id>attach-source</id>
                        <goals>
                            <goal>help</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
 
 
 
父子pom.xml中插件配置信息会合并。可以通过 mvn help:effective-pom 命令解析得到这个构件最终 pom.xml的内容
 
 
聚合与继承的关系
 
聚合主要是为了方便多模块快速构建。
而继承主要是为了重用相同的配置。
 
代码编译时文件编码配置
 
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
 
 
 
编译代码的时候，涉及到资源文件和测试资源文件的拷贝，拷贝文件的时候涉及到文件的编码，这个是设置文件的编码为UTF-8格式的.
 
 
执行命令查看插件目标 resources 的详细参数：
 mvn help:describe -Dplugin=resources -Dgoal=resources -Ddetail
 输出内容如下：
 
  encoding (Default: ${project.build.sourceEncoding})
      The character encoding scheme to be applied when filtering resources.
 
 
 
encoding这个参数用来指定编码的，默认值是${project.build.sourceEncoding}，也可以通过encoding用户属性来设置。
 
 
所以设置编码的共四种：，
 
pom.xml中2种：
<encoding>UTF-8</encoding>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

mvn命令中2种：
mvn compile -Dencoding=UTF-8
mvn compile -Dproject.build.sourceEncoding=UTF-8
 
mvn test 命令
 
mvn test运行测试用例的时候，测试用例类名的写法默认是有规则的，这些规则有人知道么？从哪里可以看到这些规则？如何自定义？
 
目标详细参数
 
$ mvn help:describe -Dplugin=surefire -Dgoal=test -Ddetail
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building maven-application 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-help-plugin:3.2.0:describe (default-cli) @ maven-application ---
[INFO] Mojo: 'surefire:test'
surefire:test
  Description: Run tests using Surefire.
  Implementation: org.apache.maven.plugin.surefire.SurefirePlugin
  Language: java
  Bound to phase: test

  Available parameters:
   includes
      A list of <include> elements specifying the tests (by pattern) that
      should be included in testing. When not specified and when the test
      parameter is not specified, the default includes will be
      <includes>
       <include>**/Test*.java</include>
       <include>**/*Test.java</include>
       <include>**/*Tests.java</include>
       <include>**/*TestCase.java</include>
      </includes>

      Each include item may also contain a comma-separated sub-list of items,
      which will be treated as multiple  <include> entries.
      Since 2.19 a complex syntax is supported in one parameter (JUnit 4, JUnit
      4.7+, TestNG):
 
 
 
可以看到上面有个includes参数，可以用来配置需要运行的测试用例，可以配置通配符的方式。
 
 
上面还有一段信息：
 
Implementation: org.apache.maven.plugin.surefire.SurefirePlugin
 
上面这部分列出了这个目标的具体实现类是SurefirePlugin。
 
查看实现类：SurefirePlugin 中 的 includes 的默认值
 
 protected String[] getDefaultIncludes() {
        return new String[]{"**/Test*.java", "**/*Test.java", "**/*Tests.java", "**/*TestCase.java"};
    }
 
 
 
这部分代码就是我们测试用例默认需要满足的格式，你创建的测试用例默认情况下必须满足上面这3种格式，否则，测试用例不会被mvn test执行
 
 
参考
 
聚合、继承、单继承问题详解

 
 说到聚合与继承我们都很熟悉，maven同样也具备这样的设计原则，下面我们来看一下Maven的pom如何进行聚合与继承的配置实现。
 
 
 
 
 一、为什么要聚合？
 
 随着技术的飞速发展和各类用户对软件的要求越来越高，软件本身也变得越来越复杂，然后软件设计人员开始采用各种方式进行开发，于是就有了我们的分层架构、分模块开发，来提高代码的清晰和重用。针对于这一特性，maven也给予了相应的配置。
 
 情景分析一：
 
 我们在开发过程中，创建了2个以上的模块，每个模块都是一个独立的maven project，在开始的时候我们可以独立的编译和测试运行每个模块，但是随着项目的不断变大和复杂化，我们期望能够使用简单的操作来完成编译等工作，这时Maven给出了聚合的配置方式。
 
 所谓聚合，顾名思义，就是把多个模块或项目聚合到一起，我们可以建立一个专门负责聚合工作的Maven project ---  aggregator。
 
 建立该project的时候，我们要注意以下几点：
 
 1.该aggregator本身也做为一个Maven项目，它必须有自己的POM
 
 2.它的打包方式必须为： pom
 
 3.引入了新的元素：modules---module
 
 4.版本：聚合模块的版本和被聚合模块版本一致
 
 5.relative path：每个module的值都是一个当前POM的相对目录
 
 6.目录名称：为了方便的快速定位内容，模块所处的目录应当与其artifactId一致(Maven约定而不是硬性要求)，总之，模块所处的目录必须和<module>模块所处的目录</module>相一致。
 
 7.习惯约定：为了方便构建，通常将聚合模块放在项目目录层的最顶层，其它聚合模块作为子目录存在。这样当我们打开项目的时候，第一个看到的就是聚合模块的POM
 
 8.聚合模块减少的内容：聚合模块的内容仅仅是一个pom.xml文件，它不包含src/main/java、src/test/java等目录，因为它只是用来帮助其它模块构建的工具，本身并没有实质的内容。
 
 9.聚合模块和子模块的目录：他们可以是父子类，也可以是平行结构，当然如果使用平行结构，那么聚合模块的POM也需要做出相应的更改。
 
 二、为什么要继承？
 
 做面向对象编程的人都会觉得这是一个没意义的问题，是的，继承就是避免重复，maven的继承也是这样，它还有一个好处就是让项目更加安全
 
 情景分析二：我们在项目开发的过程中，可能多个模块独立开发，但是多个模块可能依赖相同的元素，比如说每个模块都需要Junit，使用spring的时候，其核心jar也必须都被引入，在编译的时候，maven-compiler-plugin插件也要被引入
 
 如何配置继承：
 
 
 1.说到继承肯定是一个父子结构，那么我们在aggregator中来创建一个parent project
 
 2.<packaging>: 作为父模块的POM，其打包类型也必须为POM
 
 3.结构：父模块只是为了帮助我们消除重复，所以它也不需要src/main/java、src/test/java等目录
 
 4.新的元素：<parent> ， 它是被用在子模块中的
 
 5.<parent>元素的属性：<relativePath>: 表示父模块POM的相对路径，在构建的时候，Maven会先根据relativePath检查父POM，如果找不到，再从本地仓库查找
 
 6.relativePath的默认值： ../pom.xml
 
 7.子模块省略groupId和version： 使用了继承的子模块中可以不声明groupId和version, 子模块将隐式的继承父模块的这两个元素
 
 三、可被继承的POM元素
 
 groupId:项目组ID,项目坐标的核心元素
 
 version: 项目版本, 项目坐标的核心元素
 
 description: 项目的描述信息
 
 organization: 项目的组织信息
 
 inceptionYear: 项目的创始年份
 
 url: 项目的URL地址
 
 developers: 项目开发者信息
 
 contributors: 项目的贡献者信息
 
 distributionManagement: 项目的部署配置
 
 issueManagement: 项目的缺陷跟踪系统信息
 
 ciManagement: 项目的持续集成系统信息
 
 scm: 项目的版本控制系统信息
 
 mailingLists: 项目的邮件列表信息
 
 properties: 自定义的maven属性
 
 dependencies: 项目的依赖配置
 
 dependencyManagement: 项目的依赖管理配置
 
 repositories: 项目的仓库配置
 
 build: 包括项目的源码目录配置、输出目录配置、插件配置、插件管理配置等
 
 reporting: 包括项目的报告输出目录配置、报告插件配置等
 
 四、maven的依赖管理
 
 我们知道dependencies是可以被继承的，这个时候我们就想到让我们的发生了共用的依赖元素转移到parent中，这样我们又进一步的优化了配置。可是问题也随之而来，如果有一天我创建了一个新的模块，但是这个模块不需要这些parent的依赖，这时候如何处理？
 
 是的，maven的依赖管理就是来解决这个问题的
 
 增加一个新的元素：dependencyManagement
 
 从上面的列表中我们发现dependencyManagement也是可以被继承的，这恰恰满足了我们的需要，它既能够让子模块继承到父模块的依赖配置，又能保证子模块依赖使用的灵活性
 
 dependencyManagement的特性：在dependencyManagement中配置的元素既不会给parent引入依赖，也不会给它的子模块引入依赖，仅仅是它的配置是可继承的
 
 最佳实践：
 
 这时候我们就可以在父POM中声明这些依赖：
 
 
 
<properties>
		<target.version>2.5.6</target.version>
	</properties>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>your groupId</groupId>
				<artifactId>your artifactId</artifactId>
				<version>${target.version}</version>
			</dependency>
		</dependencies>
	</dependencyManagement>

 子模块的POM继承这些配置：子模块继承这些配置的时候，仍然要声明groupId和artifactId,表示当前配置是继承于父POM的，从而直接使用父POM的版本对应的资源 
 
 
 
<dependencies>
			<dependency>
				<groupId>your groupId</groupId>
				<artifactId>your artifactId</artifactId>
			</dependency>
		</dependencies>

 
 
 这个可以有效的避免多个子模块使用依赖版本不一致的情况，有助于降低依赖冲突的几率。注：只有子模块配置了继承的元素，才会真正的有效，否则maven是不会加载父模块中声明的元素。
 
 五、Maven的插件管理
 
 再增加一个新的元素：<pluginManagement>
 
 这个元素和<dependencyManagement>相类似，它是用来进行插件管理的。
 
 在我们项目开发的过程中，也会频繁的引入插件，所以解决这些复杂配置的方法就是使用插件管理
 
 我们可以在父POM中做如下声明：
 
 
<build>
		<pluginManagement>
			<plugins>
				<plugin>
					<groupId></groupId>
					<artifactId></artifactId>
					<version></version>
					<executions>
						<execution>
							<id></id>
							<goals>
								<goal></goal>
							</goals>
							<phase></phase>
							<configuration>
								<source></source>
								<target></target>
							</configuration>
						</execution>
					</executions>
				</plugin>
			</plugins>
		</pluginManagement>
	</build>

 
 
 在子模块中，我们可以直接继承
 
 
 
<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
			</plugin>
		</plugins>
 </build>

 
 
 我们会发现，继承的细节上和<dependencyManagement>几乎一样。
 
 
 
 
 六、聚合与继承的总结
 
 当我们明白聚合与继承的细节之后，我们会发现：
 
 对于聚合模块来说，它知道有哪些被聚合的模块，而对于被聚合的模块来说，它们不知道被谁聚合了，也不知道它的存在
 
 对于继承关系的父POM来说，它不知道自己被哪些子模块继承了，对于子POM来说，它必须知道自己的父POM是谁
 
 在一些最佳实践中我们会发现：一个POM既是聚合POM，又是父POM，这么做主要是为了方便。
 
 
 
 
 
 
 
 用人之道：首用圣人，次用君子，宁用庸才，不用小人。
 
 感悟——是这样，人常说真坏人并不可怕，可怕的是假好人（小人）。