开始

1. Spring Boot 简介

Spring Boot 可帮助您创建可以运行的基于 Spring 的独立生产级应用程序。我们对 Spring 平台和第三方库持固执己见的看法，因此您可以毫不费力地开始使用。大多数 Spring Boot 应用程序只需要很少的 Spring 配置。spring-doc.cn

您可以使用 Spring Boot 创建可以使用或更传统的 war 部署启动的 Java 应用程序。java -jarspring-doc.cn

我们的主要目标是：spring-doc.cn

为所有 Spring 开发提供极其快速且可广泛访问的入门体验。spring-doc.cn
开箱即用，但当需求开始与默认值不同时，请迅速离开。spring-doc.cn
提供一系列大型项目通用的非功能性功能（例如嵌入式服务器、安全性、指标、运行状况检查和外部化配置）。spring-doc.cn
绝对不需要代码生成（当不针对本机图像时），也不需要 XML 配置。spring-doc.cn

2. 系统要求

Spring Boot 3.1.12 需要 Java 17，并且与 Java 21 兼容。还需要 Spring Framework 6.0.21 或更高版本。spring-doc.cn

为以下构建工具提供显式构建支持：spring-doc.cn

构建工具	版本
Maven 系列spring-doc.cn	3.6.3 或更高版本spring-doc.cn
Gradlespring-doc.cn	7.x（7.5 或更高版本）和 8.xspring-doc.cn

构建工具

版本

Maven 系列spring-doc.cn

3.6.3 或更高版本spring-doc.cn

Gradlespring-doc.cn

7.x（7.5 或更高版本）和 8.xspring-doc.cn

2.1. Servlet 容器

Spring Boot 支持以下嵌入式 servlet 容器：spring-doc.cn

名字	Servlet 版本
Tomcat 10.1 版本spring-doc.cn	6.0spring-doc.cn
Jetty 11.0spring-doc.cn	5.0spring-doc.cn
暗流 2.3spring-doc.cn	6.0spring-doc.cn

名字

Servlet 版本

Tomcat 10.1 版本spring-doc.cn

6.0spring-doc.cn

Jetty 11.0spring-doc.cn

5.0spring-doc.cn

暗流 2.3spring-doc.cn

6.0spring-doc.cn

您还可以将 Spring Boot 应用程序部署到任何与 servlet 5.0+ 兼容的容器。spring-doc.cn

2.2. GraalVM 原生镜像

Spring Boot 应用程序可以使用 GraalVM 22.3 或更高版本转换为本机映像。spring-doc.cn

可以使用 GraalVM 提供的原生构建工具 Gradle/Maven 插件或工具创建映像。您还可以使用 native-image Paketo buildpack 创建原生镜像。native-imagespring-doc.cn

支持以下版本：spring-doc.cn

名字	版本
GraalVM 社区spring-doc.cn	22.3spring-doc.cn
原生构建工具spring-doc.cn	0.9.28spring-doc.cn

名字

版本

GraalVM 社区spring-doc.cn

22.3spring-doc.cn

原生构建工具spring-doc.cn

0.9.28spring-doc.cn

3. 安装 Spring Boot

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

$ java -version

如果您不熟悉 Java 开发，或者想尝试 Spring Boot，则可能需要先尝试 Spring Boot CLI（命令行界面）。否则，请继续阅读 “经典” 安装说明。spring-doc.cn

3.1. Java 开发人员的安装说明

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

尽管您可以复制 Spring Boot jar，但我们通常建议您使用支持依赖项管理的构建工具（例如 Maven 或 Gradle）。spring-doc.cn

3.1.1. Maven 安装

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

在许多操作系统上，Maven 可以与包管理器一起安装。如果您使用 OSX Homebrew，请尝试。 Ubuntu 用户可以运行 . 使用 Chocolatey 的 Windows 用户可以从提升的（管理员）提示符运行。brew install mavensudo apt-get install mavenchoco install maven

Spring Boot 依赖项使用组 ID。通常，您的 Maven POM 文件继承自项目，并将依赖项声明给一个或多个 “Starters”。 Spring Boot 还提供了一个可选的 Maven 插件来创建可执行 jar。org.springframework.bootspring-boot-starter-parentspring-doc.cn

有关 Spring Boot 和 Maven 入门的更多详细信息，请参阅 Maven 插件参考指南的入门部分。spring-doc.cn

3.1.2. Gradle 安装

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

Spring Boot 依赖项可以使用 . 通常，您的项目会声明对一个或多个 “Starters” 的依赖关系。 Spring Boot 提供了一个有用的 Gradle 插件，可用于简化依赖项声明和创建可执行 jar。org.springframework.bootgroupspring-doc.cn

Gradle 包装器

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

有关 Spring Boot 和 Gradle 入门的更多详细信息，请参阅 Gradle 插件参考指南的入门部分。spring-doc.cn

3.2. 安装 Spring Boot CLI

Spring Boot CLI（命令行界面）是一个命令行工具，可用于快速使用 Spring 进行原型设计。spring-doc.cn

