Maven多模块项目管理：基于SpringBoot单体项目的继承与聚合实战指南

本文概览：本文系统讲解Maven在SpringBoot单体项目中的多模块管理机制，深入剖析Maven继承与聚合的核心原理、SpringBoot起步依赖的版本控制策略，并通过完整实战演示多模块项目的构建全过程

第一部分：Maven继承与聚合机制基础

1.1 Maven继承机制详解

1.1.1 继承的核心概念

Maven继承类似于面向对象编程中的继承概念，子模块可以继承父模块的配置信息，实现配置复用和统一管理。这种机制特别适用于多模块项目中需要统一管理依赖版本、插件配置等场景。

1.1.2 可继承的POM元素

<!-- 基础信息 -->
<parent>
<groupId>
<artifactId>
<version>
<relativePath>

<!-- 配置信息 -->
<properties>                <!-- 属性配置 -->
<dependencyManagement>      <!-- 依赖管理（版本锁定） -->
<dependencies>              <!-- 依赖配置 -->
<build>                     <!-- 构建配置 -->
<pluginManagement>          <!-- 插件管理 -->
<reporting>                 <!-- 报告配置 -->

基础信息：

<groupId>：你的组织/公司域名倒写，比如 com.baidu、org.springframework
<artifactId>：当前项目/模块的名字，比如 user-service
<version>：版本，1.0.0、2.1.3.RELEASE(发行版)
<parent>：在标签包裹处填写对应的模块名即可实现继承
<relativePath>：相对路径，本地找父项目 pom.xml 的路径，不写默认从仓库找

配置信息：

<properties> 属性配置

<properties>
    <java.version>17</java.version>
    <spring.version>6.1.0</spring.version>
</properties>

<properties> 标签包裹起来的内容是全局变量。java.version 和 spring.version 则为变量名。

可以自定义一个变量名，然后加上 <> 包裹起来的值即为变量值，在后续想要引用这个变量的地方使用 ${java.version} 这种形式将变量名包裹，他就会自动替换为对于这个全局变量的值。

因此可以我们只需要在 <properties> 标签中定义大量的全局变量，在下面引用的依赖中的 <version> 标签中使用全局变量 ${....} 即可实现直观且便捷的版本控制，下面是 pom 文件演示：

<!-- 配置全局变量 -->
<properties>
     <mybatis.spring>2.2.0</mybatis.spring>
     <lombok>1.18.30</lombok>
     <mybatis.plus>3.5.1</mybatis.plus>
</properties>

<!-- 引用依赖 -->
<dependencies>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>${mybatis.plus}</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>${mybatis.spring}</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>${lombok}</version>
    </dependency>
</dependencies>

以后如果想修改版本，只需要将上面的 <properties> 中包裹的全局变量的值修改即可，不需要去依赖管理中一个个找了，直观且便捷。

<dependencyManagement> 依赖管理（版本锁定）

<!-- 依赖管理 -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>6.1.0</version>
        </dependency>
    </dependencies>
</dependencyManagement>

对于 <dependencyManagement> 管理的依赖会锁定依赖版本，但是不引入依赖，子模块继承之后如果没有在 <dependencies> 中引入：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
</dependency>

则该模块中无法继承该依赖。但是子模块继承后，写依赖不用写 version，父模块通过 <dependencies> 中写入的依赖锁定了版本，只需要写对应的 <groupId> 和 <artifactId> 即可。

<dependencies> 依赖配置

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
    </dependency>
</dependencies>

真正引入 jar 包，项目运行需要什么库，就写在这里。如果父项目使用 <dependencyManagement> 锁了版本，这里可以省略 <version>。

<build> 构建配置

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

控制项目怎么编译、打包、运行：

配置编译 JDK 版本
配置打包方式（jar/war/pom）1.3有详解
配置资源文件（xml、properties 等）
配置各种构建插件

<pluginManagement> 插件管理

<pluginManagement>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.11.0</version>
        </plugin>
    </plugins>
</pluginManagement>

与 dependencyManagement 逻辑一样：只锁定插件版本，不实际启用插件，子模块可以直接用，不用写版本，统一多模块插件规范。

1.2 Maven聚合机制详解

1.2.1 聚合的核心概念

聚合（Aggregation）是将多个相关的Maven项目组合在一起，通过一个顶层POM来统一构建所有模块。聚合关注的是构建过程的统一管理，而不是配置的继承。

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>aggregator-project</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    
    <!-- 聚合配置：声明要包含的子模块 -->
    <modules>
        <module>common</module>
        <module>pojo</module>
        <module>service</module>
        <module>web</module>
    </modules>
</project>

<module> 标签里面写的就是对应每个模块名，写入则代表聚合到父模块，父模块可以进行统一控制。

