---

Spring Boot Maven 项目创建与配置详解

引言：踏入 Spring Boot 的世界

在当今的 Java 企业级应用开发领域，Spring Boot 无疑已经成为事实上的标准。它以其“约定大于配置”的设计理念、强大的自动化配置能力以及丰富的 Starter 依赖，极大地简化了 Spring 应用的搭建和开发过程。告别繁琐的 XML 配置，迎接轻量、高效的开发体验，这是 Spring Boot 带来的核心价值。

而 Maven，作为 Java 世界中最流行的项目管理工具之一，以其标准化的项目结构、强大的依赖管理和构建生命周期，与 Spring Boot 天然契合。结合使用 Spring Boot 和 Maven，可以让我们更轻松地创建、管理和构建强大的、可独立运行的应用程序。

本文将带您一步步详细了解如何创建一个基于 Maven 的 Spring Boot 项目，并深入探讨项目的基本结构、核心配置以及如何运行和构建您的第一个 Spring Boot 应用。无论您是 Spring Boot 的新手，还是希望系统回顾项目搭建流程，本文都将为您提供一份全面的指南。

我们将从项目创建的几种常用方法开始，重点讲解使用 Spring Initializr 这个官方推荐的工具，然后深入分析生成的项目文件结构和最重要的 pom.xml 文件，接着讨论常见的配置方式，并展示如何编写一个简单的 REST 接口并运行它。最后，我们还将触及项目的构建与打包。

准备好了吗？让我们开始 Spring Boot Maven 项目的探索之旅！

前提准备：工欲善其事，必先利其器

在开始创建 Spring Boot 项目之前，您需要确保本地开发环境已经具备以下工具：

1. Java Development Kit (JDK): Spring Boot 需要 Java 运行环境。建议安装 Java 8 或更高版本。随着 Spring Boot 版本的迭代，对 JDK 版本的要求也会提高，请参考您计划使用的 Spring Boot 版本对应的文档。您可以从 Oracle 或 OpenJDK 官网下载并安装。安装完成后，请确保 JAVA_HOME 环境变量已正确配置，并且 java 和 javac 命令可以在命令行中执行。

2. Maven: Maven 是一个项目管理和综合工具。它提供了标准化的项目结构、依赖管理机制和构建生命周期。您可以从 Maven 官网下载并安装。安装完成后，请确保 mvn 命令可以在命令行中执行，并且 MAVEN_HOME 环境变量（或通过 Path 配置）已正确设置。

3. 集成开发环境 (IDE): 虽然理论上可以使用任何文本编辑器和命令行进行开发，但使用一款功能强大的 Java IDE 将极大地提高开发效率。推荐的 IDE 包括：

   • Spring Tool Suite (STS): 基于 Eclipse，Spring 官方提供的 IDE，对 Spring 开发有很好的支持。
   • IntelliJ IDEA: 功能强大，社区版免费，旗舰版功能更全面，对 Maven 和 Spring Boot 的支持非常出色。
   • VS Code: 轻量级但功能齐全，通过安装 Java 扩展包和 Spring Boot 相关扩展，也可以进行 Spring Boot 开发。

请根据您的喜好选择并安装其中一款 IDE。在本文中，我们将主要侧重于项目本身的创建和配置，IDE 的操作会有所提及，但具体细节请参考您所使用 IDE 的官方文档。

项目创建方法：多种途径，殊途同归

创建 Spring Boot Maven 项目有多种途径，但最常用且官方推荐的是使用 Spring Initializr。此外，也可以通过 Spring Boot CLI 或手动创建 Maven 项目并添加依赖。

方法一：使用 Spring Initializr (Web UI) – 最推荐的方式

Spring Initializr 是一个 Web 服务，旨在帮助开发者快速生成一个具备基本结构的 Spring Boot 项目。它是创建 Spring Boot 项目最便捷的方式。

步骤：

1. 打开您的 Web 浏览器，访问 Spring Initializr 网站：https://start.spring.io/

