Maven 实战：整合 Spring Boot 从入门到部署

上一篇我们学习了 Maven 的基础配置和核心概念，本文将通过一个完整的 Spring Boot 项目实战，展示 Maven 在实际开发中的应用。你将学到如何用 Maven 构建 Spring Boot 项目、管理依赖、打包部署，真正做到从“配置”到“实战”的落地。

一、为什么 Spring Boot 与 Maven 是绝配？

Spring Boot 简化了 Java 开发（自动配置、嵌入式服务器等），而 Maven 解决了依赖管理和构建流程问题，两者结合能极大提升开发效率：

依赖管理：Spring Boot 提供的 starter 依赖（如 spring-boot-starter-web）通过 Maven 自动引入相关 jar 包，无需手动找版本；
版本统一：Spring Boot 父工程（spring-boot-starter-parent）统一管理依赖版本，避免冲突；
一键构建：通过 Maven 命令可直接启动、打包 Spring Boot 项目，无需复杂配置。

二、实战：用 Maven 构建 Spring Boot 项目

步骤 1：创建标准 Maven 项目结构

首先按 Maven 标准结构创建项目（也可通过 IDEA 的“Spring Initializr”快速生成，本文手动创建以理解细节）：

spring-boot-maven-demo/
├── pom.xml                 # Maven 核心配置
└── src/
    └── main/
        ├── java/
        │   └── com/
        │       └── example/
        │           └── demo/
        │               ├── DemoApplication.java  # 启动类
        │               └── controller/
        │                   └── HelloController.java  # 接口类
        └── resources/
            └── application.properties  # Spring Boot 配置文件

步骤 2：配置 pom.xml（核心依赖）

Spring Boot 项目的 pom.xml 核心在于继承父工程和引入 starter 依赖，以下是完整配置：

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>

    <!-- 1. 继承 Spring Boot 父工程（核心） -->
    <!-- 父工程统一管理依赖版本，无需手动指定版本号 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.18</version> <!-- Spring Boot 版本 -->
        <relativePath/> <!-- 从仓库找父工程，而非本地 -->
    </parent>

    <!-- 2. 项目坐标 -->
    <groupId>com.example</groupId>
    <artifactId>spring-boot-maven-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>Spring Boot Maven Demo</name>

    <!-- 3. 依赖配置 -->
    <dependencies>
        <!-- Web 依赖：自动引入 Tomcat、Spring MVC 等 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <!-- 无需写版本，父工程已指定 -->
        </dependency>

        <!-- 测试依赖：包含 JUnit、Spring 测试支持等 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope> <!-- 仅测试时生效 -->
        </dependency>
    </dependencies>

    <!-- 4. 构建插件（Spring Boot 打包专用） -->
    <build>
        <plugins>
            <!-- Spring Boot Maven 插件：支持启动、打包等功能 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <!-- 版本由父工程管理 -->
            </plugin>
        </plugins>
    </build>
</project>

配置说明：

spring-boot-starter-parent：父工程，定义了几乎所有 Spring Boot 依赖的版本，避免手动指定版本导致的冲突；
spring-boot-starter-web：Web starters 依赖，自动引入 Tomcat（嵌入式服务器）、Spring MVC、Jackson（JSON 解析）等，无需手动配置；
spring-boot-maven-plugin：Spring Boot 专用插件，支持 mvn spring-boot:run 启动项目，以及打包成可执行 jar 包。

步骤 3：编写 Spring Boot 代码

（1）启动类（入口）

创建 src/main/java/com/example/demo/DemoApplication.java：

java

package com.example.demo;

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

// @SpringBootApplication：Spring Boot 核心注解（包含自动配置、组件扫描等）
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        // 启动 Spring Boot 应用
        SpringApplication.run(DemoApplication.class, args);
    }
}

（2）接口类（测试 API）

创建 src/main/java/com/example/demo/controller/HelloController.java：

java

package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

// @RestController：标识为控制器，且方法返回 JSON 数据
@RestController
public class HelloController {

    // 定义 GET 请求接口：http://localhost:8080/hello/xxx
    @GetMapping("/hello/{name}")
    public String hello(@PathVariable String name) {
        return "Hello, " + name + "! 这是 Maven + Spring Boot 实战";
    }
}

（3）配置文件（可选）

src/main/resources/application.properties 可配置端口等参数：

properties

