Spring Boot Maven 快速入门：从零开始构建你的第一个应用

引言

在当今快节奏的软件开发领域，快速构建、部署和迭代应用程序是成功的关键。Java 生态系统中的 Spring 框架凭借其强大的功能和灵活性长期占据主导地位。然而，传统的 Spring 应用配置繁琐、依赖管理复杂，对于新手来说门槛较高。正是在这样的背景下，Spring Boot 应运而生，它以“约定优于配置”的理念，极大地简化了 Spring 应用的开发过程。

而 Maven，作为 Java 项目最流行的构建工具之一，提供了强大的依赖管理和标准化的构建生命周期。将 Spring Boot 与 Maven 结合，可以让你以前所未有的速度启动和运行一个功能完备的 Spring 应用。

本文将带领你从零开始，使用 Maven 创建一个简单的 Spring Boot 项目，详细讲解项目结构、核心配置、构建过程和运行方式，旨在帮助你快速掌握 Spring Boot + Maven 的开发流程。

为什么选择 Spring Boot 和 Maven？

在深入实践之前，我们先来理解为何 Spring Boot 和 Maven 是如此完美的组合。

Spring Boot 的优势

简化配置： Spring Boot 的核心理念是自动化配置。它会根据你项目中引入的依赖，自动配置大量的 Spring 组件，如数据源、Web 服务器、模板引擎等，极大地减少了手动配置 XML 或 Java Config 的工作量。
内嵌式服务器： Spring Boot 应用可以内嵌 Tomcat、Jetty 或 Undertow 等 Web 服务器，可以直接打包成可执行的 JAR 文件运行，无需额外安装和配置 Web 服务器。这简化了部署过程。
Starters（启动器）： Spring Boot 提供了一系列“starter”依赖，它们是预定义的依赖集合，包含了某个特定功能所需的全部依赖（包括传递性依赖）。例如，spring-boot-starter-web 包含了开发 Web 应用所需的一切依赖（Spring MVC, Tomcat, Jackson 等）。这解决了依赖管理的痛点，避免了版本冲突。
生产就绪特性： Spring Boot 提供了很多生产环境常用的功能，如健康检查、监控、外部化配置等。
无代码生成，无 XML 配置： Spring Boot 强调基于 Java Config 和注解，避免了繁琐的 XML 配置，代码更加清晰。

Maven 的优势

标准化的项目结构： Maven 定义了标准的项目目录结构（src/main/java, src/main/resources, src/test/java 等），使得项目结构清晰，易于理解和协作。
依赖管理： Maven 通过 pom.xml 文件管理项目的依赖。它可以自动从远程仓库下载依赖，处理依赖的版本冲突，并支持传递性依赖。这是 Maven 最核心和强大的功能之一。
构建生命周期： Maven 定义了一套标准的构建生命周期（validate, compile, test, package, verify, install, deploy 等）。通过简单的命令（如 mvn package）， Maven 会按照预定的顺序执行构建任务。
插件系统： Maven 的功能通过插件实现，这使得 Maven 具有很高的扩展性。Spring Boot 也提供了 Maven 插件来支持 Spring Boot 应用的构建和打包。
仓库管理： Maven 通过本地仓库、中央仓库和私有仓库来管理依赖，方便了项目的依赖查找和共享。

将 Spring Boot 的开发效率与 Maven 的构建和依赖管理能力结合，无疑是开发现代化 Java 应用的黄金组合。

准备工作

在开始创建项目之前，你需要确保你的开发环境中安装了必要的软件：

Java Development Kit (JDK): Spring Boot 3.x 要求 Java 17 或更高版本；Spring Boot 2.x 通常要求 Java 8 或更高版本。建议安装 Java 17 或更高版本。
- 验证安装：打开终端或命令行窗口，运行 java -version 和 javac -version，确认输出了正确的版本信息。
Maven: Spring Boot 推荐使用 Maven 3.5 或更高版本。
- 验证安装：打开终端或命令行窗口，运行 mvn -v，确认输出了 Maven 的版本信息。
集成开发环境 (IDE): 虽然不是必须的，但一个功能强大的 IDE（如 IntelliJ IDEA、Eclipse 或 VS Code）能极大地提高开发效率，它们通常内置了 Maven 和 Spring Boot 的支持。