2. 在页面上，您将看到一系列配置选项：

   • Project: 选择项目构建工具。对于本文，请选择 Maven Project。
   • Language: 选择开发语言。通常选择 Java。
   • Spring Boot: 选择 Spring Boot 的版本。通常选择一个稳定的、非 SNAPSHOT 的最新版本。例如，选择 3.2.4 (根据实际情况选择最新稳定版)。注意：不同的 Spring Boot 版本对 Java 版本等有不同要求。
   • Project Metadata: 这是项目的基本信息，对应于 Maven pom.xml 文件中的元素：
     • Group: 组织或公司标识符，通常使用反向域名。例如：com.yourcompany.demo。
     • Artifact: 项目的唯一标识符，通常是项目的名称。例如：my-spring-boot-app。
     • Name: 项目的用户友好名称，默认为 Artifact 名称。
     • Description: 项目的简要描述。
     • Package name: 项目的根包名，默认为 Group.Artifact。例如：com.yourcompany.demo.myspringbootapp。
   • Packaging: 选择项目的打包方式。
     • Jar: 打包成一个可执行的 JAR 文件，包含了内嵌的 Web 服务器和其他依赖，这是 Spring Boot 推荐的打包方式，方便独立运行。
     • War: 打包成一个 WAR 文件，通常需要部署到外部的 Web 服务器（如 Tomcat, Jetty）中运行。对于大多数现代微服务应用，推荐使用 JAR。
   • Java: 选择项目使用的 Java 版本。请确保您本地安装的 JDK 版本与此选项兼容。例如：17 或 21。
   • Dependencies: 这是最重要的一步，选择项目所需的依赖。Spring Boot 的核心优势在于其 Starter 依赖。点击 “Add Dependencies…” 按钮，搜索并添加您需要的 Starter：
     • 对于 Web 应用，至少需要添加 Spring Web Starter。它包含了 Tomcat 或 Jetty 等内嵌服务器和 Spring MVC。
     • 如果您需要使用数据库，可以添加 Spring Data JPA 或特定数据库的驱动（如 MySQL Driver）。
     • 为了方便开发时的热重载和调试，可以添加 Spring Boot DevTools。
     • 为了方便测试，可以添加 Spring Boot Test (通常默认已选中)。
     • 可以根据需求搜索并添加其他 Starter，如 Spring Security, Thymeleaf, Lombok 等。

3. 配置完成后，点击页面底部的 GENERATE 按钮。Initializr 会生成一个 .zip 文件并下载到您的本地。

4. 解压下载的 .zip 文件。这将是您的 Spring Boot 项目的初始骨架。

5. 打开您选择的 IDE，选择 “Import Project” (或类似的选项)，然后导航到您解压的项目目录。IDE 会识别这是一个 Maven 项目，并自动加载和解析 pom.xml 文件，下载所需的依赖。

方法二：使用 Spring Initializr (REST API 或 cURL)

Spring Initializr 也提供了 REST API，可以通过命令行工具（如 cURL）直接生成项目。这对于自动化脚本或喜欢命令行操作的开发者非常有用。

示例 (使用 cURL 生成一个 Web 项目):

bash
curl https://start.spring.io/starter.zip -d dependencies=web,devtools -d type=maven-project -d javaVersion=17 -d groupId=com.yourcompany -d artifactId=myapp -d name=myapp -d description="Demo project for Spring Boot" -o myapp.zip

这条命令会生成一个包含 spring-web 和 spring-boot-devtools 依赖、Java 17 版本、Maven 项目类型的压缩包，并保存为 myapp.zip。解压后同样导入 IDE。

方法三：使用 Spring Boot CLI

Spring Boot CLI (Command Line Interface) 也是一个快速创建和运行 Spring 应用的工具，它内置了 Initializr 功能。

步骤：

1. 确保您已经安装了 Spring Boot CLI。安装方法请参考 Spring Boot 官方文档。
2. 打开命令行终端。
3. 使用 spring init 命令生成项目。

示例：

bash
spring init --dependencies=web,data-jpa myproject

