编程开发 --- springboot参考文档之入门和升级
版权声明 spring.io © 2012-2024
您可以复制本文件供自己使用或分发给他人，但不得收取任何费用，而且每份复制件都必须包含本版权声明，无论是以印刷品还是电子方式分发。
https://github.com/graalvm/native-build-tools
https://github.com/paketo-buildpacks/native-image
第 4 章 入门
如果您要开始学习 Spring Boot 或一般意义上的 "Spring"，请先阅读本节内容。它回答了 "它是什么？"、"怎么做？"和 "为什么？"等基本问题。其中包括 Spring Boot 简介和安装说明。然后，我们将引导您构建第一个 Spring Boot 应用程序，并讨论一些核心原则。
4.1. Spring Boot 简介
Spring Boot 可以帮助您创建独立的、基于 Spring 的生产级应用程序，并可以直接运行。我们对 Spring 平台和第三方库持开放的态度，因此您可以轻松上手。大多数 Spring Boot 应用程序只需要很少的 Spring 配置。
您可以使用 Spring Boot 创建 Java 应用程序，这些应用程序可以通过使用 java -jar 或更传统的 war 部署来启动。
我们的主要目标是
- 为所有 Spring 开发提供更快、更广泛的入门体验。
- 开始时要有主见，但当需求开始偏离默认值时，要迅速摆脱困境。（译者注：这里的意思就是说他是 约定大于配置，在通俗讲比如我们使用一款软件，打开后需要先做一大堆配置，比如配置项目路径、配置网卡、配置界面风格、配置语言环境、配置时区才能使用体验好，还是说不要做任何配置开箱即用，一切配置保持默认，之后在修改来的好。再举一个开发的例子，springboot内嵌tomcat服务器，如果我们不做任何配置，spirngboot会自动配置好，端口在8080，但是我们还是可以通过修改配置文件的方式修改端口号）
- 提供一系列大型项目常用的非业务性功能（例如嵌入式服务器、安全性、指标、运行状况检查和外部化配置）。
- 完全不需要生成代码（当不针对本地镜像时），也不需要 XML 配置。（译者注；在生成本地镜像时，GraalVM 通常会进行一些代码生成。GraalVM 是一个开源的、高性能的、通用的虚拟机，它支持多种语言，并具有即时编译（JIT）和 Ahead-of-Time（AOT）编译的能力。在创建本地镜像时，GraalVM 可以使用 AOT 编译器来预编译应用程序的 Java 代码，以及其他语言的代码，生成本地机器代码，从而使应用程序能够以本地执行而不需要 JVM。这种编译过程涉及到对应用程序代码的分析和优化，因此可以被认为是一种代码生成。总的来说，当使用 GraalVM 创建本地镜像时，会涉及到代码生成过程，但这与传统意义上在运行时动态生成代码是不同的。GraalVM 的代码生成是在构建过程中进行的，用于生成可执行的本地机器代码，而不是在应用程序运行时动态生成代码。这里我想解释一下什么是代码生成，有编写时代码生成、编译时代码生成和运行时代码生成，编写时代码生成是说我们在写代码时自动生成一些前端和后端代码加速开发，编译时代码生成是指在编译代码时又生成成了一些代码，运行时代码生成是指在运行一个程序时通过一些框架自动生成sql代码去执行，这里spring所谓的代码生成应该时编译时代码生成，但是还是需要运行时代码生成）
4.2. 系统要求
Spring Boot 3.2.2 需要
Java 17，并兼容 Java 21（含 Java 21）。
Spring 框架还需要 6.1.3 或更高版本。
为以下构建工具提供了明确的构建支持：
|
构建工具 |
版本 |
|
Maven |
3.6.3 或更高版本 |
|
Gradle |
7.x（7.5 或更高版本）和 8.x |
4.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+ 的容器中。
4.2.2. GraalVM 本地镜像
Spring Boot 应用程序可使用 GraalVM 22.3 或更高版本转换为本地镜像。
可以使用 本地构建工具 Gradle/Maven 插件或GraalVM 提供的工具创建镜像。你也可以使用 native-image Paketo buildpack 创建本地镜像。
支持以下版本
|
名称 |
版本 |
|
GraalVM 社区 |
22.3 |
|
本地构建工具 |
0.9.28 |
4.3. 安装 Spring Boot
Spring Boot 可与 "经典 "Java 开发工具一起使用，也可作为命令行工具安装。无论哪种方式，您都需要 Java SDK v17 或更高版本。开始之前，应使用以下命令检查当前的 Java 安装：
$ java -version
如果您是 Java 开发新手或想尝试使用 Spring Boot，您可能想先试试 Spring Boot CLI（命令行界面）。否则，请继续阅读 "经典 "安装说明。
4.3.1. Java 开发人员安装说明
您可以像使用任何标准 Java 库一样使用 Spring Boot。为此，请在 classpath 中包含相应的 spring-boot-*.jar 文件。Spring Boot 不需要任何特殊的集成工具，因此您可以使用任何集成开发环境或文本编辑器。此外，Spring Boot 应用程序也没有什么特别之处，因此您可以像运行其他 Java 程序一样运行和调试 Spring Boot 应用程序。
虽然您可以复制 Spring Boot jars，但我们通常建议您使用支持依赖管理的构建工具（如 Maven 或 Gradle）。
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 项目，并声明对一个或多个 "启动器 "的依赖。Spring Boot 还提供了一个可选的 Maven 插件，用于创建可执行的 jar。
有关 Spring Boot 和 Maven 入门的更多详情，请参阅 Maven 插件参考指南的 "入门 "部分。
Gradle 安装
Spring Boot 兼容 Gradle 7.x（7.5 或更高版本）和 8.x。如果尚未安装 Gradle，可以按照 gradle.org 上的说明进行安装。
Spring Boot 依赖项可以通过使用 org.springframework.boot 组来声明。通常，项目会声明对一个或多个 "启动器 "的依赖。Spring Boot 提供了一个有用的 Gradle 插件，可用于简化依赖关系声明和创建可执行 jar。
Gradle 包装器
当你需要构建一个项目时，Gradle Wrapper 提供了一种 "获取 "Gradle 的好方法。它是一个小脚本和库，与代码一起提交，用于引导构建过程。详情请参阅 docs.gradle.org/current/userguide/gradle_wrapper.html。 （译者注：Gradle Wrapper 是 Gradle 构建工具提供的一个功能，它允许您在项目中包含 Gradle 的特定版本，并且不需要在系统中预先安装 Gradle。通过 Gradle Wrapper，您可以确保每个人在构建项目时都使用相同版本的 Gradle，而无需手动安装和配置 Gradle。）
有关 Spring Boot 和 Gradle 入门的更多详情，请参阅 Gradle 插件参考指南的 "入门 "部分。
4.3.2. 安装 Spring Boot CLI
Spring Boot CLI（命令行界面）是一种命令行工具，可用于快速创建 Spring 的原型。
您不需要使用 CLI 来使用 Spring Boot，但它是一种无需集成开发环境即可快速启动 Spring 应用程序的方法。
手动安装
您可以从以下位置下载 Spring CLI 发行版：
下载完成后，请按照解压压缩包中的 INSTALL.txt 说明进行操作。总之，.zip 文件的 bin/ 目录中有一个 Spring 脚本（Windows 版本为 spring.bat）。或者，你也可以使用 java -jar 来运行 .jar 文件（该脚本可帮助你确保正确设置了 classpath）。
使用 SDKMAN 安装！
SDKMAN！(软件开发工具包管理器）可用于管理各种二进制 SDK 的多个版本，包括 Groovy 和 Spring Boot CLI。从 sdkman.io 获取 SDKMAN! 并使用以下命令安装 Spring Boot：
$ sdk install springboot $ spring --version Spring CLI v3.2.2
如果您为 CLI 开发功能，并希望访问您创建的版本，请使用以下命令：
sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-3.2.2-bin/spring-3.2.2/ （译者注：这条命令用于安装 Spring Boot CLI。dev 是版本名称，后面的路径是指向已下载 Spring Boot CLI 的位置。） sdk default springboot dev （译者注：这条命令用于将刚刚安装的 Spring Boot CLI 版本设置为 SDKMAN 的默认版本。这样，在执行 spring 相关的命令时，SDKMAN 将使用默认的 Spring Boot CLI 版本。）
前面的说明安装了一个名为dev实例的本地 Spring 实例。它指向目标构建位置，因此每次重建 Spring Boot 时，spring 都是最新的。
运行以下命令即可查看：
$ sdk ls springboot ================================================================================ 可用的 Springboot 版本 ================================================================================ > + 开发 * 3.2.2 ================================================================================ + - 表示本地版本 * - 表示已安装 > - 表示使用中 ================================================================================
OSX Homebrew 安装
如果你使用的是 Mac 和 Homebrew，可以使用以下命令安装 Spring Boot CLI：
$ brew tap spring-io/tap
$ brew install spring-boot
Homebrew 会将 Spring 安装到 /usr/local/bin。
注意
如果看不到formula，可能是您安装的 brew 已经过时。在这种情况下，请运行 brew update 并重试。
（译者注:"formula" 是 Homebrew 中的术语，指的是一个软件包的描述文件，其中包含了安装、配置和管理特定软件的指令。每个 formula 文件通常以 Ruby 编写，并包含有关软件包的信息，如名称、版本、下载地址、依赖关系等。
在上下文中，如果提到没有看到某个 formula，意味着在 Homebrew 的存储库中找不到相应的软件包描述文件。这可能是因为 Homebrew 的本地存储库信息不完整或已过时，需要通过运行 brew update 来更新本地存储库信息，以便获取最新的软件包描述文件。）
安装 MacPorts
如果使用 Mac 并使用 MacPorts，则可以使用以下命令安装 Spring Boot CLI：
$ sudo port install spring-boot-cli
命令行自动补全
Spring Boot CLI 包含为 BASH 和 zsh shell 提供命令自动补全的脚本。您可以在任何 shell 中运行该脚本（也命名为 spring），也可以将其放置在个人范围或系统范围的 bash 自动完成初始化中。在 Debian 系统上，系统范围的脚本位于这个目录中，并且该目录中的所有脚本在新 shell 启动时都会被执行。例如，如果您通过 SDKMAN! 安装了 Spring Boot CLI，则可以使用以下命令手动运行该脚本：source spring <installation location>/shell-completion/bash ( 译者注:整个命令可能的意思是在当前 shell 中加载指定位置的 Bash 自动补全脚本文件，并应用它们到与 spring 相关的程序或工具中。)
$ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring $ spring <HIT TAB HERE> grab help jar run test version
注意 如果使用Homebrew 或 MacPorts 安装 Spring Boot CLI，命令行自动完成脚本会自动在 shell 中注册。
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.4. 开发第一个 Spring Boot 应用程序
本节介绍如何开发一个小型的 "Hello World!" Web 应用程序，以突出 Spring Boot 的一些关键功能。您可以选择 Maven 或 Gradle 作为构建系统。
提示
spring.io 网站包含许多使用 Spring Boot 的 "入门 "指南。如果您需要解决某个具体问题，请先查看该网站。
您可以访问 start.spring.io，从依赖关系搜索器中选择 "Web "启动器，从而缩短下面的步骤。这样做会生成一个新的项目结构，让你可以立即开始编码。更多详情请查看 start.spring.io 用户指南。
4.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)
注意
该示例需要创建在自己的目录中。后续说明假定您已创建了一个合适的目录，并且该目录就是您的当前目录。
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
4.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.2</version> </parent> <!-- Additional lines to be added here... --> </project>
上面的列表应该能为你提供一个可用的构建。你可以运行 mvn package 对其进行测试（暂时可以忽略警告 "[WARNING] JAR will be empty - no content was marked for inclusion!"）。
注意
此时，您可以将项目导入集成开发环境（大多数现代 Java 集成开发环境都内置了对 Maven 的支持）。为简单起见，本例中我们继续使用纯文本编辑器。(译者注：这里的maven就是一个标准化的java项目的构建工具，他还有个功能就是下载项目依赖软件、gradle类似只是它支持的语言更多，也有非标准化的项目构建工具，就是使用idea、eclipse生成的项目)
4.4.3. 使用 Gradle 设置项目
我们首先需要创建一个 Gradle build.gradle 文件。build.gradle 是用于构建项目的构建脚本。打开你喜欢的文本编辑器，添加以下内容：
plugins { id 'java' id 'org.springframework.boot' version '3.2.2' //编译插件，对应maven的 } apply plugin: 'io.spring.dependency-management' //依赖管理，对应maven的<dependencyManagement> group = 'com.example' //项目信息 version = '0.0.1-SNAPSHOT' sourceCompatibility = '17' //对应<properties> repositories { mavenCentral() //下载地址，对应maven的 <repositories> } dependencies { } //这个依赖是空的，对应maven的 <dependencies>
上面的列表应该能为您提供一个可运行的构建。您可以运行 gradle classes 对其进行测试。
注意
此时，您可以将项目导入集成开发环境（大多数现代 Java 集成开发环境都内置了对 Gradle 的支持）。为简单起见，本示例继续使用纯文本编辑器。
4.4.4. 添加 Classpath 依赖项
Spring Boot 提供了许多 "启动器"，可让您在类路径中添加 jar。"启动器 "提供了开发特定类型应用程序时可能需要的依赖项。
Maven
大多数 Spring Boot 应用程序都在 POM 的父级部分使用 spring-boot-starter-parent。spring-boot-starter-parent 是一个特殊的启动器，提供了有用的 Maven 默认值。它还提供了一个依赖关系管理部分，这样就可以省略 "祝福 "依赖关系的版本标记。（译者注：在软件开发中，有时会有一些依赖项被认为是可信赖的、稳定的、适合特定用途的，因此被称为“blessed”（受祝福的）依赖项。）
由于我们要开发的是网络应用，所以要添加 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，并在父节点下添加 spring-boot-starter-web 依赖项：
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies>
如果再次运行 mvn dependency:tree，你会发现现在又多了一些依赖项，包括 Tomcat 网络服务器和 Spring Boot 本身。
Gradle
大多数 Spring Boot 应用程序都使用 org.springframework.boot Gradle 插件。该插件提供了有用的默认设置和 Gradle 任务。io.spring.dependency-management（依赖管理）Gradle 插件提供了依赖管理功能，让你可以省略 "祝福 "依赖的版本标签。
由于我们要开发的是网络应用，所以要添加 spring-boot-starter-web 依赖。在此之前，我们可以通过运行以下命令来查看当前的情况：
$ gradle dependencies > Task :dependencies ------------------------------------------------------------ Root project 'myproject' ------------------------------------------------------------
gradle dependencies 命令会打印出项目依赖关系的树状图。目前，该项目没有依赖项。要添加必要的依赖项，请编辑 build.gradle，在依赖项部分添加 spring-boot-starter-web 依赖项：
dependencies { implementation 'org.springframework.boot:spring-boot-starter-web' }
如果再次运行 gradle dependencies，你会发现现在又多了一些依赖项，包括 Tomcat 网络服务器和 Spring Boot 本身。
4.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
// 标记这是一个控制器类，用于处理HTTP请求并返回HTTP响应
@RestController
// 标记这是Spring Boot应用程序的入口点，并启用了Spring Boot的自动配置功能
@SpringBootApplication
class MyApplication {
// 定义一个名为home的方法，将该方法映射到根路径("/")的HTTP GET请求，并返回"Hello World!"作为HTTP响应的内容
@RequestMapping("/")
fun home() = "Hello World!" //这里的等号等价于 {return }
}
fun main(args: Array<String>) {
// 启动Spring Boot应用程序，传入MyApplication类和命令行参数args
runApplication<MyApplication>(*args) //MyApplication是泛型，*args是数组展开，所谓展开就是将里面的字符串，逐个取出赋值到一个变量
}
虽然这里的代码不多，但内容却不少。在接下来的几节中，我们将逐步介绍重要的部分。
@RestController 和 @RequestMapping 注解
MyApplication 类的第一个注解是 @RestController。这就是所谓的构造型注解。它为阅读代码的人和 Spring 提供了提示，表明该类扮演着特定的角色。在本例中，我们的类是一个网络 @Controller，因此 Spring 在处理传入的网络请求时会考虑到它。
@RequestMapping 注解提供了 "路由 "信息。它告诉 Spring，任何带有 / 路径的 HTTP 请求都应映射到 home 方法。@RestController 注解告诉 Spring 将生成的字符串直接呈现给调用者。（译者注：这里所谓的路由就是路径和方法的映射关系，所谓的将字符串直接呈现给调用者，其实spring在没有这个注解的时候认为该字符串是网页模板的文件名称，他会返回网页文件，有了这个RestController则是将字符串直接返回给调用者）
TIP
@RestController 和 @RequestMapping 注解是 Spring MVC 注解（并非 Spring Boot 特有）。有关详细信息，请参阅 Spring Reference Documentation 中的 MVC 部分。
@SpringBootApplication 注解
第二个类级注解是 @SpringBootApplication。这个注解被称为元注解，它将 @SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan 结合在一起。
其中，我们最感兴趣的注解是 @EnableAutoConfiguration。@EnableAutoConfiguration 可以让 Spring Boot 根据你添加的 jar 依赖关系 "猜测 "你想如何配置 Spring。由于 spring-boot-starter-web 添加了 Tomcat 和 Spring MVC，因此自动配置会假定你正在开发 Web 应用程序，并相应地设置 Spring。
启动器和自动配置
自动配置旨在与 "启动器 "良好配合，但这两个概念并不直接相关。您可以自由选择启动器之外的 jar 依赖项。Spring Boot 仍会尽力自动配置您的应用程序。
main "方法
应用程序的最后一部分是 main 方法。这是一个标准方法，遵循应用程序入口点的 Java 惯例。我们的主方法通过调用 run 委托给 Spring Boot 的 SpringApplication 类。SpringApplication 会引导我们的应用程序，启动 Spring，而 Spring 又会启动自动配置的 Tomcat Web 服务器。我们需要将 MyApplication.class 作为参数传递给 run 方法，以告诉 SpringApplication 哪个是主要的 Spring 组件。我们还需要传递 args 数组，以显示任何命令行参数。
4.4.6. 运行示例
Maven
至此，应用程序应该可以正常运行了。由于你使用了 spring-boot-starter-parent POM，所以你有了一个有用的run目标，可以用来启动应用程序。在项目根目录下键入 mvn spring-boot:run，启动应用程序。你应该会看到与下面类似的输出：
$ mvn spring-boot:run . ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: (v3.2.2) ....... . . . ....... . . . (log output here) ....... . . . ........ Started MyApplication in 0.906 seconds (process running for 6.514)
如果打开浏览器访问 localhost:8080，应该会看到以下输出：
Hello World!
要优雅地退出应用程序，请按 ctrl-c。
Gradle
至此，应用程序应该可以正常运行了。因为使用了 org.springframework.boot Gradle 插件，所以有了一个有用的 bootRun 目标，可以用来启动应用程序。在项目根目录下键入 gradle bootRun 来启动应用程序。效果同maven
4.4.7. 创建可执行jar
最后，我们将创建一个完全独立的可执行 jar 文件，以便在生产中运行。可执行 jar（有时称为 "uber jars "或 "fat jars"）是包含已编译类以及代码运行所需的所有 jar 依赖项的归档文件。（译者注：这里包含一个嵌入式的tomcat服务器，他其实也是一个jar，提供实现servlet api的java web服务器技术，这样的springboot框架与其他高度集成的比如python的django框架类似了）
可执行 jar 和 Java
Java 未提供加载嵌套 jar 文件（本身包含在 jar 中的 jar 文件）的标准方法。如果您要发布一个自包含的应用程序，这可能会造成问题。为了解决这个问题，许多开发人员使用 "uber "jar。uber jar 将应用程序所有依赖库中的所有类都打包到一个压缩包中。这种方法的问题是很难看出应用程序中包含哪些库。如果在多个 jar 中使用相同的文件名（但内容不同），也会造成问题。
Spring Boot 采用了一种不同的方法，让你可以直接嵌套 jar。（译者注：这意味着你可以在一个 JAR 文件内部包含其他 JAR 文件，而不需要将它们合并成一个大的 Uber JAR。这种方法使得应用程序的组织结构更加清晰，你可以清楚地看到应用程序中包含了哪些库，同时避免了可能出现的文件名冲突问题。）
Maven创建jar
要创建可执行 jar，我们需要在 pom.xml 中添加 spring-boot-maven-plugin。为此，请在依赖关系部分下方插入以下几行：
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
注意
spring-boot-starter-parent POM 包含用于绑定repackage目标的 <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.2:repackage (default) @ myproject --- [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO]
译者注：这段日志表示了 Maven 在构建过程中先使用 maven-jar-plugin 插件创建了一个普通的 JAR 文件，然后使用 spring-boot-maven-plugin 插件将其重新打包为一个可执行的 Spring Boot JAR 文件。
在目标目录中，你应该能看到 myproject-0.0.1-SNAPSHOT.jar。该文件大小应在 18 MB 左右。如果你想窥探里面的内容，可以使用 jar tvf，如下所示：
$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar在目标文件中，你还会看到一个更小的名为 myproject-0.0.1-SNAPSHOT.jar.original 的文件在目标目录。这是 Maven 在 Spring Boot 重新打包之前创建的原始 jar 文件。（译者注：myproject-0.0.1-SNAPSHOT.jar.original 是在项目的 target 目录中生成的原始 JAR 文件，它是 Maven 在执行 mvn package 过程中使用 maven-jar-plugin 插件创建的。在使用 spring-boot-maven-plugin 插件进行重新打包之前，这个原始的 JAR 文件会被生成。一旦 Spring Boot 对原始 JAR 文件进行重新打包（通常是为了添加 Spring Boot 特有的结构和配置），它会生成一个更大的 JAR 文件，通常是 myproject-0.0.1-SNAPSHOT.jar。这个重新打包的 JAR 文件是一个可执行的 Spring Boot 应用程序。）
要运行该应用程序，请使用 java -jar 命令，如下所示：
$ java -jar target/myproject-0.0.1-SNAPSHOT.jar
与之前一样，要退出应用程序，请按 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，要运行该应用程序，请使用 java -jar 命令，与之前一样，要退出应用程序，请按 ctrl-c。
4.5. 下一步读什么
希望本节提供的一些 Spring Boot 基础知识能帮助你开始编写自己的应用程序。如果您是以任务为导向的开发人员，您可能需要跳转到 spring.io，查看一些入门指南，以解决 "如何使用 Spring 进行操作 "的具体问题。我们还有专门针对 Spring Boot 的 "如何做 "参考文档。
否则，下一步就是阅读 开发部分。如果你实在没有耐心，也可以提前阅读有关 核心功能 的内容。
第 5 章 升级
项目维基上提供了如何从 Spring Boot 早期版本升级的说明。请点击发行说明部分的链接，查找要升级到的版本。
升级说明总是发布说明中的第一项。如果你需要一次跨越多个版本升级，请确保你也查看了跳跃的每个版本的发布说明。
5.1. 从 1.x 升级
如果您要从 Spring Boot 1.x 版本升级，请查看项目维基上的 "迁移指南"，其中提供了详细的升级说明。还可查看 "发布说明"，了解每个版本的 "新功能和值得注意的功能 "列表。
5.2. 升级到新功能版本
升级到新功能版本时，某些属性可能会被重命名或移除。Spring Boot 提供了一种在启动时分析应用程序环境并打印诊断结果的方法，而且还能在运行时为您临时迁移属性。（译者注：举个例子，假设在旧版本的 Spring Boot 中某个属性名为 old.property.name，但在新版本中被重命名为 new.property.name。当你升级到新版本时，如果你的应用程序仍然在使用旧版本的属性名，Spring Boot 可能会在应用程序启动时检测到这种情况，并尝试将旧属性名转换为新属性名，以确保应用程序的配置仍然有效。）要启用该功能，请在项目中添加以下依赖关系：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-properties-migrator</artifactId> <scope>runtime</scope> </dependency>
警告
在运行时后期添加到环境中的属性，比如使用 @PropertySource 注解添加的属性，不会被考虑在内。（译者注：如果你在应用程序运行时动态加载了一些属性文件，这些属性可能不会被包含在迁移的范围内。）
注意
完成迁移后，请确保从项目的依赖关系中移除该模块。
5.3. 升级 Spring Boot CLI
要升级现有的 CLI 安装，请使用相应的软件包管理器命令（例如 brew upgrade）。如果您手动安装了 CLI，请按照手动安装操作，记住要更新 PATH 环境变量以移除任何旧的引用。
5.4. 下一步读什么
一旦决定升级应用程序，您可以在本文档的其余部分找到有关具体功能的详细信息。
Spring Boot 的文档是针对该版本的，因此您在这里找到的任何信息都将包含该版本的最新变更。