如果你的环境中尚未安装这些工具，请先下载并安装它们。

创建第一个 Spring Boot 项目

创建 Spring Boot 项目有多种方式，最常用也是官方推荐的方式是使用 Spring Initializr。Spring Initializr 是一个 Web 工具，可以帮助你快速生成一个基本的 Spring Boot 项目骨架。

方式一：使用 Spring Initializr 网站 (start.spring.io)

这是最直观的方式。

打开浏览器，访问 https://start.spring.io/。
在页面上，你需要进行如下配置：
- Project: 选择 Maven Project。
- Language: 选择 Java。
- Spring Boot: 选择一个稳定的版本。通常选择最新稳定版本，但如果你有特定需求，可以选择旧版本。
- Project Metadata:
  - Group: 定义项目所在的组织或公司，通常使用域名倒序，例如 com.example。
  - Artifact: 定义项目的名称，例如 my-first-springboot-app。
  - Name: 默认与 Artifact 相同，可以修改为更友好的名称。
  - Description: 项目的简要描述。
  - Package name: 默认是 Group 和 Artifact 的组合，即 com.example.myfirstspringbootapp。这是主应用类所在的包名。
- Packaging: 选择 Jar。对于大多数 Web 应用，JAR 包是首选，因为它内嵌服务器，方便运行。WAR 包用于部署到外部的传统应用服务器（如 Tomcat, Jetty）。
- Java: 选择你本地安装的 Java 版本，建议与你验证的 JDK 版本一致。
Dependencies: 点击右侧的 Add Dependencies... 按钮，搜索并添加必要的依赖。对于一个基本的 Web 应用，你需要添加：
- Spring Web: 提供了构建 Web 应用（包括 RESTful 应用）所需的依赖，它会自动引入 Spring MVC 和内嵌的 Tomcat 服务器。
- Spring Boot DevTools: 这是一个可选的依赖，但强烈推荐添加。它提供了很多开发阶段有用的功能，如热部署（代码修改后应用自动重启或刷新）。
- Lombok: 也是可选的，一个非常流行的库，可以通过注解减少 Java 代码的样板代码（如 getter/setter, constructor）。
点击底部的 Generate 按钮。这将下载一个包含项目骨架的 ZIP 文件。
解压下载的 ZIP 文件到你的工作目录。

方式二：使用 IDE 的 Spring Initializr 集成

大多数现代 Java IDE 都内置了 Spring Initializr 的功能，可以让你直接在 IDE 中创建项目，无需访问 Web 页面。

IntelliJ IDEA:
1. 选择 File -> New -> Project...。
2. 在左侧选择 Spring Initializr。
3. 配置 Initializr 的 URL、项目 SDK。
4. 点击 Next。
5. 填写项目元数据（Group, Artifact 等）和项目类型（Maven）。
6. 点击 Next。
7. 选择 Spring Boot 版本和所需的依赖（Spring Web, DevTools 等）。
8. 点击 Next，然后指定项目存储位置。
9. 点击 Finish。
Eclipse (Spring Tool Suite – STS):
1. 选择 File -> New -> Spring Starter Project。
2. 填写项目元数据、选择类型（Maven）、Java 版本。
3. 点击 Next。
4. 选择 Spring Boot 版本和所需的依赖。
5. 点击 Finish。
VS Code (需要安装 Spring Boot Extension Pack):
1. 打开命令面板 (Ctrl+Shift+P 或 Cmd+Shift+P)。
2. 搜索并选择 Spring Initializr: Create a Maven Project。
3. 按照提示选择 Spring Boot 版本、项目语言、Group ID, Artifact ID, Dependencies 等。
4. 选择项目保存位置。

使用 IDE 集成创建项目通常更加便捷，且能自动将项目导入到工作空间。无论使用哪种方式，最终你都会得到一个具有标准 Maven 结构的 Spring Boot 项目文件夹。

项目结构解析

解压下载的 ZIP 文件或通过 IDE 创建项目后，你会看到类似如下的目录结构：

