Spring Boot Maven 基础教程 – wiki基地

作者： /

Spring Boot Maven 基础教程：从入门到精通

欢迎来到 Spring Boot 的世界！如果你是一名 Java 开发者，或者正打算进入 Java 开发领域，那么 Spring Boot 几乎是你绕不开的技术栈。它以“约定优于配置”的理念，极大地简化了 Spring 应用程序的搭建和开发过程。而 Maven，作为 Java 世界里最流行的项目管理和构建工具之一，是 Spring Boot 项目的绝佳搭档。

本篇文章将带你深入了解 Spring Boot 和 Maven，从零开始创建一个 Spring Boot 项目，理解项目结构，配置依赖，最终学会如何构建和运行你的第一个 Spring Boot 应用程序。我们将尽可能详细地讲解每个步骤和背后的原理，力求让你不仅知其然，更能知其所以然。

文章结构如下：

  1. 引言：为什么选择 Spring Boot 和 Maven？
    • Spring Boot 的魅力：快速开发与简化配置
    • Maven 的作用：依赖管理与项目构建
    • 强强联合：Spring Boot 与 Maven
  2. 环境准备：工欲善其事，必先利其器
    • 安装 Java Development Kit (JDK)
    • 安装 Maven
    • 选择一款趁手的集成开发环境 (IDE)
  3. 初探 Spring Boot Maven 项目结构
    • 理解标准的 Maven 项目目录结构
    • 核心文件解析：pom.xml 的重要性
  4. 创建你的第一个 Spring Boot Maven 项目
    • 方法一：使用 Spring Initializr (推荐)
      • 在线创建步骤详解
      • 生成项目并导入 IDE
    • 方法二：手动搭建 (了解原理)
      • 创建基础目录结构
      • 编写基础 pom.xml
      • 创建主应用程序类
  5. 深入理解 pom.xml 文件
    • Maven Coordinates (坐标)：groupId, artifactId, version
    • <parent>：Spring Boot 父项目
      • 继承的好处：统一版本管理与默认配置
    • <properties>：定义属性
    • <dependencies>：依赖管理
      • 什么是 Starter？以 spring-boot-starter-web 为例
      • 传递性依赖
    • <build>：构建配置
      • <plugins>：插件的使用
      • spring-boot-maven-plugin：构建可执行 Jar
  6. 编写你的第一个 Spring Boot 应用：Hello World 接口
    • 主应用程序类 (@SpringBootApplication)
      • @Configuration, @EnableAutoConfiguration, @ComponentScan 的作用
      • SpringApplication.run() 方法
    • 创建一个简单的 REST Controller (@RestController, @GetMapping)
  7. 构建与运行 Spring Boot 项目
    • 在 IDE 中直接运行
    • 使用 Maven 命令行运行
      • mvn clean
      • mvn compile
      • mvn test
      • mvn package (生成可执行 Jar)
      • mvn spring-boot:run (开发阶段快捷运行)
    • 运行生成的可执行 Jar
  8. 测试你的 Hello World 接口
    • 使用浏览器或 curl 命令
  9. 进一步探索 (拓展)
    • 添加更多 Starter (如 spring-boot-starter-data-jpa, spring-boot-starter-test)
    • 外部化配置 (application.properties/application.yml)
    • 集成测试
  10. 总结

1. 引言：为什么选择 Spring Boot 和 Maven？

在 Java 企业级开发领域，Spring 框架因其强大的功能、灵活的配置和庞大的生态系统而占据主导地位。然而，传统的 Spring 应用配置通常比较繁琐，特别是 XML 配置，使得项目搭建和维护成本较高。

Spring Boot 的魅力：快速开发与简化配置

