开发您的第一个 Spring Boot 应用程序

本节描述如何开发一个小的 “Hello World!” Web 应用程序，展示 Spring Boot 的一些关键功能。 您可以选择 Maven 或 Gradle 作为构建系统。

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

您可以通过访问 start.spring.io 并在依赖搜索中选择 "Web" starter 来简化以下步骤。 这样做会生成一个新的项目结构，以便您可以 立即开始编码。 有关更多详细信息，请查看 start.spring.io 用户指南。

前提条件

在开始之前，打开终端并运行以下命令，以确保您已安装有效版本的 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)
此示例需要在自己的目录中创建。 后续说明假设您已创建了一个合适的目录，并且它是您当前的目录。

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

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

使用 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>{version spring-boot}</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）。 为简单起见，我们在此示例中继续使用纯文本编辑器。

使用 Gradle 设置项目

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

plugins {
    id 'java'
    id 'org.springframework.boot' version '{version spring-boot}'
}

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）。 为简单起见，我们在此示例中继续使用纯文本编辑器。

添加类路径依赖

Spring Boot 提供了许多 starter，允许您将 jar 添加到类路径中。 Starter 提供了开发特定类型应用程序时可能需要的依赖。

Maven

大多数 Spring Boot 应用程序在 POM 的 parent 部分使用 spring-boot-starter-parent。 spring-boot-starter-parent 是一个特殊的 starter，提供有用的 Maven 默认配置。 它还提供一个 dependency-management 部分，以便您可以省略 “blessed” 依赖的 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 本身。

Gradle

大多数 Spring Boot 应用程序使用 org.springframework.boot Gradle 插件。 此插件提供有用的默认配置和 Gradle 任务。 io.spring.dependency-management Gradle 插件提供 依赖管理，以便您可以省略 “blessed” 依赖的 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 本身。

编写代码

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

  • Java

  • Kotlin

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

}
package com.example

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

虽然这里的代码不多，但发生了很多事情。 我们在接下来的几个部分中逐步讲解重要部分。

@RestController 和 @RequestMapping 注解

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

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

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

@SpringBootApplication 注解

第二个类级注解是 @SpringBootApplication。 此注解被称为 meta-annotation，它结合了 @SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan。

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

Starters 和自动配置

自动配置设计为与 starter 配合良好，但这两个概念并非直接关联。 您可以自由选择 starter 之外的 jar 依赖。 Spring Boot 仍会尽力自动配置您的应用程序。

“main” 方法

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

运行示例

Maven

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

$ mvn spring-boot:run

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

如果您打开 Web 浏览器访问 localhost:8080，您应该看到以下输出：

Hello World!

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

Gradle

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

$ gradle bootRun

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

如果您打开 Web 浏览器访问 localhost:8080，您应该看到以下输出：

Hello World!

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

创建可执行 Jar

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

可执行 jar 和 Java

Java 不提供加载嵌套 jar 文件（即包含在 jar 文件中的 jar 文件）的标准方式。 如果您希望分发自包含的应用程序，这可能会成为问题。

为解决此问题，许多开发者使用 “uber” jar。 Uber jar 将应用程序所有依赖中的所有类打包到一个单一归档文件中。 这种方法的缺点是难以看出应用程序中包含哪些库。 如果多个 jar 中使用了相同的文件名（但内容不同），也可能出现问题。

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

Maven

要创建可执行 jar，我们需要在 pom.xml 中添加 spring-boot-maven-plugin。 为此，在 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 目标。 如果您不使用 parent 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:{version spring-boot}: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 创建的原始 jar 文件，在被 Spring Boot 重新打包之前。

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

$ java -jar target/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-c。

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 ::  (v{version spring-boot})
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.999 seconds (process running for 1.253)

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