Spring Boot Maven 教程：从入门到实践

欢迎来到 Spring Boot 的世界！如果你是一名 Java 开发者，渴望以更高效、更便捷的方式构建企业级应用，那么 Spring Boot 绝对是你不可错过的利器。而 Maven，作为 Java 世界主流的项目管理和构建工具，与 Spring Boot 的结合更是天衣无缝，能够极大地提升开发效率。

本教程将带领你一步步深入了解 Spring Boot，并学习如何使用 Maven 来管理你的 Spring Boot 项目。我们将从基础概念讲起，逐步深入到项目构建、依赖管理、核心功能实现以及最终的打包运行。

目标读者：

有一定 Java 基础的开发者。
希望快速入门 Spring Boot 的新手。
希望了解如何使用 Maven 管理 Spring Boot 项目的开发者。

预计阅读时间： 30-45 分钟

第一章：初识 Spring Boot 与 Maven

在开始实践之前，让我们先了解一下 Spring Boot 和 Maven 分别是什么，以及它们为何如此契合。

1.1 什么是 Spring Boot？

Spring Boot 是一个用于简化 Spring 应用开发的框架。它基于 Spring 平台，但通过”约定优于配置”（Convention over Configuration）的思想，极大地减少了繁琐的配置步骤。它的核心目标是让你能够快速地创建独立运行的、生产级别的 Spring 应用。

Spring Boot 的主要特点包括：

简化配置： 提供了大量的默认配置，让你无需手动配置数据源、连接池、Web 服务器等常见组件。
内嵌式服务器： 可以直接打包成可执行的 JAR 文件，内置 Tomcat、Jetty 或 Undertow 服务器，无需部署到外部应用服务器。
Starter POMs： 提供了一系列依赖的集合，方便你一次性引入某个特定功能所需的全部依赖（例如 spring-boot-starter-web 包含了构建 Web 应用所需的一切）。
自动化配置： 根据你在项目中添加的依赖，Spring Boot 会自动配置相应的组件。
生产就绪特性： 提供了健康检查、度量、外部化配置等生产环境常用的功能。

简单来说，Spring Boot 让你能够”just run”，专注于业务逻辑，而不是纠结于底层框架的配置。

1.2 什么是 Maven？

Maven 是一个强大的项目管理和理解工具。它基于项目对象模型（Project Object Model, POM）的概念，通过一个 XML 文件（pom.xml）来描述项目的基本信息、依赖关系、构建过程等。

Maven 的主要功能包括：

依赖管理： 自动下载、管理项目所需的各种库文件（JAR 包）。
项目构建： 标准化的构建生命周期（clean, compile, test, package, install, deploy）。
项目信息管理： 提供项目报告、文档生成等功能。
插件机制： 高度灵活，可以通过插件扩展功能，执行各种任务。

使用 Maven 的好处在于它提供了一种标准化的方式来构建和管理项目，使得项目的构建过程可重复、可预测，并简化了依赖的管理。

1.3 Spring Boot 与 Maven 的结合

Spring Boot 强烈推荐使用 Maven 或 Gradle 作为项目构建工具。Maven 的依赖管理和标准化构建过程与 Spring Boot 的”约定优于配置”理念完美契合。

依赖管理： Spring Boot 的 Starter POMs 本质上是 Maven 的依赖配置。通过引入一个 Starter，Maven 会自动下载并管理该 Starter 所依赖的所有 JAR 包。
构建打包： Spring Boot 提供了一个 Maven 插件 (spring-boot-maven-plugin)，它可以将你的应用打包成一个可执行的 JAR 文件，其中包含了内嵌的 Web 服务器和所有依赖。
项目结构： Maven 推崇标准的目录结构 (src/main/java, src/main/resources 等)，这与 Spring Boot 的自动化配置扫描等功能是兼容的。

因此，使用 Maven 来构建 Spring Boot 项目是一种非常自然和高效的选择。

第二章：环境准备与项目创建

在开始编写代码之前，你需要准备好开发环境，并创建你的第一个 Spring Boot Maven 项目。

2.1 准备开发环境

你需要安装以下软件：