1.3 为什么父POM的packaging必须设置为pom？

1.3.1 Maven的packaging类型

Maven支持多种打包类型，每种类型对应不同的构建行为：

Packaging类型	说明	输出产物
pom	项目对象模型	pom.xml文件
jar	Java归档文件	jar包
war	Web应用归档	war包
ear	企业应用归档	ear包
rar	资源适配器归档	rar包

1.3.2 父POM为什么必须是pom类型？

核心原因：

不生成实际代码产物：父POM只包含配置信息，不包含实际的Java代码，不需要打包成jar/war
Maven构建生命周期：pom类型的项目使用简化的构建生命周期，不会执行编译、测试等阶段
聚合功能要求：只有packaging为pom的项目才能使用 <modules> 标签进行聚合

1.3.3 继承与聚合的关系

继承关注的是配置复用，聚合关注的是构建管理：

<!-- 父POM：同时承担继承和聚合角色 -->
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>parent</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging>  <!-- 必须是pom -->
    
    <!-- 聚合配置 -->
    <modules>
        <module>module-a</module>
        <module>module-b</module>
    </modules>
    
    <!-- 继承配置 -->
    <properties>
        <java.version>1.8</java.version>
    </properties>
</project>

第二部分：SpringBoot起步依赖的版本控制策略

2.1 SpringBoot Parent方式

SpringBoot提供了一个父POM spring-boot-starter-parent，它包含了大量默认配置：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.5</version>
</parent>

在这个模块里面又继承了 spring-boot-dependencies 模块。它内置依赖中不仅使用了前文所说的 <properties> 实现全局变量配置，还使用了 <dependencyManagement> 实现版本控制，对应每一个不同的 SpringBoot 版本，这些依赖的版本也不一样，这样带来的好处就是我们无需关注这些固定配置的依赖的版本了，我们只需要使用对应的 SpringBoot 版本，他会自动更新依赖并且无兼容问题。

但是它只是实现了版本控制，并没有直接引用依赖，所以子模块如果继承了该模块是不能直接使用这些依赖的。

这就是三个常用的起步依赖：spring-boot-starter、spring-boot-starter-test、spring-boot-starter-web，并且如果你继承了 spring-boot-stater-parent，那这三个起步依赖都无需指定 version，因为他已经被 spring-boot-stater-parent 管理版本了。

2.2 SpringBoot starter方式

spring-boot-starter 内置的是 <dependencies>，而不是 <dependencyManagement>，也就是说是直接引入了依赖。

是什么：Spring Boot 最核心、最基础的起步依赖，是所有 Starter 的"根"。

核心作用：提供 Spring Boot 运行的基础核心能力，是所有 Spring Boot 项目的基石。

主要引入的依赖：

依赖	作用
spring-core / spring-context	Spring 核心容器、IoC、AOP 基础
spring-boot / spring-boot-autoconfigure	Spring Boot 自动配置、启动类核心
spring-boot-starter-logging	日志框架（默认 Logback + SLF4J）
jakarta.annotation-api	注解支持（如 @Resource）
jackson	JSON 序列化/反序列化
commons-logging / log4j-to-slf4j	日志桥接，统一日志体系

适用场景：

所有 Spring Boot 项目默认都会间接引入（比如 spring-boot-starter-web 会依赖它）
纯后台工具、非 Web 项目可以单独引入它作为基础依赖
提供自动配置、日志、核心容器等基础能力

2.3 SpringBoot starter test方式

内部也是使用 <dependencies> 直接引入依赖的，并不是做版本控制的。

是什么：Spring Boot 官方测试工具集，专门用来做单元测试、集成测试。

核心作用：一站式引入所有主流测试框架，不用单独配置，开箱即用。

主要引入的依赖：

依赖	作用
JUnit 5（Jupiter）	单元测试框架（Spring Boot 2.2+ 默认 JUnit 5）
Mockito	Mock 测试框架，模拟依赖对象
AssertJ	流式断言，让测试代码更简洁
Hamcrest	匹配器库，增强断言能力
Spring Test	Spring 集成测试支持（@SpringBootTest）
json-path	JSON 路径断言，测试接口返回值

关键特性：

<scope>test</scope>：只在测试阶段生效，不会打包到生产环境
支持单元测试、集成测试、Mock 测试、接口测试
配合 @SpringBootTest 可以启动整个 Spring 容器做全链路测试

2.4 SpringBoot starter web方式

可见这里也是直接引入的依赖，且这个依赖还是依赖于 spring-boot-starter 的所以版本要一致，而这个版本也在 spring-boot-starter-parent 中实现控制了。

是什么：Spring Boot Web 开发一站式解决方案，是做 Web 项目的核心依赖。