您不需要使用 CLI 来使用 Spring Boot，但这是在没有 IDE 的情况下启动 Spring 应用程序的快速方法。spring-doc.cn

3.2.1. 手动安装

您可以从以下位置之一下载 Spring CLI 发行版：spring-doc.cn

下载后，请按照解压后的存档中的INSTALL.txt说明进行操作。总之，在文件的目录中有一个脚本（适用于 Windows）。或者，您也可以使用该文件（该脚本可帮助您确保 Classpath 设置正确）。springspring.batbin/.zipjava -jar.jarspring-doc.cn

3.2.2. 使用 SDKMAN 安装！

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

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

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

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

上述说明安装名为 instance 的本地实例。它指向您的目标构建位置，因此每次重新构建 Spring Boot 时，它都是最新的。springdevspringspring-doc.cn

您可以通过运行以下命令来查看它：spring-doc.cn

$ sdk ls springboot

================================================================================
Available Springboot Versions
================================================================================
> + dev
* 3.1.12

================================================================================
+ - local version
* - installed
> - currently in use
================================================================================

3.2.3. OSX Homebrew 安装

如果您使用的是 Mac 并使用 Homebrew，则可以使用以下命令安装 Spring Boot CLI：spring-doc.cn

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

Homebrew 安装到。spring/usr/local/binspring-doc.cn

如果您没有看到公式，则您的 brew 安装可能已过期。在这种情况下，请运行并重试。brew update

3.2.4. MacPorts 安装

如果您使用的是 Mac 并使用 MacPorts，则可以使用以下命令安装 Spring Boot CLI：spring-doc.cn

$ sudo port install spring-boot-cli

3.2.5. 命令行补全

Spring Boot CLI 包括为 BASH 和 zsh shell 提供命令完成的脚本。您可以在任何 shell 中使用脚本（也称为），也可以将其放在您个人或系统范围的 bash 完成初始化中。在 Debian 系统上，系统范围的脚本都在其中，并且该目录中的所有脚本都会在新的 shell 启动时执行。例如，如果已使用 SDKMAN！进行安装，要手动运行脚本，请使用以下命令：sourcespring<installation location>/shell-completion/bashspring-doc.cn

$ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring
$ spring <HIT TAB HERE>
  grab  help  jar  run  test  version

如果使用 Homebrew 或 MacPorts 安装 Spring Boot CLI，则命令行完成脚本会自动注册到 shell。

3.2.6. Windows Scoop 安装

如果您使用的是 Windows 并使用 Scoop，则可以使用以下命令安装 Spring Boot CLI：spring-doc.cn

> scoop bucket add extras
> scoop install springboot

Scoop 安装到。spring~/scoop/apps/springboot/current/binspring-doc.cn

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

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

本节介绍如何开发一个小型的 “Hello World！” Web 应用程序，其中重点介绍了 Spring Boot 的一些关键功能。您可以选择 Maven 或 Gradle 作为构建系统。spring-doc.cn

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

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

4.1. 先决条件

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

$ 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：spring-doc.cn

$ 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：spring-doc.cn

$ 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.xmlpom.xmlspring-doc.cn

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

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

</project>

前面的清单应该为您提供一个有效的版本。您可以通过运行来测试它（现在，您可以忽略 “jar will be empty - no content was marked for inclusion！” 警告）。mvn packagespring-doc.cn

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

4.3. 使用 Gradle 设置项目

我们需要先创建一个 Gradle 文件。这是用于生成项目的生成脚本。打开您最喜欢的文本编辑器并添加以下内容：build.gradlebuild.gradlespring-doc.cn

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

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

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

repositories {
    mavenCentral()
}

dependencies {
}

前面的清单应该为您提供一个有效的版本。您可以通过运行来测试它。gradle classesspring-doc.cn

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

4.4. 添加 Classpath 依赖项

Spring Boot 提供了许多“Starters”，允许您将 jar 添加到 Classpath 中。 “Starters” 提供您在开发特定类型的应用程序时可能需要的依赖项。spring-doc.cn

4.4.1. Maven 浏览器

大多数 Spring Boot 应用程序在 POM 的部分中使用。这是一个特殊的 starter，可提供有用的 Maven 默认值。它还提供了一个 dependency-management 部分，以便您可以省略 “blessed” 依赖项的标签。spring-boot-starter-parentparentspring-boot-starter-parentversionspring-doc.cn

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

$ mvn dependency:tree

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

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

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

如果再次运行，您会看到现在还有许多其他依赖项，包括 Tomcat Web 服务器和 Spring Boot 本身。mvn dependency:treespring-doc.cn

4.4.2. Gradle

大多数 Spring Boot 应用程序都使用 Gradle 插件。此插件提供有用的默认值和 Gradle 任务。 Gradle 插件提供依赖项管理，因此您可以省略 “blessed” 依赖项的标签。org.springframework.bootio.spring.dependency-managementversionspring-doc.cn

$ gradle dependencies

> Task :dependencies

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

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

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

如果再次运行，您会看到现在还有许多其他依赖项，包括 Tomcat Web 服务器和 Spring Boot 本身。gradle dependenciesspring-doc.cn

