Spring Boot 多模块怎么统一管理

在 Spring Boot 中，多模块项目是一种常见的架构模式，尤其适用于构建大型、复杂的应用程序。将应用程序拆分成多个模块可以提高代码的可维护性、可重用性和团队协作效率。然而，多模块项目也带来了一些管理上的挑战，例如依赖版本管理、构建配置管理、模块间的依赖关系管理等。为了解决这些问题，统一管理变得至关重要。

下面我将详细解释 Spring Boot 多模块项目如何进行统一管理，并提供一些最佳实践和技巧。

一、为什么需要统一管理多模块 Spring Boot 项目？

在没有统一管理的情况下，多模块项目可能会遇到以下问题：

依赖版本冲突：
- 每个模块独立管理依赖，容易引入不同版本的相同依赖库。
- 版本不兼容可能导致运行时冲突、编译错误或不可预测的行为。
- 排查和解决依赖冲突会变得非常耗时和复杂。
构建配置不一致：
- 不同模块可能使用不同的 Maven 或 Gradle 插件版本和配置。
- 构建过程不一致，可能导致不同模块的构建结果不一致，增加集成风险。
- 维护和更新构建配置变得分散且容易出错。
重复配置：
- 每个模块都需要重复配置一些通用的信息，例如 Spring Boot 版本、公共依赖、插件配置等。
- 代码冗余，降低维护效率，修改时需要同步多个模块。
模块依赖关系混乱：
- 模块间的依赖关系如果没有清晰地定义和管理，容易形成复杂的依赖环路或不必要的依赖关系。
- 影响模块的编译顺序和构建效率，增加模块间的耦合度。
升级和维护困难：
- 当需要升级 Spring Boot 版本或公共依赖库时，需要逐个模块进行修改和测试，工作量大且容易遗漏。
- 维护成本高，升级风险大。

二、统一管理的核心思想

Spring Boot 多模块项目统一管理的核心思想是： 集中化配置，约定优于配置，减少重复性工作，提高一致性和可维护性。

主要通过以下几个方面来实现：

使用父模块 (Parent POM/Build Script)：
- 创建一个父模块作为整个项目的根模块。
- 父模块的 pom.xml (Maven) 或 build.gradle (Gradle) 文件用于集中管理公共的配置和依赖。
- 其他模块作为子模块，继承父模块的配置。
依赖管理 (Dependency Management)：
- 在父模块的 dependencyManagement 部分声明所有公共依赖的版本信息。
- 子模块只需要声明依赖的 groupId 和 artifactId，版本信息从父模块继承。
- 确保整个项目使用统一的依赖版本，避免版本冲突。
插件管理 (Plugin Management)：
- 在父模块的 pluginManagement 部分声明公共插件的版本和配置信息。
- 子模块只需要声明需要使用的插件，版本和公共配置从父模块继承。
- 保证整个项目使用一致的插件版本和配置，提高构建过程的一致性。
属性管理 (Property Management)：
- 在父模块的 properties 部分定义一些公共属性，例如 Spring Boot 版本、Java 版本、公共依赖版本等。
- 子模块可以直接引用父模块定义的属性，方便统一修改和管理。
构建 Profile 管理 (Build Profile)：
- 在父模块中定义构建 Profile，例如 dev、test、prod 等，用于管理不同环境下的构建配置。
- 子模块可以继承父模块的 Profile 配置，或者根据需要自定义 Profile。
模块依赖关系管理 (Module Dependency)：
- 在模块的 pom.xml 或 build.gradle 中明确声明模块之间的依赖关系。
- Maven 或 Gradle 会根据依赖关系自动管理模块的编译顺序和构建顺序。

三、Maven 和 Gradle 的统一管理实践

无论是使用 Maven 还是 Gradle 构建工具，都可以实现 Spring Boot 多模块项目的统一管理。下面分别介绍 Maven 和 Gradle 的实践方式：

1. Maven 多模块统一管理