my-first-springboot-app/ ├── .mvn/ │ └── wrapper/ │ ├── maven-wrapper.jar │ └── maven-wrapper.properties ├── src/ │ ├── main/ │ │ ├── java/ │ │ │ └── com/ │ │ │ └── example/ │ │ │ └── myfirstspringbootapp/ │ │ │ └── MyFirstSpringbootAppApplication.java <-- 主应用类 │ │ └── resources/ │ │ ├── application.properties <-- 配置文件 │ │ ├── static/ <-- 静态资源 (HTML, CSS, JS) │ │ └── templates/ <-- 模板文件 (Thymeleaf, FreeMarker) │ └── test/ │ └── java/ │ └── com/ │ └── example/ │ └── myfirstspringbootapp/ │ └── MyFirstSpringbootAppApplicationTests.java <-- 测试类 ├── .gitignore <-- Git 忽略文件 ├── mvnw <-- Maven Wrapper 脚本 (Linux/macOS) ├── mvnw.cmd <-- Maven Wrapper 脚本 (Windows) └── pom.xml <-- Maven 项目对象模型文件 (核心配置文件)

让我们简单介绍一下这些目录和文件：

.mvn/wrapper: 包含 Maven Wrapper 文件。Maven Wrapper 允许你在没有预先安装 Maven 的机器上执行 Maven 命令，它会自动下载并使用指定版本的 Maven。mvnw (或 mvnw.cmd) 脚本就是用来执行 Maven 命令的。
src/main/java: 存放项目的 Java 源代码。按照 Maven 约定，源代码位于此目录下，并按包名组织。
src/main/resources: 存放项目的资源文件，如配置文件 (application.properties/application.yml)、静态资源 (static 目录)、模板文件 (templates 目录) 等。这些资源文件在项目打包后会被复制到 classpath 的根目录。
src/test/java: 存放项目的测试源代码。与主代码类似，按包名组织。Spring Boot Initializr 会生成一个基本的集成测试类。
.gitignore: 如果你使用 Git 进行版本控制，这个文件定义了哪些文件和目录应该被忽略，例如编译生成的文件、日志文件等。
mvnw, mvnw.cmd: Maven Wrapper 执行脚本。
pom.xml: 这是 Maven 项目的核心配置文件，Project Object Model（项目对象模型）。它定义了项目的基本信息、依赖、构建方式、插件等。我们将重点分析这个文件。

深入理解 pom.xml

pom.xml 文件是 Maven 项目的灵魂，它描述了项目的方方面面。一个 Spring Boot 项目的 pom.xml 通常包含以下关键部分：

“`xml

4.0.0

<!-- 1. 父项目 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version> <!-- 这里的版本与你在 Initializr 中选择的 Spring Boot 版本一致 -->
    <relativePath/> <!-- lookup parent from repository -->
</parent>

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

<!-- 3. 项目属性 -->
<properties>
    <java.version>17</java.version> <!-- 指定 Java 版本 -->
</properties>

<!-- 4. 依赖管理 -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 如果你添加了 DevTools -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <!-- 如果你添加了 Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

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

<!-- 5. 构建配置 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <!-- 如果你添加了 Lombok，这里可能需要配置 lombok 的版本 -->
             <configuration>
                <excludes>
                    <exclude>
                        <groupId>org.projectlombok</groupId>
                        <artifactId>lombok</artifactId>
                    </exclude>
                </excludes>
            </configuration>
        </plugin>
    </plugins>
</build>

“`

我们逐一解释各个部分：

<parent>:
- 这是 Spring Boot Maven 项目最关键的部分之一。它继承自 spring-boot-starter-parent 项目。
- spring-boot-starter-parent 是一个特殊的 Maven POM，它本身不包含任何代码，主要作用是进行依赖管理。
- 它定义了许多常用第三方库（如 Spring, Jackson, Hibernate, Tomcat 等）的稳定版本号，并在其 <dependencyManagement> 部分进行统一管理。
- 当你在子项目中引用这些库时，通常无需指定版本号。Maven 会自动使用父 POM 中定义或推荐的版本。这极大地简化了依赖管理，避免了版本冲突。
- 它还定义了许多常用的 Maven 插件的默认配置，例如 Java 编译版本、资源文件编码等。
- 这里的 <version> 标签指定了你使用的 Spring Boot 版本。
- <relativePath/> 表示如果 Maven 在本地仓库找不到父 POM，就不要在文件系统中查找，只从远程仓库查找。
项目基本信息:
- <groupId>, <artifactId>, <version>: 这是 Maven 项目的唯一坐标。它们一起标识了一个特定的项目版本。
  - groupId: 通常代表公司或组织的唯一标识符，比如域名倒序。
  - artifactId: 项目的名称。
  - version: 项目的当前版本。-SNAPSHOT 后缀表示这是一个开发中的快照版本。
