开发您的第一个 Spring Boot 应用程序 (Developing Your First Spring Boot Application) _ Spring Boot 3.3.1 中文文档(官方文档中文翻译) —

本节介绍如何开发一个小型的“Hello World！”Web 应用程序，该应用程序突出了 Spring Boot 的一些关键功能。您可以选择 Maven 或 Gradle 作为构建系统。Spring中文文档

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

您可以通过转到 start.spring.io 并从依赖项搜索器中选择“Web”启动器来快捷执行以下步骤。这样做会生成一个新的项目结构，以便您可以立即开始编码。有关更多详细信息，请查看 start.spring.io 用户指南。Spring中文文档

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

先决条件

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

$ 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)

此示例需要在其自己的目录中创建。后续说明假定您已经创建了一个合适的目录，并且该目录是您的当前目录。

Maven

如果要使用 Maven，请确保已安装 Maven：Spring中文文档

$ 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

Gradle

如果要使用 Gradle，请确保已安装 Gradle：Spring中文文档

$ 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

此示例需要在其自己的目录中创建。后续说明假定您已经创建了一个合适的目录，并且该目录是您的当前目录。

使用 Maven 设置项目

我们需要从创建一个 Maven 文件开始。这是用于构建项目的配方。打开您喜欢的文本编辑器并添加以下内容：pom.xmlpom.xmlSpring中文文档

<?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.3.1</version>
	</parent>

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

	<!-- (you only need this if you are using a milestone or snapshot version) -->
	<repositories>
		<repository>
			<id>spring-snapshots</id>
			<url>https://repo.spring.io/snapshot</url>
			<snapshots><enabled>true</enabled></snapshots>
		</repository>
		<repository>
			<id>spring-milestones</id>
			<url>https://repo.spring.io/milestone</url>
		</repository>
	</repositories>
	<pluginRepositories>
		<pluginRepository>
			<id>spring-snapshots</id>
			<url>https://repo.spring.io/snapshot</url>
		</pluginRepository>
		<pluginRepository>
			<id>spring-milestones</id>
			<url>https://repo.spring.io/milestone</url>
		</pluginRepository>
	</pluginRepositories>
</project>

前面的列表应该会给你一个有效的版本。您可以通过运行来测试它（现在，您可以忽略“jar will be empty - no content was marked for inclusion！”警告）。mvn packageSpring中文文档

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

使用 Gradle 设置项目

我们需要从创建一个 Gradle 文件开始。这是用于生成项目的生成脚本。打开您喜欢的文本编辑器并添加以下内容：build.gradlebuild.gradleSpring中文文档

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

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

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

repositories {
	mavenCentral()
	maven { url 'https://repo.spring.io/milestone' }
	maven { url 'https://repo.spring.io/snapshot' }
}

dependencies {
}

前面的列表应该会给你一个有效的版本。您可以通过运行来测试它。gradle classesSpring中文文档

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

添加类路径依赖关系

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

Maven

大多数 Spring Boot 应用程序都使用 POM 的 in 部分。这是一个特殊的启动器，它提供了有用的 Maven 默认值。它还提供了一个依赖项管理部分，以便您可以省略“受祝福”依赖项的标签。spring-boot-starter-parentparentspring-boot-starter-parentversionSpring中文文档

由于我们正在开发 Web 应用程序，因此我们添加了一个依赖项。在此之前，我们可以通过运行以下命令来查看当前拥有的内容：spring-boot-starter-webSpring中文文档

$ mvn dependency:tree

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

该命令打印项目依赖项的树表示形式。您可以看到它本身不提供任何依赖项。要添加必要的依赖项，请编辑您的依赖项，并在该部分的正下方添加依赖项：mvn dependency:treespring-boot-starter-parentpom.xmlspring-boot-starter-webparentSpring中文文档

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

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

Gradle

大多数 Spring Boot 应用程序都使用 Gradle 插件。此插件提供了有用的默认值和 Gradle 任务。 Gradle 插件提供依赖项管理，以便您可以省略“受祝福”依赖项的标签。org.springframework.bootio.spring.dependency-managementversionSpring中文文档

$ gradle dependencies

> Task :dependencies

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

该命令打印项目依赖项的树表示形式。目前，该项目没有依赖项。若要添加必要的依赖项，请在以下部分中编辑并添加依赖项：gradle dependenciesbuild.gradlespring-boot-starter-webdependenciesSpring中文文档

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

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

编写代码

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

JavaSpring中文文档
KotlinSpring中文文档

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);
	}

}

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)
}

虽然这里没有太多的代码，但有很多事情正在发生。在接下来的几节中，我们将逐步介绍重要部分。Spring中文文档

@RestController和@RequestMapping注释

我们类的第一个注释是。这称为构造型批注。它为阅读代码的人和 Spring 提供了提示，说明该类扮演着特定的角色。在本例中，我们的类是一个 web ，因此 Spring 在处理传入的 Web 请求时会考虑它。MyApplication@RestController@ControllerSpring中文文档