核心作用：一键引入 Web 开发所需的所有核心组件，快速搭建 Spring MVC 项目。

主要引入的依赖：

依赖	作用
spring-boot-starter	核心基础依赖（间接引入上面的所有基础能力）
spring-web / spring-webmvc	Spring MVC 核心，处理 HTTP 请求、路由、控制器
spring-boot-starter-tomcat	内嵌 Tomcat 服务器（默认），让项目可以直接运行
jackson-databind	JSON 序列化/反序列化（处理 @ResponseBody）
hibernate-validator	数据校验（@Valid 注解）
tomcat-embed-el	Tomcat 表达式语言支持

关键特性：

内嵌 Tomcat，直接 java -jar 运行，不需要外部 Tomcat
自动配置 Spring MVC、DispatcherServlet、视图解析器等
支持 RESTful 接口开发、前后端分离项目
默认 <scope>compile</scope>：编译、测试、运行全阶段生效，会打包到生产环境

2.5 三个起步依赖与spring-boot-starter-parent的关系

spring-boot-starter-parent 是「大管家」：管所有 Starter 的版本、统一项目配置，让你不用操心兼容
spring-boot-starter 是「地基」：提供 Spring Boot 运行的核心基础能力，所有 Starter 都依赖它
spring-boot-starter-web 是「Web 工具包」：基于地基，提供 Web 开发的全套组件
spring-boot-starter-test 是「测试工具包」：基于地基，提供测试的全套组件

四者是「管家管地基，地基撑工具包」的层级关系，共同构成 Spring Boot「开箱即用」的核心能力。

维度	spring-boot-starter-parent	spring-boot-starter	spring-boot-starter-test	spring-boot-starter-web
类型	Maven 父工程（pom）	Maven 依赖（jar）	Maven 依赖（jar）	Maven 依赖（jar）
核心定位	全局配置/版本管家	核心基础功能	测试专用功能	Web 开发功能
是否包含代码	无业务代码，仅配置	包含核心业务代码	包含测试框架代码	包含 Web 框架代码
使用方式	`<parent>` 继承	`<dependency>` 引入（通常间接依赖）	`<dependency>` 引入（手动加）	`<dependency>` 引入（手动加）
版本管理	管理所有 Starter 的版本	被 parent 管理版本	被 parent 管理版本	被 parent 管理版本
依赖关系	无依赖，是顶层父工程	被 web/test 依赖	独立，依赖核心 starter	依赖核心 starter
生效范围	影响整个项目的 Maven 配置	全阶段生效（编译/测试/运行）	仅测试阶段生效（`<scope>test</scope>`）	全阶段生效（`<scope>compile`）

2.6 版本统一管理的好处

避免版本冲突：所有SpringBoot相关依赖使用统一版本
简化配置：子模块无需关心具体版本号
易于升级：只需修改父POM中的版本号即可升级所有模块

第三部分：实战演示 - 完整多模块项目构建

3.1 项目结构设计

3.1.1 典型的多模块项目结构

springboot-multi-module/
├── pom.xml                    # 父POM（聚合+继承）
├── common/                    # 公共工具模块
│   ├── pom.xml
│   └── src/main/java/
│       └── com/example/common/
│           ├── utils/         # 工具类
│           ├── constant/      # 常量定义
│           └── exception/     # 自定义异常
├── pojo/                      # 数据对象模块
│   ├── pom.xml
│   └── src/main/java/
│       └── com/example/pojo/
│           ├── entity/        # 实体类
│           └── dto/           # 数据传输对象
├── dao/                       # 数据访问层
│   ├── pom.xml
│   └── src/main/java/
│       └── com/example/dao/
│           ├── mapper/        # MyBatis Mapper
│           └── config/        # 数据库配置
├── service/                   # 业务逻辑层
│   ├── pom.xml
│   └── src/main/java/
│       └── com/example/service/
│           ├── impl/          # 服务实现
│           └── config/        # 业务配置
└── web/                       # Web层（启动模块）
    ├── pom.xml
    └── src/main/java/
        └── com/example/web/
            ├── controller/    # Controller层
            ├── config/        # Web配置
            └── Application.java  # SpringBoot启动类

3.1.2 模块依赖关系

1
2
3

web → service → dao → pojo
          ↓        ↓
        common   common

3.2 父POM配置详解