- <name>: 项目的友好名称。
- <description>: 项目的简要描述。
<properties>:
- 这个部分允许你定义一些属性，这些属性可以在 POM 的其他地方引用（使用 ${propertyName} 的语法）。
- java.version: 定义了项目使用的 Java 编译版本。Spring Boot Starter Parent 会根据这个属性配置 Maven 编译器插件。
<dependencies>:
- 这个部分列出了项目直接依赖的所有库。
- 每个 <dependency> 标签定义一个依赖。
- spring-boot-starter-web: 这是 Spring Boot 提供的 Web 开发启动器。如前所述，它会自动引入 Spring Core、Spring MVC、嵌入式 Tomcat、Jackson 等一系列开发 Web 应用所需的依赖。注意这里没有指定 <version>，因为版本由父 POM spring-boot-starter-parent 统一管理。
- spring-boot-devtools: 开发工具启动器。scope 设置为 runtime 且 optional 设置为 true 是为了防止它被包含在最终的 JAR 包中（仅在开发时启用）。
- lombok: 如果选择了，会被包含在这里。同样通常设置为 optional true。注意，使用 Lombok 需要在 IDE 中安装相应的插件。
- spring-boot-starter-test: 测试启动器。scope 设置为 test 表示这个依赖只在测试阶段需要，不会被包含在最终的运行时 JAR 包中。它包含了 Spring Test、JUnit、Mockito 等测试框架和库。
<build>:
- 这个部分配置项目的构建行为，最重要的是定义了构建过程中使用的插件。
- <plugins>: 包含构建过程中使用的 Maven 插件列表。
- spring-boot-maven-plugin: 这是 Spring Boot 项目特有的核心插件。
  - 它的主要目标是重新打包项目 JAR/WAR 文件，使其成为一个可执行的 JAR/WAR。它会将项目依赖的库嵌入到最终的 JAR 文件中，并在 META-INF/MANIFEST.MF 文件中指定启动类，从而可以通过 java -jar 命令直接运行。
  - 它还提供了一些便捷的目标（goals），如 spring-boot:run（直接运行应用）、spring-boot:build-info（生成构建信息）。
  - 如果你使用了 Lombok，可能需要在 <configuration> 中添加 <excludes> 来排除 Lombok，这是为了避免在最终的可执行 JAR 中包含 Lombok 注解处理器相关的元数据，通常不是必须的，但可以避免潜在问题。

理解了 pom.xml 的结构和内容，你就掌握了 Spring Boot Maven 项目的依赖和构建核心。

主应用类解析

打开 src/main/java 下的你的主应用类，例如 MyFirstSpringbootAppApplication.java。你会看到类似如下的代码：

“`java
package com.example.myfirstspringbootapp;

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

@SpringBootApplication
public class MyFirstSpringbootAppApplication {

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

}
“`

这看起来非常简洁，但包含了启动 Spring Boot 应用所需的关键元素：

