#1 strutrue merge master

83a71950 · 茶陵後 · 284806f3 · 49824049 · 83a71950 · 83a71950
140 changed file
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
--- a/docs/README.md
+++ b/docs/README.md
@@ -6,16 +6,16 @@

 | 内容大纲 | 校对者 | 已校对  |
 | ------ | ------ | -------  |
-| [为什么是Spring](https://dev-cloud.gitcode.host/spring/why-spring.html) | 冯丙见 | <ul><li> [ ] </li></ul> |
-| [Spring Boot 介绍](https://dev-cloud.gitcode.host/spring/introducing-spring-boot.html) | 冯丙见 | <ul><li> [ ] </li></ul> |
-| [Spring 快速入门指南](https://dev-cloud.gitcode.host/spring/quickstart.html) | 冯丙见 | <ul><li> [ ] </li></ul> |
+| [为什么是Spring](https://dev-cloud.gitcode.host/spring/why-spring.html) | 冯丙见 | <ul><li> [x] </li></ul> |
+| [Spring Boot 介绍](https://dev-cloud.gitcode.host/spring/introducing-spring-boot.html) | 冯丙见 | <ul><li> [x] </li></ul> |
+| [Spring 快速入门指南](https://dev-cloud.gitcode.host/spring/quickstart.html) | 冯丙见 | <ul><li> [x] </li></ul> |
 | [安装系统要求](https://dev-cloud.gitcode.host/spring/system-requirements.html) | 崔志康 | <ul><li> [ ] </li></ul> |
 | [安装Spring Boot](https://dev-cloud.gitcode.host/spring/installing.html) | 崔志康 | <ul><li> [ ] </li></ul> |
-| [安装脚手架](https://dev-cloud.gitcode.host/spring/initializr.html) | 王晗 | <ul><li> [ ] </li></ul> |
-| [在 VS Code 中开始使用 Java](https://dev-cloud.gitcode.host/spring/vscode_java.html) | 王晗 | <ul><li> [ ] </li></ul> |
+| [安装脚手架](https://dev-cloud.gitcode.host/spring/initializr.html) | 王晗 | <ul><li> [x] </li></ul> |
+| [在 VS Code 中开始使用 Java](https://dev-cloud.gitcode.host/spring/vscode_java.html) | 王晗 | <ul><li> [x] </li></ul> |
 | [使用 IntelliJ IDEA 编写入门指南](https://dev-cloud.gitcode.host/spring/intellij_idea.html) | 王捷 | <ul><li> [ ] </li></ul> |
 | [开发你的第一个 Spring Boot 应用程序](https://dev-cloud.gitcode.host/spring/getting-started_first-application.html) | 王捷 |  <ul><li> [ ] </li></ul> |
-| [构建 RESTful Web 服务](https://dev-cloud.gitcode.host/spring/rest-service.html#%E4%BD%A0%E5%B0%86%E5%BB%BA%E9%80%A0%E4%BB%80%E4%B9%88) | 王晗 |  <ul><li> [ ] </li></ul> |
+| [构建 RESTful Web 服务](https://dev-cloud.gitcode.host/spring/rest-service.html#%E4%BD%A0%E5%B0%86%E5%BB%BA%E9%80%A0%E4%BB%80%E4%B9%88) | 王晗 |  <ul><li> [x] </li></ul> |
 | [使用 RESTful Web 服务](https://dev-cloud.gitcode.host/spring/consuming-rest.html#%E4%BD%A0%E5%B0%86%E5%BB%BA%E9%80%A0%E4%BB%80%E4%B9%88) | 王捷 |  <ul><li> [ ] </li></ul> |

 ## 参与贡献流程

--- a/docs/consuming-rest.md
+++ b/docs/consuming-rest.md
 # 使用 RESTful Web 服务

-本指南将引导您完成创建使用 RESTful Web 服务的应用程序的过程。
+本指南将引导您创建一个提供 RESTful Web 服务的应用程序。

 ## 你将建造什么

-您将构建一个应用程序，该应用程序使用 Spring`RestTemplate`在https://quoters.apps.pcfone.io/api/random检索随机 Spring Boot 报价。
+您将构建一个应用程序，该应用程序使用 Spring`RestTemplate` 请求 https://quoters.apps.pcfone.io/api/random 获得一个随机的 Spring Boot 引文。

 ## 你需要什么

@@ -13,46 +13,46 @@
 - [JDK 1.8](http://www.oracle.com/technetwork/java/javase/downloads/index.html)或更高版本
 - [Gradle 4+](http://www.gradle.org/downloads)或[Maven 3.2+](https://maven.apache.org/download.cgi)
 - 您还可以将代码直接导入 IDE：
-  - [弹簧工具套件 (STS)](https://spring.io/guides/gs/sts)
+  - [Spring Tool Suite (STS)](https://spring.io/guides/gs/sts)
  - [IntelliJ IDEA](https://spring.io/guides/gs/intellij-idea/)

 ## 如何完成本指南

-像大多数 Spring[入门指南](https://spring.io/guides)一样，您可以从头开始并完成每个步骤，也可以绕过您已经熟悉的基本设置步骤。无论哪种方式，您最终都会得到工作代码。
+像大多数 Spring[入门指南](https://spring.io/guides)一样，您可以从头开始并完成每个步骤，也可以绕过您已经熟悉的基本设置步骤。两种方式都会让您得到可以成功运行的代码。

-要**从头开始**，请继续[从 Spring Initializr 开始](https://spring.io/guides/gs/consuming-rest/#scratch)。
+要**从头开始**，请参考[从 Spring Initializr 开始](https://spring.io/guides/gs/consuming-rest/#scratch)。

 要**跳过基础知识**，请执行以下操作：

- [下载](https://github.com/spring-guides/gs-consuming-rest/archive/main.zip)并解压缩本指南的源存储库，或使用[Git](https://spring.io/understanding/Git)克隆它：`git clone https://github.com/spring-guides/gs-consuming-rest.git`
- 光盘进入`gs-consuming-rest/initial`
- 跳转到[获取 REST 资源](https://spring.io/guides/gs/consuming-rest/#initial)。
+- [下载](https://github.com/spring-guides/gs-consuming-rest/archive/main.zip)并解压缩本指南的源代码，或使用[Git](https://spring.io/understanding/Git)克隆它：`git clone https://github.com/spring-guides/gs-consuming-rest.git`
+- 进入项目中的 `gs-consuming-rest/initial` 目录
+- 继续阅读[获取 REST 资源](https://spring.io/guides/gs/consuming-rest/#initial)。

-**完成后**，您可以对照中的代码检查结果`gs-consuming-rest/complete`。
+**完成后**，您可以对照`gs-consuming-rest/complete`中的代码进行检查。

 ## 从 Spring Initializr 开始

-您可以使用这个[预先初始化的项目](https://start.spring.io/#!type=maven-project&language=java&platformVersion=2.5.5&packaging=jar&jvmVersion=11&groupId=com.example&artifactId=consuming-rest&name=consuming-rest&description=Demo project for Spring Boot&packageName=com.example.consuming-rest&dependencies=web)并单击 Generate 下载 ZIP 文件。此项目配置为适合本教程中的示例。
+您可以使用这个[预先初始化的项目](https://start.spring.io/#!type=maven-project&language=java&platformVersion=2.5.5&packaging=jar&jvmVersion=11&groupId=com.example&artifactId=consuming-rest&name=consuming-rest&description=Demo project for Spring Boot&packageName=com.example.consuming-rest&dependencies=web) 单击 Generate 下载 ZIP 文件。此项目的配置适合教程中的示例。

 手动初始化项目：

 1. 导航到[https://start.spring.io](https://start.spring.io/)。该服务提取应用程序所需的所有依赖项，并为您完成大部分设置。
 2. 选择 Gradle 或 Maven 以及您要使用的语言。本指南假定您选择了 Java。
 3. 单击**Dependencies**并选择**Spring Web**。
-4. 单击**生成**。
-5. 下载生成的 ZIP 文件，该文件是根据您的选择配置的 Web 应用程序的存档。
+4. 单击**Generate**。
+5. 下载生成的 ZIP 文件，该文件是根据您的选择配置好的 Web 应用程序压缩包。

 如果您的 IDE 具有 Spring Initializr 集成，您可以从您的 IDE 完成此过程。

-你也可以从 Github 上 fork 项目并在你的 IDE 或其他编辑器中打开它。
+你也可以从 Github 上 fork 这个项目并在你的 IDE 或其他编辑器中打开它。

 ## 获取 REST 资源

-完成项目设置后，您可以创建一个使用 RESTful 服务的简单应用程序。
+完成项目设置后，您可以创建一个使用 RESTful 服务的简单的应用程序。

-一个 RESTful 服务已经在https://quoters.apps.pcfone.io/api/random建立起来。它随机获取有关 Spring Boot 的引用并将它们作为 JSON 文档返回。
+在 https://quoters.apps.pcfone.io/api/random 已经提供了一个 RESTful 服务。它随机将有关 Spring Boot 的引文作为 JSON 文档的形式返回。

-如果您通过 Web 浏览器或 curl 请求该 URL，您会收到如下所示的 JSON 文档：
+如果您通过 Web 浏览器或 curl 命令请求该 URL，您会收到如下所示的 JSON 文档：

 ```
 {
@@ -64,11 +64,11 @@
 }
 ```

-这很容易，但在通过浏览器或 curl 获取时并不是非常有用。
+通过浏览器或 curl 获取响应很容易，但这种方式并不是用途很广。

-以编程方式使用 REST Web 服务的更有用的方法。为了帮助您完成这项任务，Spring 提供了一个方便的模板类，称为[`RestTemplate`](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/client/RestTemplate.html). `RestTemplate`使与大多数 RESTful 服务的交互成为单行咒语。它甚至可以将该数据绑定到自定义域类型。
+以编程方式使用 REST Web 服务是更通用的方法。为了帮助您完成这项任务，Spring 提供了一个方便的模板类，称为[`RestTemplate`](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/client/RestTemplate.html). `RestTemplate` 大大简化了与 RESTful 服务交互的代码。它甚至可以将该数据绑定到自定义的领域类。

-首先，您需要创建一个域类来包含您需要的数据。以下清单显示了`Quote`可以用作域类的类：
+首先，您需要创建一个领域类来包含您需要的数据。以下清单显示了可以用作领域类的`Quote`类：

 ```
 src/main/java/com/example/consumingrest/Quote.java
@@ -114,11 +114,11 @@ public class Quote {
 }
 ```

-这个简单的 Java 类有一些属性和匹配的 getter 方法。它使用`@JsonIgnoreProperties`来自 Jackson JSON 处理库的注释来指示任何未绑定在此类型中的属性应被忽略。
+这个简单的 Java 类有一些属性和对应的 getter 方法。用于 JSON 处理的 Jackson  库的 `@JsonIgnoreProperties` 注释意味着未绑定在此类中的属性都应被忽略。

-要将您的数据直接绑定到您的自定义类型，您需要将变量名称指定为与从 API 返回的 JSON 文档中的键完全相同。如果您的 JSON 文档中的变量名称和键不匹配，您可以使用`@JsonProperty`注释来指定 JSON 文档的确切键。（此示例将每个变量名称与 JSON 键匹配，因此此处不需要该注释。）
+要将数据直接绑定到自定义领域类，您需要在类中定义和 API 返回的 JSON 中的键完全相同的变量名称。如果您的 JSON 中的变量名称和键不匹配，您可以使用`@JsonProperty`注释来为变量指定对应的 JSON 的键。（此示例中每个变量名称都与 JSON 键匹配，因此此处不需要该注释。）

-您还需要一个额外的类来嵌入内部引用本身。该类`Value`满足了这一需求，并显示在以下清单 (at `src/main/java/com/example/consumingrest/Value.java`) 中：
+您还需要一个额外的类来存储引文。`Value`类满足了这一需求，展示如下 (`src/main/java/com/example/consumingrest/Value.java`) ：

 ```
 package com.example.consumingrest;
@@ -160,11 +160,11 @@ public class Value {
 }
 ```

-这使用相同的注释，但映射到其他数据字段。
+这个类使用了相同的注释，但数据会根据变量名映射到不同的字段。

-## 完成申请
+## 完成应用

-Initalizr 创建一个带有`main()`方法的类。以下清单显示了 Initializr 创建的类（at `src/main/java/com/example/consumingrest/ConsumingRestApplication.java`）：
+Initalizr 创建了一个带有`main()`方法的类。以下代码显示了 Initializr 创建的类（`src/main/java/com/example/consumingrest/ConsumingRestApplication.java`）：

 ```
 package com.example.consumingrest;
@@ -182,13 +182,13 @@ public class ConsumingRestApplication {
 }
 ```

-现在您需要向`ConsumingRestApplication`该类添加一些其他内容，以使其显示来自我们 RESTful 源的引用。您需要添加：
+现在您需要向`ConsumingRestApplication`类添加一些代码，以使其展示 RESTful 源服务返回的引文。您需要添加：

- 一个记录器，用于将输出发送到日志（在此示例中为控制台）。
- A `RestTemplate`，它使用 Jackson JSON 处理库来处理传入的数据。
- A在启动`CommandLineRunner`时运行`RestTemplate`（并因此获取我们的报价）。
+- 一个日志记录器，用于将输出发送到日志（在此示例中为控制台）。
+- 一个 `RestTemplate`，它使用用于 JSON 处理的 Jackson 库来处理传入的数据。
+- 一个在启动时用来运行 `RestTemplate` 的 `CommandLineRunner`（获取我们的引文）。

-以下清单显示了完成的`ConsumingRestApplication`类 (at `src/main/java/com/example/consumingrest/ConsumingRestApplication.java`)：
+以下代码是最终的`ConsumingRestApplication`类 ( `src/main/java/com/example/consumingrest/ConsumingRestApplication.java`)：

 ```
 package com.example.consumingrest;
@@ -229,29 +229,29 @@ public class ConsumingRestApplication {

 ## 运行应用程序

-您可以使用 Gradle 或 Maven 从命令行运行应用程序。您还可以构建一个包含所有必要依赖项、类和资源的单个可执行 JAR 文件并运行它。构建可执行 jar 可以在整个开发生命周期、跨不同环境等中轻松地作为应用程序交付、版本化和部署服务。
+您可以使用 Gradle 或 Maven 从命令行运行应用程序。您还可以构建一个包含所有必要依赖项、类和资源的单个可执行 JAR 文件并运行它。构建一个可执行的 jar 可以在整个开发生命周期、不同环境中作为应用程序轻松地去交付、升级、部署。

-如果您使用 Gradle，则可以使用`./gradlew bootRun`. 或者，您可以使用构建 JAR 文件`./gradlew build`，然后运行 JAR 文件，如下所示：
+如果您使用 Gradle，则可以使用`./gradlew bootRun` 去运行程序。或者，您可以使用`./gradlew build`构建 JAR 文件，然后运行 JAR 文件，如下所示：

 ```
 java -jar build/libs/gs-consuming-rest-0.1.0.jar
 ```

- 如果您使用 Maven，则可以使用`./mvnw spring-boot:run`. 或者，您可以使用构建 JAR 文件，`./mvnw clean package`然后运行该 JAR 文件，如下所示：
+如果您使用 Maven，则可以使用`./mvnw spring-boot:run`. 或者，您可以使用`./mvnw clean package`构建 JAR 文件，然后运行该 JAR 文件，如下所示：

 ```
 java -jar target/gs-consuming-rest-0.1.0.jar
 ```

-此处描述的步骤创建了一个可运行的 JAR。您还可以[构建经典的 WAR 文件](https://spring.io/guides/gs/convert-jar-to-war/)。
+以上描述的步骤是如何创建一个可运行的 JAR。您还可以[构建经典的 WAR 文件](https://spring.io/guides/gs/convert-jar-to-war/)。

-您应该看到类似于以下的输出，但带有随机引用：
+您应该会看到类似于下面内容的输出，但会包含随机的引文：

 ```
 2019-08-22 14:06:46.506  INFO 42940 --- [           main] c.e.c.ConsumingRestApplication           : Quote{type='success', value=Value{id=1, quote='Working with Spring Boot is like pair-programming with the Spring developers.'}}
 ```

-如果您看到显示为 的错误，`Could not extract response: no suitable HttpMessageConverter found for response type [class com.example.consumingrest.Quote]`则可能是您处于无法连接到后端服务的环境中（如果您可以访问它，它将发送 JSON）。也许您是公司代理的幕后黑手。尝试将`http.proxyHost`和`http.proxyPort`系统属性设置为适合您的环境的值。
+如果您看到显示为的错误，`Could not extract response: no suitable HttpMessageConverter found for response type [class com.example.consumingrest.Quote]` 则可能是您处于无法访问到后端服务的环境中（如果您可以访问它，它将发送 JSON）。如果您是公司代理的管理员，尝试将 `http.proxyHost`和`http.proxyPort` 系统属性设置为适合您的环境的值。

 ## 概括


--- a/docs/getting-started_first-application.md
+++ b/docs/getting-started_first-application.md
 ## 开发你的第一个 Spring Boot 应用程序

-本节介绍如何开发一个小的“Hello World！” 突出 Spring Boot 的一些关键特性的 web 应用程序。我们使用 Maven 来构建这个项目，因为大多数 IDE 都支持它。
+本节介绍如何开发一个小的 “Hello World！” web 应用程序，用来突出 Spring Boot 的一些关键特性的。因为大多数 IDE 都支持 Maven，所以我们使用 Maven 来构建这个项目。

 Tip:

-spring.io网站包含许多使用 Spring Boot 的“入门”[指南](https://spring.io/guides)[。](https://spring.io/)如果您需要解决特定问题，请先检查那里。
+spring.io 网站包含许多使用 Spring Boot 的“入门”[指南](https://spring.io/guides)[。](https://spring.io/) 如果您需要解决特定的问题，请先到那里查找解决方案。

-您可以通过转到[start.spring.io](https://start.spring.io/)并从依赖项搜索器中选择“Web”启动器来简化以下步骤。这样做会生成一个新的项目结构，以便您可以[立即开始编码](https://docs.spring.io/spring-boot/docs/2.6.4/reference/html/getting-started.html#getting-started.first-application.code)。查看[start.spring.io 用户指南](https://github.com/spring-io/start.spring.io/blob/main/USING.adoc)了解更多详情。
+如果您想简化以下构建项目的步骤，可以在 [start.spring.io](https://start.spring.io/) 中选择 "Dependencies" 搜索器中的 “Web” 选项。这样做会生成一个全新的项目结构，以便您可以[立即开始编码](https://docs.spring.io/spring-boot/docs/2.6.4/reference/html/getting-started.html#getting-started.first-application.code)。查看[start.spring.io 用户指南](https://github.com/spring-io/start.spring.io/blob/main/USING.adoc)了解更多详情。

 在我们开始之前，打开一个终端并运行以下命令以确保您安装了有效版本的 Java 和 Maven：

@@ -26,11 +26,11 @@ Java version: 1.8.0_102, vendor: Oracle Corporation

 Note:

-此示例需要在其自己的目录中创建。后续说明假定您已经创建了一个合适的目录并且它是您的当前目录。
+此示例需要创建在一个它自己单独的目录中。后续说明都是假定您已经创建了一个合适的目录并且它是您的当前目录。

 ### 创建 POM

-我们需要从创建一个 Maven`pom.xml`文件开始。这`pom.xml`是用于构建项目的配方。打开您喜欢的文本编辑器并添加以下内容：
+我们需要从创建一个 Maven 的 `pom.xml`文件开始。这个`pom.xml`是用于构建项目的配方。打开您喜欢的文本编辑器并添加以下内容：

 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
@@ -53,17 +53,17 @@ Note:
 </project>
 ```

-前面的清单应该给你一个工作构建。您可以通过运行对其进行测试`mvn package`（现在，您可以忽略“jar 将为空 - 没有内容被标记为包含！”警告）。
+前面的内容应该会让您成功地构建项目。您可以运行 `mvn package` 进行测试（目前您可以忽略 “jar will be empty - no content was marked for inclusion!” 的警告）。

 Note:

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

-### 添加类路径依赖项
+### 添加 ClassPath 依赖项

-Spring Boot 提供了许多“启动器”，可让您将 jars 添加到类路径中。我们的烟雾测试应用程序使用POM 部分中的`spring-boot-starter-parent`。`parent`这`spring-boot-starter-parent`是一个特殊的启动器，提供有用的 Maven 默认值。它还提供了一个[`dependency-management`](https://docs.spring.io/spring-boot/docs/2.6.4/reference/html/using.html#using.build-systems.dependency-management)部分，以便您可以省略`version`“祝福”依赖项的标签。
+Spring Boot 提供了许多“启动器” (stater) ，可让您将 jars 添加到 ClassPath 中。我们冒烟测试应用程序使用的是 POM 文件 "parent" 部分的 `spring-boot-starter-parent` 。`spring-boot-starter-parent` 是一个特殊的启动器，提供了有用的 Maven 默认值。它还提供了一个[`dependency-management`](https://docs.spring.io/spring-boot/docs/2.6.4/reference/html/using.html#using.build-systems.dependency-management)，以便您可以省略一部分依赖项的 `version` 标签。

-其他“Starters”提供了您在开发特定类型的应用程序时可能需要的依赖项。由于我们正在开发 Web 应用程序，因此我们添加了一个`spring-boot-starter-web`依赖项。在此之前，我们可以通过运行以下命令查看我们当前拥有的内容：
+其他“Starters”提供了您在开发特定类型的应用程序时可能需要的依赖项。由于我们正在开发 Web 应用程序，因此我们添加了一个`spring-boot-starter-web`依赖项。我们可以通过运行以下命令查看我们当前依赖的内容：

 ```shell
 $ mvn dependency:tree
@@ -71,7 +71,7 @@ $ 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 parent`
+该`mvn dependency:tree`命令会打印一个树，它表示了项目的依赖项。您可以看到`spring-boot-starter-parent`本身不提供任何依赖项。要添加必要的依赖项，请编辑您的`pom.xml`，在`parent`部分正下方添加依赖项：`spring-boot-starter-web`

 ```xml
 <dependencies>
@@ -82,11 +82,11 @@ $ mvn dependency:tree
 </dependencies>
 ```

-如果`mvn dependency:tree`再次运行，您会看到现在有许多附加依赖项，包括 Tomcat Web 服务器和 Spring Boot 本身。
+如果再次运行 `mvn dependency:tree`，您会看到现在有许多附加依赖项，包括 Tomcat Web 服务器和 Spring Boot 本身。

 ### 编写代码

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

 ```java
 @RestController
@@ -105,34 +105,34 @@ public class MyApplication {
 }
 ```

-虽然这里没有太多代码，但有很多事情正在发生。我们将在接下来的几节中逐步介绍重要部分。
+虽然这里没有太多代码，但已经产生了很大的作用。我们将在接下来的几节中逐步介绍重要的部分。

 #### @RestController 和 @RequestMapping 注解

-`MyApplication`我们类的第一个注释是`@RestController`. 这称为*构造型*注释。它为阅读代码的人和 Spring 提供了类扮演特定角色的提示。在这种情况下，我们的类是一个 web `@Controller`，因此 Spring 在处理传入的 Web 请求时会考虑它。
+`MyApplication`类的第一个注解是`@RestController`. 这称为*构造型*注解。它告诉阅读代码的人和 Spring 这个类扮演了哪些特定的角色。在这个例子中，我们的类是一个 web `@Controller`，因此 Spring 在处理传入的 Web 请求时会使用它。

-`@RequestMapping`注释提供“路由”信息。它告诉 Spring 任何带有该`/`路径的 HTTP 请求都应该映射到该`home`方法。注释告诉 Spring将`@RestController`结果字符串直接呈现给调用者。
+`@RequestMapping` 注释提供“路由”信息。它告诉 Spring 任何带有`/`路径的 HTTP 请求都应该映射到 `home` 方法。`@RestController` 注释告诉 Spring 将结果以字符串的形式直接呈现给调用者。

 Tip:

-和注释是 Spring MVC 注释`@RestController`（`@RequestMapping`它们不是特定于 Spring Boot）。有关详细信息，请参阅 Spring 参考文档中的[MVC 部分](https://docs.spring.io/spring-framework/docs/5.3.16/reference/html/web.html#mvc)。
+`@RestController` 和 `@RequestMapping` 注释是 Spring MVC 注释（它们不是特定只用于 Spring Boot）。有关详细信息，请参阅 Spring 参考文档中的[MVC 部分](https://docs.spring.io/spring-framework/docs/5.3.16/reference/html/web.html#mvc)。

 #### @EnableAutoConfiguration 注解

-第二个类级别的注释是`@EnableAutoConfiguration`. 这个注解告诉 Spring Boot 根据你添加的 jar 依赖来“猜测”你想如何配置 Spring。由于`spring-boot-starter-web`添加了 Tomcat 和 Spring MVC，自动配置假定您正在开发 Web 应用程序并相应地设置 Spring。
+第二个类级别的注释是`@EnableAutoConfiguration`. 这个注解告诉 Spring Boot 根据你添加的 jar 依赖来“猜测”你想如何配置 Spring。由于`spring-boot-starter-web`添加了 Tomcat 和 Spring MVC，自动配置功能会假定您正在开发 Web 应用程序并相应地设置 Spring。

 ```
 启动器和自动配置
 自动配置旨在与“启动器”很好地配合使用，但这两个概念并没有直接联系。您可以自由选择启动器之外的 jar 依赖项。Spring Boot 仍然尽力自动配置您的应用程序。
 ```

-#### “主要”方法
+#### “main”方法

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

 ### 运行示例

-此时，您的应用程序应该可以工作了。由于您使用了`spring-boot-starter-parent`POM，因此您有一个有用的`run`目标，可用于启动应用程序。`mvn spring-boot:run`从根项目目录键入以启动应用程序。您应该会看到类似于以下内容的输出：
+此时，您的应用程序应该可以工作了。由于您在POM中使用了`spring-boot-starter-parent`，因此您有了一个有用的`run`目标，可用于启动应用程序。通过命令行工具，在根项目目录输入 `mvn spring-boot:run` 来启动应用程序。您应该会看到类似于以下内容的输出：

 ```shell
 $ mvn spring-boot:run
@@ -156,7 +156,7 @@ $ mvn spring-boot:run
 Hello World!
 ```

-要优雅地退出应用程序，请按`ctrl-c`。
+要优雅地退出应用程序，请在命令行中按`ctrl-c`。

 ### 创建可执行 Jar

@@ -164,13 +164,13 @@ Hello World!

 可执行 jar 和 Java

-Java 不提供加载嵌套 jar 文件（本身包含在 jar 中的 jar 文件）的标准方法。如果您希望分发一个独立的应用程序，这可能会出现问题。
+Java 不提供加载嵌套 jar 文件（包含了 jar 的 jar 文件）的标准方法。如果您希望部署一个独立的应用程序，这可能会出现问题。

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

 Spring Boot 采用了[不同的方法](https://docs.spring.io/spring-boot/docs/2.6.4/reference/html/executable-jar.html#appendix.executable-jar)，让您实际上可以直接嵌套 jar。

-`spring-boot-maven-plugin`要创建一个可执行的 jar，我们需要将`pom.xml`. 为此，请在该`dependencies`部分下方插入以下行：
+要创建一个可执行的 jar，我们需要将`spring-boot-maven-plugin`添加到`pom.xml`. 为此，请在`dependencies`部分下方插入以下内容：

 ```xml
 <build>
@@ -183,9 +183,9 @@ Spring Boot 采用了[不同的方法](https://docs.spring.io/spring-boot/docs/2
 </build>
 ```

-Note:
+备注:

-`spring-boot-starter-parent`POM 包含`<executions>`绑定`repackage`目标 的配置。如果不使用父 POM，则需要自己声明此配置。有关详细信息，请参阅[插件文档](https://docs.spring.io/spring-boot/docs/2.6.4/maven-plugin/reference/htmlsingle/#getting-started)。
+POM中的 `spring-boot-starter-parent` 包含了 `<executions>` 的配置去绑定 `repackage` 的目标。如果不使用父 POM，则需要自己声明此配置。有关详细信息，请参阅[插件文档](https://docs.spring.io/spring-boot/docs/2.6.4/maven-plugin/reference/htmlsingle/#getting-started)。

 保存`pom.xml`并从命令行运行`mvn package`，如下：

@@ -207,15 +207,15 @@ $ mvn package
 [INFO] ------------------------------------------------------------------------
 ```

-如果您查看`target`目录，您应该会看到`myproject-0.0.1-SNAPSHOT.jar`. 该文件的大小应约为 10 MB。如果你想偷看里面，你可以使用`jar tvf`，如下：
+如果您查看`target`目录，您应该会看到`myproject-0.0.1-SNAPSHOT.jar`. 该文件的大小应约为 10 MB。如果你想看 jar 里面的内容，可以使用`jar tvf`，如下所示：

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

-`myproject-0.0.1-SNAPSHOT.jar.original`您还应该在目录中看到一个小得多的文件`target`。这是Maven在被Spring Boot重新打包之前创建的原始jar文件。
+您还应该在 `target` 目录中看到一个小得多的文件 `myproject-0.0.1-SNAPSHOT.jar.original`。这是在被 Spring Boot 重新打包之前，Maven 创建的原始jar文件。

-和以前一样，要退出应用程序，请按`ctrl-c`。
+如下所示，使用 "java -jar" 命令来运行应用程序。

 ```shell
 $ java -jar target/myproject-0.0.1-SNAPSHOT.jar
@@ -233,6 +233,6 @@ $ java -jar target/myproject-0.0.1-SNAPSHOT.jar
 ........ Started MyApplication in 2.536 seconds (JVM running for 2.864)
 ```

-As before, to exit the application, press `ctrl-c`.
+和以前一样，要退出应用程序，请按`ctrl-c`。

 原文链接: https://docs.spring.io/spring-boot/docs/2.6.4/reference/html/getting-started.html#getting-started.first-application
\ No newline at end of file
--- a/docs/initializr.md
+++ b/docs/initializr.md
 # 脚手架

-![2022-03-01-18-11-18](./initializr/2022-03-01-18-11-18.png)
+**[通过配置，生成spring demo项目](https://start.spring.io/)**
+![2022-03-01-18-11-18](./initializr/2022-03-03-13-33.png)
+

 原文链接: https://start.spring.io/

--- a/docs/initializr/2022-03-03-13-33.png
+++ b/docs/initializr/2022-03-03-13-33.png
--- a/docs/introducing-spring-boot.md
+++ b/docs/introducing-spring-boot.md
 ## Spring Boot 介绍

-Spring Boot 可帮助您创建可以运行的独立的、生产级的基于 Spring 的应用程序。我们对 Spring 平台和第三方库持固执己见的看法，以便您可以轻松上手。大多数 Spring Boot 应用程序只需要很少的 Spring 配置。
+Spring Boot 可帮助您创建可以运行的独立的、生产级的基于 Spring 的应用程序。我们固化Spring平台和第三方库的依赖，以便您可以轻松上手。大多数 Spring Boot 应用程序只需要很少的 Spring 配置。

-您可以使用 Spring Boot 创建可以通过使用`java -jar`或更传统的战争部署启动的 Java 应用程序。我们还提供了一个运行“spring 脚本”的命令行工具。
+您可以使用 Spring Boot 创建可以通过使用`java -jar`或更传统的war部署启动的Java应用程序。我们还提供了一个运行“spring 脚本”的命令行工具。

 我们的主要目标是：

- 为所有 Spring 开发提供从根本上更快且可广泛访问的入门体验。
- 开箱即用，但随着需求开始偏离默认值，请迅速摆脱困境。
- 提供大类项目（例如嵌入式服务器、安全性、指标、健康检查和外部化配置）通用的一系列非功能性特性。
+- 为所有Spring开发提供更快、更广泛的入门体验。
+- 开箱即用，但随着需求开始变更时，可以快速变更。
+- 提供一系列对大型项目（例如嵌入式服务器，安全性，度量标准，运行状况检查和外部化配置）通用的非功能性功能
 - 绝对没有代码生成，也不需要 XML 配置。

-原文链接: https://docs.spring.io/spring-boot/docs/2.6.4/reference/html/getting-started.html#getting-started.introducing-spring-boot
\ No newline at end of file
+原文链接: https://docs.spring.io/spring-boot/docs/2.6.4/reference/html/getting-started.html#getting-started.introducing-spring-boot
--- a/docs/quickstart.md
+++ b/docs/quickstart.md
@@ -2,29 +2,29 @@

 ## 您将构建什么

-您将构建一个经典的“Hello World！” 任何浏览器都可以连接的端点。你甚至可以告诉它你的名字，它会以更友好的方式回应。
+您将构建一个经典的“Hello World！” 任何浏览器都可以连接的终端。你甚至可以告诉它你的名字，它会以更友好的方式回应。

 ## 你需要什么

 **集成开发人员环境 (IDE)**

-热门选择包括[IntelliJ IDEA](https://www.jetbrains.com/idea/),[弹簧工具](https://spring.io/tools),[视觉工作室代码](https://code.visualstudio.com/docs/languages/java)， 要么[蚀](https://www.eclipse.org/downloads/packages/)， 还有很多。
+热门选择包括[IntelliJ IDEA](https://www.jetbrains.com/idea/),[Spring Tools](https://spring.io/tools),[Visual Studio Code](https://code.visualstudio.com/docs/languages/java)，[Eclipse](https://www.eclipse.org/downloads/packages/)等等。

 **Java™ 开发工具包 (JDK)**

 我们推荐[BellSoft Liberica JDK](https://bell-sw.com/)版本 8 或版本 11。

-## 第一步：启动一个新的 Spring Boot 项目
+## 第一步：开始一个新的 Spring Boot 项目

-采用[启动.spring.io](https://start.spring.io/)创建一个“网络”项目。在“依赖项”对话框中搜索并添加“web”依赖项，如屏幕截图所示。点击“生成”按钮，下载 zip，然后将其解压缩到计算机上的文件夹中。
+通过[start.spring.io](https://start.spring.io/)创建一个“web”项目。在“依赖项”对话框中搜索并添加“web”依赖项，如屏幕截图所示。点击“生成”按钮，下载 zip，然后将其解压缩到计算机上的文件夹中。

 ![quick-img-1-12bfde9c5c280b1940d85dee3d81772d](./quickstart_img/quick-img-1-12bfde9c5c280b1940d85dee3d81772d.png)

-创建的项目[启动.spring.io](https://start.spring.io/)包含[弹簧靴](https://spring.io/projects/spring-boot)，一个使 Spring 准备好在您的应用程序中工作的框架，但不需要太多代码或配置。Spring Boot 是启动 Spring 项目的最快和最流行的方式。
+通过[start.spring.io](https://start.spring.io/)创建的项目包含[Spring Boot](https://spring.io/projects/spring-boot)，Spring Boot是一个不需要太多代码或配置,就可以使Spring在您的应用程序中正常工作的框架，Spring Boot 是使用 Spring 项目的最快、最流行的方式。

 ## 第 2 步：添加您的代码

-在 IDE 中打开项目并在文件夹`DemoApplication.java`中找到该文件`src/main/java/com/example/demo`。现在通过添加下面代码中显示的额外方法和注释来更改文件的内容。您可以复制并粘贴代码或直接输入。
+在 IDE 中打开项目并在文件夹`DemoApplication.java`中找到该文件`src/main/java/com/example/demo`。现在通过添加下面代码中显示的额外方法和注解来更改文件的内容。您可以复制并粘贴代码或直接输入。

 ```

@@ -53,15 +53,17 @@
            
 ```

-这是在 Spring Boot 中创建一个简单的“Hello World”Web 服务所需的所有代码。
+这是在Spring Boot中创建一个简单的“Hello World”Web服务所需的所有代码。

-`hello()`我们添加的方法旨在获取一个名为 的字符串参数`name`，然后将该参数与`"Hello"`代码中的单词结合起来。这意味着如果您`“Amy”`在请求中将您的姓名设置为，则响应将为`“Hello Amy”`.
+`hello()`方法，我们设计成接收一个字符串参数`name`，然后将该参数与`"Hello"`连接起来。如果您请求时将`name`设置为`“Amy”`，服务将会返回`“Hello Amy”`.

-`@RestController`注释告诉 Spring 这段代码描述了一个应该在 web 上可用的端点。`@GetMapping(“/hello”)`告诉 Spring 使用我们的方法`hello()`来回答发送到该`http://localhost:8080/hello`地址的请求。最后，`@RequestParam`告诉 Spring`name`在请求中期待一个值，但如果它不存在，它将默认使用单词“World”。
+`@RestController`注解告诉 Spring 这段代码描述了一个应该在 web 上可用的端点。
+`@GetMapping(“/hello”)`告诉 Spring 使用我们的方法`hello()`来响应发送到该`http://localhost:8080/hello`地址的请求。
+`@RequestParam`告诉 Spring期望请求中包含`name`参数，但如果它不存在，将使用默认值“World”。

 ## 第 3 步：尝试一下

-让我们构建并运行程序。打开命令行（或终端）并导航到您拥有项目文件的文件夹。我们可以通过发出以下命令来构建和运行应用程序：
+让我们构建并运行程序。打开命令行（或终端）并进入到项目所在文件夹。可以通过以下命令来构建和运行应用程序：

 **MacOS/Linux:**

@@ -79,8 +81,8 @@ mvnw spring-boot:run

 ![quick-img2-ac5ae88c60ffaa062234a580f9f1abc3](./quickstart_img/quick-img2-ac5ae88c60ffaa062234a580f9f1abc3.png)

-这里的最后几行告诉我们春天已经开始了。Spring Boot 的嵌入式 Apache Tomcat 服务器充当 Web 服务器，并正在侦听`localhost`port上的请求`8080`。打开浏览器，在顶部的地址栏中输入[http://localhost:8080/你好](http://localhost:8080/hello). 你应该得到一个很好的友好回应，如下所示：
+最后的几行日志显示Spring已经启动了。Spring Boot 的嵌入式 Apache Tomcat 服务器充当 Web 服务器，并正在监听`localhost`上`8080`端口请求。打开浏览器，在地址栏中输入[http://localhost:8080/hello](http://localhost:8080/hello). 你应该得到一个很好的友好回应，如下所示：

 ![quick-img3-afa0a1fe446db8e3c8c7a8d9ca532d23](./quickstart_img/quick-img3-afa0a1fe446db8e3c8c7a8d9ca532d23.png)

-原文链接: https://spring.io/quickstart
\ No newline at end of file
+原文链接: https://spring.io/quickstart
--- a/docs/rest-service.md
+++ b/docs/rest-service.md
 # 构建 RESTful Web 服务

-本指南将引导您完成使用 Spring 创建“Hello, World”RESTful Web 服务的过程。
+本指南将引导您完成使用 Spring 创建“Hello, World” RESTful Web项目。

-## 你将建造什么
+## 你将开发什么

-您将构建一个接受 HTTP GET 请求的服务`http://localhost:8080/greeting`。
+您将开发一个HTTP服务，可以接收如下GET 请求：`http://localhost:8080/greeting`。

-它将以问候语的 JSON 表示形式进行响应，如以下清单所示：
+它将以JSON格式返回值响应请求，如以下清单所示：

 ```
 {"id":1,"content":"Hello, World!"}
 ```

-您可以在查询字符串中使用可选`name`参数自定义问候语，如以下清单所示：
+您可以在请求链接中使用`name`参数发送请求，如以下清单所示：

 ```
 http://localhost:8080/greeting?name=User
 ```

-`name`参数值覆盖默认值`World`并反映在响应中，如以下清单所示：
+请求返回报文中，`name`参数值将覆盖默认值`World`，如下所示：

 ```
 {"id":1,"content":"Hello, User!"}
@@ -27,35 +27,35 @@ http://localhost:8080/greeting?name=User
 ## 你需要什么

 - 约15分钟
- 最喜欢的文本编辑器或 IDE
+- 最喜欢的文本编辑器或IDE
 - [JDK 1.8](http://www.oracle.com/technetwork/java/javase/downloads/index.html)或更高版本
 - [Gradle 4+](http://www.gradle.org/downloads)或[Maven 3.2+](https://maven.apache.org/download.cgi)
 - 您还可以将代码直接导入 IDE：
-  - [弹簧工具套件 (STS)](https://spring.io/guides/gs/sts)
+  - [Spring 工具套件 (STS)](https://spring.io/guides/gs/sts)
  - [IntelliJ IDEA](https://spring.io/guides/gs/intellij-idea/)

 ## 如何完成本指南

-像大多数 Spring[入门指南](https://spring.io/guides)一样，您可以从头开始并完成每个步骤，也可以绕过您已经熟悉的基本设置步骤。无论哪种方式，您最终都会得到工作代码。
+像大多数 Spring[入门指南](https://spring.io/guides)一样，您可以从头开始并完成每个步骤，也可以绕过您已经熟悉的基本设置步骤。无论哪种方式，您最终都会获得可用的代码。

-要**从头开始**，请继续[从 Spring Initializr 开始](https://spring.io/guides/gs/rest-service/#scratch)。
+要**从头开始**，请跳转到[从 Spring Initializr 开始](https://spring.io/guides/gs/rest-service/#scratch)。

 要**跳过基础知识**，请执行以下操作：

- [下载](https://github.com/spring-guides/gs-rest-service/archive/main.zip)并解压缩本指南的源存储库，或使用[Git](https://spring.io/understanding/Git)克隆它：`git clone https://github.com/spring-guides/gs-rest-service.git`
- 光盘进入`gs-rest-service/initial`
+- [下载](https://github.com/spring-guides/gs-rest-service/archive/main.zip)并解压缩本指南的源存储库，或使用[Git](https://spring.io/understanding/Git) Clone：`git clone https://github.com/spring-guides/gs-rest-service.git`
+- cd into `gs-rest-service/initial`
 - 继续[创建资源表示类](https://spring.io/guides/gs/rest-service/#initial)。

-**完成后**，您可以对照中的代码检查结果`gs-rest-service/complete`。
+**完成后**，您可以从如下目录查看结果代码 `gs-rest-service/complete`。

 ## 从 Spring Initializr 开始

-您可以使用这个[预先初始化的项目](https://start.spring.io/#!type=maven-project&language=java&platformVersion=2.5.5&packaging=jar&jvmVersion=11&groupId=com.example&artifactId=rest-service&name=rest-service&description=Demo project for Spring Boot&packageName=com.example.rest-service&dependencies=web)并单击 Generate 下载 ZIP 文件。此项目配置为适合本教程中的示例。
+您可以使用这个[预先初始化的项目](https://start.spring.io/#!type=maven-project&language=java&platformVersion=2.5.5&packaging=jar&jvmVersion=11&groupId=com.example&artifactId=rest-service&name=rest-service&description=Demo project for Spring Boot&packageName=com.example.rest-service&dependencies=web)并单击 Generate 下载 ZIP 文件。此项目配置兼容本教程中的示例。

 手动初始化项目：

 1. 导航到[https://start.spring.io](https://start.spring.io/)。该服务提取应用程序所需的所有依赖项，并为您完成大部分设置。
-2. 选择 Gradle 或 Maven 以及您要使用的语言。本指南假定您选择了 Java。
+2. 选择 Gradle 或 Maven 以及您要使用的开发语言。本指南假定您选择了 Java。
 3. 单击**Dependencies**并选择**Spring Web**。
 4. 单击**生成**。
 5. 下载生成的 ZIP 文件，该文件是根据您的选择配置的 Web 应用程序的存档。
@@ -72,9 +72,9 @@ http://localhost:8080/greeting?name=User

 现在您已经设置了项目和构建系统，您可以创建您的 Web 服务。

-从考虑服务交互开始这个过程。
+首先考虑服务交互流程。

-该服务将处理对 的`GET`请求`/greeting`，可以选择`name`在查询字符串中使用参数。该`GET`请求应`200 OK`在表示问候的正文中返回带有 JSON 的响应。它应该类似于以下输出：
+该服务将处理访问`/greeting`的`GET`请求，请求可选参数 `name`。该`GET`请求在返回`200 OK`的情况下，JSON返回值如下：

 ```
 {
@@ -83,9 +83,9 @@ http://localhost:8080/greeting?name=User
 }
 ```

-该`id`字段是问候语的唯一标识符，是问候语`content`的文本表示。
+该`id`字段是返回内容的唯一标识符，是返回内容`content`的文本表示。

-要对问候表示建模，请创建一个资源表示类。为此，请提供一个普通的旧 Java 对象，其中包含用于`id`和`content`数据的字段、构造函数和访问器，如以下清单（来自`src/main/java/com/example/restservice/Greeting.java`）所示：
+要对返回内容建模，请创建一个资源表示类。为此，需要创建一个普通的Java 对象，其中包含`id`和`content`两个数据字段、构造函数和访问器，如以下（来自`src/main/java/com/example/restservice/Greeting.java`）所示：

 ```
 package com.example.restservice;
@@ -110,11 +110,11 @@ public class Greeting {
 }
 ```

- 此应用程序使用[Jackson JSON](https://github.com/FasterXML/jackson)库将类型的实例自动编组`Greeting`为 JSON。网络启动器默认包含 Jackson。
+ 此应用程序使用[Jackson JSON](https://github.com/FasterXML/jackson)库，将实例`Greeting`转换为JSON。web启动器默认包含Jackson。

 ## 创建资源控制器

-在 Spring 构建 RESTful Web 服务的方法中，HTTP 请求由控制器处理。这些组件由[`@RestController`](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/bind/annotation/RestController.html)注释标识，`GreetingController`下面的清单 (from )通过返回类的新实例来`src/main/java/com/example/restservice/GreetingController.java`处理`GET`请求：`/greeting``Greeting`
+在 Spring 构建的 RESTful Web 服务中，HTTP 请求由控制器处理。这些组件由[`@RestController`](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/bind/annotation/RestController.html)注释标识，如下 `GreetingController`实例（参看 `src/main/java/com/example/restservice/GreetingController.java`）处理`GET`请求：`/greeting`

 ```
 package com.example.restservice;
@@ -138,29 +138,31 @@ public class GreetingController {
 }
 ```

-这个控制器简洁明了，但引擎盖下有很多事情要做。我们一步一步分解。
+这个控制器简洁明了，但底层有很多事情要做。我们一步一步分解。

-`@GetMapping`注释确保 HTTP GET 请求`/greeting`映射到`greeting()`方法。
+`@GetMapping`注解确保 HTTP GET 请求`/greeting` 可以映射到`greeting()`方法。

-有其他 HTTP 动词的伴随注释（例如`@PostMapping`POST）。还有一个`@RequestMapping`它们都源自的注释，并且可以用作同义词（例如`@RequestMapping(method=GET)`）。
+```
+还有其他 HTTP 请求注解（例如`@PostMapping`POST）。所有注解均继承`@RequestMapping`，同时也可以使用如下注解方式（例如`@RequestMapping(method=GET)`）。
+```

-`@RequestParam`将查询字符串参数的值绑定`name`到方法的`name`参数中`greeting()`。如果`name`请求中没有参数，则使用`defaultValue`of `World`。
+`@RequestParam`将查询参数`name`的值绑定到方法`greeting()`的参数`name`上。如果请求中没有`name`参数，则使用参数默认值 `World`。

-方法体的实现创建并返回一个新`Greeting`对象，该对象具有`id`和`content`基于下一个值的属性，并使用 greeting`counter`格式化给定的格式。`name``template`
+此方法创建并返回一个新`Greeting`对象，该对象包含`id`和`content`属性，并通过counter.incrementAndGet(), String.format(template, name) 分别进行参数赋值

-传统 MVC 控制器和前面显示的 RESTful Web 服务控制器之间的一个关键区别是 HTTP 响应主体的创建方式。这个 RESTful Web 服务控制器不是依靠视图技术来执行服务器端将问候数据呈现为 HTML，而是填充并返回一个`Greeting`对象。对象数据将作为 JSON 直接写入 HTTP 响应。
+传统 MVC 控制器和前面显示的 RESTful Web 服务控制器之间的一个关键区别是 HTTP 请求响应的创建方式。这个 RESTful Web 服务控制器不是依靠视图技术直接返回HTML类型的响应内容，而是填充并返回一个`Greeting`对象。对象数据将以 JSON 类型直接写入 HTTP 响应。

-此代码使用 Spring[`@RestController`](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/bind/annotation/RestController.html)注释，它将类标记为控制器，其中每个方法都返回域对象而不是视图。它是同时包含`@Controller`和的简写`@ResponseBody`。
+此代码使用 Spring[`@RestController`](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/bind/annotation/RestController.html)注解，它将类标记为控制器，其中每个方法都返回域对象而不是视图。它是`@Controller`和`@ResponseBody`的简写。

-该`Greeting`对象必须转换为 JSON。感谢 Spring 的 HTTP 消息转换器支持，您无需手动进行此转换。因为[Jackson 2](https://github.com/FasterXML/jackson)在类路径上，所以会自动选择 Spring[`MappingJackson2HttpMessageConverter`](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/http/converter/json/MappingJackson2HttpMessageConverter.html)将`Greeting`实例转换为 JSON。
+该`Greeting`对象必须转换为 JSON 格式。依赖于 Spring 的 HTTP 消息转换器支持，您无需手动进行此转换。因为classpath里面已经包含[Jackson 2](https://github.com/FasterXML/jackson)，所以会自动选择Spring的[`MappingJackson2HttpMessageConverter`](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/http/converter/json/MappingJackson2HttpMessageConverter.html)将`Greeting`实例转换为JSON格式。

-`@SpringBootApplication`是一个方便的注释，它添加了以下所有内容：
+`@SpringBootApplication`是一个方便的注释，它包含了以下所有内容：

- `@Configuration`: 将类标记为应用程序上下文的 bean 定义源。
- `@EnableAutoConfiguration`：告诉 Spring Boot 根据类路径设置、其他 bean 和各种属性设置开始添加 bean。例如，如果`spring-webmvc`位于类路径上，则此注释将应用程序标记为 Web 应用程序并激活关键行为，例如设置`DispatcherServlet`.
- `@ComponentScan`: 告诉 Spring 在包中查找其他组件、配置和服务`com/example`，让它找到控制器。
+- `@Configuration`: 在应用程序上下文中，将类标记为bean。
+- `@EnableAutoConfiguration`：告诉 Spring Boot 根据类路径设置、其他 bean 和各种属性设置扫描并添加bean。例如，如果`spring-webmvc`位于类路径上，则此注释将应用程序标记为 Web 应用程序并激活关键行为，例如设置`DispatcherServlet`.
+- `@ComponentScan`: 告诉 Spring 在包`com/example`中扫描其他components, configurations及services类

-该`main()`方法使用 Spring Boot 的`SpringApplication.run()`方法来启动应用程序。您是否注意到没有一行 XML？也没有`web.xml`文件。这个 Web 应用程序是 100% 纯 Java，您不必处理任何管道或基础设施的配置。
+该`main()`方法使用 Spring Boot 的`SpringApplication.run()`方法来启动应用程序。您是否注意到我们没有配置一行 XML？也没有`web.xml`文件。这个 Web 应用程序是 100% 纯 Java，您不必处理任何管道或基础设施的配置。

 ### 构建一个可执行的 JAR

@@ -180,7 +182,7 @@ java -jar target/gs-rest-service-0.1.0.jar

 此处描述的步骤创建了一个可运行的 JAR。您还可以[构建经典的 WAR 文件](https://spring.io/guides/gs/convert-jar-to-war/)。

-显示记录输出。该服务应在几秒钟内启动并运行。
+该服务会在几秒钟内启动并运行。

 ## 测试服务

@@ -190,18 +192,18 @@ java -jar target/gs-rest-service-0.1.0.jar
 {"id":1,"content":"Hello, World!"}
 ```

-通过访问提供`name`查询字符串参数`http://localhost:8080/greeting?name=User`。`content`请注意属性的值如何从`Hello, World!`变为`Hello, User!`，如以下清单所示：
+通过访问提供`name`查询字符串参数`http://localhost:8080/greeting?name=User`。`content`请注意属性的值如何从`Hello, World!`变为`Hello, User!`，如以下所示：

 ```
 {"id":2,"content":"Hello, User!"}
 ```

-这一变化表明，`@RequestParam`安排在`GreetingController`按预期工作。该`name`参数已被赋予默认值，`World`但可以通过查询字符串显式覆盖。
+这一变化表明，`@RequestParam`在`GreetingController`按预期工作。该`name`参数的默认值`World` 已被参数`name`的值覆盖

-还要注意`id`属性是如何从`1`变为 的`2`。这证明您正在`GreetingController`跨多个请求处理同一个实例，并且其`counter`字段在每次调用时都按预期递增。
+还要注意`id`属性是如何从`1`变为 的`2`。这证明是使用同一个`GreetingController`处理多个请求，并且其`counter`字段在每次调用时都按预期递增。

 ## 概括

 恭喜！您刚刚使用 Spring 开发了一个 RESTful Web 服务。

-原文链接: https://spring.io/guides/gs/rest-service/
\ No newline at end of file
+原文链接: https://spring.io/guides/gs/rest-service/
--- a/docs/spring-amqp/READEME.md
+++ b/docs/spring-amqp/READEME.md
--- a/docs/spring-amqp/README.md
+++ b/docs/spring-amqp/README.md
+# Spring AMQP
\ No newline at end of file
--- a/docs/spring-amqp/spring-amqp.md
+++ b/docs/spring-amqp/spring-amqp.md
@@ -6957,8 +6957,4 @@ Spring-AMQP 现在是用 Gradle 构建的。

 添加一个选项，以支持将消息 ID 添加到已记录的消息中。

-添加一个选项，允许在将`String`转换为`byte[]`时使用`Charset`名称的规范。
-
-版本 2.4.2 最后更新时间：2022 年 01 月 16 日 15:18:50UTC
-
-hljs.inithighlighting（）if{{{i[’GoogleAnalyticsObject’]=r；i[r]=i[r]||function（）{（i[r].q=i[r].q|[]）.push（参数）}，i[r].l=1\*new date（）；a=s.createelement（o），m.getelementsname（o）[0]；a.asymentsname=1；a.SRC=g.node=getname；google（a.com=node=gleanalytnode，’，’’docume’，’’’document’，’
\ No newline at end of file
+添加一个选项，允许在将`String`转换为`byte[]`时使用`Charset`名称的规范。
\ No newline at end of file
--- a/docs/spring-batch/READEME.md
+++ b/docs/spring-batch/READEME.md
--- a/docs/spring-batch/README.md
+++ b/docs/spring-batch/README.md
+# Spring Batch
\ No newline at end of file
--- a/docs/spring-batch/common-patterns.md
+++ b/docs/spring-batch/common-patterns.md
@@ -297,13 +297,13 @@ public void update(ExecutionContext executionContext) {

 在[关于读者和作家的章节](readersAndWriters.html)中，讨论了利用分页进行数据库输入的问题。许多数据库供应商（例如 DB2）都有非常悲观的锁定策略，如果正在读取的表也需要由在线应用程序的其他部分使用，这些策略可能会导致问题。此外，在非常大的数据集上打开游标可能会导致某些供应商的数据库出现问题。因此，许多项目更喜欢使用“驱动查询”方法来读取数据。这种方法的工作原理是对键进行迭代，而不是对需要返回的整个对象进行迭代，如下图所示：

-![驾驶查询工作](./images/drivingQueryExample.png)
+![驾驶查询工作](https://docs.spring.io/spring-batch/docs/current/reference/html/images/drivingQueryExample.png)

 图 1。驾驶查询工作

 正如你所看到的，前面图片中显示的示例使用了与基于游标的示例中使用的相同的“foo”表。但是，在 SQL 语句中只选择了 ID，而不是选择整行。因此，不是从`read`返回`FOO`对象，而是返回`Integer`对象。然后可以使用这个数字来查询“details”，这是一个完整的`Foo`对象，如下图所示：

-![驱动查询示例](./images/drivingQueryJob.png)
+![驱动查询示例](https://docs.spring.io/spring-batch/docs/current/reference/html/images/drivingQueryJob.png)

 图 2。驱动查询示例


--- a/docs/spring-batch/domain.md
+++ b/docs/spring-batch/domain.md
@@ -16,7 +16,7 @@ XMLJavaBoth

 下图是使用了几十年的批处理引用体系结构的简化版本。它提供了组成批处理领域语言的组件的概述。这个架构框架是一个蓝图，已经通过过去几代平台（COBOL/大型机、C/UNIX 和现在的 Java/Anywhere）上几十年的实现得到了证明。JCL 和 COBOL 开发人员可能与 C、C# 和 Java 开发人员一样熟悉这些概念。 Spring 批处理提供了通常在健壮的、可维护的系统中发现的层、组件和技术服务的物理实现，这些系统被用于解决创建简单到复杂的批处理应用程序，具有用于解决非常复杂的处理需求的基础设施和扩展。

-![图 2.1:批处理原型](./images/spring-batch-reference-model.png)
+![图 2.1:批处理原型](https://docs.spring.io/spring-batch/docs/current/reference/html/images/spring-batch-reference-model.png)

 图 1。批处理模式

@@ -26,7 +26,7 @@ XMLJavaBoth

 这一部分描述了与批处理作业的概念有关的刻板印象。`Job`是封装整个批处理过程的实体。与其他 Spring 项目一样，`Job`与 XML 配置文件或基于 Java 的配置连接在一起。这种配置可以称为“作业配置”。然而，`Job`只是整个层次结构的顶部，如下图所示：

-![工作层次结构](./images/job-heirarchy.png)
+![工作层次结构]https://docs.spring.io/spring-batch/docs/current/reference/html/images/job-heirarchy.png)

 图 2。工作层次结构

@@ -71,7 +71,7 @@ a`JobInstance`指的是逻辑作业运行的概念。考虑应该在一天结束

 在讨论了`JobInstance`以及它与约伯有何不同之后，我们自然要问的问题是：“一个`JobInstance`如何与另一个区分开来？”答案是：`JobParameters`。`JobParameters`对象持有一组用于启动批处理作业的参数。它们可以用于标识，甚至在运行过程中作为参考数据，如下图所示：

-![作业参数](./images/job-stereotypes-parameters.png)
+![作业参数](https://docs.spring.io/spring-batch/docs/current/reference/html/images/job-stereotypes-parameters.png)

 图 3。作业参数

@@ -140,7 +140,7 @@ a`JobExecution`指的是一次尝试运行作业的技术概念。一次执行

 `Step`是一个域对象，它封装了批处理作业的一个独立的、连续的阶段。因此，每一项工作都完全由一个或多个步骤组成。a`Step`包含定义和控制实际批处理所需的所有信息。这必然是一个模糊的描述，因为任何给定的`Step`的内容都是由编写`Job`的开发人员自行决定的。a`Step`可以是简单的，也可以是复杂的，正如开发人员所希望的那样。简单的`Step`可能会将文件中的数据加载到数据库中，只需要很少或不需要代码（取决于使用的实现）。更复杂的`Step`可能具有复杂的业务规则，这些规则作为处理的一部分被应用。与`Job`一样，`Step`具有与唯一的`StepExecution`相关的个体`StepExecution`，如下图所示：

-![图 2.1:带有步骤的工作层次结构](./images/jobHeirarchyWithSteps.png)
+![图 2.1:带有步骤的工作层次结构](https://docs.spring.io/spring-batch/docs/current/reference/html/images/jobHeirarchyWithSteps.png)

 图 4。带有步骤的工作层次结构


--- a/docs/spring-batch/job.md
+++ b/docs/spring-batch/job.md
@@ -6,7 +6,7 @@ XMLJavaBoth

 在[领域部分](domain.html#domainLanguageOfBatch)中，使用以下图表作为指导，讨论了总体架构设计：

-![图 2.1:批处理原型](./images/spring-batch-reference-model.png)
+![图 2.1:批处理原型](https://docs.spring.io/spring-batch/docs/current/reference/html/images/spring-batch-reference-model.png)

 图 1。批处理模式

@@ -545,13 +545,13 @@ protected JobLauncher createJobLauncher() throws Exception {

 一旦获得了[工作执行](domain.html#domainLanguageOfBatch)，它就被传递给`Job`的执行方法，最终将`JobExecution`返回给调用者，如下图所示：

-![作业启动器序列](./images/job-launcher-sequence-sync.png)
+![作业启动器序列](https://docs.spring.io/spring-batch/docs/current/reference/html/images/job-launcher-sequence-sync.png)

 图 2。作业启动器序列

 这个序列很简单，从调度程序启动时效果很好。然而，在尝试从 HTTP 请求启动时会出现问题。在这种情况下，启动需要异步完成，以便`SimpleJobLauncher`立即返回其调用方。这是因为，在长时间运行的进程（如批处理）所需的时间内保持 HTTP 请求的开放状态是不好的做法。下图显示了一个示例序列：

-![异步作业启动器序列](./images/job-launcher-sequence-async.png)
+![异步作业启动器序列](https://docs.spring.io/spring-batch/docs/current/reference/html/images/job-launcher-sequence-async.png)

 图 3。异步作业启动器序列

@@ -696,7 +696,7 @@ public interface ExitCodeMapper {

 从历史上看，离线处理（如批处理作业）是从命令行启动的，如上文所述。然而，在许多情况下，从`HttpRequest`发射是更好的选择。许多这样的用例包括报告、临时作业运行和 Web 应用程序支持。因为按定义，批处理作业是长时间运行的，所以最重要的问题是确保异步启动该作业：

-![基于 Web 容器的异步作业启动器序列](./images/launch-from-request.png)
+![基于 Web 容器的异步作业启动器序列](https://docs.spring.io/spring-batch/docs/current/reference/html/images/launch-from-request.png)

 图 4。来自 Web 容器的异步作业启动器序列

@@ -723,13 +723,13 @@ public class JobLauncherController {

 到目前为止，`JobLauncher`和`JobRepository`接口都已经讨论过了。它们一起表示作业的简单启动，以及批处理域对象的基本操作：

-![作业存储库](./images/job-repository.png)
+![作业存储库](https://docs.spring.io/spring-batch/docs/current/reference/html/images/job-repository.png)

 图 5。作业存储库

 a`JobLauncher`使用`JobRepository`来创建新的`JobExecution`对象并运行它们。`Job`和`Step`实现稍后将使用相同的`JobRepository`用于运行作业期间相同执行的基本更新。对于简单的场景，基本的操作就足够了，但是在具有数百个批处理任务和复杂的调度需求的大批处理环境中，需要对元数据进行更高级的访问：

-![作业存储库高级版](./images/job-repository-advanced.png)
+![作业存储库高级版](https://docs.spring.io/spring-batch/docs/current/reference/html/images/job-repository-advanced.png)

 图 6。高级作业存储库访问


--- a/docs/spring-batch/readersAndWriters.md
+++ b/docs/spring-batch/readersAndWriters.md
@@ -594,7 +594,7 @@ catch (IncorrectLineLengthException ex) {
 }
 ```

-上面的记号生成器的配置范围是：1-5、6-10 和 11-15。因此，这条线的总长度是 15。但是，在前面的示例中，传入了长度为 5 的行，从而引发了`IncorrectLineLengthException`。在此抛出一个异常，而不是仅映射第一列，这样可以使行的处理更早失败，并且所包含的信息比在试图在`FieldSetMapper`中读取第 2 列时失败时所包含的信息更多。然而，在某些情况下，直线的长度并不总是恒定的。因此，可以通过“严格”属性关闭对行长的验证，如下例所示：
+上面的记号生成器的配置范围是：1-5、6-10 和 11-1 5.因此，这条线的总长度是 1 5.但是，在前面的示例中，传入了长度为 5 的行，从而引发了`IncorrectLineLengthException`。在此抛出一个异常，而不是仅映射第一列，这样可以使行的处理更早失败，并且所包含的信息比在试图在`FieldSetMapper`中读取第 2 列时失败时所包含的信息更多。然而，在某些情况下，直线的长度并不总是恒定的。因此，可以通过“严格”属性关闭对行长的验证，如下例所示：

 ```
 tokenizer.setColumns(new Range[] { new Range(1, 5), new Range(6, 10) });
@@ -914,15 +914,15 @@ Spring Batch 提供了用于读取 XML 记录并将它们映射到 Java 对象

 我们需要考虑 XML 输入和输出如何在 Spring 批处理中工作。首先，有几个概念与文件读写不同，但在 Spring 批 XML 处理中很常见。使用 XML 处理，不是需要标记的记录行（`FieldSet`实例），而是假设 XML 资源是与单个记录相对应的“片段”的集合，如下图所示：

-![XML Input](./images/xmlinput.png)
+![XML Input](https://docs.spring.io/spring-batch/docs/current/reference/html/images/xmlinput.png)

-图 1。XML 输入
+图  1.XML 输入

 在上面的场景中，“trade”标记被定义为“root 元素”。“\<trade\>”和“\</trade\>”之间的所有内容都被视为一个“片段”。 Spring 批处理使用对象/XML 映射（OXM）将片段绑定到对象。然而， Spring 批处理并不绑定到任何特定的 XML 绑定技术。典型的用途是委托给[Spring OXM](https://docs.spring.io/spring/docs/current/spring-framework-reference/data-access.html#oxm)，这为最流行的 OXM 技术提供了统一的抽象。对 Spring OXM 的依赖是可选的，如果需要，可以选择实现 Spring 批处理特定接口。与 OXM 支持的技术之间的关系如下图所示：

-![OXM 绑定](./images/oxm-fragments.png)
+![OXM 绑定](https://docs.spring.io/spring-batch/docs/current/reference/html/images/oxm-fragments.png)

-图 2。OXM 绑定
+图  2.OXM 绑定

 通过介绍 OXM 以及如何使用 XML 片段来表示记录，我们现在可以更仔细地研究阅读器和编写器。

@@ -1314,9 +1314,9 @@ public MultiResourceItemReader multiResourceReader() {

 使用数据库游标通常是大多数批处理开发人员的默认方法，因为它是数据库解决关系数据“流”问题的方法。Java`ResultSet`类本质上是一种用于操作游标的面向对象机制。a`ResultSet`维护当前数据行的游标。在`ResultSet`上调用`next`将光标移动到下一行。 Spring 基于批处理游标的`ItemReader`实现在初始化时打开游标，并在每次调用`read`时将游标向前移动一行，返回可用于处理的映射对象。然后调用`close`方法，以确保释放所有资源。 Spring 核心`JdbcTemplate`通过使用回调模式来完全映射`ResultSet`中的所有行，并在将控制权返回给方法调用方之前关闭，从而绕过了这个问题。然而，在批处理中，这必须等到步骤完成。下图显示了基于游标的`ItemReader`如何工作的通用关系图。请注意，虽然示例使用 SQL（因为 SQL 是广为人知的），但任何技术都可以实现基本方法。

-![游标示例](./images/cursorExample.png)
+![游标示例](https://docs.spring.io/spring-batch/docs/current/reference/html/images/cursorExample.png)

-图 3。游标示例
+图  3.游标示例

 这个例子说明了基本模式。给定一个有三列的“foo”表：`ID`、`NAME`和`BAR`，选择 ID 大于 1 但小于 7 的所有行。这将把游标的开头（第 1 行）放在 ID2 上。该行的结果应该是一个完全映射的`Foo`对象。调用`read()`再次将光标移动到下一行，即 ID 为 3 的`Foo`。在每个`read`之后写出这些读取的结果，从而允许对对象进行垃圾收集（假设没有实例变量维护对它们的引用）。

@@ -1380,7 +1380,7 @@ while(customerCredit != null){
 itemReader.close();
 ```

-在运行前面的代码片段之后，计数器等于 1,000。如果上面的代码将返回的`customerCredit`放入一个列表中，结果将与`JdbcTemplate`示例完全相同。然而，`ItemReader`的一大优势在于，它允许项目被“流化”。`read`方法可以调用一次，该项可以由一个`ItemWriter`写出，然后可以用`read`获得下一个项。这使得项目的读写可以在“块”中完成，并定期提交，这是高性能批处理的本质。此外，很容易地将其配置为将`Step`注入到 Spring 批中。
+在运行前面的代码片段之后，计数器等于 1,00 0.如果上面的代码将返回的`customerCredit`放入一个列表中，结果将与`JdbcTemplate`示例完全相同。然而，`ItemReader`的一大优势在于，它允许项目被“流化”。`read`方法可以调用一次，该项可以由一个`ItemWriter`写出，然后可以用`read`获得下一个项。这使得项目的读写可以在“块”中完成，并定期提交，这是高性能批处理的本质。此外，很容易地将其配置为将`Step`注入到 Spring 批中。

 下面的示例展示了如何在 XML 中将`ItemReader`插入到`Step`中：

@@ -1774,15 +1774,15 @@ public JpaPagingItemReader itemReader() {

 虽然平面文件和 XML 文件都有一个特定的`ItemWriter`实例，但在数据库世界中没有完全相同的实例。这是因为事务提供了所需的所有功能。`ItemWriter`实现对于文件来说是必要的，因为它们必须像事务一样工作，跟踪写好的项目，并在适当的时候刷新或清除。数据库不需要此功能，因为写操作已经包含在事务中了。用户可以创建自己的 DAO 来实现`ItemWriter`接口，或者使用自定义的`ItemWriter`接口，这是为通用处理问题编写的。无论哪种方式，它们的工作都应该没有任何问题。需要注意的一点是批处理输出所提供的性能和错误处理能力。当使用 Hibernate 作为`ItemWriter`时，这是最常见的，但是当使用 JDBC 批处理模式时，可能会有相同的问题。批处理数据库输出没有任何固有的缺陷，前提是我们要小心刷新，并且数据中没有错误。然而，书写时的任何错误都可能导致混淆，因为无法知道是哪个单独的项目导致了异常，或者即使是任何单独的项目是负责任的，如下图所示：

-![刷新错误](./images/errorOnFlush.png)
+![刷新错误](https://docs.spring.io/spring-batch/docs/current/reference/html/images/errorOnFlush.png)

-图 4。刷新错误
+图  4.刷新错误

 如果项目在写入之前被缓冲，则在提交之前刷新缓冲区之前不会抛出任何错误。例如，假设每个块写 20 个项，第 15 个项抛出一个`DataIntegrityViolationException`。就`Step`而言，所有 20 个项都已成功写入，因为只有在实际写入它们之前，才能知道发生了错误。一旦调用`Session#flush()`，将清空缓冲区并命中异常。在这一点上，`Step`是无能为力的。事务必须回滚。通常，此异常可能会导致跳过该项（取决于跳过/重试策略），然后不会再次写入该项。但是，在批处理场景中，无法知道是哪个项导致了问题。当故障发生时，整个缓冲区正在被写入。解决此问题的唯一方法是在每个项目之后进行刷新，如下图所示：

-![写错误](./images/errorOnWrite.png)
+![写错误](https://docs.spring.io/spring-batch/docs/current/reference/html/images/errorOnWrite.png)

-图 5。写错误
+图  5.写错误

 这是一个常见的用例，尤其是在使用 Hibernate 时，而`ItemWriter`的实现的简单准则是在每次调用`write()`时刷新。这样做允许可靠地跳过项， Spring 批处理在内部处理错误后对`ItemWriter`的调用的粒度。


--- a/docs/spring-batch/scalability.md
+++ b/docs/spring-batch/scalability.md
@@ -167,7 +167,7 @@ public TaskExecutor taskExecutor() {

 在远程分块中，`Step`处理被分割到多个进程中，通过一些中间件相互通信。下图显示了该模式：

-![远程分块](./images/remote-chunking.png)
+![远程分块](https://docs.spring.io/spring-batch/docs/current/reference/html/images/remote-chunking.png)

 图 1。远程分块

@@ -183,7 +183,7 @@ Manager 是 Spring 批处理`Step`的实现，其中`ItemWriter`被一个通用

 Spring 批处理还提供了用于分区`Step`执行并远程执行它的 SPI。在这种情况下，远程参与者是`Step`实例，这些实例可以很容易地被配置并用于本地处理。下图显示了该模式：

-![分区概述](./images/partitioning-overview.png)
+![分区概述](https://docs.spring.io/spring-batch/docs/current/reference/html/images/partitioning-overview.png)

 图 2。划分

@@ -191,7 +191,7 @@ Spring 批处理还提供了用于分区`Step`执行并远程执行它的 SPI。

 Spring 批处理中的 SPI 由`Step`（称为`PartitionStep`）的特殊实现和需要为特定环境实现的两个策略接口组成。策略接口是`PartitionHandler`和`StepExecutionSplitter`，它们的作用在下面的序列图中显示：

-![分区 SPI](./images/partitioning-spi.png)
+![分区 SPI](https://docs.spring.io/spring-batch/docs/current/reference/html/images/partitioning-spi.png)

 图 3。分区 SPI


--- a/docs/spring-batch/schema-appendix.md
+++ b/docs/spring-batch/schema-appendix.md
@@ -6,7 +6,7 @@

 Spring 批处理元数据表与在 Java 中表示它们的域对象非常匹配。例如，`JobInstance`，`JobExecution`，`JobParameters`，和`StepExecution`分别映射到`BATCH_JOB_INSTANCE`，`BATCH_JOB_EXECUTION`，`BATCH_JOB_EXECUTION_PARAMS`和`BATCH_STEP_EXECUTION`。`ExecutionContext`映射到`BATCH_JOB_EXECUTION_CONTEXT`和`BATCH_STEP_EXECUTION_CONTEXT`。`JobRepository`负责将每个 Java 对象保存并存储到其正确的表中。本附录详细描述了元数据表，以及在创建元数据表时做出的许多设计决策。在查看下面的各种表创建语句时，重要的是要认识到所使用的数据类型是尽可能通用的。 Spring Batch 提供了许多模式作为示例，所有这些模式都具有不同的数据类型，这是由于各个数据库供应商处理数据类型的方式有所不同。下图显示了所有 6 个表及其相互关系的 ERD 模型：

-![Spring Batch Meta-Data ERD](./images/meta-data-erd.png)
+![Spring Batch Meta-Data ERD](https://docs.spring.io/spring-batch/docs/current/reference/html/images/meta-data-erd.png)

 图 1。 Spring 批处理元数据 ERD


--- a/docs/spring-batch/spring-batch-integration.md
+++ b/docs/spring-batch/spring-batch-integration.md
@@ -82,7 +82,7 @@ Spring 批处理集成提供了`JobLaunchingMessageHandler`类，你可以使用

 下面的图像演示了典型的 Spring 集成消息流，以便启动批处理作业。[Enterprise 集成模式网站](https://www.enterpriseintegrationpatterns.com/toc.html)提供了消息传递图标及其描述的完整概述。

-![启动批处理作业](./images/launch-batch-job.png)
+![启动批处理作业](https://docs.spring.io/spring-batch/docs/current/reference/html/images/launch-batch-job.png)

 图 1。启动批处理作业

@@ -304,7 +304,7 @@ Spring 由于批处理作业可以运行很长时间，因此提供进度信息

 在下图所示的示例中， Spring 批处理作业已配置为`StepExecutionListener`。因此， Spring 集成接收并处理事件之前或之后的任何步骤。例如，接收到的`StepExecution`可以通过使用`Router`进行检查。基于该检查的结果，可以发生各种事情（例如将消息路由到邮件出站通道适配器），以便可以基于某些条件发送出电子邮件通知。

-![处理信息消息](./images/handling-informational-messages.png)
+![处理信息消息](https://docs.spring.io/spring-batch/docs/current/reference/html/images/handling-informational-messages.png)

 图 2。处理信息消息

@@ -457,7 +457,7 @@ public AsyncItemWriter writer(ItemWriter itemWriter) {

 ##### 远程分块

-![远程分块](./images/remote-chunking-sbi.png)
+![远程分块](https://docs.spring.io/spring-batch/docs/current/reference/html/images/remote-chunking-sbi.png)

 图 3。远程分块

@@ -708,7 +708,7 @@ public ChunkProcessorChunkHandler<Integer> chunkProcessorChunkHandler() {

 这些 API 负责配置一些组件，如下图所示：

-![远程组块配置](./images/remote-chunking-config.png)
+![远程组块配置](https://docs.spring.io/spring-batch/docs/current/reference/html/images/remote-chunking-config.png)

 图 4。远程组块配置

@@ -786,7 +786,7 @@ public class RemoteChunkingJobConfiguration {

 ##### 远程分区

-![远程分区](./images/remote-partitioning.png)
+![远程分区](https://docs.spring.io/spring-batch/docs/current/reference/html/images/remote-partitioning.png)

 图 5。远程分区

@@ -1005,11 +1005,11 @@ Java 配置

 这些 API 负责配置一些组件，如下图所示：

-![远程分区配置（使用作业存储库轮询）](./images/remote-partitioning-polling-config.png)
+![远程分区配置（使用作业存储库轮询）](https://docs.spring.io/spring-batch/docs/current/reference/html/images/remote-partitioning-polling-config.png)

 图 6。远程分区配置（使用作业存储库轮询）

-![远程分区配置（带有回复聚合）](./images/remote-partitioning-aggregation-config.png)
+![远程分区配置（带有回复聚合）](https://docs.spring.io/spring-batch/docs/current/reference/html/images/remote-partitioning-aggregation-config.png)

 图 7。远程分区配置（带有回复聚合）


--- a/docs/spring-batch/spring-batch-intro.md
+++ b/docs/spring-batch/spring-batch-intro.md
@@ -74,9 +74,9 @@ Spring 批处理自动化了这种基本的批处理迭代，提供了将类似

 Spring Batch 的设计考虑到了可扩展性和多样化的最终用户群体。下图显示了支持最终用户开发人员的可扩展性和易用性的分层架构。

-![Figure 1.1: Spring Batch Layered Architecture](./images/spring-batch-layers.png)
+![Figure 1.1: Spring Batch Layered Architecture](https://docs.spring.io/spring-batch/docs/current/reference/html/images/spring-batch-layers.png)

-图 1。 Spring 批处理分层架构
+图  1. Spring 批处理分层架构

 这个分层架构突出了三个主要的高级组件：应用程序、核心和基础架构。该应用程序包含由开发人员使用 Spring 批处理编写的所有批处理作业和自定义代码。批处理核心包含启动和控制批处理作业所必需的核心运行时类。它包括`JobLauncher`、`Job`和`Step`的实现。应用程序和核心都是建立在一个共同的基础架构之上的。这个基础结构包含常见的读取器、编写器和服务（例如`RetryTemplate`），应用程序开发人员（读取器和编写器，例如`ItemReader`和`ItemWriter`）和核心框架本身（Retry，这是它自己的库）都使用它们。

@@ -194,9 +194,9 @@ Spring Batch 的设计考虑到了可扩展性和多样化的最终用户群体

 此外，被分区的进程必须被设计为仅处理其分配的数据集。分区体系结构必须与数据库设计和数据库分区策略紧密联系在一起。请注意，数据库分区并不一定意味着数据库的物理分区，尽管在大多数情况下这是可取的。下图展示了分区方法：

-![图 1.2:分区过程](./images/partitioned.png)
+![图 1.2:分区过程](https://docs.spring.io/spring-batch/docs/current/reference/html/images/partitioned.png)

-图 2。分区过程
+图 2.分区过程

 体系结构应该足够灵活，以允许分区数量的动态配置。应同时考虑自动配置和用户控制配置。自动配置可以基于参数，例如输入文件的大小和输入记录的数量。


--- a/docs/spring-batch/step.md
+++ b/docs/spring-batch/step.md
@@ -6,17 +6,17 @@ XMLJavaBoth

 正如[领域章节](domain.html#domainLanguageOfBatch)中所讨论的，`Step`是一个域对象，它封装了批处理作业的一个独立的、连续的阶段，并包含定义和控制实际批处理所需的所有信息。这必然是一个模糊的描述，因为任何给定的`Step`的内容都是由编写`Job`的开发人员自行决定的。a`Step`可以是简单的，也可以是复杂的，正如开发人员所希望的那样。一个简单的`Step`可能会将文件中的数据加载到数据库中，只需要很少或不需要代码（取决于使用的实现）。更复杂的`Step`可能具有复杂的业务规则，作为处理的一部分，如下图所示：

-![Step](./images/step.png)
+![Step](https://docs.spring.io/spring-batch/docs/current/reference/html/images/step.png)

-图 1。步骤
+图 1.步骤

 ### 面向块的处理

 Spring 批处理在其最常见的实现中使用了一种“面向块”的处理风格。面向块的处理指的是一次读取一个数据，并创建在事务边界内写出的“块”。一旦读取的项数等于提交间隔，`ItemWriter`就会写出整个块，然后提交事务。下图显示了这个过程：

-![面向块的处理](./images/chunk-oriented-processing.png)
+![面向块的处理](https://docs.spring.io/spring-batch/docs/current/reference/html/images/chunk-oriented-processing.png)

-图 2。面向块的处理
+图 2.面向块的处理

 下面的伪代码以简化的形式显示了相同的概念：

@@ -33,9 +33,9 @@ itemWriter.write(items);

 面向块的步骤还可以配置一个可选的`ItemProcessor`来处理项，然后将它们传递给`ItemWriter`。下图显示了在步骤中注册`ItemProcessor`时的过程：

-![基于项目处理器的面向块处理](./images/chunk-oriented-processing-with-item-processor.png)
+![基于项目处理器的面向块处理](https://docs.spring.io/spring-batch/docs/current/reference/html/images/chunk-oriented-processing-with-item-processor.png)

-图 3。基于项目处理器的面向块处理
+图 3.基于项目处理器的面向块处理

 下面的伪代码展示了如何以简化的形式实现这一点：

@@ -387,7 +387,7 @@ public Step playerSummarization() {
 }
 ```

-前面的示例配置用于加载有关足球比赛的信息并对其进行总结的作业。它包含三个步骤：`playerLoad`、`gameLoad`和`playerSummarization`。`playerLoad`步骤从平面文件加载玩家信息，而`gameLoad`步骤对游戏也是如此。最后一步，`playerSummarization`，然后根据提供的游戏总结每个玩家的统计数据。假设`playerLoad`加载的文件必须只加载一次，但是`gameLoad`可以加载特定目录中的任何游戏，并在它们成功加载到数据库后将其删除。因此，`playerLoad`步骤不包含额外的配置。它可以启动任意次数，如果完成，则跳过。但是，每次都需要运行`gameLoad`步骤，以防自上次运行以来添加了额外的文件。它有“允许-启动-如果-完成”设置为“真”，以便始终被启动。（假设游戏加载到的数据库表上有一个进程指示器，以确保新的游戏可以通过摘要步骤正确地找到）。摘要步骤是作业中最重要的一步，它的起始限制为 2。这是有用的，因为如果该步骤持续失败，新的退出代码将返回给控制作业执行的操作符，并且在手动干预发生之前，它不能再次启动。
+前面的示例配置用于加载有关足球比赛的信息并对其进行总结的作业。它包含三个步骤：`playerLoad`、`gameLoad`和`playerSummarization`。`playerLoad`步骤从平面文件加载玩家信息，而`gameLoad`步骤对游戏也是如此。最后一步，`playerSummarization`，然后根据提供的游戏总结每个玩家的统计数据。假设`playerLoad`加载的文件必须只加载一次，但是`gameLoad`可以加载特定目录中的任何游戏，并在它们成功加载到数据库后将其删除。因此，`playerLoad`步骤不包含额外的配置。它可以启动任意次数，如果完成，则跳过。但是，每次都需要运行`gameLoad`步骤，以防自上次运行以来添加了额外的文件。它有“允许-启动-如果-完成”设置为“真”，以便始终被启动。（假设游戏加载到的数据库表上有一个进程指示器，以确保新的游戏可以通过摘要步骤正确地找到）。摘要步骤是作业中最重要的一步，它的起始限制为 2.这是有用的，因为如果该步骤持续失败，新的退出代码将返回给控制作业执行的操作符，并且在手动干预发生之前，它不能再次启动。

 |   |此作业为该文档提供了一个示例，它与示例项目中的`footballJob`不同。|
 |---|--------------------------------------------------------------------------------------------------------------------|
@@ -416,7 +416,7 @@ public Step playerSummarization() {

 2. `gameLoad`再次运行并处理另外 2 个文件，并将其内容加载到“Games”表中（进程指示器指示它们尚未被处理）。

-3. 由于这是`playerSummarization`的第三次执行，因此`playerSummarization`未启动并立即终止作业，并且其限制仅为 2。要么必须提高限制，要么必须执行`Job`作为新的`JobInstance`。
+3. 由于这是`playerSummarization`的第三次执行，因此`playerSummarization`未启动并立即终止作业，并且其限制仅为 2.要么必须提高限制，要么必须执行`Job`作为新的`JobInstance`。

 #### 配置跳过逻辑

@@ -457,7 +457,7 @@ public Step step1() {
 }
 ```

-在前面的示例中，使用了`FlatFileItemReader`。如果在任何时候抛出一个`FlatFileParseException`，则跳过该项并将其计入总跳过限制 10。声明的异常（及其子类）可能会在块处理的任何阶段（读、进程、写）抛出，但是在步骤执行中，读、进程和写的跳过是单独的计数，但是该限制适用于所有跳过。一旦达到跳过限制，发现的下一个异常将导致该步骤失败。换句话说，第 11 跳会触发异常，而不是第 10 跳会触发异常。
+在前面的示例中，使用了`FlatFileItemReader`。如果在任何时候抛出一个`FlatFileParseException`，则跳过该项并将其计入总跳过限制 10.声明的异常（及其子类）可能会在块处理的任何阶段（读、进程、写）抛出，但是在步骤执行中，读、进程和写的跳过是单独的计数，但是该限制适用于所有跳过。一旦达到跳过限制，发现的下一个异常将导致该步骤失败。换句话说，第 11 跳会触发异常，而不是第 10 跳会触发异常。

 上述示例的一个问题是，除了`FlatFileParseException`之外的任何其他异常都会导致`Job`失败。在某些情况下，这可能是正确的行为。然而，在其他情况下，可能更容易确定哪些异常应该导致失败，并跳过其他所有情况。

@@ -1071,9 +1071,9 @@ public FileDeletingTasklet fileDeletingTasklet() {

 最简单的流程场景是所有步骤都按顺序执行的作业，如下图所示：

-![顺序流动](./images/sequential-flow.png)
+![顺序流动](https://docs.spring.io/spring-batch/docs/current/reference/html/images/sequential-flow.png)

-图 4。顺序流动
+图 4.顺序流动

 这可以通过使用`step`中的“next”来实现。

@@ -1119,9 +1119,9 @@ public Job job() {

 在许多情况下，这可能就足够了。但是，如果`step`的失败应该触发不同的`step`，而不是导致失败，那么在这种情况下该怎么办？下图显示了这样的流程：

-![条件流](./images/conditional-flow.png)
+![条件流](https://docs.spring.io/spring-batch/docs/current/reference/html/images/conditional-flow.png)

-图 5。条件流
+图 5.条件流

 为了处理更复杂的场景， Spring 批 XML 命名空间允许在 Step 元素中定义转换元素。一个这样的转换是`next`元素。与`next`属性类似，`next`元素告诉`Job`下一个执行的是`Step`。然而，与属性不同的是，在给定的`Step`上允许任意数量的`next`元素，并且在失败的情况下没有默认行为。这意味着，如果使用了转换元素，则必须显式地定义`Step`转换的所有行为。还请注意，单个步骤不能同时具有`next`属性和`transition`元素。


--- a/docs/spring-boot/README.md
+++ b/docs/spring-boot/README.md
-# Spring 引导
\ No newline at end of file
+# Spring Boot
--- a/docs/spring-boot/actuator.md
+++ b/docs/spring-boot/actuator.md
--- a/docs/spring-boot/build-tool-plugins.md
+++ b/docs/spring-boot/build-tool-plugins.md
 # 构建工具插件

-Spring Boot 为 Maven 和 Gradle 提供了构建工具插件。这些插件提供了各种特性，包括可执行 JAR 的打包。本节提供了有关这两个插件的更多详细信息，以及在需要扩展不受支持的构建系统时提供的一些帮助。如果你刚刚开始，你可能需要先阅读“[using.html](using.html#using.build-systems)”一节中的“[using.html](using.html#using)”。
+Spring Boot 为 Maven 和 Gradle 提供了构建工具插件。这些插件提供了各种特性，包括可执行 JAR 的打包。本节提供了有关这两个插件的更多详细信息，以及在需要扩展不受支持的构建系统时提供的一些帮助。如果你刚刚开始，那么你可能需要先阅读“[using.html](using.html#using.build-systems)”一节中的“[using.html](using.html#using)”。

 ## 1.1 Spring 引导 Maven 插件

@@ -38,7 +38,7 @@ Spring 启动 Antlib 模块为 Apache Ant 提供了基本的 Spring 启动支持
 $ 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)的更完整示例。
+> “使用 Spring 引导”部分包括一个更完整的[使用`spring-boot-antlib`的 Apache Ant 示例]（使用.html#using.build-systems. Ant）。

 ### 3.1. Spring 引导 Ant 任务

@@ -50,13 +50,13 @@ $ ant -lib <directory containing spring-boot-antlib-2.6.4.jar>

 #### 3.1.1.使用“exejar”任务

-你可以使用`exejar`任务来创建 Spring 引导可执行文件 jar。该任务支持以下属性：
+你可以使用`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)*|
+|`start-class`|  The main application class to run   |否 *（默认值是发现的第一个类，它声明了`main`方法）*|

 以下嵌套元素可与任务一起使用：

@@ -67,7 +67,7 @@ $ ant -lib <directory containing spring-boot-antlib-2.6.4.jar>

 #### 3.1.2.例子

-本节展示了 Ant 任务的两个示例。
+本节展示了 Ant 项任务的两个示例。

 指定起始类

@@ -101,7 +101,7 @@ $ ant -lib <directory containing spring-boot-antlib-2.6.4.jar>
 |-------------|----------------------------------------------------|-------------------------------------------|
 |`classesroot`|Java 类文件的根目录|  Yes *(unless `mainclass` is specified)*  |
 | `mainclass` |可用于短路`main`类搜索|                    No                     |
-| `property`  |应与结果一起设置的 Ant 属性|No *(result will be logged if unspecified)*|
+| `property`  |Ant 应与结果一起设置的属性|No *(result will be logged if unspecified)*|

 #### 3.2.1.例子

@@ -127,7 +127,7 @@ $ ant -lib <directory containing spring-boot-antlib-2.6.4.jar>

 ## 4. 支持其他构建系统

-如果你想使用 Maven、 Gradle 或 Ant 以外的构建工具，那么你可能需要开发自己的插件。可执行 JAR 需要遵循特定的格式，并且某些条目需要以未压缩的形式编写（有关详细信息，请参见附录中的“[executable jar format](executable-jar.html#appendix.executable-jar)”部分）。
+如果你希望使用 Maven、 Gradle 或 Ant 以外的构建工具，那么你可能需要开发自己的插件。可执行 JAR 需要遵循特定的格式，并且某些条目需要以未压缩的形式编写（有关详细信息，请参见附录中的“[executable jar format](executable-jar.html#appendix.executable-jar)”部分）。

 Spring boot Maven 和 Gradle 插件都使用`spring-boot-loader-tools`来实际生成 JAR。如果需要，可以直接使用这个库。

@@ -143,7 +143,7 @@ Spring boot Maven 和 Gradle 插件都使用`spring-boot-loader-tools`来实际

 ### 4.3.寻找主类

-如果你不使用`Repackager.setMainClass()`来指定主类，则 Repackager 将使用[ASM](https://asm.ow2.io/)来读取类文件，并尝试使用`public static void main(String[] args)`方法找到合适的类。如果发现一个以上的候选者，将抛出一个异常。
+如果你没有使用`Repackager.setMainClass()`来指定主类，那么 Repackager 将使用[ASM](https://asm.ow2.io/)来读取类文件，并尝试使用`public static void main(String[] args)`方法找到合适的类。如果发现一个以上的候选者，将抛出一个异常。

 ### 4.4.示例重新打包实现

@@ -184,9 +184,9 @@ public class MyBuildTool {

 ```

-## 5. 接下来读什么？
+## 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)中进行了介绍。
+如果你对构建工具插件的工作方式感兴趣，可以查看 Github 上的[`spring-boot-tools`]（https://github.com/ Spring-projects/ Spring-boot/tree/v2.6.4/ Spring-boot-project/ Spring-boot-tools）模块。可执行 jar 格式的更多技术细节在[附录](executable-jar.html#appendix.executable-jar)中进行了介绍。

 如果你有特定的与构建相关的问题，请参阅“[how-to](howto.html#howto)”指南。

--- a/docs/spring-boot/cli.md
+++ b/docs/spring-boot/cli.md
 # Spring 引导 CLI

-Spring 引导 CLI 是一个命令行工具，如果你想快速开发 Spring 应用程序，可以使用它。它允许你运行 Groovy 脚本，这意味着你有一个熟悉的类似 Java 的语法，而不需要那么多样板代码。你还可以引导一个新项目，或者为它编写自己的命令。
+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)*。
+可以使用 SDKMAN 手动安装 Spring boot cli（命令行界面）！（SDK 管理器），或者如果你是 OSX 用户，则使用 Homebrew 或 MacPorts。有关全面的安装说明，请参见“入门”部分中的 *[getting-started.html](getting-started.html#getting-started.installing.cli)*。

 ## 2. 使用 CLI

@@ -23,7 +23,7 @@ Available commands are:
  _... more command help is shown here_
 ```

-你可以键入`spring help`来获得有关任何支持的命令的更多详细信息，如以下示例所示：
+你可以键入`spring help`来获取有关任何支持的命令的更多详细信息，如以下示例所示：

 ```
 $ spring help run
@@ -115,7 +115,7 @@ Spring Boot 进一步扩展了这种技术，并试图根据你的代码推断
 |`@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)的子类，以确切了解如何应用自定义。|
+|   |参见[`CompilerAutoConfiguration`]（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/compiler/compilerautorfigation.java）的子类，在 Spring bootcli 源代码中了解定制是如何应用的。|
 |---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

 #### 2.1.2.推导出的“抓取”坐标
@@ -138,7 +138,7 @@ Spring Boot 扩展了 Groovy 的标准`@Grab`支持，允许你指定一个没

 #### 2.1.5.自定义依赖管理

-默认情况下，CLI 在解析`@Grab`依赖关系时使用在`spring-boot-dependencies`中声明的依赖关系管理。可以通过使用`@DependencyManagementBom`注释来配置额外的依赖管理，该管理覆盖了默认的依赖管理。注释的值应该指定一个或多个 Maven boms 的坐标（“groupid:artifactid:version”）。
+默认情况下，CLI 在解析`@Grab`依赖关系时使用在`spring-boot-dependencies`中声明的依赖关系管理。可以通过使用`@DependencyManagementBom`注释来配置附加的依赖项管理，该管理覆盖了默认的依赖项管理。注释的值应该指定一个或多个 Maven boms 的坐标（`groupId:artifactId:version`）。

 例如，考虑以下声明：

@@ -178,7 +178,7 @@ $ spring run *.groovy
 $ spring jar my-app.jar *.groovy
 ```

-jar 结果包含通过编译应用程序产生的类和应用程序的所有依赖项，这样就可以使用`java -jar`运行它。 jar 文件还包含来自应用程序 Classpath 的条目。可以通过使用`--include`和`--exclude`来添加和删除 jar 的显式路径。两者都是用逗号分隔的，并且都接受前缀，以“+”和“-”的形式表示它们应该从默认值中删除。默认值包括以下内容：
+jar 结果包含通过编译应用程序产生的类和应用程序的所有依赖项，这样就可以使用`java -jar`运行它。 jar 文件还包含来自应用程序 Classpath 的条目。可以使用`--include`和`--exclude`来添加和删除 jar 的显式路径。两者都是用逗号分隔的，并且都接受前缀，以“+”和“-”的形式表示它们应该从默认值中删除。默认值包括以下内容：

 ```
 public/**, resources/**, static/**, templates/**, META-INF/**, *
@@ -281,7 +281,7 @@ $ spring uninstall --all

 ## 3. 使用 Groovy Beans DSL 开发应用程序

-Spring Framework4.0 对`beans{}`“DSL”（借用自[Grails](https://grails.org/)）具有原生支持，并且你可以通过使用相同的格式在 Groovy 应用程序脚本中嵌入 Bean 定义。这有时是一种很好的方式，可以包含外部特性，比如中间件声明，如下例所示：
+Spring Framework4.0 对`beans{}`“DSL”（借鉴自[Grails](https://grails.org/)）具有原生支持，并且你可以通过使用相同的格式在 Groovy 应用程序脚本中嵌入 Bean 定义。这有时是一种很好的方式，可以包含外部特性，比如中间件声明，如下例所示：

 ```
 @Configuration(proxyBeanMethods = false)
@@ -331,8 +331,8 @@ Spring 引导 CLI 使用 Maven resolver（ Maven 的依赖项解析引擎）来

 有关更多信息，请参见[Maven’s settings documentation](https://maven.apache.org/settings.html)。

-## 5. 接下来读什么？
+## 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。
+GitHub 存储库中有一些[Groovy 脚本示例](https://github.com/spring-projects/spring-boot/tree/v2.6.4/spring-boot-project/spring-boot-cli/samples)可用，你可以使用它们来尝试 Spring 引导 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)中也有大量的 Javadoc。

 如果你发现你已经达到了 CLI 工具的极限，那么你可能希望将你的应用程序转换为完整的 Gradle 或 Maven 构建的“Groovy 项目”。下一节将介绍 Spring boot 的“[构建工具插件](build-tool-plugins.html#build-tool-plugins)”，你可以在 Gradle 或 Maven 中使用它。
--- a/docs/spring-boot/container-images.md
+++ b/docs/spring-boot/container-images.md
 # 容器图像

-Spring 引导应用程序可以是容器化的[使用 DockerFiles](#container-images.dockerfiles)，也可以是容器化的[使用本地云构建包创建优化的 Docker 兼容容器映像，可以在任何地方运行](#container-images.buildpacks)。
+Spring 引导应用程序可以是容器化的[使用 DockerFiles](#container-images.dockerfiles)，也可以是容器化的[使用本地云构建包创建可在任何地方运行的优化的 Docker 兼容容器映像](#container-images.buildpacks)。

 ## 1. 高效的容器图像


-将 Spring 引导 fat jar 打包为 Docker 映像是很容易的。然而，复制和运行 Docker 映像中的 fat jar 有各种缺点。在不拆包的情况下运行 A fat jar 时，总会有一定的开销，在集装箱化的环境中，这一点是显而易见的。另一个问题是，将应用程序的代码及其所有依赖项放在 Docker 映像中的一个层中是次优的。由于你重新编译代码的次数可能比升级所使用的启动版本更多，所以更好的做法通常是多分离一些东西。如果将 jar 个文件放在应用程序类之前的层中，Docker 通常只需要更改最底层的文件，就可以从其缓存中获取其他文件。
+将 Spring 引导 fat jar 打包为 Docker 映像是很容易的。然而，复制和运行 Docker 映像中的 fat jar 有各种缺点。在不拆包的情况下运行 A fat jar 时，总会有一定的开销，在集装箱化的环境中，这一点可能是显而易见的。另一个问题是，将应用程序的代码及其所有依赖项放在 Docker 映像中的一个层中是次优的。由于你重新编译代码的次数可能比升级所使用的启动版本更多，所以更好的做法通常是多分离一些代码。如果将 jar 个文件放在应用程序类之前的层中，Docker 通常只需要更改最底层的文件，就可以从其缓存中获取其他文件。

 ### 1.1.打开 fat jar

@@ -56,9 +56,9 @@ $ java -cp BOOT-INF/classes:BOOT-INF/lib/* com.example.MyApplication
  - BOOT-INF/classes/a/b/C.class
 ```

-这种分层设计是为了根据在应用程序构建之间更改代码的可能性来分离代码。库代码在两次构建之间更改的可能性较小，因此将其放置在自己的层中，以允许工具重新使用缓存中的层。应用程序代码更有可能在构建之间进行更改，因此它被隔离在一个单独的层中。
+这种分层设计是为了根据在应用程序构建之间更改代码的可能性来分离代码。库代码不太可能在构建之间发生变化，因此将其放置在自己的层中，以允许工具重新使用缓存中的层。应用程序代码更有可能在不同的构建之间进行更改，因此它被隔离在一个单独的层中。

-Spring 在`layers.idx`的帮助下，引导还支持对 WAR 文件进行分层。
+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)。

@@ -119,7 +119,7 @@ $ docker build --build-arg JAR_FILE=path/to/myapp.jar .

 DockerFiles 只是构建 Docker 映像的一种方式。另一种构建 Docker 映像的方法是直接从 Maven 或 Gradle 插件中使用 buildpacks。如果你曾经使用过 Cloud Foundry 或 Heroku 之类的应用程序平台，那么你很可能使用过 BuildPack。构建包是平台的一部分，它接收应用程序并将其转换为平台可以实际运行的内容。例如，Cloud Foundry 的 Java BuildPack 会注意到，你正在推送一个`.jar`文件，并自动添加一个相关的 JRE。

-使用 Cloud Native 构建包，你可以创建可以在任何地方运行的与 Docker 兼容的映像。 Spring 引导包括直接针对 Maven 和 Gradle 的 BuildPack 支持。这意味着你只需键入一个命令，就可以快速地在本地运行的 Docker 守护程序中获得一个合理的映像。
+使用 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)构建包的单个插件文档。

@@ -129,7 +129,7 @@ DockerFiles 只是构建 Docker 映像的一种方式。另一种构建 Docker 
 |   |为了实现可重复的构建和容器映像缓存，构建包可以操作应用程序资源元数据（例如文件“上次修改”信息）。<br/>你应该确保你的应用程序在运行时不依赖于该元数据。<br/> Spring 引导在服务静态资源时可以使用该信息，但这可以用`spring.web.resources.cache.use-last-modified`禁用|
 |---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

-## 4. 接下来读什么？
+## 4. 接下来要读什么？

 一旦你了解了如何构建高效的容器映像，你就可以了解[将应用程序部署到云平台](deployment.html#deployment.cloud.kubernetes)，比如 Kubernetes。

--- a/docs/spring-boot/data.md
+++ b/docs/spring-boot/data.md
--- a/docs/spring-boot/deployment.md
+++ b/docs/spring-boot/deployment.md
--- a/docs/spring-boot/documentation.md
+++ b/docs/spring-boot/documentation.md
@@ -8,7 +8,7 @@

 如果你开始使用 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)
+* **从零开始：** [Overview](getting-started.html#getting-started.introducing-spring-boot) | [所需经费](getting-started.html#getting-started.system-requirements) | [安装](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)

@@ -32,13 +32,13 @@

 * **构建系统：** [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)
+* **最佳实践：** [代码结构](using.html#using.structuring-your-code) | [@ 配置](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)
+* **打包应用程序：** [生产罐子](using.html#using.packaging-for-production)

-* **Spring Boot CLI:** [Using the CLI](cli.html#cli)
+* **Spring Boot CLI:** [使用 CLI](cli.html#cli)

 ## 4. 学习 Spring 引导功能

@@ -98,7 +98,7 @@

 * **石英：** [石英调度](io.html#io.quartz)

-* **邮件：** [Sending Email](io.html#io.email)
+* **邮件：** [发送电子邮件](io.html#io.email)

 * **验证：** [JSR-303 验证](io.html#io.validation)

@@ -126,5 +126,5 @@ Spring Boot 为构建高效的容器映像提供了一流的支持。你可以

 * **构建工具插件：** [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)
+* **附录：** [应用程序属性](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) | [可执行 JAR](executable-jar.html#appendix.executable-jar) | [依赖版本](dependency-versions.html#appendix.dependency-versions)

--- a/docs/spring-boot/features.md
+++ b/docs/spring-boot/features.md
--- a/docs/spring-boot/getting-help.md
+++ b/docs/spring-boot/getting-help.md
@@ -6,10 +6,10 @@

 * 学习基础知识。 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)标记的问题。
+* 问一个问题。我们监视[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 存在问题或希望改进它们，请[参与进来](https://github.com/spring-projects/spring-boot/tree/v2.6.4)。
\ No newline at end of file
--- a/docs/spring-boot/getting-started.md
+++ b/docs/spring-boot/getting-started.md
@@ -14,7 +14,7 @@ Spring 引导帮助你创建可以运行的独立的、基于生产级别 Spring

 * 在需求开始偏离默认值时，不要拘泥于常规，但要尽快摆脱。

-* 提供一系列非功能特性，这些特性是大型项目（如嵌入式服务器、安全性、度量、健康检查和外部化配置）所共有的。
+* 提供一系列非功能特性，这些特性是大型项目类所共有的（例如嵌入式服务器、安全性、度量、健康检查和外部化配置）。

 * 绝对不需要代码生成，也不需要 XML 配置。

@@ -97,11 +97,11 @@ Spring 引导 CLI（命令行界面）是一种命令行工具，你可以使用

 尖端[快照分布](https://repo.spring.io/snapshot/org/springframework/boot/spring-boot-cli/)也是可用的。

-一旦下载，请按照解压缩归档文件中的[INSTALL.txt](https://raw.githubusercontent.com/spring-projects/spring-boot/v2.6.4/spring-boot-project/spring-boot-cli/src/main/content/INSTALL.txt)说明进行操作。总之，在`.zip`文件中的`bin/`目录中有一个`spring`脚本（用于 Windows 的 ` Spring.bat`）。或者，你可以在`java -jar`文件中使用`.jar`（该脚本可以帮助你确保 Classpath 设置正确）。
+一旦下载，请按照解压缩归档文件中的[安装.TXT](https://raw.githubusercontent.com/spring-projects/spring-boot/v2.6.4/spring-boot-project/spring-boot-cli/src/main/content/INSTALL.txt)说明进行操作。总之，在`.zip`文件中的`bin/`目录中有一个`spring`脚本（`spring.bat`用于 Windows）。或者，你可以在`.jar`文件中使用`java -jar`（该脚本可以帮助你确保 Classpath 设置正确）。

 #### 3.2.2.用 SDKMAN 安装！

-SDKMAN!（软件开发工具包管理器）可以用于管理各种二进制 SDK 的多个版本，包括 Groovy 和 Spring 引导 CLI。得到 SDKMAN！从[sdkman.io](https://sdkman.io)开始，使用以下命令安装 Spring boot:
+SDKMAN!（软件开发工具包管理器）可以用于管理各种二进制 SDK 的多个版本，包括 Groovy 和 Spring Boot CLI。得到 SDKMAN！从[sdkman.io](https://sdkman.io)开始，使用以下命令安装 Spring boot:

 ```
 $ sdk install springboot
@@ -149,7 +149,7 @@ $ brew install spring-boot

 Homebrew 将`spring`安装到`/usr/local/bin`。

-|   |如果你没有看到公式，那么你安装的 BREW 可能已经过时。<br/>在这种情况下，运行`brew update`，然后再试一次。|
+|   |如果你没有看到公式，那么你安装的 BREW 可能已经过期。<br/>在这种情况下，运行`brew update`，然后再试一次。|
 |---|---------------------------------------------------------------------------------------------------------------------------------|

 #### 3.2.4. MacPorts 安装
@@ -170,7 +170,7 @@ $ spring <HIT TAB HERE>
  grab  help  jar  run  test  version
 ```

-|   |如果你使用 Homebrew 或 MacPorts 安装 Spring 引导 CLI，那么命令行完成脚本将自动注册到你的 shell 中。|
+|   |如果你使用 Homebrew 或 MacPorts 安装 Spring 启动 CLI，那么命令行完成脚本将自动注册到你的 shell 中。|
 |---|---------------------------------------------------------------------------------------------------------------------------------------------------|

 #### 3.2.6.Windows Scoop 安装
@@ -184,7 +184,7 @@ $ spring <HIT TAB HERE>

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

-|   |如果你没有看到应用程序清单，那么你安装的 Scoop 可能已经过期。<br/>在这种情况下，运行`scoop update`，然后再试一次。|
+|   |如果你没有看到应用程序清单，那么你的 Scoop 安装可能已经过期。<br/>在这种情况下，运行`scoop update`，然后再试一次。|
 |---|----------------------------------------------------------------------------------------------------------------------------------------|

 #### 3.2.7.快速启动 Spring CLI 示例
@@ -223,7 +223,7 @@ Hello World!

 这一部分描述了如何开发一个小型的“Hello World！”Web 应用程序，该应用程序突出了 Spring Boot 的一些关键功能。我们使用 Maven 来构建这个项目，因为大多数 IDE 都支持它。

-|   |[spring.io](https://spring.io)网站包含许多使用 Spring 引导的“入门”[guides](https://spring.io/guides)，<br/>如果需要解决特定问题，首先检查那里。<br/><br/>你可以通过转到[start.spring.io](https://start.spring.io)并从依赖项搜索器中选择“web”启动器来缩短以下步骤。<br/>这样做会生成一个新的项目结构，以便你可以[立即开始编码](#getting-started.first-application.code)。<br/>检查[start.spring.io user guide](https://github.com/spring-io/start.spring.io/blob/main/USING.adoc)以获取更多详细信息。|
+|   |[spring.io](https://spring.io)网站包含许多使用 Spring 引导的“入门”[guides](https://spring.io/guides)，<br/>如果你需要解决特定的问题，首先检查那里。<br/><br/>你可以通过转到[start.spring.io](https://start.spring.io)并从依赖项搜索器中选择“web”启动器来快捷下面的步骤。<br/>这样做会生成一个新的项目结构，这样你就可以[立即开始编码](#getting-started.first-application.code)。<br/>检查[start.spring.io user guide](https://github.com/spring-io/start.spring.io/blob/main/USING.adoc)以获取更多详细信息。|
 |---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

 在开始之前，打开一个终端并运行以下命令，以确保安装了有效的 Java 和 Maven 版本：
@@ -272,12 +272,12 @@ Java version: 1.8.0_102, vendor: Oracle Corporation

 前面的列表应该为你提供一个可工作的构建。你可以通过运行`mvn package`来测试它（目前，你可以忽略“ jar 将为空-没有内容被标记为包含！”警告）。

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

 ### 4.2.添加 Classpath 依赖项

-Spring Boot 提供了许多“启动器”，允许你将罐子添加到你的 Classpath。我们的烟雾测试应用程序使用 POM 中`parent`部分中的`spring-boot-starter-parent`。`spring-boot-starter-parent`是一种特殊的启动器，它提供了有用的 Maven 默认值。它还提供了[“扶养-管理”](using.html#using.build-systems.dependency-management)节，以便你可以省略“有福的”依赖项的`version`标记。
+Spring Boot 提供了许多“启动器”，允许你将罐子添加到你的 Classpath。我们的烟雾测试应用程序使用 POM 中`parent`部分中的`spring-boot-starter-parent`。`spring-boot-starter-parent`是一种特殊的启动器，它提供了有用的 Maven 默认值。它还提供了一个[`dependency-management`]（使用.html#using.build-systems.dependency-management）部分，这样你就可以省略`version`标记来表示“有福的”依赖关系。

 其他“启动器”提供了在开发特定类型的应用程序时可能需要的依赖关系。因为我们正在开发一个 Web 应用程序，所以我们添加了一个`spring-boot-starter-web`依赖项。在此之前，我们可以通过运行以下命令查看当前的内容：

@@ -287,7 +287,7 @@ $ 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`依赖关系：
+`mvn dependency:tree`命令打印项目依赖关系的树表示。你可以看到`spring-boot-starter-parent`本身不提供依赖关系。要添加必要的依赖项，请编辑`pom.xml`，并在`parent`部分下面添加`spring-boot-starter-web`依赖项：

 ```
 <dependencies>
@@ -333,9 +333,9 @@ public class MyApplication {

 我们的`MyApplication`类的第一个注释是`@RestController`。这被称为*刻板印象*注释。它为阅读代码的人提供了提示，并为 Spring 提供了类扮演特定角色的提示。在这种情况下，我们的类是一个 Web`@Controller`，因此 Spring 在处理传入的 Web 请求时考虑它。

-`@RequestMapping`注释提供了“路由”信息。它告诉 Spring 任何带有`/`路径的 HTTP 请求都应该映射到`home`方法。`@RestController`注释告诉 Spring 将生成的字符串直接呈现给调用方。
+`@RequestMapping`注释提供了“路由”信息。它告诉 Spring，任何带有`/`路径的 HTTP 请求都应该映射到`home`方法。`@RestController`注释告诉 Spring 将生成的字符串直接呈现给调用方。

-|   |`@RestController`和`@RequestMapping`注释是 Spring MVC 注释（它们不特定于 Spring 引导）。<br/>有关更多详细信息，请参见 Spring 参考文档中的[MVC section](https://docs.spring.io/spring-framework/docs/5.3.16/reference/html/web.html#mvc)。|
+|   |`@RestController`和`@RequestMapping`注释是 Spring MVC 注释（它们不特定于 Spring 引导）。<br/>有关更多详细信息，请参见 Spring 参考文档中的[MVC 部分](https://docs.spring.io/spring-framework/docs/5.3.16/reference/html/web.html#mvc)。|
 |---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

 #### 4.3.2.@enableAutoConfiguration 注释 ###
@@ -348,7 +348,7 @@ public class MyApplication {

 #### 4.3.3.“主”法

-我们应用程序的最后一部分是`main`方法。对于应用程序入口点，这是一种遵循 Java 约定的标准方法。通过调用`run`，我们的主方法委托给 Spring boot 的`SpringApplication`类。`SpringApplication` 引导我们的应用程序，启动 Spring，然后启动自动配置的 Tomcat Web 服务器。我们需要将`MyApplication.class`作为参数传递给`run`方法，以告诉`SpringApplication`哪个是主要的 Spring 组件。还会传递`args`数组，以公开任何命令行参数。
+我们应用程序的最后一部分是`main`方法。对于应用程序入口点，这是一种遵循 Java 约定的标准方法。我们的主方法通过调用`run`来委托 Spring boot 的`SpringApplication`类。`SpringApplication`引导我们的应用程序，启动 Spring，然后启动自动配置的 Tomcat Web 服务器。我们需要将`MyApplication.class`作为参数传递给`run`方法，以告诉`SpringApplication`哪个是主要的 Spring 组件。还通过`args`数组公开任何命令行参数。

 ### 4.4.运行示例

@@ -403,10 +403,10 @@ Spring boot 需要[不同的方法](executable-jar.html#appendix.executable-jar)
 </build>
 ```

-|   |`spring-boot-starter-parent` POM 包括`<executions>`配置以绑定`repackage`目标。<br/>如果不使用父 POM，则需要自己声明此配置。<br/>详情请参见[插件文档](https://docs.spring.io/spring-boot/docs/2.6.4/maven-plugin/reference/htmlsingle/#getting-started)。|
+|   |`spring-boot-starter-parent` POM 包括`<executions>`配置，以绑定`repackage`目标。<br/>如果不使用父 POM，则需要自己声明此配置。<br/>有关详细信息，请参见[插件文档](https://docs.spring.io/spring-boot/docs/2.6.4/maven-plugin/reference/htmlsingle/#getting-started)。|
 |---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

-保存`pom.xml`并从命令行中运行`mvn package`，如下所示：
+保存`pom.xml`并从命令行运行`mvn package`，如下所示：

 ```
 $ mvn package
@@ -454,8 +454,8 @@ $ java -jar target/myproject-0.0.1-SNAPSHOT.jar

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

-## 5. 接下来读什么？
+## 5. 接下来要读什么？

-希望这一部分提供了一些 Spring 引导基础知识，并帮助你编写自己的应用程序。如果你是一位面向任务类型的开发人员，那么你可能希望跳到[spring.io](https://spring.io)，并遵循一些[getting started](https://spring.io/guides/)指南，这些指南解决了特定的“我如何使用 Spring？”问题。我们还有 Spring 特定于引导的“[How-to](howto.html#howto)”参考文档。
+希望这一部分提供了一些 Spring 引导基础知识，并帮助你编写自己的应用程序。如果你是一位面向任务类型的开发人员，你可能希望跳到[spring.io](https://spring.io)，并遵循一些[开始](https://spring.io/guides/)指南，这些指南解决了特定的“如何使用 Spring？”问题。我们还有 Spring 特定于引导的“[How-to](howto.html#howto)”参考文档。

-否则，下一个逻辑步骤是读取*[using.html](using.html#using)*。如果你真的不耐烦了，你也可以跳到前面去读*[Spring Boot features](features.html#features)*。
+否则，下一个逻辑步骤是读取 *[using.html](using.html#using)*。如果你真的不耐烦了，你也可以跳到前面去读关于 *[Spring Boot features](features.html#features)* 的文章。
--- a/docs/spring-boot/howto.md
+++ b/docs/spring-boot/howto.md
--- a/docs/spring-boot/io.md
+++ b/docs/spring-boot/io.md
--- a/docs/spring-boot/messaging.md
+++ b/docs/spring-boot/messaging.md
--- a/docs/spring-boot/upgrading.md
+++ b/docs/spring-boot/upgrading.md
-# 升级 Spring 引导
+# 升级 Spring Boot

-在项目[wiki](https://github.com/spring-projects/spring-boot/wiki)上提供了如何从 Spring 启动的早期版本升级的说明。按照[release notes](https://github.com/spring-projects/spring-boot/wiki#release-notes)部分中的链接查找要升级到的版本。
+在项目[wiki](https://github.com/spring-projects/spring-boot/wiki)上提供了如何从 Spring 启动的早期版本升级的说明。按照[发行说明](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)中查看每个版本的“新的和值得注意的”特性列表。
+如果你正在从 Spring 启动的`1.x`版本进行升级，请检查提供详细升级说明的[维基项目中的“迁移指南”](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0-Migration-Guide)。还可以在[“发行说明”](https://github.com/spring-projects/spring-boot/wiki)中查看每个版本的“新的和值得注意的”特性列表。

 ## 2. 升级到新的功能版本

@@ -26,11 +26,11 @@
 |   |完成迁移后，请确保从项目的依赖项中删除此模块。|
 |---|-------------------------------------------------------------------------------------------------------|

-## 3. 升级 Spring 引导 cli
+## 3. 升级 Spring Boot cli

 要升级现有的 CLI 安装，请使用适当的 PackageManager 命令（例如，<gtr="8"/>）。如果你手动安装了 CLI，请按照[标准说明](getting-started.html#getting-started.installing.cli.manual-installation)，记住更新你的`PATH`环境变量，以删除任何旧的引用。

-## 4. 接下来读什么？
+## 4. 接下来要读什么？

 一旦你决定升级你的应用程序，你可以在文档的其余部分找到关于特定功能的详细信息。


--- a/docs/spring-boot/using.md
+++ b/docs/spring-boot/using.md
--- a/docs/spring-boot/web.md
+++ b/docs/spring-boot/web.md
--- a/docs/spring-cloud-data-flow/READEME.md
+++ b/docs/spring-cloud-data-flow/READEME.md
--- a/docs/spring-cloud-data-flow/README.md
+++ b/docs/spring-cloud-data-flow/README.md
+# Spring Cloud Data Flow
\ No newline at end of file
--- a/docs/spring-cloud-data-flow/spring-cloud-dataflow.md
+++ b/docs/spring-cloud-data-flow/spring-cloud-dataflow.md
--- a/docs/spring-cloud/README.md
+++ b/docs/spring-cloud/README.md
-# Spring 云
\ No newline at end of file
+# Spring Cloud
\ No newline at end of file
--- a/docs/spring-cloud/document-overview.md
+++ b/docs/spring-cloud/document-overview.md
-# Spring 云文档
-
-
-本节提供了 Spring 云参考文档的简要概述。它是这份文件其余部分的一张地图。
-
-## [](#documentation-about)[1.关于文档](#documentation-about)
-
-Spring 云参考指南如下所示
-
-* [Multi-page HTML](https://docs.spring.io/spring-cloud/docs/2021.0.1/reference/html)
-
-* [单页 HTML](https://docs.spring.io/spring-cloud/docs/2021.0.1/reference/htmlsingle)
-
-* [PDF](https://docs.spring.io/spring-cloud/docs/2021.0.1/reference/pdf/spring-cloud.pdf)
-
-本文件的副本可供你自己使用并分发给他人，但前提是你不对此类副本收取任何费用，并且还需每一份副本均包含本版权声明，无论是以印刷形式还是以电子方式分发。
-
-## [](#documentation-getting-help)[2. Getting Help](#documentation-getting-help)
-
-如果你在云计算方面有困难，我们愿意提供帮助。
-
-* 学习云的基础知识。如果你从 Spring Cloud 开始，请尝试使用[guides](https://spring.io/guides)中的一个。
-
-* 问一个问题。我们监控[stackoverflow.com](https://stackoverflow.com)中带有[`spring-cloud`](https://stackoverflow.com/tags/spring-cloud)标记的问题。
-
-* 在[Spring Cloud Gitter](https://gitter.im/spring-cloud/spring-cloud)与我们聊天
-
-|   |所有的云都是开源的，包括文档。如果你发现<br/>DOCS 存在问题，或者你希望改进这些问题，请参与进来。|
-|---|------------------------------------------------------------------------------------------------------------------------------------------------------------|
-
--- a/docs/spring-cloud/documentation-overview.md
+++ b/docs/spring-cloud/documentation-overview.md
+# Spring Cloud 文档
+
+本节提供了 Spring Cloud 参考文档的简要概述。它是这份文件其余部分的一张地图。
+
+## [1.关于文档](#documentation-about)
+
+Spring Cloud 参考指南如下所示
+
+* [多页 HTML](https://docs.spring.io/spring-cloud/docs/2021.0.1/reference/html)
+
+* [单页 HTML](https://docs.spring.io/spring-cloud/docs/2021.0.1/reference/htmlsingle)
+
+* [PDF](https://docs.spring.io/spring-cloud/docs/2021.0.1/reference/pdf/spring-cloud.pdf)
--- a/docs/spring-cloud/spring-cloud-build.md
+++ b/docs/spring-cloud/spring-cloud-build.md
--- a/docs/spring-cloud/spring-cloud-bus.md
+++ b/docs/spring-cloud/spring-cloud-bus.md
--- a/docs/spring-cloud/spring-cloud-circuitbreaker.md
+++ b/docs/spring-cloud/spring-cloud-circuitbreaker.md
--- a/docs/spring-cloud/spring-cloud-cli.md
+++ b/docs/spring-cloud/spring-cloud-cli.md
--- a/docs/spring-cloud/spring-cloud-cloudfoundry.md
+++ b/docs/spring-cloud/spring-cloud-cloudfoundry.md
 # Spring Cloud for Cloud Foundry

-
 Spring Cloud for CloudFoundry 使得在[Cloud Foundry](https://github.com/cloudfoundry)（平台即服务）中运行[Spring Cloud](https://github.com/spring-cloud)应用程序变得很容易。Cloud Foundry 有一个“服务”的概念，这是一个可以“绑定”到应用程序的中间软件，本质上为它提供了一个包含凭据的环境变量（例如，用于服务的位置和用户名）。

 `spring-cloud-cloudfoundry-commons`模块配置了基于反应堆的 Cloud Foundry Java 客户端 V3.0，并且可以独立使用。

 `spring-cloud-cloudfoundry-web`项目为 Cloud Foundry 中 WebApps 的一些增强功能提供了基本支持：自动绑定到单点登录服务，并可选地为发现启用粘性路由。

-`spring-cloud-cloudfoundry-discovery`项目提供了 Spring Cloud Commons`DiscoveryClient`的实现，因此你可以 `@enableDiscoveryClient’并提供你的凭据为 ` Spring.cloud.cloudfoundry.Discovery.[username，password]`（如果你没有连接到[Pivotal Web 服务](https://run.pivotal.io)，也可以`*.url`），然后你可以直接使用`DiscoveryClient`，或者通过`LoadBalancerClient`。
+`spring-cloud-cloudfoundry-discovery`项目提供了 Spring Cloud Commons`DiscoveryClient`的实现，因此你可以`@EnableDiscoveryClient`并提供你的凭据为`spring.cloud.cloudfoundry.discovery.[username,password]`（如果你没有连接到[Pivotal Web 服务](https://run.pivotal.io)，也可以`*.url`），然后你可以直接使用`DiscoveryClient`，或者通过`LoadBalancerClient`。

 第一次使用 Discovery 客户机时，由于它必须从 Cloud Foundry 获得一个访问令牌，因此它可能会比较慢。

-## [](#discovery)[1. Discovery](#discovery)
+## 1.发现

-以下是一款带有 Cloud Foundry Discovery 的 Spring 云应用：
+以下是一款带有 Cloud Foundry Discovery 的 Spring Cloud应用：

 App.Groovy

@@ -45,14 +44,13 @@ $ cf push -p app.jar

 `DiscoveryClient`可以根据经过身份验证的凭据列出一个空间中的所有应用程序，该空间默认为客户端运行的空间（如果有的话）。如果既不配置组织也不配置空间，那么在 Cloud Foundry 中，它们默认为用户的配置文件。

-## [](#single-sign-on)[2.单点登录](#single-sign-on)
+## 2.单点登录

-|   |在版本 1.3 中，所有的 OAuth2SSO 和资源服务器功能都移动到了 Spring boot<br/>。你可以在[Spring Boot user guide](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/)中找到文档。|
+|   |在版本 1.3 中，所有的 OAuth2SSO 和资源服务器功能都移到了 Spring boot<br/>。你可以在[Spring Boot user guide](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/)中找到文档。|
 |---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

-该项目提供了从 CloudFoundry 服务凭据到 Spring 启动特性的自动绑定。例如，如果你有一个名为“SSO”的 CloudFoundry 服务，其凭据中包含“client\_id”、“client\_secret”和“auth\_domain”，那么它将自动绑定到你用 `@enableoAuth2SSO’启用的 Spring OAuth2 客户端（从 Spring 启动）。服务的名称可以使用`spring.oauth2.sso.serviceId`进行参数化。
-
-## [](#configuration)[3.配置](#configuration)
+该项目提供了从 CloudFoundry 服务凭据到 Spring 启动特性的自动绑定。例如，如果你有一个名为“SSO”的 CloudFoundry 服务，其凭据包含“client\_id”、“client\_secret”和“auth\_domain”，那么它将自动绑定到你通过`@EnableOAuth2Sso`（从 Spring 启动）启用的 Spring OAuth2 客户端。服务的名称可以使用`spring.oauth2.sso.serviceId`进行参数化。

-要查看所有 Spring Cloud Foundry 相关配置属性的列表，请检查[附录页](appendix.html)。
+## 3.配置

+要查看所有 Spring Cloud Foundry 相关配置属性的列表，请检查[附录页](appendix.html)。
\ No newline at end of file
--- a/docs/spring-cloud/spring-cloud-commons.md
+++ b/docs/spring-cloud/spring-cloud-commons.md
--- a/docs/spring-cloud/spring-cloud-config.md
+++ b/docs/spring-cloud/spring-cloud-config.md
--- a/docs/spring-cloud/spring-cloud-consul.md
+++ b/docs/spring-cloud/spring-cloud-consul.md
--- a/docs/spring-cloud/spring-cloud-contract.md
+++ b/docs/spring-cloud/spring-cloud-contract.md
--- a/docs/spring-cloud/spring-cloud-function.md
+++ b/docs/spring-cloud/spring-cloud-function.md
--- a/docs/spring-cloud/spring-cloud-gateway.md
+++ b/docs/spring-cloud/spring-cloud-gateway.md
--- a/docs/spring-cloud/spring-cloud-kubernetes.md
+++ b/docs/spring-cloud/spring-cloud-kubernetes.md
--- a/docs/spring-cloud/spring-cloud-netflix.md
+++ b/docs/spring-cloud/spring-cloud-netflix.md
--- a/docs/spring-cloud/spring-cloud-openfeign.md
+++ b/docs/spring-cloud/spring-cloud-openfeign.md
--- a/docs/spring-cloud/spring-cloud-sleuth.md
+++ b/docs/spring-cloud/spring-cloud-sleuth.md
--- a/docs/spring-cloud/spring-cloud-stream.md
+++ b/docs/spring-cloud/spring-cloud-stream.md
--- a/docs/spring-cloud/spring-cloud-task.md
+++ b/docs/spring-cloud/spring-cloud-task.md
--- a/docs/spring-cloud/spring-cloud-vault.md
+++ b/docs/spring-cloud/spring-cloud-vault.md
--- a/docs/spring-cloud/spring-cloud-zookeeper.md
+++ b/docs/spring-cloud/spring-cloud-zookeeper.md
--- a/docs/spring-credhub/READEME.md
+++ b/docs/spring-credhub/READEME.md
--- a/docs/spring-credhub/README.md
+++ b/docs/spring-credhub/README.md
+# Spring CredHub
\ No newline at end of file
--- a/docs/spring-credhub/spring-credhub.md
+++ b/docs/spring-credhub/spring-credhub.md
--- a/docs/spring-data/spring-data.md
+++ b/docs/spring-data/spring-data.md
--- a/docs/spring-flo/READEME.md
+++ b/docs/spring-flo/READEME.md
--- a/docs/spring-flo/README.md
+++ b/docs/spring-flo/README.md
--- a/docs/spring-flo/spring-flo.md
+++ b/docs/spring-flo/spring-flo.md
--- a/docs/spring-for-apache-kafka/READEME.md
+++ b/docs/spring-for-apache-kafka/READEME.md
--- a/docs/spring-for-apache-kafka/README.md
+++ b/docs/spring-for-apache-kafka/README.md
--- a/docs/spring-for-apache-kafka/spring-kafka.md
+++ b/docs/spring-for-apache-kafka/spring-kafka.md
--- a/docs/spring-for-graphql/READEME.md
+++ b/docs/spring-for-graphql/READEME.md
--- a/docs/spring-for-graphql/README.md
+++ b/docs/spring-for-graphql/README.md
--- a/docs/spring-for-graphql/spring-graphql.md
+++ b/docs/spring-for-graphql/spring-graphql.md
--- a/docs/spring-framework/core.md
+++ b/docs/spring-framework/core.md
--- a/docs/spring-framework/data-access.md
+++ b/docs/spring-framework/data-access.md
--- a/docs/spring-framework/integration.md
+++ b/docs/spring-framework/integration.md
--- a/docs/spring-framework/languages.md
+++ b/docs/spring-framework/languages.md
--- a/docs/spring-framework/overview.md
+++ b/docs/spring-framework/overview.md
--- a/docs/spring-framework/testing.md
+++ b/docs/spring-framework/testing.md
--- a/docs/spring-framework/web-reactive.md
+++ b/docs/spring-framework/web-reactive.md
--- a/docs/spring-framework/web-servlet.md
+++ b/docs/spring-framework/web-servlet.md
--- a/docs/spring-hateoas/READEME.md
+++ b/docs/spring-hateoas/READEME.md
--- a/docs/spring-hateoas/README.md
+++ b/docs/spring-hateoas/README.md
--- a/docs/spring-hateoas/spring-hateoas.md
+++ b/docs/spring-hateoas/spring-hateoas.md
--- a/docs/spring-integration/READEME.md
+++ b/docs/spring-integration/READEME.md
--- a/docs/spring-integration/README.md
+++ b/docs/spring-integration/README.md
--- a/docs/spring-integration/zookeeper.md
+++ b/docs/spring-integration/zookeeper.md
--- a/docs/spring-ldap/READEME.md
+++ b/docs/spring-ldap/READEME.md
--- a/docs/spring-ldap/README.md
+++ b/docs/spring-ldap/README.md
--- a/docs/spring-rest-docs/READEME.md
+++ b/docs/spring-rest-docs/READEME.md
--- a/docs/spring-rest-docs/README.md
+++ b/docs/spring-rest-docs/README.md
--- a/docs/spring-security/READEME.md
+++ b/docs/spring-security/READEME.md
--- a/docs/spring-security/README.md
+++ b/docs/spring-security/README.md
--- a/docs/spring-security/features-exploits-headers.md
+++ b/docs/spring-security/features-exploits-headers.md
--- a/docs/spring-security/reactive-oauth2-resource-server-opaque-token.md
+++ b/docs/spring-security/reactive-oauth2-resource-server-opaque-token.md
--- a/docs/spring-security/servlet-architecture.md
+++ b/docs/spring-security/servlet-architecture.md
--- a/docs/spring-security/servlet-authentication-architecture.md
+++ b/docs/spring-security/servlet-authentication-architecture.md
--- a/docs/spring-security/servlet-authentication-passwords-basic.md
+++ b/docs/spring-security/servlet-authentication-passwords-basic.md
--- a/docs/spring-security/servlet-authentication-passwords-form.md
+++ b/docs/spring-security/servlet-authentication-passwords-form.md
--- a/docs/spring-security/servlet-authentication-passwords-storage-dao-authentication-provider.md
+++ b/docs/spring-security/servlet-authentication-passwords-storage-dao-authentication-provider.md
--- a/docs/spring-security/servlet-authorization-architecture.md
+++ b/docs/spring-security/servlet-authorization-architecture.md
--- a/docs/spring-security/servlet-authorization-authorize-http-requests.md
+++ b/docs/spring-security/servlet-authorization-authorize-http-requests.md
--- a/docs/spring-security/servlet-authorization-authorize-requests.md
+++ b/docs/spring-security/servlet-authorization-authorize-requests.md
--- a/docs/spring-security/servlet-oauth2-resource-server-jwt.md
+++ b/docs/spring-security/servlet-oauth2-resource-server-jwt.md
--- a/docs/spring-security/servlet-oauth2-resource-server-opaque-token.md
+++ b/docs/spring-security/servlet-oauth2-resource-server-opaque-token.md
--- a/docs/spring-security/servlet-oauth2-resource-server.md
+++ b/docs/spring-security/servlet-oauth2-resource-server.md
--- a/docs/spring-security/servlet-saml2-login-overview.md
+++ b/docs/spring-security/servlet-saml2-login-overview.md
--- a/docs/spring-session/READEME.md
+++ b/docs/spring-session/READEME.md
--- a/docs/spring-session/README.md
+++ b/docs/spring-session/README.md
--- a/docs/spring-session/index.md
+++ b/docs/spring-session/index.md
--- a/docs/spring-session/api.md
+++ b/docs/spring-session/api.md
--- a/docs/spring-session/boot-redis.md
+++ b/docs/spring-session/boot-redis.md
--- a/docs/spring-session/boot-jdbc.md
+++ b/docs/spring-session/boot-jdbc.md
--- a/docs/spring-session/boot-mongo.md
+++ b/docs/spring-session/boot-mongo.md
--- a/docs/spring-session/boot-findbyusername.md
+++ b/docs/spring-session/boot-findbyusername.md
--- a/docs/spring-session/boot-websocket.md
+++ b/docs/spring-session/boot-websocket.md
--- a/docs/spring-session/http-session.md
+++ b/docs/spring-session/http-session.md
--- a/docs/spring-session/spring-security.md
+++ b/docs/spring-session/spring-security.md
--- a/docs/spring-session/upgrading.md
+++ b/docs/spring-session/upgrading.md
--- a/docs/spring-session/web-session.md
+++ b/docs/spring-session/web-session.md
--- a/docs/spring-session/web-socket.md
+++ b/docs/spring-session/web-socket.md
--- a/docs/spring-session/boot-webflux-custom-cookie.md
+++ b/docs/spring-session/boot-webflux-custom-cookie.md
--- a/docs/spring-shell/READEME.md
+++ b/docs/spring-shell/READEME.md
--- a/docs/spring-shell/README.md
+++ b/docs/spring-shell/README.md
--- a/docs/spring-statemachine/READEME.md
+++ b/docs/spring-statemachine/READEME.md
--- a/docs/spring-statemachine/README.md
+++ b/docs/spring-statemachine/README.md
--- a/docs/spring-vault/READEME.md
+++ b/docs/spring-vault/READEME.md
--- a/docs/spring-vault/README.md
+++ b/docs/spring-vault/README.md
--- a/docs/spring-web-flow/READEME.md
+++ b/docs/spring-web-flow/READEME.md
--- a/docs/spring-web-flow/README.md
+++ b/docs/spring-web-flow/README.md
--- a/docs/spring-web-services/READEME.md
+++ b/docs/spring-web-services/READEME.md
--- a/docs/spring-web-services/README.md
+++ b/docs/spring-web-services/README.md
--- a/docs/vscode_java.md
+++ b/docs/vscode_java.md
--- a/package.json
+++ b/package.json
--- a/yarn.lock
+++ b/yarn.lock