# 配置服务器端口（默认 8080）
server.port=8081

步骤 4：用 Maven 命令操作 Spring Boot 项目

（1）启动项目

在项目根目录（pom.xml 所在目录）执行命令：

bash

mvn spring-boot:run

效果：

Maven 会自动下载依赖（首次执行较慢，依赖缓存后会加快）；
启动嵌入式 Tomcat 服务器，控制台输出 Started DemoApplication in xxx seconds；
访问 http://localhost:8081/hello/Maven，浏览器显示：Hello, Maven! 这是 Maven + Spring Boot 实战。

（2）执行测试

Spring Boot 测试依赖已包含 JUnit 5，我们编写一个简单测试类：

创建 src/test/java/com/example/demo/HelloControllerTest.java：

java

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

// 启动 Spring Boot 测试环境
@SpringBootTest
// 自动配置 MockMvc（模拟 HTTP 请求）
@AutoConfigureMockMvc
public class HelloControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testHello() throws Exception {
        // 模拟访问 /hello/Test，并验证结果
        mockMvc.perform(get("/hello/Test"))
                .andExpect(status().isOk()) // 验证状态码 200
                .andExpect(content().string("Hello, Test! 这是 Maven + Spring Boot 实战")); // 验证返回内容
    }
}

执行测试命令：

bash

mvn test

效果：控制台输出测试结果，显示 Tests run: 1, Failures: 0 表示测试通过。

（3）打包项目

Spring Boot 项目可打包为可执行 jar 包（包含嵌入式 Tomcat，无需单独部署），执行命令：

bash

mvn clean package

效果：

clean 清理之前的构建产物；
package 打包，生成 target/spring-boot-maven-demo-1.0-SNAPSHOT.jar；
jar 包可直接运行：java -jar target/spring-boot-maven-demo-1.0-SNAPSHOT.jar，访问效果与 mvn spring-boot:run 一致。

（4）安装到本地仓库

若该项目需要被其他项目依赖（如作为公共模块），可安装到本地仓库：

bash

mvn install

效果：本地仓库（如 ~/.m2/repository/com/example/spring-boot-maven-demo/1.0-SNAPSHOT/）出现该项目的 jar 包，其他项目可通过以下依赖引入：

xml

<dependency>
    <groupId>com.example</groupId>
    <artifactId>spring-boot-maven-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

三、Maven 与 Spring Boot 核心结合点解析

1. 依赖管理：Starter 与 Parent

Starter 依赖：Spring Boot 的 starter 是“依赖描述符”，比如 spring-boot-starter-web 包含了开发 Web 应用所需的所有依赖（Tomcat、Spring MVC 等），Maven 会自动下载这些依赖及其传递依赖，无需手动逐个引入；
Parent 工程：spring-boot-starter-parent 定义了 dependencyManagement，统一管理所有 starter 的版本，避免“版本地狱”。例如，引入 spring-boot-starter-web 时无需写版本，父工程已指定匹配当前 Spring Boot 版本的依赖版本。

2. 构建插件：spring-boot-maven-plugin

该插件是 Spring Boot 与 Maven 交互的核心，提供三大功能：

启动项目：mvn spring-boot:run 直接启动应用，无需手动部署到服务器；
打包可执行 jar：mvn package 生成的 jar 包包含所有依赖和嵌入式服务器，可通过 java -jar 直接运行；
依赖分析：mvn spring-boot:dependency-tree 查看项目依赖树，方便排查冲突。

3. 版本冲突解决实战

假设项目中引入了一个与 Spring Boot 父工程版本冲突的依赖（如 Jackson）：

xml

<dependencies>
    <!-- 引入与父工程版本冲突的 Jackson -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.10.0</version> <!-- 与父工程管理的版本冲突 -->
    </dependency>
</dependencies>

解决方法：

查看依赖树，确认冲突来源：

bash

mvn dependency:tree | grep jackson-databind

排除冲突依赖，使用父工程管理的版本：

xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <!-- 排除 web starter 中的 Jackson -->
    <exclusions>
        <exclusion>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!-- 手动引入统一版本（或删除，使用父工程默认） -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <!-- 不指定版本，继承父工程 -->
</dependency>

四、扩展：多模块 Spring Boot 项目

大型项目通常拆分为多个模块（如 api、service、common），Maven 支持多模块管理。

1. 多模块项目结构