注释提供“路由”信息。它告诉 Spring，任何带有路径的 HTTP 请求都应该映射到该方法。注解告诉 Spring 将生成的字符串直接呈现回调用方。@RequestMapping/home@RestControllerSpring中文文档

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

@SpringBootApplication注释

第二个类级注解是。此注释称为元注释，它结合了和。@SpringBootApplication@SpringBootConfiguration@EnableAutoConfiguration@ComponentScanSpring中文文档

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

启动器和自动配置

自动配置旨在与“入门器”很好地配合使用，但这两个概念并不直接相关。您可以自由选择启动器之外的 jar 依赖项。 Spring Boot 仍会尽最大努力自动配置您的应用程序。Spring中文文档

“main”方法

我们应用程序的最后一部分是方法。这是遵循应用程序入口点的 Java 约定的标准方法。我们的 main 方法通过调用来委托给 Spring Boot 的类。引导我们的应用程序，启动 Spring，而 Spring 又启动自动配置的 Tomcat Web 服务器。我们需要将参数传递给该方法，以判断哪个是主要的 Spring 组件。还会传递数组以公开任何命令行参数。mainSpringApplicationrunSpringApplicationMyApplication.classrunSpringApplicationargsSpring中文文档

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

运行示例

Maven

此时，您的应用程序应该可以正常工作。由于您使用了 POM，因此您有一个有用的目标，可用于启动应用程序。键入根项目目录以启动应用程序。您应看到类似于以下内容的输出：spring-boot-starter-parentrunmvn spring-boot:runSpring中文文档

$ mvn spring-boot:run

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v3.3.1)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.906 seconds (process running for 6.514)

如果打开 Web 浏览器，应看到以下输出：localhost:8080Spring中文文档

Hello World!

要正常退出应用程序，请按。ctrl-cSpring中文文档

Gradle

此时，您的应用程序应该可以正常工作。由于您使用了 Gradle 插件，因此您有一个有用的目标，您可以使用它来启动应用程序。键入根项目目录以启动应用程序。您应看到类似于以下内容的输出：org.springframework.bootbootRungradle bootRunSpring中文文档

$ gradle bootRun

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v3.3.1)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.906 seconds (process running for 6.514)

如果打开 Web 浏览器，应看到以下输出：localhost:8080Spring中文文档

Hello World!

要正常退出应用程序，请按。ctrl-cSpring中文文档

创建可执行 Jar

我们通过创建一个完全独立的可执行 jar 文件来完成我们的示例，我们可以在生产环境中运行该文件。可执行 jar（有时称为“uber jars”或“fat jars”）是包含已编译类以及代码运行所需的所有 jar 依赖项的存档。Spring中文文档

可执行 jar 和 Java

Java 没有提供加载嵌套 jar 文件（jar 文件本身包含在 jar 中的 jar 文件）的标准方法。如果您希望分发独立应用程序，这可能会有问题。Spring中文文档

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

Spring Boot 采用了不同的方法，让您直接嵌套 jar。Spring中文文档

Maven

要创建一个可执行的 jar，我们需要将添加到我们的 . 为此，请在该部分的正下方插入以下行：spring-boot-maven-pluginpom.xmldependenciesSpring中文文档

<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
		</plugin>
	</plugins>
</build>

POM 包括绑定目标的配置。如果不使用父 POM，则需要自行声明此配置。有关详细信息，请参阅插件文档。spring-boot-starter-parent<executions>repackage

保存并从命令行运行，如下所示：pom.xmlmvn packageSpring中文文档

$ 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.3.1:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

如果查看目录，则应看到 . 该文件的大小应约为 18 MB。如果想窥视内部，可以使用，如下所示：targetmyproject-0.0.1-SNAPSHOT.jarjar tvfSpring中文文档

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

您还应该看到目录中命名的一个小得多的文件。这是 Maven 在被 Spring Boot 重新打包之前创建的原始 jar 文件。myproject-0.0.1-SNAPSHOT.jar.originaltargetSpring中文文档

若要运行该应用程序，请使用以下命令：java -jarSpring中文文档

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

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v3.3.1)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.999 seconds (process running for 1.253)

和以前一样，要退出应用程序，请按。ctrl-cSpring中文文档

Gradle

要创建一个可执行的 jar，我们需要从命令行运行，如下所示：gradle bootJarSpring中文文档

$ gradle bootJar

BUILD SUCCESSFUL in 639ms
3 actionable tasks: 3 executed

如果查看目录，则应看到 . 该文件的大小应约为 18 MB。如果想窥视内部，可以使用，如下所示：build/libsmyproject-0.0.1-SNAPSHOT.jarjar tvfSpring中文文档

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

若要运行该应用程序，请使用以下命令：java -jarSpring中文文档

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

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v{version-spring-boot})
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.999 seconds (process running for 1.253)

和以前一样，要退出应用程序，请按。ctrl-cSpring中文文档

POM 包括绑定目标的配置。如果不使用父 POM，则需要自行声明此配置。有关详细信息，请参阅插件文档。spring-boot-starter-parent<executions>repackage