MVN4️⃣聚合 & 继承

前言

Mavan 是基于 Java 编写的，可以类比学习。

• 聚合：类比 Java 封装。
• 继承：类比 Java 继承。

Hint：本文提及的项目、模块都是 Maven 工程，可理解为一个项目由多个模块组成。

1、聚合

1.1、引入

场景：项目中某个模块（被使用者）重新构建时，其关联模块（使用者）也需要重新构建。

（构建：可简单理解为 install）

示例：A 导入 B，B 导入 C。

1. 若 C 的代码变更，则 C 需要重新构建。

2. B 导入了 C，因此 B 也需要重新构建（A 同理）。

   

分析

• 当项目中的多个模块之间有依赖关系时，关联模块之间无法感知变更。
• 当某个模块变更时，开发者需要手动、逐个、按顺序维护所有模块的构建。
• 引入聚合机制，可快速构建 Maven 工程。

1.2、聚合（❗）

1.2.1、说明

相关概念

• 聚合：引入一个聚合模块，将多个模块组织为一个整体。

  • 作用：管理项目模块，根据依赖关系进行一次性构建，以保证关联模块同步更新。
  • 构建顺序：与模块间的依赖关系有关，与配置顺序无关。
  • 类比思想：
    1. Java 封装
    2. 命令模式：宏命令（批量处理命令）

• 聚合模块：通常是一个不具有实际内容的空模块，有且仅有一个 pom.xml 文件。

  

1.2.2、实现

① 步骤

Hint：聚合模块仅需保留 pom.xml 文件。

1. 创建聚合模块：打包方式为 pom。

   <packaging>pom</packaging>
   

2. 模块组成：在聚合模块中，通过相对路径定义参与聚合的模块。

   <modules>
     <module>模块路径</module>
     <module>模块路径</module>
     <module>模块路径</module>
   </modules>
   

② 示例

A 导入 B，B 导入 C

• 聚合模块的 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>indi.jaywee</groupId>
      <artifactId>aggregation</artifactId>
      <version>1.0-RELEASE</version>
      <!-- 打包方式 -->
      <packaging>pom</packaging>
      
      <!-- 参与聚合的模块 -->
      <modules>
          <module>../projectA</module>
          <module>../projectB</module>
          <module>../projectC</module>
      </modules>
  </project>
  

• Maven 面板：

  • 聚合模块会显示 root 标识。

  • 操作聚合模块的 Lifecycle 时，参与聚合模块的所有模块都会同步操作。

    

2、继承

2.1、引入

场景：项目中的多个模块用到相同的依赖，存在重复编写的问题。

示例：模块 A, B, C 都用到依赖 p,q，即 pq 是共有依赖。

1. 每个使用到共有依赖的项目，都需要编写依赖的 GAV。
2. 若 p 版本更新，所有 pom.xml 都需要修改 p 的 version（q 同理）。

分析

• 项目中的多个模块用到相同的依赖，存在重复编写的问题。
• 若依赖更新，所有导入该依赖的坐标也需更新，维护成本高。
• 引入继承机制，可快速配置 Maven 工程依赖。

2.2、继承（❗）

2.2.1、说明

• 继承：引入一个父模块，子模块可继承使用父模块的配置（通常是依赖）。

  • 作用：管理并快速配置项目资源，简化子模块配置，减少版本冲突。

  • 类比思想：Java 继承。

    

• 父模块：通常是一个不具有实际内容的空模块，有且仅有一个 pom.xml 文件。

  （与聚合模块相同，通常可共用一个模块）

2.2.2、实现

步骤：先实现父模块，再实现子模块。

（👉 类似 Java 中先定义父类，再定义子类）

① 父模块

Hint：以下操作在父模块中进行。

1. 创建父模块：打包方式为 pom。

   <packaging>pom</packaging>
   

2. 依赖 & 依赖管理：定义项目中所有依赖的 GAV（❗）。

   • dependencies：父模块和子模块都会实际导入，通常是所有子模块共用的依赖。

   • dependencyManagement：父模块不会实际导入，子模块可配置 GA 导入。

     <!-- 共用的具体依赖 -->
     <dependencies>
         <dependency>
             <groupId></groupId>
             <artifactId></artifactId>
             <version></version>
         </dependency>
     </dependencies>
     
     <!-- 依赖管理 -->
     <dependencyManagement>
         <!-- 可选的具体依赖 -->
         <dependencies>
             <dependency>
                 <groupId></groupId>
                 <artifactId></artifactId>
                 <version></version>
             </dependency>
         </dependencies>
     </dependencyManagement>
     

② 子模块

Hint：以下操作在子模块中进行。

1. 标识父模块：通过 **GAV ** 定义其父模块。

   <!--定义当前模块的父模块-->
   <parent>
       <groupId></groupId>
       <artifactId></artifactId>
       <version></version>
       <!-- 父模块 pom.xml 相对路径（可省略） -->
       <relativePath></relativePath>
   </parent>
   

2. 依赖：

   • 获取父模块的依赖：

     1. 默认导入父模块 dependencies 的依赖。
     2. 定义 GA 导入父模块 dependencyManagement 的可选依赖。
        • 若不指定 version，默认沿用父模块中定义的版本（👍）
        • 若指定 version，覆盖父模块版本。

   • 定义特有依赖：子模块可以定义父模块中未定义的依赖。

     <dependencies>
         <!-- 父模块的可选依赖 -->
         <dependency>
             <groupId></groupId>
             <artifactId></artifactId>
         </dependency>
         <!-- 特有依赖 -->
         <dependency>
             <groupId></groupId>
             <artifactId></artifactId>
         </dependency>
     </dependencies>
     

3、对比（❗）

	聚合	继承
场景	多个模块之间具有依赖关系	多个模块使用到相同配置
作用	管理项目模块。 快速构建项目，保证关联模块同步更新	管理并快速配置项目资源。 简化子模块配置，减少版本冲突。
谁来配置？	聚合模块（管理参与聚合的模块）	父模块（管理依赖）， 子模块（标识父模块，使用依赖）
是否可感知？	聚合模块可感知有哪些参与聚合的模块	父模块无法感知被哪些子模块继承
类比思想	Java 封装，命令模式	Java 继承