3.2.1 完整的父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.example</groupId>
    <artifactId>springboot-multi-module</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging>  <!-- ⚠️ 必须是pom -->
    <name>SpringBoot Multi-Module Project</name>
    <description>基于SpringBoot的多模块项目示例</description>
    
    <!-- 模块聚合 -->
    <modules>
        <module>common</module>
        <module>pojo</module>
        <module>dao</module>
        <module>service</module>
        <module>web</module>
    </modules>
    
    <!-- 属性配置：统一版本管理 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        
        <!-- SpringBoot版本 -->
        <spring-boot.version>2.7.5</spring-boot.version>
        
        <!-- 第三方依赖版本 -->
        <mybatis.version>2.2.2</mybatis.version>
        <mysql.version>8.0.31</mysql.version>
        <lombok.version>1.18.24</lombok.version>
        <druid.version>1.2.15</druid.version>
    </properties>
    
    <!-- SpringBoot BOM导入（版本控制核心） -->
    <dependencyManagement>
        <dependencies>
            <!-- SpringBoot依赖管理 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            
            <!-- MyBatis -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            
            <!-- MySQL驱动 -->
            <dependency>
                <groupId>com.mysql</groupId>
                <artifactId>mysql-connector-j</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            
            <!-- Druid连接池 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>${druid.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    
    <!-- 公共依赖：所有子模块都会继承 -->
    <dependencies>
        <!-- Lombok：简化代码 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <scope>provided</scope>
        </dependency>
        
        <!-- SpringBoot测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <!-- 构建配置 -->
    <build>
        <pluginManagement>
            <plugins>
                <!-- SpringBoot Maven插件 -->
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>${spring-boot.version}</version>
                    <executions>
                        <execution>
                            <goals>
                                <goal>repackage</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </pluginManagement>
        
        <plugins>
            <!-- 编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.10.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

3.3 各子模块POM配置

3.3.1 Common模块（公共工具）

<?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>
    
    <!-- 继承父POM -->
    <parent>
        <groupId>com.example</groupId>
        <artifactId>springboot-multi-module</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    
    <artifactId>common</artifactId>
    <packaging>jar</packaging>
    <name>Common Module</name>
    <description>公共工具类模块</description>
    
    <dependencies>
        <!-- 依赖SpringBoot工具包 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        
        <!-- Apache Commons工具包 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>31.1-jre</version>
        </dependency>
    </dependencies>
</project>

3.3.2 POJO模块（数据对象）

<?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>
    
    <parent>
        <groupId>com.example</groupId>
        <artifactId>springboot-multi-module</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    
    <artifactId>pojo</artifactId>
    <packaging>jar</packaging>
    <name>POJO Module</name>
    <description>数据对象模块</description>
    
    <dependencies>
        <!-- 依赖common模块 -->
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>common</artifactId>
            <version>${project.version}</version>
        </dependency>
        
        <!-- Validation验证 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        
        <!-- Jackson序列化 -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
    </dependencies>
</project>

3.3.3 DAO模块（数据访问层）

<?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>
    
    <parent>
        <groupId>com.example</groupId>
        <artifactId>springboot-multi-module</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    
    <artifactId>dao</artifactId>
    <packaging>jar</packaging>
    <name>DAO Module</name>
    <description>数据访问层模块</description>
    
    <dependencies>
        <!-- 依赖pojo和common模块 -->
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>pojo</artifactId>
            <version>${project.version}</version>
        </dependency>
        
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>common</artifactId>
            <version>${project.version}</version>
        </dependency>
        
        <!-- MyBatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        
        <!-- MySQL驱动 -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
        </dependency>
        
        <!-- Druid连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
        </dependency>
    </dependencies>
</project>

3.3.4 Service模块（业务逻辑层）

<?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>
    
    <parent>
        <groupId>com.example</groupId>
        <artifactId>springboot-multi-module</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    
    <artifactId>service</artifactId>
    <packaging>jar</packaging>
    <name>Service Module</name>
    <description>业务逻辑层模块</description>
    
    <dependencies>
        <!-- 依赖dao、pojo、common模块 -->
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>dao</artifactId>
            <version>${project.version}</version>
        </dependency>
        
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>pojo</artifactId>
            <version>${project.version}</version>
        </dependency>
        
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>common</artifactId>
            <version>${project.version}</version>
        </dependency>
        
        <!-- SpringBoot Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- SpringBoot AOP -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
    </dependencies>
</project>

3.3.5 Web模块（启动模块）

<?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>
    
    <parent>
        <groupId>com.example</groupId>
        <artifactId>springboot-multi-module</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    
    <artifactId>web</artifactId>
    <packaging>jar</packaging>
    <name>Web Module</name>
    <description>Web层启动模块</description>
    
    <dependencies>
        <!-- 依赖service模块（会自动传递依赖dao、pojo、common） -->
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>service</artifactId>
            <version>${project.version}</version>
        </dependency>
        
        <!-- SpringBoot Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- SpringBoot Actuator（监控） -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>
    
    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <!-- SpringBoot Maven插件：打包可执行jar -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>com.example.web.Application</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>