package com.example.myfirstspringbootapp;: 定义了类所在的包。
import ...: 导入必要的 Spring 类。
@SpringBootApplication: 这是 Spring Boot 应用的核心注解。 这是一个组合注解，等价于以下三个注解：
- @Configuration: 将当前类标记为一个配置类，可以用来定义 Spring Bean。
- @EnableAutoConfiguration: 启用 Spring Boot 的自动配置机制。Spring Boot 会根据项目中引入的依赖，自动推断并配置所需的 Spring Bean。例如，如果引入了 spring-boot-starter-web，它会自动配置 Tomcat 和 Spring MVC。
- @ComponentScan: 启用组件扫描。默认情况下，它会扫描当前包及其子包下的所有 Spring 组件（如 @Component, @Service, @Repository, @Controller 等），并将它们注册为 Spring Bean。因此，你的应用组件应该放在主应用类所在的包或其子包下。
public class MyFirstSpringbootAppApplication: 定义了应用的主类。
public static void main(String[] args): Java 应用程序的入口方法。
SpringApplication.run(MyFirstSpringbootAppApplication.class, args);: 这是启动 Spring Boot 应用的关键代码。
- SpringApplication 是一个类，它提供了一种方便的方式来引导 Spring 应用。
- run() 方法用于启动 Spring 应用上下文。它会执行以下操作：
  - 创建一个合适的 ApplicationContext 实例（对于 Web 应用通常是 AnnotationConfigServletWebServerApplicationContext）。
  - 注册配置类（这里是 MyFirstSpringbootAppApplication.class）。
  - 执行自动配置 (@EnableAutoConfiguration)。
  - 执行组件扫描 (@ComponentScan)。
  - 加载和处理外部化配置（application.properties 等）。
  - 启动内嵌的 Web 服务器（如果引入了 Web 启动器）。
  - 执行命令行运行器 (CommandLineRunner) 和应用运行器 (ApplicationRunner)。
  - 返回配置好的 ApplicationContext。

只需要一个 @SpringBootApplication 注解和一个简单的 main 方法，你就可以启动一个功能完备的 Spring 应用！

添加一个简单的 Web 接口

光有一个启动类还不够，我们需要添加一些功能来验证应用是否正常工作。作为一个 Web 应用，最常见的起点是添加一个简单的 REST 接口。

在主应用类 MyFirstSpringbootAppApplication.java 所在的包 (com.example.myfirstspringbootapp) 或其子包下，创建一个新的 Java 类，例如 HelloController.java。
编写如下代码：

“`java
package com.example.myfirstspringbootapp; // 确保包名与你的项目一致

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

@RestController // 1. 组合注解，表明这是一个处理 HTTP 请求的 Controller，且方法的返回值直接作为响应体
public class HelloController {

@GetMapping("/hello") // 2. 将 hello() 方法映射到 HTTP GET 请求的 /hello 路径
public String hello() { // 3. 方法返回一个字符串
    return "Hello, Spring Boot with Maven!"; // 4. 返回的字符串将作为 HTTP 响应体
}

}
“`

代码解释：

@RestController: 这是 Spring MVC 提供的注解，标记这是一个 REST 控制器。它是 @Controller 和 @ResponseBody 的组合注解。@Controller 标记类为 Spring MVC 控制器，@ResponseBody 标记方法的返回值直接作为 HTTP 响应体（而不是视图名称）。
@GetMapping("/hello"): 这是 Spring MVC 提供的注解，用于处理 HTTP GET 请求。它将 hello() 方法映射到 /hello 这个 URL 路径。当收到对 /hello 的 GET 请求时，Spring MVC 会调用 hello() 方法。
public String hello(): 定义了一个公共方法，返回类型为 String。
return "Hello, Spring Boot with Maven!";: 方法返回一个字符串。由于使用了 @RestController，这个字符串会被写入 HTTP 响应体，并发送给客户端。

这个简单的控制器类将被 @SpringBootApplication 的 @ComponentScan 扫描到，并作为 Spring Bean 注册到应用上下文中。

使用 Maven 构建和运行应用

现在我们已经有了完整的项目代码，可以使用 Maven 来构建和运行它了。

打开终端或命令行窗口，进入到项目根目录 (my-first-springboot-app/)。

1. 构建项目

使用 Maven Wrapper 脚本执行 package 目标：

bash ./mvnw clean package

./mvnw: 在 Linux/macOS 系统中使用 Maven Wrapper 脚本。在 Windows 系统中使用 mvnw.cmd。如果你全局安装了 Maven，也可以直接使用 mvn clean package。使用 Wrapper 的好处是确保使用了项目指定的 Maven 版本。
clean: 这是 Maven 生命周期的一个阶段。它会清理 target 目录下的所有构建生成的文件。
package: 这是 Maven 构建生命周期的另一个阶段。它会执行从 validate 到 package 阶段的所有任务，包括：
- 编译主代码 (compile)
- 运行单元测试 (test)
- 编译测试代码
- 将编译后的类文件、资源文件等打包成一个 JAR/WAR 文件 (package)。
- Spring Boot Maven 插件会在标准的 package 阶段之后，自动执行 repackage 目标，将项目打成一个可执行的 JAR 包。