父模块 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.example</groupId>
    <artifactId>parent-module</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging>  <!-- 父模块packaging必须为pom -->

    <modules>
        <module>module-a</module>
        <module>module-b</module>
        <module>module-c</module>
        </modules>

    <properties>
        <java.version>1.8</java.version>
        <spring-boot.version>2.7.0</spring-boot.version>
        <commons-lang3.version>3.12.0</commons-lang3.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>${commons-lang3.version}</version>
            </dependency>
            <!-- 其他公共依赖 -->
        </dependencies>
    </dependencyManagement>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>${spring-boot.version}</version>
                </plugin>
                <!-- 其他公共插件配置 -->
            </plugins>
        </pluginManagement>
    </build>

</project>

子模块 pom.xml 示例 (例如 module-a):

<?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>parent-module</artifactId>
        <version>1.0.0-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>  <!-- 指向父模块的pom.xml -->
    </parent>

    <artifactId>module-a</artifactId>
    <version>1.0.0-SNAPSHOT</version>  <!-- 版本号可以省略，默认继承父模块 -->
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>  <!-- 版本号从父模块继承 -->
        </dependency>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>module-b</artifactId> <!-- 模块间依赖 -->
            <version>1.0.0-SNAPSHOT</version> <!-- 版本号从父模块继承，但显式声明更清晰 -->
        </dependency>
    </dependencies>

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

</project>

Maven 统一管理关键点:

父模块 packaging 为 pom: 声明父模块为 POM 类型，用于管理其他模块。
<modules> 标签: 在父模块中列出所有子模块。
<parent> 标签: 子模块 pom.xml 中使用 <parent> 标签指向父模块，建立继承关系。
<dependencyManagement>: 父模块中使用 dependencyManagement 集中管理依赖版本。
<pluginManagement>: 父模块中使用 pluginManagement 集中管理插件版本和配置。
属性 properties: 父模块中定义公共属性，子模块可以直接引用。
relativePath: <parent> 标签中的 relativePath 指向父模块 pom.xml 的相对路径。
模块间依赖: 使用 <dependency> 标签声明模块之间的依赖关系，groupId 和 version 保持一致。

2. Gradle 多模块统一管理

settings.gradle.kts (根目录): 声明项目包含的模块

rootProject.name = "parent-module"
include("module-a")
include("module-b")
include("module-c")

根目录 build.gradle.kts (父模块 build script):

plugins {
    java
    // 使用 Spring Boot 插件，但不应用到父模块 (apply false)
    id("org.springframework.boot") version "2.7.0" apply false
    id("io.spring.dependency-management") version "1.0.11.RELEASE" apply false
}

allprojects {
    group = "com.example"
    version = "1.0.0-SNAPSHOT"
}

subprojects {
    apply(plugin = "java")
    apply(plugin = "io.spring.dependency-management")

    repositories {
        mavenCentral()
    }

    dependencies {
        implementation("org.apache.commons:commons-lang3:3.12.0")
        // 其他公共依赖
    }

    dependencyManagement {
        imports {
            mavenBom(org.springframework.boot.gradle.plugin.SpringBootPlugin.BOM_COORDINATES)
        }
    }
}

子模块 module-a/build.gradle.kts 示例:

plugins {
    id("org.springframework.boot")
    id("io.spring.dependency-management")
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation(project(":module-b")) // 模块间依赖
}

Gradle 统一管理关键点:

settings.gradle.kts: 使用 include() 函数声明子模块。
根目录 build.gradle.kts: 作为父模块的构建脚本，使用 subprojects {} 配置所有子模块的通用配置。
dependencyManagement: 在父模块中使用 dependencyManagement 导入 Spring Boot 的 BOM (Bill of Materials) 和管理公共依赖版本。
allprojects {}: 配置所有模块通用的属性 (例如 group, version)。
模块间依赖: 使用 implementation(project(":module-b")) 声明模块之间的依赖关系。