Spring Boot 应运而生，旨在解决传统 Spring 应用的痛点。它遵循“约定优于配置”的原则，提供了大量的自动化配置，使得开发者可以快速搭建独立的、生产级别的 Spring 应用程序。Spring Boot 的核心特性包括：

  • 自动化配置 (Auto-configuration): 根据项目中存在的依赖，自动配置 Spring 应用程序的大部分功能，无需手动编写大量的配置代码。
  • Starter 依赖 (Starter Dependencies): 提供一系列预配置的依赖集合，例如 spring-boot-starter-web 包含了构建 Web 应用所需的所有常用依赖，极大地简化了依赖管理。
  • 嵌入式服务器 (Embedded Servers): 内嵌 Tomcat, Jetty 或 Undertow 等 Web 服务器，无需单独部署 War 包到应用服务器，可以直接运行 Jar 包。
  • 开箱即用: 提供很多生产环境常用的功能，如监控、健康检查等。

这些特性让开发者能够更专注于业务逻辑的实现，而不是繁琐的配置。

Maven 的作用：依赖管理与项目构建

Maven 是一个强大的项目管理和理解工具。它基于项目对象模型（Project Object Model, POM）的概念，通过一个中心化的方式来管理项目的构建、报告和文档。Maven 的主要功能包括：

  • 依赖管理 (Dependency Management): 自动下载、管理和传递项目所需的各种第三方库（Jar 文件）。你只需要在 pom.xml 文件中声明项目的依赖，Maven 会负责解决它们的下载、版本冲突等问题。
  • 项目构建 (Project Build): 定义了一套标准的生命周期（如编译、测试、打包、安装、部署），并提供了执行这些阶段的命令。
  • 项目信息管理: 在 pom.xml 中定义项目的各种信息（如项目名称、版本、开发者信息等）。
  • 插件体系 (Plugin System): Maven 的核心功能都是通过插件实现的，这使得 Maven 具有很强的扩展性。

强强联合：Spring Boot 与 Maven

Spring Boot 和 Maven 的结合是现代 Java 企业级开发的黄金搭档。Spring Boot 利用 Maven 标准的项目结构和强大的依赖管理能力来构建项目，而 Spring Boot 本身又提供了许多 Maven 插件（如 spring-boot-maven-plugin）来简化构建过程，例如生成可执行的 Jar 包。

Maven 负责项目的骨架、依赖的管理和标准化的构建流程；Spring Boot 则负责简化 Spring 框架的配置和应用启动。两者协同工作，使得 Java 应用的开发效率大大提升。

2. 环境准备：工欲善其事，必先利其器

在开始创建 Spring Boot 项目之前，你需要确保开发环境已经搭建好。

安装 Java Development Kit (JDK)

Spring Boot 支持不同版本的 Java。为了兼容性和新特性，建议安装 JDK 8 或更高版本（例如 JDK 11 或 JDK 17）。你可以从 Oracle 官网或 OpenJDK 官网下载适合你操作系统的安装包，并按照指引进行安装。安装完成后，确保 JAVA_HOME 环境变量已设置，并且 java 和 javac 命令可以在命令行中执行。

在命令行输入：
bash
java -version
javac -version
如果显示版本信息，说明 JDK 安装成功。

安装 Maven