Java Development Kit (JDK): 推荐使用 Java 8 或更高版本。确保设置了 JAVA_HOME 环境变量，并将 JAVA_HOME/bin 添加到系统的 PATH 环境变量中。
Apache Maven: 下载 Maven 并解压到一个目录。同样，确保将 Maven 的 bin 目录添加到系统的 PATH 环境变量中。可以通过在命令行输入 mvn -v 来检查 Maven 是否安装成功。
集成开发环境 (IDE): 强烈推荐使用支持 Spring Boot 和 Maven 的 IDE，例如：
- Spring Tool Suite (STS): 专门为 Spring 开发设计的 Eclipse 版本。
- IntelliJ IDEA (Ultimate 或 Community 版): 功能强大，对 Spring 和 Maven 支持良好。
- Eclipse: 需要安装相关的 Maven 和 Spring 插件。

安装步骤相对简单，如果遇到问题，请查阅对应软件的官方安装文档。

2.2 创建 Spring Boot 项目

创建 Spring Boot 项目有几种常用方法：

方法一：使用 Spring Initializr (Web UI) – 推荐新手使用

这是最简单、最快捷的方式。

打开浏览器，访问 Spring Initializr 网站：https://start.spring.io/
在页面上进行以下配置：
- Project: 选择 Maven Project。
- Language: 选择 Java。
- Spring Boot: 选择一个稳定的版本（不要选择 SNAPSHOT 或 M 结尾的版本，除非你知道自己在做什么）。
- Project Metadata:
  - Group: 填写组织或公司的域名反写，例如 com.example 或 com.yourcompany。
  - Artifact: 填写项目名称，例如 my-spring-boot-app。
  - Name: 项目显示名称，通常与 Artifact 相同。
  - Description: 项目的简单描述。
  - Package name: 自动生成，通常是 Group.Artifact，可以修改。
  - Packaging: 选择 Jar (用于构建独立运行的应用) 或 War (用于部署到外部应用服务器，较少用)。
  - Java: 选择你安装的 Java 版本 (例如 8, 11, 17)。
- Dependencies: 点击 “Add Dependencies…” 按钮，搜索并添加你需要的依赖。对于一个基本的 Web 应用，通常需要添加：
  - Spring Web: 用于构建 Web 和 RESTful 应用，包含内嵌的 Tomcat。
  - Spring Boot DevTools: 提供开发时的便利功能，如热部署。
点击 “Generate” 按钮，会下载一个 ZIP 文件。
解压 ZIP 文件到你的工作目录。
打开你的 IDE，选择 “Import Project” 或 “Open Project”，然后选择解压后的项目目录。IDE 会自动识别这是一个 Maven 项目并加载依赖。

方法二：使用 Spring Initializr (命令行)

如果你喜欢使用命令行，也可以通过 curl 或其他工具调用 Spring Initializr 的 API：

bash curl https://start.spring.io/starter.zip -d type=maven-project \ -d language=java \ -d bootVersion=2.7.5 \ -d groupId=com.example \ -d artifactId=my-cli-app \ -d name=my-cli-app \ -d description="Demo project for Spring Boot" \ -d packageName=com.example.mycli \ -d packaging=jar \ -d javaVersion=11 \ -d dependencies=web,devtools \ -o my-cli-app.zip

下载后解压并导入到 IDE 的步骤同上。

方法三：手动创建 Maven 项目并引入 Spring Boot 依赖

虽然不推荐新手使用，但了解这个过程有助于理解 Spring Boot 项目的 Maven 结构。

使用 IDE 或命令行创建一个标准的 Maven 项目。
打开生成的 pom.xml 文件。
添加 Spring Boot 的 Parent 依赖。
添加 Spring Boot 的 Starter 依赖。
配置 Spring Boot Maven 插件。

这个过程将在下一章详细介绍 pom.xml 文件时讲解。

本教程将主要基于方法一（Spring Initializr Web UI）创建的项目结构进行讲解。

第三章：理解 Maven 项目结构与 `pom.xml`

通过 Spring Initializr 创建的项目会有一个标准的 Maven 目录结构，以及一个核心的 pom.xml 文件。理解它们是进行后续开发的基础。

3.1 标准的 Maven 项目结构

解压项目并导入 IDE 后，你会看到类似以下的目录结构：

