Spring Boot项目中怎么构建多模块的应用

冥胖胖9

已于 2024-09-06 17:52:16 修改

阅读量762

点赞数 13

文章标签： spring boot java 数据库

于 2024-09-05 14:47:45 首次发布

本文链接：https://blog.csdn.net/wenbin729392753/article/details/141897245

版权

在大型项目开发中，将项目分解为多个模块不仅可以增强代码的可维护性，还能提高开发效率。Spring Boot 提供了对多模块项目的良好支持，使得我们可以轻松地构建复杂的企业级应用程序。在这篇文章中，我们将深入探讨如何在Spring Boot项目中构建多模块的应用，包括多模块的原理、项目结构以及代码示例。

为了有效管理多个模块间的依赖版本，通常推荐使用BOM（Bill of Materials）。本文将详细介绍如何在Spring Boot项目中构建多模块应用，并使用子模块BOM来集中管理依赖版本。

一、为什么要使用多模块结构？

在一个多模块项目中，通常有一个主模块（也称为父模块），它包含多个子模块和一个bom模块。父模块负责管理子模块和插件配置。每个子模块都可以独立开发和测试，并且能够与其他模块协同工作。bom模块用来统一管理项目依赖版本。

多模块项目的核心优势包括：

分而治之：将大项目拆分为多个模块，减少模块之间的耦合，提高可维护性。
独立开发：各模块可以独立开发和测试，便于团队协作。
重用性：模块可以在其他项目中复用，提高开发效率。

二、项目结构

一个典型的多模块项目结构如下：

