如果您刚开始使用Spring Boot，或者对“Spring”有一般了解，请先阅读本节。它回答了基本的“什么？”，“如何？”和“为什么？”问题。其中包括Spring Boot的简介以及安装说明。然后我们将指导您构建第一个Spring Boot应用程序，并在此过程中讨论一些核心原则。

1. 介绍Spring Boot

Spring Boot帮助您创建独立的、生产级别的基于Spring的应用程序，可以直接运行。我们对Spring平台和第三方库持有一种主观的看法，这样您就可以轻松入门。大多数Spring Boot应用程序几乎不需要Spring配置。

您可以使用Spring Boot创建可以通过java -jar启动的Java应用程序，也可以使用更传统的war部署方式。

我们的主要目标是：

  • 为所有Spring开发提供一个极快速和广泛可访问的入门体验。

  • 默认情况下具有主观看法，但在需求开始与默认值分歧时能够快速脱离。

  • 提供一系列对大类项目通用的非功能特性（如嵌入式服务器、安全性、度量、健康检查和外部化配置）。

  • 绝对不生成代码（当不针对原生镜像时）且不需要XML配置。

2. 系统要求

Spring Boot 3.2.3需要 Java 17，兼容Java 21及以下。还需要 Spring Framework 6.1.4 或更高版本。

以下构建工具提供了显式的构建支持：

构建工具 版本

Maven

3.6.3或更高版本

Gradle

7.x（7.5或更高版本）和 8.x

2.1. Servlet容器

Spring Boot支持以下嵌入式Servlet容器：

名称 Servlet版本

Tomcat 10.1

6.0

Jetty 12.0

6.0

Undertow 2.3

6.0

您还可以将Spring Boot应用程序部署到任何兼容Servlet 5.0+的容器中。

2.2. GraalVM原生镜像

Spring Boot应用程序可以使用GraalVM 22.3或更高版本转换为原生镜像。

可以使用GraalVM提供的native-image工具或Gradle/Maven插件的本地构建工具来创建镜像。您还可以使用Paketo原生镜像构建包来创建原生镜像。

支持以下版本：

名称 版本

GraalVM社区版

22.3

本地构建工具

0.9.28

3. 安装Spring Boot

Spring Boot可以与“经典”Java开发工具一起使用，也可以安装为命令行工具。无论哪种方式，您都需要Java SDK v17或更高版本。在开始之前，您应该使用以下命令检查当前的Java安装情况：

$ java -version

如果您是Java开发新手，或者想尝试使用Spring Boot，您可能希望首先尝试Spring Boot CLI（命令行界面）。否则，请继续阅读“经典”安装说明。

3.1. Java开发人员安装说明

您可以像使用任何标准Java库一样使用Spring Boot。为此，请将适当的spring-boot-*.jar文件包含在类路径中。Spring Boot不需要任何特殊的工具集成，因此您可以使用任何IDE或文本编辑器。此外，Spring Boot应用程序没有任何特殊之处，因此您可以像运行和调试其他Java程序一样运行和调试Spring Boot应用程序。

虽然您可以复制Spring Boot jars，但我们通常建议您使用支持依赖管理的构建工具（如Maven或Gradle）。

3.1.1. Maven安装

Spring Boot与Apache Maven 3.6.3或更高版本兼容。如果您尚未安装Maven，可以按照maven.apache.org上的说明进行操作。

在许多操作系统上，可以使用软件包管理器安装Maven。如果您使用OSX Homebrew，请尝试brew install maven。Ubuntu用户可以运行sudo apt-get install maven。具有Chocolatey的Windows用户可以从提升的（管理员）提示符中运行choco install maven。

Spring Boot依赖项使用org.springframework.boot组ID。通常，您的Maven POM文件继承自spring-boot-starter-parent项目，并声明对一个或多个“Starters”的依赖关系。Spring Boot还提供了一个可选的Maven插件用于创建可执行jar包。

有关使用Spring Boot和Maven入门的更多详细信息，请参阅Maven插件参考指南中的入门部分。

3.1.2. Gradle安装

Spring Boot与Gradle 7.x（7.5或更高版本）和8.x兼容。如果您尚未安装Gradle，可以按照gradle.org上的说明进行操作。