这会在当前目录下创建一个名为 myproject 的目录，里面包含一个基于 Maven、包含 web 和 data-jpa 依赖的 Spring Boot 项目。

方法四：手动创建 Maven 项目并添加依赖

这是最基础的方法，适合理解 Maven 项目结构和 Spring Boot 核心依赖的开发者。

步骤：

1. 使用 Maven 命令或 IDE 创建一个标准的 Maven 项目骨架。
   bash
mvn archetype:generate -DgroupId=com.yourcompany -DartifactId=manual-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
2. 编辑生成的 pom.xml 文件，手动添加 Spring Boot 相关的父项目和依赖。这比使用 Initializr 复杂，需要了解 Spring Boot Maven 插件和 Starter 依赖的结构。我们稍后会在 pom.xml 部分详细解释这些。

结论： 对于大多数场景，强烈推荐使用 Spring Initializr 的 Web UI 来创建项目骨架。它直观、便捷，能够确保您获得一个配置正确的初始项目。接下来的讨论将基于通过 Spring Initializr 生成的项目结构进行。

项目结构详解：初识 Spring Boot Maven 项目

通过 Spring Initializr 生成并解压的项目目录通常具有以下标准结构：

my-spring-boot-app/
├── .mvn/
│ └── wrapper/
│ ├── maven-wrapper.jar
│ └── maven-wrapper.properties
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── yourcompany/
│ │ │ └── demo/
│ │ │ └── myspringbootapp/
│ │ │ └── MySpringBootAppApplication.java <-- 主应用入口类
│ │ └── resources/
│ │ ├── application.properties <-- 主要配置文件 (或 application.yml)
│ │ ├── static/ <-- 存放静态资源 (CSS, JS, Images)
│ │ └── templates/ <-- 存放模板文件 (如 Thymeleaf, FreeMarker)
│ └── test/
│ └── java/
│ └── com/
│ └── yourcompany/
│ └── demo/
│ └── myspringbootapp/
│ └── MySpringBootAppApplicationTests.java <-- 测试类
├── .gitignore <-- Git 版本控制忽略文件
├── HELP.md <-- 项目帮助文档
├── mvnw <-- Maven Wrapper 脚本 (Linux/macOS)
├── mvnw.cmd <-- Maven Wrapper 脚本 (Windows)
└── pom.xml <-- Maven 项目对象模型文件，核心配置文件

让我们逐一解释这些目录和文件：

• .mvn 目录: 包含 Maven Wrapper 相关的脚本和 JAR 文件。Maven Wrapper 允许您在没有全局安装 Maven 的情况下，使用特定版本的 Maven 来构建项目。通过 ./mvnw (Linux/macOS) 或 mvnw.cmd (Windows) 命令，项目会自动下载并使用项目指定的 Maven 版本。这确保了团队成员使用相同的 Maven 版本进行构建，避免了版本不一致带来的问题。
• src/main/java: 存放项目的 Java 源代码。按照 Maven 标准，代码应遵循包结构组织。Initializr 会生成一个与您指定的 Package name 对应的目录结构，并在根目录下创建一个主应用入口类。
• src/main/resources: 存放项目的资源文件，如配置文件、国际化文件、静态资源、模板文件等。
  • application.properties 或 application.yml: 这是 Spring Boot 默认的主要配置文件。您可以在这里设置服务器端口、数据库连接、日志级别等各种应用属性。YAML (.yml) 格式由于其结构化和易读性，在复杂配置中越来越受欢迎。
  • static/: 默认存放静态资源，如 HTML 文件、CSS 文件、JavaScript 文件、图片等。当使用 Spring Web Starter 时，这些资源可以直接通过浏览器访问（例如，src/main/resources/static/index.html 可以通过 http://localhost:8080/index.html 访问）。
  • templates/: 默认存放服务器端模板文件，如使用 Thymeleaf, FreeMarker, Mustache 等模板引擎的模板文件。这些文件通常不直接通过浏览器访问，而是在控制器中渲染后返回给客户端。
