Maven聚合和继承，使用IDEA构建聚合与继承工程

刺骨的言语ヽ痛彻心扉 2024-03-22 19:26 34阅读 0赞

#### 文章目录 ####

*   *  1 聚合
     *   *   *  步骤1:创建一个空的maven项目
             *  步骤2:将项目的打包方式改为pom
             *  步骤3:pom.xml添加所要管理的项目
             *  步骤4:使用聚合统一管理项目
     *  2 继承
     *   *   *  步骤1:创建一个空的Maven项目并将其打包方式设置为pom
             *  步骤2:在子项目中设置其父工程
             *  步骤3:优化子项目共有依赖导入问题
             *  步骤4:优化子项目依赖版本问题
     *  3 聚合与继承的区别
     *  4 IDEA构建聚合与继承工程
     *   *   *  步骤1:创建一个Maven项目
             *  步骤2:创建子项目

我们的项目已经从以前的单模块，变成了现在的多模块开发。项目一旦变成了多模块开发以后，就会引发一些问题，在这一节中我们主要会学习两个内容`聚合`和`继承`，用这两个知识来解决下分模块后的一些问题。

1.  聚合：在 Maven 中，聚合指将多个 Maven 项目组合成一个单一的项目。这通常发生在具有多个项目模块的项目中，每个模块都是单独的 Maven 项目。使用聚合机制，可以在父项目中将所有模块组合在一起，同时也可以独立地构建和测试每个子模块。
2.  继承：在 Maven 中，继承指的是定义一个 Maven 项目作为另一个 Maven 项目的基础。这样，可以在父项目中定义一些公共的依赖关系、插件和配置等，然后让子项目继承这些信息。这样做的好处是可以避免在各个项目中编写相同的配置，减少了冗余代码的出现，以及提高了代码的可维护性。

### 1 聚合 ###

![1630858596147][]

*  分模块开发后，需要将这四个项目都安装到本地仓库，目前我们只能通过项目Maven面板的`install`来安装，并且需要安装四个，如果我们的项目足够多，那么一个个安装起来还是比较麻烦的
 *  如果四个项目都已经安装成功，当ssm\_pojo发生变化后，我们就得将ssm\_pojo重新安装到maven仓库，但是为了确保我们对ssm\_pojo的修改不会影响到其他项目模块，我们需要对所有的模块进行重新编译，那又需要将所有的模块再来一遍

项目少的话还好，但是如果项目多的话，一个个操作项目就容易出现漏掉或重复操作的问题，所以我们就想能不能抽取一个项目，把所有的项目管理起来，以后我们要想操作这些项目，只需要操作这一个项目，其他所有的项目都走一样的流程，这个不就很省事省力。

这就用到了我们接下来要讲解的聚合，

*  所谓聚合:将多个模块组织成一个整体，同时进行项目构建的过程称为聚合
 *  聚合工程：通常是一个不具有业务功能的"空"工程（有且仅有一个pom文件）
 *  作用：使用聚合工程可以将多个工程编组，通过对聚合工程进行构建，实现对所包含的模块进行同步构建
    
     *  当工程中某个模块发生更新（变更）时，必须保障工程中与已更新模块关联的模块同步更新，此时可以使用聚合工程来解决批量模块同步构建的问题。

关于聚合具体的实现步骤为:

##### 步骤1:创建一个空的maven项目 #####

![1630859532119][]

##### 步骤2:将项目的打包方式改为pom #####

**说明**: 项目的打包方式，我们接触到的有三种，分别是

*  jar:默认情况，说明该项目为java项目
 *  war:说明该项目为web项目
 *  pom:说明该项目为聚合或继承(后面会讲)项目

##### 步骤3:pom.xml添加所要管理的项目 #####

##### 步骤4:使用聚合统一管理项目 #####

![1630859797123][]

测试发现，当`maven_01_parent`的`compile`被点击后，所有被其管理的项目都会被执行编译操作。这就是聚合工程的作用。

\*\*说明：\*\*聚合工程管理的项目在进行运行的时候，会按照项目与项目之间的依赖关系来自动决定执行的顺序, 和配置的顺序无关。

聚合的知识我们就讲解完了，最后总结一句话就是，**聚合工程主要是用来管理项目**。

### 2 继承 ###

我们已经完成了使用聚合工程去管理项目，聚合工程进行某一个构建操作，其他被其管理的项目也会执行相同的构建操作。那么接下来，我们再来分析下，多模块开发存在的另外一个问题，`重复配置`的问题，我们先来看张图:

![1630860344968][]

*  `spring-webmvc`、`spring-jdbc`在三个项目模块中都有出现，这样就出现了重复的内容
 *  `spring-test`只在ssm\_crm和ssm\_goods中出现，而在ssm\_order中没有，这里是部分重复的内容
 *  我们使用的spring版本目前是`5.2.10.RELEASE`,假如后期要想升级spring版本，所有跟Spring相关jar包都得被修改，涉及到的项目越多，维护成本越高

面对上面的这些问题，我们就得用到接下来要学习的继承

