diff --git a/docs/spring-for-graphql/spring-graphql.md b/docs/spring-for-graphql/spring-graphql.md
new file mode 100644
index 0000000000000000000000000000000000000000..f0409622cd40e207b701d89313e7660bd4230b67
--- /dev/null
+++ b/docs/spring-for-graphql/spring-graphql.md
@@ -0,0 +1,1282 @@
+# Spring 用于 GraphQL 文档
+
+## [](#overview)1. 概述
+
+Spring for GraphQL 为 Spring 构建在[GraphQL Java](https://www.graphql-java.com/)上的应用程序提供支持。这是两个团队的联合合作。我们的共同理念是少些固执己见，更多地关注全面和广泛的支持。
+
+Spring 对于 GraphQL 来说，它是 GraphQL Java 团队的[GraphQL Java Spring](https://github.com/graphql-java/graphql-java-spring)项目的继承者。它旨在成为所有 Spring、GraphQL 应用程序的基础。
+
+目前，该项目正处于迈向 1.0 版本的里程碑阶段，并正在寻找反馈。请使用我们的[问题追踪器](https://github.com/spring-projects/spring-graphql/issues)报告问题，讨论设计问题，或请求一个功能。
+
+要开始，请检查[start.spring.io](https://start.spring.io)上的 Spring GraphQL 启动器和[Samples](#samples)部分。
+
+## [](#requirements)2. 所需经费
+
+Spring 对于 GraphQL，需要以下作为基线：
+
+* JDK8
+
+* Spring 框架 5.3
+
+* GraphQL Java17
+
+* Spring 用于 QueryDSL 或通过示例查询的数据 2021.1.0 或更高版本
+
+## [](#web-transports)3. 网络传输
+
+Spring for GraphQL 支持 HTTP 和 Over WebSocket 上的 GraphQL 请求。
+
+### [](#web-http)3.1. HTTP
+
+`GraphQlHttpHandler`通过 HTTP 请求处理 GraphQL，并将其委托给[网络拦截](#web-interception)链以执行请求。有两种变体，一种适用于 Spring MVC，另一种适用于 Spring WebFlux。两者都异步处理请求，并具有等效的功能，但在编写 HTTP 响应时分别依赖于阻塞和非阻塞 I/O。
+
+请求必须使用 HTTP POST，而 GraphQL 请求详细信息作为 JSON 包含在请求主体中，如提议的[HTTP 上的 GraphQL](https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md)规范中所定义的那样。一旦成功解码了 JSON 主体，HTTP 响应状态总是 200（OK），来自 GraphQL 请求执行的任何错误都会出现在 GraphQL 响应的“错误”部分。
+
+通过声明`RouterFunction` Bean 并使用 Spring MVC 或 WebFlux 中的`RouterFunctions`来创建路由，`GraphQlHttpHandler`可以作为 HTTP 端点公开。引导启动器执行此操作，请参阅[Web 端点](https://docs.spring.io/spring-boot/docs/2.7.0-SNAPSHOT/reference/html/web.html#web.graphql.web-endpoints)小节以获取详细信息，或检查其包含的`GraphQlWebMvcAutoConfiguration`或`GraphQlWebFluxAutoConfiguration`以获取实际配置。
+
+Spring for GraphQL 存储库包含一个 Spring MVC应用程序。
+
+### [](#web-websocket)3.2. WebSocket
+
+`GraphQlWebSocketHandler`基于[graphql-ws](https://github.com/enisdenjo/graphql-ws)库中定义的[protocol](https://github.com/enisdenjo/graphql-ws/blob/master/PROTOCOL.md)处理 WebSocket 请求上的 GraphQL。在 WebSocket 以上使用 GraphQL 的主要原因是订阅允许发送 GraphQL 响应流，但它也可以用于具有单个响应的常规查询。处理程序将每个请求委托给[网络拦截](#web-interception)链，以进一步执行请求。
+
+| |GraphQL over WebSocket 协议
有两个这样的协议，一个在[订阅-transport-ws](https://github.com/apollographql/subscriptions-transport-ws)库中，另一个在[graphql-ws](https://github.com/enisdenjo/graphql-ws)库中。前者不是活动的，而
是由后者继承的。阅读此[blog post](https://the-guild.dev/blog/graphql-over-websockets)查看历史。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+`GraphQlWebSocketHandler`有两种变体，一种用于 Spring MVC，另一种用于 Spring WebFlux。两者都异步处理请求，并具有等效的功能。WebFlux 处理程序还使用非阻塞 I/O 和反压来传输消息流，这很好地工作，因为在 GraphQL Java 中，订阅响应是一个反应流`Publisher`。
+
+`graphql-ws`项目列出了许多用于客户机的[recipes](https://github.com/enisdenjo/graphql-ws#recipes)。
+
+通过声明`SimpleUrlHandlerMapping` Bean 并使用它将处理程序映射到 URL 路径，可以将`GraphQlWebSocketHandler`公开为 WebSocket 端点。引导启动器有启用此功能的选项，有关详细信息，请参见[Web 端点](https://docs.spring.io/spring-boot/docs/2.7.0-SNAPSHOT/reference/html/web.html#web.graphql.web-endpoints)部分，或检查其包含的`GraphQlWebMvcAutoConfiguration`或`GraphQlWebFluxAutoConfiguration`以获取实际配置。
+
+Spring for GraphQL 存储库包含一个 WebFlux[WebSocket sample](https://github.com/spring-projects/spring-graphql/tree/main/samples/webflux-websocket)应用程序。
+
+### [](#web-interception)3.3. 网络拦截
+
+[HTTP](#web-http)和[WebSocket](#web-websocket)传输处理程序委托给公共 Web 拦截链以执行请求。该链由`WebInterceptor`组件序列组成，然后是调用 GraphQL Java 引擎的`GraphQlService`组件序列。
+
+`WebInterceptor`是在 Spring MVC 和 WebFlux 应用程序中使用的通用契约。使用它来拦截请求、检查 HTTP 请求头或注册`graphql.ExecutionInput`的转换：
+
+```
+class MyInterceptor implements WebInterceptor {
+
+ @Override
+ public Mono intercept(WebInput webInput, WebInterceptorChain chain) {
+ webInput.configureExecutionInput((executionInput, builder) -> {
+ Map map = ... ;
+ return builder.extensions(map).build();
+ });
+ return chain.next(webInput);
+ }
+}
+
+```
+
+也可以使用`WebInterceptor`来拦截响应，添加 HTTP 响应头，或转换`graphql.ExecutionResult`:
+
+```
+class MyInterceptor implements WebInterceptor {
+
+ @Override
+ public Mono intercept(WebInput webInput, WebInterceptorChain chain) {
+ return chain.next(webInput)
+ .map(webOutput -> {
+ Object data = webOutput.getData();
+ Object updatedData = ... ;
+ return webOutput.transform(builder -> builder.data(updatedData));
+ });
+ }
+}
+
+```
+
+`WebGraphQlHandler`提供了一个构建器来初始化 Web 拦截链。在构建链后，可以使用生成的`WebGraphQlHandler`初始化 HTTP 或 WebSocket 传输处理程序。引导启动器配置所有这些，请参阅[Web 端点](https://docs.spring.io/spring-boot/docs/2.7.0-SNAPSHOT/reference/html/web.html#web.graphql.web-endpoints)小节以获取详细信息，或检查其包含的`GraphQlWebMvcAutoConfiguration`或`GraphQlWebFluxAutoConfiguration`以获取实际配置。
+
+## [](#execution)4. 请求执行
+
+`GraphQlService`是调用 GraphQL Java 执行请求的主要 Spring 抽象。底层传输，例如[网络传输](#web-transports)，委托给`GraphQlService`来处理请求。
+
+主要的实现`ExecutionGraphQlService`是围绕`graphql.GraphQL`调用的一个很薄的外观。它配置了`GraphQlSource`以访问`graphql.GraphQL`实例。
+
+### [](#execution-graphqlsource)4.1. `GraphQLSource`
+
+`GraphQlSource`是用于访问用于执行请求的`graphql.GraphQL`实例的核心 Spring 抽象。它提供了一个 Builder API 来初始化 GraphQL Java 并构建`GraphQlSource`。
+
+默认的`GraphQlSource`Builder 可通过`GraphQlSource.builder()`访问，支持[active`DataFetcher`]（#execution-active-datafetcher）、[上下文传播](#execution-context)和[异常解决](#execution-exceptions)。
+
+Spring boot[starter](https://docs.spring.io/spring-boot/docs/2.7.0-SNAPSHOT/reference/html/web.html#web.graphql)通过默认的`GraphQlSource.Builder`初始化`GraphQlSource`实例，并启用以下功能：
+
+* 从可配置位置加载[模式文件](#execution-graphqlsource-schema-resources)。
+
+* 公开适用于`GraphQlSource.Builder`的[properties](https://docs.spring.io/spring-boot/docs/2.7.0-SNAPSHOT/reference/html/application-properties.html#appendix.application-properties.web)。
+
+* 检测[`RuntimeWiringConfigurer`]bean。
+
+* 检测[仪器仪表](https://www.graphql-java.com/documentation/instrumentation)bean 的[GraphQL 度量](https://docs.spring.io/spring-boot/docs/2.7.0-SNAPSHOT/reference/html/actuator.html#actuator.metrics.supported.spring-graphql)。
+
+* 检测`DataFetcherExceptionResolver`bean 的[异常解决](#execution-exceptions)。
+
+* 检测`GraphQlSourceBuilderCustomizer`bean 的任何其他自定义。
+
+#### [](#execution-graphqlsource-schema-resources)4.1.1. 模式资源
+
+`GraphQlSource.Builder`可以配置一个或多个`Resource`实例来进行解析和合并。这意味着模式文件可以从几乎任何位置加载。
+
+默认情况下， Spring 引导启动器[查找架构文件](https://docs.spring.io/spring-boot/docs/2.7.0-SNAPSHOT/reference/html/web.html#web.graphql.schema)来自一个众所周知的 Classpath 位置，但是你可以通过`FileSystemResource`将其更改为文件系统上的一个位置，通过`ByteArrayResource`将字节内容更改为通过`ByteArrayResource`，或者实现一个自定义的`Resource`从远程位置或存储空间加载模式文件。
+
+#### [](#execution-graphqlsource-schema-creation)4.1.2. 模式创建
+
+默认情况下，`GraphQlSource.Builder`使用 GraphQLJava来创建。这适用于大多数应用程序，但如果有必要，你可以通过构建器连接到模式创建：
+
+```
+// Typically, accessed through Spring Boot's GraphQlSourceBuilderCustomizer
+GraphQlSource.Builder builder = ...
+
+builder.schemaResources(..)
+ .configureRuntimeWiring(..)
+ .schemaFactory((typeDefinitionRegistry, runtimeWiring) -> {
+ // create GraphQLSchema
+ })
+
+```
+
+这样做的主要原因是通过联合库创建模式。
+
+#### [](#execution-graphqlsource-runtimewiring-configurer)4.1.3. `RuntimeWiringConfigurer`
+
+你可以使用`RuntimeWiringConfigurer`注册：
+
+* 自定义标量类型。
+
+* 指令处理代码。
+
+* `TypeResolver`，如果需要覆盖类型的[default`TypeResolver`]（#execution-grapqlsource-default-type-resolver）。
+
+* 对于字段`DataFetcher`，尽管大多数应用程序只会简单地配置`AnnotatedControllerConfigurer`，其中检测带注释的`DataFetcher`处理程序方法。 Spring 引导启动器默认添加`AnnotatedControllerConfigurer`。
+
+Spring 引导启动器检测类型`RuntimeWiringConfigurer`的 bean，并将它们注册在`GraphQlSource.Builder`中。这意味着，在大多数情况下，在配置中都会有如下内容：
+
+```
+@Configuration
+public class GraphQlConfig {
+
+ @Bean
+ public RuntimeWiringConfigurer runtimeWiringConfigurer(BookRepository repository) {
+
+ GraphQLScalarType scalarType = ... ;
+ SchemaDirectiveWiring directiveWiring = ... ;
+ DataFetcher dataFetcher = QuerydslDataFetcher.builder(repository).single();
+
+ return wiringBuilder -> wiringBuilder
+ .scalar(scalarType)
+ .directiveWiring(directiveWiring)
+ .type("Query", builder -> builder.dataFetcher("book", dataFetcher));
+ }
+}
+
+```
+
+如果需要添加`WiringFactory`，例如，为了使注册考虑到模式定义，实现替代的`configure`方法，该方法同时接受`RuntimeWiring.Builder`和输出`List`。这允许你添加任意数量的工厂，然后按顺序调用这些工厂。
+
+#### [](#execution-graphqlsource-default-type-resolver)4.1.4. 默认`TypeResolver`
+
+`GraphQlSource.Builder`将`ClassNameTypeResolver`注册为默认的`TypeResolver`，用于尚未通过[`RuntimeWiringConfigurer`]进行注册的 GraphQL 接口和联合。在 GraphQL Java 中，`TypeResolver`的目的是确定从`DataFetcher`返回的值的 GraphQL 对象类型，用于 GraphQL 接口或 Union 字段。
+
+`ClassNameTypeResolver`尝试将该值的简单类名与 GraphQL 对象类型匹配，如果不成功，它还会导航其超级类型，包括基类和接口，以寻找匹配。`ClassNameTypeResolver`提供了一个选项，可以将名称提取函数与`Class`一起配置为 GraphQL 对象类型名称映射，这应该有助于覆盖更多的角情况。
+
+#### [](#execution-graphqlsource-operation-caching)4.1.5. 操作缓存
+
+GraphQL Java 在执行操作之前必须*解析*和*验证*。这可能会对业绩产生重大影响。为了避免重新解析和验证的需要，应用程序可以配置一个`PreparsedDocumentProvider`来缓存和重用文档实例。[GraphQL Java DOCS](https://www.graphql-java.com/documentation/execution/#query-caching)通过`PreparsedDocumentProvider`提供有关查询缓存的更多详细信息。
+
+在 Spring GraphQL 中，你可以通过`GraphQlSource.Builder#configureGraphQl`注册一个`PreparsedDocumentProvider`:。
+
+```
+// Typically, accessed through Spring Boot's GraphQlSourceBuilderCustomizer
+GraphQlSource.Builder builder = ...
+
+// Create provider
+PreparsedDocumentProvider provider = ...
+
+builder.schemaResources(..)
+ .configureRuntimeWiring(..)
+ .configureGraphQl(graphQLBuilder -> graphQLBuilder.preparsedDocumentProvider(provider))
+
+```
+
+#### [](#execution-graphqlsource-directives)4.1.6. 指令
+
+GraphQL 语言支持“描述 GraphQL 文档中的替代运行时执行和类型验证行为”的指令。指令类似于 Java 中的注释，但在 GraphQL 文档中对类型、字段、片段和操作进行了声明。
+
+GraphQL Java 提供`SchemaDirectiveWiring`契约来帮助应用程序检测和处理指令。有关更多详细信息，请参见 GraphQL Java 文档中的[模式指令](https://www.graphql-java.com/documentation/sdl-directives/)。
+
+在 Spring GraphQL 中，可以通过[`RuntimeWiringConfigurer`]（#execution-graphqlsource-runtimewilling-configurer）注册`SchemaDirectiveWiring`。 Spring 引导启动器会检测到这样的 bean，因此你可能会有如下内容：
+
+```
+@Configuration
+public class GraphQlConfig {
+
+ @Bean
+ public RuntimeWiringConfigurer runtimeWiringConfigurer() {
+ return builder -> builder.directiveWiring(new MySchemaDirectiveWiring());
+ }
+
+}
+
+```
+
+| |对于指令支持的示例，请查看[GraphQL Java 的扩展验证](https://github.com/graphql-java/graphql-java-extended-validation)库。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### [](#execution-reactive-datafetcher)4.2. Reactive `DataFetcher`
+
+默认的`GraphQlSource`Builder 使对`DataFetcher`的支持返回`Mono`或`Flux`，这将这些支持调整为`CompletableFuture`，其中`Flux`值被聚合并转换为一个列表，除非该请求是 GraphQL 订阅请求，在这种情况下，返回值仍然是用于流式 GraphQL 响应的反应流`Publisher`。
+
+反应性`DataFetcher`可以依赖于对从传输层传播的反应器上下文的访问，例如来自 WebFlux 请求的处理，请参见[WebFlux 上下文](#execution-context-webflux)。
+
+### [](#execution-context)4.3. 执行上下文
+
+Spring 对于 GraphQL 提供了支持，以通过 GraphQL 引擎从[网络传输](#web-transports)透明地传播上下文，并支持`DataFetcher`和它调用的其他组件。这既包括来自 Spring MVC 请求处理线程的`ThreadLocal`上下文，也包括来自 WebFlux 处理管道的反应器`Context`上下文。
+
+#### [](#execution-context-webmvc)4.3.1. WebMVC
+
+GraphQL Java 调用的`DataFetcher`和其他组件可能并不总是在与 Spring MVC 处理程序相同的线程上执行，例如，如果异步[`WebInterceptor`]或`DataFetcher`切换到不同的线程。
+
+Spring 对于 GraphQL 支持将`ThreadLocal`值从 Servlet 容器线程传播到`DataFetcher`线程和由 GraphQL 引擎调用的其他组件上执行。要做到这一点，应用程序需要创建`ThreadLocalAccessor`以提取感兴趣的`ThreadLocal`值：
+
+```
+public class RequestAttributesAccessor implements ThreadLocalAccessor {
+
+ private static final String KEY = RequestAttributesAccessor.class.getName();
+
+ @Override
+ public void extractValues(Map container) {
+ container.put(KEY, RequestContextHolder.getRequestAttributes());
+ }
+
+ @Override
+ public void restoreValues(Map values) {
+ if (values.containsKey(KEY)) {
+ RequestContextHolder.setRequestAttributes((RequestAttributes) values.get(KEY));
+ }
+ }
+
+ @Override
+ public void resetValues(Map values) {
+ RequestContextHolder.resetRequestAttributes();
+ }
+
+}
+
+```
+
+可以在[Webgraphandler](#web-interception)构建器中注册`ThreadLocalAccessor`。引导启动器检测这种类型的 bean 并自动为 Spring MVC 应用程序注册它们，请参见[Web 端点](https://docs.spring.io/spring-boot/docs/2.7.0-SNAPSHOT/reference/html/web.html#web.graphql.web-endpoints)小节。
+
+#### [](#execution-context-webflux)4.3.2. WebFlux
+
+[acceptive`DataFetcher`]（#execution-acceptive-datafetcher）可以依赖于对源自 WebFlux 请求处理链的反应器上下文的访问。这包括由[网络拦截器](#web-interception)组件添加的反应堆上下文。
+
+### [](#execution-exceptions)4.4. 异常解决
+
+GraphQL Java 应用程序可以注册`DataFetcherExceptionHandler`，以决定如何在 GraphQL 响应的“错误”部分中表示来自数据层的异常。
+
+Spring 对于 GraphQL，有一个内置的`DataFetcherExceptionHandler`，它被配置为由[`GraphQLSource`]（#execution-grapqlsource）生成器使用。它使应用程序能够注册一个或多个 Spring `DataFetcherExceptionResolver`按顺序调用的组件，直到将`Exception`解析为`graphql.GraphQLError`对象的列表。
+
+`DataFetcherExceptionResolver`是一种异步契约。对于大多数实现方式，扩展`DataFetcherExceptionResolverAdapter`并覆盖其同步解决异常的`resolveToSingleError`或`resolveToMultipleErrors`方法之一就足够了。
+
+a`GraphQLError`可以被分配一个`graphql.ErrorClassification`。 Spring 对于 GraphQL 定义了一个`ErrorType`枚举，具有常见的、错误的分类类别：
+
+* `BAD_REQUEST`
+
+* `UNAUTHORIZED`
+
+* `FORBIDDEN`
+
+* `NOT_FOUND`
+
+* `INTERNAL_ERROR`
+
+应用程序可以使用它来对错误进行分类。如果错误仍未解决，则默认情况下将其标记为`INTERNAL_ERROR`。
+
+### [](#execution-batching)4.5. 批量装载
+
+给定一个`Book`和它的`Author`，我们可以为一本书创建一个`DataFetcher`，为它的作者创建另一个。这允许在有或没有作者的情况下选择书籍，但这意味着书籍和作者 AREN 不能一起加载，这在查询多本书时效率特别低，因为每本书的作者都是单独加载的。这就是所谓的 N+1 选择问题。
+
+#### [](#execution-batching-dataloader)4.5.1. `DataLoader`
+
+GraphQL Java 提供了一种`DataLoader`机制，用于批量加载相关实体。你可以在[GraphQL Java DOCS](https://www.graphql-java.com/documentation/batching/)中找到完整的详细信息。以下是其工作原理的摘要：
+
+1. 在`DataLoaderRegistry`中注册`DataLoader`的可以加载实体的项，给定唯一的键。
+
+2. `DataFetcher`的可以访问`DataLoader`的，并使用它们通过 ID 加载实体。
+
+3. a`DataLoader`通过返回 future 来延迟加载，因此可以在批处理中完成。
+
+4. `DataLoader`的每请求保持一个加载实体的缓存，这可以进一步提高效率。
+
+#### [](#execution-batching-batch-loader-registry)4.5.2. `BatchLoaderRegistry`
+
+GraphQL Java 中完整的批处理加载机制需要实现几个`BatchLoader`接口中的一个，然后用`DataLoader`中的名称将这些接口包装并注册为`DataLoader`s。
+
+Spring GraphQL 中的 API 略有不同。对于注册，只有一个 central`BatchLoaderRegistry`公开工厂方法和构建器，以创建和注册任意数量的批处理加载函数：
+
+```
+@Configuration
+public class MyConfig {
+
+ public MyConfig(BatchLoaderRegistry registry) {
+
+ registry.forTypePair(Long.class, Author.class).registerMappedBatchLoader((authorIds, env) -> {
+ // return Mono
+ });
+
+ // more registrations ...
+ }
+
+}
+
+```
+
+Spring 引导启动器声明一个`BatchLoaderRegistry` Bean，你可以将其注入到你的配置中，如上面所示，或注入到任何组件中，例如控制器中的顺序寄存器批处理加载功能。然后，将`BatchLoaderRegistry`注入`ExecutionGraphQlService`，从而确保每个请求的注册量`DataLoader`。
+
+默认情况下，`DataLoader`名称是基于目标实体的类名。这允许`@SchemaMapping`方法使用泛型类型声明[Dataloader 参数](#controllers-schema-mapping-data-loader)，而不需要指定名称。但是，如果有必要，可以通过`BatchLoaderRegistry`Builder 自定义名称，以及其他`DataLoader`选项。
+
+对于许多情况，在加载相关实体时，可以使用[@batchmapping](#controllers-batch-mapping)控制器方法，这对于需要使用`BatchLoaderRegistry`和`DataLoader`直接替换的快捷方式也提供了重要的好处。S`BatchLoaderRegistry`也提供了其他好处。它支持从批装载函数和从`@BatchMapping`方法访问相同的`GraphQLContext`，并确保[上下文传播](#execution-context)到它们。这就是为什么应用程序需要使用它。可以直接执行你自己的`DataLoader`注册，但这种注册将放弃上述好处。
+
+#### [](#execution-batching-testing)4.5.3. 测试批装载
+
+首先让`BatchLoaderRegistry`在`DataLoaderRegistry`上执行注册：
+
+```
+BatchLoaderRegistry batchLoaderRegistry = new DefaultBatchLoaderRegistry();
+// perform registrations...
+
+DataLoaderRegistry dataLoaderRegistry = DataLoaderRegistry.newRegistry().build();
+batchLoaderRegistry.registerDataLoaders(dataLoaderRegistry, graphQLContext);
+
+```
+
+现在你可以访问和测试个别`DataLoader`的如下所示：
+
+```
+DataLoader loader = dataLoaderRegistry.getDataLoader(Book.class.getName());
+loader.load(1L);
+loader.loadMany(Arrays.asList(2L, 3L));
+List books = loader.dispatchAndJoin(); // actual loading
+
+assertThat(books).hasSize(3);
+assertThat(books.get(0).getName()).isEqualTo("...");
+// ...
+
+```
+
+## [](#data)5. 数据整合
+
+Spring 对于 GraphQL，你可以利用现有的 Spring 技术，遵循常见的编程模型来通过 GraphQL 公开底层数据源。
+
+本节讨论了用于 Spring 数据的集成层，该集成层提供了一种简单的方法，将 QueryDSL 或查询 by example 存储库调整为`DataFetcher`，包括用于标记为`@GraphQlRepository`的存储库的自动检测和 GraphQL 查询注册的选项。
+
+### [](#data-querydsl)5.1. QueryDSL
+
+Spring 对于 GraphQL 支持使用[Querydsl](http://www.querydsl.com/)来通过 Spring 数据获取数据[QueryDSL 扩展](https://docs.spring.io/spring-data/commons/docs/current/reference/html/#core.extensions)。QueryDSL 提供了一种灵活的 TypeSafe 方法，通过使用注释处理器生成元模型来表示查询谓词。
+
+例如，将存储库声明为`QuerydslPredicateExecutor`:
+
+```
+public interface AccountRepository extends Repository,
+ QuerydslPredicateExecutor {
+}
+
+```
+
+然后使用它创建`DataFetcher`:
+
+```
+// For single result queries
+DataFetcher dataFetcher =
+ QuerydslDataFetcher.builder(repository).single();
+
+// For multi-result queries
+DataFetcher> dataFetcher =
+ QuerydslDataFetcher.builder(repository).many();
+
+```
+
+你现在可以通过[`RuntimeWiringConfigurer`]（#execution-graphqlsource-runtimewilling-configurer）注册上面的`DataFetcher`。
+
+`DataFetcher`从 GraphQL 请求参数构建一个 QueryDSL`Predicate`，并使用它来获取数据。 Spring 对于 JPA、MongoDB 和 LDAP，数据支持`QuerydslPredicateExecutor`。
+
+如果存储库是`ReactiveQuerydslPredicateExecutor`，则构建器返回`DataFetcher>`或`DataFetcher>`。 Spring 数据支持 MongoDB 的这种变体。
+
+#### [](#data-querydsl-build)5.1.1. 构建设置
+
+要在构建中配置 QueryDSL，请遵循[正式参考文件](https://querydsl.com/static/querydsl/latest/reference/html/ch02.html):
+
+例如：
+
+Gradle
+
+```
+dependencies {
+ //...
+
+ annotationProcessor "com.querydsl:querydsl-apt:$querydslVersion:jpa",
+ 'org.hibernate.javax.persistence:hibernate-jpa-2.1-api:1.0.2.Final',
+ 'javax.annotation:javax.annotation-api:1.3.2'
+}
+
+compileJava {
+ options.annotationProcessorPath = configurations.annotationProcessor
+}
+```
+
+Maven
+
+```
+
+
+
+ com.querydsl
+ querydsl-apt
+ ${querydsl.version}
+ jpa
+ provided
+
+
+ org.hibernate.javax.persistence
+ hibernate-jpa-2.1-api
+ 1.0.2.Final
+
+
+ javax.annotation
+ javax.annotation-api
+ 1.3.2
+
+
+
+
+
+ com.mysema.maven
+ apt-maven-plugin
+ ${apt-maven-plugin.version}
+
+
+
+ process
+
+
+ target/generated-sources/java
+ com.querydsl.apt.jpa.JPAAnnotationProcessor
+
+
+
+
+
+```
+
+[WebMVC-HTTP](https://github.com/spring-projects/spring-graphql/tree/main/samples/webmvc-http)样本使用 queryDSL 表示`artifactRepositories`。
+
+#### [](#data-querydsl-customizations)5.1.2. 定制
+
+`QuerydslDataFetcher`支持自定义如何将 GraphQL 参数绑定到属性上以创建 QueryDSL`Predicate`。默认情况下，对于每个可用的属性，参数被绑定为“is equaled to”。要对此进行定制，可以使用`QuerydslDataFetcher`Builder 方法来提供`QuerydslBinderCustomizer`。
+
+存储库本身可能是`QuerydslBinderCustomizer`的实例。这是在[自动注册](#data-querydsl-registration)期间自动检测和透明地应用的。然而，当手动构建`QuerydslDataFetcher`时，你将需要使用 Builder 方法来应用它。
+
+`QuerydslDataFetcher`支持接口和 DTO 投影来转换查询结果，然后返回这些结果进行进一步的 GraphQL 处理。
+
+| |要了解投影是什么，请参阅[Spring Data docs](https://docs.spring.io/spring-data/commons/docs/current/reference/html/#projections)。
要了解如何在 GraphQL 中使用投影，请参见[选择集与投影](#data-projections)。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+要在 QueryDSL 存储库中使用 Spring 数据投影，请创建一个投影接口或一个目标 DTO 类，并通过`projectAs`方法对其进行配置，以获得产生目标类型的`DataFetcher`:
+
+```
+class Account {
+
+ String name, identifier, description;
+
+ Person owner;
+}
+
+interface AccountProjection {
+
+ String getName();
+
+ String getIdentifier();
+}
+
+// For single result queries
+DataFetcher dataFetcher =
+ QuerydslDataFetcher.builder(repository).projectAs(AccountProjection.class).single();
+
+// For multi-result queries
+DataFetcher> dataFetcher =
+ QuerydslDataFetcher.builder(repository).projectAs(AccountProjection.class).many();
+
+```
+
+#### [](#data-querydsl-registration)5.1.3. 自动注册
+
+如果存储库使用`@GraphQlRepository`进行注释，那么对于尚未注册`DataFetcher`且其返回类型与存储库域类型匹配的查询，将自动对其进行注册。这包括单值查询和多值查询。
+
+默认情况下，查询返回的 GraphQL 类型的名称必须与存储库域类型的简单名称匹配。如果需要，可以使用`@GraphQlRepository`的`typeName`属性来指定目标 GraphQL 类型名。
+
+自动注册检测给定存储库是否实现`QuerydslBinderCustomizer`，并通过`QuerydslDataFetcher`Builder 方法透明地应用该方法。
+
+自动注册是通过可从`QuerydslDataFetcher`获得的内置`RuntimeWiringConfigurer`执行的。[引导启动器](https://docs.spring.io/spring-boot/docs/2.7.0-SNAPSHOT/reference/html/web.html#web.graphql.data-query)自动检测`@GraphQlRepository`bean，并使用它们初始化`RuntimeWiringConfigurer`with。
+
+自动注册不支持[定制](#data-querybyexample-customizations)。如果需要，你需要使用`QueryByExampleDataFetcher`通过[`RuntimeWiringConfigurer`]（#execution-graphqlsource-runtimewilling-configurer）手动构建和注册`DataFetcher`。
+
+### [](#data-querybyexample)5.2. 示例查询
+
+Spring 数据支持使用[示例查询](https://docs.spring.io/spring-data/commons/docs/current/reference/html/#query-by-example)来获取数据。Query by Example 是一种简单的查询技术，不需要你通过特定于存储的查询语言编写查询。
+
+从声明`QueryByExampleExecutor`的存储库开始：
+
+```
+public interface AccountRepository extends Repository,
+ QueryByExampleExecutor {
+}
+
+```
+
+使用`QueryByExampleDataFetcher`将存储库转换为`DataFecher`:
+
+```
+// For single result queries
+DataFetcher dataFetcher =
+ QueryByExampleDataFetcher.builder(repository).single();
+
+// For multi-result queries
+DataFetcher> dataFetcher =
+ QueryByExampleDataFetcher.builder(repository).many();
+
+```
+
+你现在可以通过[`RuntimeWiringConfigurer`]注册上面的`DataFetcher`（#execution-graphqlsource-runtimewilling-configurer）。
+
+`DataFetcher`使用 GraphQL 参数映射来创建存储库的域类型，并将其作为示例对象来获取数据。 Spring 对于 JPA、MongoDB、NEO4J 和 Redis，数据支持`QueryByExampleDataFetcher`。
+
+如果存储库是`ReactiveQueryByExampleExecutor`，则构建器返回`DataFetcher>`或`DataFetcher>`。 Spring 数据支持 MongoDB、NEO4J、Redis 和 R2DBC 的这种变体。
+
+#### [](#data-querybyexample-build)5.2.1. 构建设置
+
+Spring 对于支持它的数据存储，示例查询已经包括在 Spring 数据模块中，因此不需要额外的设置来启用它。
+
+#### [](#data-querybyexample-customizations)5.2.2. 定制
+
+`QueryByExampleDataFetcher`支持接口和 DTO 投影来转换查询结果，然后返回这些结果进行进一步的 GraphQL 处理。
+
+| |要了解投影是什么，请参阅[Spring Data documentation](https://docs.spring.io/spring-data/commons/docs/current/reference/html/#projections)。
要了解投影在 GraphQL 中的作用，请参见[选择集与投影](#data-projections)。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+Spring 要通过示例存储库查询使用数据投影，可以创建投影接口或目标 DTO 类，并通过`projectAs`方法对其进行配置，以获得产生目标类型的`DataFetcher`:
+
+```
+class Account {
+
+ String name, identifier, description;
+
+ Person owner;
+}
+
+interface AccountProjection {
+
+ String getName();
+
+ String getIdentifier();
+}
+
+// For single result queries
+DataFetcher dataFetcher =
+ QueryByExampleDataFetcher.builder(repository).projectAs(AccountProjection.class).single();
+
+// For multi-result queries
+DataFetcher> dataFetcher =
+ QueryByExampleDataFetcher.builder(repository).projectAs(AccountProjection.class).many();
+
+```
+
+#### [](#data-querybyexample-registration)5.2.3. 自动注册
+
+如果存储库使用`@GraphQlRepository`进行注释，那么对于尚未注册`DataFetcher`且其返回类型与存储库域类型匹配的查询，将自动对其进行注册。这包括单值查询和多值查询。
+
+默认情况下，查询返回的 GraphQL 类型的名称必须与存储库域类型的简单名称匹配。如果需要，可以使用`@GraphQlRepository`的`typeName`属性来指定目标 GraphQL 类型名。
+
+自动注册是通过可从`QueryByExampleDataFetcher`获得的内置`RuntimeWiringConfigurer`执行的。[引导启动器](https://docs.spring.io/spring-boot/docs/2.7.0-SNAPSHOT/reference/html/web.html#web.graphql.data-query)自动检测`@GraphQlRepository`bean，并使用它们初始化`RuntimeWiringConfigurer`with。
+
+自动注册不支持[定制](#data-querybyexample-customizations)。如果需要，你需要使用`QueryByExampleDataFetcher`通过[`RuntimeWiringConfigurer`]手动构建和注册`DataFetcher`（#execution-grapqlsource-runtimewilling-configurer）。
+
+### [](#data-projections)5.3. 选择集与投影
+
+出现的一个常见问题是，GraphQL 选择集与[Spring Data projections](https://docs.spring.io/spring-data/commons/docs/current/reference/html/#projections)相比如何，每个选择集起什么作用？
+
+简短的回答是， Spring for GraphQL 不是将 GraphQL 查询直接转换为 SQL 或 JSON 查询的数据网关。相反，它允许你利用现有的 Spring 技术，并且不假定 GraphQL 模式和底层数据模型之间存在一对一的映射。这就是为什么客户机驱动的选择和数据模型的服务器端转换可以发挥互补作用的原因。
+
+为了更好地理解，考虑 Spring 数据促进了域驱动（DDD）设计，作为管理数据层中复杂性的推荐方法。在 DDD 中，坚持总量约束是很重要的。根据定义，聚合只有在全部加载的情况下才是有效的，因为部分加载的聚合可能会对聚合功能施加限制。
+
+在 Spring 数据中，你可以选择是希望将聚合按原样公开，还是在将其作为 GraphQL 结果返回之前将转换应用于数据模型。有时，做前者就足够了，默认情况下，[Querydsl](#data-querydsl)和[示例查询](#data-querybyexample)集成将 GraphQL 选择集转换为属性路径提示，底层 Spring 数据模块使用这些属性路径提示来限制选择。
+
+在其他情况下，为了适应 GraphQL 模式，减少甚至转换底层数据模型是有用的。 Spring 数据通过接口和 DTO 投影来支持这一点。
+
+接口投影定义了一组固定的属性，根据数据存储查询结果，在其中属性可以`null`，也可以不是`null`。有两种类型的接口预测，它们都决定从底层数据源加载哪些属性：
+
+* 如果不能部分实现聚合对象，但仍然希望公开属性的子集，则[闭合界面投影](https://docs.spring.io/spring-data/commons/docs/current/reference/html/#projections.interfaces.closed)是有帮助的。
+
+* [开放接口投影](https://docs.spring.io/spring-data/commons/docs/current/reference/html/#projections.interfaces.open)利用 Spring 的`@Value`注释和[SpEL](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#expressions)表达式来应用轻量级数据转换，例如连接、计算或将静态函数应用于属性。
+
+DTO 投影提供了更高级别的定制，因为你可以将转换代码放置在构造函数或 getter 方法中。
+
+DTO 投影是通过查询实现的，查询中的各个属性是由投影本身确定的。DTO 投影通常用于 Full-Args 构造函数（例如 Java 记录），因此只有当所有必需的字段（或列）都是数据库查询结果的一部分时，才能构造它们。
+
+## [](#controllers)6. 带注释的控制器
+
+Spring 对于 GraphQL 提供了一种基于注释的编程模型，其中`@Controller`组件使用注释来声明具有灵活方法签名的处理程序方法，以获取特定 GraphQL 字段的数据。例如：
+
+```
+@Controller
+public class GreetingController {
+
+ @QueryMapping (1)
+ public String hello() { (2)
+ return "Hello, world!";
+ }
+
+}
+
+```
+
+|**1**|将此方法绑定到查询，即查询类型下的字段。|
+|-----|---------------------------------------------------------------------------|
+|**2**|如果未在注释上声明，则从方法名确定查询。|
+
+Spring 对于 GraphQL 使用`RuntimeWiring.Builder`将上述处理程序方法注册为用于名为“Hello”的查询的`graphql.schema.DataFetcher`。
+
+### [](#controllers-declaration)6.1. 声明
+
+你可以将`@Controller`bean 定义为标准 Spring Bean 定义。该`@Controller`原型允许自动检测，与 Spring 对齐，用于在 Classpath 上检测`@Controller`和`@Component`类并为它们自动注册 Bean 定义。它还充当带注释的类的原型，指示其作为 GraphQL 应用程序中的数据获取组件的角色。
+
+`AnnotatedControllerConfigurer`通过`RuntimeWiring.Builder`检测`@Controller`bean 并将其注释的处理程序方法注册为`DataFetcher`s。它是`RuntimeWiringConfigurer`的一个实现，它可以被添加到`GraphQlSource.Builder`中。 Spring 引导启动器会自动将`AnnotatedControllerConfigurer`声明为 Bean，并将所有`RuntimeWiringConfigurer`bean 添加到`GraphQlSource.Builder`中，从而支持带注释的`DataFetcher`s，请参见引导启动器文档中的[GraphQL RuntimeWiring](https://docs.spring.io/spring-boot/docs/2.7.0-SNAPSHOT/reference/html/web.html#web.graphql.runtimewiring)部分。
+
+### [](#controllers-schema-mapping)6.2. `@SchemaMapping`
+
+`@SchemaMapping`注释将处理程序方法映射到 GraphQL 模式中的字段，并声明该字段为该字段的`DataFetcher`。注释可以指定父类型名和字段名：
+
+```
+@Controller
+public class BookController {
+
+ @SchemaMapping(typeName="Book", field="author")
+ public Author getAuthor(Book book) {
+ // ...
+ }
+}
+
+```
+
+`@SchemaMapping`注释也可以省略这些属性，在这种情况下，字段名称默认为方法名称，而类型名称默认为注入到方法中的源/父对象的简单类名。例如，以下默认输入“book”和字段“author”：
+
+```
+@Controller
+public class BookController {
+
+ @SchemaMapping
+ public Author author(Book book) {
+ // ...
+ }
+}
+
+```
+
+可以在类级别声明`@SchemaMapping`注释，以指定类中所有处理程序方法的默认类型名。
+
+```
+@Controller
+@SchemaMapping(typeName="Book")
+public class BookController {
+
+ // @SchemaMapping methods for fields of the "Book" type
+
+}
+
+```
+
+`@QueryMapping`、`@MutationMapping`和`@SubscriptionMapping`是元注释，它们本身用`@SchemaMapping`进行注释，并且将类型名称预设为`Query`、`Mutation`或`Subscription`。实际上，这些是分别针对查询、突变和订阅类型下的字段的快捷方式注释。例如：
+
+```
+@Controller
+public class BookController {
+
+ @QueryMapping
+ public Book bookById(@Argument Long id) {
+ // ...
+ }
+
+ @MutationMapping
+ public Book addBook(@Argument BookInput bookInput) {
+ // ...
+ }
+
+ @SubscriptionMapping
+ public Flux newPublications() {
+ // ...
+ }
+}
+
+```
+
+`@SchemaMapping`处理程序方法具有灵活的签名，可以从一系列方法参数和返回值中进行选择。
+
+#### [](#controllers-schema-mapping-signature)6.2.1. 方法签名
+
+模式映射处理程序方法可以具有以下任何一个方法参数：
+
+| Method Argument |说明|
+|-------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `@Argument` |要访问将命名字段参数转换为更高级别的类型化对象。
请参见[`@Argument`]（#controllers-schema-mapping-convention）。|
+| `@Arguments` |有关对转换为更高级别的类型化对象的所有字段参数的访问。
参见[`@Arguments`]（#controllers-schema-mapping-arguments）。|
+| `@ProjectedPayload` Interface |通过项目接口访问字段参数。
参见[`@ProjectPayload`接口]（#controllers-schema-mapping-projectedpayload-pargument）。|
+| Source |关于字段的源（即父/容器）实例的访问。
参见[Source](#controllers-schema-mapping-source)。|
+| `DataLoader` |要访问`DataLoader`中的`DataLoader`。
请参见[`DataLoader`]（#controllers-schema-mapping-data-loader）。|
+| `@ContextValue` |对于从 localContext 访问一个值，如果它是`GraphQLContext`、
的实例，或者来自`GraphQLContext`的`DataFetchingEnvironment`的实例。|
+| `GraphQLContext` |用于从`DataFetchingEnvironment`访问上下文。|
+| `java.security.Principal` |从 Spring 安全上下文中获得的，如果可用的话。|
+| `@AuthenticationPrincipal` |用于从 Spring 安全上下文访问`Authentication#getPrincipal()`。|
+|`DataFetchingFieldSelectionSet`|用于通过`DataFetchingEnvironment`访问查询的选择集。|
+| `Locale`, `Optional` |从`DataFetchingEnvironment`访问`Locale`。|
+| `DataFetchingEnvironment` |直接访问底层`DataFetchingEnvironment`。|
+
+模式映射处理程序方法可以返回任意值，包括反应器`Mono`和`Flux`中描述的[ractive`DataFetcher`]（#execution-ractive-datafetcher）。
+
+#### [](#controllers-schema-mapping-argument)6.2.2. `@Argument`
+
+在 GraphQL Java 中，`DataFetchingEnvironment`提供对特定字段参数值的映射的访问。这些值可以是简单的标量值（例如 String，long）、用于更复杂输入的`Map`的值，或者是`List`的值。
+
+使用`@Argument`注释将命名字段参数注入到处理程序方法中。方法参数可以是任何类型的更高级别的类型化对象。它是根据已命名字段参数的值创建和初始化的，或者将它们匹配到单个数据构造函数参数，或者使用默认构造函数，然后通过`org.springframework.validation.DataBinder`将键匹配到对象属性上：
+
+```
+@Controller
+public class BookController {
+
+ @QueryMapping
+ public Book bookById(@Argument Long id) {
+ // ...
+ }
+
+ @MutationMapping
+ public Book addBook(@Argument BookInput bookInput) {
+ // ...
+ }
+}
+
+```
+
+默认情况下，如果方法参数名是可用的（需要`-parameters`带有 Java8+ 或来自编译器的调试信息的编译器标志），它将用于查找参数。如果需要，可以通过注释自定义名称，例如`@Argument("bookInput")`。
+
+| |`@Argument`注释没有“required”标志，也没有
指定默认值的选项。这两个都可以在 GraphQL 模式级别指定，
由 GraphQL 引擎强制执行。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+你可以在`Map`参数上使用`@Argument`，以获得所有参数的值。不能设置`@Argument`上的 name 属性。
+
+#### [](#controllers-schema-mapping-arguments)6.2.3. `@Arguments`
+
+如果你想将完整的参数映射到单个目标对象上，请使用`@Arguments`注释，与`@Argument`相反，后者绑定一个特定的命名参数。
+
+例如，`@Argument BookInput bookInput`使用参数“bookinput”的值初始化`BookInput`，而`@Arguments`使用完整的参数映射，在这种情况下，顶层参数绑定到`BookInput`属性。
+
+#### [](#controllers-schema-mapping-validation)6.2.4. `@Argument(s)`验证
+
+如果在应用程序上下文中存在一个[Bean Validation](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#validation-beanvalidation-overview)`Validator`（或者通常，一个`LocalValidatorFactoryBean`） Bean，则`AnnotatedControllerConfigurer`将自动检测它并配置用于验证的支持。然后在方法调用之前验证用`@Valid`和`@Validated`注释的控制器参数。
+
+Bean 验证允许你声明对类型的约束，如下例所示：
+
+```
+public class BookInput {
+
+ @NotNull
+ private String title;
+
+ @NotNull
+ @Size(max=13)
+ private String isbn;
+}
+
+```
+
+然后，我们可以用`@Valid`标记我们的验证参数：
+
+```
+@Controller
+public class BookController {
+
+ @MutationMapping
+ public Book addBook(@Argument @Valid BookInput bookInput) {
+ // ...
+ }
+}
+
+```
+
+如果在验证过程中发生错误，将抛出一个`ConstraintViolationException`，并可以在以后[使用自定义`DataFetcherExceptionResolver`解决]（#execution-exceptions）。
+
+| |与 Spring MVC 不同，处理程序方法签名不支持注入`BindingResult`以对验证错误做出反应：这些将作为例外情况在全局范围内处理。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+#### [](#controllers-schema-mapping-projectedpayload-argument)6.2.5. `@ProjectPayload`接口
+
+作为使用带有[`@Argument`]（#controllers-schema-mapping-argument）的完整对象的一种替代方法，你还可以使用投影接口通过定义良好的最小接口访问 GraphQL 请求参数。当 Spring 数据在类路径上时，参数投影由[Spring Data’s Interface projections](https://docs.spring.io/spring-data/commons/docs/current/reference/html/#projections.interfaces)提供。
+
+要利用这一点，请创建一个带有`@ProjectedPayload`注释的接口，并将其声明为控制器方法参数。如果参数被注释为`@Argument`，则它将应用于`DataFetchingEnvironment.getArguments()`映射中的单个参数。当声明时不带`@Argument`，投影工作于完整参数映射中的顶层参数。
+
+例如：
+
+```
+@Controller
+public class BookController {
+
+ @QueryMapping
+ public Book bookById(BookIdProjection bookId) {
+ // ...
+ }
+
+ @MutationMapping
+ public Book addBook(@Argument BookInputProjection bookInput) {
+ // ...
+ }
+}
+
+@ProjectedPayload
+interface BookIdProjection {
+
+ Long getId();
+}
+
+@ProjectedPayload
+interface BookInputProjection {
+
+ String getName();
+
+ @Value("#{target.author + ' ' + target.name}")
+ String getAuthorAndName();
+}
+
+```
+
+#### [](#controllers-schema-mapping-source)6.2.6. 来源
+
+在 GraphQL Java 中，`DataFetchingEnvironment`提供对字段的源（即父/容器）实例的访问。要访问它，只需声明一个预期目标类型的方法参数。
+
+```
+@Controller
+public class BookController {
+
+ @SchemaMapping
+ public Author author(Book book) {
+ // ...
+ }
+}
+
+```
+
+源方法参数还有助于确定映射的类型名。如果 Java 类的简单名称与 GraphQL 类型匹配，则不需要在`@SchemaMapping`注释中显式指定类型名称。
+
+| |[`@BatchMapping`]（#controllers-batch-mapping）处理程序方法可以为一个查询批装载所有作者，
给定源/父书对象的列表。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+#### [](#controllers-schema-mapping-data-loader)6.2.7. `DataLoader`
+
+当你注册一个实体的批处理加载函数时，如[批量装载](#execution-batching)中所解释的那样，你可以通过声明一个类型为`DataLoader`的方法参数来访问该实体的`DataLoader`，并使用它来加载该实体：
+
+```
+@Controller
+public class BookController {
+
+ public BookController(BatchLoaderRegistry registry) {
+ registry.forTypePair(Long.class, Author.class).registerMappedBatchLoader((authorIds, env) -> {
+ // return Map
+ });
+ }
+
+ @SchemaMapping
+ public CompletableFuture author(Book book, DataLoader loader) {
+ return loader.load(book.getAuthorId());
+ }
+
+}
+
+```
+
+默认情况下，`BatchLoaderRegistry`使用值类型的完整类名（例如，`Author`的类名）作为注册的键，因此只需声明带有泛型类型的`DataLoader`方法参数，就可以提供足够的信息来在`DataLoaderRegistry`中定位它。作为后备，`DataLoader`方法参数解析器也将尝试方法参数名称作为键，但通常不需要这样做。
+
+请注意，对于许多加载相关实体的情况，其中`@SchemaMapping`只是将其委托给`DataLoader`，你可以使用[@batchmapping](#controllers-batch-mapping)方法来减少样板文件，如下一节所述。
+
+### [](#controllers-batch-mapping)6.3. `@BatchMapping`
+
+[批量装载](#execution-batching)通过使用`org.dataloader.DataLoader`来延迟单个实体实例的加载，从而解决了 N+1SELECT 问题，从而可以将它们一起加载。例如：
+
+```
+@Controller
+public class BookController {
+
+ public BookController(BatchLoaderRegistry registry) {
+ registry.forTypePair(Long.class, Author.class).registerMappedBatchLoader((authorIds, env) -> {
+ // return Map
+ });
+ }
+
+ @SchemaMapping
+ public CompletableFuture author(Book book, DataLoader loader) {
+ return loader.load(book.getAuthorId());
+ }
+
+}
+
+```
+
+对于加载关联实体的简单情况（如上图所示），`@SchemaMapping`方法所做的不过是将其委托给`DataLoader`。这是用`@BatchMapping`方法可以避免的样板。例如：
+
+```
+@Controller
+public class BookController {
+
+ @BatchMapping
+ public Mono> author(List books) {
+ // ...
+ }
+}
+
+```
+
+上面变成了`BatchLoaderRegistry`中的批处理加载函数，其中键是`Book`实例和加载的值它们的作者。此外，`DataFetcher`也透明地绑定到类型`author`的`author`字段，对于作者来说，它只是将其委托给`DataLoader`，给定其源/父`Book`实例。
+
+| |要作为唯一键使用，`Book`必须实现`hashcode`和`equals`。|
+|---|--------------------------------------------------------------------------|
+
+默认情况下，字段名称默认为方法名称，而类型名称默认为输入`List`元素类型的简单类名。两者都可以通过注释属性进行定制。类型名也可以从类级别`@SchemaMapping`继承。
+
+#### [](#controllers-batch-mapping-signature)6.3.1. 方法签名
+
+批处理映射方法支持以下参数：
+
+| Method Argument |说明|
+|-------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `List` |源/父对象。|
+|`java.security.Principal`|从 Spring 安全上下文获得（如果可用的话）。|
+| `@ContextValue` |要访问来自`GraphQLContext`的`BatchLoaderEnvironment`的值，请使用
，该上下文与来自`DataFetchingEnvironment`的上下文相同。|
+| `GraphQLContext` |要访问来自`BatchLoaderEnvironment`的上下文，请访问
，该上下文与来自`DataFetchingEnvironment`的上下文相同。|
+|`BatchLoaderEnvironment` |在 GraphQL Java 中可用的环境为`org.dataloader.BatchLoaderWithContext`。|
+
+批处理映射方法可以返回：
+
+| Return Type |说明|
+|---------------------|--------------------------------------------------------------------------------------------------------------------------|
+| `Mono>` |以父对象为键，以批处理加载对象为值的映射。|
+| `Flux` |批装载对象的序列，其顺序必须与传递到方法中的源/父
对象的顺序相同。|
+|`Map`, `List`|命令式变体，例如，不需要进行远程调用。|
+
+## [](#security)7. 安全
+
+可以使用 HTTP URL 安全性来保护[Web](#web-transports)GraphQL 端点的路径，以确保只有经过身份验证的用户才能访问它。然而，这并不能区分在单个 URL 上的共享端点上的不同 GraphQL 请求。
+
+要应用更细粒度的安全性，可以在获取 GraphQL 响应的特定部分所涉及的服务方法中添加 Spring 安全性注释，例如`@PreAuthorize`或`@Secured`。由于[上下文传播](#execution-context)的目的是使安全性和其他上下文在数据获取级别可用，所以这种方法应该有效。
+
+Spring for GraphQL 存储库包含[Spring MVC](https://github.com/spring-projects/spring-graphql/tree/main/samples/webmvc-http-security)和[WebFlux](https://github.com/spring-projects/spring-graphql/tree/main/samples/webflux-security)的示例。
+
+## [](#testing)8. 测试
+
+用 Spring 的`WebTestClient`测试 GraphQL 请求是可能的，只需要发送和接收 JSON，但是许多 GraphQL 特定的细节使得这种方法比必要的更麻烦。
+
+要获得完整的测试支持，你需要在构建中添加`spring-graphql-test`依赖项：
+
+Gradle
+
+```
+dependencies {
+ // ...
+ testImplementation 'org.springframework.graphql:spring-graphql-test:1.0.0-SNAPSHOT'
+}
+```
+
+Maven
+
+```
+
+
+
+ org.springframework.graphql
+ spring-graphql-test
+ 1.0.0-SNAPSHOT
+ test
+
+
+```
+
+### [](#testing-graphqltester)8.1. `GraphQlTester`
+
+`GraphQlTester`定义了一个工作流，用于测试 GraphQL 请求，该工作流具有以下优点：
+
+* 在响应中的“errors”键下验证没有意外错误。
+
+* 在响应中的“数据”键下进行解码。
+
+* 使用 JSONPath 来解码响应的不同部分。
+
+* 测试订阅。
+
+要创建`GraphQlTester`，只需要一个`GraphQlService`，并且不需要传输：
+
+```
+GraphQlSource graphQlSource = GraphQlSource.builder()
+ .schemaResources(...)
+ .runtimeWiringConfigurer(...)
+ .build();
+
+GraphQlService graphQlService = new ExecutionGraphQlService(graphQlSource);
+
+GraphQlTester graphQlTester = GraphQlTester.builder(graphQlService).build();
+
+```
+
+### [](#testing-webgraphqltester)8.2. `WebGraphQlTester`
+
+`WebGraphQlTester`扩展`GraphQlTester`以添加特定于[网络传输](#web-transports)的工作流和配置，并且它始终验证 GraphQL HTTP 响应是 200（OK）。
+
+要创建`WebGraphQlTester`，你需要以下输入之一：
+
+* `WebTestClient`——作为 HTTP 客户机执行请求，或者针对没有服务器的[HTTP](#web-http)处理程序，或者针对活动服务器。
+
+* `WebGraphQlHandler`——通过[网络拦截](#web-interception)和[WebSocket](#web-websocket)处理程序都使用的[网络拦截](#web-interception)链执行请求，这实际上是在没有 Web 框架的情况下进行的测试。使用这个的一个原因是[订阅](#testing-subscriptions)。
+
+对于没有服务器的 Spring WebFlux，你可以指向你的 Spring 配置：
+
+```
+ApplicationContext context = ... ;
+
+WebTestClient client =
+ WebTestClient.bindToApplicationContext(context)
+ .configureClient()
+ .baseUrl("/graphql")
+ .build();
+
+WebGraphQlTester tester = WebGraphQlTester.builder(client).build();
+
+```
+
+对于没有服务器的 Spring MVC，使用`MockMvcWebTestClient`的方法是相同的：
+
+```
+WebApplicationContext context = ... ;
+
+WebTestClient client =
+ MockMvcWebTestClient.bindToApplicationContext(context)
+ .configureClient()
+ .baseUrl("/graphql")
+ .build();
+
+WebGraphQlTester tester = WebGraphQlTester.builder(client).build();
+
+```
+
+对运行中的实时服务器进行测试：
+
+```
+WebTestClient client =
+ WebTestClient.bindToServer()
+ .baseUrl("http://localhost:8080/graphql")
+ .build();
+
+WebGraphQlTester tester = WebGraphQlTester.builder(client).build();
+
+```
+
+`WebGraphQlTester`支持设置 HTTP 请求标头和访问 HTTP 响应标头。这对于检查或设置与安全性相关的标题可能很有用。
+
+```
+this.graphQlTester.queryName("{ myQuery }")
+ .httpHeaders(headers -> headers.setBasicAuth("rob", "..."))
+ .execute()
+ .httpHeadersSatisfy(headers -> {
+ // check response headers
+ })
+ .path("myQuery.field1").entity(String.class).isEqualTo("value1")
+ .path("myQuery.field2").entity(String.class).isEqualTo("value2");
+
+```
+
+你还可以在构建器级别设置默认的请求标题：
+
+```
+WebGraphQlTester tester = WebGraphQlTester.builder(client)
+ .defaultHttpHeaders(headers -> headers.setBasicAuth("rob", "..."))
+ .build();
+
+```
+
+### [](#testing-queries)8.3. 查询
+
+下面是一个使用[JsonPath](https://github.com/json-path/JsonPath)提取 GraphQL 响应中所有发布版本的示例查询测试。
+
+```
+String query = "{" +
+ " project(slug:\"spring-framework\") {" +
+ " releases {" +
+ " version" +
+ " }"+
+ " }" +
+ "}";
+
+graphQlTester.query(query)
+ .execute()
+ .path("project.releases[*].version")
+ .entityList(String.class)
+ .hasSizeGreaterThan(1);
+
+```
+
+JSONPath 是相对于响应的“数据”部分的。
+
+还可以在 Classpath 上的`"graphql/"`下创建扩展名为`.graphql`或`.gql`的查询文件，并通过文件名引用它们。例如，给定一个名为`projectReleases.graphql`in`src/main/resources/graphql`的文件，其内容如下：
+
+```
+query projectReleases($slug: ID!) {
+ project(slug: $slug) {
+ releases {
+ version
+ }
+ }
+}
+```
+
+你可以编写相同的测试，如下所示：
+
+```
+graphQlTester.queryName("projectReleases") (1)
+ .variable("slug", "spring-framework") (2)
+ .execute()
+ .path("project.releases[*].version")
+ .entityList(String.class)
+ .hasSizeGreaterThan(1);
+
+```
+
+|**1**|请参阅名为“ProjectReleases”的文件中的查询。|
+|-----|-------------------------------------------------------|
+|**2**|设置`slug`变量。|
+
+| |IntelliJ 的“JS GraphQL”插件支持带有代码补全功能的 GraphQL 查询文件。|
+|---|---------------------------------------------------------------------------------------|
+
+### [](#testing-errors)8.4. 错误
+
+当响应中的“错误”键下有错误时，验证将不会成功。
+
+如果有必要忽略错误，请使用错误过滤器`Predicate`:
+
+```
+graphQlTester.query(query)
+ .execute()
+ .errors()
+ .filter(error -> ...)
+ .verify()
+ .path("project.releases[*].version")
+ .entityList(String.class)
+ .hasSizeGreaterThan(1);
+
+```
+
+错误筛选器可以全局注册并应用于所有测试：
+
+```
+WebGraphQlTester graphQlTester = WebGraphQlTester.builder(client)
+ .errorFilter(error -> ...)
+ .build();
+
+```
+
+或者预期会出现错误，与`filter`相反，如果响应中不存在断言错误，则抛出该断言错误：
+
+```
+graphQlTester.query(query)
+ .execute()
+ .errors()
+ .expect(error -> ...)
+ .verify()
+ .path("project.releases[*].version")
+ .entityList(String.class)
+ .hasSizeGreaterThan(1);
+
+```
+
+或直接检查所有错误，并将其标记为已过滤的：
+
+```
+graphQlTester.query(query)
+ .execute()
+ .errors()
+ .satisfy(errors -> {
+ // ...
+ });
+
+```
+
+如果请求没有任何响应数据（例如，突变），请使用`executeAndVerify`而不是`execute`来验证响应中没有错误：
+
+```
+graphQlTester.query(query).executeAndVerify();
+
+```
+
+### [](#testing-subscriptions)8.5. 订阅
+
+`executeSubscription`方法定义了一个特定于订阅的工作流，该工作流将返回一个响应流，而不是单个响应。
+
+要测试订阅，你可以使用`GraphQlTester`创建`GraphQlService`，它直接调用`graphql.GraphQL`，并返回一个响应流：
+
+```
+GraphQlService service = ... ;
+
+GraphQlTester graphQlTester = GraphQlTester.builder(service).build();
+
+Flux result = graphQlTester.query("subscription { greetings }")
+ .executeSubscription()
+ .toFlux("greetings", String.class); // decode each response
+
+```
+
+来自 Project Reactor 的对于验证流是有用的：
+
+```
+Flux result = graphQlTester.query("subscription { greetings }")
+ .executeSubscription()
+ .toFlux("greetings", String.class);
+
+StepVerifier.create(result)
+ .expectNext("Hi")
+ .expectNext("Bonjour")
+ .expectNext("Hola")
+ .verifyComplete();
+
+```
+
+要测试[网络拦截](#web-interception)链，你可以使用`WebGraphQlHandler`创建`WebGraphQlTester`:
+
+```
+GraphQlService service = ... ;
+
+WebGraphQlHandler handler = WebGraphQlHandler.builder(service)
+ .interceptor((input, next) -> next.handle(input))
+ .build();
+
+WebGraphQlTester graphQlTester = WebGraphQlTester.builder(handler).build();
+
+```
+
+目前， Spring for GraphQL 不支持使用 WebSocket 客户端进行测试，并且它不能用于在 WebSocket 请求上对 GraphQL 进行集成测试。
+
+## [](#samples)9. 样本
+
+Spring 对于 GraphQL 存储库，针对各种场景包含[示例应用程序](https://github.com/spring-projects/spring-graphql/tree/main/samples)。
+
+你可以通过克隆此存储库并从你的 IDE 中运行主应用程序类，或者通过在命令行中键入以下内容来运行这些应用程序：
+
+```
+$ ./gradlew :samples:{sample-directory-name}:bootRun
+```
\ No newline at end of file
diff --git a/docs/spring-security/community.md b/docs/spring-security/community.md
new file mode 100644
index 0000000000000000000000000000000000000000..c7d448915d38ed6dc7d197e5aa896fbdfbcef0c3
--- /dev/null
+++ b/docs/spring-security/community.md
@@ -0,0 +1,31 @@
+# Spring 安全共同体
+
+欢迎来到 Spring 安全社区！本节讨论如何充分利用我们庞大的社区。
+
+## 获得帮助
+
+如果你在安全方面需要帮助，我们会提供帮助。以下是获得帮助的一些最佳方式：
+
+* 通读这份文件。
+
+* 试试我们的许多[示例应用程序](samples.html#samples)中的一个。
+
+* 用`spring-security`标记在[https://stackoverflow.com](https://stackoverflow.com/questions/tagged/spring-security)上提问。
+
+* 在[https://github.com/spring-projects/spring-security/issues](https://github.com/spring-projects/spring-security/issues)上报告错误和增强请求
+
+## 参与
+
+我们欢迎你参与 Spring 安全项目。有很多方法可以帮助你，包括回答有关堆栈溢出的问题，编写新代码，改进现有代码，协助编写文档，开发示例或教程，报告错误，或者只是提出建议。有关更多信息，请参见我们的[贡献](https://github.com/spring-projects/spring-security/blob/main/CONTRIBUTING.adoc)文档。
+
+## 源代码
+
+你可以在 GitHub 上找到 Spring Security 的源代码，网址为[https://github.com/spring-projects/spring-security/](https://github.com/spring-projects/spring-security/)
+
+## Apache 2 许可证
+
+Spring 安全性是在[Apache 2.0 license](https://www.apache.org/licenses/LICENSE-2.0.html)下发布的开源软件。
+
+## 社交媒体
+
+你可以在 Twitter 上关注[@SpringSecurity](https://twitter.com/SpringSecurity)和[Spring Security team](https://twitter.com/SpringSecurity/lists/team)，了解最新消息。你还可以跟踪[@SpringCentral](https://twitter.com/SpringCentral)，以了解整个 Spring 投资组合的最新情况。
\ No newline at end of file
diff --git a/docs/spring-security/features-authentication-password-storage.md b/docs/spring-security/features-authentication-password-storage.md
new file mode 100644
index 0000000000000000000000000000000000000000..faecef658040c8984b494aa9069faa6604590b12
--- /dev/null
+++ b/docs/spring-security/features-authentication-password-storage.md
@@ -0,0 +1,445 @@
+# 密码存储
+
+Spring Security 的`PasswordEncoder`接口用于执行密码的单向转换，以允许安全地存储密码。给定`PasswordEncoder`是单向转换，当密码转换需要双向（即存储用于对数据库进行身份验证的凭据）时，并不打算这样做。通常`PasswordEncoder`用于存储需要与用户在身份验证时提供的密码进行比较的密码。
+
+## 密码存储历史
+
+多年来，存储密码的标准机制一直在发展。在开始的时候，密码是用纯文本格式存储的。这些密码被认为是安全的，因为数据存储中的密码被保存在访问它所需的凭据中。然而，恶意用户能够通过 SQL 注入等攻击，找到获取大量用户名和密码的“数据转储”的方法。随着越来越多的用户证书成为公共安全专家意识到，我们需要做更多的工作来保护用户的密码。
+
+然后鼓励开发人员在通过 SHA-256 等单向散列运行密码后存储密码。当用户试图进行身份验证时，会将散列密码与他们键入的密码的散列进行比较。这意味着系统只需要存储密码的单向散列。如果发生了漏洞，那么只会公开密码的单向散列。由于散列是一种方式，并且在计算上很难猜测给定散列的密码，因此不值得花费精力来计算系统中的每个密码。为了击败这个新系统，恶意用户决定创建名为[彩虹桌](https://en.wikipedia.org/wiki/Rainbow_table)的查找表。他们不是每次都猜测每个密码，而是计算一次密码并将其存储在查找表中。
+
+为了降低 Rainbow 表的有效性，鼓励开发人员使用盐渍密码。不再只使用密码作为散列函数的输入，而是为每个用户的密码生成随机字节（称为 salt）。SALT 和用户的密码将通过散列函数运行，该函数将生成一个唯一的散列。这种盐将与用户的密码一起以明文形式存储。然后，当用户试图进行身份验证时，散列密码将与存储的盐的散列和他们输入的密码进行比较。独特的盐意味着彩虹表格不再有效，因为每种盐和密码组合的散列值都不同。
+
+在现代，我们意识到加密散列（如 SHA-256）不再安全。原因在于，有了现代硬件，我们每秒钟可以进行数十亿次散列计算。这意味着我们可以轻松地单独破解每个密码。
+
+现在鼓励开发人员利用自适应单向功能来存储密码。具有自适应单向功能的密码的验证是有意的资源密集型的（如 CPU、内存等）。一个自适应的单向功能允许配置一个“工作因素”，可以随着硬件变得更好而增长。建议将“工作因子”调整为在系统上验证密码所需的时间约为 1 秒。这样做的代价是让攻击者很难破解密码，但也不会因为代价太高而给自己的系统带来过大的负担。 Spring 安全性已经尝试为“工作因素”提供了一个很好的起点，但是鼓励用户为自己的系统定制“工作因素”，因为系统之间的性能会有很大的差异。应该使用的自适应单向函数的示例包括[bcrypt](#authentication-password-storage-bcrypt)、[PBKDF2](#authentication-password-storage-pbkdf2)、[scrypt](#authentication-password-storage-scrypt)和[argon2](#authentication-password-storage-argon2)。
+
+由于自适应单向函数是故意的资源密集型的，因此为每个请求验证用户名和密码将大大降低应用程序的性能。 Spring 安全性（或任何其他库）不能做任何事情来加速密码的验证，因为安全性是通过使验证资源密集型来获得的。鼓励用户将长期凭据（即用户名和密码）交换为短期凭据（即会话、OAuth 令牌等）。短期凭据可以被快速验证，而不会损失任何安全性。
+
+## PasswordEncoder
+
+在 Spring Security5.0 之前，默认的`PasswordEncoder`是`NoOpPasswordEncoder`，它需要纯文本密码。基于[密码历史记录](#authentication-password-storage-history)部分，你可能认为默认的`PasswordEncoder`现在类似于`bcryptpasswordencoder`。然而，这忽略了三个现实世界中的问题：
+
+* 有许多应用程序使用旧的密码编码，无法轻松地进行迁移。
+
+* 密码存储的最佳实践将再次改变。
+
+* 作为一种框架 Spring，安全不能频繁地进行破坏更改
+
+Spring 安全性引入了`DelegatingPasswordEncoder`，它通过以下方式解决了所有问题：
+
+* 确保使用当前的密码存储建议对密码进行编码
+
+* 允许验证现代和遗留格式的密码。
+
+* 允许在将来升级编码
+
+你可以使用`PasswordEncoderFactories`轻松地构造`DelegatingPasswordEncoder`的实例。
+
+例 1。创建默认的代理 PasswordEncoder
+
+爪哇
+
+```
+PasswordEncoder passwordEncoder =
+ PasswordEncoderFactories.createDelegatingPasswordEncoder();
+```
+
+Kotlin
+
+```
+val passwordEncoder: PasswordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder()
+```
+
+或者，你可以创建自己的自定义实例。例如：
+
+例 2。创建自定义代理 PasswordEncoder
+
+爪哇
+
+```
+String idForEncode = "bcrypt";
+Map encoders = new HashMap<>();
+encoders.put(idForEncode, new BCryptPasswordEncoder());
+encoders.put("noop", NoOpPasswordEncoder.getInstance());
+encoders.put("pbkdf2", new Pbkdf2PasswordEncoder());
+encoders.put("scrypt", new SCryptPasswordEncoder());
+encoders.put("sha256", new StandardPasswordEncoder());
+
+PasswordEncoder passwordEncoder =
+ new DelegatingPasswordEncoder(idForEncode, encoders);
+```
+
+Kotlin
+
+```
+val idForEncode = "bcrypt"
+val encoders: MutableMap = mutableMapOf()
+encoders[idForEncode] = BCryptPasswordEncoder()
+encoders["noop"] = NoOpPasswordEncoder.getInstance()
+encoders["pbkdf2"] = Pbkdf2PasswordEncoder()
+encoders["scrypt"] = SCryptPasswordEncoder()
+encoders["sha256"] = StandardPasswordEncoder()
+
+val passwordEncoder: PasswordEncoder = DelegatingPasswordEncoder(idForEncode, encoders)
+```
+
+### 密码存储格式
+
+密码的一般格式是：
+
+例 3。passwordencoder 存储格式
+
+```
+{id}encodedPassword
+```
+
+使得`id`是用于查找应该使用`PasswordEncoder`的标识符，而`encodedPassword`是所选`PasswordEncoder`的原始编码密码。`id`必须位于密码的开头，以`{`开头，以`}`结尾。如果不能找到`id`，则`id`将为空。例如，以下可能是使用不同的`id`编码的密码列表。所有的原始密码都是“密码”。
+
+例 4。代理 PasswordEncoder 编码的密码示例
+
+```
+{bcrypt}$2a$10$dXJ3SW6G7P50lGmMkkmwe.20cQQubK3.HZWzG3YB1tlRy.fqvM/BG (1)
+{noop}password (2)
+{pbkdf2}5d923b44a6d129f3ddf3e3c8d29412723dcbde72445e8ef6bf3b508fbf17fa4ed4d6b99ca763d8dc (3)
+{scrypt}$e0801$8bWJaSu2IKSn9Z9kM+TPXfOc/9bdYSrN1oD9qfVThWEwdRTnO7re7Ei+fUZRJ68k9lTyuTeUp4of4g24hHnazw==$OAOec05+bXxvuu/1qZ6NUR+xQYvYv7BeL1QxwRpY5Pc= (4)
+{sha256}97cde38028ad898ebc02e690819fa220e88c62e0699403e94fff291cfffaf8410849f27605abcbc0 (5)
+```
+
+|**1**|第一个密码的`PasswordEncoder`ID 为`bcrypt`，编码密码为`$2a$10$dXJ3SW6G7P50lGmMkkmwe.20cQQubK3.HZWzG3YB1tlRy.fqvM/BG`。
匹配时，将委托给`BCryptPasswordEncoder`|
+|-----|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|**2**|第二个密码的`PasswordEncoder`ID 为`noop`，编码密码为`password`。|
+|**3**|第三个密码的`PasswordEncoder`ID 为`pbkdf2`，编码密码为`5d923b44a6d129f3ddf3e3c8d29412723dcbde72445e8ef6bf3b508fbf17fa4ed4d6b99ca763d8dc`。|
+|**4**|第四个密码的`PasswordEncoder`ID 为`scrypt`，编码密码为`$e0801$8bWJaSu2IKSn9Z9kM+TPXfOc/9bdYSrN1oD9qfVThWEwdRTnO7re7Ei+fUZRJ68k9lTyuTeUp4of4g24hHnazw==$OAOec05+bXxvuu/1qZ6NUR+xQYvYv7BeL1QxwRpY5Pc=`，当与之匹配时，它将委托给`ScryptPassWordEncoder`。|
+|**5**|最终的密码将具有`PasswordEncoder`的 ID`sha256`和`97cde38028ad898ebc02e690819fa220e88c62e0699403e94fff291cfffaf8410849f27605abcbc0`的编码密码。
匹配时，它将委托给`StandardPasswordEncoder`。|
+
+| |一些用户可能担心存储格式是为潜在的黑客提供的。
这不是一个问题，因为密码的存储不依赖于算法是一个秘密。
此外，大多数格式都很容易被攻击者在没有前缀的情况下发现。
例如，bcrypt 密码通常以`$2a$`开头。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 密码编码
+
+传递到构造函数的`idForEncode`确定将使用哪个`PasswordEncoder`来编码密码。在我们上面构造的`DelegatingPasswordEncoder`中，这意味着编码的结果`password`将被委托给`BCryptPasswordEncoder`，并以`{bcrypt}`作为前缀。最终的结果会是：
+
+例 5。delegatingPassWordEncoder 编码示例
+
+```
+{bcrypt}$2a$10$dXJ3SW6G7P50lGmMkkmwe.20cQQubK3.HZWzG3YB1tlRy.fqvM/BG
+```
+
+### 密码匹配
+
+匹配是基于`{id}`和`id`到构造函数中提供的`PasswordEncoder`的映射完成的。我们在[密码存储格式](#authentication-password-storage-dpe-format)中的示例提供了如何实现这一点的工作示例。默认情况下，使用密码调用`matches(CharSequence, String)`并调用未映射（包括空 ID）的`id`的结果将导致`IllegalArgumentException`。可以使用`DelegatingPasswordEncoder.setDefaultPasswordEncoderForMatches(PasswordEncoder)`定制此行为。
+
+通过使用`id`，我们可以在任何密码编码上进行匹配，但是可以使用最现代的密码编码来编码密码。这一点很重要，因为与加密不同，密码散列的设计使得没有简单的方法来恢复明文。由于无法恢复明文，因此很难迁移密码。虽然迁移`NoOpPasswordEncoder`对用户来说很简单，但我们选择在默认情况下包含它，以使入门体验更简单。
+
+### 入门经验
+
+如果你正在组装一个演示或示例，那么花时间对用户的密码进行散列会有点麻烦。有方便的机制使这一点更容易，但这仍然不打算用于生产。
+
+示例 6.与 DefaultPassWordEncoder 示例
+
+爪哇
+
+```
+User user = User.withDefaultPasswordEncoder()
+ .username("user")
+ .password("password")
+ .roles("user")
+ .build();
+System.out.println(user.getPassword());
+// {bcrypt}$2a$10$dXJ3SW6G7P50lGmMkkmwe.20cQQubK3.HZWzG3YB1tlRy.fqvM/BG
+```
+
+Kotlin
+
+```
+val user = User.withDefaultPasswordEncoder()
+ .username("user")
+ .password("password")
+ .roles("user")
+ .build()
+println(user.password)
+// {bcrypt}$2a$10$dXJ3SW6G7P50lGmMkkmwe.20cQQubK3.HZWzG3YB1tlRy.fqvM/BG
+```
+
+如果要创建多个用户，还可以重用构建器。
+
+示例 7.WithDefaultPassWordEncoder 重用构建器
+
+爪哇
+
+```
+UserBuilder users = User.withDefaultPasswordEncoder();
+User user = users
+ .username("user")
+ .password("password")
+ .roles("USER")
+ .build();
+User admin = users
+ .username("admin")
+ .password("password")
+ .roles("USER","ADMIN")
+ .build();
+```
+
+Kotlin
+
+```
+val users = User.withDefaultPasswordEncoder()
+val user = users
+ .username("user")
+ .password("password")
+ .roles("USER")
+ .build()
+val admin = users
+ .username("admin")
+ .password("password")
+ .roles("USER", "ADMIN")
+ .build()
+```
+
+这会对存储的密码进行散列，但这些密码仍会在内存和编译后的源代码中公开。因此，对于生产环境来说，它仍然不被认为是安全的。对于生产，你应该[在外部散列密码](#authentication-password-storage-boot-cli)。
+
+### 用 Spring boot cli 编码
+
+正确编码密码的最简单方法是使用[Spring Boot CLI](https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-cli.html)。
+
+例如，下面将对`password`的密码进行编码，以便与[PasswordEncoder](#authentication-password-storage-dpe)一起使用：
+
+例 8。 Spring 启动 CLI EncodePassword 示例
+
+```
+spring encodepassword password
+{bcrypt}$2a$10$X5wFBtLrL/kHcmrOGGTrGufsBX8CJ0WpQpF3pgeuxBB/H73BK1DW6
+```
+
+### 故障排除
+
+当存储的密码之一没有[密码存储格式](#authentication-password-storage-dpe-format)中所述的 ID 时，会发生以下错误。
+
+```
+java.lang.IllegalArgumentException: There is no PasswordEncoder mapped for the id "null"
+ at org.springframework.security.crypto.password.DelegatingPasswordEncoder$UnmappedIdPasswordEncoder.matches(DelegatingPasswordEncoder.java:233)
+ at org.springframework.security.crypto.password.DelegatingPasswordEncoder.matches(DelegatingPasswordEncoder.java:196)
+```
+
+解决该错误的最简单方法是切换到显式提供你的密码所使用的`PasswordEncoder`。解决此问题的最简单方法是弄清楚当前如何存储密码，并显式地提供正确的`PasswordEncoder`。
+
+如果你正在从 Spring Security4.2.x 迁移，则可以通过[公开`NoOpPasswordEncoder` Bean]（# 身份验证-密码-存储-配置）来恢复到以前的行为。
+
+或者，你可以在所有密码前加上正确的 ID，然后继续使用`DelegatingPasswordEncoder`。例如，如果你正在使用 bcrypt，那么你将从以下内容迁移密码：
+
+```
+$2a$10$dXJ3SW6G7P50lGmMkkmwe.20cQQubK3.HZWzG3YB1tlRy.fqvM/BG
+```
+
+to
+
+```
+{bcrypt}$2a$10$dXJ3SW6G7P50lGmMkkmwe.20cQQubK3.HZWzG3YB1tlRy.fqvM/BG
+```
+
+对于映射的完整列表，请参考[PasswordEncoderFactories](https://docs.spring.io/spring-security/site/docs/5.0.x/api/org/springframework/security/crypto/factory/PasswordEncoderFactories.html)上的 爪哇doc。
+
+## BCryptPasswordEncoder
+
+`BCryptPasswordEncoder`实现使用广泛支持的[bcrypt](https://en.wikipedia.org/wiki/Bcrypt)算法来散列密码。为了使其更好地抵抗密码破解，bcrypt 故意放慢速度。像其他自适应单向功能一样，它应该调整为在系统上验证密码所需的时间约为 1 秒。`BCryptPasswordEncoder`的默认实现使用了在[bcryptpasswordencoder](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/crypto/bcrypt/BCryptPasswordEncoder.html)的 爪哇doc 中提到的强度 10。我们鼓励你在自己的系统上调整和测试强度参数，这样验证密码大约需要 1 秒钟。
+
+例 9。bcryptpasswordencoder
+
+爪哇
+
+```
+// Create an encoder with strength 16
+BCryptPasswordEncoder encoder = new BCryptPasswordEncoder(16);
+String result = encoder.encode("myPassword");
+assertTrue(encoder.matches("myPassword", result));
+```
+
+Kotlin
+
+```
+// Create an encoder with strength 16
+val encoder = BCryptPasswordEncoder(16)
+val result: String = encoder.encode("myPassword")
+assertTrue(encoder.matches("myPassword", result))
+```
+
+## Argon2Passwordencoder
+
+`Argon2PasswordEncoder`实现使用[Argon2](https://en.wikipedia.org/wiki/Argon2)算法来散列密码。Argon2 是[密码散列竞赛](https://en.wikipedia.org/wiki/Password_Hashing_Competition)的获胜者。为了击败定制硬件上的密码破解，Argon2 是一种故意缓慢的算法，需要大量内存。像其他自适应单向功能一样，它应该调整为在系统上验证密码所需的时间约为 1 秒。`Argon2PasswordEncoder`的当前实现需要 bouncycastle。
+
+例 10。Argon2Passwordencoder
+
+爪哇
+
+```
+// Create an encoder with all the defaults
+Argon2PasswordEncoder encoder = new Argon2PasswordEncoder();
+String result = encoder.encode("myPassword");
+assertTrue(encoder.matches("myPassword", result));
+```
+
+Kotlin
+
+```
+// Create an encoder with all the defaults
+val encoder = Argon2PasswordEncoder()
+val result: String = encoder.encode("myPassword")
+assertTrue(encoder.matches("myPassword", result))
+```
+
+## PBKDF2PASSWORDENCODER
+
+`Pbkdf2PasswordEncoder`实现使用[PBKDF2](https://en.wikipedia.org/wiki/PBKDF2)算法来散列密码。为了击败密码破解，PBKDF2 是一种故意缓慢的算法。像其他自适应单向功能一样，它应该调整为在系统上验证密码所需的时间约为 1 秒。当需要 FIPS 认证时，该算法是一个很好的选择。
+
+例 11。PBKDF2PASSWORDENCODER
+
+爪哇
+
+```
+// Create an encoder with all the defaults
+Pbkdf2PasswordEncoder encoder = new Pbkdf2PasswordEncoder();
+String result = encoder.encode("myPassword");
+assertTrue(encoder.matches("myPassword", result));
+```
+
+Kotlin
+
+```
+// Create an encoder with all the defaults
+val encoder = Pbkdf2PasswordEncoder()
+val result: String = encoder.encode("myPassword")
+assertTrue(encoder.matches("myPassword", result))
+```
+
+## SCryptPasswordEncoder
+
+`SCryptPasswordEncoder`实现使用[scrypt](https://en.wikipedia.org/wiki/Scrypt)算法来散列密码。为了击败定制硬件上的密码破解，Scrypt 是一种故意缓慢的算法，需要大量的内存。像其他自适应单向功能一样，它应该调整为在系统上验证密码所需的时间约为 1 秒。
+
+例 12。ScryptPassWordEncoder
+
+爪哇
+
+```
+// Create an encoder with all the defaults
+SCryptPasswordEncoder encoder = new SCryptPasswordEncoder();
+String result = encoder.encode("myPassword");
+assertTrue(encoder.matches("myPassword", result));
+```
+
+Kotlin
+
+```
+// Create an encoder with all the defaults
+val encoder = SCryptPasswordEncoder()
+val result: String = encoder.encode("myPassword")
+assertTrue(encoder.matches("myPassword", result))
+```
+
+## 其他 PasswordEncoders
+
+还有相当数量的其他`PasswordEncoder`实现完全是为了向后兼容而存在的。它们都被弃用，以表明它们不再被认为是安全的。但是，由于很难迁移现有的遗留系统，因此没有删除它们的计划。
+
+## 密码存储配置
+
+Spring 安全性默认使用[PasswordEncoder](#authentication-password-storage-dpe)。然而，这可以通过将`PasswordEncoder`公开为 Spring Bean 来定制。
+
+如果从 Spring Security4.2.x 迁移，则可以通过公开`NoOpPasswordEncoder` Bean 来恢复到以前的行为。
+
+| |恢复到`NoOpPasswordEncoder`不被认为是安全的。
你应该转而使用`DelegatingPasswordEncoder`来支持安全的密码编码。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+例 13。NoopPassWordEncoder
+
+爪哇
+
+```
+@Bean
+public static PasswordEncoder passwordEncoder() {
+ return NoOpPasswordEncoder.getInstance();
+}
+```
+
+XML
+
+```
+
+```
+
+Kotlin
+
+```
+@Bean
+fun passwordEncoder(): PasswordEncoder {
+ return NoOpPasswordEncoder.getInstance();
+}
+```
+
+| |XML 配置要求`NoOpPasswordEncoder` Bean 名称为`passwordEncoder`。|
+|---|---------------------------------------------------------------------------------------|
+
+## 更改密码配置
+
+大多数允许用户指定密码的应用程序也需要更新该密码的功能。
+
+[一个众所周知的更改密码的 URL](https://w3c.github.io/webappsec-change-password-url/)表示一种机制，通过这种机制，密码管理器可以发现给定应用程序的密码更新端点。
+
+你可以配置 Spring 安全性以提供此发现端点。例如，如果应用程序中的更改密码端点是`/change-password`，那么你可以这样配置 Spring 安全性：
+
+例 14。默认更改密码端点
+
+Java
+
+```
+http
+ .passwordManagement(Customizer.withDefaults())
+```
+
+XML
+
+```
+
+```
+
+Kotlin
+
+```
+http {
+ passwordManagement { }
+}
+```
+
+然后，当密码管理器导航到`/.well-known/change-password`时， Spring 安全性将重定向你的端点，`/change-password`。
+
+或者，如果你的端点不是`/change-password`，也可以这样指定：
+
+例 15。更改密码端点
+
+Java
+
+```
+http
+ .passwordManagement((management) -> management
+ .changePasswordPage("/update-password")
+ )
+```
+
+XML
+
+```
+
+```
+
+Kotlin
+
+```
+http {
+ passwordManagement {
+ changePasswordPage = "/update-password"
+ }
+}
+```
+
+通过上述配置，当密码管理器导航到`/.well-known/change-password`时， Spring Security 将重定向到`/update-password`。
\ No newline at end of file
diff --git a/docs/spring-security/features-authentication.md b/docs/spring-security/features-authentication.md
new file mode 100644
index 0000000000000000000000000000000000000000..b19d4e6eb805b8bedb141349660479f3870a697b
--- /dev/null
+++ b/docs/spring-security/features-authentication.md
@@ -0,0 +1,5 @@
+# 认证
+
+Spring 安全性为[认证](https://en.wikipedia.org/wiki/Authentication)提供了全面的支持。身份验证是指我们如何验证试图访问特定资源的人的身份。验证用户身份的一种常见方法是要求用户输入用户名和密码。一旦进行了身份验证，我们就知道了身份并可以执行授权。
+
+Spring 安全性为用户身份验证提供了内置支持。本节专门介绍在 Servlet 和 WebFlux 环境中都适用的通用身份验证支持。有关每个堆栈支持什么的详细信息，请参阅[Servlet](../../servlet/authentication/index.html#servlet-authentication)和 WebFlux 的身份验证部分。
\ No newline at end of file
diff --git a/docs/spring-security/features-exploits-csrf.md b/docs/spring-security/features-exploits-csrf.md
new file mode 100644
index 0000000000000000000000000000000000000000..a385b8999147d62ff99d47ab3c4e3fc3cdbb6273
--- /dev/null
+++ b/docs/spring-security/features-exploits-csrf.md
@@ -0,0 +1,296 @@
+# 跨站点请求伪造
+
+Spring 为防范[跨站点请求伪造](https://en.wikipedia.org/wiki/Cross-site_request_forgery)攻击提供了全面的支持。在以下几节中，我们将探讨：
+
+* [什么是 CSRF 攻击？](#csrf-explained)
+
+* [防范 CSRF 攻击](#csrf-protection)
+
+* [CSRF 考虑因素](#csrf-considerations)
+
+| |这部分的文档讨论了 CSRF 保护的一般主题。
关于基于[servlet](../../servlet/exploits/csrf.html#servlet-csrf)和[WebFlux](../../reactive/exploits/csrf.html#webflux-csrf)的应用程序的 CSRF 保护的具体信息，请参阅相关章节。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## 什么是 CSRF 攻击？
+
+理解 CSRF 攻击的最好方法是看一个具体的例子。
+
+假设你的银行的网站提供了一种表单，允许将当前登录的用户的资金转移到另一个银行帐户。例如，传输表单可能看起来像：
+
+例 1。转移形式
+
+```
+
+```
+
+相应的 HTTP 请求可能看起来像：
+
+例 2。传输 HTTP 请求
+
+```
+POST /transfer HTTP/1.1
+Host: bank.example.com
+Cookie: JSESSIONID=randomid
+Content-Type: application/x-www-form-urlencoded
+
+amount=100.00&routingNumber=1234&account=9876
+```
+
+现在，假装你对银行的网站进行了认证，然后在不登出的情况下，访问一个邪恶的网站。邪恶网站包含一个 HTML 页面，其形式如下：
+
+例 3。邪恶转移形式
+
+```
+
+```
+
+你想赢钱，所以你点击提交按钮。在此过程中，你无意中向恶意用户转移了 100 美元。发生这种情况的原因是，虽然邪恶的网站无法看到你的 cookie，但与你的银行相关的 cookie 仍会随请求一起发送。
+
+最糟糕的是，整个过程都可以使用 JavaScript 实现自动化。这意味着你甚至不需要点击这个按钮。此外，当访问一个受[XSS attack](https://www.owasp.org/index.php/Cross-site_Scripting_(XSS)影响的诚实网站时，也很容易发生这种情况。那么，我们如何保护我们的用户免受此类攻击呢？
+
+## 防范 CSRF 攻击
+
+可能发生 CSRF 攻击的原因是，来自受害者网站的 HTTP 请求和来自攻击者网站的请求完全相同。这意味着，无法拒绝来自邪恶网站的请求，也无法允许来自该行网站的请求。为了防止 CSRF 攻击，我们需要确保请求中有邪恶站点无法提供的内容，因此我们可以区分这两个请求。
+
+Spring 提供了两种机制来防止 CSRF 攻击：
+
+* the[同步器令牌模式](#csrf-protection-stp)
+
+* 在会话cookie 上指定[Samesite 属性](#csrf-protection-ssa)
+
+| |这两种保护都要求[安全的方法必须是幂等的。](#csrf-protection-idempotent)|
+|---|--------------------------------------------------------------------------------------------|
+
+### 安全的方法必须是幂等的。
+
+为了使针对 CSRF 的[要么保护](#csrf-protection)工作，应用程序必须确保[“安全的”HTTP 方法是幂等的](https://tools.ietf.org/html/rfc7231#section-4.2.1)。这意味着使用 http 方法`GET`、`HEAD`、`OPTIONS`和`TRACE`的请求不应改变应用程序的状态。
+
+### 同步器令牌模式
+
+防止 CSRF 攻击的主要和最全面的方法是使用[同步器令牌模式](https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html#synchronizer-token-pattern)。这种解决方案是为了确保每个 HTTP 请求，除了我们的会话cookie 之外，还必须在 HTTP 请求中存在一个安全的随机生成值，称为 CSRF 令牌。
+
+当提交 HTTP 请求时，服务器必须查找预期的 CSRF 令牌，并将其与 HTTP 请求中的实际 CSRF 令牌进行比较。如果值不匹配，则应拒绝 HTTP 请求。
+
+这一工作的关键是，实际的 CSRF 令牌应该位于 HTTP 请求的一部分，该部分不会被浏览器自动包含。例如，在 HTTP 参数或 HTTP 报头中要求实际的 CSRF 令牌，可以防止 CSRF 攻击。在 Cookie 中要求实际的 CSRF 令牌是不起作用的，因为浏览器会自动将 Cookie 包含在 HTTP 请求中。
+
+我们可以放松预期，只需要每个更新应用程序状态的 HTTP 请求的实际 CSRF 令牌。要使其工作，我们的应用程序必须确保[安全的 HTTP 方法是幂等的](#csrf-protection-idempotent)。这提高了可用性，因为我们希望允许使用外部站点的链接来链接到我们的网站。此外，我们不想在 HTTP GET 中包含随机令牌，因为这可能导致令牌泄漏。
+
+让我们来看看使用 Synchronizer 令牌模式时[我们的例子](#csrf-explained)将如何更改。假设实际的 CSRF 令牌需要位于一个名为`_csrf`的 HTTP 参数中。我们的申请的转移表看起来是这样的：
+
+例 4。同步器令牌形式
+
+```
+
+```
+
+表单现在包含一个隐藏的输入，其值为 CSRF 令牌。外部站点无法读取 CSRF 令牌，因为相同的源策略确保邪恶站点无法读取响应。
+
+相应的转移资金的 HTTP 请求将如下所示：
+
+例 5。同步器令牌请求
+
+```
+POST /transfer HTTP/1.1
+Host: bank.example.com
+Cookie: JSESSIONID=randomid
+Content-Type: application/x-www-form-urlencoded
+
+amount=100.00&routingNumber=1234&account=9876&_csrf=4bfd1575-3ad1-4d21-96c7-4ef2d9f86721
+```
+
+你将注意到，HTTP 请求现在包含带有安全随机值的`_csrf`参数。当服务器将实际的 CSRF 令牌与预期的 CSRF 令牌进行比较时，Evil 网站将无法为`_csrf`参数（必须在 Evil 网站上显式提供）提供正确的值，并且传输将失败。
+
+### Samesite 属性
+
+防止[CSRF 攻击](#csrf)的一种新兴方法是在 cookie 上指定[Samesite 属性](https://tools.ietf.org/html/draft-west-first-party-cookies)。服务器在设置 cookie 时可以指定`SameSite`属性，以指示当来自外部站点时不应发送 cookie。
+
+| |Spring 安全性并不直接控制会话cookie 的创建，因此它不提供对 Samesite 属性的支持。[Spring Session](https://spring.io/projects/spring-session)在基于 Servlet 的应用程序中提供了对`SameSite`属性的支持。
Spring 框架的[CookiewebessionDresolver](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/server/session/CookieWebSessionIdResolver.html)在基于 WebFlux 的应用程序中提供了对`SameSite`属性的开箱即用支持。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+例如，具有`SameSite`属性的 HTTP 响应头可能看起来如下所示：
+
+例 6。Samesite HTTP 响应
+
+```
+Set-Cookie: JSESSIONID=randomid; Domain=bank.example.com; Secure; HttpOnly; SameSite=Lax
+```
+
+`SameSite`属性的有效值是：
+
+* `Strict`-当指定时，来自[same-site](https://tools.ietf.org/html/draft-west-first-party-cookies-07#section-2.1)的任何请求都将包括 cookie。否则，Cookie 将不会包含在 HTTP 请求中。
+
+* `Lax`-当指定的 cookie 来自[same-site](https://tools.ietf.org/html/draft-west-first-party-cookies-07#section-2.1)或当请求来自顶级导航和[方法是幂等的](#csrf-protection-idempotent)时将被发送。否则，Cookie 将不会包含在 HTTP 请求中。
+
+让我们来看看如何使用[我们的例子](#csrf-explained)属性来保护`SameSite`。银行应用程序可以通过在会话cookie 上指定`SameSite`属性来防止 CSRF。
+
+通过在我们的会话cookie 上设置`SameSite`属性，浏览器将继续发送来自银行网站的请求的`JSESSIONID`cookie。但是，浏览器将不再发送带有来自 Evil 网站的传输请求的`JSESSIONID`cookie。由于会话在来自邪恶网站的传输请求中不再存在，因此应用程序受到 CSRF 攻击的保护。
+
+在使用`SameSite`属性来防止 CSRF 攻击时，应该注意一些重要的[注意事项](https://tools.ietf.org/html/draft-west-first-party-cookies-07#section-5)属性。
+
+将`SameSite`属性设置为`Strict`提供了更强的防御能力，但可能会使用户感到困惑。考虑一个用户保持登录到托管在[https://social.example.com](https://social.example.com)的社交媒体网站。用户在[https://email.example.org](https://email.example.org)处收到一封电子邮件，其中包括一个到该社交媒体网站的链接。如果用户点击了该链接，他们理所当然地希望得到该社交媒体网站的认证。但是，如果`SameSite`属性是`Strict`，则不会发送 cookie，因此不会对用户进行身份验证。
+
+| |通过实现[gh-7537](https://github.com/spring-projects/spring-security/issues/7537)，可以提高`SameSite`对 CSRF 攻击的防护能力和可用性。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+另一个明显的考虑因素是，为了让`SameSite`属性保护用户，浏览器必须支持`SameSite`属性。大多数现代浏览器都[支持 Samesite 属性](https://developer.mozilla.org/en-US/docs/Web/HTTP/headers/Set-Cookie#Browser_compatibility)。然而，仍在使用的旧浏览器可能不会。
+
+出于这个原因，通常建议使用`SameSite`属性作为深度防御，而不是针对 CSRF 攻击的唯一保护。
+
+## 何时使用 CSRF 保护
+
+你什么时候应该使用 CSRF 保护？我们的建议是，对于普通用户可能通过浏览器处理的任何请求，使用 CSRF 保护。如果你只是创建一个由非浏览器客户端使用的服务，那么你可能希望禁用 CSRF 保护。
+
+### CSRF 保护和 JSON
+
+一个常见的问题是“我需要保护 JavaScript 发出的 JSON 请求吗？”简短的回答是，这要看情况而定。但是，你必须非常小心，因为有 CSRF 漏洞可能会影响 JSON 请求。例如，恶意用户可以创建[使用以下表单使用 JSON 的 CSRF](http://blog.opensecurityresearch.com/2012/02/json-csrf-with-parameter-padding.html):
+
+例 7。使用 JSON 表单的 CSRF
+
+```
+
+```
+
+这将产生以下 JSON 结构
+
+例 8。CSRF 与 JSON 请求
+
+```
+{ "amount": 100,
+"routingNumber": "evilsRoutingNumber",
+"account": "evilsAccountNumber",
+"ignore_me": "=test"
+}
+```
+
+如果应用程序没有验证 Content-type，那么它就会受到此攻击。根据设置，验证 Content-type 的 Spring MVC 应用程序仍然可以通过将 URL 后缀更新为`.json`来利用该漏洞，如下所示：
+
+例 9。使用 JSON Spring MVC 表单的 CSRF
+
+```
+
+```
+
+### CSRF 和无状态浏览器应用程序
+
+如果我的应用程序是无状态的，该怎么办？这并不一定意味着你受到了保护。实际上，如果用户不需要在 Web 浏览器中为给定的请求执行任何操作，那么他们很可能仍然容易受到 CSRF 攻击。
+
+例如，考虑一个应用程序，它使用一个自定义 Cookie 来进行身份验证，而不是使用 JSessionID。当发生 CSRF 攻击时，将以与我们上一个示例中发送 JSessionID Cookie 相同的方式发送自定义 Cookie 和请求。此应用程序易受 CSRF 攻击。
+
+使用基本身份验证的应用程序也容易受到 CSRF 攻击。该应用程序很容易受到攻击，因为浏览器将在任何请求中自动包括用户名和密码，其方式与我们上一个示例中发送的 JSessionID cookie 的方式相同。
+
+## CSRF 考虑因素
+
+在实施针对 CSRF 攻击的保护时，有几个特殊的考虑因素需要考虑。
+
+### 登录
+
+为了防止[请求中的伪造日志](https://en.wikipedia.org/wiki/Cross-site_request_forgery#Forging_login_requests)，应该保护 HTTP 请求中的日志不受 CSRF 攻击。防止在请求中伪造日志是必要的，这样恶意用户就无法读取受害者的敏感信息。攻击的执行方式如下：
+
+* 恶意用户使用恶意用户的凭据执行 CSRF 登录。受害者现在被认证为恶意用户。
+
+* 然后，恶意用户诱使受害者访问受损网站并输入敏感信息。
+
+* 该信息与恶意用户的帐户相关联，因此恶意用户可以使用自己的凭据登录并查看 Vicitim 的敏感信息。
+
+确保登录 HTTP 请求不受 CSRF 攻击的一个可能的复杂情况是，用户可能会经历会话超时，这会导致请求被拒绝。会话超时对于那些预计不需要会话才能登录的用户来说是令人惊讶的。有关更多信息，请参见[CSRF 和会话暂停](#csrf-considerations-timeouts)。
+
+### 注销
+
+为了防止伪造注销请求，应该保护注销 HTTP 请求不受 CSRF 攻击。防止伪造注销请求是必要的，这样恶意用户就无法读取受害者的敏感信息。有关攻击的详细信息，请参阅[这篇博文](https://labs.detectify.com/2017/03/15/loginlogout-csrf-time-to-reconsider/)。
+
+确保退出 HTTP 请求不受 CSRF 攻击的一个可能的复杂情况是，用户可能会经历会话超时，这会导致请求被拒绝。会话超时对于那些不期望为了注销而需要会话超时的用户来说是令人惊讶的。有关更多信息，请参见[CSRF and Session Timeouts](#csrf-considerations-timeouts)。
+
+### CSRF and Session Timeouts
+
+通常，期望的 CSRF 令牌存储在会话中。这意味着，一旦会话过期，服务器将找不到预期的 CSRF 令牌并拒绝 HTTP 请求。解决超时问题有多种选择，每种选择都需要权衡利弊。
+
+* 减少超时的最佳方法是使用 JavaScript 在表单提交时请求 CSRF 令牌。然后用 CSRF 令牌更新表单并提交表单。
+
+* 另一种选择是使用一些 JavaScript，让用户知道他们的会话即将到期。用户可以单击按钮继续并刷新会话。
+
+* 最后，预期的 CSRF 令牌可以存储在 Cookie 中。这允许预期的 CSRF 令牌比会话有效。
+
+ 有人可能会问，为什么预期的 CSRF 令牌在默认情况下没有存储在 Cookie 中。这是因为存在已知的利用漏洞攻击，其中的头（例如，指定 cookie）可以由另一个域设置。这也是 Ruby on Rails[当标题 x-request-with 出现时，不再跳过 CSRF 检查](https://weblog.rubyonrails.org/2011/2/8/csrf-protection-bypass-in-ruby-on-rails/)的原因。有关如何执行此漏洞利用的详细信息，请参见[这个 webappsec.org 线程](https://web.archive.org/web/20210221120355/https://lists.webappsec.org/pipermail/websecurity_lists.webappsec.org/2011-February/007533.html)。另一个缺点是，通过删除状态（即超时），如果令牌受到损害，你将失去强制使其无效的能力。
+
+###
+
+保护多部分请求（文件上传）不受 CSRF 攻击会导致[鸡和蛋](https://en.wikipedia.org/wiki/Chicken_or_the_egg)问题。为了防止 CSRF 攻击的发生，必须读取 HTTP 请求的主体以获得实际的 CSRF 令牌。然而，读取主体意味着文件将被上传，这意味着外部站点可以上传文件。
+
+有两个选择使用 CSRF 保护与多部分/形式数据。每一种选择都有其利弊得失。
+
+* [将 CSRF 标记放入体内](#csrf-considerations-multipart-body)
+
+* [在 URL 中放置 CSRF 令牌](#csrf-considerations-multipart-url)
+
+| |在将 Spring Security 的 CSRF 保护与多部分文件上载集成在一起之前，请确保首先可以在没有 CSRF 保护的情况下进行上传。
关于使用 Spring 的多部分表单的更多信息可以在 Spring 引用的[1.1.11.多部分旋转变压器](https://docs.spring.io/spring/docs/5.2.x/spring-framework-reference/web.html#mvc-multipart)部分和[MultipartFilter Javadoc](https://docs.spring.io/spring/docs/5.2.x/javadoc-api/org/springframework/web/multipart/support/MultipartFilter.html)中找到。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+#### 将 CSRF 标记放入体内
+
+第一个选项是在请求主体中包含实际的 CSRF 令牌。通过将 CSRF 令牌放置在主体中，主体将在执行授权之前被读取。这意味着任何人都可以在你的服务器上放置临时文件。但是，只有经过授权的用户才能提交由你的应用程序处理的文件。通常，这是推荐的方法，因为临时文件上传对大多数服务器的影响可以忽略不计。
+
+#### 在 URL 中包含 CSRF 令牌
+
+如果允许未经授权的用户上传临时文件是不可接受的，那么另一种选择是在表单的 Action 属性中包含预期的 CSRF 令牌作为查询参数。这种方法的缺点是查询参数可能会泄露。更普遍地说，将敏感数据放置在主体或标头内以确保其不会泄漏被认为是最佳实践。其他信息可以在[RFC2616 第 15.1.3 节在 URI 中对敏感信息进行编码](https://www.w3.org/Protocols/rfc2616/rfc2616-sec15.html#sec15.1.3)中找到。
+
+#### HiddenHttpMethodFilter
+
+在某些应用程序中，表单参数可用于覆盖 HTTP 方法。例如，下面的表单可以用来将 HTTP 方法视为`delete`，而不是`post`。
+
+例 10。CSRF 隐藏 HTTP 方法表单
+
+```
+
+```
+
+在筛选器中重写 HTTP 方法。这个过滤器必须放在安全部门的支持之前。请注意，覆盖只发生在`post`上，因此这实际上不太可能导致任何实际问题。然而，最好的做法仍然是确保将其置于 Spring Security 的过滤器之前。
\ No newline at end of file
diff --git a/docs/spring-security/features-exploits-headers.md b/docs/spring-security/features-exploits-headers.md
new file mode 100644
index 0000000000000000000000000000000000000000..92aa00d3191be34cdd0165c7235da8e34cd23ad9
--- /dev/null
+++ b/docs/spring-security/features-exploits-headers.md
@@ -0,0 +1,270 @@
+# 安全 HTTP 响应标头
+
+| |文档的这一部分讨论了安全 HTTP 响应头的一般主题。
关于基于应用程序的安全 HTTP 响应头[servlet](../../servlet/exploits/headers.html#servlet-headers)和[WebFlux](../../reactive/exploits/headers.html#webflux-headers)的特定信息，请参阅相关部分。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+有许多[HTTP 响应标头](https://owasp.org/www-project-secure-headers/#div-headers)可以用来增加 Web 应用程序的安全性。本节专门讨论 Spring Security 提供明确支持的各种 HTTP 响应头。如果需要， Spring 还可以将安全性配置为提供[自定义标头](#headers-custom)。
+
+## 默认安全标头
+
+| |参考相关章节，了解如何为基于[servlet](../../servlet/exploits/headers.html#servlet-headers-default)和[webflux](../../reactive/exploits/headers.html#webflux-headers-default)的应用程序定制默认值。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+Spring 安全性提供了一组与安全性相关的默认 HTTP 响应头，以提供安全的默认值。
+
+Spring 安全性的默认设置是包含以下标题：
+
+例 1。默认安全 HTTP 响应标头
+
+```
+Cache-Control: no-cache, no-store, max-age=0, must-revalidate
+Pragma: no-cache
+Expires: 0
+X-Content-Type-Options: nosniff
+Strict-Transport-Security: max-age=31536000 ; includeSubDomains
+X-Frame-Options: DENY
+X-XSS-Protection: 1; mode=block
+```
+
+| |严格传输安全性仅在 HTTPS 请求中添加|
+|---|---------------------------------------------------------|
+
+如果默认值不能满足你的需求，那么你可以轻松地从这些默认值中删除、修改或添加标题。有关每个标题的其他详细信息，请参阅相应的部分：
+
+* [缓存控制](#headers-cache-control)
+
+* [内容类型选项](#headers-content-type-options)
+
+* [HTTP 严格的传输安全](#headers-hsts)
+
+* [X-帧-选项](#headers-frame-options)
+
+* [X-XSS-保护](#headers-xss-protection)
+
+## 缓存控制
+
+| |参考相关章节，了解如何为基于[servlet](../../servlet/exploits/headers.html#servlet-headers-cache-control)和[webflux](../../reactive/exploits/headers.html#webflux-headers-cache-control)的应用程序定制默认值。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+Spring 安全性的默认方式是禁用缓存，以保护用户的内容。
+
+如果用户通过身份验证查看敏感信息，然后注销，我们不希望恶意用户能够单击“后退”按钮查看敏感信息。默认情况下发送的缓存控制头是：
+
+例 2。默认缓存控制 HTTP 响应标头
+
+```
+Cache-Control: no-cache, no-store, max-age=0, must-revalidate
+Pragma: no-cache
+Expires: 0
+```
+
+为了在默认情况下保持安全， Spring Security 在默认情况下添加了这些标题。但是，如果你的应用程序提供了自己的缓存控制头 Spring，安全性就会退缩。这允许应用程序确保 CSS 和 JavaScript 等静态资源可以被缓存。
+
+## 内容类型选项
+
+| |参考相关章节，了解如何为基于[servlet](../../servlet/exploits/headers.html#servlet-headers-content-type-options)和[webflux](../../reactive/exploits/headers.html#webflux-headers-content-type-options)的应用程序定制默认值。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+历史上，包括 Internet Explorer 在内的浏览器都会尝试使用[内容嗅探](https://en.wikipedia.org/wiki/Content_sniffing)来猜测请求的内容类型。这允许浏览器通过猜测未指定内容类型的资源上的内容类型来改善用户体验。例如，如果浏览器遇到一个没有指定内容类型的 JavaScript 文件，它将能够猜测内容类型，然后运行它。
+
+| |在允许上传内容时，还应该做很多其他事情（例如，只在一个不同的域中显示文档，确保设置了 Content-Type 头，对文档进行了消毒等）。
但是，这些措施超出了 Spring 安全性所提供的范围。
还需要指出的是，在禁用内容嗅探时，必须指定内容类型，以便使事情正常工作。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+内容嗅探的问题在于，这使得恶意用户能够使用多义词（即作为多个内容类型有效的文件）来执行 XSS 攻击。例如，一些网站可能允许用户向网站提交有效的 PostScript 文档并查看它。恶意用户可能会创建[PostScript 文档，也是一个有效的 JavaScript 文件](http://webblaze.cs.berkeley.edu/papers/barth-caballero-song.pdf)并对其执行 XSS 攻击。
+
+Spring 安全性通过在 HTTP 响应中添加以下头来在默认情况下禁用内容嗅探：
+
+示例 3.Nosniff HTTP 响应头
+
+```
+X-Content-Type-Options: nosniff
+```
+
+##
+
+| |参考相关章节，了解如何为基于[servlet](../../servlet/exploits/headers.html#servlet-headers-hsts)和[webflux](../../reactive/exploits/headers.html#webflux-headers-hsts)的应用程序定制默认值。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+当你在你的银行的网站上输入时，你是输入 mybank.example.com 还是输入[https://mybank.example.com](https://mybank.example.com)？如果你省略了 HTTPS 协议，那么你可能会受到[中间派攻击](https://en.wikipedia.org/wiki/Man-in-the-middle_attack)的攻击。即使网站执行重定向到[https://mybank.example.com](https://mybank.example.com)，恶意用户也可能拦截初始的 HTTP 请求并操纵响应（例如，重定向到[https://mibank.example.com](https://mibank.example.com)并窃取其凭据）。
+
+许多用户省略了 HTTPS 协议，这就是创建[HTTP 严格传输安全](https://tools.ietf.org/html/rfc6797)的原因。一旦 mybank.example.com 被添加为[HSTS host](https://tools.ietf.org/html/rfc6797#section-5.1)，浏览器就可以提前知道，对 mybank.example.com 的任何请求都应该被解释为[https://mybank.example.com](https://mybank.example.com)。这大大降低了中锋出现的可能性。
+
+| |根据[RFC6797](https://tools.ietf.org/html/rfc6797#section-7.2)，HSTS 报头只被注入到 HTTPS 响应中。
为了使浏览器承认报头，浏览器必须首先信任签署了用于建立连接的 SSL 证书（而不仅仅是 SSL 证书）的 CA。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+将站点标记为 HSTS 主机的一种方法是将主机预装到浏览器中。另一种方法是将`Strict-Transport-Security`头添加到响应中。例如， Spring Security 的默认行为是添加以下标题，该标题指示浏览器在一年内将该域视为 HSTS 主机（一年中大约有 31536000 秒）：
+
+例 4。严格的传输安全 HTTP 响应头
+
+```
+Strict-Transport-Security: max-age=31536000 ; includeSubDomains ; preload
+```
+
+可选的`includeSubDomains`指令指示浏览器将子域（例如 secure.mybank.example.com）也视为 HSTS 域。
+
+可选的`preload`指令指示浏览器将域作为 HSTS 域预装到浏览器中。有关 HSTS 预加载的更多详细信息，请参见[https://hstspreload.org](https://hstspreload.org)。
+
+##
+
+| |为了保持被动 Spring 安全仍然提供，但是由于上面列出的原因，HPKP 不再由安全团队推荐。|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+[HTTP 公钥固定](https://developer.mozilla.org/en-US/docs/Web/HTTP/Public_Key_Pinning)向 Web 客户端指定在特定 Web 服务器上使用哪种公钥，以防止使用伪造证书的 MITM 攻击。如果正确使用，HPKP 可以添加额外的保护层，以防止受损的证书。然而，由于 HPKP 的复杂性，许多专家不再推荐使用它和[Chrome 甚至取消了支持](https://www.chromestatus.com/feature/5903385005916160)。
+
+有关不再推荐 HPKP 的其他详细信息，请参见[HTTP 公钥钉死了吗？](https://blog.qualys.com/ssllabs/2016/09/06/is-http-public-key-pinning-dead)和[我要放弃 HPKP 了。](https://scotthelme.co.uk/im-giving-up-on-hpkp/)。
+
+## X-帧-选项
+
+| |参考相关章节，了解如何为基于[servlet](../../servlet/exploits/headers.html#servlet-headers-frame-options)和[webflux](../../reactive/exploits/headers.html#webflux-headers-frame-options)的应用程序定制默认值。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+允许你的网站被添加到一个框架可能是一个安全问题。例如，使用聪明的 CSS 样式的用户可能会被诱使点击一些他们不打算点击的东西。例如，已登录其银行的用户可能会单击授予其他用户访问权限的按钮。这种攻击被称为[点击劫持](https://en.wikipedia.org/wiki/Clickjacking)。
+
+| |另一种处理点击劫持的现代方法是使用[内容安全策略](#headers-csp)。|
+|---|-------------------------------------------------------------------------------------------------------------|
+
+有很多方法可以减轻点击劫持攻击。例如，要保护遗留浏览器免受点击劫持攻击，你可以使用[帧断代码](https://www.owasp.org/index.php/Clickjacking_Defense_Cheat_Sheet#Best-for-now_Legacy_Browser_Frame_Breaking_Script)。虽然不是完美的，但断帧代码是你可以为传统浏览器做的最好的事情。
+
+一个更现代的解决点击劫持的方法是使用[X-帧-选项](https://developer.mozilla.org/en-US/docs/HTTP/X-Frame-Options)头。 Spring 默认情况下，安全性禁用使用以下标题在 IFRAME 中呈现页面：
+
+```
+X-Frame-Options: DENY
+```
+
+## X-XSS-保护
+
+| |参考相关章节，了解如何为基于[servlet](../../servlet/exploits/headers.html#servlet-headers-xss-protection)和[webflux](../../reactive/exploits/headers.html#webflux-headers-xss-protection)的应用程序定制默认值。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+一些浏览器内置了对过滤掉[反射 XSS 攻击](https://www.owasp.org/index.php/Testing_for_Reflected_Cross_site_scripting_(OWASP-DV-001)的支持。这绝不是万无一失的，但确实有助于 XSS 保护。
+
+默认情况下，过滤通常是启用的，因此添加标题通常只会确保它已启用，并指示浏览器在检测到 XSS 攻击时该做什么。例如，过滤器可能会尝试以最不具侵入性的方式更改内容，以便仍然呈现所有内容。有时，这种类型的替换可以变成[XSS 本身的漏洞](https://hackademix.net/2009/11/21/ies-xss-filter-creates-xss-vulnerabilities/)。相反，最好是屏蔽内容，而不是试图修复它。 Spring 默认情况下，安全性使用以下头来阻止内容：
+
+```
+X-XSS-Protection: 1; mode=block
+```
+
+##
+
+| |参考相关章节，了解如何配置基于[servlet](../../servlet/exploits/headers.html#servlet-headers-csp)和[webflux](../../reactive/exploits/headers.html#webflux-headers-csp)的应用程序。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+[内容安全策略](https://www.w3.org/TR/CSP2/)是一种机制，Web 应用程序可以利用该机制来减轻内容注入漏洞，例如跨站点脚本。CSP 是一种声明性策略，它为 Web 应用程序的作者提供了一种工具，用于声明并最终通知客户机（用户代理）Web 应用程序期望从哪些源加载资源。
+
+| |内容安全策略并不是要解决所有的内容注入漏洞。
相反，可以利用 CSP 来帮助减少内容注入攻击造成的危害。
作为第一道防线，Web 应用程序作者应该验证其输入并对其输出进行编码。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+Web 应用程序可以通过在响应中包含以下 HTTP 头中的一个来使用 CSP:
+
+* `Content-Security-Policy`
+
+* `Content-Security-Policy-Report-Only`
+
+这些头中的每一个都被用作向客户机交付安全策略的机制。安全策略包含一组安全策略指令，每个指令负责声明特定资源表示的限制。
+
+例如，Web 应用程序可以声明它希望从特定的、受信任的源加载脚本，方法是在响应中包含以下头：
+
+例 5。内容安全策略示例
+
+```
+Content-Security-Policy: script-src https://trustedscripts.example.com
+```
+
+试图从除`script-src`指令中声明的内容以外的其他来源加载脚本的行为将被 User-Agent 阻止。此外，如果[report-uri](https://www.w3.org/TR/CSP2/#directive-report-uri)指令是在安全策略中声明的，那么违反行为将由用户代理报告给声明的 URL。
+
+例如，如果 Web 应用程序违反了声明的安全策略，那么下面的响应头将指示用户代理将违规报告发送到策略的`report-uri`指令中指定的 URL。
+
+例 6。带有 report-uri 的内容安全策略
+
+```
+Content-Security-Policy: script-src https://trustedscripts.example.com; report-uri /csp-report-endpoint/
+```
+
+[违规报告](https://www.w3.org/TR/CSP2/#violation-reports)是标准的 JSON 结构，可以由 Web 应用程序自己的 API 或公共托管的 CSP 违规报告服务捕获，例如，[https://report-uri.com/](https://report-uri.com/)。
+
+`Content-Security-Policy-Report-Only`头为 Web 应用程序的作者和管理员提供了监视安全策略而不是强制执行它们的功能。此标头通常用于为站点进行试验和/或开发安全策略。当策略被认为有效时，可以使用`Content-Security-Policy`头字段来强制执行该策略。
+
+给定以下响应头，策略声明脚本可以从两个可能的源中的一个加载。
+
+例 7。仅提供内容安全策略报告
+
+```
+Content-Security-Policy-Report-Only: script-src 'self' https://trustedscripts.example.com; report-uri /csp-report-endpoint/
+```
+
+如果站点违反了此策略，通过尝试从*Evil.com*加载脚本，用户代理将向*报告-URI*指令指定的声明 URL 发送违规报告，但仍然允许违规资源加载。
+
+将内容安全策略应用于 Web 应用程序通常是一项非常重要的工作。以下资源可以为你的站点提供进一步的帮助，帮助你制定有效的安全策略。
+
+[内容安全策略介绍](https://www.html5rocks.com/en/tutorials/security/content-security-policy/)
+
+[CSP 指南-Mozilla 开发者网络](https://developer.mozilla.org/en-US/docs/Web/Security/CSP)
+
+[W3C 候选推荐](https://www.w3.org/TR/CSP2/)
+
+## 推荐人政策
+
+| |参考相关章节，了解如何配置基于[servlet](../../servlet/exploits/headers.html#servlet-headers-referrer)和[webflux](../../reactive/exploits/headers.html#webflux-headers-referrer)的应用程序。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+[推荐人政策](https://www.w3.org/TR/referrer-policy)是一种机制，Web 应用程序可以利用它来管理 Referrer 字段，该字段包含用户所在的最后一页。
+
+Spring Security 的方法是使用[推荐人政策](https://www.w3.org/TR/referrer-policy/)头，它提供不同的[policies](https://www.w3.org/TR/referrer-policy/#referrer-policies):
+
+例 8。推荐人政策示例
+
+```
+Referrer-Policy: same-origin
+```
+
+Referrer-Policy 响应头指示浏览器让目标知道用户先前所在的源。
+
+## 特征策略
+
+| |参考相关章节，了解如何配置基于[servlet](../../servlet/exploits/headers.html#servlet-headers-feature)和[webflux](../../reactive/exploits/headers.html#webflux-headers-feature)的应用程序。|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+[特征策略](https://wicg.github.io/feature-policy/)是一种机制，允许 Web 开发人员有选择地启用、禁用和修改浏览器中某些 API 和 Web 功能的行为。
+
+例 9。功能策略示例
+
+```
+Feature-Policy: geolocation 'self'
+```
+
+通过功能策略，开发人员可以 OPT 到一组“策略”中，以便浏览器对整个站点中使用的特定功能进行强制执行。这些策略限制了站点可以访问哪些 API，或修改浏览器的某些功能的默认行为。
+
+## 权限策略
+
+| |参考相关章节，了解如何配置基于[servlet](../../servlet/exploits/headers.html#servlet-headers-permissions)和[webflux](../../reactive/exploits/headers.html#webflux-headers-permissions)的应用程序。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+[权限策略](https://w3c.github.io/webappsec-permissions-policy/)是一种机制，允许 Web 开发人员有选择地启用、禁用和修改浏览器中某些 API 和 Web 功能的行为。
+
+例 10。权限策略示例
+
+```
+Permissions-Policy: geolocation=(self)
+```
+
+通过权限策略，开发人员可以 OPT 到一组“策略”中，以便浏览器对整个站点中使用的特定功能进行强制执行。这些策略限制了站点可以访问哪些 API，或修改浏览器的某些功能的默认行为。
+
+## 清除站点数据
+
+| |参考相关章节，了解如何配置基于[servlet](../../servlet/exploits/headers.html#servlet-headers-clear-site-data)和[webflux](../../reactive/exploits/headers.html#webflux-headers-clear-site-data)的应用程序。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+[清除站点数据](https://www.w3.org/TR/clear-site-data/)是一种机制，通过这种机制，当 HTTP 响应包含此标头时，可以删除任何浏览器端数据（cookie、本地存储等）：
+
+```
+Clear-Site-Data: "cache", "cookies", "storage", "executionContexts"
+```
+
+这是一个很好的清理行动，执行注销。
+
+## 自定义标头
+
+| |请参阅相关部分，以了解如何配置基于[servlet](../../servlet/exploits/headers.html#servlet-headers-custom)的应用程序。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------|
+
+Spring 安全性有一些机制，可以方便地将更常见的安全性标题添加到应用程序中。然而，它也提供了钩子来支持添加自定义头。
\ No newline at end of file
diff --git a/docs/spring-security/features-exploits-http.md b/docs/spring-security/features-exploits-http.md
new file mode 100644
index 0000000000000000000000000000000000000000..2ea2f48d2730a7da816b82b252e2097cc381ba6a
--- /dev/null
+++ b/docs/spring-security/features-exploits-http.md
@@ -0,0 +1,21 @@
+# HTTP
+
+所有基于 HTTP 的通信，包括[静态资源](https://www.troyhunt.com/heres-why-your-static-website-needs-https/)，都应该受到[using TLS](https://cheatsheetseries.owasp.org/cheatsheets/Transport_Layer_Protection_Cheat_Sheet.html)的保护。
+
+作为一个框架， Spring 安全性不处理 HTTP 连接，因此不直接提供对 HTTPS 的支持。然而，它确实提供了许多有助于 HTTPS 使用的功能。
+
+## 重定向到 HTTPS
+
+当客户端使用 HTTP 时， Spring 安全性可以被配置为将[Servlet](../../servlet/exploits/http.html#servlet-http-redirect)和[WebFlux](../../reactive/exploits/http.html#webflux-http-redirect)环境重定向到 HTTPS。
+
+## 严格的运输安全
+
+Spring 安全性为[严格的运输安全](headers.html#headers-hsts)提供支持，并在默认情况下启用它。
+
+## 代理服务器配置
+
+在使用代理服务器时，重要的是要确保你已经正确地配置了应用程序。例如，许多应用程序将有一个负载均衡器，该负载均衡器通过在[https://192.168.1:8080](https://192.168.1:8080)处将请求转发到应用程序服务器来响应[https://example.com/](https://example.com/)的请求。如果没有适当的配置，应用程序服务器将不知道负载均衡器的存在，并将请求视为[https://192.168.1:8080](https://192.168.1:8080)是由客户机请求的。
+
+要解决这个问题，你可以使用[RFC 7239](https://tools.ietf.org/html/rfc7239)来指定正在使用负载均衡器。要使应用程序意识到这一点，你需要配置你的应用程序服务器来了解 X 转发头。例如， Tomcat 使用[Remoteipvalve](https://tomcat.apache.org/tomcat-8.0-doc/api/org/apache/catalina/valves/RemoteIpValve.html)， Jetty 使用[ForwardeDrequestCustomizer](https://www.eclipse.org/jetty/javadoc/jetty-9/org/eclipse/jetty/server/ForwardedRequestCustomizer.html)。或者， Spring 用户可以利用[ForwardedHeaderFilter](https://github.com/spring-projects/spring-framework/blob/v4.3.3.RELEASE/spring-web/src/main/java/org/springframework/web/filter/ForwardedHeaderFilter.java)。
+
+Spring 引导用户可以使用`server.use-forward-headers`属性来配置应用程序。有关更多详细信息，请参见[Spring Boot documentation](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#howto-use-tomcat-behind-a-proxy-server)。
\ No newline at end of file
diff --git a/docs/spring-security/features-exploits.md b/docs/spring-security/features-exploits.md
new file mode 100644
index 0000000000000000000000000000000000000000..7bae47e923cba043c3de28b06e1c7c77bf504b04
--- /dev/null
+++ b/docs/spring-security/features-exploits.md
@@ -0,0 +1,9 @@
+# 保护免受剥削
+
+Spring 安全性提供了针对常见攻击的保护。只要有可能，默认情况下都会启用该保护。下面，你将看到安全防范的各种攻击的高级描述。
+
+## 章节摘要
+
+* [CSRF](csrf.html)
+* [HTTP 头](headers.html)
+* [HTTP 请求](http.html)
\ No newline at end of file
diff --git a/docs/spring-security/features-integrations-concurrency.md b/docs/spring-security/features-integrations-concurrency.md
new file mode 100644
index 0000000000000000000000000000000000000000..e1b62bd10e503cbe3f6ee3eb94bc537355ee250d
--- /dev/null
+++ b/docs/spring-security/features-integrations-concurrency.md
@@ -0,0 +1,231 @@
+# 并发支持
+
+在大多数环境中，安全性是以 per`Thread`为基础存储的。这意味着，当在新的`Thread`上完成工作时，`SecurityContext`将丢失。 Spring 安全性提供了一些基础设施，以帮助用户更容易地实现这一点。 Spring 安全性为在多线程环境中使用 Spring 安全性提供了低层次的抽象。事实上，这就是 Spring 安全性构建到与[AsyncContext.start（可运行）](../../servlet/integrations/servlet-api.html#servletapi-start-runnable)和[Spring MVC Async Integration](../../servlet/integrations/mvc.html#mvc-async)集成的基础。
+
+## 在可撤销的情况下将证券转让
+
+Spring Security 的并发支持中最基本的构建块之一是`DelegatingSecurityContextRunnable`。它包装了一个委托`Runnable`，以便用指定的`SecurityContext`为委托初始化`SecurityContextHolder`。然后，它调用委托 Runnable 确保在之后清除`SecurityContextHolder`。`DelegatingSecurityContextRunnable`看起来是这样的：
+
+爪哇
+
+```
+public void run() {
+try {
+ SecurityContextHolder.setContext(securityContext);
+ delegate.run();
+} finally {
+ SecurityContextHolder.clearContext();
+}
+}
+```
+
+Kotlin
+
+```
+fun run() {
+ try {
+ SecurityContextHolder.setContext(securityContext)
+ delegate.run()
+ } finally {
+ SecurityContextHolder.clearContext()
+ }
+}
+```
+
+虽然非常简单，但它可以无缝地将 SecurityContext 从一个线程转移到另一个线程。这一点很重要，因为在大多数情况下，SecurityContextholder 是以每个线程为基础的。例如，你可能使用了 Spring Security 的[\](../../servlet/appendix/namespace/method-security.html#nsa-global-method-security)支持来保护你的某个服务。现在，你可以轻松地将当前`Thread`的`SecurityContext`传输到调用安全服务的`Thread`。下面是你如何做到这一点的一个示例：
+
+爪哇
+
+```
+Runnable originalRunnable = new Runnable() {
+public void run() {
+ // invoke secured service
+}
+};
+
+SecurityContext context = SecurityContextHolder.getContext();
+DelegatingSecurityContextRunnable wrappedRunnable =
+ new DelegatingSecurityContextRunnable(originalRunnable, context);
+
+new Thread(wrappedRunnable).start();
+```
+
+Kotlin
+
+```
+val originalRunnable = Runnable {
+ // invoke secured service
+}
+val context: SecurityContext = SecurityContextHolder.getContext()
+val wrappedRunnable = DelegatingSecurityContextRunnable(originalRunnable, context)
+
+Thread(wrappedRunnable).start()
+```
+
+上面的代码执行以下步骤：
+
+* 创建将调用我们的安全服务的`Runnable`。请注意，它并不了解 Spring 安全性
+
+* 从`SecurityContextHolder`获取我们希望使用的`SecurityContext`，并初始化`DelegatingSecurityContextRunnable`
+
+* 使用`DelegatingSecurityContextRunnable`创建线程
+
+* 启动我们创建的线程
+
+由于从`SecurityContextHolder`中使用`SecurityContext`创建`DelegatingSecurityContextRunnable`是很常见的，因此它有一个快捷构造函数。以下代码与上述代码相同：
+
+爪哇
+
+```
+Runnable originalRunnable = new Runnable() {
+public void run() {
+ // invoke secured service
+}
+};
+
+DelegatingSecurityContextRunnable wrappedRunnable =
+ new DelegatingSecurityContextRunnable(originalRunnable);
+
+new Thread(wrappedRunnable).start();
+```
+
+Kotlin
+
+```
+val originalRunnable = Runnable {
+ // invoke secured service
+}
+
+val wrappedRunnable = DelegatingSecurityContextRunnable(originalRunnable)
+
+Thread(wrappedRunnable).start()
+```
+
+我们拥有的代码使用起来很简单，但仍然需要了解我们正在使用 Spring 安全性。在下一节中，我们将研究如何利用`委派安全环境专家`来隐藏我们正在使用 Spring 安全性的事实。
+
+## DelegatingSecurityContextExecutor
+
+在上一节中，我们发现使用`DelegatingSecurityContextRunnable`很容易，但并不理想，因为我们必须意识到 Spring 安全性才能使用它。让我们来看看`DelegatingSecurityContextExecutor`如何保护我们的代码不受我们正在使用 Spring 安全性的任何知识的影响。
+
+`DelegatingSecurityContextExecutor`的设计与`DelegatingSecurityContextRunnable`的设计非常相似，只是它接受一个委托`Executor`而不是一个委托`Runnable`。你可以在下面看到一个如何使用它的示例：
+
+爪哇
+
+```
+SecurityContext context = SecurityContextHolder.createEmptyContext();
+Authentication authentication =
+ new UsernamePasswordAuthenticationToken("user","doesnotmatter", AuthorityUtils.createAuthorityList("ROLE_USER"));
+context.setAuthentication(authentication);
+
+SimpleAsyncTaskExecutor delegateExecutor =
+ new SimpleAsyncTaskExecutor();
+DelegatingSecurityContextExecutor executor =
+ new DelegatingSecurityContextExecutor(delegateExecutor, context);
+
+Runnable originalRunnable = new Runnable() {
+public void run() {
+ // invoke secured service
+}
+};
+
+executor.execute(originalRunnable);
+```
+
+Kotlin
+
+```
+val context: SecurityContext = SecurityContextHolder.createEmptyContext()
+val authentication: Authentication =
+ UsernamePasswordAuthenticationToken("user", "doesnotmatter", AuthorityUtils.createAuthorityList("ROLE_USER"))
+context.authentication = authentication
+
+val delegateExecutor = SimpleAsyncTaskExecutor()
+val executor = DelegatingSecurityContextExecutor(delegateExecutor, context)
+
+val originalRunnable = Runnable {
+ // invoke secured service
+}
+
+executor.execute(originalRunnable)
+```
+
+代码执行以下步骤：
+
+* 创建用于我们的`DelegatingSecurityContextExecutor`的`SecurityContext`。注意，在这个示例中，我们只需手工创建`SecurityContext`。然而，无论我们在哪里或如何获得`SecurityContext`都不重要（也就是说，如果我们愿意，我们可以从`SecurityContextHolder`获得它）。
+
+* 创建一个 DelegateExecutor，它负责执行提交的`Runnable`s
+
+* 最后，我们创建一个`DelegatingSecurityContextExecutor`，它负责用`DelegatingSecurityContextRunnable`包装传递到 Execute 方法中的任何 runnable。然后，它将包装好的 Runnable 传递给 DelegateExecutor。在此实例中，对于提交到我们的`DelegatingSecurityContextExecutor`的每个 runnable，将使用相同的`SecurityContext`。如果我们运行的是需要由具有提升权限的用户运行的后台任务，那么这很好。
+
+* 此时，你可能会问自己：“这是如何屏蔽我的代码中的任何安全知识的？”我们不需要在自己的代码中创建`SecurityContext`和`DelegatingSecurityContextExecutor`，而是可以插入一个已经初始化的`DelegatingSecurityContextExecutor`实例。
+
+爪哇
+
+```
+@Autowired
+private Executor executor; // becomes an instance of our DelegatingSecurityContextExecutor
+
+public void submitRunnable() {
+Runnable originalRunnable = new Runnable() {
+ public void run() {
+ // invoke secured service
+ }
+};
+executor.execute(originalRunnable);
+}
+```
+
+Kotlin
+
+```
+@Autowired
+lateinit var executor: Executor // becomes an instance of our DelegatingSecurityContextExecutor
+
+fun submitRunnable() {
+ val originalRunnable = Runnable {
+ // invoke secured service
+ }
+ executor.execute(originalRunnable)
+}
+```
+
+现在我们的代码不知道`SecurityContext`正在传播到`Thread`，然后运行`originalRunnable`，然后清除`SecurityContextHolder`。在本例中，使用相同的用户运行每个线程。如果我们希望在调用`executor.execute(Runnable)`时使用来自`SecurityContextHolder`的用户（即当前登录的用户）来处理`originalRunnable`，该怎么办？这可以通过从我们的`DelegatingSecurityContextExecutor`构造函数中删除`SecurityContext`参数来完成。例如：
+
+爪哇
+
+```
+SimpleAsyncTaskExecutor delegateExecutor = new SimpleAsyncTaskExecutor();
+DelegatingSecurityContextExecutor executor =
+ new DelegatingSecurityContextExecutor(delegateExecutor);
+```
+
+Kotlin
+
+```
+val delegateExecutor = SimpleAsyncTaskExecutor()
+val executor = DelegatingSecurityContextExecutor(delegateExecutor)
+```
+
+现在，每当执行`executor.execute(Runnable)`时，`SecurityContext`首先由`SecurityContextHolder`获得，然后`SecurityContext`用于创建我们的`DelegatingSecurityContextRunnable`。这意味着我们运行`Runnable`的用户与调用`executor.execute(Runnable)`代码的用户相同。
+
+## Spring 安全并发类
+
+有关 Java Concurrent API 和 Spring 任务抽象的附加集成，请参考 Javadoc。一旦你理解了前面的代码，它们就非常不言自明了。
+
+* `DelegatingSecurityContextCallable`
+
+* `DelegatingSecurityContextExecutor`
+
+* `DelegatingSecurityContextExecutorService`
+
+* `DelegatingSecurityContextRunnable`
+
+* `DelegatingSecurityContextScheduledExecutorService`
+
+* `DelegatingSecurityContextSchedulingTaskExecutor`
+
+* `DelegatingSecurityContextAsyncTaskExecutor`
+
+* `DelegatingSecurityContextTaskExecutor`
+
+* `DelegatingSecurityContextTaskScheduler`
\ No newline at end of file
diff --git a/docs/spring-security/features-integrations-cryptography.md b/docs/spring-security/features-integrations-cryptography.md
new file mode 100644
index 0000000000000000000000000000000000000000..a6b7e7d5d20f4508860a9fd42b535a9856f1bf0d
--- /dev/null
+++ b/docs/spring-security/features-integrations-cryptography.md
@@ -0,0 +1,218 @@
+# Spring 安全加密模块
+
+## 导言
+
+Spring 安全加密模块提供对对称加密、密钥生成和密码编码的支持。该代码作为核心模块的一部分进行分发，但不依赖于任何其他 Spring 安全性（或 Spring）代码。
+
+## 加密者
+
+Encryptors 类提供了用于构造对称加密器的工厂方法。使用这个类，你可以创建 ByteenCryptors 来加密原始字节[]形式的数据。你还可以构造文本加密器来加密文本字符串。加密器是线程安全的。
+
+### BytesenCryptor
+
+使用`Encryptors.stronger`工厂方法来构造一个 ByteSenCryptor:
+
+例 1。BytesenCryptor
+
+爪哇
+
+```
+Encryptors.stronger("password", "salt");
+```
+
+Kotlin
+
+```
+Encryptors.stronger("password", "salt")
+```
+
+“更强”的加密方法使用 256 位 AES 加密和伽罗瓦计数器模式创建一个加密器。它使用 PKCS#5 的 PBKDF2（基于密码的密钥派生函数 #2）来派生密钥。这个方法需要 爪哇6。用于生成秘密密钥的密码应保存在安全的地方，不得共享。SALT 用于防止在你的加密数据遭到破坏时对密钥发起字典攻击。还应用了 16 字节的随机初始化向量，因此每个加密消息都是唯一的。
+
+所提供的 SALT 应该是十六进制编码的字符串形式，是随机的，并且至少有 8 个字节的长度。可以使用键盘生成器生成这样的 salt:
+
+例 2。生成密钥
+
+爪哇
+
+```
+String salt = KeyGenerators.string().generateKey(); // generates a random 8-byte salt that is then hex-encoded
+```
+
+Kotlin
+
+```
+val salt = KeyGenerators.string().generateKey() // generates a random 8-byte salt that is then hex-encoded
+```
+
+用户也可以使用`standard`加密方法，这是在密码块链接模式下的 256 位 AES。此模式不是[已认证](https://en.wikipedia.org/wiki/Authenticated_encryption)，并且不提供有关数据真实性的任何保证。对于更安全的选择，用户应该更喜欢`Encryptors.stronger`。
+
+### TextEncryptor
+
+使用 Encryptors.text Factory 方法构建一个标准的 TextEncryptor:
+
+例 3。TextEncryptor
+
+爪哇
+
+```
+Encryptors.text("password", "salt");
+```
+
+Kotlin
+
+```
+Encryptors.text("password", "salt")
+```
+
+TextEncryptor 使用标准的 BytesEncryptor 加密文本数据。加密的结果以十六进制编码字符串的形式返回，以便于存储在文件系统或数据库中。
+
+使用 Encryptors.queryableText Factory 方法构造一个“可查询的”文本加密程序：
+
+例 4。可查询文本加密器
+
+爪哇
+
+```
+Encryptors.queryableText("password", "salt");
+```
+
+Kotlin
+
+```
+Encryptors.queryableText("password", "salt")
+```
+
+可查询文本加密器和标准文本加密器之间的区别与初始化向量处理有关。在可查询的 TextEncryptor#Encrypt 操作中使用的 IV 是共享的或常量的，并且不是随机生成的。这意味着多次加密的相同文本将始终产生相同的加密结果。这不太安全，但对于需要查询的加密数据来说是必要的。可查询加密文本的一个例子是 OAuth Apikey。
+
+## 关键生成器
+
+keygenerators 类为构造不同类型的密钥生成器提供了许多方便的工厂方法。使用这个类，你可以创建一个 byteskeygenerator 来生成 byte[]键。你还可以构造一个 串键生成器 来生成 String 键。键盘生成器是线程安全的。
+
+### Byteskeygenerator
+
+使用 keygenerators.secureRandom Factory 方法生成由 secureRandom 实例支持的 byteskeygenerator:
+
+例 5。Byteskeygenerator
+
+爪哇
+
+```
+BytesKeyGenerator generator = KeyGenerators.secureRandom();
+byte[] key = generator.generateKey();
+```
+
+Kotlin
+
+```
+val generator = KeyGenerators.secureRandom()
+val key = generator.generateKey()
+```
+
+默认的密钥长度是 8 个字节。还有一个 keygenerators.secureRandom 变体，它提供对密钥长度的控制：
+
+例 6。keygenerators.secureRandom
+
+爪哇
+
+```
+KeyGenerators.secureRandom(16);
+```
+
+Kotlin
+
+```
+KeyGenerators.secureRandom(16)
+```
+
+使用 keygenerators.shared Factory 方法构造一个 byteskeygenerator，它总是在每次调用时返回相同的键：
+
+例 7。keygenerators.shared
+
+爪哇
+
+```
+KeyGenerators.shared(16);
+```
+
+Kotlin
+
+```
+KeyGenerators.shared(16)
+```
+
+### StringKeyGenerator
+
+使用 keygenerators.string Factory 方法构造一个 8 字节的安全随机密钥生成器，将每个密钥作为字符串进行十六进制编码：
+
+例 8。串键生成器
+
+爪哇
+
+```
+KeyGenerators.string();
+```
+
+Kotlin
+
+```
+KeyGenerators.string()
+```
+
+## 密码编码
+
+Spring-security-crypto 模块的密码包提供了对密码编码的支持。`PasswordEncoder`是中心服务接口，具有以下签名：
+
+```
+public interface PasswordEncoder {
+
+String encode(String rawPassword);
+
+boolean matches(String rawPassword, String encodedPassword);
+}
+```
+
+如果编码后的 RAWPassword 等于 EncodedPassword，则 Matches 方法返回 true。该方法旨在支持基于密码的身份验证方案。
+
+`BCryptPasswordEncoder`实现使用广泛支持的“bcrypt”算法来散列密码。Bcrypt 使用一个随机的 16 字节的盐值，并且是一个故意缓慢的算法，以阻止密码破解器。它所做的工作量可以使用“强度”参数进行调整，该参数的取值范围为 4 到 31。值越高，计算散列所需做的工作就越多。默认值是 10。你可以在部署的系统中更改该值，而不会影响现有的密码，因为该值也存储在编码的散列中。
+
+例 9。bcryptpasswordencoder
+
+爪哇
+
+```
+// Create an encoder with strength 16
+BCryptPasswordEncoder encoder = new BCryptPasswordEncoder(16);
+String result = encoder.encode("myPassword");
+assertTrue(encoder.matches("myPassword", result));
+```
+
+Kotlin
+
+```
+// Create an encoder with strength 16
+val encoder = BCryptPasswordEncoder(16)
+val result: String = encoder.encode("myPassword")
+assertTrue(encoder.matches("myPassword", result))
+```
+
+`Pbkdf2PasswordEncoder`实现使用 PBKDF2 算法来散列密码。为了击败密码破解，PBKDF2 是一个故意缓慢的算法，应该调整为大约 0.5 秒来验证你的系统上的密码。
+
+例 10。PBKDF2PASSWORDENCODER
+
+Java
+
+```
+// Create an encoder with all the defaults
+Pbkdf2PasswordEncoder encoder = new Pbkdf2PasswordEncoder();
+String result = encoder.encode("myPassword");
+assertTrue(encoder.matches("myPassword", result));
+```
+
+Kotlin
+
+```
+// Create an encoder with all the defaults
+val encoder = Pbkdf2PasswordEncoder()
+val result: String = encoder.encode("myPassword")
+assertTrue(encoder.matches("myPassword", result))
+```
\ No newline at end of file
diff --git a/docs/spring-security/features-integrations-data.md b/docs/spring-security/features-integrations-data.md
new file mode 100644
index 0000000000000000000000000000000000000000..68504ee72a399417e408f1315ac4d19b6bf695de
--- /dev/null
+++ b/docs/spring-security/features-integrations-data.md
@@ -0,0 +1,57 @@
+# Spring 数据集成
+
+Spring 安全性提供了 Spring 数据集成，允许在查询中引用当前用户。将用户包括在查询中以支持分页结果不仅是有用的，而且是必要的，因为在此之后对结果进行过滤将不会扩展。
+
+## Spring 数据和 Spring 安全配置
+
+要使用此支持，请添加`org.springframework.security:spring-security-data`依赖项，并提供类型`SecurityEvaluationContextExtension`的 Bean。在 爪哇 配置中，这看起来像是：
+
+爪哇
+
+```
+@Bean
+public SecurityEvaluationContextExtension securityEvaluationContextExtension() {
+ return new SecurityEvaluationContextExtension();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun securityEvaluationContextExtension(): SecurityEvaluationContextExtension {
+ return SecurityEvaluationContextExtension()
+}
+```
+
+在 XML 配置中，这看起来像是：
+
+```
+
+```
+
+## @query 中的安全表达式
+
+现在 Spring 可以在查询中使用安全性。例如：
+
+Java
+
+```
+@Repository
+public interface MessageRepository extends PagingAndSortingRepository {
+ @Query("select m from Message m where m.to.id = ?#{ principal?.id }")
+ Page findInbox(Pageable pageable);
+}
+```
+
+Kotlin
+
+```
+@Repository
+interface MessageRepository : PagingAndSortingRepository {
+ @Query("select m from Message m where m.to.id = ?#{ principal?.id }")
+ fun findInbox(pageable: Pageable?): Page?
+}
+```
+
+这将检查`Authentication.getPrincipal().getId()`是否等于`Message`的接收者。请注意，本例假定你已将主体自定义为具有 ID 属性的对象。通过公开`SecurityEvaluationContextExtension` Bean，查询中的所有[常见的安全表达式](../../servlet/authorization/expression-based.html#common-expressions)都是可用的。
\ No newline at end of file
diff --git a/docs/spring-security/features-integrations-jackson.md b/docs/spring-security/features-integrations-jackson.md
new file mode 100644
index 0000000000000000000000000000000000000000..30debd251680abfa8e2a0afa9f5b9f8cb83cca5c
--- /dev/null
+++ b/docs/spring-security/features-integrations-jackson.md
@@ -0,0 +1,36 @@
+# Jackson 支助
+
+Spring 安全性为持久化 Spring 与安全性相关的类提供了 Jackson 支持。这可以在使用分布式会话（即会话复制、 Spring 会话等）时提高序列化 Spring 安全相关类的性能。
+
+要使用它，将`SecurityJackson2Modules.getModules(ClassLoader)`注册为`ObjectMapper`（[Jackson-数据库](https://github.com/FasterXML/jackson-databind)）：
+
+爪哇
+
+```
+ObjectMapper mapper = new ObjectMapper();
+ClassLoader loader = getClass().getClassLoader();
+List modules = SecurityJackson2Modules.getModules(loader);
+mapper.registerModules(modules);
+
+// ... use ObjectMapper as normally ...
+SecurityContext context = new SecurityContextImpl();
+// ...
+String json = mapper.writeValueAsString(context);
+```
+
+Kotlin
+
+```
+val mapper = ObjectMapper()
+val loader = javaClass.classLoader
+val modules: MutableList = SecurityJackson2Modules.getModules(loader)
+mapper.registerModules(modules)
+
+// ... use ObjectMapper as normally ...
+val context: SecurityContext = SecurityContextImpl()
+// ...
+val json: String = mapper.writeValueAsString(context)
+```
+
+| |下面的 Spring 安全模块提供了 Jackson 支持：
* Spring-security-core（`CoreJackson2Module`）
* Spring-security-web（`WebJackson2Module`，`WebServletJackson2Module`，`WebServerJackson2Module`）
（<12"gt=">>（<10"/>r=“r=”10“>）r=“20”/>（<<>|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
\ No newline at end of file
diff --git a/docs/spring-security/features-integrations-localization.md b/docs/spring-security/features-integrations-localization.md
new file mode 100644
index 0000000000000000000000000000000000000000..9fe9fc1c64f0c4570f3e7515827f9f843460c32f
--- /dev/null
+++ b/docs/spring-security/features-integrations-localization.md
@@ -0,0 +1,22 @@
+# 本地化
+
+如果你需要支持其他语言环境，那么你需要了解的所有内容都包含在本节中。
+
+所有异常消息都可以本地化，包括与身份验证失败和访问被拒绝（授权失败）相关的消息。针对开发人员或系统部署人员的异常和日志消息（包括不正确的属性、违反接口契约、使用不正确的构造函数、启动时间验证、调试级别的日志记录）没有本地化，而是在 Spring Security 的代码中用英文进行了硬编码。
+
+在`spring-security-core-xx.jar`中，你将发现一个`org.springframework.security`包，该包依次包含一个`messages.properties`文件，以及一些常见语言的本地化版本。这应该由你的`ApplicationContext`来引用，因为 Spring 安全类实现了 Spring 的`MessageSourceAware`接口，并且期望消息解析程序是在应用程序上下文启动时注入的依赖项。通常，你所需要做的就是在应用程序上下文中注册一个 Bean 来引用消息。下面是一个例子：
+
+```
+
+
+
+```
+
+`messages.properties`是根据标准资源包命名的，表示 Spring 安全消息支持的默认语言。这个默认文件是英文的。
+
+如果你希望自定义`messages.properties`文件，或者支持其他语言，那么你应该复制该文件，对其进行相应的重命名，并将其注册到上述 Bean 定义中。在这个文件中没有大量的消息键，因此本地化不应该被认为是一项主要的举措。如果你确实执行了此文件的本地化，请考虑通过记录 JIRA 任务并附加适当命名的本地化版本`messages.properties`来与社区共享你的工作。
+
+Spring 安全性依赖于 Spring 的本地化支持，以便实际查找适当的消息。为了实现这一点，你必须确保来自传入请求的区域设置存储在 Spring 的`org.springframework.context.i18n.LocaleContextHolder`中。 Spring MVC 的`DispatcherServlet`自动为你的应用程序执行此操作，但是由于 Spring Security 的过滤器是在此之前调用的，因此在调用过滤器之前，需要设置`LocaleContextHolder`以包含正确的`Locale`。你可以自己在过滤器中执行此操作（它必须在`web.xml`中的 Spring 安全过滤器之前），也可以使用 Spring 的`RequestContextFilter`。请参阅 Spring 框架文档，以获取关于使用 Spring 本地化的更多详细信息。
+
+将“联系人”示例应用程序设置为使用本地化消息。
\ No newline at end of file
diff --git a/docs/spring-security/features-integrations.md b/docs/spring-security/features-integrations.md
new file mode 100644
index 0000000000000000000000000000000000000000..119ab019e5596714c53e91c711426edee7d0e65f
--- /dev/null
+++ b/docs/spring-security/features-integrations.md
@@ -0,0 +1,11 @@
+# 整合
+
+Spring 安全性提供了与众多框架和 API 的集成。在这一节中，我们将讨论不特定于 Servlet 或反应性环境的通用集成。要查看特定的集成，请参阅[Servlet](../../servlet/integrations/index.html)和[Reactive](../../servlet/integrations/index.html)集成部分。
+
+## 章节摘要
+
+* [密码学](cryptography.html)
+* [Spring Data](data.html)
+* [Java 的并发 API](concurrency.html)
+* [Jackson](jackson.html)
+* [本地化](localization.html)
\ No newline at end of file
diff --git a/docs/spring-security/features.md b/docs/spring-security/features.md
new file mode 100644
index 0000000000000000000000000000000000000000..8f6fada33a93c083e415430156e77e3058c93393
--- /dev/null
+++ b/docs/spring-security/features.md
@@ -0,0 +1,11 @@
+# 特征
+
+Spring 安全性为[认证](authentication/index.html)、[授权](authorization/index.html)和[共同的功绩](exploits/index.html#exploits)提供了全面的支持。它还提供了与其他库的集成，以简化其使用。
+
+## 章节摘要
+
+* [认证](authentication/index.html)
+* [保护免受剥削](exploits/index.html)
+* [整合](integrations/index.html)
+
+[Getting Spring Security](../getting-spring-security.html)[认证](authentication/index.html)
\ No newline at end of file
diff --git a/docs/spring-security/getting-spring-security.md b/docs/spring-security/getting-spring-security.md
new file mode 100644
index 0000000000000000000000000000000000000000..70c38a4e28967f526cd7187d840c16b949700d5a
--- /dev/null
+++ b/docs/spring-security/getting-spring-security.md
@@ -0,0 +1,275 @@
+# 获得 Spring 安全性
+
+本节讨论了有关获得 Spring 安全性二进制文件所需了解的所有信息。有关如何获得源代码，请参见[源代码](community.html#community-source)。
+
+## 发行版本编号
+
+Spring 安全版本的格式为 major.minor.patch，例如：
+
+* 主要的版本可能包含断开的更改。通常，这样做是为了提供与现代安全实践相匹配的改进的安全性。
+
+* 小版本包含增强功能，但被视为被动更新。
+
+* 补丁级别应该是完全兼容的，向前和向后，可能的例外情况是修复错误的更改。
+
+## Maven 的用法
+
+与大多数开源项目一样， Spring Security 将其依赖关系部署为 Maven 工件。本节中的主题提供了有关在使用 Maven 时如何使用 Spring 安全性的详细信息。
+
+### Spring 用 Maven 引导
+
+Spring Boot 提供了一个`spring-boot-starter-security`启动器，该启动器将 Spring 与安全相关的依赖关系聚合在一起。使用启动器的最简单和首选的方法是通过使用 IDE 集成（[Eclipse](https://joshlong.com/jl/blogPost/tech_tip_geting_started_with_spring_boot.html)，[IntelliJ](https://www.jetbrains.com/help/idea/spring-boot.html#d1489567e2)，[NetBeans](https://github.com/AlexFalappa/nb-springboot/wiki/Quick-Tour)）或通过[https://start.spring.io](https://start.spring.io)使用[Spring Initializr](https://docs.spring.io/initializr/docs/current/reference/html/)。
+
+或者，你也可以手动添加启动器，如下例所示：
+
+例 1。 POM.xml
+
+```
+
+
+
+ org.springframework.boot
+ spring-boot-starter-security
+
+
+```
+
+由于 Spring 启动提供了一个 Maven BOM 来管理依赖版本，因此你不需要指定版本。如果你希望重写 Spring 安全版本，那么可以通过提供 Maven 属性来实现，如下例所示：
+
+例 2。 POM.xml
+
+```
+
+
+ 5.6.2
+
+```
+
+由于 Spring 安全性仅在主要版本中进行破坏更改，因此使用具有 Spring 启动的 Spring 安全性的较新版本是安全的。然而，有时你可能还需要更新 Spring Framework 的版本。你可以通过添加一个 Maven 属性来做到这一点，如下例所示：
+
+例 3。 POM.xml
+
+```
+
+
+ 5.3.16
+
+```
+
+如果使用额外的功能（例如 LDAP、OpenID 和其他功能），还需要包括适当的[项目模块和依赖项](modules.html#modules)。
+
+### Maven 没有靴子
+
+当使用 Spring 安全性而不启动 Spring 时，首选的方法是使用 Spring 安全性的 BOM，以确保在整个项目中使用 Spring 安全性的一致版本。下面的示例展示了如何做到这一点：
+
+例 4。 POM.xml
+
+```
+
+
+
+
+ org.springframework.security
+ spring-security-bom
+ {spring-security-version}
+ pom
+ import
+
+
+
+```
+
+一组最小的 Spring 安全性 Maven 依赖关系通常如下所示：
+
+例 5。 POM.xml
+
+```
+
+
+
+ org.springframework.security
+ spring-security-web
+
+
+ org.springframework.security
+ spring-security-config
+
+
+```
+
+如果你使用了额外的功能（例如 LDAP、OpenID 和其他功能），则还需要包括适当的[项目模块和依赖项](modules.html#modules)。
+
+Spring 安全性是根据 Spring Framework5.3.16 构建的，但通常应该与 Spring Framework5.x 的任何较新版本一起工作。 Spring 安全性的传递依赖关系解决了 Spring Framework5.3.16，这可能会导致奇怪的 Classpath 问题，许多用户可能会对此感到不满。解决此问题的最简单方法是使用`spring-framework-bom`中``部分中的`pom.xml`，如下例所示：
+
+例 6。 POM.xml
+
+```
+
+
+
+
+ org.springframework
+ spring-framework-bom
+ 5.3.16
+ pom
+ import
+
+
+
+```
+
+前面的示例确保 Spring 安全性的所有传递依赖使用 Spring 5.3.16 模块。
+
+| |这种方法使用 Maven 的“物料清单”概念，并且仅在 Maven 2.0.9+ 中可用。
有关如何解决依赖关系的更多详细信息，请参见[Maven’s Introduction to the Dependency Mechanism documentation](https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html)。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### Maven 存储库
+
+所有 GA 版本（即以.release 结尾的版本）都部署到 Maven Central，因此不需要在 POM 中声明额外的 Maven 存储库。
+
+如果使用快照版本，则需要确保定义了 Spring 快照存储库，如下例所示：
+
+例 7。 POM.xml
+
+```
+
+
+
+ spring-snapshot
+ Spring Snapshot Repository
+ https://repo.spring.io/snapshot
+
+
+```
+
+如果使用里程碑或发布候选版本，则需要确保定义了 Spring 里程碑存储库，如下例所示：
+
+例 8。 POM.xml
+
+```
+
+
+
+ spring-milestone
+ Spring Milestone Repository
+ https://repo.spring.io/milestone
+
+
+```
+
+## Gradle
+
+与大多数开源项目一样， Spring Security 将其依赖关系部署为 Maven 工件，这允许一流的 Gradle 支持。以下主题提供了在使用 Gradle 时如何使用 Spring 安全性的详细信息。
+
+### Spring 用 Gradle 引导
+
+Spring 引导提供了一个`spring-boot-starter-security`启动器，该启动器将 Spring 安全相关的依赖关系聚合在一起。使用启动器的最简单和首选方法是通过使用 IDE 集成（[Eclipse](https://joshlong.com/jl/blogPost/tech_tip_geting_started_with_spring_boot.html)，[IntelliJ](https://www.jetbrains.com/help/idea/spring-boot.html#d1489567e2)，[NetBeans](https://github.com/AlexFalappa/nb-springboot/wiki/Quick-Tour)）或通过[https://start.spring.io](https://start.spring.io)使用[Spring Initializr](https://docs.spring.io/initializr/docs/current/reference/html/)。
+
+或者，你也可以手动添加启动器，如下例所示：
+
+示例 9.build. Gradle
+
+```
+dependencies {
+ compile "org.springframework.boot:spring-boot-starter-security"
+}
+```
+
+由于 Spring 启动提供了一个 Maven BOM 来管理依赖版本，所以不需要指定版本。如果你希望重写 Spring 安全版本，那么可以通过提供 Gradle 属性来实现，如下例所示：
+
+示例 10.构建。 Gradle
+
+```
+ext['spring-security.version']='5.6.2'
+```
+
+由于 Spring 安全性仅在主要版本中进行破坏更改，因此使用具有 Spring 启动的 Spring 安全性的较新版本是安全的。然而，有时你可能还需要更新 Spring 框架的版本。你可以通过添加一个 Gradle 属性来做到这一点，如下例所示：
+
+示例 11.build. Gradle
+
+```
+ext['spring.version']='5.3.16'
+```
+
+如果你使用了额外的功能（例如 LDAP、OpenID 和其他功能），则还需要包括适当的[项目模块和依赖项](modules.html#modules)。
+
+### Gradle 没有靴子
+
+当使用 Spring 安全性而不启动 Spring 时，首选的方法是使用 Spring 安全性的 BOM，以确保在整个项目中使用 Spring 安全性的一致版本。你可以通过使用[依赖管理插件 Name](https://github.com/spring-gradle-plugins/dependency-management-plugin)来实现这一点，如下例所示：
+
+例 12.build. Gradle
+
+```
+plugins {
+ id "io.spring.dependency-management" version "1.0.6.RELEASE"
+}
+
+dependencyManagement {
+ imports {
+ mavenBom 'org.springframework.security:spring-security-bom:5.6.2'
+ }
+}
+```
+
+Spring 安全性 Maven 依赖性的最小集合通常如下所示：
+
+例 13.build. Gradle
+
+```
+dependencies {
+ compile "org.springframework.security:spring-security-web"
+ compile "org.springframework.security:spring-security-config"
+}
+```
+
+如果你使用了额外的功能（例如 LDAP、OpenID 和其他功能），则还需要包括适当的[项目模块和依赖项](modules.html#modules)。
+
+Spring 安全性是根据 Spring Framework5.3.16 构建的，但通常应该与 Spring Framework5.x 的任何较新版本一起工作。 Spring 安全性的传递依赖关系解决了 Spring Framework5.3.16，这可能会导致奇怪的 Classpath 问题，许多用户可能会对此感到不满。解决此问题的最简单方法是在`pom.xml`的``部分中使用`spring-framework-bom`。你可以通过使用[依赖管理插件 Name](https://github.com/spring-gradle-plugins/dependency-management-plugin)来实现这一点，如下例所示：
+
+示例 14.build. Gradle
+
+```
+plugins {
+ id "io.spring.dependency-management" version "1.0.6.RELEASE"
+}
+
+dependencyManagement {
+ imports {
+ mavenBom 'org.springframework:spring-framework-bom:5.3.16'
+ }
+}
+```
+
+前面的示例确保 Spring 安全性的所有传递依赖使用 Spring 5.3.16 模块。
+
+### Gradle 存储库
+
+所有 GA 版本（即以.release 结尾的版本）都部署到 Maven Central，因此对于 GA 版本，使用 MavenCentral（）存储库就足够了。下面的示例展示了如何做到这一点：
+
+例 15.build. Gradle
+
+```
+repositories {
+ mavenCentral()
+}
+```
+
+如果使用快照版本，则需要确保定义了 Spring 快照存储库，如下例所示：
+
+示例 16.build. Gradle
+
+```
+repositories {
+ maven { url 'https://repo.spring.io/snapshot' }
+}
+```
+
+如果使用里程碑或发布候选版本，则需要确保定义了 Spring 里程碑存储库，如下例所示：
+
+示例 17.build. Gradle
+
+```
+repositories {
+ maven { url 'https://repo.spring.io/milestone' }
+}
+```
\ No newline at end of file
diff --git a/docs/spring-security/modules.md b/docs/spring-security/modules.md
new file mode 100644
index 0000000000000000000000000000000000000000..fff4dc8b8a3a9bb7226e6af575626d4382f21b91
--- /dev/null
+++ b/docs/spring-security/modules.md
@@ -0,0 +1,163 @@
+# 项目模块和依赖项
+
+即使你不使用 Maven，我们也建议你查阅`pom.xml`文件，以了解第三方的依赖关系和版本。另一个好主意是检查示例应用程序中包含的库。
+
+本节提供了 Spring Security 中的模块的参考，以及它们在运行中的应用程序中起作用所需的附加依赖关系。我们不包括仅在构建或测试 Spring 安全性本身时使用的依赖关系。我们也不包括外部依赖项所要求的传递依赖项。
+
+项目网站上列出了 Spring Required 的版本，因此在下面的 Spring 依赖项中省略了具体的版本。请注意，在 Spring 应用程序中的其他非安全功能可能仍然需要下面列出的一些“可选”依赖项。此外，如果在大多数应用程序中使用了被列为“可选”的依赖项，那么它们在项目的 Maven POM 文件中实际上可能不会被标记为可选的依赖项。它们是“可选的”，只是因为除非你使用指定的功能，否则你不需要它们。
+
+当一个模块依赖于另一个 Spring 安全模块时，它所依赖的模块的非可选依赖也被认为是必需的，并且不会单独列出。
+
+## 核心—`spring-security-core.jar`
+
+该模块包含核心身份验证和访问控制类和接口、远程支持和基本供应 API。任何使用 Spring 安全性的应用程序都需要它。它支持独立的应用程序、远程客户机、方法（服务层）安全性和 JDBC 用户配置。它包含以下顶级包：
+
+* `org.springframework.security.core`
+
+* `org.springframework.security.access`
+
+* `org.springframework.security.authentication`
+
+* `org.springframework.security.provisioning`
+
+| Dependency |Version|说明|
+|-----------------|-------|---------------------------------------------------------------------------|
+| ehcache | 1.6.2 |如果使用基于 EHCache 的用户缓存实现，则需要（可选）。|
+| spring-aop | |方法安全性基于 Spring AOP|
+| spring-beans | |Spring 配置所需|
+|spring-expression| |基于表达式的方法安全性所需（可选）|
+| spring-jdbc | |如果使用数据库存储用户数据（可选），则需要.|
+| spring-tx | |如果使用数据库存储用户数据（可选），则需要.|
+| aspectjrt |1.6.10 |如果使用 AspectJ 支持（可选），则是必需的。|
+| jsr250-api | 1.0 |如果你使用的是 JSR-250 方法-安全注释（可选），则需要这样做。|
+
+## remoting—`spring-security-remoting.jar`
+
+该模块提供了与 Spring 远程的集成。你不需要这样做，除非你正在编写使用远程处理的远程客户机。主包是`org.springframework.security.remoting`。
+
+| Dependency |Version|说明|
+|--------------------|-------|-----------------------------------------------------|
+|spring-security-core| | |
+| spring-web | |对于使用 HTTP 远程支持的客户端来说是必需的。|
+
+## web—`spring-security-web.jar`
+
+这个模块包含过滤器和相关的 Web 安全基础设施代码。它包含任何具有 Servlet API 依赖关系的内容。如果你需要 Spring 安全性 Web 身份验证服务和基于 URL 的访问控制，那么你就需要它。主包是`org.springframework.security.web`。
+
+| Dependency |Version|说明|
+|--------------------|-------|-------------------------------------------------------------------------------|
+|spring-security-core| | |
+| spring-web | |Spring Web 支持类被广泛使用。|
+| spring-jdbc | |基于 JDBC 的持久 Rememe-Me 令牌存储库所需（可选）.|
+| spring-tx | |Rememe-Me 持久令牌存储库实现所需（可选）.|
+
+## 配置—`spring-security-config.jar`
+
+这个模块包含安全名称空间解析代码和 Java 配置代码。如果你使用 Spring Security XML 名称空间进行配置或 Spring Security 的 Java 配置支持，那么你就需要它。主包是`org.springframework.security.config`。这些类都不打算在应用程序中直接使用。
+
+| Dependency |Version|说明|
+|----------------------|-------|-----------------------------------------------------------------------------|
+| spring-security-core | | |
+| spring-security-web | |如果你正在使用任何与 Web 相关的名称空间配置（可选），则需要这样做。|
+| spring-security-ldap | |如果你正在使用 LDAP 命名空间选项（可选），则是必需的。|
+|spring-security-openid| |如果你使用的是 OpenID 身份验证（可选的），则需要这样做。|
+| aspectjweaver |1.6.10 |如果使用 protect-pointcut 命名空间语法（可选），则需要.|
+
+## LDAP—`spring-security-ldap.jar`
+
+该模块提供 LDAP 身份验证和配置代码。如果你需要使用 LDAP 身份验证或管理 LDAP 用户条目，则需要使用它。顶级包是`org.springframework.security.ldap`。
+
+| Dependency |Version|说明|
+|-----------------------------------------------------------------------------------------------------------------------------------|-------|-----------------------------------------------------------------------------------------------------------------------------------------------|
+| spring-security-core | | |
+| spring-ldap-core | 1.3.0 |LDAP 支持基于 Spring LDAP。|
+| spring-tx | |数据异常类是必需的。|
+|apache-ds | 1.5.5 |如果你使用的是嵌入式 LDAP 服务器（可选），则需要这样做。|
+| shared-ldap |0.9.15 |如果你使用的是嵌入式 LDAP 服务器（可选），则需要这样做。|
+| ldapsdk | 4.1 |例如，如果你使用 OpenLDAP 的密码策略功能，则使用 Mozilla ldapsdk.对 LDAP 密码策略控件进行解码。|
+
+## OAuth2.0 核心—`spring-security-oauth2-core.jar`
+
+`spring-security-oauth2-core.jar`包含支持 OAuth2.0 授权框架和 OpenID Connect Core1.0 的核心类和接口。它是使用 OAuth2.0 或 OpenID Connect Core1.0 的应用程序所必需的，例如客户机、资源服务器和授权服务器。顶级包是`org.springframework.security.oauth2.core`。
+
+## OAuth2.0 客户端—`spring-security-oauth2-client.jar`
+
+`spring-security-oauth2-client.jar`包含 Spring Security 对 OAuth2.0 授权框架和 OpenID Connect Core1.0 的客户端支持。它是使用 OAuth2.0 登录或 OAuth 客户端支持的应用程序所必需的。顶级包是`org.springframework.security.oauth2.client`。
+
+## OAuth2.0Jose—`spring-security-oauth2-jose.jar`
+
+`spring-security-oauth2-jose.jar`包含 Spring Security 对 Jose（JavaScript 对象签名和加密）框架的支持。Jose 框架旨在提供一种在各方之间安全地转移权利要求的方法。它是由一系列规范构建而成的：
+
+* JSON Web Token
+
+* JSON Web 签名
+
+* JSON 网络加密
+
+* JSON Web Key
+
+它包含以下顶级包：
+
+* `org.springframework.security.oauth2.jwt`
+
+* `org.springframework.security.oauth2.jose`
+
+## OAuth2.0 资源服务器—`spring-security-oauth2-resource-server.jar`
+
+`spring-security-oauth2-resource-server.jar`包含 Spring Security 对 OAuth2.0 资源服务器的支持。它用于通过 OAuth2.0 承载令牌保护 API。顶级包是`org.springframework.security.oauth2.server.resource`。
+
+## ACL—`spring-security-acl.jar`
+
+这个模块包含一个专门的域对象 ACL 实现。它用于将安全性应用于应用程序中的特定域对象实例。顶级包是`org.springframework.security.acls`。
+
+| Dependency |Version|说明|
+|--------------------|-------|-------------------------------------------------------------------------------------------------------------------|
+|spring-security-core| | |
+| ehcache | 1.6.2 |如果使用了基于 EHCache 的 ACL 缓存实现，则需要（如果你使用自己的实现，则可以选择）。|
+| spring-jdbc | |如果你使用的是默认的基于 JDBC 的 ACLService（如果你实现了自己的 ACLService，则是可选的），则是必需的。|
+| spring-tx | |如果你使用的是默认的基于 JDBC 的 ACLService（如果你实现了自己的 ACLService，则是可选的），则是必需的。|
+
+## 化学文摘社—`spring-security-cas.jar`
+
+该模块包含 Spring Security 的 CAS 客户端集成。如果你想对 CAS 单点登录服务器使用 Spring 安全性 Web 身份验证，那么你应该使用它。顶级包是`org.springframework.security.cas`。
+
+| Dependency |Version|说明|
+|--------------------|-------|--------------------------------------------------------------------------------|
+|spring-security-core| | |
+|spring-security-web | | |
+| cas-client-core |3.1.12 |JA-SIG CAS 客户机.
这是 Spring 安全集成的基础。|
+| ehcache | 1.6.2 |如果你正在使用基于 EHCache 的票证缓存（可选），则需要这样做。|
+
+## OpenID—`spring-security-openid.jar`
+
+| |OpenID1.0 和 2.0 协议已被弃用，并鼓励用户迁移到 OpenID Connect，这得到了 Spring-Security-OAuth2 的支持。|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+此模块包含对 OpenID Web 身份验证的支持。它用于针对外部 OpenID 服务器对用户进行身份验证。顶级包是`org.springframework.security.openid`。它需要 OpenID4Java。
+
+| Dependency |Version|说明|
+|--------------------|-------|------------------------------------------------------|
+|spring-security-core| | |
+|spring-security-web | | |
+| openid4java-nodeps | 0.9.6 |Spring Security 的 OpenID 集成使用了 OpenID4Java。|
+| httpclient | 4.1.1 |OpenID4Java-Nodeps 依赖于 HttpClient4。|
+| guice | 2.0 |OpenID4Java-Nodeps 依赖于 Guice2。|
+
+## 测试—`spring-security-test.jar`
+
+该模块包含对具有 Spring 安全性的测试的支持。
+
+## taglibs—`spring-secuity-taglibs.jar`
+
+提供 Spring 安全性的 JSP 标记实现。
+
+| Dependency |Version|说明|
+|--------------------|-------|------------------------------------------------------------------------------------------------------------|
+|spring-security-core| | |
+|spring-security-web | | |
+|spring-security-acl | |如果使用带有 ACLS 的`accesscontrollist`标记或`hasPermission()`表达式（可选），则需要这样做。|
+| spring-expression | |如果你在标记访问约束中使用 SPEL 表达式，则需要这样做。|
+
+---
+
+[1](#_footnoteref_1)。需要的模块有`apacheds-core`，`apacheds-core-entry`，`apacheds-protocol-shared`，`apacheds-protocol-ldap`和`apacheds-server-jndi`。
\ No newline at end of file
diff --git a/docs/spring-security/overview.md b/docs/spring-security/overview.md
new file mode 100644
index 0000000000000000000000000000000000000000..b9f0a75875f1f848ff6698525ffae2a31bea87b5
--- /dev/null
+++ b/docs/spring-security/overview.md
@@ -0,0 +1,13 @@
+# Spring 安全
+
+Spring 安全性是提供[认证](features/authentication/index.html)、[授权](features/authorization/index.html)和[防范常见攻击](features/exploits/index.html)的框架。由于对[imperative](servlet/index.html)和[reactive](reactive/index.html)应用程序的安全都提供了第一类支持，因此它是保护基于 Spring 的应用程序的事实上的标准。
+
+有关功能的完整列表，请参见引用的[Features](features/index.html)部分。
+
+## 开始
+
+如果你准备好开始保护应用程序，请参阅[servlet](servlet/getting-started.html)和[reactive](reactive/getting-started.html)的入门部分。这些部分将引导你创建你的第一个安全应用程序。
+
+如果你想了解 Spring 安全性是如何工作的，那么可以参考[建筑](servlet/architecture.html)部分。
+
+如果你有任何问题，有一个很棒的[community](community.html)将很乐意帮助你！
\ No newline at end of file
diff --git a/docs/spring-security/prerequisites.md b/docs/spring-security/prerequisites.md
new file mode 100644
index 0000000000000000000000000000000000000000..18221384af11a47f3d0b45ad3ef38e897d8cee6f
--- /dev/null
+++ b/docs/spring-security/prerequisites.md
@@ -0,0 +1,9 @@
+# 先决条件
+
+Spring 安全性要求 Java8 或更高的运行时环境。
+
+Spring 由于安全性旨在以一种自包含的方式进行操作，因此你不需要在 Java 运行时环境中放置任何特殊的配置文件。特别是，你不需要配置特殊的 Java 身份验证和授权服务策略文件，也不需要将 Spring 安全性放入公共 Classpath 位置。
+
+类似地，如果使用 EJB 容器或 Servlet 容器，则不需要在任何地方放置任何特殊的配置文件，也不需要在服务器类加载器中包含 Spring 安全性。所有必需的文件都包含在你的应用程序中。
+
+这种设计提供了最大的部署时间灵活性，因为你可以将目标工件（无论是 JAR、WAR 还是 EAR）从一个系统复制到另一个系统，并且它可以立即工作。
\ No newline at end of file
diff --git a/docs/spring-security/reactive-authentication-logout.md b/docs/spring-security/reactive-authentication-logout.md
new file mode 100644
index 0000000000000000000000000000000000000000..617591acafd5fce69656c3bc8927ba4fe747971b
--- /dev/null
+++ b/docs/spring-security/reactive-authentication-logout.md
@@ -0,0 +1,24 @@
+# 注销
+
+Spring 安全性默认情况下提供注销端点。登录后，你可以`GET /logout`查看默认的注销确认页，或者`POST /logout`启动注销。这将：
+
+* 清除`ServerCsrfTokenRepository`，`ServerSecurityContextRepository`，并
+
+* 重定向回登录页面
+
+通常，你也希望注销时的会话无效。为了实现这一点，你可以将`WebSessionServerLogoutHandler`添加到你的注销配置中，如下所示：
+
+```
+@Bean
+SecurityWebFilterChain http(ServerHttpSecurity http) throws Exception {
+ DelegatingServerLogoutHandler logoutHandler = new DelegatingServerLogoutHandler(
+ new WebSessionServerLogoutHandler(), new SecurityContextServerLogoutHandler()
+ );
+
+ http
+ .authorizeExchange((exchange) -> exchange.anyExchange().authenticated())
+ .logout((logout) -> logout.logoutHandler(logoutHandler));
+
+ return http.build();
+}
+```
\ No newline at end of file
diff --git a/docs/spring-security/reactive-authentication-x509.md b/docs/spring-security/reactive-authentication-x509.md
new file mode 100644
index 0000000000000000000000000000000000000000..96dc86a0fd850ac50051ee7908671d58fe1ae4c5
--- /dev/null
+++ b/docs/spring-security/reactive-authentication-x509.md
@@ -0,0 +1,91 @@
+# 反应式 X.509 认证
+
+与[Servlet X.509 authentication](../../servlet/authentication/x509.html#servlet-x509)类似，Active X509 身份验证过滤器允许从客户端提供的证书中提取身份验证令牌。
+
+下面是一个反应式 X509 安全配置的示例：
+
+爪哇
+
+```
+@Bean
+public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
+ http
+ .x509(withDefaults())
+ .authorizeExchange(exchanges -> exchanges
+ .anyExchange().permitAll()
+ );
+ return http.build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun securityWebFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain {
+ return http {
+ x509 { }
+ authorizeExchange {
+ authorize(anyExchange, authenticated)
+ }
+ }
+}
+```
+
+在上面的配置中，当`principalExtractor`和`authenticationManager`都不提供时，将使用默认值。默认的主体提取器是`SubjectDnX509PrincipalExtractor`，它从客户机提供的证书中提取 CN（通用名称）字段。默认的身份验证管理器是`ReactivePreAuthenticatedAuthenticationManager`，它执行用户帐户验证，检查具有`principalExtractor`提取的名称的用户帐户是否存在，并且该帐户没有被锁定、禁用或过期。
+
+下一个示例演示了如何重写这些默认值。
+
+爪哇
+
+```
+@Bean
+public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
+ SubjectDnX509PrincipalExtractor principalExtractor =
+ new SubjectDnX509PrincipalExtractor();
+
+ principalExtractor.setSubjectDnRegex("OU=(.*?)(?:,|$)");
+
+ ReactiveAuthenticationManager authenticationManager = authentication -> {
+ authentication.setAuthenticated("Trusted Org Unit".equals(authentication.getName()));
+ return Mono.just(authentication);
+ };
+
+ http
+ .x509(x509 -> x509
+ .principalExtractor(principalExtractor)
+ .authenticationManager(authenticationManager)
+ )
+ .authorizeExchange(exchanges -> exchanges
+ .anyExchange().authenticated()
+ );
+ return http.build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun securityWebFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain? {
+ val customPrincipalExtractor = SubjectDnX509PrincipalExtractor()
+ customPrincipalExtractor.setSubjectDnRegex("OU=(.*?)(?:,|$)")
+ val customAuthenticationManager = ReactiveAuthenticationManager { authentication: Authentication ->
+ authentication.isAuthenticated = "Trusted Org Unit" == authentication.name
+ Mono.just(authentication)
+ }
+ return http {
+ x509 {
+ principalExtractor = customPrincipalExtractor
+ authenticationManager = customAuthenticationManager
+ }
+ authorizeExchange {
+ authorize(anyExchange, authenticated)
+ }
+ }
+}
+```
+
+在此示例中，从客户端证书的 OU 字段中提取用户名，而不是从 CN 中提取用户名，并且根本不执行使用`ReactiveUserDetailsService`的帐户查找。相反，如果将提供的证书颁发给名为“可信的组织单元”的 OU，则将对请求进行身份验证。
+
+有关配置 Netty 和`WebClient`或`curl`命令行工具以使用相互 TLS 并启用 X.509 身份验证的示例，请参见[https://github.com/spring-projects/spring-security-samples/tree/main/servlet/java-configuration/authentication/x509](https://github.com/spring-projects/spring-security-samples/tree/main/servlet/java-configuration/authentication/x509)。
\ No newline at end of file
diff --git a/docs/spring-security/reactive-authorization-authorize-http-requests.md b/docs/spring-security/reactive-authorization-authorize-http-requests.md
new file mode 100644
index 0000000000000000000000000000000000000000..b81351707a6bf073134ac1c4def5b4b799c00aa4
--- /dev/null
+++ b/docs/spring-security/reactive-authorization-authorize-http-requests.md
@@ -0,0 +1,92 @@
+# 授权 ServerHttpRequest
+
+Spring 安全性为授权传入的 HTTP 请求提供了支持。默认情况下， Spring Security 的授权将要求对所有请求进行身份验证。显式配置如下所示：
+
+例 1。所有请求都需要经过身份验证的用户。
+
+爪哇
+
+```
+@Bean
+SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
+ http
+ .authorizeExchange(exchanges -> exchanges
+ .anyExchange().authenticated()
+ )
+ .httpBasic(withDefaults())
+ .formLogin(withDefaults());
+ return http.build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain {
+ return http {
+ authorizeExchange {
+ authorize(anyExchange, authenticated)
+ }
+ formLogin { }
+ httpBasic { }
+ }
+}
+```
+
+我们可以通过按优先级顺序添加更多规则来配置 Spring 安全性，使其具有不同的规则。
+
+例 2。多个授权请求规则
+
+爪哇
+
+```
+import static org.springframework.security.authorization.AuthorityReactiveAuthorizationManager.hasRole;
+// ...
+@Bean
+SecurityWebFilterChain springWebFilterChain(ServerHttpSecurity http) {
+ // @formatter:off
+ http
+ // ...
+ .authorizeExchange((authorize) -> authorize (1)
+ .pathMatchers("/resources/**", "/signup", "/about").permitAll() (2)
+ .pathMatchers("/admin/**").hasRole("ADMIN") (3)
+ .pathMatchers("/db/**").access((authentication, context) -> (4)
+ hasRole("ADMIN").check(authentication, context)
+ .filter(decision -> !decision.isGranted())
+ .switchIfEmpty(hasRole("DBA").check(authentication, context))
+ )
+ .anyExchange().denyAll() (5)
+ );
+ // @formatter:on
+ return http.build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain {
+ return http {
+ authorizeExchange { (1)
+ authorize(pathMatchers("/resources/**", "/signup", "/about"), permitAll) (2)
+ authorize("/admin/**", hasRole("ADMIN")) (3)
+ authorize("/db/**", { authentication, context -> (4)
+ hasRole("ADMIN").check(authentication, context)
+ .filter({ decision -> !decision.isGranted() })
+ .switchIfEmpty(hasRole("DBA").check(authentication, context))
+ })
+ authorize(anyExchange, denyAll) (5)
+ }
+ // ...
+ }
+}
+```
+
+|**1**|指定了多个授权规则。
每个规则都按照它们被声明的顺序被考虑。|
+|-----|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|**2**|我们指定了任何用户都可以访问的多个 URL 模式。
具体来说，如果 URL 以“/resources/”开头，等于“/signup”或等于“/about”，则任何用户都可以访问请求。|
+|**3**|任何以“/admin/”开头的 URL 都将被限制为具有“role\_admin”权限的用户。
你将注意到，由于我们正在调用`hasRole`方法，因此我们不需要指定“role\_”前缀。|
+|**4**|任何以“/db/”开头的 URL 都需要用户同时具有“role\_admin”和“role\_DBA”。
这表明了提供自定义`ReactiveAuthorizationManager`的灵活性，允许我们实现任意的授权逻辑。
为了简单起见，示例使用 lambda 并将其委托给现有的`AuthorityReactiveAuthorizationManager.hasRole`实现。
但是，在实际情况下，应用程序可能会在实现`ReactiveAuthorizationManager`的适当类中实现该逻辑。|
+|**5**|任何尚未匹配的 URL 都将被拒绝访问。
如果你不想意外地忘记更新授权规则，这是一个很好的策略。|
\ No newline at end of file
diff --git a/docs/spring-security/reactive-authorization-method.md b/docs/spring-security/reactive-authorization-method.md
new file mode 100644
index 0000000000000000000000000000000000000000..2d1373e3b7485b8f34f256ae719b61016a8761b1
--- /dev/null
+++ b/docs/spring-security/reactive-authorization-method.md
@@ -0,0 +1,213 @@
+# EnableReactiveMethodSecurity
+
+Spring 安全性支持使用[反应堆的背景](https://projectreactor.io/docs/core/release/reference/#context)的方法安全性，其设置使用`ReactiveSecurityContextHolder`。例如，这演示了如何检索当前登录的用户消息。
+
+| |要使其工作，方法的返回类型必须是`org.reactivestreams.Publisher`（即`Mono`/`Flux`），或者函数必须是 Kotlin 协程函数。
这是与反应器的`Context`积分所必需的。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+爪哇
+
+```
+Authentication authentication = new TestingAuthenticationToken("user", "password", "ROLE_USER");
+
+Mono messageByUsername = ReactiveSecurityContextHolder.getContext()
+ .map(SecurityContext::getAuthentication)
+ .map(Authentication::getName)
+ .flatMap(this::findMessageByUsername)
+ // In a WebFlux application the `subscriberContext` is automatically setup using `ReactorContextWebFilter`
+ .subscriberContext(ReactiveSecurityContextHolder.withAuthentication(authentication));
+
+StepVerifier.create(messageByUsername)
+ .expectNext("Hi user")
+ .verifyComplete();
+```
+
+Kotlin
+
+```
+val authentication: Authentication = TestingAuthenticationToken("user", "password", "ROLE_USER")
+
+val messageByUsername: Mono = ReactiveSecurityContextHolder.getContext()
+ .map(SecurityContext::getAuthentication)
+ .map(Authentication::getName)
+ .flatMap(this::findMessageByUsername) // In a WebFlux application the `subscriberContext` is automatically setup using `ReactorContextWebFilter`
+ .subscriberContext(ReactiveSecurityContextHolder.withAuthentication(authentication))
+
+StepVerifier.create(messageByUsername)
+ .expectNext("Hi user")
+ .verifyComplete()
+```
+
+用`this::findMessageByUsername`定义为：
+
+爪哇
+
+```
+Mono findMessageByUsername(String username) {
+ return Mono.just("Hi " + username);
+}
+```
+
+Kotlin
+
+```
+fun findMessageByUsername(username: String): Mono {
+ return Mono.just("Hi $username")
+}
+```
+
+下面是在反应性应用程序中使用方法安全性时的最小方法安全配置。
+
+爪哇
+
+```
+@EnableReactiveMethodSecurity
+public class SecurityConfig {
+ @Bean
+ public MapReactiveUserDetailsService userDetailsService() {
+ User.UserBuilder userBuilder = User.withDefaultPasswordEncoder();
+ UserDetails rob = userBuilder.username("rob")
+ .password("rob")
+ .roles("USER")
+ .build();
+ UserDetails admin = userBuilder.username("admin")
+ .password("admin")
+ .roles("USER","ADMIN")
+ .build();
+ return new MapReactiveUserDetailsService(rob, admin);
+ }
+}
+```
+
+Kotlin
+
+```
+@EnableReactiveMethodSecurity
+class SecurityConfig {
+ @Bean
+ fun userDetailsService(): MapReactiveUserDetailsService {
+ val userBuilder: User.UserBuilder = User.withDefaultPasswordEncoder()
+ val rob = userBuilder.username("rob")
+ .password("rob")
+ .roles("USER")
+ .build()
+ val admin = userBuilder.username("admin")
+ .password("admin")
+ .roles("USER", "ADMIN")
+ .build()
+ return MapReactiveUserDetailsService(rob, admin)
+ }
+}
+```
+
+考虑以下类：
+
+爪哇
+
+```
+@Component
+public class HelloWorldMessageService {
+ @PreAuthorize("hasRole('ADMIN')")
+ public Mono findMessage() {
+ return Mono.just("Hello World!");
+ }
+}
+```
+
+Kotlin
+
+```
+@Component
+class HelloWorldMessageService {
+ @PreAuthorize("hasRole('ADMIN')")
+ fun findMessage(): Mono {
+ return Mono.just("Hello World!")
+ }
+}
+```
+
+或者，使用 Kotlin 协程的下列类：
+
+Kotlin
+
+```
+@Component
+class HelloWorldMessageService {
+ @PreAuthorize("hasRole('ADMIN')")
+ suspend fun findMessage(): String {
+ delay(10)
+ return "Hello World!"
+ }
+}
+```
+
+结合上面的配置，`@PreAuthorize("hasRole('ADMIN')")`将确保`findByMessage`仅由具有`ADMIN`角色的用户调用。需要注意的是，标准方法安全性中的任何表达式都可以用于`@EnableReactiveMethodSecurity`。但是，此时我们只支持返回类型为`Boolean`或`boolean`的表达式。这意味着表达式不能阻塞。
+
+当与[WebFlux 安全性](../configuration/webflux.html#jc-webflux)集成时，反应器上下文由 Spring 安全性根据经过身份验证的用户自动建立。
+
+爪哇
+
+```
+@EnableWebFluxSecurity
+@EnableReactiveMethodSecurity
+public class SecurityConfig {
+
+ @Bean
+ SecurityWebFilterChain springWebFilterChain(ServerHttpSecurity http) throws Exception {
+ return http
+ // Demonstrate that method security works
+ // Best practice to use both for defense in depth
+ .authorizeExchange(exchanges -> exchanges
+ .anyExchange().permitAll()
+ )
+ .httpBasic(withDefaults())
+ .build();
+ }
+
+ @Bean
+ MapReactiveUserDetailsService userDetailsService() {
+ User.UserBuilder userBuilder = User.withDefaultPasswordEncoder();
+ UserDetails rob = userBuilder.username("rob")
+ .password("rob")
+ .roles("USER")
+ .build();
+ UserDetails admin = userBuilder.username("admin")
+ .password("admin")
+ .roles("USER","ADMIN")
+ .build();
+ return new MapReactiveUserDetailsService(rob, admin);
+ }
+}
+```
+
+Kotlin
+
+```
+@EnableWebFluxSecurity
+@EnableReactiveMethodSecurity
+class SecurityConfig {
+ @Bean
+ open fun springWebFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain {
+ return http {
+ authorizeExchange {
+ authorize(anyExchange, permitAll)
+ }
+ httpBasic { }
+ }
+ }
+
+ @Bean
+ fun userDetailsService(): MapReactiveUserDetailsService {
+ val userBuilder: User.UserBuilder = User.withDefaultPasswordEncoder()
+ val rob = userBuilder.username("rob")
+ .password("rob")
+ .roles("USER")
+ .build()
+ val admin = userBuilder.username("admin")
+ .password("admin")
+ .roles("USER", "ADMIN")
+ .build()
+ return MapReactiveUserDetailsService(rob, admin)
+ }
+}
+```
\ No newline at end of file
diff --git a/docs/spring-security/reactive-configuration-webflux.md b/docs/spring-security/reactive-configuration-webflux.md
new file mode 100644
index 0000000000000000000000000000000000000000..0ceb74656931b54b872c2edf3087ffbbd9185c38
--- /dev/null
+++ b/docs/spring-security/reactive-configuration-webflux.md
@@ -0,0 +1,217 @@
+# WebFlux 安全性
+
+Spring Security 的 WebFlux 支持依赖于`WebFilter`，并且对 Spring WebFlux 和 Spring WebFlux.FN 的工作原理相同。你可以找到一些示例应用程序来演示下面的代码：
+
+* Hello WebFlux[HelloWebFlux ](https://github.com/spring-projects/spring-security-samples/tree/5.6.x/reactive/webflux/java/hello-security)
+
+* FN[HelloWebFluxFN ](https://github.com/spring-projects/spring-security-samples/tree/5.6.x/reactive/webflux-fn/hello-security)
+
+* Hello WebFlux 方法[HelloWebFlux 方法](https://github.com/spring-projects/spring-security-samples/tree/5.6.x/reactive/webflux/java/method)
+
+## 最小 WebFlux 安全配置
+
+你可以在下面找到最小的 WebFlux 安全配置：
+
+例 1。最小 WebFlux 安全配置
+
+爪哇
+
+```
+@EnableWebFluxSecurity
+public class HelloWebfluxSecurityConfig {
+
+ @Bean
+ public MapReactiveUserDetailsService userDetailsService() {
+ UserDetails user = User.withDefaultPasswordEncoder()
+ .username("user")
+ .password("user")
+ .roles("USER")
+ .build();
+ return new MapReactiveUserDetailsService(user);
+ }
+}
+```
+
+Kotlin
+
+```
+@EnableWebFluxSecurity
+class HelloWebfluxSecurityConfig {
+
+ @Bean
+ fun userDetailsService(): ReactiveUserDetailsService {
+ val userDetails = User.withDefaultPasswordEncoder()
+ .username("user")
+ .password("user")
+ .roles("USER")
+ .build()
+ return MapReactiveUserDetailsService(userDetails)
+ }
+}
+```
+
+该配置提供表单和 HTTP 基本身份验证，设置授权以要求经过身份验证的用户访问任何页面，设置默认的登录页面和默认的注销页面，设置与安全相关的 HTTP 标题，CSRF 保护，等等。
+
+## 显式 WebFlux 安全配置
+
+你可以在下面找到最小 WebFlux 安全配置的显式版本：
+
+例 2。显式 WebFlux 安全配置
+
+爪哇
+
+```
+@Configuration
+@EnableWebFluxSecurity
+public class HelloWebfluxSecurityConfig {
+
+ @Bean
+ public MapReactiveUserDetailsService userDetailsService() {
+ UserDetails user = User.withDefaultPasswordEncoder()
+ .username("user")
+ .password("user")
+ .roles("USER")
+ .build();
+ return new MapReactiveUserDetailsService(user);
+ }
+
+ @Bean
+ public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
+ http
+ .authorizeExchange(exchanges -> exchanges
+ .anyExchange().authenticated()
+ )
+ .httpBasic(withDefaults())
+ .formLogin(withDefaults());
+ return http.build();
+ }
+}
+```
+
+Kotlin
+
+```
+@Configuration
+@EnableWebFluxSecurity
+class HelloWebfluxSecurityConfig {
+
+ @Bean
+ fun userDetailsService(): ReactiveUserDetailsService {
+ val userDetails = User.withDefaultPasswordEncoder()
+ .username("user")
+ .password("user")
+ .roles("USER")
+ .build()
+ return MapReactiveUserDetailsService(userDetails)
+ }
+
+ @Bean
+ fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain {
+ return http {
+ authorizeExchange {
+ authorize(anyExchange, authenticated)
+ }
+ formLogin { }
+ httpBasic { }
+ }
+ }
+}
+```
+
+这个配置显式地设置了与我们的最小配置相同的所有内容。从这里，你可以轻松地对默认值进行更改。
+
+通过在`config/src/test/`目录中搜索[enableWebfluxsecurity]（https://github.com/ Spring-projects/ Spring-security/search？q=path%3aconfig%2fsrc%2ftest%2f+enableWebfluxsecurity），你可以在单元测试中找到更多显式配置的示例。
+
+### 多链支撑
+
+你可以通过`RequestMatcher`s 将多个`SecurityWebFilterChain`实例配置为单独的配置。
+
+例如，可以为以`/api`开头的 URL 隔离配置，如下所示：
+
+爪哇
+
+```
+@Configuration
+@EnableWebFluxSecurity
+static class MultiSecurityHttpConfig {
+
+ @Order(Ordered.HIGHEST_PRECEDENCE) (1)
+ @Bean
+ SecurityWebFilterChain apiHttpSecurity(ServerHttpSecurity http) {
+ http
+ .securityMatcher(new PathPatternParserServerWebExchangeMatcher("/api/**")) (2)
+ .authorizeExchange((exchanges) -> exchanges
+ .anyExchange().authenticated()
+ )
+ .oauth2ResourceServer(OAuth2ResourceServerSpec::jwt); (3)
+ return http.build();
+ }
+
+ @Bean
+ SecurityWebFilterChain webHttpSecurity(ServerHttpSecurity http) { (4)
+ http
+ .authorizeExchange((exchanges) -> exchanges
+ .anyExchange().authenticated()
+ )
+ .httpBasic(withDefaults()); (5)
+ return http.build();
+ }
+
+ @Bean
+ ReactiveUserDetailsService userDetailsService() {
+ return new MapReactiveUserDetailsService(
+ PasswordEncodedUser.user(), PasswordEncodedUser.admin());
+ }
+
+}
+```
+
+Kotlin
+
+```
+@Configuration
+@EnableWebFluxSecurity
+open class MultiSecurityHttpConfig {
+ @Order(Ordered.HIGHEST_PRECEDENCE) (1)
+ @Bean
+ open fun apiHttpSecurity(http: ServerHttpSecurity): SecurityWebFilterChain {
+ return http {
+ securityMatcher(PathPatternParserServerWebExchangeMatcher("/api/**")) (2)
+ authorizeExchange {
+ authorize(anyExchange, authenticated)
+ }
+ oauth2ResourceServer {
+ jwt { } (3)
+ }
+ }
+ }
+
+ @Bean
+ open fun webHttpSecurity(http: ServerHttpSecurity): SecurityWebFilterChain { (4)
+ return http {
+ authorizeExchange {
+ authorize(anyExchange, authenticated)
+ }
+ httpBasic { } (5)
+ }
+ }
+
+ @Bean
+ open fun userDetailsService(): ReactiveUserDetailsService {
+ return MapReactiveUserDetailsService(
+ PasswordEncodedUser.user(), PasswordEncodedUser.admin()
+ )
+ }
+}
+```
+
+|**1**|将`SecurityWebFilterChain`配置为`@Order`，以指定安全应该首先考虑哪个`SecurityWebFilterChain` Spring|
+|-----|------------------------------------------------------------------------------------------------------------------------------------------------|
+|**2**|使用`PathPatternParserServerWebExchangeMatcher`声明此`SecurityWebFilterChain`将仅适用于以`/api/`开头的 URL 路径|
+|**3**|指定将用于`/api/**`端点的身份验证机制|
+|**4**|创建另一个优先级较低的`SecurityWebFilterChain`实例，以匹配所有其他 URL|
+|**5**|指定将用于应用程序其余部分的身份验证机制|
+
+Spring 安全性将为每个请求选择一个`SecurityWebFilterChain``@Bean`。它将按照`securityMatcher`定义的顺序匹配请求。
+
+在这种情况下，这意味着如果 URL 路径以`/api`开始，那么 Spring Security 将使用`apiHttpSecurity`。如果 URL 不以`/api`开头，则 Spring Security 将默认为`webHttpSecurity`，其中隐含的`securityMatcher`与任何请求匹配。
\ No newline at end of file
diff --git a/docs/spring-security/reactive-exploits-csrf.md b/docs/spring-security/reactive-exploits-csrf.md
new file mode 100644
index 0000000000000000000000000000000000000000..e5b24875fce68fd766430d7471ff842bd86d2829
--- /dev/null
+++ b/docs/spring-security/reactive-exploits-csrf.md
@@ -0,0 +1,340 @@
+# WebFlux 环境中的跨站点请求伪造
+
+本节讨论 Spring Security 对 WebFlux 环境的[跨站点请求伪造](../../features/exploits/csrf.html#csrf)支持。
+
+## 使用 Spring 安全 CSRF 保护
+
+使用 Spring Security 的 CSRF 保护的步骤概述如下：
+
+* [使用适当的 HTTP 动词](#webflux-csrf-idempotent)
+
+* [配置 CSRF 保护](#webflux-csrf-configure)
+
+* [包括 CSRF 令牌](#webflux-csrf-include)
+
+### 使用适当的 HTTP 动词
+
+防止 CSRF 攻击的第一步是确保你的网站使用正确的 HTTP 动词。这在[安全的方法必须是幂等的。](../../features/exploits/csrf.html#csrf-protection-idempotent)中有详细介绍。
+
+### 配置 CSRF 保护
+
+下一步是在应用程序中配置 Spring Security 的 CSRF 保护。 Spring 默认情况下，Security 的 CSRF 保护是启用的，但你可能需要定制配置。下面是一些常见的定制。
+
+#### 自定义 CSRFTokenRepository
+
+默认情况下， Spring Security 使用`WebSessionServerCsrfTokenRepository`将预期的 CSRF 令牌存储在`WebSession`中。在某些情况下，用户可能希望配置自定义`ServerCsrfTokenRepository`。例如，可能希望将 cookie 中的`CsrfToken`持久化到[支持基于 爪哇Script 的应用程序](#webflux-csrf-include-ajax-auto)。
+
+默认情况下，`CookieServerCsrfTokenRepository`将写到一个名为`XSRF-TOKEN`的 cookie，并从一个名为`X-XSRF-TOKEN`的头部或 HTTP 参数`_csrf`读取它。这些默认值来自[AngularJS](https://docs.angularjs.org/api/ng/service/$http#cross-site-request-forgery-xsrf-protection)
+
+你可以在 爪哇 配置中使用以下方法配置`CookieServerCsrfTokenRepository`:
+
+例 1。在 cookie 中存储 CSRF 令牌
+
+爪哇
+
+```
+@Bean
+public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
+ http
+ // ...
+ .csrf(csrf -> csrf.csrfTokenRepository(CookieServerCsrfTokenRepository.withHttpOnlyFalse()))
+ return http.build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain {
+ return http {
+ // ...
+ csrf {
+ csrfTokenRepository = CookieServerCsrfTokenRepository.withHttpOnlyFalse()
+ }
+ }
+}
+```
+
+| |示例显式设置`cookieHttpOnly=false`.
这是允许 爪哇Script（即 Angularjs）读取它所必需的。
如果不需要直接使用 爪哇Script 读取 cookie 的能力，建议省略`cookieHttpOnly=false`（通过使用`new CookieServerCsrfTokenRepository()`代替）以提高安全性。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+#### 禁用 CSRF 保护
+
+默认情况下启用了 CSRF 保护。但是，如果 CSRF 保护[对你的应用程序来说是有意义的](../../features/exploits/csrf.html#csrf-when)，则禁用 CSRF 保护非常简单。
+
+下面的 Java 配置将禁用 CSRF 保护。
+
+例 2。禁用 CSRF 配置
+
+Java
+
+```
+@Bean
+public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
+ http
+ // ...
+ .csrf(csrf -> csrf.disable()))
+ return http.build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain {
+ return http {
+ // ...
+ csrf {
+ disable()
+ }
+ }
+}
+```
+
+### 包括 CSRF 令牌
+
+为了使[同步器令牌模式](../../features/exploits/csrf.html#csrf-protection-stp)能够抵御 CSRF 攻击，我们必须在 HTTP 请求中包含实际的 CSRF 令牌。这必须包含在请求的一部分（即表单参数、HTTP 头等）中，而该部分不是由浏览器自动包含在 HTTP 请求中的。
+
+Spring Security 的[CSRFWebfilter ](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/web/server/csrf/CsrfWebFilter.html)将[Mono\](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/web/csrf/CsrfToken.html)公开为名为`ServerWebExchange`的属性。这意味着，任何视图技术都可以访问`Mono`以将预期的令牌公开为[form](#webflux-csrf-include-form-attr)或[meta tag](#webflux-csrf-include-ajax-meta)。
+
+如果你的视图技术没有提供订阅`Mono`的简单方法，那么一个常见的模式是使用 Spring 的`@ControllerAdvice`直接公开`CsrfToken`。例如，以下代码将在 Spring Security 的[CsrfrequestDataValueProcessor ](#webflux-csrf-include-form-auto)使用的默认属性名（`_csrf`）上放置`CsrfToken`，以自动将 CSRF 令牌作为隐藏输入。
+
+例 3。`CsrfToken`as`@ModelAttribute`
+
+Java
+
+```
+@ControllerAdvice
+public class SecurityControllerAdvice {
+ @ModelAttribute
+ Mono csrfToken(ServerWebExchange exchange) {
+ Mono csrfToken = exchange.getAttribute(CsrfToken.class.getName());
+ return csrfToken.doOnSuccess(token -> exchange.getAttributes()
+ .put(CsrfRequestDataValueProcessor.DEFAULT_CSRF_ATTR_NAME, token));
+ }
+}
+```
+
+Kotlin
+
+```
+@ControllerAdvice
+class SecurityControllerAdvice {
+ @ModelAttribute
+ fun csrfToken(exchange: ServerWebExchange): Mono {
+ val csrfToken: Mono? = exchange.getAttribute(CsrfToken::class.java.name)
+ return csrfToken!!.doOnSuccess { token ->
+ exchange.attributes[CsrfRequestDataValueProcessor.DEFAULT_CSRF_ATTR_NAME] = token
+ }
+ }
+}
+```
+
+幸运的是，ThymeLeaf 提供了[整合](#webflux-csrf-include-form-auto)，它的工作不需要任何额外的工作。
+
+#### 表单 URL 编码
+
+为了发布 HTML 表单，CSRF 令牌必须作为隐藏输入包含在表单中。例如，呈现的 HTML 可能看起来像：
+
+例 4。CSRF 令牌 HTML
+
+```
+
+```
+
+接下来，我们将讨论将 CSRF 令牌以一种形式包含为隐藏输入的各种方法。
+
+##### CSRF 令牌自动包含
+
+Spring Security 的 CSRF 支持通过其[CsrfrequestDataValueProcessor ](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/web/reactive/result/view/CsrfRequestDataValueProcessor.html)提供与 Spring 的[RequestDataValueProcessor ](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/reactive/result/view/RequestDataValueProcessor.html)的集成。为了使`CsrfRequestDataValueProcessor`工作，必须订阅`Mono`，并且`CsrfToken`必须是与[作为属性公开](#webflux-csrf-include-subscribe)匹配的[默认 \_CSRF\_ATTR\_Name ](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/web/reactive/result/view/CsrfRequestDataValueProcessor.html#DEFAULT_CSRF_ATTR_NAME)。
+
+幸运的是，ThymeLeaf[提供支持](https://www.thymeleaf.org/doc/tutorials/2.1/thymeleafspring.html#integration-with-requestdatavalueprocessor)通过与`RequestDataValueProcessor`集成来为你处理所有的样板文件，以确保具有不安全的 HTTP 方法（即 POST）的窗体将自动包括实际的 CSRF 令牌。
+
+##### CSRFToken 请求属性
+
+如果用于在请求中包含实际 CSRF 令牌的[其他选择](#webflux-csrf-include)不起作用，则可以利用以下事实：`Mono`[is exposed](#webflux-csrf-include)作为`ServerWebExchange`属性，该属性名为`org.springframework.security.web.server.csrf.CsrfToken`。
+
+下面的 ThymeLeaf 示例假设你在一个名为`_csrf`的属性上[expose](#webflux-csrf-include-subscribe)。
+
+例 5。具有请求属性的表单中的 CSRF 令牌
+
+```
+
+```
+
+#### Ajax 和 JSON 请求
+
+如果你正在使用 JSON，那么就不可能在 HTTP 参数中提交 CSRF 令牌。相反，你可以在 HTTP 头中提交令牌。
+
+在下面的部分中，我们将讨论在基于 JavaScript 的应用程序中将 CSRF 令牌作为 HTTP 请求头包含在内的各种方法。
+
+##### 自动包含
+
+Spring 安全性可以很容易地[configured](#webflux-csrf-configure-custom-repository)将预期的 CSRF 令牌存储在 cookie 中。通过将预期的 CSRF 存储在 Cookie 中，像[AngularJS](https://docs.angularjs.org/api/ng/service/$http#cross-site-request-forgery-xsrf-protection)这样的 JavaScript 框架将自动在 HTTP 请求头中包含实际的 CSRF 令牌。
+
+##### 元标签
+
+[在 cookie 中暴露 CSRF ](#webflux-csrf-include-form-auto)的另一种模式是在`meta`标记中包含 CSRF 标记。HTML 可能看起来是这样的：
+
+例 6。CSRF 元标记 HTML
+
+```
+
+
+
+
+
+
+
+```
+
+一旦元标记包含 CSRF 令牌，JavaScript 代码将读取元标记并将 CSRF 令牌作为报头。如果你正在使用 jQuery，可以通过以下方式完成此操作：
+
+例 7。Ajax 发送 CSRF 令牌
+
+```
+$(function () {
+ var token = $("meta[name='_csrf']").attr("content");
+ var header = $("meta[name='_csrf_header']").attr("content");
+ $(document).ajaxSend(function(e, xhr, options) {
+ xhr.setRequestHeader(header, token);
+ });
+});
+```
+
+下面的示例假设你在名为`_csrf`的属性上`CsrfToken`。使用 Thymeleaf 进行此操作的示例如下所示：
+
+例 8。CSRF 元标记 JSP
+
+```
+
+
+
+
+
+
+
+
+```
+
+## CSRF 考虑因素
+
+在实施针对 CSRF 攻击的保护时，有几个特殊的考虑因素需要考虑。本节讨论了与 WebFlux 环境相关的那些注意事项。有关更一般的讨论，请参见[CSRF 考虑因素](../../features/exploits/csrf.html#csrf-considerations)。
+
+### 登录
+
+这是重要的[需要 CSRF 才能登录](../../features/exploits/csrf.html#csrf-considerations-login)请求，以防止伪造日志的企图。 Spring Security 的 WebFlux 支持提供了开箱即用的服务。
+
+### 注销
+
+重要的是[需要 CSRF 才能注销](../../features/exploits/csrf.html#csrf-considerations-logout)请求，以防止伪造注销尝试。默认情况下 Spring Security 的`LogoutWebFilter`只处理 HTTP POST 请求。这确保了注销需要 CSRF 令牌，并且恶意用户不能强制注销你的用户。
+
+最简单的方法是使用表单注销。如果你真的想要一个链接，可以使用 JavaScript 让该链接执行一个 POST（例如，可能在一个隐藏的表单上）。对于禁用了 JavaScript 的浏览器，你可以选择让链接将用户带到将执行 POST 的注销确认页面。
+
+如果你真的想使用 HTTP GET 与注销，你可以这样做，但请记住，这通常是不推荐的。例如，下面的 Java 配置将使用任何 HTTP 方法请求的 URL`/logout`执行注销：
+
+例 9。用 HTTP GET 登出
+
+Java
+
+```
+@Bean
+public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
+ http
+ // ...
+ .logout(logout -> logout.requiresLogout(new PathPatternParserServerWebExchangeMatcher("/logout")))
+ return http.build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain {
+ return http {
+ // ...
+ logout {
+ requiresLogout = PathPatternParserServerWebExchangeMatcher("/logout")
+ }
+ }
+}
+```
+
+### CSRF 和会话暂停
+
+默认情况下， Spring Security 将 CSRF 令牌存储在`WebSession`中。这可能导致会话过期的情况，这意味着没有预期的 CSRF 令牌来验证。
+
+我们已经讨论了[一般解决方案](../../features/exploits/csrf.html#csrf-considerations-login)到会话的超时。本节讨论 CSRF 超时的细节，因为它与 WebFlux 支持有关。
+
+将预期的 CSRF 令牌的存储更改为 cookie 中的存储是很简单的。有关详细信息，请参阅[自定义 CSRFTokenRepository ](#webflux-csrf-configure-custom-repository)部分。
+
+###
+
+我们有[已经讨论过了](../../features/exploits/csrf.html#csrf-considerations-multipart)如何保护多部分请求（文件上传）不受 CSRF 攻击导致[鸡和蛋](https://en.wikipedia.org/wiki/Chicken_or_the_egg)问题。本节讨论如何在 WebFlux 应用程序中实现将 CSRF 令牌放置在[body](#webflux-csrf-considerations-multipart-body)和[url](#webflux-csrf-considerations-multipart-url)中。
+
+| |关于使用具有 Spring 的多部分表单的更多信息可以在 Spring 引用的[多部分数据](https://docs.spring.io/spring/docs/5.2.x/spring-framework-reference/web-reactive.html#webflux-multipart)部分中找到。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+#### 将 CSRF 标记放入体内
+
+我们有[已经讨论过了](../../features/exploits/csrf.html#csrf-considerations-multipart)在主体中放置 CSRF 标记的权衡。
+
+在 WebFlux 应用程序中，可以使用以下配置对其进行配置：
+
+例 10。启用从多部分/表单数据获取 CSRF 令牌
+
+Java
+
+```
+@Bean
+public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
+ http
+ // ...
+ .csrf(csrf -> csrf.tokenFromMultipartDataEnabled(true))
+ return http.build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain {
+ return http {
+ // ...
+ csrf {
+ tokenFromMultipartDataEnabled = true
+ }
+ }
+}
+```
+
+#### 在 URL 中包含 CSRF 令牌
+
+我们有[已经讨论过了](../../features/exploits/csrf.html#csrf-considerations-multipart)在 URL 中放置 CSRF 标记的权衡。由于`CsrfToken`被公开为`ServerHttpRequest`[请求属性](#webflux-csrf-include)，因此我们可以使用它来创建带有 CSRF 令牌的`action`。ThymeLeaf 的一个示例如下所示：
+
+例 11。CSRF 令牌正在运行
+
+```
+