• src/test/java: 存放项目的测试 Java 源代码。Initializr 会生成一个基本的测试类。
• .gitignore: Git 版本控制的忽略文件，通常会忽略构建输出目录 (target/)、IDE 配置文件等，避免将不必要的文件提交到版本库。
• HELP.md: Initializr 生成的一个简单的帮助文档，包含一些关于如何启动和构建项目的基础信息。
• mvnw / mvnw.cmd: Maven Wrapper 脚本。用于在没有安装 Maven 的环境下执行 Maven 命令。

• pom.xml: 这是 Maven 项目的核心配置文件，采用 XML 格式。它定义了项目的元数据、依赖、构建配置、插件等几乎所有与项目构建和管理相关的信息。我们将重点深入讲解这个文件。

• 主应用入口类 (MySpringBootAppApplication.java):
  这个类通常位于 src/main/java 下根包的顶层，并包含一个 main 方法。它通常被 @SpringBootApplication 注解标记。

  “`java
  package com.yourcompany.demo.myspringbootapp;

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

  @SpringBootApplication // 组合注解，包含了 @Configuration, @EnableAutoConfiguration, @ComponentScan
  public class MySpringBootAppApplication {

  public static void main(String[] args) {
      SpringApplication.run(MySpringBootAppApplication.class, args); // 启动 Spring Boot 应用
  }
  

  }
  ``
*@SpringBootApplication: 这是一个方便的组合注解，等同于同时使用@Configuration,@EnableAutoConfiguration和@ComponentScan。
*@Configuration: 表明该类是一个配置类。
*@EnableAutoConfiguration: 启用 Spring Boot 的自动配置机制。Spring Boot 会根据 classpath 中的依赖自动配置 Spring 应用程序，大大减少手动配置。
*@ComponentScan: 扫描当前包及其子包下的组件（如@Component,@Service,@Repository,@Controller等），并将它们注册为 Spring Bean。
*SpringApplication.run()`: 静态方法，用于启动 Spring Boot 应用程序。它会创建一个 Spring ApplicationContext，加载配置，并运行嵌入式 Web 服务器（如果配置了 Web 依赖）。

pom.xml 详解：Maven 构建的核心

pom.xml 文件是 Maven 项目的灵魂，它定义了项目的构建方式、依赖关系等。理解 pom.xml 对于管理 Spring Boot 项目至关重要。通过 Spring Initializr 生成的 pom.xml 文件已经包含了 Spring Boot 项目所需的核心配置。

以下是一个典型的 Spring Boot Maven 项目的 pom.xml 结构，我们将逐个解释关键部分：

“`xml

4.0.0

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

<!-- 项目基本信息 -->
<groupId>com.yourcompany.demo</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>17</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>

    <!-- 如果添加了其他依赖，会在这里列出 -->
    <!-- 例如： -->
    <!-- <dependency> -->
    <!--     <groupId>org.springframework.boot</groupId> -->
    <!--     <artifactId>spring-boot-starter-data-jpa</artifactId> -->
    <!-- </dependency> -->
    <!-- <dependency> -->
    <!--     <groupId>mysql</groupId> -->
    <!--     <artifactId>mysql-connector-java</artifactId> -->
    <!--     <scope>runtime</scope> -->
    <!-- </dependency> -->

</dependencies>

<!-- 构建配置 -->
<build>
    <plugins>
        <!-- Spring Boot Maven Plugin -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <!-- <configuration> -->
            <!--     <excludes> -->
            <!--         <exclude> -->
            <!--             <groupId>org.projectlombok</groupId> -->
            <!--             <artifactId>lombok</artifactId> -->
            <!--         </exclude> -->
            <!--     </excludes> -->
            <!-- </configuration> -->
        </plugin>
    </plugins>
</build>

“`

核心元素解释：

1. <project> 根元素：Maven 项目文件的根元素。
2. <modelVersion>4.0.0</modelVersion>：指定 POM 模型版本，当前为 4.0.0。