Spring Boot依赖项可以通过使用org.springframework.boot group来声明。通常，您的项目声明对一个或多个“Starters”的依赖关系。Spring Boot提供了一个有用的Gradle插件，可用于简化依赖声明并创建可执行jar包。

Gradle Wrapper

Gradle Wrapper提供了一种很好的方式在构建项目时“获取”Gradle。它是一个小型脚本和库，您可以将其与代码一起提交以引导构建过程。有关详细信息，请参阅docs.gradle.org/current/userguide/gradle_wrapper.html。

有关使用Spring Boot和Gradle入门的更多详细信息，请参阅Gradle插件参考指南中的入门部分。

3.2. 安装Spring Boot CLI

Spring Boot CLI（命令行界面）是一个命令行工具，您可以使用它快速进行Spring原型设计。

您不需要使用CLI来使用Spring Boot，但它是一个快速的方法，在没有集成开发环境的情况下启动Spring应用程序。

3.2.1. 手动安装

您可以从以下位置之一下载Spring CLI分发版：

下载后，请按照解压缩存档中的 INSTALL.txt 说明操作。简而言之，在 .zip 文件的 bin/ 目录中有一个 spring 脚本（Windows 上为 spring.bat）。或者，您可以使用 java -jar 加上 .jar 文件（该脚本可帮助您确保类路径设置正确）。

3.2.2. 使用SDKMAN!安装

SDKMAN!（软件开发工具包管理器）可用于管理各种二进制SDK的多个版本，包括Groovy和Spring Boot CLI。从 sdkman.io 获取SDKMAN! 并使用以下命令安装Spring Boot：

$ sdk install springboot
$ spring --version
Spring CLI v3.2.3

如果您为CLI开发功能并希望访问您构建的版本，请使用以下命令：

$ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-3.2.3-bin/spring-3.2.3/
$ sdk default springboot dev
$ spring --version
Spring CLI v3.2.3

上述说明安装了一个名为 dev 的本地 spring 实例。它指向您的目标构建位置，因此每次重新构建Spring Boot 时，spring 都是最新的。

您可以通过运行以下命令查看：

$ sdk ls springboot

================================================================================
可用的Springboot版本
================================================================================
> + dev
* 3.2.3

================================================================================
+ - 本地版本
* - 已安装
> - 当前使用
================================================================================

3.2.3. OSX Homebrew安装

如果您使用Mac并且使用 Homebrew，您可以使用以下命令安装Spring Boot CLI：

$ brew tap spring-io/tap
$ brew install spring-boot

Homebrew 将 spring 安装到 /usr/local/bin。

如果您看不到公式，则您的brew安装可能已过时。在这种情况下，请运行 brew update 然后重试。

3.2.4. MacPorts安装

如果您使用Mac并且使用 MacPorts，您可以使用以下命令安装Spring Boot CLI：

$ sudo port install spring-boot-cli

3.2.5. 命令行自动完成

Spring Boot CLI 包含提供 BASH 和 zsh shells 的命令完成的脚本。您可以在任何shell中 source 该脚本（也称为 spring）或将其放在您的个人或系统范围的bash完成初始化中。在Debian系统上，系统范围的脚本位于 <installation location>/shell-completion/bash，该目录中的所有脚本在新shell启动时都会执行。例如，如果您通过SDKMAN!安装，可以使用以下命令手动运行脚本：

$ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring
$ spring <在此按TAB>
  grab  help  jar  run  test  version
如果您使用Homebrew或MacPorts安装Spring Boot CLI，则命令行完成脚本会自动注册到您的shell。

3.2.6. Windows Scoop安装

如果您使用Windows并且使用 Scoop，您可以使用以下命令安装Spring Boot CLI：

> scoop bucket add extras
> scoop install springboot

Scoop 将 spring 安装到 ~/scoop/apps/springboot/current/bin。

如果您看不到应用程序清单，则您的scoop安装可能已过时。在这种情况下，请运行 scoop update 然后重试。

4. 开发你的第一个Spring Boot应用程序

本节描述了如何开发一个小型的“Hello World！”Web应用程序，突出了Spring Boot的一些关键特性。您可以选择Maven或Gradle作为构建系统。

spring.io 网站包含许多使用Spring Boot的“入门”指南。如果您需要解决特定问题，请首先查看那里。