my-spring-boot-app/
|-- pom.xml                 # 父项目pom文件
|-- bom/                    # BOM模块
|   |-- pom.xml             # BOM模块pom文件
|-- common/                 # 公共模块
|   |-- cache/                  # 缓存组件
|       |-- pom.xml             # 缓存组件pom文件
|       `-- src/main/java/      # 缓存组件Java源码
|   |-- pom.xml             # 公共模块pom文件
|-- business/               # 业务模块
|   |-- order/                  # 订单模块
|       |-- pom.xml             # 订单模块pom文件
|       `-- src/main/java/      # 订单模块java源码
|   |-- trade/                   # 交易模块
|       |-- pom.xml             # 交易模块pom文件
|       `-- src/main/java/      # 交易模块Java源码  
|   |-- pom.xml             # 业务模块pom文件

my-spring-boot-app/: 主模块，用于管理子模块。
common/, business/: 子模块，以及子模块下的子模块各自独立进行开发和维护。
bom/: bom模块，用于统一管理项目的依赖包和插件版本。

三、构建多模块项目

1. 创建主模块

首先，创建一个Maven项目作为主模块。在主模块的pom.xml中，我们需要声明该项目是一个父模块，并列出所有的子模块。

<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.nft</groupId>
        <artifactId>nft-bom</artifactId>
        <version>${revision}</version>
        <relativePath>./nft-bom/pom.xml</relativePath>
    </parent>

    <artifactId>nft</artifactId>
    <packaging>pom</packaging>
    <description>NFT System</description>

    <properties>
        <revision>1.0.0-SNAPSHOT</revision>
    </properties>

    <modules>
        <module>nft-bom</module>
        <module>nft-business</module>
        <module>nft-common</module>
    </modules>

</project>

2. 创建子模块

接下来，创建子模块。在每个子模块中，pom.xml文件需要继承主模块的配置：

2.1.创建子模块common及其子模块

创建common模块

<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.nft</groupId>
        <artifactId>nft</artifactId>
        <version>${revision}</version>
    </parent>

    <groupId>com.nft.common</groupId>
    <artifactId>nft-common</artifactId>
    <packaging>pom</packaging>
    <description>Nft Common Modules</description>

    <modules>
        <module>nft-cache</module>
    </modules>

</project>

创建comon的子模块cache

<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.nft.common</groupId>
        <artifactId>nft-common</artifactId>
        <version>${revision}</version>
    </parent>

    <artifactId>nft-cache</artifactId>
    <description>nft cache module</description>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

        <dependency>
            <groupId>org.hibernate.orm</groupId>
            <artifactId>hibernate-jcache</artifactId>
        </dependency>

        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>tech.jhipster</groupId>
            <artifactId>jhipster-framework</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>

    </dependencies>
</project>

2.2.创建子模块business及其子模块

创建business模块

<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.nft</groupId>
        <artifactId>nft</artifactId>
        <version>${revision}</version>
    </parent>

    <groupId>com.nft.business</groupId>
    <artifactId>nft-business</artifactId>
    <packaging>pom</packaging>
    <description>Nft Business Modules</description>

    <modules>
        <module>nft-order</module>
        <module>nft-trade</module>
    </modules>

</project>

创建business的子模块order

<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.nft.business</groupId>
        <artifactId>nft-business</artifactId>
        <version>${revision}</version>
    </parent>

    <artifactId>nft-order</artifactId>
    <description>Nft Order Modules</description>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-undertow</artifactId>
        </dependency>

        <dependency>
            <groupId>com.nft.common</groupId>
            <artifactId>nft-cache</artifactId>
        </dependency>

    </dependencies>

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

创建business的子模块trade

<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.nft.business</groupId>
        <artifactId>nft-business</artifactId>
        <version>${revision}</version>
    </parent>

    <artifactId>nft-trade</artifactId>
    <description>Nft Trade Modules</description>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-undertow</artifactId>
        </dependency>

    </dependencies>
</project>

3. 配置子模块之间的依赖

如果模块之间有依赖关系，例如nft-order依赖于nft-cache，可以在nft-order的pom.xml中添加依赖：

<!--版本在bom中配置-->
<dependency>
    <groupId>com.nft.common</groupId>
    <artifactId>nft-cache</artifactId>
</dependency>

4.在子模块中创建BOM来管理依赖和插件版本

接下来，我们在 my-spring-boot-app 项目中创建 bom 子模块，用来管理所有子模块的依赖和插件版本。

创建 bom 模块的 pom.xml：

<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>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.3</version>
        <relativePath/>
        <!-- lookup parent from repository -->
    </parent>

    <groupId>com.nft</groupId>
    <artifactId>nft-bom</artifactId>
    <version>${revision}</version>
    <packaging>pom</packaging>
    <description>Bill of materials for nft modules</description>

    <properties>
        <nft.version>1.0.0-SNAPSHOT</nft.version>
        <java.version>21</java.version>

        <spring-boot.version>3.3.3</spring-boot.version>
        <jhipster-framework.version>8.7.0</jhipster-framework.version>
        <redisson.version>3.35.0</redisson.version>

        <!-- plugin versions -->
        <flatten-maven-plugin.version>1.6.0</flatten-maven-plugin.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>${spring-boot.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-tomcat</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>

            <dependency>
                <groupId>org.redisson</groupId>
                <artifactId>redisson</artifactId>
                <version>${redisson.version}</version>
            </dependency>

            <dependency>
                <groupId>tech.jhipster</groupId>
                <artifactId>jhipster-framework</artifactId>
                <version>${jhipster-framework.version}</version>
            </dependency>

            <dependency>
                <groupId>com.nft.common</groupId>
                <artifactId>nft-cache</artifactId>
                <version>${revision}</version>
            </dependency>

            <!-- fix vulnerable -->
            <dependency>
                <groupId>io.undertow</groupId>
                <artifactId>undertow-core</artifactId>
                <version>2.3.17.Final</version>
            </dependency>

        </dependencies>
    </dependencyManagement>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>flatten-maven-plugin</artifactId>
                    <version>${flatten-maven-plugin.version}</version>
                </plugin>
            </plugins>

        </pluginManagement>

        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>flatten-maven-plugin</artifactId>
                <configuration>
                    <updatePomFile>true</updatePomFile>
                    <flattenMode>oss</flattenMode>
                </configuration>
                <executions>
                    <execution>
                        <id>flatten</id>
                        <phase>process-resources</phase>
                        <goals>
                            <goal>flatten</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>flatten.clean</id>
                        <phase>clean</phase>
                        <goals>
                            <goal>clean</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

5. 编写代码

在各自的src/main/java目录下，编写模块对应的代码。例如在nft-order中编写一个简单的Spring Boot应用：

package com.spring.nft.order;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class OrderServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }

}

其他模块可以编写类似的代码。子模块中的类可以互相调用，从而实现模块之间的协作。

6. 构建和运行项目

在主模块的根目录下，运行以下命令构建整个项目：

mvn clean install

构建完成后，可以运行各个子模块的Spring Boot应用：

mvn spring-boot:run -pl nft-order

四、使用BOM管理的好处

通过在 bom 子模块中集中管理依赖和插件版本，父模块和子模块的 pom.xml 将变得更加简洁和可维护。

统一依赖版本：通过BOM模块集中管理依赖和插件版本，避免了多个子模块中手动管理版本的一致性问题。
减少冗余配置：子模块只需声明依赖，而不需要关注具体的版本号，所有版本管理集中在一个地方。

五、总结

通过本文的介绍，我们了解了如何在Spring Boot项目中构建多模块应用，并且通过实际的示例展示了如何配置和使用多模块结构。在实际开发中，根据项目的需求，合理设计模块结构，不仅可以提高开发效率，还能有效地管理项目的复杂性。

使用子模块BOM来管理多模块项目的依赖和插件版本，是一种高效且可维护的方案。通过这种方式，可以将所有版本信息集中在一个地方，使得整个项目的依赖和插件管理变得更加简洁和一致。在复杂项目中，这种方法能够有效地减少版本冲突和管理成本。

希望本文能帮助你在实际项目中更加灵活和有效地使用Spring Boot多模块结构。如果你有任何问题或建议，欢迎在评论区留言讨论。

冥胖胖9

关注

13
点赞
踩
10

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