*  所谓继承:描述的是两个工程间的关系，与java中的继承相似，子工程可以继承父工程中的配置信息，常见于依赖关系的继承。
 *  作用：
    
     *  简化配置
     *  减少版本冲突

接下来，我们到程序中去看看继承该如何实现?

##### 步骤1:创建一个空的Maven项目并将其打包方式设置为pom #####

因为这一步和前面maven创建聚合工程的方式是一摸一样，所以我们可以单独创建一个新的工程，也可以直接和聚合公用一个工程。实际开发中，聚合和继承一般也都放在同一个项目中，但是这两个的功能是不一样的。

##### 步骤2:在子项目中设置其父工程 #####

分别在`maven_02_ssm`,`maven_03_pojo`,`maven_04_dao`的pom.xml中添加其父项目为`maven_01_parent`

<parent>
        <groupId>com.itheima</groupId>
        <artifactId>maven_01_parent</artifactId>
        <version>1.0-RELEASE</version>
        
        <relativePath>../maven_01_parent/pom.xml</relativePath>
    </parent>

##### 步骤3:优化子项目共有依赖导入问题 #####

1.  将子项目共同使用的jar包都抽取出来，维护在父项目的pom.xml中

<?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.itheima</groupId>
        <artifactId>maven_01_parent</artifactId>
        <version>1.0-RELEASE</version>
        <packaging>pom</packaging>
        
        
        <modules>
            <module>../maven_02_ssm</module>
            <module>../maven_03_pojo</module>
            <module>../maven_04_dao</module>
        </modules>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>5.2.10.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>5.2.10.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>5.2.10.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>5.2.10.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.5.6</version>
            </dependency>
    
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>1.3.0</version>
            </dependency>
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
    
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.16</version>
            </dependency>
    
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>3.1.0</version>
                <scope>provided</scope>
            </dependency>
    
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>2.9.0</version>
            </dependency>
        </dependencies>
    </project>

1.  删除子项目中已经被抽取到父项目的pom.xml中的jar包，如在`maven_02_ssm`的pom.xml中将已经出现在父项目的jar包删除掉

<?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.itheima</groupId>
      <artifactId>maven_02_ssm</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
    
      
      <parent>
        <groupId>com.itheima</groupId>
        <artifactId>maven_01_parent</artifactId>
        <version>1.0-RELEASE</version>
        <relativePath>../maven_01_parent/pom.xml</relativePath>
      </parent>
      <dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
          <scope>test</scope>
        </dependency>
    
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.11</version>
          <scope>test</scope>
        </dependency>
    
        <dependency>
          <groupId>com.itheima</groupId>
          <artifactId>maven_04_dao</artifactId>
          <version>1.0-SNAPSHOT</version>
          
          <exclusions>
            <exclusion>
              <groupId>log4j</groupId>
              <artifactId>log4j</artifactId>
            </exclusion>
            <exclusion>
              <groupId>org.mybatis</groupId>
              <artifactId>mybatis</artifactId>
            </exclusion>
          </exclusions>
        </dependency>
    
      </dependencies>
    
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.1</version>
            <configuration>
              <port>80</port>
              <path>/</path>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </project>

删除完后，你会发现父项目中有依赖对应的jar包，子项目虽然已经将重复的依赖删除掉了，但是刷新的时候，子项目中所需要的jar包依然存在。

当项目的`<parent>`标签被移除掉，会发现多出来的jar包依赖也会随之消失。

1.  将`maven_04_dao`项目的pom.xml中的所有依赖删除，然后添加上`maven_01_parent`的父项目坐标

刷新并查看Maven的面板，会发现maven\_04\_dao同样引入了父项目中的所有依赖。

![1630862406709][]

这样我们就可以解决刚才提到的第一个问题，将子项目中的公共jar包抽取到父工程中进行统一添加依赖，这样做的可以简化配置，并且当父工程中所依赖的jar包版本发生变化，所有子项目中对应的jar包版本也会跟着更新。

![1630943390187][]

##### 步骤4:优化子项目依赖版本问题 #####

如果把所有用到的jar包都管理在父项目的pom.xml，看上去更简单些，但是这样就会导致有很多项目引入了过多自己不需要的jar包。如上面看到的这张图:

![1e434d9e762134207ac435b88eecd12a.png][]

如果把所有的依赖都放在了父工程中进行统一维护，就会导致ssm\_order项目中多引入了`spring-test`的jar包，如果这样的jar包过多的话，对于ssm\_order来说也是一种"负担"。

那针对于这种部分项目有的jar包，我们该如何管理优化呢?

1.  在父工程mavne\_01\_parent的pom.xml来定义依赖管理

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

1.  将maven\_02\_ssm的pom.xml中的junit依赖删除掉，刷新Maven

![1630944335419][]

刷新完会发现，在maven\_02\_ssm项目中的junit依赖并没有出现，所以我们得到一个结论:

`<dependencyManagement>`标签不真正引入jar包，而是配置可供子项目选择的jar包依赖

子项目要想使用它所提供的这些jar包，需要自己添加依赖，并且不需要指定`<version>`