3. <parent> – Spring Boot 父项目：

   • <groupId>org.springframework.boot</groupId>
   • <artifactId>spring-boot-starter-parent</artifactId>
   • <version>3.2.4</version> (请与您的 Spring Boot 版本对应)
   • <relativePath/>
     这是 Spring Boot Maven 项目的关键。您的项目继承自 spring-boot-starter-parent。这个父项目的作用非常重要：
     • 依赖管理 (Dependency Management): 它定义了许多常用依赖的版本号。当您在项目的 <dependencies> 中引入 Spring Boot Starter 或 Spring 项目的其他依赖时，通常无需指定 <version>，父项目会统一管理版本，避免版本冲突。这被称为依赖管理。
     • 默认 Maven 插件配置: 它提供了一些合理的默认 Maven 插件配置，例如编译插件、资源插件等。
     • 资源过滤: 默认支持对 application.properties (或 yml) 等文件进行资源过滤，可以在构建时替换占位符。
     • 字符编码: 默认使用 UTF-8 字符编码。
     • Java 版本: 通过 <properties> 可以设置 Java 版本。
       继承 spring-boot-starter-parent 是使用 Spring Boot 推荐的方式，极大地简化了依赖管理。

4. 项目基本信息：

   • <groupId>: 项目的组织标识符，通常是公司或组织的域名反写。
   • <artifactId>: 项目的唯一标识符，通常是项目名称。
   • <version>: 项目的版本号。SNAPSHOT 后缀表示这是一个开发中的不稳定版本。
   • <name>: 项目的用户友好名称。
   • <description>: 项目的简要描述。

5. <properties> – 项目属性：
   定义可以在整个 POM 文件中引用的属性。

   • <java.version>17</java.version>: 指定项目使用的 Java 编译版本。这是通过父 POM 配置的。

6. <dependencies> – 项目依赖：
   定义项目所需的所有依赖库。每个 <dependency> 块代表一个依赖。

   • <groupId>: 依赖库的组织标识符。
   • <artifactId>: 依赖库的模块标识符。
   • <version>: 依赖库的版本号。注意： 对于继承了 spring-boot-starter-parent 的项目，对于大部分 Spring 相关的依赖和常用第三方库，您通常不需要在这里指定 <version>，因为父 POM 已经通过 <dependencyManagement> 定义了它们的推荐版本。这正是父 POM 带来的便利之处。
   • <scope>: 依赖的作用范围。常见的 scope 包括：
     • compile (默认): 编译、测试和运行时都需要。
     • runtime: 测试和运行时需要，编译时不需要（如 JDBC 驱动）。
     • test: 仅测试时需要（如 JUnit, Mockito）。
     • provided: 编译和测试时需要，运行时由容器提供（如 Servlet API，如果打包为 WAR 部署到外部 Tomcat）。
     • system: 类似于 provided，但需要指定本地文件路径，不推荐使用。
   • <optional>: true 表示该依赖是可选的。当其他项目依赖您的项目时，不会默认传递该可选依赖。

   Spring Boot Starter 依赖：
   Spring Boot 提供了大量的 Starter 依赖，它们是预配置的依赖集合，旨在帮助您快速集成特定功能。例如：
   * spring-boot-starter-web: 用于构建 Web 应用，包含 Spring MVC, Tomcat (默认嵌入式服务器) 等。
   * spring-boot-starter-data-jpa: 用于使用 Spring Data JPA 进行数据访问，包含 Hibernate (默认 JPA 实现) 等。
   * spring-boot-starter-test: 用于编写测试，包含 JUnit, Spring Test, Mockito 等。
   * spring-boot-starter-thymeleaf: 用于使用 Thymeleaf 模板引擎。
   * spring-boot-starter-security: 用于 Spring Security 安全框架。
   * spring-boot-devtools: 提供开发时的便利功能，如自动重启、LiveReload 等。其 <scope>runtime 和 <optional>true 配置是标准的。

   添加新的依赖时，只需在 <dependencies> 块中添加新的 <dependency> 块即可。利用 IDE 的 Maven 集成功能通常可以方便地搜索和添加依赖。

