#13 [skip ci] 推送springboot 的中文文档

docs/spring-boot/README.md

-# Spring Boot
\ No newline at end of file
+# Spring 引导
\ No newline at end of file

docs/spring-boot/build-tool-plugins.md

+# 构建工具插件
+
+Spring Boot 为 Maven 和 Gradle 提供了构建工具插件。这些插件提供了各种特性，包括可执行 JAR 的打包。本节提供了有关这两个插件的更多详细信息，以及在需要扩展不受支持的构建系统时提供的一些帮助。如果你刚刚开始，你可能需要先阅读“[using.html](using.html#using.build-systems)”一节中的“[using.html](using.html#using)”。
+
+## 1.1 Spring 引导 Maven 插件
+
+Spring boot Maven 插件在 Maven 中提供了 Spring boot 支持，允许你打包可执行文件 jar 或战争归档文件并“就地”运行应用程序。要使用它，你必须使用 Maven 3.2（或更高版本）。
+
+查看该插件的文档以了解更多信息：
+
+* 引用（[HTML](https://docs.spring.io/spring-boot/docs/2.6.4/maven-plugin/reference/htmlsingle/)和[PDF](https://docs.spring.io/spring-boot/docs/2.6.4/maven-plugin/reference/pdf/spring-boot-maven-plugin-reference.pdf)）
+
+* [API](https://docs.spring.io/spring-boot/docs/2.6.4/maven-plugin/api/)
+
+## 1.2. Spring 引导 Gradle 插件
+
+Spring boot Gradle 插件在 Gradle 中提供 Spring 引导支持，允许你打包可执行文件 jar 或战争归档文件，运行 Spring 引导应用程序，并使用`spring-boot-dependencies`提供的依赖管理。它需要 Gradle 6.8、6.9 或 7.x。查看该插件的文档以了解更多信息：
+
+* 参考文献（[HTML](https://docs.spring.io/spring-boot/docs/2.6.4/gradle-plugin/reference/htmlsingle/)和[PDF](https://docs.spring.io/spring-boot/docs/2.6.4/gradle-plugin/reference/pdf/spring-boot-gradle-plugin-reference.pdf)）
+
+* [API](https://docs.spring.io/spring-boot/docs/2.6.4/gradle-plugin/api/)
+
+## 3. Spring 启动 Antlib 模块
+
+Spring 启动 Antlib 模块为 Apache Ant 提供了基本的 Spring 启动支持。你可以使用该模块创建可执行 JAR。要使用该模块，你需要在你的`build.xml`中声明一个额外的`spring-boot`名称空间，如以下示例所示：
+
+```
+<project xmlns:ivy="antlib:org.apache.ivy.ant"
+    xmlns:spring-boot="antlib:org.springframework.boot.ant"
+    name="myapp" default="build">
+    ...
+</project>
+```
+
+你需要记住使用`-lib`选项启动 Ant，如以下示例所示：
+
+```
+$ ant -lib <directory containing spring-boot-antlib-2.6.4.jar>
+```
+
+> “使用 Spring 引导”部分包括[using Apache Ant with `spring-boot-antlib`](using.html#using.build-systems.ant)的更完整示例。
+
+### 3.1. Spring 引导 Ant 任务
+
+一旦声明了`spring-boot-antlib`名称空间，就可以执行以下附加任务：
+
+* [使用“exejar”任务](#build-tool-plugins.antlib.tasks.exejar)
+
+* [使用“FindMainclass”任务](#build-tool-plugins.antlib.findmainclass)
+
+#### 3.1.1.使用“exejar”任务
+
+你可以使用`exejar`任务来创建 Spring 引导可执行文件 jar。该任务支持以下属性：
+
+|  Attribute  |             Description              |必需的|
+|-------------|--------------------------------------|-------------------------------------------------------------------------|
+| `destfile`  |  The destination jar file to create  |是的|
+|  `classes`  |The root directory of Java class files|是的|
+|`start-class`|  The main application class to run   |否*(the default is the first class found that declares a `main` method)*|
+
+以下嵌套元素可与任务一起使用：
+
+|  Element  |说明|
+|-----------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|`resources`|一个或多个[资源收集](https://ant.apache.org/manual/Types/resources.html#collection)，描述一组[Resources](https://ant.apache.org/manual/Types/resources.html)，该集合应被添加到所创建的 jar 文件的内容中。|
+|   `lib`   |应该将一个或多个[资源收集](https://ant.apache.org/manual/Types/resources.html#collection)添加到构成应用程序运行时依赖项 Classpath 的 jar 库集合中。|
+
+#### 3.1.2.例子
+
+本节展示了 Ant 任务的两个示例。
+
+指定起始类
+
+```
+<spring-boot:exejar destfile="target/my-application.jar"
+        classes="target/classes" start-class="com.example.MyApplication">
+    <resources>
+        <fileset dir="src/main/resources" />
+    </resources>
+    <lib>
+        <fileset dir="lib" />
+    </lib>
+</spring-boot:exejar>
+```
+
+检测起始类
+
+```
+<exejar destfile="target/my-application.jar" classes="target/classes">
+    <lib>
+        <fileset dir="lib" />
+    </lib>
+</exejar>
+```
+
+### 3.2.使用“FindMainclass”任务
+
+`findmainclass`任务由`exejar`内部使用，用于定位声明`main`的类。如果有必要，你也可以在构建中直接使用此任务。支持以下属性：
+
+|  Attribute  |说明|                 Required                  |
+|-------------|----------------------------------------------------|-------------------------------------------|
+|`classesroot`|Java 类文件的根目录|  Yes *(unless `mainclass` is specified)*  |
+| `mainclass` |可用于短路`main`类搜索|                    No                     |
+| `property`  |应与结果一起设置的 Ant 属性|No *(result will be logged if unspecified)*|
+
+#### 3.2.1.例子
+
+本节包含使用`findmainclass`的三个示例。
+
+查找并记录
+
+```
+<findmainclass classesroot="target/classes" />
+```
+
+查找并设置
+
+```
+<findmainclass classesroot="target/classes" property="main-class" />
+```
+
+覆盖和设置
+
+```
+<findmainclass mainclass="com.example.MainClass" property="main-class" />
+```
+
+## 4. 支持其他构建系统
+
+如果你想使用 Maven、 Gradle 或 Ant 以外的构建工具，那么你可能需要开发自己的插件。可执行 JAR 需要遵循特定的格式，并且某些条目需要以未压缩的形式编写（有关详细信息，请参见附录中的“[executable jar format](executable-jar.html#appendix.executable-jar)”部分）。
+
+Spring boot Maven 和 Gradle 插件都使用`spring-boot-loader-tools`来实际生成 JAR。如果需要，可以直接使用这个库。
+
+### 4.1.重新包装档案
+
+要重新打包现有的归档文件，使其成为一个自包含的可执行归档文件，请使用`org.springframework.boot.loader.tools.Repackager`。`Repackager`类接受一个构造函数参数，该参数引用现有的 jar 或 WAR 归档。使用两个可用的`repackage()`方法中的一个来替换原始文件或写入新的目标。在运行 Repackager 之前，还可以在其上配置各种设置。
+
+### 4.2.嵌套库
+
+在重新打包归档文件时，可以使用`org.springframework.boot.loader.tools.Libraries`接口来包含对依赖项文件的引用。这里我们不提供`Libraries`的任何具体实现，因为它们通常是特定于构建系统的。
+
+如果你的归档文件已经包含库，那么你可以使用`Libraries.NONE`。
+
+### 4.3.寻找主类
+
+如果你不使用`Repackager.setMainClass()`来指定主类，则 Repackager 将使用[ASM](https://asm.ow2.io/)来读取类文件，并尝试使用`public static void main(String[] args)`方法找到合适的类。如果发现一个以上的候选者，将抛出一个异常。
+
+### 4.4.示例重新打包实现
+
+下面的示例展示了一个典型的重新打包实现：
+
+```
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+
+import org.springframework.boot.loader.tools.Library;
+import org.springframework.boot.loader.tools.LibraryCallback;
+import org.springframework.boot.loader.tools.LibraryScope;
+import org.springframework.boot.loader.tools.Repackager;
+
+public class MyBuildTool {
+
+    public void build() throws IOException {
+        File sourceJarFile = ...
+        Repackager repackager = new Repackager(sourceJarFile);
+        repackager.setBackupSource(false);
+        repackager.repackage(this::getLibraries);
+    }
+
+    private void getLibraries(LibraryCallback callback) throws IOException {
+        // Build system specific implementation, callback for each dependency
+        for (File nestedJar : getCompileScopeJars()) {
+            callback.library(new Library(nestedJar, LibraryScope.COMPILE));
+        }
+        // ...
+    }
+
+    private List<File> getCompileScopeJars() {
+        return ...
+    }
+
+}
+
+```
+
+## 5. 接下来读什么？
+
+如果你对构建工具插件的工作方式感兴趣，可以查看 Github 上的[`spring-boot-tools`](https://github.com/spring-projects/spring-boot/tree/v2.6.4/spring-boot-project/spring-boot-tools)模块。可执行 jar 格式的更多技术细节在[the appendix](executable-jar.html#appendix.executable-jar)中进行了介绍。
+
+如果你有特定的与构建相关的问题，请参阅“[how-to](howto.html#howto)”指南。
+

docs/spring-boot/cli.md

+# Spring 引导 CLI
+
+Spring 引导 CLI 是一个命令行工具，如果你想快速开发 Spring 应用程序，可以使用它。它允许你运行 Groovy 脚本，这意味着你有一个熟悉的类似 Java 的语法，而不需要那么多样板代码。你还可以引导一个新项目，或者为它编写自己的命令。
+
+## 1. 安装 CLI
+
+可以使用 SDKMAN 手动安装 Spring boot cli（命令行界面）！（SDK 管理器），或者如果你是 OSX 用户，则使用 Homebrew 或 MacPorts。有关全面的安装说明，请参见“开始”部分中的*[getting-started.html](getting-started.html#getting-started.installing.cli)*。
+
+## 2. 使用 CLI
+
+一旦安装了 CLI，就可以通过输入`spring`并在命令行按 Enter 来运行它。如果你在没有任何参数的情况下运行`spring`，将显示一个帮助屏幕，如下所示：
+
+```
+$ spring
+usage: spring [--help] [--version]
+       <command> [<args>]
+
+Available commands are:
+
+  run [options] <files> [--] [args]
+    Run a spring groovy script
+
+  _... more command help is shown here_
+```
+
+你可以键入`spring help`来获得有关任何支持的命令的更多详细信息，如以下示例所示：
+
+```
+$ spring help run
+spring run - Run a spring groovy script
+
+usage: spring run [options] <files> [--] [args]
+
+Option                     Description
+------                     -----------
+--autoconfigure [Boolean]  Add autoconfigure compiler
+                             transformations (default: true)
+--classpath, -cp           Additional classpath entries
+--no-guess-dependencies    Do not attempt to guess dependencies
+--no-guess-imports         Do not attempt to guess imports
+-q, --quiet                Quiet logging
+-v, --verbose              Verbose logging of dependency
+                             resolution
+--watch                    Watch the specified file for changes
+```
+
+`version`命令提供了一种快速的方法来检查你正在使用的 Spring 启动版本，如下所示：
+
+```
+$ spring version
+Spring CLI v2.6.4
+```
+
+### 2.1.使用 CLI 运行应用程序
+
+你可以使用`run`命令编译和运行 Groovy 源代码。 Spring 引导 CLI 是完全自包含的，因此不需要任何外部 Groovy 安装。
+
+下面的示例展示了一个用 Groovy 编写的“Hello World”Web 应用程序：
+
+你好。Groovy
+
+```
+@RestController
+class WebApplication {
+
+    @RequestMapping("/")
+    String home() {
+        "Hello World!"
+    }
+
+}
+
+```
+
+要编译和运行应用程序，请键入以下命令：
+
+```
+$ spring run hello.groovy
+```
+
+要将命令行参数传递给应用程序，请使用`--`将命令与“ Spring”命令参数分开，如以下示例所示：
+
+```
+$ spring run hello.groovy -- --server.port=9000
+```
+
+要设置 JVM 命令行参数，可以使用`JAVA_OPTS`环境变量，如以下示例所示：
+
+```
+$ JAVA_OPTS=-Xmx1024m spring run hello.groovy
+```
+
+|   |在 Microsoft Windows 上设置`JAVA_OPTS`时，请确保引用整个指令，例如`set "JAVA_OPTS=-Xms256m -Xmx2048m"`。<br/>这样做可以确保将值正确地传递给进程。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+#### 2.1.1.推导出“抓取”依赖项
+
+标准 Groovy 包含一个`@Grab`注释，它允许你声明对第三方库的依赖关系。这一有用的技术让 Groovy 以与 Maven 或 Gradle 相同的方式下载 JAR，但不需要使用构建工具。
+
+Spring Boot 进一步扩展了这种技术，并试图根据你的代码推断出要“抓取”哪些库。例如，由于前面显示的`WebApplication`代码使用`@RestController`注释， Spring 引导抓取“ Tomcat”和“ Spring MVC”。
+
+以下项目被用作“抓取提示”：
+
+|项目|            Grabs             |
+|----------------------------------------------------------|------------------------------|
+|`JdbcTemplate`, `NamedParameterJdbcTemplate`, `DataSource`|      JDBC Application.       |
+|`@EnableJms`|       JMS Application.       |
+|`@EnableCaching`|     Caching abstraction.     |
+|`@Test`|            JUnit.            |
+|`@EnableRabbit`|          RabbitMQ.           |
+|扩展`Specification`|         Spock test.          |
+|`@EnableBatchProcessing`|        Spring Batch.         |
+|`@MessageEndpoint` `@EnableIntegration`|     Spring Integration.      |
+|`@Controller` `@RestController` `@EnableWebMvc`|Spring MVC + Embedded Tomcat. |
+|`@EnableWebSecurity`|       Spring Security.       |
+|`@EnableTransactionManagement`|Spring Transaction Management.|
+
+|   |请参阅 Spring Boot CLI 源代码中[“编译器自动配置”](https://github.com/spring-projects/spring-boot/tree/v2.6.4/spring-boot-project/spring-boot-cli/src/main/java/org/springframework/boot/cli/compiler/CompilerAutoConfiguration.java)的子类，以确切了解如何应用自定义。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+#### 2.1.2.推导出的“抓取”坐标
+
+Spring Boot 扩展了 Groovy 的标准`@Grab`支持，允许你指定一个没有组或版本的依赖项（例如，`@Grab('freemarker')`）。这样做会参考 Spring Boot 的默认依赖关系元数据来推断工件的组和版本。
+
+|   |默认的元数据与你使用的 CLI 版本绑定，<br/>只有当你移动到新版本的 CLI 时，它才会发生变化，让你控制依赖项的版本何时可能更改。<br/>在[appendix](dependency-versions.html#appendix.dependency-versions)中可以找到一个表，该表显示了默认元数据中包含的依赖项及其版本。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+#### 2.1.3.默认导入语句
+
+为了帮助减少 Groovy 代码的大小，会自动包含几个`import`语句。注意前面的示例是如何引用`@Component`、`@RestController`和`@RequestMapping`而不需要使用完全限定的名称或`import`语句的。
+
+|   |许多 Spring 注释在不使用`import`语句的情况下工作。<br/>在添加导入之前，尝试运行你的应用程序以查看失败的原因。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------|
+
+#### 2.1.4.自动主法
+
+与等效的 Java 应用程序不同，你不需要在`Groovy`脚本中包含`public static void main(String[] args)`方法。将自动创建`SpringApplication`，你的编译代码将充当`source`。
+
+#### 2.1.5.自定义依赖管理
+
+默认情况下，CLI 在解析`@Grab`依赖关系时使用在`spring-boot-dependencies`中声明的依赖关系管理。可以通过使用`@DependencyManagementBom`注释来配置额外的依赖管理，该管理覆盖了默认的依赖管理。注释的值应该指定一个或多个 Maven boms 的坐标（“groupid:artifactid:version”）。
+
+例如，考虑以下声明：
+
+```
+@DependencyManagementBom("com.example.custom-bom:1.0.0")
+
+```
+
+前面的声明在 Maven 存储库中的`com/example/custom-versions/1.0.0/`下获取`custom-bom-1.0.0.pom`。
+
+当你指定多个 BOM 时，它们将按照你声明它们的顺序应用，如下例所示：
+
+```
+@DependencyManagementBom([
+    "com.example.custom-bom:1.0.0",
+    "com.example.another-bom:1.0.0"])
+
+```
+
+前面的示例表明，`another-bom`中的依赖管理重写了`custom-bom`中的依赖管理。
+
+你可以在任何可以使用`@DependencyManagementBom`的地方使用`@Grab`。然而，为了确保依赖管理的一致顺序，你可以在应用程序中最多使用`@DependencyManagementBom`一次。
+
+### 2.2.具有多个源文件的应用程序
+
+你可以在所有接受文件输入的命令中使用“shell globbing”。这样做可以让你从一个目录中使用多个文件，如下面的示例所示：
+
+```
+$ spring run *.groovy
+```
+
+### 2.3.打包你的应用程序
+
+你可以使用`jar`命令将你的应用程序打包成一个自包含的可执行文件 jar，如下例所示：
+
+```
+$ spring jar my-app.jar *.groovy
+```
+
+jar 结果包含通过编译应用程序产生的类和应用程序的所有依赖项，这样就可以使用`java -jar`运行它。 jar 文件还包含来自应用程序 Classpath 的条目。可以通过使用`--include`和`--exclude`来添加和删除 jar 的显式路径。两者都是用逗号分隔的，并且都接受前缀，以“+”和“-”的形式表示它们应该从默认值中删除。默认值包括以下内容：
+
+```
+public/**, resources/**, static/**, templates/**, META-INF/**, *
+```
+
+默认排除如下：
+
+```
+.*, repository/**, build/**, target/**, **/*.jar, **/*.groovy
+```
+
+有关详细信息，请在命令行上键入`spring help jar`。
+
+### 2.4.初始化一个新项目
+
+`init`命令允许你在不离开 shell 的情况下使用[start.spring.io](https://start.spring.io)创建一个新项目，如下面的示例所示：
+
+```
+$ spring init --dependencies=web,data-jpa my-project
+Using service at https://start.spring.io
+Project extracted to '/Users/developer/example/my-project'
+```
+
+前面的示例使用基于 Maven 的项目创建`my-project`目录，该项目使用`spring-boot-starter-web`和`spring-boot-starter-data-jpa`。你可以使用`--list`标志列出服务的功能，如以下示例所示：
+
+```
+$ spring init --list
+=======================================
+Capabilities of https://start.spring.io
+=======================================
+
+Available dependencies:
+-----------------------
+actuator - Actuator: Production ready features to help you monitor and manage your application
+...
+web - Web: Support for full-stack web development, including Tomcat and spring-webmvc
+websocket - Websocket: Support for WebSocket development
+ws - WS: Support for Spring Web Services
+
+Available project types:
+------------------------
+gradle-build -  Gradle Config [format:build, build:gradle]
+gradle-project -  Gradle Project [format:project, build:gradle]
+maven-build -  Maven POM [format:build, build:maven]
+maven-project -  Maven Project [format:project, build:maven] (default)
+
+...
+```
+
+`init`命令支持许多选项。有关更多详细信息，请参见`help`输出。例如，下面的命令创建了一个使用 Java8 和`war`打包的 Gradle 项目：
+
+```
+$ spring init --build=gradle --java-version=1.8 --dependencies=websocket --packaging=war sample-app.zip
+Using service at https://start.spring.io
+Content saved to 'sample-app.zip'
+```
+
+### 2.5.使用嵌入式外壳
+
+Spring 引导包括用于 bash 和 zsh shell 的命令行完成脚本。如果不使用这两个 shell 中的任何一个（也许你是 Windows 用户），则可以使用`shell`命令来启动一个集成的 shell，如下例所示：
+
+```
+$ spring shell
+Spring Boot (v2.6.4)
+Hit TAB to complete. Type \'help' and hit RETURN for help, and \'exit' to quit.
+```
+
+在嵌入的 shell 中，你可以直接运行其他命令：
+
+```
+$ version
+Spring CLI v2.6.4
+```
+
+嵌入式外壳支持 ANSI 颜色输出以及`tab`补全。如果需要运行本机命令，可以使用`!`前缀。要退出嵌入的 shell，请按`ctrl-c`。
+
+### 2.6.向 CLI 添加扩展
+
+你可以使用`install`命令向 CLI 添加扩展。该命令以`group:artifact:version`的格式接受一组或多组工件坐标，如以下示例所示：
+
+```
+$ spring install com.example:spring-boot-cli-extension:1.0.0.RELEASE
+```
+
+除了安装由你提供的坐标标识的工件外，还安装了所有工件的依赖关系。
+
+要卸载依赖项，请使用`uninstall`命令。与`install`命令一样，它以`group:artifact:version`的格式接受一组或多组工件坐标，如以下示例所示：
+
+```
+$ spring uninstall com.example:spring-boot-cli-extension:1.0.0.RELEASE
+```
+
+它卸载由你提供的坐标和它们的依赖关系所标识的工件。
+
+要卸载所有附加依赖项，可以使用`--all`选项，如以下示例所示：
+
+```
+$ spring uninstall --all
+```
+
+## 3. 使用 Groovy Beans DSL 开发应用程序
+
+Spring Framework4.0 对`beans{}`“DSL”（借用自[Grails](https://grails.org/)）具有原生支持，并且你可以通过使用相同的格式在 Groovy 应用程序脚本中嵌入 Bean 定义。这有时是一种很好的方式，可以包含外部特性，比如中间件声明，如下例所示：
+
+```
+@Configuration(proxyBeanMethods = false)
+class Application implements CommandLineRunner {
+
+    @Autowired
+    SharedService service
+
+    @Override
+    void run(String... args) {
+        println service.message
+    }
+
+}
+
+import my.company.SharedService
+
+beans {
+    service(SharedService) {
+        message = "Hello World"
+    }
+}
+
+```
+
+你可以在同一个文件中将类声明与`beans{}`混合在一起，只要它们保持在顶层，或者，如果你愿意，可以将 bean DSL 放在一个单独的文件中。
+
+## 4. 使用 settings.xml 配置 CLI
+
+Spring 引导 CLI 使用 Maven resolver（ Maven 的依赖项解析引擎）来解析依赖项。CLI 使用`~/.m2/settings.xml`中的 Maven 配置来配置 Maven 解析器。以下配置设置由 CLI 执行：
+
+* 离线
+
+* 镜子
+
+* 服务器
+
+* 代理
+
+* 配置文件
+
+  * 激活
+
+  * 存储库
+
+* 活动配置文件
+
+有关更多信息，请参见[Maven’s settings documentation](https://maven.apache.org/settings.html)。
+
+## 5. 接下来读什么？
+
+GitHub 存储库中有一些[Groovy 脚本示例](https://github.com/spring-projects/spring-boot/tree/v2.6.4/spring-boot-project/spring-boot-cli/samples)可用，你可以使用它们来尝试 Spring 引导 CLI。在[source code](https://github.com/spring-projects/spring-boot/tree/v2.6.4/spring-boot-project/spring-boot-cli/src/main/java/org/springframework/boot/cli)中也有大量的 Javadoc。
+
+如果你发现你已经达到了 CLI 工具的极限，那么你可能希望将你的应用程序转换为完整的 Gradle 或 Maven 构建的“Groovy 项目”。下一节将介绍 Spring boot 的“[构建工具插件](build-tool-plugins.html#build-tool-plugins)”，你可以在 Gradle 或 Maven 中使用它。

docs/spring-boot/container-images.md

+# 容器图像
+
+Spring 引导应用程序可以是容器化的[使用 DockerFiles](#container-images.dockerfiles)，也可以是容器化的[使用本地云构建包创建优化的 Docker 兼容容器映像，可以在任何地方运行](#container-images.buildpacks)。
+
+## 1. 高效的容器图像
+
+
+将 Spring 引导 fat jar 打包为 Docker 映像是很容易的。然而，复制和运行 Docker 映像中的 fat jar 有各种缺点。在不拆包的情况下运行 A fat jar 时，总会有一定的开销，在集装箱化的环境中，这一点是显而易见的。另一个问题是，将应用程序的代码及其所有依赖项放在 Docker 映像中的一个层中是次优的。由于你重新编译代码的次数可能比升级所使用的启动版本更多，所以更好的做法通常是多分离一些东西。如果将 jar 个文件放在应用程序类之前的层中，Docker 通常只需要更改最底层的文件，就可以从其缓存中获取其他文件。
+
+### 1.1.打开 fat jar
+
+如果你是从一个容器运行你的应用程序，那么你可以使用一个可执行文件 jar，但通常也有一个优势，那就是将其分解并以不同的方式运行它。某些 PaaS 实现还可能选择在运行归档文件之前对其进行解包。例如，Cloud Foundry 就是这样运作的。运行未打包归档文件的一种方法是启动适当的启动器，如下所示：
+
+```
+$ jar -xf myapp.jar
+$ java org.springframework.boot.loader.JarLauncher
+```
+
+这实际上在启动时（取决于 jar 的大小）比在未爆炸的归档文件中运行稍微快一些。在运行时，你不应该期望有任何差异。
+
+打开 jar 文件后，还可以通过使用“自然”主方法（而不是`JarLauncher`）运行应用程序来增加启动时间。例如：
+
+```
+$ jar -xf myapp.jar
+$ java -cp BOOT-INF/classes:BOOT-INF/lib/* com.example.MyApplication
+```
+
+|   |在应用程序的主方法上使用`JarLauncher`具有可预测的 Classpath 顺序的附加好处。<br/> jar 包含一个`classpath.idx`文件，该文件由`JarLauncher`在构造 Classpath 时使用。|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 1.2.分层 Docker 图像
+
+为了使创建优化的 Docker 映像更容易， Spring 启动支持向 jar 添加层索引文件。它提供了层的列表和 jar 中应该包含在其中的部分。索引中的层列表是根据将层添加到 Docker/OCI 图像中的顺序进行排序的。在开箱即用的情况下，支持以下层：
+
+* `dependencies`（用于常规发布的依赖项）
+
+* `spring-boot-loader`（对于`org/springframework/boot/loader`下的所有内容）
+
+* `snapshot-dependencies`（用于快照依赖关系）
+
+* `application`（用于应用程序类和资源）
+
+下面显示了`layers.idx`文件的示例：
+
+```
+- "dependencies":
+  - BOOT-INF/lib/library1.jar
+  - BOOT-INF/lib/library2.jar
+- "spring-boot-loader":
+  - org/springframework/boot/loader/JarLauncher.class
+  - org/springframework/boot/loader/jar/JarEntry.class
+- "snapshot-dependencies":
+  - BOOT-INF/lib/library3-SNAPSHOT.jar
+- "application":
+  - META-INF/MANIFEST.MF
+  - BOOT-INF/classes/a/b/C.class
+```
+
+这种分层设计是为了根据在应用程序构建之间更改代码的可能性来分离代码。库代码在两次构建之间更改的可能性较小，因此将其放置在自己的层中，以允许工具重新使用缓存中的层。应用程序代码更有可能在构建之间进行更改，因此它被隔离在一个单独的层中。
+
+Spring 在`layers.idx`的帮助下，引导还支持对 WAR 文件进行分层。
+
+对于 Maven，请参阅[packaging layered jar or war section](https://docs.spring.io/spring-boot/docs/2.6.4/maven-plugin/reference/htmlsingle/#repackage-layers)以获取有关向归档文件添加图层索引的更多详细信息。有关 Gradle，请参见 Gradle 插件文档的[packaging layered jar or war section](https://docs.spring.io/spring-boot/docs/2.6.4/gradle-plugin/reference/htmlsingle/#packaging-layered-archives)。
+
+## 2. DockerFiles
+
+虽然只需在 Dockerfile 中的几行就可以将 Spring 启动 fat jar 转换为 Docker 映像，但我们将使用[分层特征](#container-images.efficient-images.layering)来创建优化的 Docker 映像。当你创建包含层索引文件的 jar 时，`spring-boot-jarmode-layertools` jar 将作为依赖项添加到 jar 中。有了这个 jar 在 Classpath 上，你可以以一种特殊的模式启动你的应用程序，该模式允许引导代码运行与你的应用程序完全不同的东西，例如，提取层的东西。
+
+|   |`layertools`模式不能与包含启动脚本的[fully executable Spring Boot archive](deployment.html#deployment.installing)一起使用。<br/>在构建打算与`layertools`一起使用的 jar 文件时禁用启动脚本配置。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+以下是使用`layertools` jar 模式启动 jar 的方法：
+
+```
+$ java -Djarmode=layertools -jar my-app.jar
+```
+
+这将提供以下产出：
+
+```
+Usage:
+  java -Djarmode=layertools -jar my-app.jar
+
+Available commands:
+  list     List layers from the jar that can be extracted
+  extract  Extracts layers from the jar for image creation
+  help     Help about any command
+```
+
+`extract`命令可以用来轻松地将应用程序分割成要添加到 DockerFile 中的层。下面是一个使用`jarmode`的 DockerFile 的示例。
+
+```
+FROM adoptopenjdk:11-jre-hotspot as builder
+WORKDIR application
+ARG JAR_FILE=target/*.jar
+COPY ${JAR_FILE} application.jar
+RUN java -Djarmode=layertools -jar application.jar extract
+
+FROM adoptopenjdk:11-jre-hotspot
+WORKDIR application
+COPY --from=builder application/dependencies/ ./
+COPY --from=builder application/spring-boot-loader/ ./
+COPY --from=builder application/snapshot-dependencies/ ./
+COPY --from=builder application/application/ ./
+ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]
+```
+
+假设上面的`Dockerfile`在当前目录中，你的 Docker 映像可以使用`docker build .`构建，或者可选地指定应用程序的路径 jar，如以下示例所示：
+
+```
+$ docker build --build-arg JAR_FILE=path/to/myapp.jar .
+```
+
+这是一个多阶段的 DockerFile。构建器阶段提取以后需要的目录。每个`COPY`命令都与 JARMODE 提取的层有关。
+
+当然，可以在不使用 JARMODE 的情况下编写 DockerFile。你可以使用`unzip`和`mv`的一些组合来将事情移动到正确的层，但是 Jarmode 简化了这一点。
+
+## 3. 云原生构建包
+
+DockerFiles 只是构建 Docker 映像的一种方式。另一种构建 Docker 映像的方法是直接从 Maven 或 Gradle 插件中使用 buildpacks。如果你曾经使用过 Cloud Foundry 或 Heroku 之类的应用程序平台，那么你很可能使用过 BuildPack。构建包是平台的一部分，它接收应用程序并将其转换为平台可以实际运行的内容。例如，Cloud Foundry 的 Java BuildPack 会注意到，你正在推送一个`.jar`文件，并自动添加一个相关的 JRE。
+
+使用 Cloud Native 构建包，你可以创建可以在任何地方运行的与 Docker 兼容的映像。 Spring 引导包括直接针对 Maven 和 Gradle 的 BuildPack 支持。这意味着你只需键入一个命令，就可以快速地在本地运行的 Docker 守护程序中获得一个合理的映像。
+
+请参阅有关如何使用[Maven](https://docs.spring.io/spring-boot/docs/2.6.4/maven-plugin/reference/htmlsingle/#build-image)和[Gradle](https://docs.spring.io/spring-boot/docs/2.6.4/gradle-plugin/reference/htmlsingle/#build-image)构建包的单个插件文档。
+
+|   |[Paketo Spring Boot buildpack](https://github.com/paketo-buildpacks/spring-boot)也已更新，以支持`layers.idx`文件，因此应用于该文件的任何定制都将反映在 BuildPack 创建的图像中。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+|   |为了实现可重复的构建和容器映像缓存，构建包可以操作应用程序资源元数据（例如文件“上次修改”信息）。<br/>你应该确保你的应用程序在运行时不依赖于该元数据。<br/> Spring 引导在服务静态资源时可以使用该信息，但这可以用`spring.web.resources.cache.use-last-modified`禁用|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## 4. 接下来读什么？
+
+一旦你了解了如何构建高效的容器映像，你就可以了解[将应用程序部署到云平台](deployment.html#deployment.cloud.kubernetes)，比如 Kubernetes。
+

docs/spring-boot/documentation.md

+# 文件概述
+
+本节简要概述了 Spring 引导参考文档。它是这份文件其余部分的一张地图。
+
+该文档的最新副本可在[docs.spring.io/spring-boot/docs/current/reference/](https://docs.spring.io/spring-boot/docs/current/reference/)上获得。
+
+## 1. 第一步
+
+如果你开始使用 Spring boot 或一般的“ Spring”，请从[以下主题](getting-started.html#getting-started)开始：
+
+* **从零开始：** [Overview](getting-started.html#getting-started.introducing-spring-boot) | [Requirements](getting-started.html#getting-started.system-requirements) | [Installation](getting-started.html#getting-started.installing)
+
+* **教程：** [Part 1](getting-started.html#getting-started.first-application) | [Part 2](getting-started.html#getting-started.first-application.code)
+
+* **运行你的示例：** [Part 1](getting-started.html#getting-started.first-application.run) | [Part 2](getting-started.html#getting-started.first-application.executable-jar)
+
+## 2. 从早期版本升级
+
+你应该始终确保运行的是 Spring boot 的[支持的版本](https://github.com/spring-projects/spring-boot/wiki/Supported-Versions)。
+
+根据你要升级到的版本，你可以在这里找到一些额外的技巧：
+
+* **从 1.x 开始：** [从 1.x 升级](actuator.html#upgrading.from-1x)
+
+* **到一个新的功能版本：** [升级到新功能版本](upgrading.html#upgrading.to-feature)
+
+* **Spring Boot CLI:** [Upgrading the Spring Boot CLI](upgrading.html#upgrading.cli)
+
+## 3. 用 Spring boot 开发
+
+准备好真正开始使用 Spring 引导了吗？[我们有你的保险。](using.html#using):
+
+* **构建系统：** [Maven](using.html#using.build-systems.maven) | [Gradle](using.html#using.build-systems.gradle) | [Ant](using.html#using.build-systems.ant) | [Starters](using.html#using.build-systems.starters)
+
+* **最佳实践：** [Code Structure](using.html#using.structuring-your-code) | [@Configuration](using.html#using.configuration-classes) | [@enableAutoConfiguration](using.html#using.auto-configuration) | [bean 和依赖注入](using.html#using.spring-beans-and-dependency-injection)
+
+* **运行你的代码：** [IDE](using.html#using.running-your-application.from-an-ide) | [Packaged](using.html#using.running-your-application.as-a-packaged-application) | [Maven](using.html#using.running-your-application.with-the-maven-plugin) | [Gradle](using.html#using.running-your-application.with-the-gradle-plugin)
+
+* **打包应用程序：** [Production jars](using.html#using.packaging-for-production)
+
+* **Spring Boot CLI:** [Using the CLI](cli.html#cli)
+
+## 4. 学习 Spring 引导功能
+
+需要更多有关 Spring Boot 核心功能的详细信息吗？[以下内容是为你准备的](features.html#features):
+
+* **Spring Application:** [SpringApplication](features.html#features.spring-application)
+
+* **外部配置：** [外部配置](features.html#features.external-config)
+
+* **配置文件：** [Profiles](features.html#features.profiles)
+
+* **日志记录：** [Logging](features.html#features.logging)
+
+## 5. 万维网
+
+如果开发 Spring 引导 Web 应用程序，请查看以下内容：
+
+* **Servlet Web Applications:** [Spring MVC, Jersey, Embedded Servlet Containers](web.html#web.servlet)
+
+* **反应式 Web 应用程序：** [Spring Webflux, Embedded Servlet Containers](web.html#web.reactive)
+
+* **优雅的关机：** [优雅的关机](web.html#web.graceful-shutdown)
+
+* **Spring Security:** [默认安全配置，自动配置 OAuth2，SAML](web.html#web.security)
+
+* **Spring Session:** [Auto-configuration for Spring Session](web.html#web.spring-session)
+
+* **Spring HATEOAS:** [Auto-configuration for Spring HATEOAS](web.html#web.spring-hateoas)
+
+## 6. 数据
+
+如果你的应用程序处理一个数据存储，你可以在这里看到如何配置它：
+
+* **SQL:** [配置 SQL 数据存储、嵌入式数据库支持、连接池等。](data.html#data.sql)
+
+* **NoSQL:** [自动配置 NoSQL 存储，如 Redis、MongoDB、NEO4J 等。](data.html#data.nosql)
+
+## 7. 消息传递
+
+如果你的应用程序使用任何消息传递协议，请参阅以下一个或多个部分：
+
+* **JMS:** [自动配置 ActiveMQ 和 Artemis，通过 JMS 发送和接收消息](messaging.html#messaging.jms)
+
+* **AMQP:** [RabbitMQ 的自动配置](messaging.html#messaging.amqp)
+
+* **卡夫卡：** [Auto-configuration for Spring Kafka](messaging.html#messaging.kafka)
+
+* **RSocket:** [Auto-configuration for Spring Framework’s RSocket Support](messaging.html#messaging.rsocket)
+
+* **Spring Integration:** [Auto-configuration for Spring Integration](messaging.html#messaging.spring-integration)
+
+## 8. IO
+
+如果你的应用程序需要 IO 功能，请参阅以下一个或多个部分：
+
+* **缓存：** [缓存支持 Ehcache、Hazelcast、Infinispan 等](io.html#io.caching)
+
+* **石英：** [石英调度](io.html#io.quartz)
+
+* **邮件：** [Sending Email](io.html#io.email)
+
+* **验证：** [JSR-303 验证](io.html#io.validation)
+
+* **休息客户：** [使用 RESTTemplate 和 WebClient 调用 REST 服务](io.html#io.rest-client)
+
+* **网络服务：** [Auto-configuration for Spring Web Services](io.html#io.webservices)
+
+* **JTA:** [使用 JTA 的分布式事务](io.html#io.jta)
+
+## 9. 容器图像
+
+Spring Boot 为构建高效的容器映像提供了一流的支持。你可以在这里了解更多有关它的信息：
+
+* **有效的容器映像：** [优化容器图像（如 Docker 图像）的技巧](container-images.html#container-images.efficient-images)
+
+* **DockerFiles:** [使用 DockerFiles 构建容器映像](container-images.html#container-images.dockerfiles)
+
+* **云原生构建包：** [Support for Cloud Native Buildpacks with Maven and Gradle](container-images.html#container-images.buildpacks)
+
+## 10. 高级主题
+
+最后，我们为更高级的用户提供了几个主题：
+
+* **Spring Boot Applications Deployment:** [云部署](deployment.html#deployment.cloud) | [OS Service](deployment.html#deployment.installing.nix-services)
+
+* **构建工具插件：** [Maven](build-tool-plugins.html#build-tool-plugins.maven) | [Gradle](build-tool-plugins.html#build-tool-plugins.gradle)
+
+* **附录：** [应用程序属性](application-properties.html#appendix.application-properties) | [配置元数据](configuration-metadata.html#appendix.configuration-metadata) | [自动配置类](auto-configuration-classes.html#appendix.auto-configuration-classes) | [测试自动配置注释](test-auto-configuration.html#appendix.test-auto-configuration) | [Executable Jars](executable-jar.html#appendix.executable-jar) | [依赖版本](dependency-versions.html#appendix.dependency-versions)
+

docs/spring-boot/getting-help.md

+# 获得帮助
+
+如果你的靴子有问题，我们愿意提供帮助。
+
+* 尝试[how-to 文档](howto.html#howto)。它们为最常见的问题提供了解决方案。
+
+* 学习基础知识。 Spring Boot 建立在许多其他 Spring 项目之上。查看[spring.io](https://spring.io)网站以获取大量的参考文档。如果你从 Spring 开始，请尝试[guides](https://spring.io/guides)中的一个。
+
+* 问一个问题。我们监视[stackoverflow.com](https://stackoverflow.com)中带有[`spring-boot`](https://stackoverflow.com/tags/spring-boot)标记的问题。
+
+* 使用 Spring boot 在[github.com/spring-projects/spring-boot/issues](https://github.com/spring-projects/spring-boot/issues)上报告错误。
+
+注：
+
+所有的启动都是开源的，包括文档。如果你发现 DOCS 存在问题或希望改进它们，请[get involved](https://github.com/spring-projects/spring-boot/tree/v2.6.4)。
\ No newline at end of file

docs/spring-boot/legal.md

+# 法律
+
+版权所有 2012-2022
+
+本文件的副本可供你自己使用并分发给他人，但前提是你不对此类副本收取任何费用，并且还需每一份副本均包含本版权声明，无论是以印刷形式还是以电子方式分发。

docs/spring-boot/upgrading.md

+# 升级 Spring 引导
+
+在项目[wiki](https://github.com/spring-projects/spring-boot/wiki)上提供了如何从 Spring 启动的早期版本升级的说明。按照[release notes](https://github.com/spring-projects/spring-boot/wiki#release-notes)部分中的链接查找要升级到的版本。
+
+升级说明总是发布说明中的第一项。如果你落后于多个版本，请确保你还查看了跳过的版本的发布说明。
+
+## 1. 从 1.x 升级
+
+如果你正在从 Spring 启动的`1.x`版本进行升级，请检查提供详细升级说明的[维基项目中的“迁移指南”](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0-Migration-Guide)。还可以在[“release notes”](https://github.com/spring-projects/spring-boot/wiki)中查看每个版本的“新的和值得注意的”特性列表。
+
+## 2. 升级到新的功能版本
+
+当升级到新的功能版本时，一些属性可能已被重命名或删除。 Spring Boot 提供了一种在启动时分析应用程序环境和打印诊断的方法，但也为你提供了在运行时临时迁移属性的方法。要启用该功能，请在项目中添加以下依赖项：
+
+```
+<dependency>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-properties-migrator</artifactId>
+    <scope>runtime</scope>
+</dependency>
+```
+
+|   |较晚添加到环境中的属性（例如使用`@PropertySource`时）将不会被考虑在内。|
+|---|------------------------------------------------------------------------------------------------------------------------|
+
+|   |完成迁移后，请确保从项目的依赖项中删除此模块。|
+|---|-------------------------------------------------------------------------------------------------------|
+
+## 3. 升级 Spring 引导 cli
+
+要升级现有的 CLI 安装，请使用适当的 PackageManager 命令（例如，<gtr="8"/>）。如果你手动安装了 CLI，请按照[标准说明](getting-started.html#getting-started.installing.cli.manual-installation)，记住更新你的`PATH`环境变量，以删除任何旧的引用。
+
+## 4. 接下来读什么？
+
+一旦你决定升级你的应用程序，你可以在文档的其余部分找到关于特定功能的详细信息。
+
+Spring Boot 的文档是针对该版本的，因此你在这里找到的任何信息都将包含该版本中最新的更改。
+