入门

本站(springdoc.cn)中的内容来源于 spring.io ，原始版权归属于 spring.io。由 springdoc.cn 进行翻译，整理。可供个人学习、研究，未经许可，不得进行任何转载、商用或与之相关的行为。商标声明：Spring 是 Pivotal Software, Inc. 在美国以及其他国家的商标。

如果你正在开始使用Spring Boot，或一般的 "Spring"，请先阅读本节。它回答了基本的 "什么"、"如何" 和 "为什么"的问题。它包括对Spring Boot的介绍，以及安装说明。然后，我们将引导你构建你的第一个Spring Boot应用程序，在此过程中讨论一些核心原则。

1. Spring Boot 介绍

Spring Boot帮助你创建可以运行的独立的、基于Spring的生产级应用程序。我们对Spring平台和第三方库采取了有主见的观点，这样你就能以最少的麻烦开始工作。大多数Spring Boot应用程序只需要很少的Spring配置。

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

我们的主要目标是。

为所有的Spring开发提供一个根本性的更快、更广泛的入门体验。
开箱即用，但随着需求开始偏离默认值，请迅速摆脱困境。
提供一系列大类项目常见的非功能特性（如嵌入式服务器、安全、度量、健康检查和外部化配置）。
绝对没有代码生成（当不以原生镜像为目标时），也不要求XML配置。

2. 系统要求

Spring Boot 3.2.0-SNAPSHOT 需要 Java 17 ，并且可以兼容到Java 20，包括Java 20。还需要 Spring Framework 6.1.0-M1 或以上版本。

为以下构建工具提供了明确的构建支持。

构建工具	版本
Maven	3.6.3 及其以上
Gradle	7.x （7.5 及其以上）和 8.x

构建工具

版本

Maven

3.6.3 及其以上

Gradle

7.x （7.5 及其以上）和 8.x

2.1. Servlet 容器

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

Servlet 容器	Servlet 版本
Tomcat 10.0	5.0
Jetty 11.0	5.1
Undertow 2.2 (Jakarta EE 9 variant)	5.0

你也可以将Spring Boot应用部署到任何兼容Servlet 5.0+的容器中。

2.2. GraalVM 原生镜像

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

镜像可以通过本地构建工具 Gradle/Maven插件或GraalVM提供的 native-image 工具来创建。你也可以使用 native-image Paketo buildpack 来创建原生镜像。

支持以下版本。

名称	版本
GraalVM Community	22.3
Native Build Tools	0.9.23

名称

版本

GraalVM Community

22.3

Native Build Tools

0.9.23

3. 安装 Spring Boot

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

$ java -version

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

3.1. 为Java开发者提供的安装说明

你可以以与任何标准Java库相同的方式使用Spring Boot。要做到这一点，在你的classpath上包括适当的 spring-boot-*.jar 文件。 Spring Boot不需要任何特殊的工具集成，所以你可以使用任何IDE或文本编辑器。另外，Spring Boot应用程序没有什么特别之处，所以你可以像运行其他Java程序一样运行和调试Spring Boot应用程序。

虽然你可以直接复制 Spring Boot的jar，但我们一般建议你使用支持依赖管理的构建工具（如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用户可以在命令行（administrator）中运行 choco install maven 。

Spring Boot依赖的 group Id 为 org.springframework.boot。通常，你的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的依赖的 group 为 org.springframework.boot。通常情况下，你的项目会声明对一个或多个 “Starters” 的依赖关系。Spring Boot提供了一个有用的Gradle plugin，可以用来简化依赖性声明和创建可执行的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，但它是一种快速的方法，可以在没有IDE的情况下让Spring应用落地。

3.2.1. 手动安装

你可以从 Spring software repository 中下载 spring-boot-cli-*-bin.zip 或 spring-boot-cli-*-bin.tar.gz。

下载后，按照解压后的档案中的 INSTALL.txt 说明操作。总之，在.zip文件的 bin/ 目录下有一个 spring 脚本（Windows的是 spring.bat ）。或者，你可以使用 java -jar 来执行 .jar 文件（脚本可以帮助你确定classpath是否设置正确）。

3.2.2. 使用SDKMAN进行安装!

SDKMAN! (The Software Development Kit Manager)可用于管理各种二进制SDK的多个版本，包括Groovy和Spring Boot CLI。从 sdkman.io 获取SDKMAN！并通过使用以下命令安装Spring Boot。

$ sdk install springboot
$ spring --version
Spring CLI v3.2.0-SNAPSHOT

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

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

前面的说明安装了一个 spring 的本地实例，称为 dev 实例。它指向你的目标构建位置，所以每次你重建Spring Boot时， spring 都是最新的。

你可以通过运行以下命令看到它。

$ sdk ls springboot

================================================================================
Available Springboot Versions
================================================================================
> + dev
* 3.2.0-SNAPSHOT

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

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中使用该脚本（也被命名为spring），或者把它放在个人或全系统的bash完成初始化中。在Debian系统中，全系统的脚本都在 /shell-completion/bash 中，当一个新的shell启动时，该目录中的所有脚本都会被执行。例如，如果你是通过使用SDKMAN！安装的，要手动运行该脚本，请使用以下命令。

$ . ~/.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。

> scoop bucket add extras
> scoop install springboot

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

如果你没有看到应用程序清单（app manifest），你安装的scoop可能已经过期。在这种情况下，运行 scoop update，再试一次。

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

本节介绍了如何开发一个小型的 “Hello World!” web应用，突出了Spring Boot的一些关键特性。你可以选择Maven或Gradle作为构建系统。