执行命令后，Maven 会下载所需的依赖（如果本地仓库没有），编译代码，运行测试，并最终在项目的 target 目录下生成一个可执行的 JAR 文件，文件名为 my-first-springboot-app-0.0.1-SNAPSHOT.jar (根据你的项目 ArtifactId 和 Version 变化)。

查找 target 目录，你会发现生成的 JAR 文件。

2. 运行应用

使用 java -jar 命令运行生成的可执行 JAR 文件：

bash java -jar target/my-first-springboot-app-0.0.1-SNAPSHOT.jar

命令执行后，你会看到 Spring Boot 的 Logo（Banner），以及应用启动的日志信息。日志中会显示 Spring Bean 的加载过程、嵌入式 Web 服务器（Tomcat）的启动信息，以及监听的端口号（默认是 8080）。

`` . ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _ | \ \ \ \
\/ )| |)| | | | | || (_| | ) ) ) )
‘ || .__|| ||| |_, | / / / /
=========|_|==============|/=///_/
:: Spring Boot :: (v3.2.0) <– Spring Boot 版本

… (省略其他日志) …

INFO … : Tomcat started on port(s): 8080 (http) with context path ”
INFO … : Started MyFirstSpringbootAppApplication in X.XXX seconds (process running for Y.YYY)
“`

这表示你的 Spring Boot 应用已经成功启动，并且内嵌的 Tomcat 服务器正在监听 8080 端口。

3. 测试 Web 接口

应用启动后，你可以使用浏览器或命令行工具（如 curl）来访问我们创建的 /hello 接口。

在浏览器中访问：http://localhost:8080/hello

或者使用 curl 命令：

bash curl http://localhost:8080/hello

你应该会看到浏览器页面显示或者 curl 命令输出：

Hello, Spring Boot with Maven!

恭喜你！你已经成功创建、构建并运行了你的第一个 Spring Boot Maven 应用，并成功访问了你编写的 Web 接口。

要停止应用，只需在运行应用的终端窗口按下 Ctrl+C。

使用 Maven 插件直接运行 (开发阶段)

除了打包后运行 JAR，Spring Boot Maven Plugin 还提供了一个方便的 spring-boot:run 目标，可以直接在开发阶段运行应用，无需先打包：

bash ./mvnw spring-boot:run

这个命令会编译代码并直接启动应用，通常用于开发和调试阶段，因为它可以更快地启动，并且配合 DevTools 可以实现热重载。

配置应用程序

Spring Boot 提供了灵活的外部化配置方式。最常用的配置文件是 application.properties 或 application.yml，它们位于 src/main/resources 目录下。

例如，如果你想修改应用启动的端口号（默认是 8080），可以编辑 src/main/resources/application.properties 文件，添加如下一行：

properties server.port=8081

保存文件后，重新运行应用 (./mvnw spring-boot:run 或重新打包再运行)，你会发现应用现在监听的是 8081 端口。

你可以在 application.properties 或 application.yml 中配置各种 Spring Boot 和第三方库的属性。Spring Boot 文档提供了详细的常见配置列表。

IDE 集成 (提升效率)

虽然可以使用命令行进行构建和运行，但集成开发环境 (IDE) 能极大地提升开发效率。现代 IDE 对 Spring Boot 和 Maven 都有非常好的支持。

项目导入： 通过 IDE 的导入功能，可以直接导入一个 Maven 项目（选择项目根目录下的 pom.xml 文件）。IDE 会自动识别 Maven 项目结构，下载依赖。
依赖管理： IDE 会根据 pom.xml 显示依赖树，方便你查看依赖关系和冲突。修改 pom.xml 后，IDE 会自动提示重新加载 Maven 项目以同步更改。
代码编辑： 提供语法高亮、代码补全、错误检查、重构等功能。
运行和调试： IDE 可以直接运行 Spring Boot 应用的主类 (main 方法)，支持断点调试。许多 IDE 甚至提供了专门的 Spring Boot 运行配置。
Spring Bean 导航： 高级 IDE（如 IntelliJ IDEA Ultimate 或 STS）可以识别 Spring 组件，并提供 Spring Bean 之间的导航功能。
Maven 目标执行： IDE 通常提供一个 Maven 面板/视图，你可以直接在 IDE 中点击执行 Maven 的各个目标（clean, compile, package, install, test, spring-boot:run 等），无需切换到命令行。

强烈建议在开发 Spring Boot 应用时使用 IDE。

总结与展望

通过本文的学习，你已经掌握了使用 Spring Boot 和 Maven 快速构建一个基础 Web 应用的流程：

准备环境： 确保安装了 JDK 和 Maven。
创建项目： 使用 Spring Initializr 快速生成项目骨架，选择 Maven 和必要的 Starter 依赖（如 Spring Web）。
理解项目结构： 熟悉 Maven 标准目录结构和核心配置文件 pom.xml。
解析 pom.xml： 深入理解 Spring Boot Parent POM、Starter 依赖、依赖管理以及 Spring Boot Maven 插件的作用。
理解主应用类： 掌握 @SpringBootApplication 注解和 SpringApplication.run() 方法的工作原理。
添加功能： 编写简单的 Controller 类和方法来处理 Web 请求。
构建与运行： 使用 Maven 命令 mvn clean package 打包项目，使用 java -jar 或 mvn spring-boot:run 运行可执行 JAR 包。
测试接口： 验证你的 Web 接口是否按预期工作。
了解配置： 知道如何通过 application.properties 文件修改应用配置。
利用 IDE： 认识到 IDE 集成对开发效率的提升。

这仅仅是 Spring Boot 和 Maven 功能的冰山一角。基于这个基础，你可以继续学习和探索更多高级特性：

其他 Starter 依赖： 添加数据库访问 (JPA/JDBC)、安全性 (Spring Security)、消息队列 (Kafka/RabbitMQ)、缓存、日志等功能。
更复杂的 Web 功能： 构建 RESTful API、处理 POST/PUT/DELETE 请求、参数校验、异常处理。
数据访问： 集成 Spring Data JPA 或 MyBatis 访问关系型数据库，或使用 Spring Data MongoDB/Redis 等访问 NoSQL 数据库。
单元测试和集成测试： 学习如何使用 spring-boot-starter-test 进行有效的测试。
Profiles： 定义不同环境（开发、测试、生产）的配置。
监控与管理： 使用 Spring Boot Actuator 监控和管理应用。
部署： 将你的 Spring Boot 应用部署到 Docker、Kubernetes、云平台或其他服务器。
Maven 高级用法： 学习 Maven 生命周期、插件配置、自定义 Profile、聚合/继承项目等。

Spring Boot 和 Maven 的结合，为现代 Java 应用开发提供了一个强大、高效且标准化的框架。希望这篇详细的入门指南能够帮助你迈出 Spring Boot 开发的第一步，并激发你继续深入学习的热情！祝你在 Spring Boot 的世界中开发愉快！

Spring Boot Maven快速入门 – wiki基地

Spring Boot Maven 快速入门：从零开始构建你的第一个应用

引言

为什么选择 Spring Boot 和 Maven？

Spring Boot 的优势

Maven 的优势

准备工作

创建第一个 Spring Boot 项目

方式一：使用 Spring Initializr 网站 (start.spring.io)

方式二：使用 IDE 的 Spring Initializr 集成

项目结构解析

深入理解 pom.xml

主应用类解析

添加一个简单的 Web 接口

使用 Maven 构建和运行应用

1. 构建项目

2. 运行应用

3. 测试 Web 接口

使用 Maven 插件直接运行 (开发阶段)

配置应用程序

IDE 集成 (提升效率)

总结与展望

发表评论取消回复

Spring Boot Maven 快速入门：从零开始构建你的第一个应用

引言

为什么选择 Spring Boot 和 Maven？

Spring Boot 的优势

Maven 的优势

准备工作

创建第一个 Spring Boot 项目

方式一：使用 Spring Initializr 网站 (start.spring.io)

方式二：使用 IDE 的 Spring Initializr 集成

项目结构解析

深入理解 pom.xml

主应用类解析

添加一个简单的 Web 接口

使用 Maven 构建和运行应用

1. 构建项目

2. 运行应用

3. 测试 Web 接口

使用 Maven 插件直接运行 (开发阶段)

配置应用程序

IDE 集成 (提升效率)

总结与展望

发表评论 取消回复

发表评论取消回复