my-spring-boot-app/ ├── .mvn/ │ └── wrapper/ │ ├── maven-wrapper.jar │ └── maven-wrapper.properties ├── src/ │ ├── main/ │ │ ├── java/ │ │ │ └── com/ │ │ │ └── example/ │ │ │ └── myspringbootapp/ │ │ │ └── MySpringBootAppApplication.java (主应用类) │ │ └── resources/ │ │ ├── application.properties (配置文件) │ │ ├── static/ (静态资源，如 HTML, CSS, JS) │ │ └── templates/ (模板文件，如 Thymeleaf, FreeMarker) │ └── test/ │ └── java/ │ └── com/ │ └── example/ │ └── myspringbootapp/ │ └── MySpringBootAppApplicationTests.java (测试类) ├── .gitignore (Git 版本控制忽略文件) ├── mvnw (Maven Wrapper 脚本 - Linux/macOS) ├── mvnw.cmd (Maven Wrapper 脚本 - Windows) └── pom.xml (项目对象模型文件)

.mvn/wrapper: Maven Wrapper 的相关文件，允许你在没有预先安装 Maven 的情况下运行 Maven 命令，它会自动下载指定版本的 Maven。
src/main/java: 存放项目的 Java 源代码。
src/main/resources: 存放项目的资源文件，如配置文件、静态文件、模板文件等。
- application.properties 或 application.yml 是 Spring Boot 的主配置文件。
- static 目录用于存放静态资源，通过 / 路径直接访问。
- templates 目录用于存放服务器端模板引擎使用的文件。
src/test/java: 存放项目的测试 Java 源代码。
src/test/resources: 存放测试相关的资源文件。
.gitignore: 指定 Git 需要忽略的文件和目录。
mvnw, mvnw.cmd: Maven Wrapper 脚本，推荐使用它们来执行 Maven 命令（例如 ./mvnw clean package），而不是系统全局安装的 mvn 命令，这可以保证所有开发者使用相同版本的 Maven。
pom.xml: 项目的核心配置文件。

3.2 深入理解 `pom.xml` 文件

pom.xml 是 Maven 项目的灵魂，它包含了项目的各种配置信息。让我们看看 Spring Boot 项目中典型的 pom.xml 文件结构和重要元素：

“`xml

4.0.0

<!-- Spring Boot Parent 依赖 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.5</version> <!-- 请替换为你选择的 Spring Boot 版本 -->
    <relativePath/> <!-- lookup parent from repository -->
</parent>

<!-- 项目基本信息 -->
<groupId>com.example</groupId>
<artifactId>my-spring-boot-app</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>my-spring-boot-app</name>
<description>Demo project for Spring Boot</description>

<!-- 项目属性 -->
<properties>
    <java.version>11</java.version> <!-- 请替换为你选择的 Java 版本 -->
</properties>

<!-- 项目依赖 -->
<dependencies>
    <!-- Spring Boot Web Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Spring Boot DevTools (开发时使用) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>

    <!-- Spring Boot Test Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

<!-- 项目构建配置 -->
<build>
    <plugins>
        <!-- Spring Boot Maven 插件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

“`

重要元素解释：

<project>: POM 文件的根元素。
<modelVersion>: 指定 POM 模型版本，通常是 4.0.0。
<parent>: 这是 Spring Boot 项目 pom.xml 的一个关键部分。
- 它指定了项目的父 POM，这里是 spring-boot-starter-parent。
- spring-boot-starter-parent 是什么？ 它是一个特殊的 Maven POM，由 Spring Boot 提供，它本身不包含任何代码，但它定义了大量的默认配置，包括：
  - 依赖管理 (Dependency Management): 定义了各种常用依赖的版本，当你引入 Starter 或其他 Spring Boot 推荐的依赖时，通常不需要指定版本号。Maven 会从 Parent POM 中继承版本信息。这极大地避免了版本冲突，并确保了依赖兼容性。
  - 默认的 Maven 插件配置: 例如 Java 编译版本、资源文件编码等。
  - 合适的资源过滤: 允许在构建过程中处理 application.properties 等文件。
- <relativePath/> 指示 Maven 在本地文件系统中查找父 POM，如果找不到则去 Maven 仓库找。
<groupId>, <artifactId>, <version>: Maven 项目的坐标，唯一标识一个项目。
- groupId: 定义项目所属的组织或群组。
- artifactId: 定义项目自身的名称，通常是模块名称。
- version: 定义项目的版本。-SNAPSHOT 表示这是一个快照版本，正在开发中。
<name>, <description>: 项目的描述信息。
<properties>: 定义一些属性，可以在 POM 文件中重复使用。
- java.version: 定义了项目使用的 Java 编译版本，这是从 Parent POM 继承并覆盖的。
<dependencies>: 列出项目所需的所有依赖。
- 每个 <dependency> 元素定义一个依赖。
- groupId, artifactId: 标识依赖的坐标。
- version: 注意： 对于 Spring Boot Starter 或 Parent POM 中已经管理的依赖，你通常不需要在这里指定 <version>，因为它会从 Parent 继承。这正是 Parent POM 依赖管理的好处！
- scope: 定义依赖的作用范围。常见的有：
  - compile: 默认范围，编译、测试、运行都需要。
  - runtime: 运行时需要，编译、测试不需要（如 JDBC 驱动）。
  - test: 测试时需要，编译、运行时不需要（如 JUnit）。
  - provided: 编译、测试需要，但运行时由容器提供（如 Servlet API，但在 Spring Boot 内嵌容器中通常不需要设为 provided）。