spring.io 网站上有许多使用Spring Boot的 "入门" 指南。如果你需要解决一个具体的问题，可以先去那里看看。

你可以通过进入 start.spring.io ，并从依赖搜索器中选择 "Web" stater 来缩短下面的步骤。这样做会生成一个新的项目结构，这样你就可以马上开始编码。查看 start.spring.io 用户指南以了解更多细节。

译者注：如果你是中国用户，推荐使用 https://start.springboot.io/ 。这是由 Spring Boot中文社区提供的镜像服务，节点在香港，比官方的服务会快很多。

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.0-SNAPSHOT</version>
    </parent>

    <!-- 将在此添加其他行... -->

    <!-- ((只有当你使用 milestone 或 snapshot 版本时，你才需要这个。)) -->
    <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>

前面的列表应该能让你运行构建工作了。你可以通过运行 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.0-SNAPSHOT'
}

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

前面的列表应该给你一个 working build。你可以通过运行 gradle 类来测试它。

在这一点上，你可以把项目导入IDE（大多数现代的Java IDE都包括对Gradle的内置支持）。为了简单起见，我们在这个例子中继续使用纯文本编辑器。

4.4. 添加依赖到 classpath

Spring Boot提供了一些 “Starter”，让你把 jar 添加到你的classpath。“Starter” 提供了你在开发特定类型的应用程序时可能需要的依赖。

4.4.1. Maven

大多数Spring Boot应用在POM的 parent 部分使用 spring-boot-starter-parent。 spring-boot-starter-parent 是一个特殊的starter，提供有用的Maven默认值。它还提供了一个 dependency-management 部分，这样你就可以省略 “blessed” 依赖的 version 标签。

译者注：spring-boot-starter-parent 是一个特殊的starter，它在POM.xml 的 dependency-management 里面声明了spring boot的各个依赖及其版本。子项目直接继承它，子项在导入 spring boot 依赖时，不需要声明版本号。

由于我们正在开发一个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 task。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 本身。

4.5. 编写代码

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

Java

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在背后帮我们做了很多事情。我们在接下来的几节中逐步介绍重要的部分。

4.5.1. @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部分。

4.5.2. @SpringBootApplication 注解

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

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

Starters 和 Auto-configuration（自动配置）

自动配置的设计是为了与 "Starter "很好地合作，但这两个概念并不直接挂钩。你可以自由选择 Starter 之外的jar依赖。 Spring Boot仍然会尽力自动配置你的应用程序。

4.5.3. “main” 方法

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

4.6. 运行 Example

4.6.1. Maven

此时，你的应用程序应该可以工作啦。由于你使用了 spring-boot-starter-parent POM，所以你有一个有用的 run target，你可以用它来启动该应用程序。在项目根目录下输入 mvn spring-boot:run 来启动应用程序。你应该看到类似以下的输出。

$ mvn spring-boot:run

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

打开你的浏览器，访问 localhost:8080 ，你应该看到以下输出。

Hello World!

通过按 ctrl-c 来优雅的退出程序。

4.6.2. Gradle

此似乎，你的应用程序应该可以工作。由于你使用了 org.springframework.boot Gradle插件，你有一个有用的 bootRun goal，你可以用它来启动该应用程序。在项目根目录下输入 gradle bootRun 来启动应用程序。你应该看到类似以下的输出：

$ gradle bootRun

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

如果你打开网页浏览器，localhost:8080，你应该看到以下输出：

Hello World!

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

4.7. 创建一个可执行 Jar

我们可以把这个例子打包为一个独立可执行jar包，它完全可以运行在生产环境中。可执行的jar文件（有时被称为 “fat jar”）是包含你的编译类以及你的代码运行所需的所有jar依赖项的压缩包。

可执行 jar 和 Java

Java没有提供一个标准的方法来加载嵌套的jar文件（jar文件本身包含在jar中）。如果你想发布一个独立的应用程序，这可能是个问题。

为了解决这个问题，许多开发者使用 “uber” jar。uber jar将所有应用程序依赖的所有类打包成一个单一的压缩包。这种方法的问题是，很难看到哪些库在你的应用程序中。如果在多个jar中使用相同的文件名（但内容不同），也会产生问题。

Spring Boot采取了一种不同的做法，让你直接嵌套jar。

4.7.1. Maven

为了创建一个可执行的jar，我们需要在 pom.xml 中添加 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> 配置来绑定重新打包的目标。如果你不使用父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.0-SNAPSHOT:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

如果你查看 target 目录，你应该看到 myproject-0.0.1-SNAPSHOT.jar。这个文件的大小应该在18MB左右。如果你想看看这jar里面到底有什么东西，你可以使用 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 命令来运行这个可执行jar程序，如下所示。

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

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v3.2.0-SNAPSHOT)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.999 seconds (process running for 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。这个文件的大小应该在18MB左右。如果你想偷看里面，你可以使用 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.0-SNAPSHOT)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.999 seconds (process running for 1.253)

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

5. 接下来读什么

希望本节提供的 Spring Boot 基础知识，能让你开始编写自己的应用程序。如果你是一个面向任务的开发者，你可能想跳到 spring.io ，并通过一些入门指南，解决具体的 "我如何用 Spring 实现这个？" 问题。我们也有专门针对 Spring Boot 的 “How-to” 参考文档。

否则，下一个合乎逻辑的步骤是阅读 开始使用 Spring Boot 。如果你真的没有耐心，你也可以跳到前面去读 Spring Boot 特性。