您可以通过访问start.spring.io并从依赖搜索器中选择“Web”启动器来快速完成下面的步骤。这样可以生成一个新的项目结构，让您可以立即开始编码。查看start.spring.io用户指南以获取更多详细信息。

4.1. 先决条件

在开始之前，打开终端并运行以下命令，以确保您安装了有效版本的Java：

$ java -version
openjdk version "17.0.4.1" 2022-08-12 LTS
OpenJDK Runtime Environment (build 17.0.4.1+1-LTS)
OpenJDK 64-Bit Server VM (build 17.0.4.1+1-LTS, mixed mode, sharing)
此示例需要在自己的目录中创建。后续说明假定您已创建了一个合适的目录，并且它是您当前的目录。

4.1.1. Maven

如果要使用Maven，请确保已安装Maven：

$ mvn -v
Apache Maven 3.8.5 (3599d3414f046de2324203b78ddcf9b5e4388aa0)
Maven home: usr/Users/developer/tools/maven/3.8.5
Java version: 17.0.4.1, vendor: BellSoft, runtime: /Users/developer/sdkman/candidates/java/17.0.4.1-librca

4.1.2. Gradle

如果要使用Gradle，请确保已安装Gradle：

$ gradle --version

------------------------------------------------------------
Gradle 8.1.1
------------------------------------------------------------

Build time:   2023-04-21 12:31:26 UTC
Revision:     1cf537a851c635c364a4214885f8b9798051175b

Kotlin:       1.8.10
Groovy:       3.0.15
Ant:          Apache Ant(TM) version 1.10.11 compiled on July 10 2021
JVM:          17.0.7 (BellSoft 17.0.7+7-LTS)
OS:           Linux 6.2.12-200.fc37.aarch64 aarch64

4.2. 使用Maven设置项目

我们需要首先创建一个Maven pom.xml 文件。 pom.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>myproject</artifactId>
    <version>0.0.1-SNAPSHOT</version>

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

    <!-- Additional lines to be added here... -->

</project>

上述清单应该给您一个可工作的构建。您可以通过运行mvn package来测试它（暂时可以忽略“jar will be empty - no content was marked for inclusion!”警告）。

此时，您可以将项目导入IDE（大多数现代Java IDE都包含对Maven的内置支持）。为简单起见，我们继续在此示例中使用纯文本编辑器。

4.3. 使用Gradle设置项目

我们需要首先创建一个Gradle build.gradle 文件。 build.gradle 是用于构建项目的构建脚本。打开您喜欢的文本编辑器并添加以下内容：

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.3'
}

apply plugin: 'io.spring.dependency-management'

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'

repositories {
    mavenCentral()
}

dependencies {
}

上述清单应该给您一个可工作的构建。您可以通过运行gradle classes来测试它。

此时，您可以将项目导入IDE（大多数现代Java IDE都包含对Gradle的内置支持）。为简单起见，我们继续在此示例中使用纯文本编辑器。

4.4. 添加类路径依赖

Spring Boot提供了许多“Starters”，让您可以将jar包添加到类路径中。“Starters”提供了在开发特定类型应用程序时可能需要的依赖项。

4.4.1. Maven

大多数Spring Boot应用程序在POM的parent部分中使用spring-boot-starter-parent。 spring-boot-starter-parent 是一个特殊的启动器，提供有用的Maven默认值。它还提供了一个dependency-management部分，以便您可以省略“受保护”的依赖项的version标签。

由于我们正在开发Web应用程序，我们添加了一个spring-boot-starter-web依赖项。在此之前，我们可以通过运行以下命令查看当前的情况：

$ mvn dependency:tree

[INFO] com.example:myproject:jar:0.0.1-SNAPSHOT

mvn dependency:tree命令会打印项目依赖关系的树形表示。您会看到spring-boot-starter-parent本身不提供任何依赖项。要添加必要的依赖项，请编辑您的pom.xml，并在parent部分的下面立即添加spring-boot-starter-web依赖项：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

如果再次运行mvn dependency:tree，您会看到现在有许多额外的依赖项，包括Tomcat Web服务器和Spring Boot本身。

4.4.2. Gradle