4.5. 编写代码

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

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

虽然这里没有太多代码，但有很多事情要做。在接下来的几节中，我们将逐步介绍重要部分。spring-doc.cn

4.5.1. @RestController 和 @RequestMapping 注解

我们类上的第一个注释是 . 这称为 stereotype annotation。它为阅读代码的人和 Spring 提供了提示，表明类起着特定的作用。在这种情况下，我们的类是 web ，因此 Spring 在处理传入的 Web 请求时会考虑它。MyApplication@RestController@Controllerspring-doc.cn

注释提供 “routing” 信息。它告诉 Spring 任何带有该路径的 HTTP 请求都应该映射到该方法。 Comments 告诉 Spring 将结果字符串直接呈现给调用者。@RequestMapping/home@RestControllerspring-doc.cn

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

4.5.2. @SpringBootApplication 注解

第二个类级注释是 . 此注释称为元注释，它结合了和。@SpringBootApplication@SpringBootConfiguration@EnableAutoConfiguration@ComponentScanspring-doc.cn

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

Starters和自动配置

自动配置旨在与 “Starters” 很好地配合，但这两个概念并没有直接联系在一起。您可以在 starter 之外自由挑选 jar 依赖项。 Spring Boot 仍然尽最大努力自动配置您的应用程序。spring-doc.cn

4.5.3. “main” 方法

我们应用程序的最后一部分是方法。这是遵循应用程序入口点的 Java 约定的标准方法。我们的 main 方法通过调用 . 引导我们的应用程序，启动 Spring，而 Spring 又启动自动配置的 Tomcat Web 服务器。我们需要将参数作为参数传递给方法，以判断哪个是主要的 Spring 组件。该数组也被传递以公开任何命令行参数。mainSpringApplicationrunSpringApplicationMyApplication.classrunSpringApplicationargsspring-doc.cn

4.6. 运行示例

4.6.1. Maven

此时，您的应用程序应该可以正常工作。由于您使用了 POM，因此您有一个有用的目标，可用于启动应用程序。键入 from the root project directory 以启动应用程序。您应该会看到类似于以下内容的输出：spring-boot-starter-parentrunmvn spring-boot:runspring-doc.cn

$ mvn spring-boot:run

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

如果打开 Web 浏览器，您应该会看到以下输出：localhost:8080spring-doc.cn

Hello World!

要正常退出应用程序，请按。ctrl-cspring-doc.cn

4.6.2. Gradle

此时，您的应用程序应该可以正常工作。由于您使用了 Gradle 插件，因此您有一个有用的目标，可用于启动应用程序。键入 from the root project directory 以启动应用程序。您应该会看到类似于以下内容的输出：org.springframework.bootbootRungradle bootRunspring-doc.cn

$ gradle bootRun

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

如果打开 Web 浏览器，您应该会看到以下输出：localhost:8080spring-doc.cn

Hello World!

要正常退出应用程序，请按。ctrl-cspring-doc.cn

4.7. 创建可执行 Jar

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

可执行 jar 和 Java

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

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

Spring Boot 采用不同的方法，让您实际上直接嵌套 jar。spring-doc.cn

4.7.1. Maven 浏览器

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

<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-doc.cn

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

如果查看目录，您应该会看到。文件大小应约为 18 MB。如果要窥视内部，可以使用，如下所示：targetmyproject-0.0.1-SNAPSHOT.jarjar tvfspring-doc.cn

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

您还应该看到一个名为的 directory 中小得多的文件。这是 Maven 在 Spring Boot 重新打包之前创建的原始 jar 文件。myproject-0.0.1-SNAPSHOT.jar.originaltargetspring-doc.cn

要运行该应用程序，请使用以下命令：java -jarspring-doc.cn

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

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

和以前一样，要退出应用程序，请按。ctrl-cspring-doc.cn

4.7.2. Gradle

要创建可执行 jar，我们需要从命令行运行，如下所示：gradle bootJarspring-doc.cn

$ gradle bootJar

BUILD SUCCESSFUL in 639ms
3 actionable tasks: 3 executed

如果查看目录，您应该会看到。文件大小应约为 18 MB。如果要窥视内部，可以使用，如下所示：build/libsmyproject-0.0.1-SNAPSHOT.jarjar tvfspring-doc.cn

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

要运行该应用程序，请使用以下命令：java -jarspring-doc.cn

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

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

和以前一样，要退出应用程序，请按。ctrl-cspring-doc.cn

5. 接下来要读什么

希望本节提供了一些 Spring Boot 基础知识，并帮助您编写自己的应用程序。如果你是一个面向任务的开发人员类型，你可能想跳到 spring.io 并遵循一些解决特定 “如何使用 Spring 实现该操作 ”问题的入门指南。我们还有特定于 Spring Boot 的 “How-to” 参考文档。spring-doc.cn

否则，下一个逻辑步骤是读取 using.html。如果你真的没有耐心，你也可以跳到前面阅读 Spring Boot 功能。spring-doc.cn