7. <build> – 构建配置：
   定义项目的构建过程和插件配置。

   • <plugins>: 包含项目使用的 Maven 插件。
   • spring-boot-maven-plugin: 这是 Spring Boot 的核心 Maven 插件。
     • <groupId>org.springframework.boot</groupId>
     • <artifactId>spring-boot-maven-plugin</artifactId>
       该插件的作用至关重要：
       • 重新打包 (Repackage): 它会找到 Spring Boot 的主应用类 (@SpringBootApplication 标记的类），并将项目打包成一个可执行的 JAR 文件。这个 JAR 文件包含了您的代码、所有依赖（包括内嵌的服务器）以及 Spring Boot loader，可以直接通过 java -jar 命令运行。这是 Spring Boot 的一大特性。
       • 查找主类: 默认会自动查找主类，但也可以通过配置手动指定。
       • 支持运行: 提供 spring-boot:run 目标，可以直接运行您的 Spring Boot 应用。
       • 支持构建镜像: 支持将应用构建成 Docker 镜像（需要额外配置）。

   您可以在 <configuration> 块中对该插件进行更详细的配置，例如排除某些依赖不打包进最终 JAR。

配置详解：应用程序的定制化

Spring Boot 提供了强大的外部化配置能力，允许您在不修改代码的情况下改变应用程序的行为。默认情况下，Spring Boot 会从 src/main/resources 目录下的 application.properties 或 application.yml 文件加载配置。

application.properties vs. application.yml

• application.properties: 使用键值对的形式，每行一个配置项。
  properties
server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=password
logging.level.root=INFO

• application.yml: 使用 YAML 格式，具有更好的可读性和层级结构，特别适合复杂的配置。
  “`yaml
  server:
  port: 8081

  spring:
  datasource:
  url: jdbc:mysql://localhost:3306/mydb
  username: root
  password: password

  logging:
  level:
  root: INFO
  ``
在同一个项目中，如果同时存在application.properties和application.yml，.yml文件中的配置会覆盖.properties中的同名配置。推荐使用.yml` 格式，因为它更清晰。

常见的配置项示例：

• 服务器端口:
  • server.port=8081 (properties)
  • server.port: 8081 (yml)
• 数据库连接:
  • spring.datasource.url=...
  • spring.datasource.username=...
  • spring.datasource.password=...
  • spring.datasource.driver-class-name=... (通常可以自动检测)
• JPA/Hibernate 配置:
  • spring.jpa.show-sql=true (在控制台打印 SQL 语句)
  • spring.jpa.hibernate.ddl-auto=update (数据库表结构自动更新策略，开发环境常用，生产环境慎用)
  • spring.jpa.properties.hibernate.format_sql=true (格式化打印的 SQL)
• 日志配置:
  • logging.level.root=INFO (设置根日志级别)
  • logging.level.org.springframework=DEBUG (设置 Spring 框架日志级别)
  • logging.file.name=myapp.log (将日志输出到文件)
• Spring Boot DevTools 配置:
  • spring.devtools.livereload.enabled=true (启用 LiveReload)
  • spring.devtools.restart.enabled=true (启用自动重启)

外部化配置的优先级：

Spring Boot 提供了多种外部化配置源，并有特定的加载顺序（优先级从高到低，高优先级的会覆盖低优先级的配置）：

1. 命令行参数
2. 来自 SPRING_APPLICATION_JSON 的 JSON 字符串（环境变量或系统属性）
3. Servlet 容器初始化参数
4. servletContext 初始化参数
5. JNDI
6. Java 系统属性 (System.getProperties())
7. 操作系统环境变量 (System.getenv())
8. 通过 @PropertySource 加载的配置
9. 应用程序打包在内的 application.properties 或 application.yml 文件（位于 classpath 根目录，如 src/main/resources）
10. 应用程序打包在外的 application.properties 或 application.yml 文件（在当前目录的 /config 子目录或当前目录）
11. @EnableAutoConfiguration 自动配置类加载的配置

了解这个优先级列表非常重要，它解释了为什么您可以通过命令行参数覆盖 application.properties 文件中的配置，例如 java -jar myapp.jar --server.port=9090 会让应用在 9090 端口启动。

使用 @Value 和 @ConfigurationProperties 读取配置

在 Java 代码中，您可以使用 @Value 注解来注入单个配置属性的值：

“`java
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MyService {

@Value("${my.property.name}")
private String myPropertyValue;

public void doSomething() {
    System.out.println("Configured property: " + myPropertyValue);
}

}
``
在application.properties中：my.property.name=someValue`

对于复杂的、结构化的配置，推荐使用 @ConfigurationProperties 注解将一组相关的配置属性绑定到一个 Java 对象上：

“`java
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = “app.settings”)
public class AppSettings {

private String name;
private int maxItems;
private boolean enabled;

// Getters and Setters
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getMaxItems() { return maxItems; }
public void setMaxItems(int maxItems) { this.maxItems = maxItems; }
public boolean isEnabled() { return enabled; }
public void setEnabled(boolean enabled) { this.enabled = enabled; }

@Override
public String toString() {
    return "AppSettings{" +
           "name='" + name + '\'' +
           ", maxItems=" + maxItems +
           ", enabled=" + enabled +
           '}';
}

}
在 `application.yml` 中：yaml
app:
settings:
name: My App
max-items: 100
enabled: true
``
Spring Boot 会自动将app.settings前缀下的配置项绑定到AppSettings对象的同名属性上（支持驼峰命名和 kebab-case 之间的转换，例如max-items对应maxItems属性）。使用@ConfigurationProperties` 可以让配置更加清晰、类型安全，并且方便进行校验。

编写一个简单的 REST 控制器

为了验证我们的 Spring Boot 应用是否正常工作，我们可以编写一个简单的 REST 控制器。

1. 在 src/main/java 下，与主应用类同级的包或子包中创建一个新的 Java 类，例如 HelloController.java。

2. 编写如下代码：

   “`java
   package com.yourcompany.demo.myspringbootapp;

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

   @RestController // 组合注解，包含了 @Controller 和 @ResponseBody
   public class HelloController {

   @GetMapping("/hello") // 将 HTTP GET 请求映射到 /hello 路径
   public String sayHello(@RequestParam(value = "name", defaultValue = "World") String name) {
       return String.format("Hello, %s!", name);
   }
   

   }
   ``
*@RestController: 这个注解标记该类为一个 REST 控制器，表示类中的方法默认返回的数据会直接写入 HTTP 响应体（而不是返回视图名称）。它是@Controller和@ResponseBody的组合。
*@GetMapping(“/hello”): 这个注解将sayHello方法映射到/hello路径的 HTTP GET 请求。
*@RequestParam(value = “name”, defaultValue = “World”) String name: 这个注解表示方法参数name的值来自请求参数中名为name的部分。如果请求中没有name参数，则使用默认值 "World"。
* 方法的返回值String` 会被直接作为 HTTP 响应体的内容返回给客户端。

运行 Spring Boot 应用

创建完项目并添加了简单的控制器后，就可以运行应用程序了。

方法一：使用 IDE 运行

大多数现代 IDE（如 STS, IntelliJ IDEA）都能识别 Spring Boot 项目。

1. 找到主应用入口类 (MySpringBootAppApplication.java)。
2. 右键点击该文件，选择 “Run As” -> “Spring Boot App” (STS) 或 “Run ‘MySpringBootAppApplication'” (IntelliJ IDEA)。
3. IDE 会启动内嵌的 Web 服务器（默认是 Tomcat）。观察控制台输出，您应该能看到 Spring Boot 的 Logo 和 Tomcat 启动的信息，以及应用启动所占用的端口号（默认 8080）。

方法二：使用 Maven 命令运行

在项目的根目录（即 pom.xml 所在的目录）打开命令行终端。

1. 使用 Maven Wrapper 脚本运行：
   • Linux/macOS: ./mvnw spring-boot:run
   • Windows: mvnw spring-boot:run
     这个命令会执行 Maven 的 spring-boot:run 目标，编译项目，然后使用 Spring Boot Maven 插件运行应用程序。首次运行可能需要下载 Maven Wrapper 和依赖。
2. 如果您全局安装了 Maven，也可以直接使用：mvn spring-boot:run

无论使用哪种方式，应用启动后，您可以在浏览器中访问 http://localhost:8080/hello 或 http://localhost:8080/hello?name=YourName 来测试我们刚刚编写的 REST 接口。如果应用成功启动并在默认端口 8080 监听，您应该能在浏览器中看到 “Hello, World!” 或 “Hello, YourName!”。

方法三：运行打包后的 JAR 文件

Spring Boot 的目标之一是创建可独立运行的应用程序。我们可以先将项目打包成一个可执行 JAR。

1. 在项目根目录打开命令行终端。
2. 使用 Maven Wrapper 脚本打包：
   • Linux/macOS: ./mvnw package
   • Windows: mvnw package
     这个命令会执行 Maven 的构建生命周期中的 package 阶段，包括编译、测试、打包等。spring-boot-maven-plugin 会在 package 阶段将项目打包成一个可执行的 JAR 文件，默认位于 target 目录下。
3. 如果您全局安装了 Maven，也可以直接使用：mvn package
4. 打包成功后，进入 target 目录。您会找到一个类似 my-spring-boot-app-0.0.1-SNAPSHOT.jar 的文件。
5. 使用 Java 命令运行这个 JAR 文件：java -jar my-spring-boot-app-0.0.1-SNAPSHOT.jar
   这个命令会直接启动内嵌了服务器的 Spring Boot 应用，无需外部应用服务器。这对于部署和分发应用程序非常方便。

构建与打包：准备发布

Maven 的构建生命周期定义了一系列阶段（如 validate, compile, test, package, install, deploy）。mvn package 命令会执行到 package 阶段及其之前的阶段。

如前所述，spring-boot-maven-plugin 在 package 阶段发挥作用，将标准的 JAR (或 WAR) 文件重新打包成一个可执行的文件，包含了所有依赖和 Spring Boot loader。

• mvn clean: 清理项目构建生成的目录（通常是 target 目录）。
• mvn compile: 编译主程序代码。
• mvn test: 运行单元测试。
• mvn package: 编译、运行测试，并将项目打包成 JAR/WAR 文件。
• mvn install: 运行 package，并将打包文件安装到本地 Maven 仓库，供其他本地项目使用。
• mvn deploy: 运行 install，并将打包文件部署到远程 Maven 仓库。

对于 Spring Boot 应用，mvn package 生成的可执行 JAR 是最常见的发布形式。

总结与展望

通过本文，我们详细了解了如何使用 Spring Initializr 创建一个标准的 Spring Boot Maven 项目，解析了生成的项目结构和核心的 pom.xml 文件，探讨了常见的配置方式，并成功运行了一个简单的 Web 应用程序。

Spring Boot 和 Maven 的结合为您提供了一个强大、灵活且高效的开发平台。掌握项目创建和基本配置是深入学习 Spring Boot 的第一步。

接下来，您可以继续探索 Spring Boot 的更多特性，例如：

• 数据库访问: 集成 Spring Data JPA、MyBatis 等框架。
• 安全性: 使用 Spring Security 实现用户认证和授权。
• 缓存: 集成 Spring Cache。
• 消息队列: 集成 RabbitMQ, Kafka 等。
• 微服务: 利用 Spring Cloud 构建分布式系统。
• 健康检查和监控: 使用 Spring Boot Actuator。
• Profile: 实现不同环境（开发、测试、生产）下的差异化配置。

希望这篇详细指南能帮助您顺利开启 Spring Boot Maven 项目的开发之旅！祝您编码愉快！

---