访问 Maven 官方网站 (https://maven.apache.org/download.cgi) 下载最新版本的 Maven 二进制发行版。下载后解压到一个目录，例如 C:\apache-maven-x.y.z (Windows) 或 /usr/local/apache-maven-x.y.z (Linux/macOS)。

接下来，你需要设置 Maven 的环境变量：

  • 创建一个名为 M2_HOME 或 MAVEN_HOME 的环境变量，指向 Maven 的安装目录。
  • 将 %M2_HOME%\bin (Windows) 或 $M2_HOME/bin (Linux/macOS) 添加到系统的 PATH 环境变量中。

设置完成后，打开新的命令行窗口，输入：
bash
mvn -v
如果显示 Maven 的版本信息、Java 版本和操作系统信息，说明 Maven 安装成功。

选择一款趁手的集成开发环境 (IDE)

虽然可以使用任何文本编辑器和命令行来开发 Spring Boot 项目，但使用一款功能强大的 IDE 会极大地提高开发效率。流行的 Java IDE 包括：

  • IntelliJ IDEA: 社区版免费，旗舰版收费。对 Spring Boot 和 Maven 的支持非常完善，功能强大。
  • Eclipse: 免费开源。需要安装 Spring Tools 4 (STS) 插件来获得更好的 Spring Boot 支持。
  • VS Code: 免费开源。需要安装 Java 扩展包和 Spring Boot 扩展。

本书后续将主要以 IntelliJ IDEA 为例进行说明，但概念和操作在其他 IDE 中也是类似的。

3. 初探 Spring Boot Maven 项目结构

一个标准的 Maven 项目遵循特定的目录结构，这使得项目的组织更加清晰和标准化。Spring Boot 项目通常也会沿用这一结构。

理解标准的 Maven 项目目录结构

创建一个 Maven 项目后，你会看到类似以下的目录结构：

my-spring-boot-app/
├── pom.xml <-- 项目对象模型文件，核心配置文件
├── src/ <-- 源代码根目录
│ ├── main/ <-- 主要源代码
│ │ ├── java/ <-- Java 源代码 (.java)
│ │ └── resources/ <-- 资源文件 (如配置文件, 模板文件等)
│ └── test/ <-- 测试源代码
│ ├── java/ <-- 测试 Java 源代码 (.java)
│ └── resources/ <-- 测试资源文件
└── target/ <-- 构建输出目录 (mvn package 后生成，包含编译后的类、jar 包等)

  • src/main/java: 存放项目的 Java 源代码。
  • src/main/resources: 存放项目所需的各种资源文件，如 application.properties 或 application.yml (Spring Boot 的配置文件)、日志配置文件、模板文件等。
  • src/test/java: 存放项目的测试代码，如单元测试、集成测试等。
  • src/test/resources: 存放测试所需的资源文件。
  • target: 这是 Maven 构建输出的目录，编译后的 .class 文件、生成的 Jar/War 包等都会放在这里。这个目录通常不需要纳入版本控制。
  • pom.xml: 这是 Maven 项目的核心配置文件，包含了项目的元信息、依赖声明、构建配置等。

核心文件解析：pom.xml 的重要性

pom.xml (Project Object Model) 文件是整个 Maven 项目的灵魂。它是一个 XML 文件，定义了项目的几乎所有方面。理解 pom.xml 是使用 Maven 和 Spring Boot 的关键。我们将在后面的章节中详细解析它的内容。

4. 创建你的第一个 Spring Boot Maven 项目

有两种主要的方式来创建一个 Spring Boot Maven 项目：使用 Spring Initializr (推荐) 或手动搭建。对于初学者，强烈建议使用 Spring Initializr，因为它能自动为你生成一个符合最佳实践的、包含基本配置和依赖的项目骨架。

方法一：使用 Spring Initializr (推荐)

Spring Initializr 是一个 Web 工具，可以帮助你快速生成 Spring Boot 项目的骨架。大多数现代 IDE 都集成了 Spring Initializr 的功能。

访问 Spring Initializr 网站: https://start.spring.io/

页面上会有一些配置选项：

  1. Project: 选择构建工具。这里我们选择 Maven Project。
  2. Language: 选择编程语言。通常选择 Java。
  3. Spring Boot: 选择 Spring Boot 版本。建议选择一个稳定、非 SNAPSHOT 版本（通常会标记推荐版本）。
  4. Project Metadata:
    • Group: 组织ID，通常是公司或组织的域名倒写，例如 com.example。
    • Artifact: 项目ID，项目的名称，例如 my-spring-boot-app。
    • Name: 项目的显示名称，默认为 Artifact ID。
    • Description: 项目的描述。
    • Package name: Java 包名，默认为 Group ID + Artifact ID。
    • Packaging: 打包方式。对于可执行的 Spring Boot 应用，通常选择 Jar。War 包用于部署到传统的应用服务器。
    • Java: 选择 JDK 版本，与你的安装版本一致或更低。
  5. Dependencies: 添加项目所需的依赖。点击 “Add Dependencies…” 按钮。对于一个基础的 Web 应用，我们需要添加：
    • 搜索 “Web” 并选择 Spring Web: 这个 Starter 会引入 Spring MVC 和嵌入式 Web 服务器（默认为 Tomcat）。

配置完成后，页面可能看起来像这样（以示例值填充）：

  • Project: Maven Project
  • Language: Java
  • Spring Boot: 3.x.x (推荐版本)
  • Group: com.example
  • Artifact: my-spring-boot-app
  • Name: my-spring-boot-app
  • Description: Demo project for Spring Boot
  • Package name: com.example.myspringbootapp
  • Packaging: Jar
  • Java: 17 (与你安装的 JDK 版本一致)
  • Dependencies: Spring Web

点击右侧的 “Generate” 按钮。这将下载一个包含项目骨架的 .zip 文件。

生成项目并导入 IDE

下载 .zip 文件后，解压到你的工作目录。

打开你的 IDE (如 IntelliJ IDEA)，选择 “File” -> “Open” (或 “Import Project”)，然后导航到你解压的项目根目录，选择 pom.xml 文件或整个项目目录，并确认导入。IDE 会识别这是一个 Maven 项目，并自动下载所需的依赖。这个过程可能需要一些时间，取决于你的网络状况。

导入成功后，IDE 会显示项目的目录结构，并可能提示你进行一些配置（如选择 JDK）。

方法二：手动搭建 (了解原理)

虽然不推荐初学者使用手动搭建，但了解这个过程有助于理解 Spring Boot Maven 项目的核心构成。

  1. 创建项目目录: 创建一个根目录，例如 manual-spring-boot-app。
  2. 创建 pom.xml: 在根目录下创建 pom.xml 文件，并手动填写基础内容。这是最关键的一步。
  3. 创建源代码目录: 按照 Maven 标准创建 src/main/java 和 src/main/resources 目录。
  4. 创建主应用程序类: 在 src/main/java 下按照你的包名创建相应的子目录，并在其中创建一个 Java 类，包含 main 方法和 @SpringBootApplication 注解。

手动编写 pom.xml 需要包含 Spring Boot 的父项目依赖、Spring Boot Maven 插件以及至少一个 Starter 依赖。这相对复杂，容易出错，所以 Spring Initializr 是更好的选择。

5. 深入理解 pom.xml 文件

我们现在来详细剖析由 Spring Initializr 生成的 pom.xml 文件。

“`xml


4.0.0

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

<!-- 2. 项目坐标 -->
<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>

<!-- 3. 属性 -->
<properties>
    <java.version>17</java.version> <!-- 与你在 Initializr 选择的 JDK 版本一致 -->
</properties>

<!-- 4. 依赖 -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- 测试依赖，Initializr 默认会添加 -->
    <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>
        </plugin>
    </plugins>
</build>

“`

我们逐一解析其中的重要标签：

  • <project>...</project>: pom.xml 的根元素。
  • <modelVersion>4.0.0</modelVersion>: 指定 POM 模型版本，目前固定是 4.0.0。

1. <parent>：Spring Boot 父项目

这是 Spring Boot 项目 pom.xml 中非常重要的一个部分。通过继承 <spring-boot-starter-parent>，你的项目就拥有了 Spring Boot 项目的许多特性。

  • <groupId>, <artifactId>, <version>: 这三个元素组成了父项目的坐标。
  • <relativePath/>: 表示从本地仓库查找父项目，而不是从文件系统中查找。

继承 <spring-boot-starter-parent> 的好处：

  • 统一版本管理 (Dependency Management): 父项目定义了一个巨大的依赖版本清单 (Bill of Materials, BOM)。这意味着对于大多数常用的 Spring 及相关第三方库，你只需要在 <dependencies> 中写出 groupId 和 artifactId，无需指定 <version>。Maven 会根据父项目管理的版本自动解析，避免了版本冲突问题。例如，你添加 spring-web 依赖时，不需要指定版本号，因为父项目已经规定了它应该是什么版本。
  • 默认配置: 父项目提供了一些默认的 Maven 插件配置，例如 Java 编译版本、资源文件过滤等。
  • Spring Boot Maven 插件配置: 父项目预配置了 spring-boot-maven-plugin 插件，这是构建可执行 Jar 的关键。

2. 项目坐标 (Maven Coordinates)

  • <groupId>...</groupId>: 定义项目所属的组织或团体。通常是公司或组织的域名倒写，例如 com.yourcompany。这是强制要求的。
  • <artifactId>...</artifactId>: 定义项目的唯一标识符，通常是项目名称。这是强制要求的。
  • <version>...</version>: 定义项目的当前版本。通常遵循语义化版本规范（如 1.0.0-SNAPSHOT）。SNAPSHOT 表示这是一个开发中的不稳定版本。这是强制要求的。

这三个元素 (groupId:artifactId:version) 唯一确定了 Maven 仓库中的一个项目或依赖。

  • <name>...</name>: 项目的显示名称。
  • <description>...</description>: 项目的简要描述。

3. <properties>：定义属性

这个部分允许你定义一些属性，这些属性可以在 pom.xml 的其他地方引用。

  • <java.version>17</java.version>: 定义项目使用的 Java 版本。Spring Boot 会根据这个属性配置相关的插件和依赖。

你可以自定义其他属性，例如某个第三方库的版本号，然后在 <dependencies> 中引用它。

4. <dependencies>：依赖管理

这个部分声明了项目运行和编译所需的依赖库。每个 <dependency> 标签代表一个依赖。

  • 什么是 Starter？
    Spring Boot Starter 是一种特殊的依赖，它们是预配置的依赖集合，旨在简化特定功能所需的依赖管理。例如：

    • spring-boot-starter-web: 用于构建 Web 应用，包含了 Spring MVC、嵌入式 Tomcat 等。
    • spring-boot-starter-data-jpa: 用于使用 Spring Data JPA 进行数据持久化。
    • spring-boot-starter-test: 用于测试 Spring Boot 应用，包含了 JUnit, Mockito, Spring Test 等。

    使用 Starter 的好处是，你无需手动添加大量零散的依赖，一个 Starter 就搞定了所有必需的依赖，并且版本都是兼容的。

  • <dependency>...</dependency>:

    • <groupId>org.springframework.boot</groupId>: 依赖所属的组织。
    • <artifactId>spring-boot-starter-web</artifactId>: 依赖的名称。
    • <version>...</version>: 依赖的版本号。注意： 在 Spring Boot 项目中，由于继承了 spring-boot-starter-parent，对于 Spring Boot 提供的 Starter 和它管理的大部分常用库，你无需指定 <version>。Maven 会自动使用父项目定义的版本。这是 Spring Boot 的一个重要特性，简化了依赖管理。
    • <scope>...</scope>: 依赖的作用范围。
      • compile (默认): 编译、测试、运行时都需要。
      • test: 只在测试时需要 (如 spring-boot-starter-test)。
      • runtime: 编译时不需要，运行时需要 (如 JDBC 驱动)。
      • provided: 编译和测试时需要，运行时由外部容器提供 (如部署 War 包到 Tomcat 时，Servlet API 是由 Tomcat 提供的)。

  • 传递性依赖 (Transitive Dependencies): Maven 的一个强大功能是传递性依赖。如果你声明了一个依赖 A，而依赖 A 又依赖于 B 和 C，那么 Maven 会自动下载 B 和 C。Starter 依赖就是利用了这一点，一个 Starter 依赖会传递性地引入许多其他依赖。例如，添加 spring-boot-starter-web 会自动引入 spring-webmvc, tomcat-embed-core 等依赖。

5. <build>：构建配置

这个部分定义了 Maven 构建项目的相关配置，例如使用哪些插件、如何处理资源文件等。

  • <plugins>...</plugins>: 声明项目构建过程中使用的 Maven 插件。
  • <plugin>...</plugin>:
    • <groupId>org.springframework.boot</groupId>: 插件所属组织。
    • <artifactId>spring-boot-maven-plugin</artifactId>: 插件名称。

spring-boot-maven-plugin 是 Spring Boot 提供的一个核心 Maven 插件。它的主要作用是：

  • 重新打包可执行 Jar/War (Repackaging): 将标准的 Jar/War 包（只包含编译后的 .class 文件和资源文件）重新打包成一个“可执行”的 Jar/War 包。这个可执行包包含了所有的依赖（通常在 BOOT-INF/lib 目录下）以及一个特殊的启动类。这样，你可以直接使用 java -jar your-app.jar 命令来运行应用程序，而无需外部的应用服务器。
  • 查找主类: 在重新打包时，它可以自动找到带有 main 方法和 @SpringBootApplication 注解的主类。
  • 支持运行应用: 提供了 spring-boot:run 目标，可以直接在开发阶段运行 Spring Boot 应用程序。

由于父项目 <spring-boot-starter-parent> 已经预配置了这个插件，你通常只需要在 <build> 中简单地声明它即可，无需复杂的配置。

6. 编写你的第一个 Spring Boot 应用：Hello World 接口

现在 pom.xml 的结构已经清晰了，我们来编写一些简单的 Java 代码，创建一个能够响应 HTTP 请求的 Hello World 接口。

打开由 Spring Initializr 生成的项目。在 src/main/java 目录下，找到你的主应用程序类。它通常以你的项目名称命名，并且在 @SpringBootApplication 注解的下方包含一个 main 方法。

例如，如果你的 Artifact ID 是 my-spring-boot-app，包名是 com.example.myspringbootapp，那么主类可能是 com.example.myspringbootapp.MySpringBootAppApplication.java，内容类似这样：

“`java
package com.example.myspringbootapp;

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

@SpringBootApplication // 1. 主应用程序注解
public class MySpringBootAppApplication {

public static void main(String[] args) { // 2. Java 应用程序入口
    SpringApplication.run(MySpringBootAppApplication.class, args); // 3. 启动 Spring Boot 应用
}

}
“`

1. @SpringBootApplication 注解

这是 Spring Boot 项目的主注解，标记了应用程序的入口。它是一个复合注解，等同于以下三个注解的组合：

  • @Configuration: 标记这个类是 Spring 的配置类，可以定义 Bean。
  • @EnableAutoConfiguration: 开启 Spring Boot 的自动配置功能。Spring Boot 会根据你添加的依赖（如 spring-boot-starter-web），自动配置相关的组件（如 Tomcat 服务器、Spring MVC 等）。
  • @ComponentScan: 开启组件扫描。Spring 会自动扫描当前包及其子包下的组件（如带有 @Component, @Service, @Repository, @Controller, @RestController 等注解的类），并将它们注册为 Bean。

2. main 方法

这是一个标准的 Java 应用程序的入口点。当运行 Spring Boot 的可执行 Jar 时，实际上就是执行这个 main 方法。

3. SpringApplication.run() 方法

这是启动 Spring Boot 应用程序的关键方法。它会执行以下操作：

  • 创建一个 Spring ApplicationContext。
  • 根据 @SpringBootApplication 注解启用自动配置和组件扫描。
  • 加载配置属性。
  • 运行嵌入式 Web 服务器（如果存在 Spring Web 依赖）。

创建一个简单的 REST Controller

现在，我们在项目中创建一个简单的 REST 接口，用于响应 HTTP 请求。

在 src/main/java 目录下，与主应用程序类相同的包或其子包下，创建一个新的 Java 类，例如 HelloController.java：

“`java
package com.example.myspringbootapp; // 确保包名正确

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

@RestController // 1. 标记这是一个 REST 控制器
public class HelloController {

@GetMapping("/hello") // 2. 映射 GET 请求到 /hello 路径
public String sayHello() { // 3. 处理请求的方法
    return "Hello, Spring Boot and Maven!"; // 4. 返回响应体
}

}
“`

  • @RestController: 这是 @Controller 和 @ResponseBody 的组合注解。
    • @Controller: 标记这个类是一个 Spring MVC 控制器，用于处理 Web 请求。
    • @ResponseBody: 表示该类的所有方法的返回值都直接作为 HTTP 响应体返回，而不是视图名称。这使得构建 RESTful API 变得非常方便。
  • @GetMapping("/hello"): 这是 @RequestMapping(method = RequestMethod.GET) 的缩写。它标记这个方法用于处理 HTTP GET 请求，并且请求的路径是 /hello。
  • public String sayHello(): 这是处理 /hello GET 请求的方法。
  • return "Hello, Spring Boot and Maven!";: 方法的返回值会被 Spring MVC 自动转换为 HTTP 响应体发送给客户端。因为使用了 @RestController，这里返回的字符串就会直接作为响应体的内容。

由于主应用程序类上的 @ComponentScan 默认会扫描当前包 (com.example.myspringbootapp) 及其子包，HelloController 类会被自动发现并注册为 Spring 的 Bean。

7. 构建与运行 Spring Boot 项目

你的第一个 Spring Boot Web 应用已经编写好了。现在我们来看看如何构建和运行它。

在 IDE 中直接运行

这是开发阶段最方便的方式。大多数 IDE (如 IntelliJ IDEA, Eclipse STS) 都能识别 Spring Boot 主应用程序类。

在 IDE 的项目导航器中，找到 MySpringBootAppApplication.java 文件，右键点击，选择 “Run ‘MySpringBootAppApplication'” (或类似选项)。

Spring Boot 会启动内嵌的 Tomcat 服务器（默认端口 8080），并在控制台输出启动日志。看到类似 “Started MySpringBootAppApplication in X.XXX seconds” 的日志，说明应用启动成功。

使用 Maven 命令行运行

你也可以使用 Maven 命令来构建和运行项目，这对于自动化构建和部署非常有用。打开命令行终端，切换到项目的根目录（pom.xml 文件所在的目录）。

常用 Maven 命令解释：

  • mvn clean:
    执行 Maven 的 clean 生命周期阶段。这个阶段会清理构建过程中生成的目录和文件，特别是删除 target 目录。这可以确保每次构建都是全新的，避免旧文件干扰。
    bash
    mvn clean

  • mvn compile:
    执行 Maven 的 compile 生命周期阶段。这个阶段会编译 src/main/java 目录下的 Java 源代码，并将编译后的 .class 文件输出到 target/classes 目录。
    bash
    mvn compile

  • mvn test:
    执行 Maven 的 test 生命周期阶段。这个阶段会执行 src/test/java 目录下的测试代码。在执行测试之前，会先自动执行 compile 阶段。
    bash
    mvn test

  • mvn package:
    执行 Maven 的 package 生命周期阶段。这是一个非常常用的命令。它会依次执行 compile, test 等阶段，最后根据 pom.xml 中的 <packaging> 配置（这里是 jar），将项目打包成一个文件。
    对于 Spring Boot 项目，由于配置了 spring-boot-maven-plugin，mvn package 会生成一个可执行的 Jar 包，通常位于 target 目录下，名称格式为 artifactId-version.jar (例如 my-spring-boot-app-0.0.1-SNAPSHOT.jar)。
    bash
    mvn package
    这个命令会编译代码、运行测试（如果测试失败则打包会失败）、并将所有内容和依赖打包成一个独立的 Jar 文件。

  • mvn spring-boot:run:
    这是 Spring Boot Maven 插件提供的一个目标。它可以在开发阶段直接运行 Spring Boot 应用程序，类似于在 IDE 中点击运行按钮。它会编译代码并启动嵌入式服务器，无需先进行完整的 package 操作。
    bash
    mvn spring-boot:run
    这个命令非常方便用于快速启动应用进行调试和测试。

运行生成的可执行 Jar

使用 mvn package 命令生成可执行 Jar 包后，你可以在任何安装了 Java 运行环境的机器上直接运行它，无需安装 Maven 或其他服务器。

bash
java -jar target/my-spring-boot-app-0.0.1-SNAPSHOT.jar
（请根据实际生成的文件名替换 my-spring-boot-app-0.0.1-SNAPSHOT.jar）

这会启动你的 Spring Boot 应用程序，内嵌的服务器（Tomcat）将开始监听默认端口 8080。

8. 测试你的 Hello World 接口

无论是通过 IDE、mvn spring-boot:run 还是 java -jar 命令启动应用，一旦控制台显示应用启动成功并监听端口 8080，你就可以测试我们之前编写的 /hello 接口了。

打开你的 Web 浏览器，访问地址：

http://localhost:8080/hello

你应该会在浏览器页面上看到输出：

Hello, Spring Boot and Maven!

或者，你也可以使用命令行工具 curl (如果已安装)：

bash
curl http://localhost:8080/hello

同样，命令行会输出：

Hello, Spring Boot and Maven!

恭喜你！你已经成功创建、构建并运行了你的第一个 Spring Boot Maven 应用程序，并测试了它的一个基本 REST 接口。

9. 进一步探索 (拓展)

掌握了基础知识后，你可以进一步探索 Spring Boot 和 Maven 的更多功能：

  • 添加更多 Starter: 根据你的需求添加其他 Starter 依赖，例如 spring-boot-starter-data-jpa 用于数据库操作，spring-boot-starter-security 用于安全认证授权等。只需要在 pom.xml 的 <dependencies> 部分添加新的 <dependency> 即可。
  • 外部化配置: Spring Boot 支持使用 application.properties 或 application.yml 文件来外部化配置，例如修改服务器端口、配置数据库连接信息等。在 src/main/resources 目录下创建这些文件，Spring Boot 会自动加载。
  • 集成测试: Spring Boot 提供了 @SpringBootTest 注解，可以方便地编写集成测试，启动完整的 Spring 应用上下文来测试你的服务和控制器。测试代码放在 src/test/java 目录下。
  • Profiles: Spring Boot 支持通过 profiles 来区分不同环境（开发、测试、生产）的配置。
  • Maven 生命周期和目标: 深入了解 Maven 的标准生命周期以及各种插件提供的目标 (goals)。

10. 总结

在本篇详细教程中，我们从零开始，全面介绍了 Spring Boot 和 Maven 的基础知识以及如何结合使用它们来构建一个现代化的 Java Web 应用程序。

我们学习了：

  • Spring Boot 如何通过自动化配置和 Starter 简化开发。
  • Maven 如何作为强大的项目管理和构建工具，处理依赖和构建流程。
  • 如何使用 Spring Initializr 快速生成项目骨架。
  • 理解了标准的 Maven 项目目录结构。
  • 详细解析了 pom.xml 文件中的核心元素，特别是 Spring Boot 父项目和 Starter 依赖的作用。
  • 编写了一个简单的 Spring Boot Web 应用程序，包含主类和 REST 控制器。
  • 学习了如何使用 IDE 和 Maven 命令行来构建和运行项目，以及生成可执行 Jar 包。
  • 成功测试了应用程序的 Hello World 接口。

通过本教程的学习，你应该对 Spring Boot 和 Maven 的基础使用有了扎实的理解。这仅仅是开始，Spring Boot 和 Maven 的功能远不止于此。继续实践，尝试构建更复杂的应用，探索更多的功能，你将成为一名高效的 Java 开发者。

祝你在 Spring Boot 和 Maven 的学习旅程中一切顺利！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部