- optional: 设置为 true 表示该依赖是可选的，不会传递给依赖本项目的其他项目。
- Starter POMs: 再次强调 Starter 的作用。例如 spring-boot-starter-web 会自动引入 Spring Core, Spring MVC, Tomcat 等一系列相关依赖，省去了手动添加大量单个依赖的麻烦。
<build>: 定义项目的构建配置。
- <plugins>: 列出构建过程中使用的 Maven 插件。
- spring-boot-maven-plugin: 这是 Spring Boot 提供的核心 Maven 插件。
  - 它的主要作用是将你的 Spring Boot 应用打包成一个可执行的 JAR 文件。
  - 它会收集所有依赖，将它们放到 JAR 包内部的指定位置。
  - 它会配置 JAR 包的 Manifest 文件，指定主类和启动类加载器，使得 JAR 包可以直接通过 java -jar 命令运行。
  - 它还支持诸如构建信息生成、应用分层打包等功能。

理解了 pom.xml 的结构和关键元素，特别是 Parent POM 和 Starter 依赖，你就掌握了 Spring Boot 项目的依赖管理和基本构建原理。

3.3 添加新的依赖

如果你的项目需要新的功能（例如连接数据库、使用消息队列等），你需要向 pom.xml 文件中添加相应的依赖。