1.  在maven\_02\_ssm的pom.xml添加junit的依赖

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

**注意：这里就不需要添加版本了，这样做的好处就是当父工程dependencyManagement标签中的版本发生变化后，子项目中的依赖版本也会跟着发生变化**

1.  在maven\_04\_dao的pom.xml添加junit的依赖

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

这个时候，maven\_02\_ssm和maven\_04\_dao这两个项目中的junit版本就会跟随着父项目中的标签dependencyManagement中junit的版本发生变化而变化。不需要junit的项目就不需要添加对应的依赖即可。

至此继承就已经学习完了，总结来说，继承可以帮助做两件事

*  将所有项目公共的jar包依赖提取到父工程的pom.xml中，子项目就可以不用重复编写，简化开发
 *  将所有项目的jar包配置到父工程的dependencyManagement标签下，实现版本管理，方便维护
    
     *  dependencyManagement标签不真正引入jar包，只是管理jar包的版本
     *  子项目在引入的时候，只需要指定groupId和artifactId，不需要加version
     *  当dependencyManagement标签中jar包版本发生变化，所有子项目中有用到该jar包的地方对应的版本会自动随之更新

最后总结一句话就是，**父工程主要是用来快速配置依赖jar包和管理项目中所使用的资源**。

**小结**

继承的实现步骤:

*  创建Maven模块，设置打包类型为pom
    
        <packaging>pom</packaging>
 *  在父工程的pom文件中配置依赖关系(子工程将沿用父工程中的依赖关系),一般只抽取子项目中公有的jar包
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>5.2.10.RELEASE</version>
            </dependency>
            ...
        </dependencies>
 *  在父工程中配置子工程中可选的依赖关系
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>com.alibaba</groupId>
                    <artifactId>druid</artifactId>
                    <version>1.1.16</version>
                </dependency>
            </dependencies>
            ...
        </dependencyManagement>
 *  在子工程中配置当前工程所继承的父工程
    
        
        <parent>
            <groupId>com.itheima</groupId>
            <artifactId>maven_01_parent</artifactId>
            <version>1.0-RELEASE</version>
            
            <relativePath>../maven_01_parent/pom.xml</relativePath>
        </parent>
 *  在子工程中配置使用父工程中可选依赖的坐标
    
        <dependencies>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
            </dependency>
        </dependencies>
    
    注意事项:
    
    1.子工程中使用父工程中的可选依赖时，仅需要提供群组id和项目id，无需提供版本，版本由父工程统一提供，避免版本冲突
    
    2.子工程中还可以定义父工程中没有定义的依赖关系,只不过不能被父工程进行版本统一管理。

### 3 聚合与继承的区别 ###

两种之间的作用:

*  聚合用于快速构建项目，对项目进行管理
 *  继承用于快速配置和管理子项目中所使用jar包的版本

聚合和继承的相同点:

*  聚合与继承的pom.xml文件打包方式均为pom，可以将两种关系制作到同一个pom文件中
 *  聚合与继承均属于设计型模块，并无实际的模块内容

聚合和继承的不同点:

*  聚合是在当前模块中配置关系，聚合可以感知到参与聚合的模块有哪些
 *  继承是在子模块中配置关系，父模块无法感知哪些子模块继承了自己

相信到这里，大家已经能区分开什么是聚合和继承，但是有一个稍微麻烦的地方就是聚合和继承的工程构建，需要在聚合项目中手动添加`modules`标签，需要在所有的子项目中添加`parent`标签，万一写错了咋办?

### 4 IDEA构建聚合与继承工程 ###

其实对于聚合和继承工程的创建，IDEA已经能帮助我们快速构建，具体的实现步骤为:

##### 步骤1:创建一个Maven项目 #####

创建一个空的Maven项目，可以将项目中的`src`目录删除掉，这个项目作为聚合工程和父工程。

![1630946592924][]

##### 步骤2:创建子项目 #####

该项目可以被聚合工程管理，同时会继承父工程。

![1630947082716][]

创建成功后，maven\_parent即是聚合工程又是父工程，maven\_web中也有parent标签，继承的就是maven\_parent,对于难以配置的内容都自动生成。

按照上面这种方式，大家就可以根据自己的需要来构建分模块项目。

[1630858596147]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/eb75fcd3417e453ba210a799d8d6b91a.png
[1630859532119]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/30aa6a659df84ef798d27f2e2f9cb9e6.png
[1630859797123]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/a6c78e9286684f48bbc6b4cb24f16de1.png
[1630860344968]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/8425b9c3461d4f628ac7e53ecab11121.png
[1630862406709]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/b12e5526345c40e99b21e75e29b7dfc6.png
[1630943390187]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/575b047255854e12a62d77387d6c2097.png
[1e434d9e762134207ac435b88eecd12a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/8ffbccdf4655438394f16d31b689a579.png
[1630944335419]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/71f8fbc669954d0788a400ae71098980.png
[1630946592924]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/b2c57d2d8b244fc2a796c13016430a8f.png
[1630947082716]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/8532d09e297e4f7cbe9a5a2c79539f2f.png