SpringBoot+Maven 多模块项目的构建、运行、打包实战

下面我会详细讲解如何使用SpringBoot和Maven构建多模块项目，包括项目的构建、运行和打包，同时会提供两个实例。

环境准备

在开始构建多模块项目之前，请确保已经安装以下软件：

• JDK 1.8或以上版本
• Maven 3.2或以上版本

项目结构

下面是一个简单的多模块项目结构：

.
├── parent
│   ├── pom.xml
│   └── src
│       ├── main
│       └── test
├── module1
│   ├── pom.xml
│   └── src
│       ├── main
│       │   ├── java
│       │   └── resources
│       └── test
└── module2
    ├── pom.xml
    └── src
        ├── main
        │   ├── java
        │   └── resources
        └── test

parent 模块是父模块，而 module1 和 module2 是子模块。

在 parent 模块中，我们会定义一些公共依赖和插件，同时也会将子模块的依赖引入进来。

在子模块中，我们可以定义一些具体的功能模块，每个子模块都有自己独立的 pom.xml 文件。

父模块的 pom.xml

父模块的 pom.xml 文件中应该包含以下信息：

• groupId：项目组的唯一标识符
• artifactId：项目的唯一标识符
• version：项目的版本号
• packaging：应该设为 pom
• modules：包含所有子模块的名称

除此之外，我们还可以在父模块中定义一些公共的依赖和插件，供子模块继承。

示例：

<project>
    <groupId>com.example</groupId>
    <artifactId>parent</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>
    <modules>
        <module>module1</module>
        <module>module2</module>
    </modules>
    <dependencies>
        <!-- 公共依赖 -->
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>common</artifactId>
            <version>1.0.0</version>
        </dependency>
    </dependencies>
</project>

子模块的 pom.xml

每个子模块都有自己独立的 pom.xml 文件，其中应该包含以下信息：

• parent：指定父模块的 groupId、artifactId 和 version
• groupId：子模块的唯一标识符，应该与父模块相同
• artifactId：子模块的唯一标识符
• version：子模块的版本号
• packaging：应该根据具体情况设定，默认是 jar
• dependencies：该子模块所需要的依赖

示例：

<project>
    <!-- 指定父模块 -->
    <parent>
        <groupId>com.example</groupId>
        <artifactId>parent</artifactId>
        <version>1.0.0</version>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>module1</artifactId>
    <version>1.0.0</version>
    <dependencies>
        <!-- 该模块所需要的依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

多模块项目的构建

在多模块项目的根目录下，我们可以使用以下命令构建整个项目：

mvn clean install

这条命令会将整个项目构建并打包成 jar/war 包，并且将这些包安装到本地仓库中。

多模块项目的运行

在多模块项目中，我们需要选择某一个子模块作为入口，然后运行该子模块。在运行指定子模块之前，我们需要先进入该子模块所在的目录。

比如，我们想要运行 module1 子模块，可以使用以下命令：

cd module1
mvn spring-boot:run

这条命令会使用SpringBoot插件启动SpringBoot应用程序，并在控制台输出应用程序的日志。

多模块项目的打包

在多模块项目中，我们可以使用以下命令打包某一个子模块：

cd module1
mvn package

该命令会将 module1 打包成一个 jar 包，并且将该包保存到 target 目录中。

示例1：创建一个简单的 SpringBoot 项目

接下来，我们将创建一个简单的 SpringBoot 项目，用来演示如何使用 Maven 构建多模块项目。

首先，我们需要在 parent 模块中加入 SpringBoot 的依赖：

<dependencies>
    <!-- SpringBoot 依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.0</version>
        <type>pom</type>
        <scope>import</scope>
    </dependency>
</dependencies>

然后，我们在 module1 子模块中添加一个简单的 SpringBoot 应用程序，并引入一些必要的依赖：

<dependencies>
    <!-- SpringBoot Web 应用程序依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

Java 代码如下：

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

最后，我们运行以下命令构建整个项目：

mvn clean install

构建成功之后，我们进入 module1 子模块的目录，并运行以下命令：

mvn spring-boot:run

这条命令会启动SpringBoot应用程序，并在控制台中输出应用程序的日志。

示例2：创建一个带有多个子模块的 SpringBoot 项目

接下来，我们将创建一个带有多个子模块的 SpringBoot 项目，用来演示如何构建、运行和打包该项目。

首先，我们在 parent 模块中加入 SpringBoot 的依赖：

<dependencies>
    <!-- SpringBoot 依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.0</version>
        <type>pom</type>
        <scope>import</scope>
    </dependency>
</dependencies>

然后，在 module1 子模块中添加一个简单的 SpringBoot 应用程序，并引入一些必要的依赖：

<dependencies>
    <!-- SpringBoot Web 应用程序依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

Java 代码如下：

@RestController
public class HelloWorldController {
    @GetMapping("/hello")
    public String helloWorld() {
        return "Hello, world!";
    }
}

然后，在 module2 子模块中添加一个简单的测试程序，并引入一些必要的依赖：

<dependencies>
    <!-- JUnit 5 单元测试依赖 -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.8.2</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-engine</artifactId>
        <version>5.8.2</version>
        <scope>test</scope>
    </dependency>

    <!-- SpringBoot 测试依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Java 代码如下：

public class HelloWorldTest {
    @Test
    public void testHelloWorld() {
        HelloWorldController controller = new HelloWorldController();
        String result = controller.helloWorld();
        assertEquals("Hello, world!", result);
    }
}

最后，在 parent 的 pom.xml 文件中，我们应该按照以下方式指定子模块的路径：

<modules>
    <module>module1</module>
    <module>module2</module>
</modules>

构建整个项目并运行 module1 子模块，可以发现访问 http://localhost:8080/hello 时，返回 Hello, world!。

同时，我们也可以运行 module2 子模块中的测试程序：mvn test。