#1 添加英文原文

docs/en/README.md

+# Spring 中文文档社区 
+
+从实操的角度整理翻译`Spring`相关文档，包括`快速开始`、`安装指南`、`开发工具配置`、`代码案例`等。
+
+## 声明
+本站中的文章内容来源于 [Spring.io](https://spring.io/)，原始版权归属于 [Spring.io](https://spring.io/)。本站对相关文章进行了翻译及整理。本站文章可供个人学习、研究或者欣赏之用，未经本站事先书面许可，不得进行任何转载、商用或与之相关的行为。
+商标声明：Spring 是 Pivotal Software, Inc. 在美国以及其他国家的商标。
+
+## 文档列表
+
+- [Spring](/why-spring.html)
+- [Spring Boot](/spring-boot/getting-help.html)
+- [Spring Framework](/spring-framework/overview.html)
+- [Spring Data](/spring-data/spring-data.html)
+- [Spring Cloud](/spring-cloud/documentation-overview.html)
+- [Spring Cloud Data Flow](/spring-cloud-data-flow/spring-cloud-dataflow.html)
+- [Spring Security](/spring-security/overview.html)
+- [Spring for GraphQL](/spring-for-graphql/spring-graphql.html)
+- [Spring Session](/spring-session/_index.html)
+- [Spring Integration](/spring-integration/preface.html)
+- [Spring HATEOAS](/spring-hateoas/spring-hateoas.html)
+- [Spring REST Docs](/spring-rest-docs/spring-restdocs.html)
+- [Spring Batch](/spring-batch/spring-batch-intro.html)
+- [Spring AMQP](/spring-amqp/spring-amqp.html)
+- [Spring CredHub](/spring-credhub/spring-credhub.html)
+- [Spring Flo](/spring-flo/spring-flo.html)
+- [Spring for Apache Kafka](/spring-for-apache-kafka/spring-kafka.html)
+- [Spring LDAP](/spring-ldap/spring-ldap.html)
+- [Spring Shell](/spring-shell/spring-shell.html)
+- [Spring Statemachine](/spring-statemachine/spring-statemachine.html)
+- [Spring Vault](/spring-vault/spring-vault.html)
+- [Spring Web Flow](/spring-web-flow/preface.html)
+- [Spring Web Services](/spring-web-services/spring-web-service.html)
+
+
+## 参与贡献流程
+
+所有 **`Java Spring 熟练使用者`** 可以参与到`Spring 中文文档社区`的建设中来，选择自己感兴趣题目，可以直接撰写文章，也可以翻译 [Spring 官方](https://spring.io/) 上面的内容，也可以校对别人翻译的文章。具体贡献流程如下。
+![](./readme/readme-1.png)
+
+### 1. 阅读文档帮助改善
+
+在[`Spring 中文文档社区`](https://spring.gitcode.net)上浏览某一篇文档时，发现有不准确的地方，可以`随时`在该页面的左下方点击`在 GitCode 上编辑此页`。
+![](./readme/readme-2.png)
+
+### 2. 在 GitCode 校对/创作
+
+进入GitCode之后，会自动定位到你想要修改的文件，修改文件内容。
+
+#### 2-1. 仓库的成员
+
+如果是仓库的成员，点击`“编辑”按钮，会直接进入可编辑的状态，供你修改文件内容。
+
+![](./readme/readme-3.png)
+
+![](./readme/readme-4.png)
+
+#### 2-2. 非仓库的成员
+
+如果是非仓库的成员，点击`“编辑”`，GitCode 会提醒你没有权限编辑，可以点击`Fork`按钮，将该项目克隆到你的 GitCode 账户下。
+
+![](./readme/readme-5.png)
+
+
+### 3. 内容编辑完成提交PR
+
+内容编辑完成者向[此仓库](https://gitcode.net/dev-cloud/spring-docs)提交 PR（Pull Request）。
+
+### 4. 审核
+[主仓库](https://gitcode.net/dev-cloud/spring-docs) 管理者会 Review，符合要求的，即会 Merge 到[主仓库](https://gitcode.net/dev-cloud/spring-docs)中。
+
+### 5. 查看更新
+Merge 成功之后，稍等片刻就可以刷新页面查看更新。

docs/en/spring-batch/appendix.md

+## Appendix A: List of ItemReaders and ItemWriters
+
+### Item Readers
+
+|              Item Reader               |                                                                                                                                                                                                                                                                                                   Description                                                                                                                                                                                                                                                                                                   |
+|----------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|AbstractItemCountingItemStreamItemReader|                                                                                                                                                                                                                                       Abstract base class that provides basic<br/>restart capabilities by counting the number of items returned from<br/>an `ItemReader`.                                                                                                                                                                                                                                       |
+|          AggregateItemReader           |An `ItemReader` that delivers a list as its<br/>item, storing up objects from the injected `ItemReader` until they<br/>are ready to be packed out as a collection. This class must be used<br/>as a wrapper for a custom `ItemReader` that can identify the record<br/>boundaries. The custom reader should mark the beginning and end of<br/>records by returning an `AggregateItem` which responds `true` to its<br/>query methods `isHeader()` and `isFooter()`. Note that this reader<br/>is not part of the library of readers provided by Spring Batch<br/>but given as a sample in `spring-batch-samples`.|
+|             AmqpItemReader             |                                                                                                                                                                                                                                 Given a Spring `AmqpTemplate`, it provides<br/>synchronous receive methods. The `receiveAndConvert()` method<br/>lets you receive POJO objects.                                                                                                                                                                                                                                 |
+|            KafkaItemReader             |                                                                                                                                                                             An `ItemReader` that reads messages from an Apache Kafka topic.<br/>It can be configured to read messages from multiple partitions of the same topic.<br/>This reader stores message offsets in the execution context to support restart capabilities.                                                                                                                                                                              |
+|           FlatFileItemReader           |                                                                                                                                                                                                                               Reads from a flat file. Includes `ItemStream`and `Skippable` functionality. See [`FlatFileItemReader`](readersAndWriters.html#flatFileItemReader).                                                                                                                                                                                                                                |
+|       HibernateCursorItemReader        |                                                                                                                                                                                                                                           Reads from a cursor based on an HQL query. See[`Cursor-based ItemReaders`](readersAndWriters.html#cursorBasedItemReaders).                                                                                                                                                                                                                                            |
+|       HibernatePagingItemReader        |                                                                                                                                                                                                                                                                                        Reads from a paginated HQL query                                                                                                                                                                                                                                                                                         |
+|           ItemReaderAdapter            |                                                                                                                                                                                                                                                                                 Adapts any class to the`ItemReader` interface.                                                                                                                                                                                                                                                                                  |
+|          JdbcCursorItemReader          |                                                                                                                                                                                                                                             Reads from a database cursor via JDBC. See[`Cursor-based ItemReaders`](readersAndWriters.html#cursorBasedItemReaders).                                                                                                                                                                                                                                              |
+|          JdbcPagingItemReader          |                                                                                                                                                                                                                                           Given an SQL statement, pages through the rows,<br/>such that large datasets can be read without running out of<br/>memory.                                                                                                                                                                                                                                           |
+|             JmsItemReader              |                                                                                                                                                                                                         Given a Spring `JmsOperations` object and a JMS<br/>Destination or destination name to which to send errors, provides items<br/>received through the injected `JmsOperations#receive()`method.                                                                                                                                                                                                          |
+|          JpaPagingItemReader           |                                                                                                                                                                                                                                           Given a JPQL statement, pages through the<br/>rows, such that large datasets can be read without running out of<br/>memory.                                                                                                                                                                                                                                           |
+|             ListItemReader             |                                                                                                                                                                                                                                                                               Provides the items from a list, one at a<br/>time.                                                                                                                                                                                                                                                                                |
+|            MongoItemReader             |                                                                                                                                                                                                                                     Given a `MongoOperations` object and a JSON-based MongoDB<br/>query, provides items received from the `MongoOperations#find()` method.                                                                                                                                                                                                                                      |
+|            Neo4jItemReader             |                                                                                                                                                                                                                              Given a `Neo4jOperations` object and the components of a<br/>Cyhper query, items are returned as the result of the Neo4jOperations.query<br/>method.                                                                                                                                                                                                                               |
+|          RepositoryItemReader          |                                                                                                                                                                                                               Given a Spring Data `PagingAndSortingRepository` object,<br/>a `Sort`, and the name of method to execute, returns items provided by the<br/>Spring Data repository implementation.                                                                                                                                                                                                                |
+|       StoredProcedureItemReader        |                                                                                                                                                                                                                Reads from a database cursor resulting from the<br/>execution of a database stored procedure. See [`StoredProcedureItemReader`](readersAndWriters.html#StoredProcedureItemReader)                                                                                                                                                                                                                |
+|          StaxEventItemReader           |                                                                                                                                                                                                                                                            Reads via StAX. see [`StaxEventItemReader`](readersAndWriters.html#StaxEventItemReader).                                                                                                                                                                                                                                                             |
+|             JsonItemReader             |                                                                                                                                                                                                                                                        Reads items from a Json document. see [`JsonItemReader`](readersAndWriters.html#JsonItemReader).                                                                                                                                                                                                                                                         |
+
+### Item Writers
+
+|             Item Writer              |                                                                                                                            Description                                                                                                                            |
+|--------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|     AbstractItemStreamItemWriter     |                                                                                           Abstract base class that combines the`ItemStream` and`ItemWriter` interfaces.                                                                                           |
+|            AmqpItemWriter            |                                                          Given a Spring `AmqpTemplate`, it provides<br/>for a synchronous `send` method. The `convertAndSend(Object)`method lets you send POJO objects.                                                           |
+|         CompositeItemWriter          |                                                                                  Passes an item to the `write` method of each<br/>in an injected `List` of `ItemWriter` objects.                                                                                  |
+|          FlatFileItemWriter          |                                                       Writes to a flat file. Includes `ItemStream` and<br/>Skippable functionality. See [`FlatFileItemWriter`](readersAndWriters.html#flatFileItemWriter).                                                        |
+|          GemfireItemWriter           |                                                     Using a `GemfireOperations` object, items are either written<br/>or removed from the Gemfire instance based on the configuration of the delete<br/>flag.                                                      |
+|         HibernateItemWriter          |            This item writer is Hibernate-session aware<br/>and handles some transaction-related work that a non-"hibernate-aware"<br/>item writer would not need to know about and then delegates<br/>to another item writer to do the actual writing.            |
+|          ItemWriterAdapter           |                                                                                                          Adapts any class to the`ItemWriter` interface.                                                                                                           |
+|         JdbcBatchItemWriter          |                                                              Uses batching features from a`PreparedStatement`, if available, and can<br/>take rudimentary steps to locate a failure during a`flush`.                                                              |
+|            JmsItemWriter             |                                                                  Using a `JmsOperations` object, items are written<br/>to the default queue through the `JmsOperations#convertAndSend()` method.                                                                  |
+|            JpaItemWriter             |                   This item writer is JPA EntityManager-aware<br/>and handles some transaction-related work that a non-"JPA-aware"`ItemWriter` would not need to know about and<br/>then delegates to another writer to do the actual writing.                    |
+|           KafkaItemWriter            |Using a `KafkaTemplate` object, items are written to the default topic through the`KafkaTemplate#sendDefault(Object, Object)` method using a `Converter` to map the key from the item.<br/>A delete flag can also be configured to send delete events to the topic.|
+|        MimeMessageItemWriter         |                                                                                      Using Spring’s `JavaMailSender`, items of type `MimeMessage`are sent as mail messages.                                                                                       |
+|           MongoItemWriter            |                             Given a `MongoOperations` object, items are written<br/>through the `MongoOperations.save(Object)` method. The actual write is delayed<br/>until the last possible moment before the transaction commits.                             |
+|           Neo4jItemWriter            |                                                Given a `Neo4jOperations` object, items are persisted through the`save(Object)` method or deleted through the `delete(Object)` per the`ItemWriter’s` configuration                                                 |
+|PropertyExtractingDelegatingItemWriter|       Extends `AbstractMethodInvokingDelegator`creating arguments on the fly. Arguments are created by retrieving<br/>the values from the fields in the item to be processed (through a`SpringBeanWrapper`), based on an injected array of field<br/>names.       |
+|         RepositoryItemWriter         |                                                                    Given a Spring Data `CrudRepository` implementation,<br/>items are saved through the method specified in the configuration.                                                                    |
+|         StaxEventItemWriter          |                                                                       Uses a `Marshaller` implementation to<br/>convert each item to XML and then writes it to an XML file using<br/>StAX.                                                                        |
+|          JsonFileItemWriter          |                                                                         Uses a `JsonObjectMarshaller` implementation to<br/>convert each item to Json and then writes it to an Json file.
\ No newline at end of file

docs/en/spring-batch/glossary.md

+# Glossary
+
+## Appendix A: Glossary
+
+### Spring Batch Glossary
+
+Batch
+
+An accumulation of business transactions over time.
+
+Batch Application Style
+
+Term used to designate batch as an application style in its own right, similar to
+online, Web, or SOA. It has standard elements of input, validation, transformation of
+information to business model, business processing, and output. In addition, it
+requires monitoring at a macro level.
+
+Batch Processing
+
+The handling of a batch of many business transactions that have accumulated over a
+period of time (such as an hour, a day, a week, a month, or a year). It is the
+application of a process or set of processes to many data entities or objects in a
+repetitive and predictable fashion with either no manual element or a separate manual
+element for error processing.
+
+Batch Window
+
+The time frame within which a batch job must complete. This can be constrained by other
+systems coming online, other dependent jobs needing to execute, or other factors
+specific to the batch environment.
+
+Step
+
+The main batch task or unit of work. It initializes the business logic and controls the
+transaction environment, based on commit interval setting and other factors.
+
+Tasklet
+
+A component created by an application developer to process the business logic for a
+Step.
+
+Batch Job Type
+
+Job types describe application of jobs for particular types of processing. Common areas
+are interface processing (typically flat files), forms processing (either for online
+PDF generation or print formats), and report processing.
+
+Driving Query
+
+A driving query identifies the set of work for a job to do. The job then breaks that
+work into individual units of work. For instance, a driving query might be to identify
+all financial transactions that have a status of "pending transmission" and send them
+to a partner system. The driving query returns a set of record IDs to process. Each
+record ID then becomes a unit of work. A driving query may involve a join (if the
+criteria for selection falls across two or more tables) or it may work with a single
+table.
+
+Item
+
+An item represents the smallest amount of complete data for processing. In the simplest
+terms, this might be a line in a file, a row in a database table, or a particular
+element in an XML file.
+
+Logical Unit of Work (LUW)
+
+A batch job iterates through a driving query (or other input source, such as a file) to
+perform the set of work that the job must accomplish. Each iteration of work performed
+is a unit of work.
+
+Commit Interval
+
+A set of LUWs processed within a single transaction.
+
+Partitioning
+
+Splitting a job into multiple threads where each thread is responsible for a subset of
+the overall data to be processed. The threads of execution may be within the same JVM
+or they may span JVMs in a clustered environment that supports workload balancing.
+
+Staging Table
+
+A table that holds temporary data while it is being processed.
+
+Restartable
+
+A job that can be executed again and assumes the same identity as when run initially.
+In other words, it is has the same job instance ID.
+
+Rerunnable
+
+A job that is restartable and manages its own state in terms of the previous run’s
+record processing. An example of a rerunnable step is one based on a driving query. If
+the driving query can be formed so that it limits the processed rows when the job is
+restarted, then it is re-runnable. This is managed by the application logic. Often, a
+condition is added to the `where` statement to limit the rows returned by the driving
+query with logic resembling "and processedFlag!= true".
+
+Repeat
+
+One of the most basic units of batch processing, it defines by repeatability calling a
+portion of code until it is finished and while there is no error. Typically, a batch
+process would be repeatable as long as there is input.
+
+Retry
+
+Simplifies the execution of operations with retry semantics most frequently associated
+with handling transactional output exceptions. Retry is slightly different from repeat,
+rather than continually calling a block of code, retry is stateful and continually
+calls the same block of code with the same input, until it either succeeds or some type
+of retry limit has been exceeded. It is only generally useful when a subsequent
+invocation of the operation might succeed because something in the environment has
+improved.
+
+Recover
+
+Recover operations handle an exception in such a way that a repeat process is able to
+continue.
+
+Skip
+
+Skip is a recovery strategy often used on file input sources as the strategy for
+ignoring bad input records that failed validation.
\ No newline at end of file

docs/en/spring-batch/monitoring-and-metrics.md

+# Monitoring and metrics
+
+## Monitoring and metrics
+
+Since version 4.2, Spring Batch provides support for batch monitoring and metrics
+based on [Micrometer](https://micrometer.io/). This section describes
+which metrics are provided out-of-the-box and how to contribute custom metrics.
+
+### Built-in metrics
+
+Metrics collection does not require any specific configuration. All metrics provided
+by the framework are registered in[Micrometer’s global registry](https://micrometer.io/docs/concepts#_global_registry)under the `spring.batch` prefix. The following table explains all the metrics in details:
+
+|       *Metric Name*       |     *Type*      |       *Description*       |             *Tags*              |
+|---------------------------|-----------------|---------------------------|---------------------------------|
+|    `spring.batch.job`     |     `TIMER`     | Duration of job execution |        `name`, `status`         |
+| `spring.batch.job.active` |`LONG_TASK_TIMER`|   Currently active jobs   |             `name`              |
+|    `spring.batch.step`    |     `TIMER`     |Duration of step execution |  `name`, `job.name`, `status`   |
+| `spring.batch.item.read`  |     `TIMER`     | Duration of item reading  |`job.name`, `step.name`, `status`|
+|`spring.batch.item.process`|     `TIMER`     |Duration of item processing|`job.name`, `step.name`, `status`|
+|`spring.batch.chunk.write` |     `TIMER`     | Duration of chunk writing |`job.name`, `step.name`, `status`|
+
+|   |The `status` tag can be either `SUCCESS` or `FAILURE`.|
+|---|------------------------------------------------------|
+
+### Custom metrics
+
+If you want to use your own metrics in your custom components, we recommend using
+Micrometer APIs directly. The following is an example of how to time a `Tasklet`:
+
+```
+import io.micrometer.core.instrument.Metrics;
+import io.micrometer.core.instrument.Timer;
+
+import org.springframework.batch.core.StepContribution;
+import org.springframework.batch.core.scope.context.ChunkContext;
+import org.springframework.batch.core.step.tasklet.Tasklet;
+import org.springframework.batch.repeat.RepeatStatus;
+
+public class MyTimedTasklet implements Tasklet {
+
+	@Override
+	public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) {
+		Timer.Sample sample = Timer.start(Metrics.globalRegistry);
+		String status = "success";
+		try {
+			// do some work
+		} catch (Exception e) {
+			// handle exception
+			status = "failure";
+		} finally {
+			sample.stop(Timer.builder("my.tasklet.timer")
+					.description("Duration of MyTimedTasklet")
+					.tag("status", status)
+					.register(Metrics.globalRegistry));
+		}
+		return RepeatStatus.FINISHED;
+	}
+}
+```
+
+### Disabling metrics
+
+Metrics collection is a concern similar to logging. Disabling logs is typically
+done by configuring the logging library and this is no different for metrics.
+There is no feature in Spring Batch to disable micrometer’s metrics, this should
+be done on micrometer’s side. Since Spring Batch stores metrics in the global
+registry of micrometer with the `spring.batch` prefix, it is possible to configure
+micrometer to ignore/deny batch metrics with the following snippet:
+
+```
+Metrics.globalRegistry.config().meterFilter(MeterFilter.denyNameStartsWith("spring.batch"))
+```
+
+Please refer to micrometer’s [reference documentation](http://micrometer.io/docs/concepts#_meter_filters)for more details.
\ No newline at end of file

docs/en/spring-boot/getting-help.md

+# Getting Help
+
+If you have trouble with Spring Boot, we would like to help.
+
+* Try the [How-to documents](howto.html#howto).
+  They provide solutions to the most common questions.
+
+* Learn the Spring basics.
+  Spring Boot builds on many other Spring projects.
+  Check the [spring.io](https://spring.io) web-site for a wealth of reference documentation.
+  If you are starting out with Spring, try one of the [guides](https://spring.io/guides).
+
+* Ask a question.
+  We monitor [stackoverflow.com](https://stackoverflow.com) for questions tagged with [`spring-boot`](https://stackoverflow.com/tags/spring-boot).
+
+* Report bugs with Spring Boot at [github.com/spring-projects/spring-boot/issues](https://github.com/spring-projects/spring-boot/issues).
+
+Note:
+
+All of Spring Boot is open source, including the documentation. If you find problems with the docs or if you want to improve them, please [get involved](https://github.com/spring-projects/spring-boot/tree/v2.6.4).
\ No newline at end of file

docs/en/spring-boot/legal.md

+# Legal
+
+Copyright © 2012-2022
+
+Copies of this document may be made for your own use and for distribution to
+others, provided that you do not charge any fee for such copies and further
+provided that each copy contains this Copyright Notice, whether distributed in
+print or electronically.