查找依赖坐标：
- 推荐方式： 查看 Spring Boot 官方文档，寻找对应功能的 Spring Boot Starter。例如，要使用 JPA 和 H2 数据库，你会查找 spring-boot-starter-data-jpa 和 h2。文档会告诉你 Starter 的 groupId 和 artifactId。对于非 Starter 的依赖（如 H2 数据库驱动），通常在 Starter POM 的依赖管理中也包含了版本信息，所以你可能只需要 groupId 和 artifactId。
- 通用方式： 在 Maven Central Repository (https://search.maven.org/) 搜索你需要的库，找到其 groupId, artifactId, version。

在 <dependencies> 块中添加 <dependency> 元素：

“`xml

<!-- 添加 Data JPA Starter -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <!-- 版本号通常可以省略，由 parent 管理 -->
</dependency>

<!-- 添加 H2 数据库 (内存数据库，用于开发测试) -->
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope> <!-- H2 是数据库驱动，运行时需要 -->
    <!-- 版本号通常可以省略，由 parent 管理 -->
</dependency>

<!-- 其他依赖 -->

`` 3. **刷新 Maven 项目：** 在你的 IDE 中，通常会有“刷新 Maven 项目”或“重新加载所有 Maven 项目”的选项。执行此操作后，Maven 会根据pom.xml` 文件下载新的依赖到本地仓库，并在项目中生效。

第四章：编写你的第一个 Web 接口

现在环境已经准备好，项目也创建并理解了基本结构，我们可以开始编写代码来实现一个简单的 Web 接口了。

4.1 找到主应用类

打开 src/main/java 目录下的主应用类（通常以 Application 结尾，并且包含 main 方法）。例如 MySpringBootAppApplication.java。

“`java
package com.example.myspringbootapp;

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

@SpringBootApplication // 核心注解
public class MySpringBootAppApplication {

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

}
“`

@SpringBootApplication: 这是 Spring Boot 的核心注解，它是一个复合注解，包含了：
- @Configuration: 表明这是一个配置类。
- @EnableAutoConfiguration: 启用 Spring Boot 的自动配置机制，根据 classpath 中的 JAR 包自动配置 Spring 组件。
- @ComponentScan: 扫描当前包及其子包下的组件（如 @Component, @Service, @Repository, @Controller 等），并将它们注册为 Spring Bean。
SpringApplication.run(...): 静态方法，用于启动 Spring Boot 应用。

这个类是你的应用程序的入口点。

4.2 创建一个简单的 Controller

在与主应用类相同的包或其子包下，创建一个新的 Java 类，例如 HelloController.java。

“`java
package com.example.myspringbootapp; // 与主应用类在同一包或子包

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

@RestController // 结合 @Controller 和 @ResponseBody
public class HelloController {

@GetMapping("/hello") // 映射 GET 请求到 /hello 路径
public String sayHello() {
    return "Hello, Spring Boot with Maven!"; // 直接返回字符串作为响应体
}

}
“`

@RestController: 这是 Spring 4.0 引入的注解，它是 @Controller 和 @ResponseBody 的组合。
- @Controller: 标记这是一个 Spring MVC 控制器，用于处理 Web 请求。
- @ResponseBody: 表示该类的所有方法的返回值都直接作为 HTTP 响应体发送，而不是渲染视图。
@GetMapping("/hello"): 这是一个 Spring MVC 注解，用于将 HTTP GET 请求映射到指定的路径 (/hello) 和方法 (sayHello)。它是 @RequestMapping(method = RequestMethod.GET) 的简化形式。
sayHello() 方法：当收到 /hello 的 GET 请求时，Spring MVC 会调用此方法，并将返回的字符串 "Hello, Spring Boot with Maven!" 作为 HTTP 响应体发送给客户端。

4.3 代码结构

创建 HelloController.java 后，你的 src/main/java 目录可能看起来像这样：

src/main/java/ └── com/ └── example/ └── myspringbootapp/ ├── MySpringBootAppApplication.java └── HelloController.java

由于 HelloController 在主应用类 MySpringBootAppApplication 的子包下，@ComponentScan 会自动扫描到它，并将其注册为 Spring Bean。@RestController 使得它能够处理 Web 请求。

第五章：运行与测试应用

代码编写完毕，现在是时候运行你的 Spring Boot 应用并测试你编写的 Web 接口了。

5.1 运行 Spring Boot 应用

你可以通过多种方式运行 Spring Boot 应用：

方法一：使用 IDE 运行 (推荐开发时使用)

这是开发过程中最便捷的方式。

打开主应用类 MySpringBootAppApplication.java。
右键点击该类，选择 “Run ‘MySpringBootAppApplication'” 或类似的选项。
IDE 会使用 Spring Boot DevTools 的特性（如果添加了该依赖），启动嵌入式 Tomcat，并部署你的应用。

查看 IDE 的控制台输出，你会看到 Spring 的启动日志，其中包含类似以下信息（端口号默认为 8080）：

... o.s.s.web.DefaultServletHandlerConfigurer : Enabling default servlet handling o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring DispatcherServlet 'dispatcherServlet' o.s.web.servlet.DispatcherServlet : Initializing Servlet 'dispatcherServlet' o.s.web.servlet.DispatcherServlet : Completed initialization in 123 ms o.s.b.web.embedded.tomcat.TomcatWebServer: Tomcat started on port(s): 8080 (http) with context path '' o.e.j.u.s.AbstractConnector : Started ServerConnector@...{HTTP/1.1,[http/1.1]}{0.0.0.0:8080} (如果是 Jetty) o.s.b.StartupInfo : Started MySpringBootAppApplication in X.XXX seconds (JVM running for Y.YYY)

这表明你的应用已经在本地的 8080 端口成功启动。

方法二：使用 Maven 插件运行

你也可以使用 Spring Boot Maven 插件提供的 spring-boot:run 命令来启动应用。

打开命令行终端，切换到项目的根目录 (my-spring-boot-app)。
执行以下命令（使用 Maven Wrapper 脚本）：

bash ./mvnw spring-boot:run
或者，如果你已经全局安装了 Maven：
bash mvn spring-boot:run

该命令会编译你的代码（如果需要）、下载依赖（如果需要），然后使用 Spring Boot Maven 插件启动应用。输出日志会与 IDE 运行类似。这个方法也通常与 DevTools 配合使用。

方法三：运行打包后的 JAR 文件 (模拟生产环境)

这种方式模拟了应用在生产环境中的运行方式。

首先，使用 Maven 打包你的应用。在项目根目录下执行：

bash ./mvnw clean package
或者
bash mvn clean package
clean 命令会清除之前的构建产物 (target 目录)。package 命令会执行编译、测试、打包等步骤，最终在 target 目录下生成一个可执行的 JAR 文件，文件名为 <artifactId>-<version>.jar，例如 my-spring-boot-app-0.0.1-SNAPSHOT.jar。注意，Spring Boot Maven 插件会将所有依赖都包含在这个 JAR 文件中。
进入 target 目录，然后执行以下命令来运行 JAR 文件：

bash java -jar target/my-spring-boot-app-0.0.1-SNAPSHOT.jar
请将文件名替换为你实际生成的 JAR 文件名。

这种方式启动的应用不会包含 DevTools 的热部署功能。

5.2 测试 Web 接口

应用启动后，你可以使用浏览器、curl 命令或 Postman 等工具来访问你创建的 /hello 接口。

使用浏览器：

打开浏览器，访问地址：http://localhost:8080/hello

你应该能在浏览器页面上看到输出：Hello, Spring Boot with Maven!

使用 curl 命令：

打开命令行终端，执行以下命令：

bash curl http://localhost:8080/hello

命令行会输出：Hello, Spring Boot with Maven!

使用 Postman 或类似工具：

打开 Postman，创建一个新的 GET 请求，输入 URL http://localhost:8080/hello，然后发送请求。你会在响应体中看到 "Hello, Spring Boot with Maven!"。

恭喜！你已经成功创建并运行了一个 Spring Boot Web 应用，并通过 Maven 对其进行了管理和构建。

第六章：常用 Maven 命令与 Spring Boot 特性

在 Spring Boot 项目开发中，你会频繁使用一些 Maven 命令，并可能需要配置一些 Spring Boot 的常用特性。

6.1 常用的 Maven 命令

./mvnw clean: 清理项目的构建产物（删除 target 目录）。
./mvnw compile: 编译 src/main/java 目录下的 Java 源代码。
./mvnw test: 运行 src/test/java 目录下的测试代码。
./mvnw package: 编译、测试，并将项目打包成 JAR 或 WAR 文件。
./mvnw install: 在本地 Maven 仓库中安装打包文件，供其他本地项目使用。
./mvnw deploy: 将打包文件部署到远程 Maven 仓库。
./mvnw dependency:tree: 显示项目的依赖树，有助于查看依赖关系和冲突。
./mvnw help:effective-pom: 显示项目最终生效的 POM 配置，包括从父 POM 继承的部分。这在调试配置问题时非常有用。
./mvnw spring-boot:run: 使用 Spring Boot 插件运行应用（开发时常用）。
./mvnw spring-boot:start / spring-boot:stop: 在后台启动/停止应用（常用于集成测试或部署脚本）。
./mvnw spring-boot:repackage: 重新打包已存在的 JAR/WAR 文件，使其成为可执行文件（package 生命周期默认会执行此操作）。

提示： 在开发环境中，通常使用 IDE 的运行功能或 spring-boot:run 命令，因为它们支持 DevTools 的热部署。在构建发布版本时，使用 clean package 命令。

6.2 配置应用端口

默认情况下，Spring Boot Web 应用使用 8080 端口。你可以通过修改配置文件来改变端口。

打开 src/main/resources/application.properties 文件（如果不存在则创建），添加以下行：

properties server.port=8081

或者使用 application.yml (需要添加 Jackson 的 SnakeYAML 依赖，Spring Initializr 添加 Web Starter 时通常会自动包含):

yaml server: port: 8081

保存文件后，重启应用。应用现在应该会在 8081 端口启动。

你也可以通过命令行参数或环境变量来设置端口，这在部署时非常有用：

bash java -jar target/*.jar --server.port=9090
或者
bash SERVER_PORT=9090 java -jar target/*.jar

6.3 使用外部化配置

Spring Boot 鼓励使用外部化配置，这意味着你可以在应用外部（如命令行参数、环境变量、配置文件等）配置应用属性，而无需修改代码。

application.properties 和 application.yml 是最常见的外部化配置文件。你可以在其中定义各种属性：

“`properties

application.properties

my.custom.property=hello config
my.another.setting=123
“`

然后在你的 Spring 组件中使用 @Value 注解注入这些属性：

“`java
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ConfigController {

@Value("${my.custom.property}") // 注入属性值
private String customProperty;

@Value("${my.another.setting}")
private int anotherSetting;

@GetMapping("/config")
public String showConfig() {
    return "Custom property: " + customProperty + ", Another setting: " + anotherSetting;
}

}
“`

访问 /config 接口，你会看到配置文件的值被成功读取。

Spring Boot 外部化配置支持多种来源和优先级，这使得应用的配置非常灵活。

6.4 DevTools 的热部署

如果你在创建项目时添加了 spring-boot-devtools 依赖，那么在开发模式下（通过 IDE 或 spring-boot:run 启动），修改 Java 代码、属性文件、模板文件等并保存后，应用会自动重启或刷新部分内容，无需手动停止和启动。这大大加快了开发速度。

注意：修改 pom.xml 通常仍然需要手动刷新 Maven 项目并重启应用。

第七章：打包与分发

最后一步是将你的 Spring Boot 应用打包成一个可执行的 JAR 文件，以便于部署和分发。

7.1 理解可执行 JAR

通过 spring-boot-maven-plugin 打包生成的 JAR 文件是一个“胖 JAR”（Fat JAR），它包含了你的应用程序代码、所有依赖的 JAR 文件以及一个能够启动应用的引导程序。这意味着你可以直接使用 java -jar 命令来运行它，而不需要一个独立的 Web 服务器环境。

7.2 执行打包命令

如前所述，在项目根目录下执行 Maven package 命令：

bash ./mvnw clean package

Maven 会执行完整的构建生命周期，包括编译、测试和打包。打包过程中的一个关键步骤就是 spring-boot-maven-plugin 的 repackage 目标，它负责创建这个可执行的 JAR。

打包成功后，你会在项目的 target 目录下找到生成的 JAR 文件，例如 my-spring-boot-app-0.0.1-SNAPSHOT.jar。

7.3 运行可执行 JAR

你可以像运行任何 JAR 文件一样运行它：

bash java -jar target/my-spring-boot-app-0.0.1-SNAPSHOT.jar

应用程序会在内嵌的 Web 服务器上启动，并监听默认或配置的端口。

7.4 打包成 WAR 文件 (可选)

如果你需要将 Spring Boot 应用部署到传统的外部 Web 服务器（如 Tomcat, Jetty）而不是使用内嵌服务器，你可以将项目打包成 WAR 文件。

在 pom.xml 中，将 <packaging> 从 jar 修改为 war：

xml <packaging>war</packaging>
2. 将内嵌 Web 服务器的依赖范围设置为 provided，以免与外部服务器冲突。找到 spring-boot-starter-web 依赖，并添加 <scope>provided</scope>。注意： 对于 Spring Boot 2.x 及更高版本，将 <packaging> 设置为 war 并添加 spring-boot-starter-tomcat 依赖（spring-boot-starter-web 默认包含它）时，这个 Starter 的 scope 会被自动设置为 provided，通常无需手动修改。但为了清晰起见，可以明确设置。

xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId>  <scope>provided</scope> </dependency>
3. 修改主应用类，继承 SpringBootServletInitializer 并覆盖 configure 方法（这是传统的 Spring MVC 部署到外部容器的方式）：

“`java
package com.example.myspringbootapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder; // 需要导入
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer; // 需要导入

@SpringBootApplication
// 继承 SpringBootServletInitializer
public class MySpringBootAppApplication extends SpringBootServletInitializer {
```
public static void main(String[] args) {
    SpringApplication.run(MySpringBootAppApplication.class, args);
}

// 覆盖 configure 方法
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
    return application.sources(MySpringBootAppApplication.class);
}
```
}
`` 4. 执行./mvnw clean package命令，会在target目录下生成一个.war` 文件。
5. 将生成的 WAR 文件部署到你的外部 Web 服务器中。

注意： 尽管 Spring Boot 支持打包成 WAR，但在大多数现代部署场景（如云原生、微服务）中，打包成可执行 JAR 并使用内嵌服务器是更常见、更推荐的方式。

第八章：故障排除与进阶方向

8.1 常见问题排查

端口被占用 (Port already in use): 启动时如果看到类似错误，说明有其他进程正在使用你配置的端口 (默认为 8080)。停止占用端口的进程，或者修改应用的端口。
依赖冲突 (Dependency Conflicts): Maven 的依赖树非常有用 (./mvnw dependency:tree)。如果出现类找不到 (ClassNotFoundException) 或方法找不到 (NoSuchMethodError) 等问题，可能是依赖冲突导致的。检查依赖树，找出重复或版本不兼容的依赖，并在 pom.xml 中使用 <exclusions> 排除冲突的依赖，或通过 Parent POM 统一版本。
Maven 命令找不到: 确保 Maven 的 bin 目录已添加到系统的 PATH 环境变量中。如果使用 Maven Wrapper (./mvnw)，确保你在项目根目录下执行命令。
应用启动失败: 仔细阅读控制台的错误日志。Spring Boot 的日志通常会给出详细的错误信息和原因。
找不到 Controller/Bean: 检查你的类是否在主应用类 @ComponentScan 的扫描范围内（通常是主应用类所在的包及其子包）。检查是否使用了正确的 Spring 注解 (@RestController, @Service, @Component 等)。
配置文件不生效: 检查配置文件名是否正确 (application.properties/application.yml)，是否放在 src/main/resources 目录下，属性名是否拼写正确。

8.2 进阶方向

掌握了 Spring Boot 与 Maven 的基本用法后，你可以进一步学习以下内容：

数据访问: 集成数据库 (如 MySQL, PostgreSQL) 和 ORM 框架 (如 Spring Data JPA, MyBatis)。
RESTful API 开发: 学习更复杂的 RESTful 接口设计、请求参数处理、数据校验、异常处理等。
测试: 学习如何编写单元测试和集成测试来测试你的 Spring Boot 应用。
安全性: 集成 Spring Security 来保护你的应用。
缓存: 使用 Spring Cache 集成 EhCache, Redis 等缓存方案。
消息队列: 集成 RabbitMQ, Kafka 等消息队列。
微服务: 学习 Spring Cloud，构建分布式系统。
部署: 学习如何将应用部署到各种环境，如 Docker, Kubernetes, 云平台等。
自定义 Maven 配置: 学习如何在 pom.xml 中进行更高级的 Maven 配置，如多模块项目、自定义插件等。

第九章：总结

本教程详细介绍了如何使用 Maven 来构建和管理 Spring Boot 应用。我们从基础概念出发，逐步学习了环境搭建、项目创建（重点是 Spring Initializr）、项目结构、pom.xml 文件的理解（特别是 Parent POM 和 Starters）、编写第一个 Web 接口、运行与测试应用，以及常用的 Maven 命令和 Spring Boot 特性。

通过 Spring Boot 和 Maven 的结合，你可以极大地提高 Java 应用的开发效率。Spring Boot 负责简化配置和提供生产就绪特性，而 Maven 则提供了强大的依赖管理和标准化的构建流程。掌握这两者，你将能更轻松地构建稳定、可维护的 Java 应用。

记住，“纸上得来终觉浅，绝知此事要躬行”。最好的学习方式是动手实践，不断尝试和探索。现在，就去创建你的 Spring Boot 项目，并开始构建你的应用吧！

祝你编码愉快！

Spring Boot Maven 教程：从入门到实践

第一章：初识 Spring Boot 与 Maven

1.1 什么是 Spring Boot？

1.2 什么是 Maven？

1.3 Spring Boot 与 Maven 的结合

第二章：环境准备与项目创建

2.1 准备开发环境

2.2 创建 Spring Boot 项目

方法一：使用 Spring Initializr (Web UI) – 推荐新手使用

方法二：使用 Spring Initializr (命令行)

方法三：手动创建 Maven 项目并引入 Spring Boot 依赖

第三章：理解 Maven 项目结构与 pom.xml

3.1 标准的 Maven 项目结构

3.2 深入理解 pom.xml 文件

3.3 添加新的依赖

第四章：编写你的第一个 Web 接口

4.1 找到主应用类

4.2 创建一个简单的 Controller

4.3 代码结构

第五章：运行与测试应用

5.1 运行 Spring Boot 应用

方法一：使用 IDE 运行 (推荐开发时使用)

方法二：使用 Maven 插件运行

方法三：运行打包后的 JAR 文件 (模拟生产环境)

5.2 测试 Web 接口

使用浏览器：

使用 curl 命令：

使用 Postman 或类似工具：

第六章：常用 Maven 命令与 Spring Boot 特性

6.1 常用的 Maven 命令

6.2 配置应用端口

6.3 使用外部化配置

application.properties

6.4 DevTools 的热部署

第七章：打包与分发

7.1 理解可执行 JAR

7.2 执行打包命令

7.3 运行可执行 JAR

7.4 打包成 WAR 文件 (可选)

第八章：故障排除与进阶方向

8.1 常见问题排查

8.2 进阶方向

第九章：总结

发表评论 取消回复

第三章：理解 Maven 项目结构与 `pom.xml`

3.2 深入理解 `pom.xml` 文件

发表评论取消回复