parent-project/          # 父项目（仅用于管理依赖）
├── pom.xml              # 父 pom
├── module-common/       # 公共模块
│   └── pom.xml
├── module-service/      # 服务模块
│   └── pom.xml
└── module-api/          # API 模块（启动类所在）
    └── pom.xml

2. 父项目 pom.xml

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>

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

    <groupId>com.example</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging> <!-- 父项目必须为 pom 打包 -->
    <name>Parent Project</name>

    <!-- 声明子模块 -->
    <modules>
        <module>module-common</module>
        <module>module-service</module>
        <module>module-api</module>
    </modules>

    <!-- 统一管理子模块依赖版本 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>module-common</artifactId>
                <version>${project.version}</version>
            </dependency>
            <!-- 其他模块依赖 -->
        </dependencies>
    </dependencyManagement>
</project>

3. 子模块依赖父项目

以 module-api 为例，其 pom.xml：

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">
    <!-- 继承父项目 -->
    <parent>
        <groupId>com.example</groupId>
        <artifactId>parent-project</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <artifactId>module-api</artifactId>

    <dependencies>
        <!-- 依赖其他子模块 -->
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>module-service</artifactId>
        </dependency>
        <!-- Web 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <!-- 引入 Spring Boot 插件 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

优势：

父项目统一管理版本，子模块无需重复配置；
模块间通过 Maven 依赖关联，清晰维护依赖关系；
可单独构建某个模块（如 cd module-api && mvn package），也可在父项目执行命令构建所有模块（mvn package）。

五、总结

通过本文的 Spring Boot 实战，你不仅巩固了 Maven 的核心用法，更理解了它在框架中的实际价值：

依赖管理：Spring Boot Starter + Maven 自动引入所需依赖，版本由父工程统一控制；
构建流程：通过 mvn spring-boot:run、mvn package 等命令，一键完成启动、测试、打包；
项目扩展：支持多模块拆分，适应大型项目开发。

下一步建议：

尝试在项目中引入更多 Starter（如 spring-boot-starter-data-jpa 操作数据库），观察 Maven 如何管理依赖；
学习 spring-boot-maven-plugin 的高级配置（如自定义打包名称、排除依赖）；
搭建 Nexus 私服，体验企业级 Maven 仓库管理。

Maven + Spring Boot 是 Java 开发的黄金组合，掌握它们能让你在实际项目中事半功倍！

Maven 实战：整合 Spring Boot 从入门到部署 ​

一、为什么 Spring Boot 与 Maven 是绝配？ ​

二、实战：用 Maven 构建 Spring Boot 项目 ​

步骤 1：创建标准 Maven 项目结构 ​

步骤 2：配置 pom.xml（核心依赖） ​

步骤 3：编写 Spring Boot 代码 ​

（1）启动类（入口） ​

（2）接口类（测试 API） ​

（3）配置文件（可选） ​

步骤 4：用 Maven 命令操作 Spring Boot 项目 ​

（1）启动项目 ​

（2）执行测试 ​

（3）打包项目 ​

（4）安装到本地仓库 ​

三、Maven 与 Spring Boot 核心结合点解析 ​

1. 依赖管理：Starter 与 Parent ​

2. 构建插件：spring-boot-maven-plugin ​

3. 版本冲突解决实战 ​

四、扩展：多模块 Spring Boot 项目 ​

1. 多模块项目结构 ​

2. 父项目 pom.xml ​

3. 子模块依赖父项目 ​

五、总结 ​

Maven 实战：整合 Spring Boot 从入门到部署

一、为什么 Spring Boot 与 Maven 是绝配？

二、实战：用 Maven 构建 Spring Boot 项目

步骤 1：创建标准 Maven 项目结构

步骤 2：配置 pom.xml（核心依赖）

步骤 3：编写 Spring Boot 代码

（1）启动类（入口）

（2）接口类（测试 API）

（3）配置文件（可选）

步骤 4：用 Maven 命令操作 Spring Boot 项目

（1）启动项目

（2）执行测试

（3）打包项目

（4）安装到本地仓库

三、Maven 与 Spring Boot 核心结合点解析

1. 依赖管理：Starter 与 Parent

2. 构建插件：spring-boot-maven-plugin

3. 版本冲突解决实战

四、扩展：多模块 Spring Boot 项目

1. 多模块项目结构

2. 父项目 pom.xml

3. 子模块依赖父项目

五、总结