大多数Spring Boot应用程序使用org.springframework.boot Gradle插件。此插件提供有用的默认值和Gradle任务。 io.spring.dependency-management Gradle插件提供依赖管理，以便您可以省略“受保护”的依赖项的version标签。

由于我们正在开发Web应用程序，我们添加了一个spring-boot-starter-web依赖项。在此之前，我们可以通过运行以下命令查看当前的情况：

$ gradle dependencies

> Task :dependencies

------------------------------------------------------------
Root project 'myproject'
------------------------------------------------------------

gradle dependencies命令会打印项目依赖关系的树形表示。目前，项目没有依赖项。要添加必要的依赖项，请编辑您的build.gradle，并在dependencies部分中添加spring-boot-starter-web依赖项：

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

如果再次运行gradle dependencies，您会看到现在有许多额外的依赖项，包括Tomcat Web服务器和Spring Boot本身。

4.5. 编写代码

为了完成我们的应用程序，我们需要创建一个单独的Java文件。默认情况下，Maven和Gradle会编译来自src/main/java的源代码，因此您需要创建该目录结构，然后添加一个名为src/main/java/MyApplication.java的文件，其中包含以下代码：

Java 
package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@SpringBootApplication
public class MyApplication {

    @RequestMapping("/")
    String home() {
        return "Hello World!";
    }

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

}
Kotlin 
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController

@RestController
@SpringBootApplication
class MyApplication {

    @RequestMapping("/")
    fun home() = "Hello World!"

}

fun main(args: Array<String>) {
    runApplication<MyApplication>(*args)
}

虽然这里的代码不多，但涉及的内容很多。我们将在接下来的几节中逐步介绍重要部分。

4.5.1. @RestController和@RequestMapping注解

我们的MyApplication类上的第一个注解是@RestController。这被称为构造型注解。它为阅读代码的人和Spring提供了关于类扮演特定角色的提示。在这种情况下，我们的类是一个web @Controller，因此Spring在处理传入的web请求时会考虑它。

@RequestMapping注解提供“路由”信息。它告诉Spring任何带有/路径的HTTP请求应映射到home方法。@RestController注解告诉Spring直接将结果字符串呈现给调用者。

@RestController和@RequestMapping注解是Spring MVC注解（它们不是Spring Boot特有的）。有关更多详细信息，请参阅Spring参考文档中的MVC部分。

4.5.2. @SpringBootApplication注解

第二个类级别的注解是@SpringBootApplication。这个注解被称为元注解，它结合了@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan。

其中，我们在这里最感兴趣的注解是@EnableAutoConfiguration。 @EnableAutoConfiguration告诉Spring Boot根据您添加的jar依赖项“猜测”您想要如何配置Spring。由于spring-boot-starter-web添加了Tomcat和Spring MVC，自动配置假定您正在开发一个web应用程序，并相应地设置Spring。

Starters和自动配置

自动配置设计与“Starters”配合使用，但这两个概念并不直接相关。您可以自由选择Starters之外的jar依赖项。Spring Boot仍然尽力自动配置您的应用程序。

4.5.3. “main”方法

我们应用程序的最后部分是main方法。这是一个遵循Java应用程序入口点惯例的标准方法。我们的main方法通过调用run委托给Spring Boot的SpringApplication类。 SpringApplication引导我们的应用程序，启动Spring，进而启动自动配置的Tomcat web服务器。我们需要将MyApplication.class作为参数传递给run方法，以告诉SpringApplication哪个是主要的Spring组件。还通过args数组传递以公开任何命令行参数。

4.6. 运行示例

4.6.1. Maven

此时，您的应用程序应该可以正常工作。由于您使用了spring-boot-starter-parent POM，您有一个有用的run目标，可以用来启动应用程序。从根项目目录键入mvn spring-boot:run启动应用程序。您应该看到类似以下输出：

$ mvn spring-boot:run

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v3.2.3)
....... . . .
....... . . . (这里是日志输出)
....... . . .
........ 在0.906秒内启动了MyApplication（进程运行了6.514秒）

如果您在web浏览器中打开localhost:8080，您应该看到以下输出：

Hello World!

要优雅地退出应用程序，请按ctrl-c。

4.6.2. Gradle

此时，您的应用程序应该可以正常工作。由于您使用了org.springframework.boot Gradle插件，您有一个有用的bootRun目标，可以用来启动应用程序。从根项目目录键入gradle bootRun启动应用程序。您应该看到类似以下输出：

$ gradle bootRun

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v3.2.3)
....... . . .
....... . . . (这里是日志输出)
....... . . .
........ 在0.906秒内启动了MyApplication（进程运行了6.514秒）

如果您在web浏览器中打开localhost:8080，您应该看到以下输出：

Hello World!

要优雅地退出应用程序，请按ctrl-c。

4.7. 创建可执行的Jar包

通过创建一个完全自包含的可执行的Jar文件来完成我们的示例，这样我们就可以在生产环境中运行。可执行的Jar包（有时被称为“超级Jar包”或“胖Jar包”）是包含您编译的类以及您的代码运行所需的所有Jar依赖项的存档文件。

可执行的Jar包和Java

Java没有提供一种标准的方式来加载嵌套的Jar文件（Jar文件本身包含在一个Jar中）。如果您希望分发一个自包含的应用程序，这可能会成为一个问题。

为了解决这个问题，许多开发人员使用“超级”Jar包。超级Jar包将所有应用程序依赖项的类打包到一个单独的存档文件中。这种方法的问题在于很难看出您的应用程序中有哪些库。如果多个Jar中使用相同的文件名（但内容不同），这也可能会成为问题。

Spring Boot采用了不同的方法，允许您直接嵌套Jar文件。

4.7.1. Maven

要创建一个可执行的Jar包，我们需要将spring-boot-maven-plugin添加到我们的pom.xml中。为此，请在dependencies部分的下面插入以下行：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>
spring-boot-starter-parent POM包含<executions>配置以绑定repackage目标。如果您不使用父POM，您需要自己声明此配置。有关详细信息，请参阅插件文档。

保存您的pom.xml并从命令行运行mvn package，如下所示：

$ mvn package

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building myproject 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] .... ..
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myproject ---
[INFO] Building jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar
[INFO]
[INFO] --- spring-boot-maven-plugin:3.2.3:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

如果您查看target目录，您应该会看到myproject-0.0.1-SNAPSHOT.jar。该文件大小约为18 MB。如果您想查看内部内容，可以使用jar tvf，如下所示：

$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar

您还应该在target目录中看到一个名为myproject-0.0.1-SNAPSHOT.jar.original的文件，这是Maven在被Spring Boot重新打包之前创建的原始Jar文件。

要运行该应用程序，请使用java -jar命令，如下所示：

$ java -jar target/myproject-0.0.1-SNAPSHOT.jar

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v3.2.3)
....... . . .
....... . . . (这里是日志输出)
....... . . .
........ 在0.999秒内启动了MyApplication（进程运行了1.253秒）

与之前一样，要退出应用程序，请按ctrl-c。

4.7.2. Gradle

要创建一个可执行的Jar包，我们需要从命令行运行gradle bootJar，如下所示：

$ gradle bootJar

BUILD SUCCESSFUL in 639ms
3 actionable tasks: 3 executed

如果您查看build/libs目录，您应该会看到myproject-0.0.1-SNAPSHOT.jar。该文件大小约为18 MB。如果您想查看内部内容，可以使用jar tvf，如下所示：

$ jar tvf build/libs/myproject-0.0.1-SNAPSHOT.jar

要运行该应用程序，请使用java -jar命令，如下所示：

$ java -jar build/libs/myproject-0.0.1-SNAPSHOT.jar

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v3.2.3)
....... . . .
....... . . . (这里是日志输出)
....... . . .
........ 在0.999秒内启动了MyApplication（进程运行了1.253秒）

与之前一样，要退出应用程序，请按ctrl-c。

5. 接下来阅读什么

希望这一节为您提供了一些Spring Boot的基础知识，并帮助您开始编写自己的应用程序。如果您是一位以任务为导向的开发人员，您可能想跳转到 spring.io 并查看一些解决特定“如何在Spring中实现这个功能？”问题的 入门指南。我们还有Spring Boot特定的“如何”参考文档。

否则，下一个合乎逻辑的步骤是阅读 using.html。如果您真的很着急，您也可以提前阅读关于 Spring Boot特性的内容。