From 7b758bce126f974e20bc0fdb4b63e0dac21b7950 Mon Sep 17 00:00:00 2001
From: ZhangKai <zhangkai@csdn.net>
Date: Wed, 9 Mar 2022 20:33:40 +0800
Subject: [PATCH] =?UTF-8?q?#18=20spring=20security=20=E5=9F=BA=E6=9C=AC?=
 =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E5=AE=A1=E6=A0=B8=E8=B0=83=E6=95=B4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/.vuepress/config.js                      |  198 ++-
 ...ive-oauth2-resource-server-opaque-token.md |   43 +-
 .../servlet-configuration-xml-namespace.md    |  249 ++++
 docs/spring-security/servlet-exploits-csrf.md |  389 +++++
 .../servlet-exploits-firewall.md              |  202 +++
 .../servlet-exploits-headers.md               | 1092 ++++++++++++++
 docs/spring-security/servlet-exploits-http.md |   72 +
 docs/spring-security/servlet-exploits.md      |   13 +
 .../servlet-getting-started.md                |   79 +
 .../servlet-integrations-concurrency.md       |  146 ++
 .../servlet-integrations-cors.md              |  116 ++
 .../servlet-integrations-data.md              |   59 +
 .../servlet-integrations-jackson.md           |   23 +
 .../servlet-integrations-jsp-taglibs.md       |  163 +++
 .../servlet-integrations-localization.md      |   24 +
 .../servlet-integrations-mvc.md               |  508 +++++++
 .../servlet-integrations-servlet-api.md       |  216 +++
 .../servlet-integrations-websocket.md         |  441 ++++++
 docs/spring-security/servlet-integrations.md  |   17 +
 docs/spring-security/servlet-oauth2-.md       |   11 +
 ...vlet-oauth2-client-authorization-grants.md | 1176 +++++++++++++++
 ...ervlet-oauth2-client-authorized-clients.md |  254 ++++
 ...let-oauth2-client-client-authentication.md |  154 ++
 .../servlet-oauth2-client-core.md             |  406 ++++++
 docs/spring-security/servlet-oauth2-client.md |  154 ++
 .../servlet-oauth2-login-advanced.md          |  872 +++++++++++
 .../servlet-oauth2-login-core.md              |  509 +++++++
 docs/spring-security/servlet-oauth2-login.md  |   13 +
 ...et-oauth2-resource-server-bearer-tokens.md |  269 ++++
 .../servlet-oauth2-resource-server-jwt.md     | 1280 +++++++++++++++++
 ...let-oauth2-resource-server-multitenancy.md |  425 ++++++
 ...let-oauth2-resource-server-opaque-token.md |  831 +++++++++++
 .../servlet-oauth2-resource-server.md         |   54 +
 ...let-saml2-login-authentication-requests.md |  270 ++++
 .../servlet-saml2-login-authentication.md     |  357 +++++
 .../servlet-saml2-login-overview.md           |  779 ++++++++++
 docs/spring-security/servlet-saml2-login.md   |   19 +
 docs/spring-security/servlet-saml2-logout.md  |  282 ++++
 .../spring-security/servlet-saml2-metadata.md |   67 +
 docs/spring-security/servlet-saml2.md         |   11 +
 docs/spring-security/servlet-test-method.md   |  554 +++++++
 .../servlet-test-mockmvc-authentication.md    |  237 +++
 .../servlet-test-mockmvc-csrf.md              |   54 +
 .../servlet-test-mockmvc-form-login.md        |   51 +
 .../servlet-test-mockmvc-http-basic.md        |   26 +
 .../servlet-test-mockmvc-logout.md            |   35 +
 .../servlet-test-mockmvc-oauth2.md            | 1048 ++++++++++++++
 .../servlet-test-mockmvc-request-builders.md  |   17 +
 ...et-test-mockmvc-request-post-processors.md |   26 +
 .../servlet-test-mockmvc-result-handlers.md   |   54 +
 .../servlet-test-mockmvc-result-matchers.md   |  134 ++
 .../servlet-test-mockmvc-setup.md             |   60 +
 docs/spring-security/servlet-test-mockmvc.md  |    5 +
 docs/spring-security/servlet-test.md          |   19 +
 docs/spring-security/servlet.md               |   19 +
 docs/spring-security/whats-new.md             |   67 +
 56 files changed, 14554 insertions(+), 95 deletions(-)
 create mode 100644 docs/spring-security/servlet-configuration-xml-namespace.md
 create mode 100644 docs/spring-security/servlet-exploits-csrf.md
 create mode 100644 docs/spring-security/servlet-exploits-firewall.md
 create mode 100644 docs/spring-security/servlet-exploits-headers.md
 create mode 100644 docs/spring-security/servlet-exploits-http.md
 create mode 100644 docs/spring-security/servlet-exploits.md
 create mode 100644 docs/spring-security/servlet-getting-started.md
 create mode 100644 docs/spring-security/servlet-integrations-concurrency.md
 create mode 100644 docs/spring-security/servlet-integrations-cors.md
 create mode 100644 docs/spring-security/servlet-integrations-data.md
 create mode 100644 docs/spring-security/servlet-integrations-jackson.md
 create mode 100644 docs/spring-security/servlet-integrations-jsp-taglibs.md
 create mode 100644 docs/spring-security/servlet-integrations-localization.md
 create mode 100644 docs/spring-security/servlet-integrations-mvc.md
 create mode 100644 docs/spring-security/servlet-integrations-servlet-api.md
 create mode 100644 docs/spring-security/servlet-integrations-websocket.md
 create mode 100644 docs/spring-security/servlet-integrations.md
 create mode 100644 docs/spring-security/servlet-oauth2-.md
 create mode 100644 docs/spring-security/servlet-oauth2-client-authorization-grants.md
 create mode 100644 docs/spring-security/servlet-oauth2-client-authorized-clients.md
 create mode 100644 docs/spring-security/servlet-oauth2-client-client-authentication.md
 create mode 100644 docs/spring-security/servlet-oauth2-client-core.md
 create mode 100644 docs/spring-security/servlet-oauth2-client.md
 create mode 100644 docs/spring-security/servlet-oauth2-login-advanced.md
 create mode 100644 docs/spring-security/servlet-oauth2-login-core.md
 create mode 100644 docs/spring-security/servlet-oauth2-login.md
 create mode 100644 docs/spring-security/servlet-oauth2-resource-server-bearer-tokens.md
 create mode 100644 docs/spring-security/servlet-oauth2-resource-server-jwt.md
 create mode 100644 docs/spring-security/servlet-oauth2-resource-server-multitenancy.md
 create mode 100644 docs/spring-security/servlet-oauth2-resource-server-opaque-token.md
 create mode 100644 docs/spring-security/servlet-oauth2-resource-server.md
 create mode 100644 docs/spring-security/servlet-saml2-login-authentication-requests.md
 create mode 100644 docs/spring-security/servlet-saml2-login-authentication.md
 create mode 100644 docs/spring-security/servlet-saml2-login-overview.md
 create mode 100644 docs/spring-security/servlet-saml2-login.md
 create mode 100644 docs/spring-security/servlet-saml2-logout.md
 create mode 100644 docs/spring-security/servlet-saml2-metadata.md
 create mode 100644 docs/spring-security/servlet-saml2.md
 create mode 100644 docs/spring-security/servlet-test-method.md
 create mode 100644 docs/spring-security/servlet-test-mockmvc-authentication.md
 create mode 100644 docs/spring-security/servlet-test-mockmvc-csrf.md
 create mode 100644 docs/spring-security/servlet-test-mockmvc-form-login.md
 create mode 100644 docs/spring-security/servlet-test-mockmvc-http-basic.md
 create mode 100644 docs/spring-security/servlet-test-mockmvc-logout.md
 create mode 100644 docs/spring-security/servlet-test-mockmvc-oauth2.md
 create mode 100644 docs/spring-security/servlet-test-mockmvc-request-builders.md
 create mode 100644 docs/spring-security/servlet-test-mockmvc-request-post-processors.md
 create mode 100644 docs/spring-security/servlet-test-mockmvc-result-handlers.md
 create mode 100644 docs/spring-security/servlet-test-mockmvc-result-matchers.md
 create mode 100644 docs/spring-security/servlet-test-mockmvc-setup.md
 create mode 100644 docs/spring-security/servlet-test-mockmvc.md
 create mode 100644 docs/spring-security/servlet-test.md
 create mode 100644 docs/spring-security/servlet.md
 create mode 100644 docs/spring-security/whats-new.md

diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index 5ccce22..39045cd 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -483,105 +483,159 @@ module.exports = {
                             sidebarDepth: 2,
                             collapsable: false,
                             children: [
+                                "/spring-security/overview.md",
+                                "/spring-security/prerequisites.md",
                                 "/spring-security/community.md",
-                                "/spring-security/features-authentication-password-storage.md",
+                                "/spring-security/whats-new.md",
+                                "/spring-security/getting-spring-security.md",
+                                "/spring-security/features.md",
                                 "/spring-security/features-authentication.md",
+                                "/spring-security/features-authentication-password-storage.md",
+                                "/spring-security/features-exploits.md",
                                 "/spring-security/features-exploits-csrf.md",
                                 "/spring-security/features-exploits-headers.md",
                                 "/spring-security/features-exploits-http.md",
-                                "/spring-security/features-exploits.md",
-                                "/spring-security/features-integrations-concurrency.md",
+                                "/spring-security/features-integrations.md",
                                 "/spring-security/features-integrations-cryptography.md",
                                 "/spring-security/features-integrations-data.md",
+                                "/spring-security/features-integrations-concurrency.md",
                                 "/spring-security/features-integrations-jackson.md",
                                 "/spring-security/features-integrations-localization.md",
-                                "/spring-security/features-integrations.md",
-                                "/spring-security/features.md",
-                                "/spring-security/getting-spring-security.md",
                                 "/spring-security/modules.md",
-                                "/spring-security/overview.md",
-                                "/spring-security/prerequisites.md",
-                                "/spring-security/reactive-authentication-logout.md",
-                                "/spring-security/reactive-authentication-x509.md",
-                                "/spring-security/reactive-authorization-authorize-http-requests.md",
-                                "/spring-security/reactive-authorization-method.md",
-                                "/spring-security/reactive-configuration-webflux.md",
-                                "/spring-security/reactive-exploits-csrf.md",
-                                "/spring-security/reactive-exploits-headers.md",
-                                "/spring-security/reactive-exploits-http.md",
-                                "/spring-security/reactive-exploits.md",
-                                "/spring-security/reactive-getting-started.md",
-                                "/spring-security/reactive-integrations-cors.md",
-                                "/spring-security/reactive-integrations-rsocket.md",
-                                "/spring-security/reactive-oauth2-client-authorization-grants.md",
-                                "/spring-security/reactive-oauth2-client-authorized-clients.md",
-                                "/spring-security/reactive-oauth2-client-client-authentication.md",
-                                "/spring-security/reactive-oauth2-client-core.md",
-                                "/spring-security/reactive-oauth2-client.md",
-                                "/spring-security/reactive-oauth2-login-advanced.md",
-                                "/spring-security/reactive-oauth2-login-core.md",
-                                "/spring-security/reactive-oauth2-login.md",
-                                "/spring-security/reactive-oauth2-resource-server-bearer-tokens.md",
-                                "/spring-security/reactive-oauth2-resource-server-jwt.md",
-                                "/spring-security/reactive-oauth2-resource-server-multitenancy.md",
-                                "/spring-security/reactive-oauth2-resource-server-opaque-token.md",
-                                "/spring-security/reactive-oauth2-resource-server.md",
-                                "/spring-security/reactive-oauth2.md",
-                                "/spring-security/reactive-test-method.md",
-                                "/spring-security/reactive-test-web-authentication.md",
-                                "/spring-security/reactive-test-web-csrf.md",
-                                "/spring-security/reactive-test-web-oauth2.md",
-                                "/spring-security/reactive-test-web-setup.md",
-                                "/spring-security/reactive-test-web.md",
-                                "/spring-security/reactive-test.md",
-                                "/spring-security/reactive.md",
                                 "/spring-security/samples.md",
-                                "/spring-security/servlet-appendix-database-schema.md",
-                                "/spring-security/servlet-appendix-faq.md",
-                                "/spring-security/servlet-appendix-namespace-authentication-manager.md",
-                                "/spring-security/servlet-appendix-namespace-http.md",
-                                "/spring-security/servlet-appendix-namespace-ldap.md",
-                                "/spring-security/servlet-appendix-namespace-method-security.md",
-                                "/spring-security/servlet-appendix-namespace-websocket.md",
-                                "/spring-security/servlet-appendix-namespace.md",
-                                "/spring-security/servlet-appendix.md",
+                                "/spring-security/servlet.md",
+                                "/spring-security/servlet-getting-started.md",
                                 "/spring-security/servlet-architecture.md",
-                                "/spring-security/servlet-authentication-anonymous.md",
+                                "/spring-security/servlet-authentication.md",
                                 "/spring-security/servlet-authentication-architecture.md",
-                                "/spring-security/servlet-authentication-cas.md",
-                                "/spring-security/servlet-authentication-events.md",
-                                "/spring-security/servlet-authentication-jaas.md",
-                                "/spring-security/servlet-authentication-logout.md",
-                                "/spring-security/servlet-authentication-openid.md",
+                                "/spring-security/servlet-authentication-passwords.md",
+                                "/spring-security/servlet-authentication-passwords-input.md",
+                                "/spring-security/servlet-authentication-passwords-form.md",
                                 "/spring-security/servlet-authentication-passwords-basic.md",
                                 "/spring-security/servlet-authentication-passwords-digest.md",
-                                "/spring-security/servlet-authentication-passwords-form.md",
-                                "/spring-security/servlet-authentication-passwords-input.md",
-                                "/spring-security/servlet-authentication-passwords-storage-dao-authentication-provider.md",
+                                "/spring-security/servlet-authentication-passwords-storage.md",
                                 "/spring-security/servlet-authentication-passwords-storage-in-memory.md",
                                 "/spring-security/servlet-authentication-passwords-storage-jdbc.md",
-                                "/spring-security/servlet-authentication-passwords-storage-ldap.md",
-                                "/spring-security/servlet-authentication-passwords-storage-password-encoder.md",
-                                "/spring-security/servlet-authentication-passwords-storage-user-details-service.md",
                                 "/spring-security/servlet-authentication-passwords-storage-user-details.md",
-                                "/spring-security/servlet-authentication-passwords-storage.md",
-                                "/spring-security/servlet-authentication-passwords.md",
-                                "/spring-security/servlet-authentication-preauth.md",
-                                "/spring-security/servlet-authentication-rememberme.md",
-                                "/spring-security/servlet-authentication-runas.md",
+                                "/spring-security/servlet-authentication-passwords-storage-user-details-service.md",
+                                "/spring-security/servlet-authentication-passwords-storage-password-encoder.md",
+                                "/spring-security/servlet-authentication-passwords-storage-dao-authentication-provider.md",
+                                "/spring-security/servlet-authentication-passwords-storage-ldap.md",
                                 "/spring-security/servlet-authentication-session-management.md",
+                                "/spring-security/servlet-authentication-rememberme.md",
+                                "/spring-security/servlet-authentication-openid.md",
+                                "/spring-security/servlet-authentication-anonymous.md",
+                                "/spring-security/servlet-authentication-preauth.md",
+                                "/spring-security/servlet-authentication-jaas.md",
+                                "/spring-security/servlet-authentication-cas.md",
                                 "/spring-security/servlet-authentication-x509.md",
-                                "/spring-security/servlet-authentication.md",
+                                "/spring-security/servlet-authentication-runas.md",
+                                "/spring-security/servlet-authentication-logout.md",
+                                "/spring-security/servlet-authentication-events.md",
                                 "/spring-security/servlet-authorization-.md",
-                                "/spring-security/servlet-authorization-acls.md",
                                 "/spring-security/servlet-authorization-architecture.md",
                                 "/spring-security/servlet-authorization-authorize-http-requests.md",
                                 "/spring-security/servlet-authorization-authorize-requests.md",
                                 "/spring-security/servlet-authorization-expression-based.md",
-                                "/spring-security/servlet-authorization-method-security.md",
                                 "/spring-security/servlet-authorization-secure-objects.md",
+                                "/spring-security/servlet-authorization-method-security.md",
+                                "/spring-security/servlet-authorization-acls.md",
+                                "/spring-security/servlet-oauth2-.md",
+                                "/spring-security/servlet-oauth2-login.md",
+                                "/spring-security/servlet-oauth2-login-core.md",
+                                "/spring-security/servlet-oauth2-login-advanced.md",
+                                "/spring-security/servlet-oauth2-client.md",
+                                "/spring-security/servlet-oauth2-client-core.md",
+                                "/spring-security/servlet-oauth2-client-authorization-grants.md",
+                                "/spring-security/servlet-oauth2-client-client-authentication.md",
+                                "/spring-security/servlet-oauth2-client-authorized-clients.md",
+                                "/spring-security/servlet-oauth2-resource-server.md",
+                                "/spring-security/servlet-oauth2-resource-server-jwt.md",
+                                "/spring-security/servlet-oauth2-resource-server-opaque-token.md",
+                                "/spring-security/servlet-oauth2-resource-server-multitenancy.md",
+                                "/spring-security/servlet-oauth2-resource-server-bearer-tokens.md",
+                                "/spring-security/servlet-saml2.md",
+                                "/spring-security/servlet-saml2-login.md",
+                                "/spring-security/servlet-saml2-login-overview.md",
+                                "/spring-security/servlet-saml2-login-authentication-requests.md",
+                                "/spring-security/servlet-saml2-login-authentication.md",
+                                "/spring-security/servlet-saml2-logout.md",
+                                "/spring-security/servlet-saml2-metadata.md",
+                                "/spring-security/servlet-exploits.md",
+                                "/spring-security/servlet-exploits-csrf.md",
+                                "/spring-security/servlet-exploits-headers.md",
+                                "/spring-security/servlet-exploits-http.md",
+                                "/spring-security/servlet-exploits-firewall.md",
+                                "/spring-security/servlet-integrations.md",
+                                "/spring-security/servlet-integrations-concurrency.md",
+                                "/spring-security/servlet-integrations-jackson.md",
+                                "/spring-security/servlet-integrations-localization.md",
+                                "/spring-security/servlet-integrations-servlet-api.md",
+                                "/spring-security/servlet-integrations-data.md",
+                                "/spring-security/servlet-integrations-mvc.md",
+                                "/spring-security/servlet-integrations-websocket.md",
+                                "/spring-security/servlet-integrations-cors.md",
+                                "/spring-security/servlet-integrations-jsp-taglibs.md",
                                 "/spring-security/servlet-configuration-java.md",
-                                "/spring-security/servlet-configuration-kotlin.md"
+                                "/spring-security/servlet-configuration-kotlin.md",
+                                "/spring-security/servlet-configuration-xml-namespace.md",
+                                "/spring-security/servlet-test.md",
+                                "/spring-security/servlet-test-method.md",
+                                "/spring-security/servlet-test-mockmvc.md",
+                                "/spring-security/servlet-test-mockmvc-setup.md",
+                                "/spring-security/servlet-test-mockmvc-request-post-processors.md",
+                                "/spring-security/servlet-test-mockmvc-authentication.md",
+                                "/spring-security/servlet-test-mockmvc-csrf.md",
+                                "/spring-security/servlet-test-mockmvc-form-login.md",
+                                "/spring-security/servlet-test-mockmvc-http-basic.md",
+                                "/spring-security/servlet-test-mockmvc-oauth2.md",
+                                "/spring-security/servlet-test-mockmvc-logout.md",
+                                "/spring-security/servlet-test-mockmvc-request-builders.md",
+                                "/spring-security/servlet-test-mockmvc-result-matchers.md",
+                                "/spring-security/servlet-test-mockmvc-result-handlers.md",
+                                "/spring-security/servlet-appendix.md",
+                                "/spring-security/servlet-appendix-database-schema.md",
+                                "/spring-security/servlet-appendix-namespace.md",
+                                "/spring-security/servlet-appendix-namespace-authentication-manager.md",
+                                "/spring-security/servlet-appendix-namespace-http.md",
+                                "/spring-security/servlet-appendix-namespace-method-security.md",
+                                "/spring-security/servlet-appendix-namespace-ldap.md",
+                                "/spring-security/servlet-appendix-namespace-websocket.md",
+                                "/spring-security/servlet-appendix-faq.md",
+                                "/spring-security/reactive.md",
+                                "/spring-security/reactive-getting-started.md",
+                                "/spring-security/reactive-authentication-x509.md",
+                                "/spring-security/reactive-authentication-logout.md",
+                                "/spring-security/reactive-authorization-authorize-http-requests.md",
+                                "/spring-security/reactive-authorization-method.md",
+                                "/spring-security/reactive-oauth2.md",
+                                "/spring-security/reactive-oauth2-login.md",
+                                "/spring-security/reactive-oauth2-login-core.md",
+                                "/spring-security/reactive-oauth2-login-advanced.md",
+                                "/spring-security/reactive-oauth2-client.md",
+                                "/spring-security/reactive-oauth2-client-core.md",
+                                "/spring-security/reactive-oauth2-client-authorization-grants.md",
+                                "/spring-security/reactive-oauth2-client-client-authentication.md",
+                                "/spring-security/reactive-oauth2-client-authorized-clients.md",
+                                "/spring-security/reactive-oauth2-resource-server.md",
+                                "/spring-security/reactive-oauth2-resource-server-jwt.md",
+                                "/spring-security/reactive-oauth2-resource-server-opaque-token.md",
+                                "/spring-security/reactive-oauth2-resource-server-multitenancy.md",
+                                "/spring-security/reactive-oauth2-resource-server-bearer-tokens.md",
+                                "/spring-security/reactive-exploits.md",
+                                "/spring-security/reactive-exploits-csrf.md",
+                                "/spring-security/reactive-exploits-headers.md",
+                                "/spring-security/reactive-exploits-http.md",
+                                "/spring-security/reactive-integrations-cors.md",
+                                "/spring-security/reactive-integrations-rsocket.md",
+                                "/spring-security/reactive-test.md",
+                                "/spring-security/reactive-test-method.md",
+                                "/spring-security/reactive-test-web.md",
+                                "/spring-security/reactive-test-web-setup.md",
+                                "/spring-security/reactive-test-web-authentication.md",
+                                "/spring-security/reactive-test-web-csrf.md",
+                                "/spring-security/reactive-test-web-oauth2.md",
+                                "/spring-security/reactive-configuration-webflux.md"
                             ],
                             initialOpenGroupIndex: 0 // 可选的, 默认值是 0
                         }
diff --git a/docs/spring-security/reactive-oauth2-resource-server-opaque-token.md b/docs/spring-security/reactive-oauth2-resource-server-opaque-token.md
index 0189d5e..0a3e69a 100644
--- a/docs/spring-security/reactive-oauth2-resource-server-opaque-token.md
+++ b/docs/spring-security/reactive-oauth2-resource-server-opaque-token.md
@@ -74,7 +74,7 @@ Authorization: Bearer some-token-value # Resource Server will process this
 
 这意味着当在配置中使用`@EnableWebFlux`时，它可以在`@Controller`方法中使用：
 
-爪哇
+Java
 
 ```
 @GetMapping("/foo")
@@ -94,7 +94,7 @@ fun foo(authentication: BearerTokenAuthentication): Mono<String> {
 
 由于`BearerTokenAuthentication`持有`OAuth2AuthenticatedPrincipal`，这也意味着控制器方法也可以使用它：
 
-爪哇
+Java
 
 ```
 @GetMapping("/foo")
@@ -118,7 +118,7 @@ fun foo(@AuthenticationPrincipal principal: OAuth2AuthenticatedPrincipal): Mono<
 
 例如，如果使用`@EnableReactiveMethodSecurity`使你可以使用`@PreAuthorize`注释，则可以这样做：
 
-爪哇
+Java
 
 ```
 @PreAuthorize("principal?.attributes['sub'] = 'foo'")
@@ -142,7 +142,7 @@ fun forFoosEyesOnly(): Mono<String> {
 
 第一个是将应用程序配置为资源服务器的`SecurityWebFilterChain`。当使用不透明令牌时，这个`SecurityWebFilterChain`看起来像：
 
-爪哇
+Java
 
 ```
 @Bean
@@ -178,7 +178,7 @@ fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain
 
 例 1。替换 SecurityWebFilterchain
 
-爪哇
+Java
 
 ```
 @EnableWebFluxSecurity
@@ -225,7 +225,7 @@ fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain
 
 例如，第二个`@Bean` Spring 启动创建了一个`ReactiveOpaqueTokenIntrospector`，它将`String`令牌解码为`OAuth2AuthenticatedPrincipal`的验证实例：
 
-爪哇
+Java
 
 ```
 @Bean
@@ -247,11 +247,10 @@ fun introspector(): ReactiveOpaqueTokenIntrospector {
 
 并且它的配置可以使用`introspectionUri()`和`introspectionClientCredentials()`进行重写，或者使用`introspector()`进行替换。
 
-### `
-
+### 使用`inrospectionUri()`
 可以配置授权服务器的内省 URI[作为配置属性](#webflux-oauth2resourceserver-opaque-introspectionuri)，也可以在 DSL 中提供它：
 
-爪哇
+Java
 
 ```
 @EnableWebFluxSecurity
@@ -292,13 +291,11 @@ fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain
 }
 ```
 
-使用`introspectionUri()`优先于任何配置属性。
-
-### `
+### 使用`introspectionUri()`优先于任何配置属性。
 
 比`introspectionUri()`更强大的是`introspector()`，它将完全取代`ReactiveOpaqueTokenIntrospector`的任何引导自动配置：
 
-爪哇
+Java
 
 ```
 @EnableWebFluxSecurity
@@ -343,7 +340,7 @@ fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain
 
 或者，暴露`ReactiveOpaqueTokenIntrospector``@Bean`具有与`introspector()`相同的效果：
 
-爪哇
+Java
 
 ```
 @Bean
@@ -371,7 +368,7 @@ OAuth2.0 内省端点通常会返回一个`scope`属性，指示它被授予的
 
 这意味着，要保护具有由不透明令牌派生的作用域的端点或方法，相应的表达式应该包括以下前缀：
 
-爪哇
+Java
 
 ```
 @EnableWebFluxSecurity
@@ -410,7 +407,7 @@ fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain
 
 或类似于方法安全性：
 
-爪哇
+Java
 
 ```
 @PreAuthorize("hasAuthority('SCOPE_messages')")
@@ -441,7 +438,7 @@ fun getMessages(): Flux<Message> { }
 
 当然，这可以使用自定义`ReactiveOpaqueTokenIntrospector`进行定制，该自定义`ReactiveOpaqueTokenIntrospector`查看属性集并以其自己的方式进行转换：
 
-爪哇
+Java
 
 ```
 public class CustomAuthoritiesOpaqueTokenIntrospector implements ReactiveOpaqueTokenIntrospector {
@@ -486,7 +483,7 @@ class CustomAuthoritiesOpaqueTokenIntrospector : ReactiveOpaqueTokenIntrospector
 
 在此之后，可以简单地将此自定义内省检测器配置为`@Bean`:
 
-爪哇
+Java
 
 ```
 @Bean
@@ -529,7 +526,7 @@ spring:
 
 在这种情况下，你可以创建一个自定义的`ReactiveOpaqueTokenIntrospector`，它仍然会到达端点，但随后会更新返回的主体，使其具有 JWTS 声明的属性：
 
-爪哇
+Java
 
 ```
 public class JwtOpaqueTokenIntrospector implements ReactiveOpaqueTokenIntrospector {
@@ -581,7 +578,7 @@ class JwtOpaqueTokenIntrospector : ReactiveOpaqueTokenIntrospector {
 
 在此之后，可以简单地将此自定义内省检测器配置为`@Bean`:
 
-爪哇
+Java
 
 ```
 @Bean
@@ -613,7 +610,7 @@ fun introspector(): ReactiveOpaqueTokenIntrospector {
 
 * 调用并返回来自`/userinfo`端点的响应
 
-爪哇
+Java
 
 ```
 public class UserInfoOpaqueTokenIntrospector implements ReactiveOpaqueTokenIntrospector {
@@ -668,7 +665,7 @@ class UserInfoOpaqueTokenIntrospector : ReactiveOpaqueTokenIntrospector {
 
 如果你 AREN 不使用`spring-security-oauth2-client`，它仍然很简单。你只需要用你自己的`WebClient`实例调用`/userinfo`:
 
-爪哇
+Java
 
 ```
 public class UserInfoOpaqueTokenIntrospector implements ReactiveOpaqueTokenIntrospector {
@@ -700,7 +697,7 @@ class UserInfoOpaqueTokenIntrospector : ReactiveOpaqueTokenIntrospector {
 
 无论哪种方式，在创建了`ReactiveOpaqueTokenIntrospector`之后，你应该将其发布为`@Bean`，以覆盖默认值：
 
-爪哇
+Java
 
 ```
 @Bean
diff --git a/docs/spring-security/servlet-configuration-xml-namespace.md b/docs/spring-security/servlet-configuration-xml-namespace.md
new file mode 100644
index 0000000..1469d97
--- /dev/null
+++ b/docs/spring-security/servlet-configuration-xml-namespace.md
@@ -0,0 +1,249 @@
+# 安全名称空间配置
+
+## 导言
+
+自 Spring 框架的2.0版本以来，名称空间配置一直可用。它允许你使用额外的XML模式中的元素来补充传统的 Spring bean应用程序上下文语法。你可以在 Spring [参考文献](https://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/)中找到更多信息。名称空间元素可以简单地用于允许以更简洁的方式配置单个 Bean，或者更强大地，用于定义替代配置语法，该语法更紧密地匹配问题域，并向用户隐藏潜在的复杂性。一个简单的元素可能掩盖了一个事实，即多个bean和处理步骤正在被添加到应用程序上下文中。例如，将以下元素从安全名称空间添加到应用程序上下文中，将启动一个嵌入式LDAP服务器，以测试在应用程序中的使用情况：
+
+```
+<security:ldap-server />
+```
+
+这比连接等效的 Apache 目录服务器bean要简单得多。最常见的替代配置需求由`ldap-server`元素上的属性支持，并且用户不必担心需要创建哪些bean以及 Bean 属性名称是什么。<sup class="footnote">[<a id="_footnoteref_1" class="footnote" href="#_footnotedef_1" title="View footnote.">1</a>]</sup>。]在编辑应用程序上下文文件时使用一个好的XML编辑器，应该提供关于可用的属性和元素的信息。我们建议你尝试[Eclipse IDE with Spring Tools](https://spring.io/tools)，因为它具有用于处理标准 Spring 名称空间的特殊功能。
+
+要在应用程序上下文中开始使用安全名称空间，你需要在 Classpath 上使用`spring-security-config`jar。然后，你所需要做的就是将架构声明添加到应用程序上下文文件中：
+
+```
+<beans xmlns="http://www.springframework.org/schema/beans"
+xmlns:security="http://www.springframework.org/schema/security"
+xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+xsi:schemaLocation="http://www.springframework.org/schema/beans
+		https://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+		http://www.springframework.org/schema/security
+		https://www.springframework.org/schema/security/spring-security.xsd">
+	...
+</beans>
+```
+
+在你将看到的许多示例中（以及在示例应用程序中），我们通常使用“security”作为默认名称空间，而不是“bean”，这意味着我们可以省略所有安全名称空间元素上的前缀，从而使内容更易于阅读。如果你将你的应用程序上下文划分为不同的文件，并且将大多数安全配置都放在其中一个文件中，那么你可能也想这样做。然后，你的安全应用程序上下文文件将像这样启动
+
+```
+<beans:beans xmlns="http://www.springframework.org/schema/security"
+xmlns:beans="http://www.springframework.org/schema/beans"
+xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+xsi:schemaLocation="http://www.springframework.org/schema/beans
+		https://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+		http://www.springframework.org/schema/security
+		https://www.springframework.org/schema/security/spring-security.xsd">
+	...
+</beans:beans>
+```
+
+在本章中，我们将假设从现在开始使用这种语法。
+
+### 命名空间的设计
+
+名称空间旨在捕捉框架的最常见用途，并提供简化和简明的语法，以便在应用程序中启用它们。该设计基于框架内的大规模依赖关系，可以分为以下几个方面：
+
+* *Web/HTTP安全性*-最复杂的部分。设置用于应用框架身份验证机制的过滤器和相关服务bean，以保护URL，呈现登录和错误页面等等。
+
+* *业务对象（方法）安全性*-用于保护服务层的选项。
+
+* *身份验证管理器*-处理来自框架其他部分的身份验证请求。
+
+* *AccessDecisionManager*-提供Web和方法安全性的访问决策。将注册一个默认的，但你也可以选择使用一个自定义的，使用正常的 Spring  Bean 语法声明。
+
+* *身份验证提供者*s-身份验证管理器对用户进行身份验证的机制。名称空间提供了对几个标准选项的支持，也是添加使用传统语法声明的自定义bean的一种方式。
+
+* *UserDetailsService*-与身份验证提供程序密切相关，但通常也需要其他bean。
+
+我们将在下面的小节中看到如何配置这些功能。
+
+## 安全名称空间配置入门
+
+在本节中，我们将研究如何构建名称空间配置，以使用框架的一些主要特性。让我们假设你最初希望尽快启动和运行，并通过一些测试登录向现有的Web应用程序添加身份验证支持和访问控制。然后，我们将研究如何转换为针对数据库或其他安全存储库进行身份验证。在后面的部分中，我们将介绍更高级的名称空间配置选项。
+
+### web.xml配置
+
+你需要做的第一件事是将以下过滤器声明添加到你的`web.xml`文件中：
+
+```
+<filter>
+<filter-name>springSecurityFilterChain</filter-name>
+<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
+</filter>
+
+<filter-mapping>
+<filter-name>springSecurityFilterChain</filter-name>
+<url-pattern>/*</url-pattern>
+</filter-mapping>
+```
+
+这提供了一个到 Spring 安全Web基础设施的钩子。`DelegatingFilterProxy`是一个 Spring 框架类，它委托给一个过滤器实现，该过滤器实现在你的应用程序上下文中被定义为 Spring  Bean。在这种情况下， Bean 被命名为“SpringSecurityFilterChain”，这是由名称空间创建的内部基础设施 Bean，用于处理Web安全。请注意，你自己不应该使用这个名称。一旦你把这个添加到你的`web.xml`中，你就可以开始编辑你的应用程序上下文文件了。Web安全服务使用`<http>`元素进行配置。
+
+### 最小\<http\>配置
+
+要启用Web安全性，你所需要做的就是从一开始就启用它。
+
+```
+<http>
+<intercept-url pattern="/**" access="hasRole('USER')" />
+<form-login />
+<logout />
+</http>
+```
+
+这表示我们希望我们的应用程序中的所有URL都是安全的，需要角色`ROLE_USER`来访问它们，我们希望使用带有用户名和密码的表单登录到应用程序，并且我们希望注册一个注销URL，这将允许我们从应用程序中注销。`<http>`元素是所有与Web相关的命名空间功能的父元素。`<intercept-url>`元素定义了一个`pattern`，它使用 Ant 路径样式语法<sup class="footnote">[<a id="_footnoteref_2" class="footnote" href="#_footnotedef_2" title="View footnote.">2</a>]</sup>，用于匹配实际执行方式的更多详细信息。]你还可以使用正则表达式匹配作为一种选择（有关更多详细信息，请参见名称空间附录）。`access`属性定义了匹配给定模式的请求的访问要求。对于默认配置，这通常是一个逗号分隔的角色列表，其中一个必须允许用户提出请求。前缀“role\_”是一个标记，表示应该与用户的权限进行简单的比较。换句话说，应该使用正常的基于角色的检查。 Spring 安全中的访问控制并不限于使用简单的角色（因此使用前缀来区分不同类型的安全属性）。稍后我们将看到解释如何改变<sup class="footnote">[<a id="_footnoteref_3" class="footnote" href="#_footnotedef_3" title="View footnote.">3</a>]</sup>。在 Spring Security3.0中，还可以使用[EL表达式](../authorization/expression-based.html#el-access)填充属性。
+
+|   |你可以使用多个`<intercept-url>`元素来为不同的URL集定义不同的访问要求，但它们将按照列出的顺序进行计算，并使用第一个匹配项。，因此，你必须将最具体的匹配项放在顶部，<br/>还可以添加一个`method`属性，以将匹配限制为特定的HTTP方法（`GET`，`POST`，`PUT`等）。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+要添加一些用户，你可以直接在名称空间中定义一组测试数据：
+
+```
+<authentication-manager>
+<authentication-provider>
+	<user-service>
+	<!-- Password is prefixed with {noop} to indicate to DelegatingPasswordEncoder that
+	NoOpPasswordEncoder should be used. This is not safe for production, but makes reading
+	in samples easier. Normally passwords should be hashed using BCrypt -->
+	<user name="jimi" password="{noop}jimispassword" authorities="ROLE_USER, ROLE_ADMIN" />
+	<user name="bob" password="{noop}bobspassword" authorities="ROLE_USER" />
+	</user-service>
+</authentication-provider>
+</authentication-manager>
+```
+
+这是存储相同密码的安全方法的一个示例。密码的前缀是`{bcrypt}`，指示`DelegatingPasswordEncoder`，该命令支持任何配置的`PasswordEncoder`进行匹配，并使用bcrypt对密码进行哈希：
+
+```
+<authentication-manager>
+<authentication-provider>
+	<user-service>
+	<user name="jimi" password="{bcrypt}$2a$10$ddEWZUl8aU0GdZPPpy7wbu82dvEw/pBpbRvDQRqA41y6mK1CoH00m"
+			authorities="ROLE_USER, ROLE_ADMIN" />
+	<user name="bob" password="{bcrypt}$2a$10$/elFpMBnAYYig6KRR5bvOOYeZr1ie1hSogJryg9qDlhza4oCw1Qka"
+			authorities="ROLE_USER" />
+	<user name="jimi" password="{noop}jimispassword" authorities="ROLE_USER, ROLE_ADMIN" />
+	<user name="bob" password="{noop}bobspassword" authorities="ROLE_USER" />
+	</user-service>
+</authentication-provider>
+</authentication-manager>
+```
+
+如果你熟悉该框架的预命名空间版本，你可能已经可以大致猜到这里发生了什么。`<http>`元素负责创建`FilterChainProxy`和它所使用的过滤器bean。常见的问题，如不正确的过滤器排序不再是一个问题，因为过滤器的位置是预先定义的。
+
+`<authentication-provider>`元素创建一个`DaoAuthenticationProvider` Bean，而`<user-service>`元素创建一个`InMemoryDaoImpl`。所有`authentication-provider`元素必须是`<authentication-manager>`元素的子元素，该元素创建一个`ProviderManager`并向其注册身份验证提供者。你可以在[名称空间附录](../appendix/namespace/index.html#appendix-namespace)中找到有关创建的bean的更详细信息。如果你想开始了解框架中的重要类是什么以及它们是如何使用的，特别是如果你想在以后定制这些类，那么值得对此进行交叉检查。
+
+上面的配置定义了两个用户、他们的密码和他们在应用程序中的角色（将用于访问控制）。还可以使用`user-service`上的`properties`属性从标准属性文件加载用户信息。有关文件格式的更多详细信息，请参见[内存中身份验证](../authentication/passwords/in-memory.html#servlet-authentication-inmemory)一节。使用`<authentication-provider>`元素意味着用户信息将被身份验证管理器用于处理身份验证请求。你可以使用多个`<authentication-provider>`元素来定义不同的认证源，并依次对每个元素进行查询。
+
+此时，你应该能够启动你的应用程序，并且需要登录才能继续。尝试一下，或者尝试一下项目附带的“教程”示例应用程序。
+
+#### 设置默认的登录后目标
+
+如果试图访问受保护的资源时没有提示表单登录，那么`default-target-url`选项就会起作用。这是用户成功登录后将被带到的URL，默认为“/”。通过将`always-use-default-target`属性设置为“true”，你还可以配置一些东西，以便用户*总是*最终在此页面结束（无论登录是“按需”还是他们明确选择登录）。如果你的应用程序总是要求用户从“主页”页面开始，这是有用的，例如：
+
+```
+<http pattern="/login.htm*" security="none"/>
+<http use-expressions="false">
+<intercept-url pattern='/**' access='ROLE_USER' />
+<form-login login-page='/login.htm' default-target-url='/home.htm'
+		always-use-default-target='true' />
+</http>
+```
+
+为了获得对目的地的更多控制，你可以使用`authentication-success-handler-ref`属性作为`default-target-url`的替代选项。引用的 Bean 应该是`AuthenticationSuccessHandler`的实例。
+
+## 高级Web功能
+
+### 添加自己的过滤器
+
+如果你以前使用过 Spring 安全性，那么你就会知道，该框架维护了一系列过滤器，以便应用其服务。你可能希望在特定位置将自己的筛选器添加到堆栈中，或者使用 Spring 安全筛选器，该筛选器目前没有名称空间配置选项（例如，CAS）。或者，你可能希望使用标准名称空间过滤器的定制版本，例如`UsernamePasswordAuthenticationFilter`，它是由`<form-login>`元素创建的，利用了一些额外的配置选项，这些额外的配置选项可以通过显式地使用 Bean 来获得。既然过滤器链不是直接公开的，那么如何使用名称空间配置来实现这一点呢？
+
+在使用名称空间时，总是严格执行过滤器的顺序。在创建应用程序上下文时，过滤器bean按名称空间处理代码进行排序，标准 Spring 安全过滤器在名称空间和众所周知的位置中都有一个别名。
+
+|   |在以前的版本中，排序是在应用程序上下文的后处理过程中，在过滤器实例被创建之后进行的，<br/>在版本3.0中，排序现在是在 Bean 元数据级别完成的，在类被实例化之前。<br/>这对于如何将自己的筛选器添加到堆栈有影响，因为在解析`<http>`元素期间，必须知道整个筛选器列表，所以语法在3.0中略有变化。|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+创建过滤器的过滤器、别名和名称空间元素/属性在[标准过滤器别名和排序](#filter-stack)中显示。过滤器是按照它们在过滤器链中出现的顺序列出的。
+
+|            Alias             |                    Filter Class                     |名称空间元素或属性|
+|------------------------------|-----------------------------------------------------|-------------------------------------------------------|
+|       CHANNEL\_FILTER        |              `ChannelProcessingFilter`              |`http/[[email protected]](/cdn-cgi/l/email-protection)`|
+|  SECURITY\_CONTEXT\_FILTER   |         `SecurityContextPersistenceFilter`          |`http`|
+| CONCURRENT\_SESSION\_FILTER  |              `ConcurrentSessionFilter`              |`session-management/concurrency-control`|
+|       HEADERS\_FILTER        |                `HeaderWriterFilter`                 |`http/headers`|
+|         CSRF\_FILTER         |                    `CsrfFilter`                     |`http/csrf`|
+|        LOGOUT\_FILTER        |                   `LogoutFilter`                    |`http/logout`|
+|         X509\_FILTER         |             `X509AuthenticationFilter`              |`http/x509`|
+|      PRE\_AUTH\_FILTER       |`AbstractPreAuthenticatedProcessingFilter` Subclasses|不适用|
+|         CAS\_FILTER          |              `CasAuthenticationFilter`              |不适用|
+|     FORM\_LOGIN\_FILTER      |       `UsernamePasswordAuthenticationFilter`        |`http/form-login`|
+|     BASIC\_AUTH\_FILTER      |             `BasicAuthenticationFilter`             |`http/http-basic`|
+|SERVLET\_API\_SUPPORT\_FILTER |      `SecurityContextHolderAwareRequestFilter`      |`http/@servlet-api-provision`|
+|  JAAS\_API\_SUPPORT\_FILTER  |             `JaasApiIntegrationFilter`              |`http/@jaas-api-provision`|
+|     REMEMBER\_ME\_FILTER     |          `RememberMeAuthenticationFilter`           |`http/remember-me`|
+|      ANONYMOUS\_FILTER       |           `AnonymousAuthenticationFilter`           |`http/anonymous`|
+| SESSION\_MANAGEMENT\_FILTER  |              `SessionManagementFilter`              |`session-management`|
+|EXCEPTION\_TRANSLATION\_FILTER|            `ExceptionTranslationFilter`             |`http`|
+|FILTER\_SECURITY\_INTERCEPTOR |             `FilterSecurityInterceptor`             |`http`|
+|     SWITCH\_USER\_FILTER     |                 `SwitchUserFilter`                  |不适用|
+
+你可以将自己的筛选器添加到堆栈中，使用`custom-filter`元素和其中一个名称来指定筛选器应该出现在以下位置：
+
+```
+<http>
+<custom-filter position="FORM_LOGIN_FILTER" ref="myFilter" />
+</http>
+
+<beans:bean id="myFilter" class="com.mycompany.MySpecialAuthenticationFilter"/>
+```
+
+如果希望在堆栈中的另一个过滤器之前或之后插入过滤器，还可以使用`after`或`before`属性。名称“first”和“last”可以与`position`属性一起使用，以表明你希望你的筛选器分别出现在整个堆栈之前或之后。
+
+|   |避免过滤器位置冲突<br/><br/>如果你要插入一个自定义过滤器，该过滤器的位置可能与名称空间创建的标准过滤器的位置相同，那么这一点很重要你没有错误地包含名称空间版本。，<br/>删除任何创建过滤器的元素，这些过滤器的功能是你想要替换的，<br/><br/>注意，你不能替换使用`<http>`元素本身创建的过滤器-`SecurityContextPersistenceFilter`，`ExceptionTranslationFilter`或`FilterSecurityInterceptor`。<br/>默认情况下添加了其他一些过滤器，但你可以禁用它们。<br/>默认情况下添加了一个`AnonymousAuthenticationFilter`，除非你禁用了[session-fixation protection](../authentication/session-management.html#ns-session-fixation)，否则还将向过滤器链中添加一个`SessionManagementFilter`。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+如果要替换需要身份验证入口点的名称空间过滤器（即未经身份验证的用户试图访问安全资源而触发身份验证过程），还需要添加自定义入口点 Bean。
+
+## 方法安全性
+
+Spring 从版本2.0开始，安全性在很大程度上改进了对向服务层方法添加安全性的支持。它提供了对JSR-250注释安全性的支持，以及框架的原始`@Secured`注释。从3.0开始，你还可以使用New[基于表达式的注释](../authorization/expression-based.html#el-access)。你可以对单个 Bean 应用安全性，使用`intercept-methods`元素来装饰 Bean 声明，或者可以使用AspectJ样式的切入点在整个服务层中保护多个bean。
+
+## 默认的accessesdecisionManager
+
+本节假定你对 Spring Security中的访问控制的底层体系结构有一定的了解。如果你不这样做，你可以跳过它，稍后再来讨论它，因为这一部分只与那些需要进行一些定制以使用比简单的基于角色的安全性更多功能的人相关。
+
+当你使用名称空间配置时，将自动为你注册一个`AccessDecisionManager`的默认实例，该实例将用于为方法调用和Web URL访问做出访问决策，基于你在`intercept-url`和`protect-pointcut`声明中指定的访问属性（如果你使用的是注释安全方法，则在注释中指定）。
+
+默认的策略是使用`AffirmativeBased``AccessDecisionManager`和`RoleVoter`。你可以在[授权](../authorization/architecture.html#authz-arch)一章中找到更多有关这些的信息。
+
+### 自定义accessDecisionManager
+
+如果需要使用更复杂的访问控制策略，那么很容易为方法和Web安全性设置替代方案。
+
+对于方法安全性，你可以通过将`global-method-security`上的`access-decision-manager-ref`属性设置为应用程序上下文中适当的`id` Bean 中的`id`来实现此目的：
+
+```
+<global-method-security access-decision-manager-ref="myAccessDecisionManagerBean">
+...
+</global-method-security>
+```
+
+Web安全性的语法是相同的，但是在`http`元素上：
+
+```
+<http access-decision-manager-ref="myAccessDecisionManagerBean">
+...
+</http>
+```
+
+---
+
+[1](#_footnoteref_1)。你可以在关于Xref的章节中找到有关`ldap-server`元素使用情况的更多信息： Servlet/authentication/unpwd/ldap.ADOC# Servlet-authentication-ldap[ldap身份验证]
+
+[2](#_footnoteref_2)。参见Xref部分： Servlet/exploits/firewall.ADOC# Servlet-HttpFirewall[`HttpFirewall`
+
+[3](#_footnoteref_3)。对`access`属性中逗号分隔的值的解释取决于所使用的[AccessDecisionManager](#ns-access-manager)的实现。
+
+[Kotlin Configuration](kotlin.html)[Testing](../test/index.html)
+
diff --git a/docs/spring-security/servlet-exploits-csrf.md b/docs/spring-security/servlet-exploits-csrf.md
new file mode 100644
index 0000000..92ce7c7
--- /dev/null
+++ b/docs/spring-security/servlet-exploits-csrf.md
@@ -0,0 +1,389 @@
+# Servlet 环境中的跨站点请求伪造
+
+本节讨论 Spring Security对 Servlet 环境的[跨站点请求伪造](../../features/exploits/csrf.html#csrf)支持。
+
+## 使用 Spring 安全CSRF保护
+
+使用 Spring Security的CSRF保护的步骤概述如下：
+
+* [使用适当的HTTP动词](#servlet-csrf-idempotent)
+
+* [配置CSRF保护](#servlet-csrf-configure)
+
+* [包括CSRF令牌](#servlet-csrf-include)
+
+### 使用适当的HTTP动词
+
+防止CSRF攻击的第一步是确保你的网站使用正确的HTTP动词。这在[安全的方法必须是幂等的。](../../features/exploits/csrf.html#csrf-protection-idempotent)中有详细介绍。
+
+### 配置CSRF保护
+
+下一步是在应用程序中配置 Spring Security的CSRF保护。 Spring 默认情况下，Security的CSRF保护是启用的，但你可能需要定制配置。下面是一些常见的定制。
+
+#### 自定义CSRFTokenRepository
+
+Spring 默认情况下，Security使用`HttpSessionCsrfTokenRepository`将预期的CSRF令牌存储在`HttpSession`中。在某些情况下，用户可能希望配置自定义`CsrfTokenRepository`。例如，可能希望将cookie中的`CsrfToken`持久化到[支持基于JavaScript的应用程序](#servlet-csrf-include-ajax-auto)。
+
+默认情况下，`CookieCsrfTokenRepository`将写到一个名为`XSRF-TOKEN`的cookie，并从一个名为`X-XSRF-TOKEN`的头部或HTTP参数`_csrf`读取它。这些默认值来自[AngularJS](https://docs.angularjs.org/api/ng/service/$http#cross-site-request-forgery-xsrf-protection)
+
+可以使用以下方法在XML中配置`CookieCsrfTokenRepository`:
+
+例1.使用XML配置在cookie中存储CSRF令牌
+
+```
+<http>
+	<!-- ... -->
+	<csrf token-repository-ref="tokenRepository"/>
+</http>
+<b:bean id="tokenRepository"
+	class="org.springframework.security.web.csrf.CookieCsrfTokenRepository"
+	p:cookieHttpOnly="false"/>
+```
+
+|   |示例显式设置`cookieHttpOnly=false`.<br/>这是允许JavaScript（即Angularjs）读取它所必需的。<br/>如果不需要直接使用JavaScript读取cookie的能力，建议省略`cookieHttpOnly=false`以提高安全性。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+你可以在 Java 配置中使用以下方法配置`CookieCsrfTokenRepository`:
+
+例2.在cookie中存储CSRF令牌
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+		WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) {
+		http
+			.csrf(csrf -> csrf
+				.csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())
+			);
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+       http {
+            csrf {
+                csrfTokenRepository = CookieCsrfTokenRepository.withHttpOnlyFalse()
+            }
+        }
+    }
+}
+```
+
+|   |示例显式设置`cookieHttpOnly=false`.<br/>这是允许JavaScript（即Angularjs）读取它所必需的。<br/>如果不需要直接使用JavaScript读取cookie的能力，建议省略`cookieHttpOnly=false`（通过使用`new CookieCsrfTokenRepository()`代替）以提高安全性。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+#### 禁用CSRF保护
+
+默认情况下启用了CSRF保护。但是，如果CSRF保护[对你的应用程序来说是有意义的](../../features/exploits/csrf.html#csrf-when)，则禁用CSRF保护非常简单。
+
+下面的XML配置将禁用CSRF保护。
+
+例3.禁用CSRF XML配置
+
+```
+<http>
+	<!-- ... -->
+	<csrf disabled="true"/>
+</http>
+```
+
+下面的 Java 配置将禁用CSRF保护。
+
+例4.禁用CSRF
+
+Java
+
+```
+@Configuration
+@EnableWebSecurity
+public class WebSecurityConfig extends
+		WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) {
+		http
+			.csrf(csrf -> csrf.disable());
+	}
+}
+```
+
+Kotlin
+
+```
+@Configuration
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+       http {
+            csrf {
+                disable()
+            }
+        }
+    }
+}
+```
+
+### 包括CSRF令牌
+
+为了使[同步器令牌模式](../../features/exploits/csrf.html#csrf-protection-stp)能够抵御CSRF攻击，我们必须在HTTP请求中包含实际的CSRF令牌。这必须包含在请求的一部分（即表单参数、HTTP头等）中，而该部分不是由浏览器自动包含在HTTP请求中的。
+
+Spring Security的[CsrfFilter](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/web/csrf/CsrfFilter.html)将[CsrfToken](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/web/csrf/CsrfToken.html)公开为名为`HttpServletRequest`的属性。这意味着，任何视图技术都可以访问`CsrfToken`以将预期的令牌公开为[form](#servlet-csrf-include-form-attr)或[meta tag](#servlet-csrf-include-ajax-meta-attr)。幸运的是，下面列出的集成使得在[form](#servlet-csrf-include-form)和[ajax](#servlet-csrf-include-ajax)请求中包含令牌变得更加容易。
+
+#### 表单URL编码
+
+为了发布HTML表单，CSRF令牌必须作为隐藏输入包含在表单中。例如，呈现的HTML可能看起来像：
+
+例5. CSRF令牌HTML
+
+```
+<input type="hidden"
+	name="_csrf"
+	value="4bfd1575-3ad1-4d21-96c7-4ef2d9f86721"/>
+```
+
+接下来，我们将讨论将CSRF令牌以一种形式包含为隐藏输入的各种方法。
+
+##### CSRF令牌自动包含
+
+Spring Security的CSRF支持通过其[CsrfrequestDataValueProcessor](https://docs.spring.io/spring-security/site/docs/current/api/org/springframework/security/web/servlet/support/csrf/CsrfRequestDataValueProcessor.html)提供与 Spring 的[RequestDataValueProcessor](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/support/RequestDataValueProcessor.html)的集成。这意味着，如果你利用[Spring’s form tag library](https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html#mvc-view-jsp-formtaglib)、[Thymeleaf](https://www.thymeleaf.org/doc/tutorials/2.1/thymeleafspring.html#integration-with-requestdatavalueprocessor)或与`RequestDataValueProcessor`集成的任何其他视图技术，那么具有不安全的HTTP方法（即POST）的窗体将自动包括实际的CSRF令牌。
+
+##### csrfinput标记
+
+如果你正在使用JSP，那么你可以使用[Spring’s form tag library](https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html#mvc-view-jsp-formtaglib)。但是，如果这不是一个选项，你也可以很容易地将令牌包含在[csrfInput](../integrations/jsp-taglibs.html#taglibs-csrfinput)标记中。
+
+##### CSRFToken请求属性
+
+如果用于在请求中包含实际CSRF令牌的[其他选择](#servlet-csrf-include)不起作用，则可以利用以下事实：`CsrfToken`[is exposed](#servlet-csrf-include)作为`HttpServletRequest`属性，该属性名为`_csrf`。
+
+使用JSP执行此操作的示例如下所示：
+
+例6.具有请求属性的表单中的CSRF令牌
+
+```
+<c:url var="logoutUrl" value="/logout"/>
+<form action="${logoutUrl}"
+	method="post">
+<input type="submit"
+	value="Log out" />
+<input type="hidden"
+	name="${_csrf.parameterName}"
+	value="${_csrf.token}"/>
+</form>
+```
+
+#### Ajax和JSON请求
+
+如果你正在使用JSON，那么就不可能在HTTP参数中提交CSRF令牌。相反，你可以在HTTP头中提交令牌。
+
+在下面的部分中，我们将讨论在基于JavaScript的应用程序中将CSRF令牌作为HTTP请求头包含在内的各种方法。
+
+##### 自动包含
+
+Spring 安全性可以很容易地[configured](#servlet-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](#servlet-csrf-include-form-auto)的另一种模式是在`meta`标记中包含CSRF标记。HTML可能看起来是这样的：
+
+例7. CSRF元标记HTML
+
+```
+<html>
+<head>
+	<meta name="_csrf" content="4bfd1575-3ad1-4d21-96c7-4ef2d9f86721"/>
+	<meta name="_csrf_header" content="X-CSRF-TOKEN"/>
+	<!-- ... -->
+</head>
+<!-- ... -->
+```
+
+一旦元标记包含CSRF令牌，JavaScript代码将读取元标记并将CSRF令牌作为报头。如果你正在使用jQuery，可以通过以下方式完成此操作：
+
+例8. 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);
+	});
+});
+```
+
+###### CSRFMeta标签
+
+如果你正在使用JSP，那么将CSRF令牌写入`meta`标记的一种简单方法是利用[csrfMeta](../integrations/jsp-taglibs.html#taglibs-csrfmeta)标记。
+
+###### CSRFToken请求属性
+
+如果用于在请求中包含实际CSRF令牌的[其他选择](#servlet-csrf-include)不起作用，则可以利用以下事实：`CsrfToken`[is exposed](#servlet-csrf-include)作为`HttpServletRequest`属性，该属性名为`_csrf`。使用JSP执行此操作的示例如下所示：
+
+例9. CSRF元标记JSP
+
+```
+<html>
+<head>
+	<meta name="_csrf" content="${_csrf.token}"/>
+	<!-- default header name is X-CSRF-TOKEN -->
+	<meta name="_csrf_header" content="${_csrf.headerName}"/>
+	<!-- ... -->
+</head>
+<!-- ... -->
+```
+
+## CSRF考虑因素
+
+在实施针对CSRF攻击的保护时，有几个特殊的考虑因素需要考虑。本节讨论与 Servlet 环境相关的那些考虑因素。有关更一般性的讨论，请参见[CSRF考虑因素](../../features/exploits/csrf.html#csrf-considerations)。
+
+### 登录
+
+这是重要的[需要CSRF才能登录](../../features/exploits/csrf.html#csrf-considerations-login)请求，以防止伪造日志的企图。 Spring Security的 Servlet 支持是开箱即用的。
+
+### 注销
+
+重要的是[需要CSRF才能注销](../../features/exploits/csrf.html#csrf-considerations-logout)请求，以防止伪造注销尝试。如果启用了CSRF保护（默认）， Spring Security的`LogoutFilter`将仅处理HTTP POST。这确保了注销需要CSRF令牌，并且恶意用户不能强制注销你的用户。
+
+最简单的方法是使用表单注销。如果你真的想要一个链接，可以使用JavaScript让该链接执行一个POST（例如，可能在一个隐藏的表单上）。对于禁用了JavaScript的浏览器，你可以选择让链接将用户带到将执行POST的注销确认页面。
+
+如果你真的想使用HTTP GET与注销，你可以这样做，但请记住，这通常是不推荐的。例如，以下 Java 配置将使用任何HTTP方法请求的URL执行注销：
+
+例10.用HTTP GET登出
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+		WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) {
+		http
+			.logout(logout -> logout
+				.logoutRequestMatcher(new AntPathRequestMatcher("/logout"))
+			);
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+       http {
+            logout {
+                logoutRequestMatcher = AntPathRequestMatcher("/logout")
+            }
+        }
+    }
+}
+```
+
+### CSRF和会话暂停
+
+默认情况下， Spring Security将CSRF令牌存储在`HttpSession`中。这可能导致会话过期的情况，这意味着没有预期的CSRF令牌来验证。
+
+我们已经讨论了[一般解决方案](../../features/exploits/csrf.html#csrf-considerations-login)到会话的超时。本节讨论CSRF超时的细节，因为它与 Servlet 支持有关。
+
+将预期的CSRF令牌的存储更改为cookie中的存储是很简单的。有关详细信息，请参阅[自定义CSRFTokenRepository](#servlet-csrf-configure-custom-repository)部分。
+
+如果一个令牌确实过期了，你可能希望通过指定一个自定义`AccessDeniedHandler`来定制它的处理方式。自定义`AccessDeniedHandler`可以以任何方式处理`InvalidCsrfTokenException`。对于如何自定义`AccessDeniedHandler`的示例，请参阅为[xml](../appendix/namespace/http.html#nsa-access-denied-handler)和[Java configuration](https://github.com/spring-projects/spring-security/tree/5.6.2/config/src/test/java/org/springframework/security/config/annotation/web/configurers/NamespaceHttpServerAccessDeniedHandlerTests.java#L64)提供的链接。
+
+### 
+
+我们有[已经讨论过了](../../features/exploits/csrf.html#csrf-considerations-multipart)如何保护多部分请求（文件上传）不受CSRF攻击导致[鸡和蛋](https://en.wikipedia.org/wiki/Chicken_or_the_egg)问题。本节讨论如何在 Servlet 应用程序中实现将CSRF令牌放置在[body](#servlet-csrf-considerations-multipart-body)和[url](#servlet-csrf-considerations-multipart-url)中。
+
+|   |关于使用具有 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标记放入体内
+
+我们有[已经讨论过了](../../features/exploits/csrf.html#csrf-considerations-multipart-body)在主体中放置CSRF标记的权衡。在本节中，我们将讨论如何配置 Spring 安全性，以便从主体读取CSRF。
+
+为了从主体中读取CSRF令牌，在 Spring 安全过滤器之前指定了`MultipartFilter`。在 Spring 安全过滤器之前指定`MultipartFilter`意味着没有调用`MultipartFilter`的授权，这意味着任何人都可以在你的服务器上放置临时文件。但是，只有经过授权的用户才能提交由你的应用程序处理的文件。通常，这是推荐的方法，因为临时文件上传对大多数服务器的影响可以忽略不计。
+
+为了确保`MultipartFilter`是在 Spring 安全过滤器 Java 配置之前指定的，用户可以在SpringSecurityFilterchain之前覆盖，如下所示：
+
+例11.初始化器MultipartFilter
+
+Java
+
+```
+public class SecurityApplicationInitializer extends AbstractSecurityWebApplicationInitializer {
+
+	@Override
+	protected void beforeSpringSecurityFilterChain(ServletContext servletContext) {
+		insertFilters(servletContext, new MultipartFilter());
+	}
+}
+```
+
+Kotlin
+
+```
+class SecurityApplicationInitializer : AbstractSecurityWebApplicationInitializer() {
+    override fun beforeSpringSecurityFilterChain(servletContext: ServletContext?) {
+        insertFilters(servletContext, MultipartFilter())
+    }
+}
+```
+
+为了确保在使用XML配置的 Spring 安全过滤器之前指定`MultipartFilter`，用户可以确保将`MultipartFilter`元素的\<filter-mapping\>元素放置在web.xml中的SpringSecurityFilterchain之前，如下所示：
+
+示例12.web.xml-multipartfilter
+
+```
+<filter>
+	<filter-name>MultipartFilter</filter-name>
+	<filter-class>org.springframework.web.multipart.support.MultipartFilter</filter-class>
+</filter>
+<filter>
+	<filter-name>springSecurityFilterChain</filter-name>
+	<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
+</filter>
+<filter-mapping>
+	<filter-name>MultipartFilter</filter-name>
+	<url-pattern>/*</url-pattern>
+</filter-mapping>
+<filter-mapping>
+	<filter-name>springSecurityFilterChain</filter-name>
+	<url-pattern>/*</url-pattern>
+</filter-mapping>
+```
+
+#### 在URL中包含CSRF令牌
+
+如果允许未经授权的用户上传临时文件是不可接受的，则另一种选择是将`MultipartFilter`置于 Spring 安全过滤器之后，并将CSRF作为查询参数包含在表单的动作属性中。由于`CsrfToken`被公开为`HttpServletRequest`[请求属性](#servlet-csrf-include)，因此我们可以使用它来创建带有CSRF令牌的`action`。下面显示了一个带有JSP的示例。
+
+例13. CSRF令牌正在运行
+
+```
+<form method="post"
+	action="./upload?${_csrf.parameterName}=${_csrf.token}"
+	enctype="multipart/form-data">
+```
+
+### HiddenHttpMethodFilter
+
+我们有[已经讨论过了](../../features/exploits/csrf.html#csrf-considerations-multipart-body)在主体中放置CSRF标记的权衡。
+
+在 Spring 的 Servlet 支持中，覆盖HTTP方法是使用[HiddenHttpMethodFilter](https://docs.spring.io/spring-framework/docs/5.2.x/javadoc-api/org/springframework/web/filter/reactive/HiddenHttpMethodFilter.html)完成的。更多信息可以在参考文档的[HTTP方法转换](https://docs.spring.io/spring/docs/5.2.x/spring-framework-reference/web.html#mvc-rest-method-conversion)部分中找到。
+
+[保护免受剥削](index.html)[安全HTTP响应标头](headers.html)
+
diff --git a/docs/spring-security/servlet-exploits-firewall.md b/docs/spring-security/servlet-exploits-firewall.md
new file mode 100644
index 0000000..14a9dd2
--- /dev/null
+++ b/docs/spring-security/servlet-exploits-firewall.md
@@ -0,0 +1,202 @@
+# HttpFirewall
+
+在针对你定义的模式进行测试时，了解该机制是什么以及使用了什么URL值是很重要的。
+
+Servlet 规范为`HttpServletRequest`定义了几个属性，这些属性可以通过getter方法访问，并且我们可能希望对其进行匹配。它们是`contextPath`，`servletPath`，`pathInfo`和`queryString`。 Spring 安全性只对保护应用程序内的路径感兴趣，因此`contextPath`被忽略。不幸的是， Servlet 规范并没有确切地定义`servletPath`和`pathInfo`对于特定的请求URI的值将包含什么。例如，一个URL的每个路径段可以包含参数，如[RFC 2396](https://www.ietf.org/rfc/rfc2396.txt)<sup class="footnote">[<a id="_footnoteref_1" class="footnote" href="#_footnotedef_1" title="View footnote.">1</a>]</sup>。规范没有明确说明是否应该将这些值包含在`servletPath`和`pathInfo`值中，并且不同的容器之间的行为是不同的。当应用程序部署在不从这些值中删除路径参数的容器中时，存在这样的危险：攻击者可能会将它们添加到所请求的URL中，从而导致模式匹配意外成功或失败。<sup class="footnote">[<a id="_footnoteref_2" class="footnote" href="#_footnotedef_2" title="View footnote.">2</a>]</sup>。传入URL中的其他变体也是可能的。例如，它可能包含路径遍历序列（如`/../`）或多个前向斜杠（`//`），这也可能导致模式匹配失败。一些容器在执行 Servlet 映射之前将这些规范化，但其他容器则不这样做。为了防止此类问题，`FilterChainProxy`使用`HttpFirewall`策略来检查和包装请求。默认情况下，未规范化的请求会被自动拒绝，并且为了匹配的目的，会删除路径参数和重复的斜杠。<sup class="footnote">[<a id="_footnoteref_3" class="footnote" href="#_footnotedef_3" title="View footnote.">3</a>]</sup>。因此，使用`FilterChainProxy`来管理安全筛选链是非常重要的。请注意，`servletPath`和`pathInfo`值是由容器解码的，因此你的应用程序不应该有任何包含半冒号的有效路径，因为为了匹配的目的，这些部分将被删除。
+
+如上所述，默认策略是使用 Ant 样式的路径进行匹配，这可能是大多数用户的最佳选择。该策略在类`AntPathRequestMatcher`中实现，该类使用 Spring 的`AntPathMatcher`对串联的`servletPath`和`pathInfo`执行不区分大小写的模式匹配，忽略`queryString`。
+
+如果出于某种原因，你需要一个更强大的匹配策略，那么可以使用正则表达式。那么策略执行`RegexRequestMatcher`。有关此类的更多信息，请参见Javadoc。
+
+在实践中，我们建议你在服务层使用方法安全性来控制对应用程序的访问，而不是完全依赖于在Web-Application级别定义的安全约束的使用。URL会发生变化，很难考虑到应用程序可能支持的所有可能的URL，以及如何操纵请求。你应该试着把自己限制在几条简单易懂的路径上。始终尝试使用“默认拒绝”方法，其中你有一个包罗万象的通配符（/**或**）在最后定义并拒绝访问。
+
+在服务层定义的安全性要强大得多，也更难绕过，因此你应该始终利用 Spring Security的方法安全性选项。
+
+`HttpFirewall`还通过拒绝HTTP响应头中的新行字符来防止[HTTP响应拆分](https://www.owasp.org/index.php/HTTP_Response_Splitting)。
+
+默认情况下使用`StrictHttpFirewall`。此实现拒绝似乎是恶意的请求。如果对你的需求来说过于严格，那么你可以自定义拒绝的请求类型。然而，重要的是，你要知道这可能会使你的应用程序受到攻击。例如，如果你希望利用 Spring MVC的矩阵变量，可以使用以下配置：
+
+例1.允许矩阵变量
+
+Java
+
+```
+@Bean
+public StrictHttpFirewall httpFirewall() {
+    StrictHttpFirewall firewall = new StrictHttpFirewall();
+    firewall.setAllowSemicolon(true);
+    return firewall;
+}
+```
+
+XML
+
+```
+<b:bean id="httpFirewall"
+    class="org.springframework.security.web.firewall.StrictHttpFirewall"
+    p:allowSemicolon="true"/>
+
+<http-firewall ref="httpFirewall"/>
+```
+
+Kotlin
+
+```
+@Bean
+fun httpFirewall(): StrictHttpFirewall {
+    val firewall = StrictHttpFirewall()
+    firewall.setAllowSemicolon(true)
+    return firewall
+}
+```
+
+`StrictHttpFirewall`提供了一个允许的有效HTTP方法列表，这些方法被允许对[跨站点跟踪](https://owasp.org/www-community/attacks/Cross_Site_Tracing)和[HTTP动词篡改](https://owasp.org/www-project-web-security-testing-guide/latest/4-Web_Application_Security_Testing/02-Configuration_and_Deployment_Management_Testing/06-Test_HTTP_Methods)进行保护。默认的有效方法是“delete”、“get”、“head”、“options”、“patch”、“post”和“put”。如果你的应用程序需要修改有效的方法，你可以配置一个自定义的`StrictHttpFirewall` Bean。例如，以下将只允许HTTP“get”和“postmethod”方法：
+
+例2.只允许get和post（P）
+
+Java
+
+```
+@Bean
+public StrictHttpFirewall httpFirewall() {
+    StrictHttpFirewall firewall = new StrictHttpFirewall();
+    firewall.setAllowedHttpMethods(Arrays.asList("GET", "POST"));
+    return firewall;
+}
+```
+
+XML
+
+```
+<b:bean id="httpFirewall"
+      class="org.springframework.security.web.firewall.StrictHttpFirewall"
+      p:allowedHttpMethods="GET,HEAD"/>
+
+<http-firewall ref="httpFirewall"/>
+```
+
+Kotlin
+
+```
+@Bean
+fun httpFirewall(): StrictHttpFirewall {
+    val firewall = StrictHttpFirewall()
+    firewall.setAllowedHttpMethods(listOf("GET", "POST"))
+    return firewall
+}
+```
+
+|   |如果你正在使用`new MockHttpServletRequest()`，则它当前将创建一个HTTP方法作为空字符串“。<br/>这是一个无效的HTTP方法，并且将被 Spring Security拒绝。<br/>你可以通过将其替换为`new MockHttpServletRequest("GET", "")`来解决此问题。<br/>有关请求改进此问题的请参见[SPR\_16851](https://jira.spring.io/browse/SPR-16851)。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+如果必须允许任何HTTP方法（不推荐），则可以使用`StrictHttpFirewall.setUnsafeAllowAnyHttpMethod(true)`。这将完全禁用HTTP方法的验证。
+
+`StrictHttpFirewall`还检查头名称、值和参数名称。它要求每个字符都有一个定义的代码点，而不是一个控制字符。
+
+可以使用以下方法根据需要放松或调整此要求：
+
+* `StrictHttpFirewall#setAllowedHeaderNames(Predicate)`
+
+* `StrictHttpFirewall#setAllowedHeaderValues(Predicate)`
+
+* `StrictHttpFirewall#setAllowedParameterNames(Predicate)`
+
+|   |而且，参数值可以用`setAllowedParameterValues(Predicate)`来控制。|
+|---|-------------------------------------------------------------------------------------|
+
+例如，要关闭此检查，你可以将你的`StrictHttpFirewall`与始终返回`Predicate`的`true`连接起来，如：
+
+例3.允许任何头名称、头值和参数名称
+
+Java
+
+```
+@Bean
+public StrictHttpFirewall httpFirewall() {
+    StrictHttpFirewall firewall = new StrictHttpFirewall();
+    firewall.setAllowedHeaderNames((header) -> true);
+    firewall.setAllowedHeaderValues((header) -> true);
+    firewall.setAllowedParameterNames((parameter) -> true);
+    return firewall;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun httpFirewall(): StrictHttpFirewall {
+    val firewall = StrictHttpFirewall()
+    firewall.setAllowedHeaderNames { true }
+    firewall.setAllowedHeaderValues { true }
+    firewall.setAllowedParameterNames { true }
+    return firewall
+}
+```
+
+或者，你可能需要允许一个特定的值。
+
+例如，iPhone X使用`User-Agent`，其中包含一个不在ISO-8859-1字符集中的字符。由于这一事实，一些应用程序服务器将把这个值解析为两个单独的字符，后者是一个未定义的字符。
+
+你可以使用`setAllowedHeaderValues`方法来解决这个问题，如下所示：
+
+例4.允许某些用户代理
+
+Java
+
+```
+@Bean
+public StrictHttpFirewall httpFirewall() {
+    StrictHttpFirewall firewall = new StrictHttpFirewall();
+    Pattern allowed = Pattern.compile("[\\p{IsAssigned}&&[^\\p{IsControl}]]*");
+    Pattern userAgent = ...;
+    firewall.setAllowedHeaderValues((header) -> allowed.matcher(header).matches() || userAgent.matcher(header).matches());
+    return firewall;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun httpFirewall(): StrictHttpFirewall {
+    val firewall = StrictHttpFirewall()
+    val allowed = Pattern.compile("[\\p{IsAssigned}&&[^\\p{IsControl}]]*")
+    val userAgent = Pattern.compile(...)
+    firewall.setAllowedHeaderValues { allowed.matcher(it).matches() || userAgent.matcher(it).matches() }
+    return firewall
+}
+```
+
+对于标头值，你可以考虑在验证时将它们解析为UTF-8，如下所示：
+
+例5.将标题解析为UTF-8
+
+Java
+
+```
+firewall.setAllowedHeaderValues((header) -> {
+    String parsed = new String(header.getBytes(ISO_8859_1), UTF_8);
+    return allowed.matcher(parsed).matches();
+});
+```
+
+Kotlin
+
+```
+firewall.setAllowedHeaderValues {
+    val parsed = String(header.getBytes(ISO_8859_1), UTF_8)
+    return allowed.matcher(parsed).matches()
+}
+```
+
+---
+
+[1](#_footnoteref_1)。当浏览器不支持cookie并且`jsessionid`参数在分号之后的URL中附加时，你可能已经看到了这种情况。然而，RFC允许在URL的任何路径段中存在这些参数。
+
+[2](#_footnoteref_2)。一旦请求离开`FilterChainProxy`，将返回原始值，因此应用程序仍然可用。
+
+[3](#_footnoteref_3)。因此，例如，原始请求路径`/secure;hack=1/somefile.html;hack=2`将返回为`/secure/somefile.html`。
+
+[HTTP](http.html)[整合](../integrations/index.html)
+
diff --git a/docs/spring-security/servlet-exploits-headers.md b/docs/spring-security/servlet-exploits-headers.md
new file mode 100644
index 0000000..1c2187e
--- /dev/null
+++ b/docs/spring-security/servlet-exploits-headers.md
@@ -0,0 +1,1092 @@
+# 安全HTTP响应标头
+
+[安全HTTP响应标头](../../features/exploits/headers.html#headers)可以用来增加Web应用程序的安全性。本节专门讨论基于 Servlet 的对安全HTTP响应头的支持。
+
+## 默认安全标头
+
+Spring 安全性提供了[默认的安全HTTP响应标头集](../../features/exploits/headers.html#headers-default)以提供安全的默认值。虽然这些标题中的每一个都被认为是最佳实践，但应该注意的是，并不是所有的客户机都使用这些标题，因此鼓励进行额外的测试。
+
+你可以自定义特定的标题。例如，假设你希望使用默认值，但不希望为[X-帧-选项](#servlet-headers-frame-options)指定`SAMEORIGIN`。
+
+你可以通过以下配置轻松地实现这一点：
+
+例1.自定义默认安全标头
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+		WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) {
+		http
+			// ...
+			.headers(headers -> headers
+				.frameOptions(frameOptions -> frameOptions
+					.sameOrigin()
+				)
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<frame-options policy="SAMEORIGIN" />
+	</headers>
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            // ...
+            headers {
+                frameOptions {
+                    sameOrigin = true
+                }
+            }
+        }
+    }
+}
+```
+
+如果不希望添加默认值，并且希望对应该使用的内容进行显式控制，则可以禁用默认值。下面举例说明：
+
+如果你使用 Spring Security的配置，以下将只添加[缓存控制](../../features/exploits/headers.html#headers-cache-control)。
+
+例2.自定义缓存控制头
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			// ...
+			.headers(headers -> headers
+				// do not use any default headers unless explicitly listed
+				.defaultsDisabled()
+				.cacheControl(withDefaults())
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers defaults-disabled="true">
+		<cache-control/>
+	</headers>
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            // ...
+            headers {
+                // do not use any default headers unless explicitly listed
+                defaultsDisabled = true
+                cacheControl {
+                }
+            }
+        }
+    }
+}
+```
+
+如果有必要，可以通过以下配置禁用所有HTTP安全响应头：
+
+例3.禁用所有HTTP安全标头
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			// ...
+			.headers(headers -> headers.disable());
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers disabled="true" />
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            // ...
+            headers {
+                disable()
+            }
+        }
+    }
+}
+```
+
+## 缓存控制
+
+Spring 默认情况下，安全性包括[缓存控制](../../features/exploits/headers.html#headers-cache-control)标头。
+
+但是，如果你实际上想要缓存特定的响应，那么你的应用程序可以有选择地调用[HttpServletResponse.setheader（字符串，字符串）](https://docs.oracle.com/javaee/6/api/javax/servlet/http/HttpServletResponse.html#setHeader(java.lang.String,java.lang.String)）来覆盖由 Spring Security设置的头。这对于确保CSS、JavaScript和图像等内容被适当地缓存是有用的。
+
+当使用 Spring Web MVC时，这通常是在你的配置中完成的。关于如何做到这一点的详细信息可以在 Spring 参考文档的[静态资源](https://docs.spring.io/spring/docs/5.0.0.RELEASE/spring-framework-reference/web.html#mvc-config-static-resources)部分中找到。
+
+如果有必要，还可以禁用 Spring Security的缓存控制HTTP响应头。
+
+例4.已禁用缓存控制
+
+Java
+
+```
+@Configuration
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) {
+		http
+			// ...
+			.headers(headers -> headers
+				.cacheControl(cache -> cache.disable())
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<cache-control disabled="true"/>
+	</headers>
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+       http {
+            headers {
+                cacheControl {
+                    disable()
+                }
+            }
+        }
+    }
+}
+```
+
+## 内容类型选项
+
+Spring 默认情况下，安全性包括[内容类型](../../features/exploits/headers.html#headers-content-type-options)标头。但是，你可以通过以下方式禁用它：
+
+例5.禁用内容类型选项
+
+Java
+
+```
+@Configuration
+@EnableWebSecurity
+public class WebSecurityConfig extends
+		WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) {
+		http
+			// ...
+			.headers(headers -> headers
+				.contentTypeOptions(contentTypeOptions -> contentTypeOptions.disable())
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<content-type-options disabled="true"/>
+	</headers>
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+       http {
+            headers {
+                contentTypeOptions {
+                    disable()
+                }
+            }
+        }
+    }
+}
+```
+
+## 
+
+Spring 默认情况下，Security提供[严格的运输安全](../../features/exploits/headers.html#headers-hsts)头。但是，你可以显式地定制结果。例如，下面是一个显式提供HSTS的示例：
+
+例6.严格的运输安全
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			// ...
+			.headers(headers -> headers
+				.httpStrictTransportSecurity(hsts -> hsts
+					.includeSubDomains(true)
+					.preload(true)
+					.maxAgeInSeconds(31536000)
+				)
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<hsts
+			include-subdomains="true"
+			max-age-seconds="31536000"
+			preload="true" />
+	</headers>
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            headers {
+                httpStrictTransportSecurity {
+                    includeSubDomains = true
+                    preload = true
+                    maxAgeInSeconds = 31536000
+                }
+            }
+        }
+    }
+}
+```
+
+## 
+
+出于被动的原因， Spring Security为[HTTP公钥固定](../../features/exploits/headers.html#headers-hpkp)提供了 Servlet 支持，但它是[不再推荐](../../features/exploits/headers.html#headers-hpkp-deprecated)。
+
+你可以通过以下配置启用HPKP头：
+
+例7. HTTP公钥固定
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			// ...
+			.headers(headers -> headers
+				.httpPublicKeyPinning(hpkp -> hpkp
+					.includeSubDomains(true)
+					.reportUri("https://example.net/pkp-report")
+					.addSha256Pins("d6qzRu9zOECb90Uez27xWltNsj0e1Md7GkYYkVoZWmM=", "E9CZ9INDbd+2eRQozYqqbQ2yXLVKB9+xcprMF+44U1g=")
+				)
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<hpkp
+			include-subdomains="true"
+			report-uri="https://example.net/pkp-report">
+			<pins>
+				<pin algorithm="sha256">d6qzRu9zOECb90Uez27xWltNsj0e1Md7GkYYkVoZWmM=</pin>
+				<pin algorithm="sha256">E9CZ9INDbd+2eRQozYqqbQ2yXLVKB9+xcprMF+44U1g=</pin>
+			</pins>
+		</hpkp>
+	</headers>
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            headers {
+                httpPublicKeyPinning {
+                    includeSubDomains = true
+                    reportUri = "https://example.net/pkp-report"
+                    pins = mapOf("d6qzRu9zOECb90Uez27xWltNsj0e1Md7GkYYkVoZWmM=" to "sha256",
+                            "E9CZ9INDbd+2eRQozYqqbQ2yXLVKB9+xcprMF+44U1g=" to "sha256")
+                }
+            }
+        }
+    }
+}
+```
+
+## X-帧-选项
+
+默认情况下， Spring Security使用[X-帧-选项](../../features/exploits/headers.html#headers-frame-options)禁用在iFrame中的呈现。
+
+你可以使用以下方法自定义框架选项，以便在配置中使用相同的原点：
+
+例8. x-frame-options:SameOrigin
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			// ...
+			.headers(headers -> headers
+				.frameOptions(frameOptions -> frameOptions
+					.sameOrigin()
+				)
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<frame-options
+		policy="SAMEORIGIN" />
+	</headers>
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            headers {
+                frameOptions {
+                    sameOrigin = true
+                }
+            }
+        }
+    }
+}
+```
+
+## X-XSS-保护
+
+默认情况下， Spring Security指示浏览器使用\\<headers-xss-protection,X-XSS-Protection header\>来阻止反射的XSS攻击。但是，你可以更改此默认值。例如，以下配置指定 Spring 安全性不应再指示浏览器阻止内容：
+
+例9. X-XSS-保护定制
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			// ...
+			.headers(headers -> headers
+				.xssProtection(xss -> xss
+					.block(false)
+				)
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<xss-protection block="false"/>
+	</headers>
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        // ...
+        http {
+            headers {
+                xssProtection {
+                    block = false
+                }
+            }
+        }
+    }
+}
+```
+
+## 
+
+Spring 默认情况下安全性不添加[内容安全策略](../../features/exploits/headers.html#headers-csp)，因为合理的默认情况是不可能在没有上下文的情况下知道应用程序的。Web应用程序作者必须声明安全策略，以强制执行和/或监视受保护的资源。
+
+例如，给出以下安全策略：
+
+例10.内容安全策略示例
+
+```
+Content-Security-Policy: script-src 'self' https://trustedscripts.example.com; object-src https://trustedplugins.example.com; report-uri /csp-report-endpoint/
+```
+
+你可以启用CSP报头，如下所示：
+
+例11.内容安全策略
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) {
+		http
+			// ...
+			.headers(headers -> headers
+				.contentSecurityPolicy(csp -> csp
+					.policyDirectives("script-src 'self' https://trustedscripts.example.com; object-src https://trustedplugins.example.com; report-uri /csp-report-endpoint/")
+				)
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<content-security-policy
+			policy-directives="script-src 'self' https://trustedscripts.example.com; object-src https://trustedplugins.example.com; report-uri /csp-report-endpoint/" />
+	</headers>
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            // ...
+            headers {
+                contentSecurityPolicy {
+                    policyDirectives = "script-src 'self' https://trustedscripts.example.com; object-src https://trustedplugins.example.com; report-uri /csp-report-endpoint/"
+                }
+            }
+        }
+    }
+}
+```
+
+要启用CSP`report-only`头，请提供以下配置：
+
+例12.仅提供内容安全策略报告
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+		WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			// ...
+			.headers(headers -> headers
+				.contentSecurityPolicy(csp -> csp
+					.policyDirectives("script-src 'self' https://trustedscripts.example.com; object-src https://trustedplugins.example.com; report-uri /csp-report-endpoint/")
+					.reportOnly()
+				)
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<content-security-policy
+			policy-directives="script-src 'self' https://trustedscripts.example.com; object-src https://trustedplugins.example.com; report-uri /csp-report-endpoint/"
+			report-only="true" />
+	</headers>
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            // ...
+            headers {
+                contentSecurityPolicy {
+                    policyDirectives = "script-src 'self' https://trustedscripts.example.com; object-src https://trustedplugins.example.com; report-uri /csp-report-endpoint/"
+                    reportOnly = true
+                }
+            }
+        }
+    }
+}
+```
+
+## 推荐人政策
+
+Spring 默认情况下，安全性不添加[推荐人政策](../../features/exploits/headers.html#headers-referrer)标头。你可以使用如下所示的配置启用Referrer策略标头：
+
+例13.推荐人政策
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) {
+		http
+			// ...
+			.headers(headers -> headers
+				.referrerPolicy(referrer -> referrer
+					.policy(ReferrerPolicy.SAME_ORIGIN)
+				)
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<referrer-policy policy="same-origin" />
+	</headers>
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            // ...
+            headers {
+                referrerPolicy {
+                    policy = ReferrerPolicy.SAME_ORIGIN
+                }
+            }
+        }
+    }
+}
+```
+
+## 特征策略
+
+Spring 默认情况下，安全性不添加[特征策略](../../features/exploits/headers.html#headers-feature)头。以下`Feature-Policy`标题：
+
+例14.功能策略示例
+
+```
+Feature-Policy: geolocation 'self'
+```
+
+可以使用如下所示的配置启用功能策略标头：
+
+例15.特征-策略
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			// ...
+			.headers(headers -> headers
+				.featurePolicy("geolocation 'self'")
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<feature-policy policy-directives="geolocation 'self'" />
+	</headers>
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            // ...
+            headers {
+                featurePolicy("geolocation 'self'")
+            }
+        }
+    }
+}
+```
+
+## 权限策略
+
+Spring 默认情况下，安全性不添加[权限策略](../../features/exploits/headers.html#headers-permissions)标头。以下`Permissions-Policy`标题：
+
+例16.权限-策略示例
+
+```
+Permissions-Policy: geolocation=(self)
+```
+
+可以使用如下所示的配置启用权限策略标头：
+
+例17.权限-策略
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			// ...
+			.headers(headers -> headers
+				.permissionsPolicy(permissions -> permissions
+					.policy("geolocation=(self)")
+				)
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<permissions-policy policy="geolocation=(self)" />
+	</headers>
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            // ...
+            headers {
+                permissionPolicy {
+                    policy = "geolocation=(self)"
+                }
+            }
+        }
+    }
+}
+```
+
+## 清除站点数据
+
+Spring 默认情况下，安全性不添加[清除站点数据](../../features/exploits/headers.html#headers-clear-site-data)头。以下Clear-Site-Data报头：
+
+例18.清除站点数据示例
+
+```
+Clear-Site-Data: "cache", "cookies"
+```
+
+可以通过以下配置在注销时发送：
+
+例19.清除站点数据
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			// ...
+			.logout()
+				.addLogoutHandler(new HeaderWriterLogoutHandler(new ClearSiteDataHeaderWriter(CACHE, COOKIES)));
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            // ...
+            logout {
+                addLogoutHandler(HeaderWriterLogoutHandler(ClearSiteDataHeaderWriter(CACHE, COOKIES)))
+            }
+        }
+    }
+}
+```
+
+## 自定义标头
+
+Spring 安全性有一些机制，以使其方便地将更常见的安全性标题添加到你的应用程序中。然而，它也提供了钩子来支持添加自定义头。
+
+### 静态标头
+
+有时，你可能希望将自定义的安全标头插入到你的应用程序中，而这些标头不受开箱即用的支持。例如，给出以下自定义安全标头：
+
+```
+X-Custom-Security-Header: header-value
+```
+
+可以使用以下配置将标头添加到响应中：
+
+例20. Staticheaderswriter
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			// ...
+			.headers(headers -> headers
+				.addHeaderWriter(new StaticHeadersWriter("X-Custom-Security-Header","header-value"))
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<header name="X-Custom-Security-Header" value="header-value"/>
+	</headers>
+</http>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            // ...
+            headers {
+                addHeaderWriter(StaticHeadersWriter("X-Custom-Security-Header","header-value"))
+            }
+        }
+    }
+}
+```
+
+### Headers Writer
+
+当名称空间或 Java 配置不支持所需的标题时，可以创建自定义`HeadersWriter`实例，甚至提供`HeadersWriter`的自定义实现。
+
+让我们来看一个使用`XFrameOptionsHeaderWriter`自定义实例的示例。如果要显式配置[X-帧-选项](#servlet-headers-frame-options)，可以通过以下配置完成：
+
+例21. Headers Writer
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			// ...
+			.headers(headers -> headers
+				.addHeaderWriter(new XFrameOptionsHeaderWriter(XFrameOptionsMode.SAMEORIGIN))
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<header ref="frameOptionsWriter"/>
+	</headers>
+</http>
+<!-- Requires the c-namespace.
+See https://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#beans-c-namespace
+-->
+<beans:bean id="frameOptionsWriter"
+	class="org.springframework.security.web.header.writers.frameoptions.XFrameOptionsHeaderWriter"
+	c:frameOptionsMode="SAMEORIGIN"/>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            // ...
+            headers {
+                addHeaderWriter(XFrameOptionsHeaderWriter(XFrameOptionsMode.SAMEORIGIN))
+            }
+        }
+    }
+}
+```
+
+### 委托请求者headerwriter
+
+有时，你可能只想为某些请求写一个头。例如，你可能只想保护你的登录页面不被框起来。你可以使用`DelegatingRequestMatcherHeaderWriter`来执行此操作。
+
+在 Java 配置中使用`DelegatingRequestMatcherHeaderWriter`的示例如下所示：
+
+例22.授权请求MatcherHeaderWriter Java 配置
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		RequestMatcher matcher = new AntPathRequestMatcher("/login");
+		DelegatingRequestMatcherHeaderWriter headerWriter =
+			new DelegatingRequestMatcherHeaderWriter(matcher,new XFrameOptionsHeaderWriter());
+		http
+			// ...
+			.headers(headers -> headers
+				.frameOptions(frameOptions -> frameOptions.disable())
+				.addHeaderWriter(headerWriter)
+			);
+	}
+}
+```
+
+XML
+
+```
+<http>
+	<!-- ... -->
+
+	<headers>
+		<frame-options disabled="true"/>
+		<header ref="headerWriter"/>
+	</headers>
+</http>
+
+<beans:bean id="headerWriter"
+	class="org.springframework.security.web.header.writers.DelegatingRequestMatcherHeaderWriter">
+	<beans:constructor-arg>
+		<bean class="org.springframework.security.web.util.matcher.AntPathRequestMatcher"
+			c:pattern="/login"/>
+	</beans:constructor-arg>
+	<beans:constructor-arg>
+		<beans:bean
+			class="org.springframework.security.web.header.writers.frameoptions.XFrameOptionsHeaderWriter"/>
+	</beans:constructor-arg>
+</beans:bean>
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        val matcher: RequestMatcher = AntPathRequestMatcher("/login")
+        val headerWriter = DelegatingRequestMatcherHeaderWriter(matcher, XFrameOptionsHeaderWriter())
+       http {
+            headers {
+                frameOptions {
+                    disable()
+                }
+                addHeaderWriter(headerWriter)
+            }
+        }
+    }
+}
+```
+
+[Cross Site Request Forgery (CSRF) for Servlet Environments](csrf.html)[HTTP](http.html)
+
diff --git a/docs/spring-security/servlet-exploits-http.md b/docs/spring-security/servlet-exploits-http.md
new file mode 100644
index 0000000..f911db8
--- /dev/null
+++ b/docs/spring-security/servlet-exploits-http.md
@@ -0,0 +1,72 @@
+# HTTP
+
+所有基于HTTP的通信都应该受到保护[using TLS](../../features/exploits/http.html#http)。
+
+下面你可以找到有关 Servlet 特定特性的详细信息，这些特性有助于HTTPS的使用。
+
+## 重定向到HTTPS
+
+如果客户机使用HTTP而不是HTTPS发出请求，则可以将安全性配置为重定向到HTTPS。
+
+例如，以下 Java 配置将把任何HTTP请求重定向到HTTPS:
+
+例1.重定向到HTTPS
+
+Java
+
+```
+@Configuration
+@EnableWebSecurity
+public class WebSecurityConfig extends
+		WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) {
+		http
+			// ...
+			.requiresChannel(channel -> channel
+				.anyRequest().requiresSecure()
+			);
+	}
+}
+```
+
+Kotlin
+
+```
+@Configuration
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            // ...
+            requiresChannel {
+                secure(AnyRequestMatcher.INSTANCE, "REQUIRES_SECURE_CHANNEL")
+            }
+        }
+    }
+}
+```
+
+下面的XML配置将把所有HTTP请求重定向到HTTPS
+
+例2.使用XML配置重定向到HTTPS
+
+```
+<http>
+	<intercept-url pattern="/**" access="ROLE_USER" requires-channel="https"/>
+...
+</http>
+```
+
+## 严格的运输安全
+
+Spring 安全性为[严格的运输安全](headers.html#servlet-headers-hsts)提供支持，并在默认情况下启用它。
+
+## 代理服务器配置
+
+Spring 安全性[与代理服务器集成](../../features/exploits/http.html#http-proxy-server)。
+
+[安全HTTP响应标头](headers.html)[HttpFirewall ](firewall.html)
+
diff --git a/docs/spring-security/servlet-exploits.md b/docs/spring-security/servlet-exploits.md
new file mode 100644
index 0000000..d1ab8d1
--- /dev/null
+++ b/docs/spring-security/servlet-exploits.md
@@ -0,0 +1,13 @@
+# 保护免受剥削
+
+本节讨论 Servlet 对[Spring Security’s protection against common exploits](../../features/exploits/index.html#exploits)的特定支持。
+
+## 章节摘要
+
+* [Cross Site Request Forgery (CSRF) for Servlet Environments](csrf.html)
+* [安全HTTP响应标头](headers.html)
+* [HTTP](http.html)
+* [HttpFirewall](firewall.html)
+
+[SAML2元数据](../saml2/metadata.html)[Cross Site Request Forgery (CSRF) for Servlet Environments](csrf.html)
+
diff --git a/docs/spring-security/servlet-getting-started.md b/docs/spring-security/servlet-getting-started.md
new file mode 100644
index 0000000..8b6bd17
--- /dev/null
+++ b/docs/spring-security/servlet-getting-started.md
@@ -0,0 +1,79 @@
+# 你好 Spring 安全
+
+本节介绍了如何在 Spring 引导中使用 Spring 安全性的最小设置。
+
+|   |可以找到已完成的应用程序[在我们的样品库中](https://github.com/spring-projects/spring-security-samples/tree/5.6.x/servlet/spring-boot/java/hello-security)。<br/>为了你的方便，你可以通过[点击这里](https://start.spring.io/starter.zip?type=maven-project&language=java&packaging=jar&jvmVersion=1.8&groupId=example&artifactId=hello-security&name=hello-security&description=Hello%20Security&packageName=example.hello-security&dependencies=web,security)下载一个最小的 Spring 引导+ Spring 安全应用程序。|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## 更新依赖项
+
+你需要做的唯一一步是通过使用[Maven](../getting-spring-security.html#getting-maven-boot)或[Gradle](../getting-spring-security.html#getting-gradle-boot)更新依赖关系。
+
+## 启动Hello Spring 安全启动
+
+现在，你可以通过使用 Maven 插件的`run`目标[run the Spring Boot application](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#using-boot-running-with-the-maven-plugin)。下面的示例展示了如何这样做（以及这样做产生的输出的开始）：
+
+例1.运行 Spring 启动应用程序
+
+```
+$ ./mvn spring-boot:run
+...
+INFO 23689 --- [  restartedMain] .s.s.UserDetailsServiceAutoConfiguration :
+
+Using generated security password: 8e557245-73e2-4286-969a-ff57fe326336
+
+...
+```
+
+## Spring 引导自动配置
+
+Spring 自动启动：
+
+* 启用 Spring Security的默认配置，该配置将创建 Servlet `Filter`作为名为`springSecurityFilterChain`的 Bean。此 Bean 负责应用程序内的所有安全性（保护应用程序的URL、验证提交的用户名和密码、重定向到表单中的日志，等等）。
+
+* 创建一个`UserDetailsService` Bean，其用户名为`user`，并随机生成一个登录到控制台的密码。
+
+* 对于每个请求，用名为`springSecurityFilterChain`的 Bean 容器注册`Filter`。
+
+Spring Boot的配置不是很多，但它做了很多。以下是这些特征的摘要：
+
+* 与应用程序的任何交互都需要经过身份验证的用户。
+
+* 为你生成默认的登录表单
+
+* 让用户名为`user`且密码已登录到控制台的用户使用基于表单的身份验证进行身份验证（在前面的示例中，密码为`8e557245-73e2-4286-969a-ff57fe326336`）
+
+* 使用bcrypt保护密码存储
+
+* 让用户注销
+
+* [CSRF攻击](https://en.wikipedia.org/wiki/Cross-site_request_forgery)预防
+
+* [Session Fixation](https://en.wikipedia.org/wiki/Session_fixation)保护
+
+* 安全报头集成
+
+  * [HTTP严格的传输安全](https://en.wikipedia.org/wiki/HTTP_Strict_Transport_Security)用于安全请求
+
+  * [X-Content-Type-Options](https://msdn.microsoft.com/en-us/library/ie/gg622941(v=vs.85).ASPX）积分
+
+  * 缓存控制（可以稍后由应用程序重写，以允许缓存静态资源）
+
+  * [X-XSS-保护](https://msdn.microsoft.com/en-us/library/dd565647(v=vs.85).ASPX）积分
+
+  * x-frame-options集成，帮助防止[点击劫持](https://en.wikipedia.org/wiki/Clickjacking)
+
+* 与以下 Servlet API方法集成：
+
+  * [`HttpServletRequest#getRemoteUser()`]（https://DOCS.oracle.com/javaee/6/api/javax/ Servlet/http/httpservletrequest.html#getremoteuser（））
+
+  * [`HttpServletRequest.html#getUserPrincipal()`]（https://DOCS.oracle.com/javaee/6/api/javax/ Servlet/http/httpservletrequest.html#getUserprincipal（））
+
+  * [`HttpServletRequest.html#isUserInRole(java.lang.String)`]（https://DOCS.oracle.com/javaee/6/api/javax/ Servlet/http/httpservletrequest.html#isuserinrole（ Java.lang.string））
+
+  * [`HttpServletRequest.html#login(java.lang.String, java.lang.String)`]（https://DOCS.oracle.com/javaee/6/api/javax/ Servlet/http/httpservletrequest.html#login（ Java.lang.string，%20java.lang.string））
+
+  * [`HttpServletRequest.html#logout()`]（https://DOCS.oracle.com/javaee/6/api/javax/ Servlet/http/httpservletrequest.html#logout（））
+
+[Servlet Applications](index.html)[建筑](architecture.html)
+
diff --git a/docs/spring-security/servlet-integrations-concurrency.md b/docs/spring-security/servlet-integrations-concurrency.md
new file mode 100644
index 0000000..14eba18
--- /dev/null
+++ b/docs/spring-security/servlet-integrations-concurrency.md
@@ -0,0 +1,146 @@
+# 并发支持
+
+在大多数环境中，安全性是以per`Thread`为基础存储的。这意味着，当在新的`Thread`上完成工作时，`SecurityContext`将丢失。 Spring 安全性提供了一些基础设施，以帮助用户更容易地实现这一点。 Spring 安全性为在多线程环境中使用 Spring 安全性提供了低层次的抽象。实际上，这是 Spring 安全性构建在[`AsyncContext.start(Runnable)`]（ Servlet-api.html#servletapi-start-runnable）和[Spring MVC Async Integration](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();
+}
+}
+```
+
+虽然非常简单，但它可以无缝地将SecurityContext从一个线程转移到另一个线程。这一点很重要，因为在大多数情况下，SecurityContextholder是以每个线程为基础的。例如，你可能使用了 Spring Security的[`<global-method-security>`]（../acception/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();
+```
+
+上面的代码执行以下步骤：
+
+* 创建将调用我们的安全服务的`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();
+```
+
+我们拥有的代码使用起来很简单，但仍然需要了解我们正在使用 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);
+```
+
+代码执行以下步骤：
+
+* 创建用于我们的`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);
+}
+```
+
+现在我们的代码不知道`SecurityContext`正在传播到`Thread`，然后运行`originalRunnable`，然后清除`SecurityContextHolder`。在本例中，使用相同的用户运行每个线程。如果我们希望在调用`SecurityContextHolder`时使用来自`executor.execute(Runnable)`的用户（即当前登录的用户）来处理`originalRunnable`，该怎么办？这可以通过从我们的`DelegatingSecurityContextExecutor`构造函数中删除`SecurityContext`参数来完成。例如：
+
+```
+SimpleAsyncTaskExecutor delegateExecutor = new SimpleAsyncTaskExecutor();
+DelegatingSecurityContextExecutor executor =
+	new DelegatingSecurityContextExecutor(delegateExecutor);
+```
+
+现在，每当执行`executor.execute(Runnable)`时，`SecurityContext`首先由`SecurityContextHolder`得到，然后`SecurityContext`用于创建我们的`DelegatingSecurityContextRunnable`。这意味着我们运行`Runnable`的用户与调用`executor.execute(Runnable)`代码的用户相同。
+
+## Spring 安全并发类
+
+请参考Javadoc，以获取与 Java 并发API和 Spring 任务抽象的附加集成。一旦你理解了前面的代码，它们就非常不言自明了。
+
+* `DelegatingSecurityContextCallable`
+
+* `DelegatingSecurityContextExecutor`
+
+* `DelegatingSecurityContextExecutorService`
+
+* `DelegatingSecurityContextRunnable`
+
+* `DelegatingSecurityContextScheduledExecutorService`
+
+* `DelegatingSecurityContextSchedulingTaskExecutor`
+
+* `DelegatingSecurityContextAsyncTaskExecutor`
+
+* `DelegatingSecurityContextTaskExecutor`
+
+* `DelegatingSecurityContextTaskScheduler`
+
+[整合](index.html)[Jackson](jackson.html)
+
diff --git a/docs/spring-security/servlet-integrations-cors.md b/docs/spring-security/servlet-integrations-cors.md
new file mode 100644
index 0000000..301bd5b
--- /dev/null
+++ b/docs/spring-security/servlet-integrations-cors.md
@@ -0,0 +1,116 @@
+# CORS
+
+Spring Framework提供[CORS的一流支持](https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html#mvc-cors)。CORS必须在 Spring 安全性之前进行处理，因为飞行前请求将不包含任何cookie（即`JSESSIONID`）。如果请求不包含任何cookie并且 Spring 安全性是第一位的，则该请求将确定用户未经过身份验证（因为在该请求中没有cookie）并拒绝它。
+
+确保先处理CORS的最简单方法是使用`CorsFilter`。用户可以通过以下方式提供`CorsConfigurationSource`，将`CorsFilter`与 Spring 安全性集成在一起：
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			// by default uses a Bean by the name of corsConfigurationSource
+			.cors(withDefaults())
+			...
+	}
+
+	@Bean
+	CorsConfigurationSource corsConfigurationSource() {
+		CorsConfiguration configuration = new CorsConfiguration();
+		configuration.setAllowedOrigins(Arrays.asList("https://example.com"));
+		configuration.setAllowedMethods(Arrays.asList("GET","POST"));
+		UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+		source.registerCorsConfiguration("/**", configuration);
+		return source;
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+open class WebSecurityConfig : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            // by default uses a Bean by the name of corsConfigurationSource
+            cors { }
+            // ...
+        }
+    }
+
+    @Bean
+    open fun corsConfigurationSource(): CorsConfigurationSource {
+        val configuration = CorsConfiguration()
+        configuration.allowedOrigins = listOf("https://example.com")
+        configuration.allowedMethods = listOf("GET", "POST")
+        val source = UrlBasedCorsConfigurationSource()
+        source.registerCorsConfiguration("/**", configuration)
+        return source
+    }
+}
+```
+
+或在XML中
+
+```
+<http>
+	<cors configuration-source-ref="corsSource"/>
+	...
+</http>
+<b:bean id="corsSource" class="org.springframework.web.cors.UrlBasedCorsConfigurationSource">
+	...
+</b:bean>
+```
+
+如果使用 Spring MVC的CORS支持，则可以省略指定`CorsConfigurationSource`，并且 Spring Security将利用提供给 Spring MVC的CORS配置。
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			// if Spring MVC is on classpath and no CorsConfigurationSource is provided,
+			// Spring Security will use CORS configuration provided to Spring MVC
+			.cors(withDefaults())
+			...
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+open class WebSecurityConfig : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            // if Spring MVC is on classpath and no CorsConfigurationSource is provided,
+            // Spring Security will use CORS configuration provided to Spring MVC
+            cors { }
+            // ...
+        }
+    }
+}
+```
+
+或在XML中
+
+```
+<http>
+	<!-- Default to Spring MVC's CORS configuration -->
+	<cors />
+	...
+</http>
+```
+
+[WebSocket](websocket.html)[JSP Taglib](jsp-taglibs.html)
+
diff --git a/docs/spring-security/servlet-integrations-data.md b/docs/spring-security/servlet-integrations-data.md
new file mode 100644
index 0000000..cc57ad3
--- /dev/null
+++ b/docs/spring-security/servlet-integrations-data.md
@@ -0,0 +1,59 @@
+# Spring 数据集成
+
+Spring 安全性提供了 Spring 数据集成，允许在查询中引用当前用户。将用户包括在查询中以支持分页结果不仅是有用的，而且是必要的，因为在此之后对结果进行过滤将不会扩展。
+
+## Spring 数据和 Spring 安全配置
+
+要使用此支持，请添加`org.springframework.security:spring-security-data`依赖项，并提供`SecurityEvaluationContextExtension`类型的 Bean:
+
+Java
+
+```
+@Bean
+public SecurityEvaluationContextExtension securityEvaluationContextExtension() {
+	return new SecurityEvaluationContextExtension();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun securityEvaluationContextExtension(): SecurityEvaluationContextExtension {
+	return SecurityEvaluationContextExtension()
+}
+```
+
+在XML配置中，这看起来像是：
+
+```
+<bean class="org.springframework.security.data.repository.query.SecurityEvaluationContextExtension"/>
+```
+
+## @query中的安全表达式
+
+现在，安全性可以在查询中使用。例如：
+
+Java
+
+```
+@Repository
+public interface MessageRepository extends PagingAndSortingRepository<Message,Long> {
+	@Query("select m from Message m where m.to.id = ?#{ principal?.id }")
+	Page<Message> findInbox(Pageable pageable);
+}
+```
+
+Kotlin
+
+```
+@Repository
+interface MessageRepository : PagingAndSortingRepository<Message,Long> {
+	@Query("select m from Message m where m.to.id = ?#{ principal?.id }")
+	fun findInbox(pageable: Pageable): Page<Message>
+}
+```
+
+这将检查`Authentication.getPrincipal().getId()`是否等于`Message`的接收者。请注意，本例假定你已将主体自定义为具有ID属性的对象。通过公开`SecurityEvaluationContextExtension` Bean，查询中的所有[常见的安全表达式](../authorization/expression-based.html#common-expressions)都是可用的。
+
+[Servlet APIs](servlet-api.html)[Spring MVC](mvc.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-integrations-jackson.md b/docs/spring-security/servlet-integrations-jackson.md
new file mode 100644
index 0000000..05b721e
--- /dev/null
+++ b/docs/spring-security/servlet-integrations-jackson.md
@@ -0,0 +1,23 @@
+# 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<Module> modules = SecurityJackson2Modules.getModules(loader);
+mapper.registerModules(modules);
+
+// ... use ObjectMapper as normally ...
+SecurityContext context = new SecurityContextImpl();
+// ...
+String json = mapper.writeValueAsString(context);
+```
+
+|   |以下 Spring 安全模块提供了Jackson支持：<br/><br/>* Spring-security-core（`CoreJackson2Module`）<br/><br/>* Spring-security-web（`WebJackson2Module`，`WebServletJackson2Module`，`WebServerJackson2Module`）<br/>（<11"gt="9"/>r=“r=”/>（<18"r="19"r=">>>>>（<<<<<gt="r="10">>>>>>|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+[并发性](concurrency.html)[本地化](localization.html)
+
diff --git a/docs/spring-security/servlet-integrations-jsp-taglibs.md b/docs/spring-security/servlet-integrations-jsp-taglibs.md
new file mode 100644
index 0000000..50ab01d
--- /dev/null
+++ b/docs/spring-security/servlet-integrations-jsp-taglibs.md
@@ -0,0 +1,163 @@
+# JSP标记库
+
+## 宣布Taglib
+
+要使用任何标记，你必须在JSP中声明安全性taglib:
+
+```
+<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags" %>
+```
+
+## 授权标签
+
+此标记用于确定是否应该对其内容进行评估。在 Spring Security3.0中，可以用两种方式<sup class="footnote">[<a id="_footnoteref_1" class="footnote" href="#_footnotedef_1" title="View footnote.">1</a>]</sup>。第一种方法使用[Web安全表达式](../authorization/expression-based.html#el-access-web)，在标记的`access`属性中指定。表达式求值将委托给在应用程序上下文中定义的`SecurityExpressionHandler<FilterInvocation>`（你应该在`<http>`名称空间配置中启用Web表达式，以确保此服务可用）。所以，举个例子，你可能
+
+```
+<sec:authorize access="hasRole('supervisor')">
+
+This content will only be visible to users who have the "supervisor" authority in their list of <tt>GrantedAuthority</tt>s.
+
+</sec:authorize>
+```
+
+当与 Spring Security的PermissionEvaluator结合使用时，该标记还可以用于检查权限。例如：
+
+```
+<sec:authorize access="hasPermission(#domain,'read') or hasPermission(#domain,'write')">
+
+This content will only be visible to users who have read or write permission to the Object found as a request attribute named "domain".
+
+</sec:authorize>
+```
+
+一个常见的要求是只显示一个特定的链接，如果用户实际上被允许单击它的话。我们怎样才能事先确定某件事是否会被允许？这个标记也可以在另一种模式下操作，这种模式允许你将特定的URL定义为一个属性。如果允许用户调用该URL，则将计算标记主体，否则将跳过该标记主体。所以你可能会有一些类似的东西
+
+```
+<sec:authorize url="/admin">
+
+This content will only be visible to users who are authorized to send requests to the "/admin" URL.
+
+</sec:authorize>
+```
+
+要使用此标记，还必须在应用程序上下文中有`WebInvocationPrivilegeEvaluator`的实例。如果使用名称空间，将自动注册一个名称空间。这是`DefaultWebInvocationPrivilegeEvaluator`的一个实例，该实例为提供的URL创建一个虚拟Web请求，并调用安全拦截器查看请求是成功还是失败。这允许你委派到使用`<http>`命名空间配置中的`intercept-url`声明定义的访问控制设置，并节省了在JSP中复制信息（例如所需的角色）的时间。这种方法还可以与`method`属性结合，提供HTTP方法，以进行更具体的匹配。
+
+通过将`var`属性设置为变量名，可以将计算标记（无论是授予还是拒绝访问）的布尔结果存储在页面上下文范围变量中，从而避免了在页面的其他点重复和重新计算条件的需要。
+
+### 禁用标记授权以进行测试
+
+在页面中为未经授权的用户隐藏链接并不会阻止他们访问该URL。例如，他们可以直接在浏览器中输入。作为测试过程的一部分，你可能想要显示隐藏的区域，以检查链接是否真的在后端得到了保护。如果将系统属性`spring.security.disableUISecurity`设置为`true`，则`authorize`标记仍将运行，但不会隐藏其内容。默认情况下，它还会用`<span class="securityHiddenUI">…​</span>`标记包围内容。这允许你以特定的CSS样式（例如不同的背景颜色）显示“隐藏”内容。例如，尝试在启用此属性的情况下运行“tutorial”示例应用程序。
+
+如果你想从默认的`span`标记中更改周围的文本（或使用空字符串完全删除它），还可以设置属性`spring.security.securedUIPrefix`和`spring.security.securedUISuffix`。
+
+## 身份验证标记
+
+此标记允许访问存储在安全上下文中的当前`Authentication`对象。它在JSP中直接呈现对象的属性。因此，例如，如果`Authentication`的`principal`属性是 Spring Security的`UserDetails`对象的实例，那么使用`<sec:authentication property="principal.username" />`将呈现当前用户的名称。
+
+当然，在这种情况下没有必要使用JSP标记，有些人更喜欢在视图中尽可能少地保留逻辑。你可以访问MVC控制器中的`Authentication`对象（通过调用`SecurityContextHolder.getContext().getAuthentication()`），并将数据直接添加到模型中，以便由视图进行呈现。
+
+## AccessControlist标签
+
+此标记仅在与 Spring Security的ACL模块一起使用时有效。它检查指定域对象所需权限的逗号分隔列表。如果当前用户拥有所有这些权限，那么将对标记主体进行评估。如果他们不这么做，就会被跳过。一个例子可能是
+
+|   |一般来说，这个标记应该被认为是废弃的。<br/>而不是使用[授权标签](#taglibs-authorize)。|
+|---|-----------------------------------------------------------------------------------------------------------------|
+
+```
+<sec:accesscontrollist hasPermission="1,2" domainObject="${someObject}">
+
+This will be shown if the user has all of the permissions represented by the values "1" or "2" on the given object.
+
+</sec:accesscontrollist>
+```
+
+这些权限被传递给在应用程序上下文中定义的`PermissionFactory`，将它们转换为ACL`Permission`实例，因此它们可以是工厂支持的任何格式-它们不必是整数，它们可以是`READ`或`WRITE`之类的字符串。如果没有找到`PermissionFactory`，将使用`DefaultPermissionFactory`的实例。应用程序上下文中的`AclService`将用于为所提供的对象加载`Acl`实例。将使用所需的权限调用`Acl`，以检查是否已授予所有权限。
+
+该标记还支持`var`属性，与`authorize`标记的方式相同。
+
+## csrfinput标记
+
+如果启用了CSRF保护，则此标记将插入一个隐藏的表单字段，其中包含CSRF保护令牌的正确名称和值。如果未启用CSRF保护，则此标记不输出任何内容。
+
+Spring 通常情况下，Security会自动为你使用的任何`<form:form>`标记插入一个CSRF窗体字段，但是如果由于某种原因你无法使用`<form:form>`，`csrfInput`是一个方便的替换。
+
+你应该将此标记放置在HTML`<form></form>`块中，在该块中你通常会放置其他输入字段。不要将此标记放置在 Spring `<form:form></form:form>`块中。 Spring 安全自动处理 Spring 表单。
+
+```
+	<form method="post" action="/do/something">
+		<sec:csrfInput />
+		Name:<br />
+		<input type="text" name="name" />
+		...
+	</form>
+```
+
+## CSRFmetatags标签
+
+如果启用了CSRF保护，则此标记将插入包含CSRF保护令牌窗体域和头名称以及CSRF保护令牌值的元标记。这些元标记对于在应用程序的JavaScript中使用CSRF保护非常有用。
+
+你应该将`csrfMetaTags`放在HTML`<head></head>`块中，在该块中你通常会放置其他元标记。使用此标记后，就可以使用JavaScript轻松地访问表单字段名、标头名和令牌值。本例中使用了jQuery来简化任务。
+
+```
+<!DOCTYPE html>
+<html>
+	<head>
+		<title>CSRF Protected JavaScript Page</title>
+		<meta name="description" content="This is the description for this page" />
+		<sec:csrfMetaTags />
+		<script type="text/javascript" language="javascript">
+
+			var csrfParameter = $("meta[name='_csrf_parameter']").attr("content");
+			var csrfHeader = $("meta[name='_csrf_header']").attr("content");
+			var csrfToken = $("meta[name='_csrf']").attr("content");
+
+			// using XMLHttpRequest directly to send an x-www-form-urlencoded request
+			var ajax = new XMLHttpRequest();
+			ajax.open("POST", "https://www.example.org/do/something", true);
+			ajax.setRequestHeader("Content-Type", "application/x-www-form-urlencoded data");
+			ajax.send(csrfParameter + "=" + csrfToken + "&name=John&...");
+
+			// using XMLHttpRequest directly to send a non-x-www-form-urlencoded request
+			var ajax = new XMLHttpRequest();
+			ajax.open("POST", "https://www.example.org/do/something", true);
+			ajax.setRequestHeader(csrfHeader, csrfToken);
+			ajax.send("...");
+
+			// using JQuery to send an x-www-form-urlencoded request
+			var data = {};
+			data[csrfParameter] = csrfToken;
+			data["name"] = "John";
+			...
+			$.ajax({
+				url: "https://www.example.org/do/something",
+				type: "POST",
+				data: data,
+				...
+			});
+
+			// using JQuery to send a non-x-www-form-urlencoded request
+			var headers = {};
+			headers[csrfHeader] = csrfToken;
+			$.ajax({
+				url: "https://www.example.org/do/something",
+				type: "POST",
+				headers: headers,
+				...
+			});
+
+		<script>
+	</head>
+	<body>
+		...
+	</body>
+</html>
+```
+
+如果不启用CSRF保护，`csrfMetaTags`将不输出任何内容。
+
+---
+
+[1](#_footnoteref_1)。还支持 Spring Security2.0中的遗留选项，但不推荐。
+
+[Spring’s CORS Support](cors.html)[Java Configuration](../configuration/java.html)
+
diff --git a/docs/spring-security/servlet-integrations-localization.md b/docs/spring-security/servlet-integrations-localization.md
new file mode 100644
index 0000000..7cf9767
--- /dev/null
+++ b/docs/spring-security/servlet-integrations-localization.md
@@ -0,0 +1,24 @@
+# 本地化
+
+如果你需要支持其他语言环境，那么你需要了解的所有内容都包含在本节中。
+
+所有异常消息都可以本地化，包括与身份验证失败和访问被拒绝（授权失败）相关的消息。针对开发人员或系统部署人员的异常和日志消息（包括不正确的属性、违反接口契约、使用不正确的构造函数、启动时间验证、调试级别的日志记录）没有本地化，而是在 Spring Security的代码中用英文进行了硬编码。
+
+在`spring-security-core-xx.jar`中，你将发现一个`org.springframework.security`包，该包依次包含一个`messages.properties`文件，以及一些常见语言的本地化版本。这应该由你的`ApplicationContext`来引用，因为 Spring 安全类实现了 Spring 的`MessageSourceAware`接口，并且期望消息解析程序是在应用程序上下文启动时注入的依赖项。通常，你所需要做的就是在应用程序上下文中注册一个 Bean 来引用消息。下面是一个例子：
+
+```
+<bean id="messageSource"
+	class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
+<property name="basename" value="classpath:org/springframework/security/messages"/>
+</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 本地化的更多详细信息。
+
+将“联系人”示例应用程序设置为使用本地化消息。
+
+[Jackson](jackson.html)[Servlet APIs](servlet-api.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-integrations-mvc.md b/docs/spring-security/servlet-integrations-mvc.md
new file mode 100644
index 0000000..6c74b54
--- /dev/null
+++ b/docs/spring-security/servlet-integrations-mvc.md
@@ -0,0 +1,508 @@
+# Spring MVC集成
+
+Spring 安全性提供了与 Spring MVC的许多可选集成。本节将进一步详细介绍集成。
+
+## @enableWebMVCSecurity
+
+|   |在 Spring Security4.0中，`@EnableWebMvcSecurity`已被弃用。<br/>替换为`@EnableWebSecurity`，这将决定在 Classpath 的基础上添加 Spring MVC特性。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+要启用 Spring 与 Spring MVC的安全集成，请在配置中添加`@EnableWebSecurity`注释。
+
+|   |Spring 安全性提供了使用 Spring MVC的的配置。这意味着，如果你正在使用更高级的选项，比如直接与集成，那么你将需要手动提供 Spring 安全性配置。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## MVCrequestMatcher
+
+Spring 安全性提供了与 Spring MVC如何在具有`MvcRequestMatcher`的URL上匹配的深度集成。这有助于确保你的安全规则与用于处理请求的逻辑相匹配。
+
+为了使用`MvcRequestMatcher`，你必须将 Spring 安全配置放在与你的`DispatcherServlet`相同的`ApplicationContext`中。这是必要的，因为 Spring Security的`MvcRequestMatcher`期望名称为`HandlerMappingIntrospector` Bean 的`mvcHandlerMappingIntrospector`被用于执行匹配的 Spring MVC配置注册。
+
+对于`web.xml`，这意味着你应该将配置放在`DispatcherServlet.xml`中。
+
+```
+<listener>
+  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
+</listener>
+
+<!-- All Spring Configuration (both MVC and Security) are in /WEB-INF/spring/ -->
+<context-param>
+  <param-name>contextConfigLocation</param-name>
+  <param-value>/WEB-INF/spring/*.xml</param-value>
+</context-param>
+
+<servlet>
+  <servlet-name>spring</servlet-name>
+  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
+  <!-- Load from the ContextLoaderListener -->
+  <init-param>
+    <param-name>contextConfigLocation</param-name>
+    <param-value></param-value>
+  </init-param>
+</servlet>
+
+<servlet-mapping>
+  <servlet-name>spring</servlet-name>
+  <url-pattern>/</url-pattern>
+</servlet-mapping>
+```
+
+下面`WebSecurityConfiguration`中置于`DispatcherServlet`s`ApplicationContext`中。
+
+Java
+
+```
+public class SecurityInitializer extends
+    AbstractAnnotationConfigDispatcherServletInitializer {
+
+  @Override
+  protected Class<?>[] getRootConfigClasses() {
+    return null;
+  }
+
+  @Override
+  protected Class<?>[] getServletConfigClasses() {
+    return new Class[] { RootConfiguration.class,
+        WebMvcConfiguration.class };
+  }
+
+  @Override
+  protected String[] getServletMappings() {
+    return new String[] { "/" };
+  }
+}
+```
+
+Kotlin
+
+```
+class SecurityInitializer : AbstractAnnotationConfigDispatcherServletInitializer() {
+    override fun getRootConfigClasses(): Array<Class<*>>? {
+        return null
+    }
+
+    override fun getServletConfigClasses(): Array<Class<*>> {
+        return arrayOf(
+            RootConfiguration::class.java,
+            WebMvcConfiguration::class.java
+        )
+    }
+
+    override fun getServletMappings(): Array<String> {
+        return arrayOf("/")
+    }
+}
+```
+
+|   |始终建议通过匹配`HttpServletRequest`和方法安全性来提供授权规则。<br/><br/>通过匹配`HttpServletRequest`来提供授权规则是很好的，因为它在代码路径中很早就发生了，并且有助于减少<br/>方法安全性确保如果有人绕过了Web授权规则，那么你的应用程序仍然是安全的。<br/>这就是所谓的[纵深防御](https://en.wikipedia.org/wiki/Defense_in_depth_(computing)）|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+考虑一个映射如下的控制器：
+
+Java
+
+```
+@RequestMapping("/admin")
+public String admin() {
+```
+
+Kotlin
+
+```
+@RequestMapping("/admin")
+fun admin(): String {
+```
+
+如果我们希望将对此控制器方法的访问限制为管理用户，那么开发人员可以通过在`HttpServletRequest`上匹配以下内容来提供授权规则：
+
+Java
+
+```
+protected configure(HttpSecurity http) throws Exception {
+	http
+		.authorizeHttpRequests(authorize -> authorize
+			.antMatchers("/admin").hasRole("ADMIN")
+		);
+}
+```
+
+Kotlin
+
+```
+override fun configure(http: HttpSecurity) {
+    http {
+        authorizeRequests {
+            authorize(AntPathRequestMatcher("/admin"), hasRole("ADMIN"))
+        }
+    }
+}
+```
+
+或在XML中
+
+```
+<http>
+	<intercept-url pattern="/admin" access="hasRole('ADMIN')"/>
+</http>
+```
+
+对于任一种配置，URL`/admin`将要求经过身份验证的用户是管理用户。然而，根据我们的 Spring MVC配置，URL`/admin.html`也将映射到我们的`admin()`方法。此外，根据我们的 Spring MVC配置，URL`/admin/`也将映射到我们的`admin()`方法。
+
+问题在于，我们的安全规则仅保护`/admin`。我们可以为 Spring MVC的所有排列添加额外的规则，但这将是非常冗长和乏味的。
+
+相反，我们可以利用 Spring security的`MvcRequestMatcher`。下面的配置将通过使用 Spring MVC在URL上进行匹配来保护与 Spring MVC匹配的相同的URL。
+
+Java
+
+```
+protected configure(HttpSecurity http) throws Exception {
+	http
+		.authorizeHttpRequests(authorize -> authorize
+			.mvcMatchers("/admin").hasRole("ADMIN")
+		);
+}
+```
+
+Kotlin
+
+```
+override fun configure(http: HttpSecurity) {
+    http {
+        authorizeRequests {
+            authorize("/admin", hasRole("ADMIN"))
+        }
+    }
+}
+```
+
+或在XML中
+
+```
+<http request-matcher="mvc">
+	<intercept-url pattern="/admin" access="hasRole('ADMIN')"/>
+</http>
+```
+
+## @AuthenticationPrincipal
+
+Spring 安全性提供了`AuthenticationPrincipalArgumentResolver`，它可以自动解析 Spring MVC参数的当前`Authentication.getPrincipal()`。通过使用`@EnableWebSecurity`，你将自动将其添加到 Spring MVC配置中。如果使用基于XML的配置，则必须自己添加该配置。例如：
+
+```
+<mvc:annotation-driven>
+		<mvc:argument-resolvers>
+				<bean class="org.springframework.security.web.method.annotation.AuthenticationPrincipalArgumentResolver" />
+		</mvc:argument-resolvers>
+</mvc:annotation-driven>
+```
+
+一旦`AuthenticationPrincipalArgumentResolver`被正确配置，你就可以在 Spring MVC层中与 Spring 安全性完全解耦。
+
+考虑一种情况，其中一个自定义`UserDetailsService`返回一个`Object`，它实现`UserDetails`和你自己的`CustomUser``Object`。可以使用以下代码访问当前经过身份验证的用户的`CustomUser`:
+
+Java
+
+```
+@RequestMapping("/messages/inbox")
+public ModelAndView findMessagesForUser() {
+	Authentication authentication =
+	SecurityContextHolder.getContext().getAuthentication();
+	CustomUser custom = (CustomUser) authentication == null ? null : authentication.getPrincipal();
+
+	// .. find messages for this user and return them ...
+}
+```
+
+Kotlin
+
+```
+@RequestMapping("/messages/inbox")
+open fun findMessagesForUser(): ModelAndView {
+    val authentication: Authentication = SecurityContextHolder.getContext().authentication
+    val custom: CustomUser? = if (authentication as CustomUser == null) null else authentication.principal
+
+    // .. find messages for this user and return them ...
+}
+```
+
+从 Spring Security3.2开始，我们可以通过添加一个注释来更直接地解决该参数。例如：
+
+Java
+
+```
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+
+// ...
+
+@RequestMapping("/messages/inbox")
+public ModelAndView findMessagesForUser(@AuthenticationPrincipal CustomUser customUser) {
+
+	// .. find messages for this user and return them ...
+}
+```
+
+Kotlin
+
+```
+@RequestMapping("/messages/inbox")
+open fun findMessagesForUser(@AuthenticationPrincipal customUser: CustomUser?): ModelAndView {
+
+    // .. find messages for this user and return them ...
+}
+```
+
+有时可能有必要以某种方式转换本金。例如，如果`CustomUser`需要是最终的，则不能对其进行扩展。在这种情况下，`UserDetailsService`可能返回一个`Object`，它实现`UserDetails`并提供一个名为`getCustomUser`的方法来访问`CustomUser`。例如，它可能看起来像：
+
+Java
+
+```
+public class CustomUserUserDetails extends User {
+		// ...
+		public CustomUser getCustomUser() {
+				return customUser;
+		}
+}
+```
+
+Kotlin
+
+```
+class CustomUserUserDetails(
+    username: String?,
+    password: String?,
+    authorities: MutableCollection<out GrantedAuthority>?
+) : User(username, password, authorities) {
+    // ...
+    val customUser: CustomUser? = null
+}
+```
+
+然后，我们可以使用一个[Spel表达式](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/expressions.html)访问`CustomUser`，它使用`Authentication.getPrincipal()`作为根对象：
+
+Java
+
+```
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+
+// ...
+
+@RequestMapping("/messages/inbox")
+public ModelAndView findMessagesForUser(@AuthenticationPrincipal(expression = "customUser") CustomUser customUser) {
+
+	// .. find messages for this user and return them ...
+}
+```
+
+Kotlin
+
+```
+import org.springframework.security.core.annotation.AuthenticationPrincipal
+
+// ...
+
+@RequestMapping("/messages/inbox")
+open fun findMessagesForUser(@AuthenticationPrincipal(expression = "customUser") customUser: CustomUser?): ModelAndView {
+
+    // .. find messages for this user and return them ...
+}
+```
+
+我们也可以在SPEL表达式中引用bean。例如，如果我们使用 JPA 来管理我们的用户，并且我们希望修改并保存当前用户的属性，那么可以使用以下内容。
+
+Java
+
+```
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+
+// ...
+
+@PutMapping("/users/self")
+public ModelAndView updateName(@AuthenticationPrincipal(expression = "@jpaEntityManager.merge(#this)") CustomUser attachedCustomUser,
+		@RequestParam String firstName) {
+
+	// change the firstName on an attached instance which will be persisted to the database
+	attachedCustomUser.setFirstName(firstName);
+
+	// ...
+}
+```
+
+Kotlin
+
+```
+import org.springframework.security.core.annotation.AuthenticationPrincipal
+
+// ...
+
+@PutMapping("/users/self")
+open fun updateName(
+    @AuthenticationPrincipal(expression = "@jpaEntityManager.merge(#this)") attachedCustomUser: CustomUser,
+    @RequestParam firstName: String?
+): ModelAndView {
+
+    // change the firstName on an attached instance which will be persisted to the database
+    attachedCustomUser.setFirstName(firstName)
+
+    // ...
+}
+```
+
+通过在我们自己的注释上使用`@AuthenticationPrincipal`元注释，我们可以进一步消除对 Spring 安全性的依赖。下面我们将演示如何在名为`@CurrentUser`的注释上实现这一点。
+
+|   |重要的是要认识到，为了消除对 Spring 安全性的依赖关系，将创建`@CurrentUser`的是消耗应用程序。<br/>这一步骤并不是严格必需的，但有助于将你对 Spring 安全性的依赖关系隔离到一个更中心的位置。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+Java
+
+```
+@Target({ElementType.PARAMETER, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@AuthenticationPrincipal
+public @interface CurrentUser {}
+```
+
+Kotlin
+
+```
+@Target(AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.TYPE)
+@Retention(AnnotationRetention.RUNTIME)
+@MustBeDocumented
+@AuthenticationPrincipal
+annotation class CurrentUser
+```
+
+现在已经指定了`@CurrentUser`，我们可以使用它来发送信号，以解析当前已验证用户的`CustomUser`。我们还将对 Spring 安全性的依赖隔离到一个文件中。
+
+Java
+
+```
+@RequestMapping("/messages/inbox")
+public ModelAndView findMessagesForUser(@CurrentUser CustomUser customUser) {
+
+	// .. find messages for this user and return them ...
+}
+```
+
+Kotlin
+
+```
+@RequestMapping("/messages/inbox")
+open fun findMessagesForUser(@CurrentUser customUser: CustomUser?): ModelAndView {
+
+    // .. find messages for this user and return them ...
+}
+```
+
+## Spring MVC异步集成
+
+Spring Web MVC3.2+对[异步请求处理](https://docs.spring.io/spring/docs/3.2.x/spring-framework-reference/html/mvc.html#mvc-ann-async)具有出色的支持。 Spring 在没有额外配置的情况下，Security将自动将`SecurityContext`设置为调用控制器返回的`Thread`的`Callable`。例如，下面的方法将自动使用创建`Callable`时可用的`SecurityContext`调用其`Callable`:
+
+Java
+
+```
+@RequestMapping(method=RequestMethod.POST)
+public Callable<String> processUpload(final MultipartFile file) {
+
+return new Callable<String>() {
+	public Object call() throws Exception {
+	// ...
+	return "someView";
+	}
+};
+}
+```
+
+Kotlin
+
+```
+@RequestMapping(method = [RequestMethod.POST])
+open fun processUpload(file: MultipartFile?): Callable<String> {
+    return Callable {
+        // ...
+        "someView"
+    }
+}
+```
+
+|   |将SecurityContext与Callable的<br/><br/>更严格地说， Spring Security与`WebAsyncManager`集成。<br/>用于处理`Callable`的`SecurityContext`是在调用`SecurityContextHolder`时存在于`SecurityContextHolder`上的`SecurityContext`。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+没有控制器返回的`DeferredResult`的自动集成。这是因为`DeferredResult`是由用户处理的，因此无法自动与其集成。然而，你仍然可以使用[并发支持](../../features/integrations/concurrency.html#concurrency)来提供具有 Spring 安全性的透明集成。
+
+## Spring MVC和CSRF集成
+
+### 自动令牌包含
+
+Spring 在使用[Spring MVC form tag](https://docs.spring.io/spring/docs/3.2.x/spring-framework-reference/html/view.html#view-jsp-formtaglib-formtag)的窗体中，安全性将自动[包括CSRF令牌](../exploits/csrf.html#servlet-csrf-include)。例如，下面的JSP:
+
+```
+<jsp:root xmlns:jsp="http://java.sun.com/JSP/Page"
+	xmlns:c="http://java.sun.com/jsp/jstl/core"
+	xmlns:form="http://www.springframework.org/tags/form" version="2.0">
+	<jsp:directive.page language="java" contentType="text/html" />
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+	<!-- ... -->
+
+	<c:url var="logoutUrl" value="/logout"/>
+	<form:form action="${logoutUrl}"
+		method="post">
+	<input type="submit"
+		value="Log out" />
+	<input type="hidden"
+		name="${_csrf.parameterName}"
+		value="${_csrf.token}"/>
+	</form:form>
+
+	<!-- ... -->
+</html>
+</jsp:root>
+```
+
+将输出类似于以下内容的HTML:
+
+```
+<!-- ... -->
+
+<form action="/context/logout" method="post">
+<input type="submit" value="Log out"/>
+<input type="hidden" name="_csrf" value="f81d4fae-7dec-11d0-a765-00a0c91e6bf6"/>
+</form>
+
+<!-- ... -->
+```
+
+### 解析CSRFToken
+
+Spring Security提供了`CsrfTokenArgumentResolver`，它可以自动解析 Spring MVC参数的当前`CsrfToken`。通过使用[@enableWebSecurity](../configuration/java.html#jc-hello-wsca)，你将自动将其添加到 Spring MVC配置中。如果使用基于XML的配置，则必须自己添加该配置。
+
+一旦正确配置了`CsrfTokenArgumentResolver`，就可以将`CsrfToken`公开到基于HTML的静态应用程序中。
+
+Java
+
+```
+@RestController
+public class CsrfController {
+
+	@RequestMapping("/csrf")
+	public CsrfToken csrf(CsrfToken token) {
+		return token;
+	}
+}
+```
+
+Kotlin
+
+```
+@RestController
+class CsrfController {
+    @RequestMapping("/csrf")
+    fun csrf(token: CsrfToken): CsrfToken {
+        return token
+    }
+}
+```
+
+保持`CsrfToken`是其他域的秘密是很重要的。这意味着如果你使用[跨源共享](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS)，那么你应该**NOT**将`CsrfToken`公开到任何外部域。
+
+[Spring Data](data.html)[WebSocket](websocket.html)
+
diff --git a/docs/spring-security/servlet-integrations-servlet-api.md b/docs/spring-security/servlet-integrations-servlet-api.md
new file mode 100644
index 0000000..41f8709
--- /dev/null
+++ b/docs/spring-security/servlet-integrations-servlet-api.md
@@ -0,0 +1,216 @@
+# Servlet API集成
+
+## Servlet 2.5+集成
+
+### HttpServletRequest.getRemoteUser（）
+
+[HttpServletRequest.getRemoteUser（）](https://docs.oracle.com/javaee/6/api/javax/servlet/http/HttpServletRequest.html#getRemoteUser()）将返回`SecurityContextHolder.getContext().getAuthentication().getName()`的结果，这通常是当前的用户名。如果你希望在应用程序中显示当前用户名，这将非常有用。此外，检查此值是否为null可以用来指示用户是否已通过身份验证或是匿名的。了解用户是否经过了身份验证，对于确定某些UI元素是否应该显示是有用的（例如，只有在用户经过身份验证的情况下才应该显示注销链接）。
+
+### HttpServletRequest.getUserPrincipal（）
+
+[HttpServletRequest.getUserPrincipal（）](https://docs.oracle.com/javaee/6/api/javax/servlet/http/HttpServletRequest.html#getUserPrincipal()）将返回`SecurityContextHolder.getContext().getAuthentication()`的结果。这意味着它是`Authentication`，当使用基于用户名和密码的身份验证时，它通常是`UsernamePasswordAuthenticationToken`的一个实例。如果你需要有关你的用户的其他信息，这可能是有用的。例如，你可能已经创建了一个自定义`UserDetailsService`，它返回一个自定义的`UserDetails`，其中包含用户的姓和名。你可以通过以下方式获得此信息：
+
+Java
+
+```
+Authentication auth = httpServletRequest.getUserPrincipal();
+// assume integrated custom UserDetails called MyCustomUserDetails
+// by default, typically instance of UserDetails
+MyCustomUserDetails userDetails = (MyCustomUserDetails) auth.getPrincipal();
+String firstName = userDetails.getFirstName();
+String lastName = userDetails.getLastName();
+```
+
+Kotlin
+
+```
+val auth: Authentication = httpServletRequest.getUserPrincipal()
+// assume integrated custom UserDetails called MyCustomUserDetails
+// by default, typically instance of UserDetails
+val userDetails: MyCustomUserDetails = auth.principal as MyCustomUserDetails
+val firstName: String = userDetails.firstName
+val lastName: String = userDetails.lastName
+```
+
+|   |应该注意的是，在整个应用程序中执行这么多逻辑通常是糟糕的做法。<br/>相反，应该将其集中以减少 Spring 安全性和 Servlet API的任何耦合。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### HttpServletRequest.isUserinRole（字符串）
+
+[HttpServletRequest.isUserinRole（字符串）](https://docs.oracle.com/javaee/6/api/javax/servlet/http/HttpServletRequest.html#isUserInRole(java.lang.String)）将确定`SecurityContextHolder.getContext().getAuthentication().getAuthorities()`是否包含带有传递到`isUserInRole(String)`的角色的`GrantedAuthority`。通常，用户不应该将“role\_”前缀传入此方法，因为它是自动添加的。例如，如果你想确定当前用户是否拥有“role\_admin”权限，可以使用以下方法：
+
+Java
+
+```
+boolean isAdmin = httpServletRequest.isUserInRole("ADMIN");
+```
+
+Kotlin
+
+```
+val isAdmin: Boolean = httpServletRequest.isUserInRole("ADMIN")
+```
+
+这对于确定是否应该显示某些UI组件可能很有用。例如，你可能仅在当前用户是管理员的情况下才显示管理链接。
+
+## Servlet 3+集成
+下面的部分描述了 Spring 安全性集成的 Servlet 3种方法。
+
+### HttpServletRequest.Authenticate（HttpServletRequest，HttpServletResponse）
+
+可以使用[HttpServletRequest.Authenticate（HttpServletRequest，HttpServletResponse）](https://docs.oracle.com/javaee/6/api/javax/servlet/http/HttpServletRequest.html#authenticate%28javax.servlet.http.HttpServletResponse%29)方法来确保对用户进行身份验证。如果未对它们进行身份验证，则将使用配置的身份验证中心点来请求用户进行身份验证（即重定向到登录页面）。
+
+### HttpServletRequest.login（字符串，字符串）
+可以使用[HttpServletRequest.login（字符串，字符串）](https://docs.oracle.com/javaee/6/api/javax/servlet/http/HttpServletRequest.html#login%28java.lang.String,%20java.lang.String%29)方法对当前`AuthenticationManager`的用户进行身份验证。例如，下面将尝试使用用户名“user”和密码“password”进行身份验证：
+
+Java
+
+```
+try {
+httpServletRequest.login("user","password");
+} catch(ServletException ex) {
+// fail to authenticate
+}
+```
+
+Kotlin
+
+```
+try {
+    httpServletRequest.login("user", "password")
+} catch (ex: ServletException) {
+    // fail to authenticate
+}
+```
+
+|   |如果你希望 Spring 安全性来处理失败的身份验证尝试，那么不需要捕获ServletException。|
+|---|---------------------------------------------------------------------------------------------------------------------------|
+
+### HttpServletRequest.logout（）
+可以使用[HttpServletRequest.logout（）](https://docs.oracle.com/javaee/6/api/javax/servlet/http/HttpServletRequest.html#logout%28%29)方法将当前用户注销。
+
+通常，这意味着SecurityContextholder将被清除，HttpSession将无效，任何“记住我”的身份验证都将被清除，等等。然而，所配置的LogouthAndler实现将根据你的 Spring 安全配置而有所不同。需要注意的是，在调用了HttpServletRequest.logout（）之后，你仍然负责编写响应。通常情况下，这需要重定向到欢迎页面。
+
+### AsyncContext.start（可运行）
+确保你的凭据将被传播到新线程的[AsyncContext.start（可运行）](https://docs.oracle.com/javaee/6/api/javax/servlet/AsyncContext.html#start%28java.lang.Runnable%29)方法。利用 Spring Security的并发支持， Spring Security覆盖了AsyncContext.Start，以确保在处理Runnable时使用当前的SecurityContext。例如，下面将输出当前用户的身份验证：
+
+Java
+
+```
+final AsyncContext async = httpServletRequest.startAsync();
+async.start(new Runnable() {
+	public void run() {
+		Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+		try {
+			final HttpServletResponse asyncResponse = (HttpServletResponse) async.getResponse();
+			asyncResponse.setStatus(HttpServletResponse.SC_OK);
+			asyncResponse.getWriter().write(String.valueOf(authentication));
+			async.complete();
+		} catch(Exception ex) {
+			throw new RuntimeException(ex);
+		}
+	}
+});
+```
+
+Kotlin
+
+```
+val async: AsyncContext = httpServletRequest.startAsync()
+async.start {
+    val authentication: Authentication = SecurityContextHolder.getContext().authentication
+    try {
+        val asyncResponse = async.response as HttpServletResponse
+        asyncResponse.status = HttpServletResponse.SC_OK
+        asyncResponse.writer.write(String.valueOf(authentication))
+        async.complete()
+    } catch (ex: Exception) {
+        throw RuntimeException(ex)
+    }
+}
+```
+
+### 异步 Servlet 支持
+如果你正在使用基于 Java 的配置，那么你已经准备好了。如果你正在使用XML配置，那么有一些更新是必要的。第一步是确保你已经更新了web.xml，以至少使用3.0模式，如下所示：
+
+```
+<web-app xmlns="http://java.sun.com/xml/ns/javaee"
+xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+xsi:schemaLocation="http://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
+version="3.0">
+
+</web-app>
+```
+
+接下来，你需要确保你的SpringSecurityFilterchain是为处理异步请求而设置的。
+
+```
+<filter>
+<filter-name>springSecurityFilterChain</filter-name>
+<filter-class>
+	org.springframework.web.filter.DelegatingFilterProxy
+</filter-class>
+<async-supported>true</async-supported>
+</filter>
+<filter-mapping>
+<filter-name>springSecurityFilterChain</filter-name>
+<url-pattern>/*</url-pattern>
+<dispatcher>REQUEST</dispatcher>
+<dispatcher>ASYNC</dispatcher>
+</filter-mapping>
+```
+
+就是这样！现在 Spring 安全性将确保你的SecurityContext也在异步请求上传播。
+
+那么，它是如何工作的呢？如果你真的不感兴趣，请跳过这一节的其余部分，否则请继续阅读。这其中的大部分是内置在 Servlet 规范中的，但是 Spring 安全性做了一些调整，以确保异步请求能够正常工作。在 Spring Security3.2之前，一旦提交了HttpServletResponse，来自SecurityContextholder的SecurityContext就会自动保存。这可能会在异步环境中引起问题。例如，考虑以下几点：
+
+Java
+
+```
+httpServletRequest.startAsync();
+new Thread("AsyncThread") {
+	@Override
+	public void run() {
+		try {
+			// Do work
+			TimeUnit.SECONDS.sleep(1);
+
+			// Write to and commit the httpServletResponse
+			httpServletResponse.getOutputStream().flush();
+		} catch (Exception ex) {
+			ex.printStackTrace();
+		}
+	}
+}.start();
+```
+
+Kotlin
+
+```
+httpServletRequest.startAsync()
+object : Thread("AsyncThread") {
+    override fun run() {
+        try {
+            // Do work
+            TimeUnit.SECONDS.sleep(1)
+
+            // Write to and commit the httpServletResponse
+            httpServletResponse.outputStream.flush()
+        } catch (ex: java.lang.Exception) {
+            ex.printStackTrace()
+        }
+    }
+}.start()
+```
+
+问题是安全性不知道这个线程，因此SecurityContext不会传播到它。这意味着当我们提交HttpServletResponse时，不存在SecurityContext。 Spring 当Security在提交HttpServletResponse时自动保存SecurityContext时，它将丢失已登录的用户。
+
+自版本3.2以来， Spring 安全性已经足够聪明，不再在调用HttpServletRequest.startasync（）时提交HttpServletResponse时自动保存SecurityContext。
+
+## Servlet 3.1+集成
+下面的部分描述了 Spring 安全性集成的 Servlet 3.1方法。
+
+### HttpServletRequest#changesessionID（）
+在 Servlet 3.1及更高版本中，[HttpServletRequest.changesessionID（）](https://docs.oracle.com/javaee/7/api/javax/servlet/http/HttpServletRequest.html#changeSessionId()）是防止[Session Fixation](../authentication/session-management.html#ns-session-fixation)攻击的默认方法。
+
+[本地化](localization.html)[Spring Data](data.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-integrations-websocket.md b/docs/spring-security/servlet-integrations-websocket.md
new file mode 100644
index 0000000..5fe14a9
--- /dev/null
+++ b/docs/spring-security/servlet-integrations-websocket.md
@@ -0,0 +1,441 @@
+# WebSocket 安全
+
+Spring Security4增加了对保护[Spring’s WebSocket support](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/websocket.html)的支持。本节介绍如何使用 Spring Security的 WebSocket 支持。
+
+直接支持JSR-356
+
+Spring 安全性不提供直接的JSR-356支持，因为这样做将提供很少的价值。这是因为格式未知，所以有[little Spring can do to secure an unknown format](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/websocket.html#websocket-intro-sub-protocol)。此外，JSR-356不提供截获消息的方法，因此安全性将是侵入性的。
+
+## WebSocket 配置
+
+Spring Security4.0通过 Spring 消息抽象引入了对WebSockets的授权支持。要使用 Java 配置配置来配置授权，只需扩展`AbstractSecurityWebSocketMessageBrokerConfigurer`并配置`MessageSecurityMetadataSourceRegistry`。例如：
+
+Java
+
+```
+@Configuration
+public class WebSocketSecurityConfig
+      extends AbstractSecurityWebSocketMessageBrokerConfigurer { (1) (2)
+
+    protected void configureInbound(MessageSecurityMetadataSourceRegistry messages) {
+        messages
+                .simpDestMatchers("/user/**").authenticated() (3)
+    }
+}
+```
+
+Kotlin
+
+```
+@Configuration
+open class WebSocketSecurityConfig : AbstractSecurityWebSocketMessageBrokerConfigurer() { (1) (2)
+    override fun configureInbound(messages: MessageSecurityMetadataSourceRegistry) {
+        messages.simpDestMatchers("/user/**").authenticated() (3)
+    }
+}
+```
+
+这将确保：
+
+|**1**|任何入站连接消息都需要一个有效的CSRF令牌来执行[同源政策](#websocket-sameorigin)|
+|-----|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|**2**|对于任何入站请求，SecurityContextholder都在Simpuser header属性中填充用户。|
+|**3**|我们的信息需要得到适当的授权。具体地说，任何以“/user/”开头的入站消息都需要角色\_user。有关授权的更多详细信息，请参见[WebSocket 授权](#websocket-authorization)。|
+
+Spring 安全性还提供了[XML命名空间](../appendix/namespace/websocket.html#nsa-websocket-security)用于保护WebSockets的支持。类似的基于XML的配置如下所示：
+
+```
+<websocket-message-broker> (1) (2)
+    (3)
+    <intercept-message pattern="/user/**" access="hasRole('USER')" />
+</websocket-message-broker>
+```
+
+这将确保：
+
+|**1**|任何入站连接消息都需要一个有效的CSRF令牌来执行[同源政策](#websocket-sameorigin)|
+|-----|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|**2**|对于任何入站请求，SecurityContextholder都在Simpuser header属性中填充用户。|
+|**3**|我们的信息需要得到适当的授权。具体地说，任何以“/user/”开头的入站消息都需要角色\_user。有关授权的更多详细信息，请参见[WebSocket Authorization](#websocket-authorization)。|
+
+## WebSocket 认证
+
+WebSockets重用在建立 WebSocket 连接时在HTTP请求中找到的相同的身份验证信息。这意味着`Principal`上的`HttpServletRequest`将被传递给WebSockets。如果使用 Spring 安全性，则`HttpServletRequest`上的`Principal`将自动被重写。
+
+更具体地说，为了确保用户已经对你的 WebSocket 应用程序进行了身份验证，所有必要的是确保设置 Spring 安全性以对基于HTTP的Web应用程序进行身份验证。
+
+## WebSocket Authorization
+
+Spring Security4.0通过 Spring 消息抽象引入了对WebSockets的授权支持。要使用 Java 配置配置来配置授权，只需扩展`AbstractSecurityWebSocketMessageBrokerConfigurer`并配置`MessageSecurityMetadataSourceRegistry`。例如：
+
+Java
+
+```
+@Configuration
+public class WebSocketSecurityConfig extends AbstractSecurityWebSocketMessageBrokerConfigurer {
+
+    @Override
+    protected void configureInbound(MessageSecurityMetadataSourceRegistry messages) {
+        messages
+                .nullDestMatcher().authenticated() (1)
+                .simpSubscribeDestMatchers("/user/queue/errors").permitAll() (2)
+                .simpDestMatchers("/app/**").hasRole("USER") (3)
+                .simpSubscribeDestMatchers("/user/**", "/topic/friends/*").hasRole("USER") (4)
+                .simpTypeMatchers(MESSAGE, SUBSCRIBE).denyAll() (5)
+                .anyMessage().denyAll(); (6)
+
+    }
+}
+```
+
+Kotlin
+
+```
+@Configuration
+open class WebSocketSecurityConfig : AbstractSecurityWebSocketMessageBrokerConfigurer() {
+    override fun configureInbound(messages: MessageSecurityMetadataSourceRegistry) {
+        messages
+            .nullDestMatcher().authenticated() (1)
+            .simpSubscribeDestMatchers("/user/queue/errors").permitAll() (2)
+            .simpDestMatchers("/app/**").hasRole("USER") (3)
+            .simpSubscribeDestMatchers("/user/**", "/topic/friends/*").hasRole("USER") (4)
+            .simpTypeMatchers(MESSAGE, SUBSCRIBE).denyAll() (5)
+            .anyMessage().denyAll() (6)
+    }
+}
+```
+
+这将确保：
+
+|**1**|任何没有目的地的消息（即消息类型或订阅以外的任何消息）都需要对用户进行身份验证。|
+|-----|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|**2**|任何人都可以订阅/user/queue/errors|
+|**3**|任何具有以“/app/”开头的目标的消息都将要求用户具有角色\_user|
+|**4**|任何以“/user/”或“/topic/friends/”开头、类型为Subscribe的消息都需要角色\_user|
+|**5**|任何其他类型为消息或订阅的消息都将被拒绝。由于6，我们不需要这个步骤，但它说明了如何在特定的消息类型上进行匹配。|
+|**6**|任何其他消息都将被拒绝。这是一个好主意，以确保你不会错过任何消息。|
+
+Spring 安全性还提供了[XML命名空间](../appendix/namespace/websocket.html#nsa-websocket-security)用于保护WebSockets的支持。类似的基于XML的配置如下所示：
+
+```
+<websocket-message-broker>
+    (1)
+    <intercept-message type="CONNECT" access="permitAll" />
+    <intercept-message type="UNSUBSCRIBE" access="permitAll" />
+    <intercept-message type="DISCONNECT" access="permitAll" />
+
+    <intercept-message pattern="/user/queue/errors" type="SUBSCRIBE" access="permitAll" /> (2)
+    <intercept-message pattern="/app/**" access="hasRole('USER')" />      (3)
+
+    (4)
+    <intercept-message pattern="/user/**" access="hasRole('USER')" />
+    <intercept-message pattern="/topic/friends/*" access="hasRole('USER')" />
+
+    (5)
+    <intercept-message type="MESSAGE" access="denyAll" />
+    <intercept-message type="SUBSCRIBE" access="denyAll" />
+
+    <intercept-message pattern="/**" access="denyAll" /> (6)
+</websocket-message-broker>
+```
+
+这将确保：
+
+|**1**|任何类型为“连接”、“取消订阅”或“断开连接”的消息都需要对用户进行身份验证。|
+|-----|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|**2**|任何人都可以订阅/user/queue/errors|
+|**3**|任何具有以“/app/”开头的目标的消息都将要求用户具有角色\_user|
+|**4**|任何以“/user/”或“/topic/friends/”开头、类型为Subscribe的消息都需要角色\_user|
+|**5**|任何其他类型为消息或订阅的消息都将被拒绝。由于6，我们不需要这个步骤，但它说明了如何在特定的消息类型上进行匹配。|
+|**6**|具有目的的任何其他消息都将被拒绝。这是一个好主意，以确保你不会错过任何消息。|
+
+### WebSocket 授权说明
+
+为了正确地保护你的应用程序，理解 Spring 的 WebSocket 支持非常重要。
+
+#### WebSocket 对消息类型的授权
+
+理解消息的订阅和消息类型之间的区别以及它在 Spring 中的工作方式非常重要。
+
+考虑一个聊天应用程序。
+
+* 系统可以通过目标“/topic/system/notifications”向所有用户发送通知消息。
+
+* 客户端可以通过订阅“/topic/system/notification”来接收通知。
+
+虽然我们希望客户机能够订阅“/topic/system/notifications”，但我们并不希望使他们能够向该目的地发送消息。如果我们允许向“/topic/system/notifications”发送消息，那么客户端可以直接向该端点发送消息并模拟系统。
+
+通常，应用程序会拒绝发送到以[代理前缀](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/websocket.html#websocket-stomp)（即“/topic/”或“/queue/”）开头的目标的任何消息。
+
+#### WebSocket 目的地授权
+
+了解目的地是如何转变的也很重要。
+
+考虑一个聊天应用程序。
+
+* 用户可以通过向“/app/chat”的目的地发送消息来向特定用户发送消息。
+
+* 应用程序看到消息，确保将“from”属性指定为当前用户（我们不能信任客户端）。
+
+* 然后，应用程序使用`SimpMessageSendingOperations.convertAndSendToUser("toUser", "/queue/messages", message)`将消息发送给收件人。
+
+* 消息被转换为“/queue/user/messages-\<sessionid\>”的目标。
+
+对于上面的应用程序，我们希望允许我们的客户机侦听“/user/queue”，它被转换为“/queue/user/messages-\<sessionid\>”。但是，我们不希望客户机能够侦听“/queue/\*”，因为这将允许客户机查看每个用户的消息。
+
+通常，应用程序会拒绝发送到以[代理前缀](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/websocket.html#websocket-stomp)（即“/topic/”或“/queue/”）开头的消息的任何订阅。当然，我们可能会提供例外情况，以解释诸如
+
+### 出站消息
+
+Spring 包含一个标题为[消息流](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/websocket.html#websocket-stomp-message-flow)的部分，该部分描述了消息如何在系统中流动。需要注意的是， Spring 安全性仅保护`clientInboundChannel`。 Spring 安全性不试图保护`clientOutboundChannel`。
+
+这其中最重要的原因是业绩。对于每一条传入的消息，通常都会有更多的消息传出。我们鼓励保护对端点的订阅，而不是保护出站消息。
+
+## 执行同源政策
+
+需要强调的是，对于 WebSocket 连接，浏览器并不强制执行[同源政策](https://en.wikipedia.org/wiki/Same-origin_policy)。这是一个极其重要的考虑因素。
+
+### 为什么是同源？
+
+考虑以下场景。用户访问bank.com并对其帐户进行身份验证。同一个用户在浏览器中打开另一个标签，然后访问Evil.com。相同的源策略确保Evil.com不能将数据读写到bank.com。
+
+对于WebSockets，相同的源策略不适用。事实上，除非bank.com明确禁止，否则evil.com可以代表用户读写数据。这意味着用户可以在 WebSocket 上做的任何事情（即转账），Evil.com都可以代表用户做。
+
+由于Sockjs试图模拟WebSockets，因此它也绕过了相同的源策略。这意味着开发人员在使用Sockjs时需要显式地保护其应用程序不受外部域的影响。
+
+### Spring  WebSocket 允许原产地
+
+幸运的是，由于 Spring 4.1.5 Spring 的 WebSocket 和Sockjs支持限制了对[当前域](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/websocket.html#websocket-server-allowed-origins)的访问。 Spring 安全性增加了额外的保护层，以提供[纵深防御](https://en.wikipedia.org/wiki/Defense_in_depth_(computing)）。
+
+### 将CSRF添加到Stomp头
+
+Spring 默认情况下，安全性要求在任何连接消息类型中使用[CSRF token](../../features/exploits/csrf.html#csrf)。这确保只有能够访问CSRF令牌的站点才能进行连接。由于只有**同源**可以访问CSRF令牌，因此不允许外部域进行连接。
+
+通常，我们需要在HTTP报头或HTTP参数中包含CSRF令牌。然而，Sockjs不允许这些选项。相反，我们必须在Stomp头中包含令牌。
+
+应用程序可以通过访问名为\_CSRF的请求属性[获取CSRF令牌](../exploits/csrf.html#servlet-csrf-include)。例如，下面将允许访问JSP中的`CsrfToken`:
+
+```
+var headerName = "${_csrf.headerName}";
+var token = "${_csrf.token}";
+```
+
+如果使用静态HTML，则可以在REST端点上公开`CsrfToken`。例如，下面将公开URL/CSRF上的`CsrfToken`
+
+Java
+
+```
+@RestController
+public class CsrfController {
+
+    @RequestMapping("/csrf")
+    public CsrfToken csrf(CsrfToken token) {
+        return token;
+    }
+}
+```
+
+Kotlin
+
+```
+@RestController
+class CsrfController {
+    @RequestMapping("/csrf")
+    fun csrf(token: CsrfToken): CsrfToken {
+        return token
+    }
+}
+```
+
+JavaScript可以对端点进行REST调用，并使用响应来填充headername和令牌。
+
+我们现在可以在我们的STOMP客户端中包含令牌。例如：
+
+```
+...
+var headers = {};
+headers[headerName] = token;
+stompClient.connect(headers, function(frame) {
+  ...
+
+}
+```
+
+### 禁用WebSockets中的CSRF
+
+如果你希望允许其他域访问你的站点，则可以禁用 Spring Security的保护。例如，在 Java 配置中，你可以使用以下方法：
+
+Java
+
+```
+@Configuration
+public class WebSocketSecurityConfig extends AbstractSecurityWebSocketMessageBrokerConfigurer {
+
+    ...
+
+    @Override
+    protected boolean sameOriginDisabled() {
+        return true;
+    }
+}
+```
+
+Kotlin
+
+```
+@Configuration
+open class WebSocketSecurityConfig : AbstractSecurityWebSocketMessageBrokerConfigurer() {
+
+    // ...
+
+    override fun sameOriginDisabled(): Boolean {
+        return true
+    }
+}
+```
+
+## 与Sockjs合作
+
+[SockJS](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/websocket.html#websocket-fallback)提供后备传输以支持较旧的浏览器。在使用后备选项时，我们需要放松一些安全约束，以允许Sockjs使用 Spring 安全性。
+
+### sockjs&frame-选项
+
+Sockjs可以使用[利用iframe的传输](https://github.com/sockjs/sockjs-client/tree/v0.3.4)。 Spring 默认情况下，安全性将[deny](../../features/exploits/headers.html#headers-frame-options)网站框起来，以防止点击劫持攻击。为了允许基于SockJS帧的传输工作，我们需要配置 Spring 安全性，以允许相同的源来帧内容。
+
+你可以使用[框架-选项](../appendix/namespace/http.html#nsa-frame-options)元素自定义X-frame-options。例如，下面将指示 Spring Security使用“X-Frame-Options:SameOrigin”，它允许在相同的域内使用IFrames:
+
+```
+<http>
+    <!-- ... -->
+
+    <headers>
+        <frame-options
+          policy="SAMEORIGIN" />
+    </headers>
+</http>
+```
+
+类似地，你可以使用以下方式自定义框架选项，以便在 Java 配置中使用相同的原点：
+
+Java
+
+```
+@EnableWebSecurity
+public class WebSecurityConfig extends
+   WebSecurityConfigurerAdapter {
+
+    @Override
+    protected void configure(HttpSecurity http) throws Exception {
+        http
+            // ...
+            .headers(headers -> headers
+                .frameOptions(frameOptions -> frameOptions
+                     .sameOrigin()
+                )
+        );
+    }
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+open class WebSecurityConfig : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            // ...
+            headers {
+                frameOptions {
+                    sameOrigin = true
+                }
+            }
+        }
+    }
+}
+```
+
+### Sockjs&放松的CSRF
+
+对于任何基于HTTP的传输，Sockjs都会在Connect消息上使用POST。通常，我们需要在HTTP报头或HTTP参数中包含CSRF令牌。然而，Sockjs不允许这些选项。相反，我们必须像[将CSRF添加到Stomp头](#websocket-sameorigin-csrf)中描述的那样，在stomp头中包含令牌。
+
+这也意味着我们需要放松对Web层的CSRF保护。具体地说，我们希望禁用我们的连接URL的CSRF保护。我们不希望禁用每个URL的CSRF保护。否则，我们的网站将容易受到CSRF攻击。
+
+我们可以通过提供CSRF请求匹配器轻松地实现这一点。我们的 Java 配置使这一点变得非常容易。例如，如果我们的Stomp端点是“/chat”，那么我们可以使用以下配置，仅禁用以“/chat/”开头的URL的CSRF保护：
+
+Java
+
+```
+@Configuration
+@EnableWebSecurity
+public class WebSecurityConfig
+    extends WebSecurityConfigurerAdapter {
+
+    @Override
+    protected void configure(HttpSecurity http) throws Exception {
+        http
+            .csrf(csrf -> csrf
+                // ignore our stomp endpoints since they are protected using Stomp headers
+                .ignoringAntMatchers("/chat/**")
+            )
+            .headers(headers -> headers
+                // allow same origin to frame our site to support iframe SockJS
+                .frameOptions(frameOptions -> frameOptions
+                    .sameOrigin()
+                )
+            )
+            .authorizeHttpRequests(authorize -> authorize
+                ...
+            )
+            ...
+```
+
+Kotlin
+
+```
+@Configuration
+@EnableWebSecurity
+open class WebSecurityConfig : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            csrf {
+                ignoringAntMatchers("/chat/**")
+            }
+            headers {
+                frameOptions {
+                    sameOrigin = true
+                }
+            }
+            authorizeRequests {
+                // ...
+            }
+            // ...
+```
+
+如果我们使用基于XML的配置，我们可以使用[[电子邮件保护]]（../acception/namespace/http.html#NSA-csrf-request-matcher-ref）。例如：
+
+```
+<http ...>
+    <csrf request-matcher-ref="csrfMatcher"/>
+
+    <headers>
+        <frame-options policy="SAMEORIGIN"/>
+    </headers>
+
+    ...
+</http>
+
+<b:bean id="csrfMatcher"
+    class="AndRequestMatcher">
+    <b:constructor-arg value="#{T(org.springframework.security.web.csrf.CsrfFilter).DEFAULT_CSRF_MATCHER}"/>
+    <b:constructor-arg>
+        <b:bean class="org.springframework.security.web.util.matcher.NegatedRequestMatcher">
+          <b:bean class="org.springframework.security.web.util.matcher.AntPathRequestMatcher">
+            <b:constructor-arg value="/chat/**"/>
+          </b:bean>
+        </b:bean>
+    </b:constructor-arg>
+</b:bean>
+```
+
+[Spring MVC](mvc.html)[Spring’s CORS Support](cors.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-integrations.md b/docs/spring-security/servlet-integrations.md
new file mode 100644
index 0000000..8367b45
--- /dev/null
+++ b/docs/spring-security/servlet-integrations.md
@@ -0,0 +1,17 @@
+# 整合
+
+Spring 安全性与许多框架和API集成在一起。在本节中，我们将讨论 Spring 安全性集成：
+
+## 章节摘要
+
+* [并发性](concurrency.html)
+* [Jackson](jackson.html)
+* [本地化](localization.html)
+* [Servlet APIs](servlet-api.html)
+* [Spring Data](data.html)
+* [Spring MVC](mvc.html)
+* [WebSocket](websocket.html)
+* [Spring’s CORS Support](cors.html)
+* [JSP Taglib](jsp-taglibs.html)
+
+[HttpFirewall](../exploits/firewall.html)[并发性](concurrency.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-oauth2-.md b/docs/spring-security/servlet-oauth2-.md
new file mode 100644
index 0000000..5b6f863
--- /dev/null
+++ b/docs/spring-security/servlet-oauth2-.md
@@ -0,0 +1,11 @@
+# OAuth2
+
+Spring 安全性提供了全面的OAuth2支持。本节讨论如何将OAuth2集成到基于 Servlet 的应用程序中。
+
+## 章节摘要
+
+* [OAuth2登录](login/index.html)
+* [OAuth2客户端](client/index.html)
+* [OAuth2资源服务器](resource-server/index.html)
+
+[域对象安全ACLS](../authorization/acls.html)[OAuth2登录](login/index.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-oauth2-client-authorization-grants.md b/docs/spring-security/servlet-oauth2-client-authorization-grants.md
new file mode 100644
index 0000000..f0a832c
--- /dev/null
+++ b/docs/spring-security/servlet-oauth2-client-authorization-grants.md
@@ -0,0 +1,1176 @@
+# 授权赠款支助
+
+## 授权代码
+
+|   |有关[授权代码](https://tools.ietf.org/html/rfc6749#section-1.3.1)授权的更多详细信息，请参阅OAuth2.0授权框架。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 获得授权
+
+|   |请参阅[授权请求/回应](https://tools.ietf.org/html/rfc6749#section-4.1.1)协议流以获得授权代码授权。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 发起授权请求
+
+`OAuth2AuthorizationRequestRedirectFilter`使用`OAuth2AuthorizationRequestResolver`解析`OAuth2AuthorizationRequest`，并通过将最终用户的用户代理重定向到授权服务器的授权端点来启动授权代码授予流。
+
+`OAuth2AuthorizationRequestResolver`的主要作用是从提供的Web请求中解析`OAuth2AuthorizationRequest`。默认实现`DefaultOAuth2AuthorizationRequestResolver`在（默认）路径`/oauth2/authorization/{registrationId}`上匹配，提取`registrationId`并使用它为关联的`OAuth2AuthorizationRequest`构建`OAuth2AuthorizationRequest`。
+
+给出了OAuth2.0客户端注册的以下 Spring Boot2.x属性：
+
+```
+spring:
+  security:
+    oauth2:
+      client:
+        registration:
+          okta:
+            client-id: okta-client-id
+            client-secret: okta-client-secret
+            authorization-grant-type: authorization_code
+            redirect-uri: "{baseUrl}/authorized/okta"
+            scope: read, write
+        provider:
+          okta:
+            authorization-uri: https://dev-1234.oktapreview.com/oauth2/v1/authorize
+            token-uri: https://dev-1234.oktapreview.com/oauth2/v1/token
+```
+
+具有基本路径`/oauth2/authorization/okta`的请求将启动由`OAuth2AuthorizationRequestRedirectFilter`重定向的授权请求，并最终启动授权代码授予流。
+
+|   |`AuthorizationCodeOAuth2AuthorizedClientProvider`是用于授权代码授予的`OAuth2AuthorizedClientProvider`的实现，<br/>还通过`OAuth2AuthorizationRequestRedirectFilter`发起重定向的授权请求。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+如果OAuth2.0客户端是[公共客户](https://tools.ietf.org/html/rfc6749#section-2.1)，则按照以下方式配置OAuth2.0客户端注册：
+
+```
+spring:
+  security:
+    oauth2:
+      client:
+        registration:
+          okta:
+            client-id: okta-client-id
+            client-authentication-method: none
+            authorization-grant-type: authorization_code
+            redirect-uri: "{baseUrl}/authorized/okta"
+            ...
+```
+
+使用[代码交换的证明密钥](https://tools.ietf.org/html/rfc7636)支持公共客户端。如果客户机运行在不受信任的环境中（例如，本地应用程序或基于Web浏览器的应用程序），因此不能维护其凭据的机密性，则当以下条件成立时，将自动使用PKCE:
+
+1. `client-secret`省略（或为空）
+
+2. `client-authentication-method`设置为“无”（`ClientAuthenticationMethod.NONE`）
+
+`DefaultOAuth2AuthorizationRequestResolver`还支持`URI`使用`UriComponentsBuilder`的`redirect-uri`模板变量。
+
+以下配置使用了所有受支持的`URI`模板变量：
+
+```
+spring:
+  security:
+    oauth2:
+      client:
+        registration:
+          okta:
+            ...
+            redirect-uri: "{baseScheme}://{baseHost}{basePort}{basePath}/authorized/{registrationId}"
+            ...
+```
+
+|   |`{baseUrl}`解析为`{baseScheme}://{baseHost}{basePort}{basePath}`|
+|---|-----------------------------------------------------------------------|
+
+当OAuth2.0客户端运行在[代理服务器](../../../features/exploits/http.html#http-proxy-server)后面时，使用`URI`模板变量配置`redirect-uri`模板变量特别有用。这确保了在展开`redirect-uri`时使用`X-Forwarded-*`头。
+
+### 自定义授权请求
+
+`OAuth2AuthorizationRequestResolver`可以实现的主要用例之一是，能够使用OAuth2.0授权框架中定义的标准参数之上的附加参数来定制授权请求。
+
+例如，OpenID Connect为[授权代码流](https://openid.net/specs/openid-connect-core-1_0.html#AuthRequest)定义了额外的OAuth2.0请求参数，它是从[OAuth2.0授权框架](https://tools.ietf.org/html/rfc6749#section-4.1.1)中定义的标准参数扩展而来的。其中一个扩展参数是`prompt`参数。
+
+|   |可选的。以空格分隔、区分大小写的ASCII字符串值列表，该列表指定授权服务器是否提示最终用户进行重新身份验证和同意。定义的值是：none、login、consent、select\_account|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+下面的示例展示了如何使用`DefaultOAuth2AuthorizationRequestResolver`配置`Consumer<OAuth2AuthorizationRequest.Builder>`，该配置通过包括请求参数`oauth2Login()`来定制`oauth2Login()`的授权请求。
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Autowired
+	private ClientRegistrationRepository clientRegistrationRepository;
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.authorizeHttpRequests(authorize -> authorize
+				.anyRequest().authenticated()
+			)
+			.oauth2Login(oauth2 -> oauth2
+				.authorizationEndpoint(authorization -> authorization
+					.authorizationRequestResolver(
+						authorizationRequestResolver(this.clientRegistrationRepository)
+					)
+				)
+			);
+	}
+
+	private OAuth2AuthorizationRequestResolver authorizationRequestResolver(
+			ClientRegistrationRepository clientRegistrationRepository) {
+
+		DefaultOAuth2AuthorizationRequestResolver authorizationRequestResolver =
+				new DefaultOAuth2AuthorizationRequestResolver(
+						clientRegistrationRepository, "/oauth2/authorization");
+		authorizationRequestResolver.setAuthorizationRequestCustomizer(
+				authorizationRequestCustomizer());
+
+		return  authorizationRequestResolver;
+	}
+
+	private Consumer<OAuth2AuthorizationRequest.Builder> authorizationRequestCustomizer() {
+		return customizer -> customizer
+					.additionalParameters(params -> params.put("prompt", "consent"));
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class SecurityConfig : WebSecurityConfigurerAdapter() {
+
+    @Autowired
+    private lateinit var customClientRegistrationRepository: ClientRegistrationRepository
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            authorizeRequests {
+                authorize(anyRequest, authenticated)
+            }
+            oauth2Login {
+                authorizationEndpoint {
+                    authorizationRequestResolver = authorizationRequestResolver(customClientRegistrationRepository)
+                }
+            }
+        }
+    }
+
+    private fun authorizationRequestResolver(
+            clientRegistrationRepository: ClientRegistrationRepository?): OAuth2AuthorizationRequestResolver? {
+        val authorizationRequestResolver = DefaultOAuth2AuthorizationRequestResolver(
+                clientRegistrationRepository, "/oauth2/authorization")
+        authorizationRequestResolver.setAuthorizationRequestCustomizer(
+                authorizationRequestCustomizer())
+        return authorizationRequestResolver
+    }
+
+    private fun authorizationRequestCustomizer(): Consumer<OAuth2AuthorizationRequest.Builder> {
+        return Consumer { customizer ->
+            customizer
+                    .additionalParameters { params -> params["prompt"] = "consent" }
+        }
+    }
+}
+```
+
+对于简单的用例，如果附加的请求参数对于特定的提供者总是相同的，那么可以直接在`authorization-uri`属性中添加它。
+
+例如，如果请求参数`prompt`的值对于提供程序`okta`总是`consent`，那么只需配置如下：
+
+```
+spring:
+  security:
+    oauth2:
+      client:
+        provider:
+          okta:
+            authorization-uri: https://dev-1234.oktapreview.com/oauth2/v1/authorize?prompt=consent
+```
+
+前面的示例展示了在标准参数之上添加一个自定义参数的常见用例。或者，如果你的需求更高级，那么你可以通过简单地覆盖`OAuth2AuthorizationRequest.authorizationRequestUri`属性来完全控制构建授权请求URI。
+
+|   |`OAuth2AuthorizationRequest.Builder.build()`构造`OAuth2AuthorizationRequest.authorizationRequestUri`，它表示授权请求URI，包括使用`application/x-www-form-urlencoded`格式的所有查询参数。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+下面的示例显示了来自前面示例的`authorizationRequestCustomizer()`的变体，并覆盖了`OAuth2AuthorizationRequest.authorizationRequestUri`属性。
+
+Java
+
+```
+private Consumer<OAuth2AuthorizationRequest.Builder> authorizationRequestCustomizer() {
+	return customizer -> customizer
+				.authorizationRequestUri(uriBuilder -> uriBuilder
+					.queryParam("prompt", "consent").build());
+}
+```
+
+Kotlin
+
+```
+private fun authorizationRequestCustomizer(): Consumer<OAuth2AuthorizationRequest.Builder> {
+    return Consumer { customizer: OAuth2AuthorizationRequest.Builder ->
+        customizer
+                .authorizationRequestUri { uriBuilder: UriBuilder ->
+                    uriBuilder
+                            .queryParam("prompt", "consent").build()
+                }
+    }
+}
+```
+
+### 存储授权请求
+
+从发起授权请求到接收授权响应（回调），`AuthorizationRequestRepository`负责`OAuth2AuthorizationRequest`的持久性。
+
+|   |`OAuth2AuthorizationRequest`用于关联和验证授权响应。|
+|---|----------------------------------------------------------------------------------------------|
+
+`AuthorizationRequestRepository`的默认实现是`HttpSessionOAuth2AuthorizationRequestRepository`，它将`OAuth2AuthorizationRequest`存储在`HttpSession`中。
+
+如果你有`AuthorizationRequestRepository`的自定义实现，则可以按照以下示例对其进行配置：
+
+例1. AuthorizationRequestRepository配置
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2ClientSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.oauth2Client(oauth2 -> oauth2
+				.authorizationCodeGrant(codeGrant -> codeGrant
+					.authorizationRequestRepository(this.authorizationRequestRepository())
+					...
+				)
+			);
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class OAuth2ClientSecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            oauth2Client {
+                authorizationCodeGrant {
+                    authorizationRequestRepository = authorizationRequestRepository()
+                }
+            }
+        }
+    }
+}
+```
+
+XML
+
+```
+<http>
+	<oauth2-client>
+		<authorization-code-grant authorization-request-repository-ref="authorizationRequestRepository"/>
+	</oauth2-client>
+</http>
+```
+
+### 请求访问令牌
+
+|   |请参阅[访问令牌请求/响应](https://tools.ietf.org/html/rfc6749#section-4.1.3)协议流以获得授权代码授权。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+对于授权代码授予，`OAuth2AccessTokenResponseClient`的默认实现是`DefaultAuthorizationCodeTokenResponseClient`，它使用`RestOperations`在授权服务器的令牌端点将授权代码交换为访问令牌。
+
+`DefaultAuthorizationCodeTokenResponseClient`非常灵活，因为它允许你定制令牌请求的预处理和/或令牌响应的后处理。
+
+### 自定义访问令牌请求
+
+如果需要定制令牌请求的预处理，则可以提供带有自定义`DefaultAuthorizationCodeTokenResponseClient.setRequestEntityConverter()`的`Converter<OAuth2AuthorizationCodeGrantRequest, RequestEntity<?>>`。默认的实现`OAuth2AuthorizationCodeGrantRequestEntityConverter`构建了标准`RequestEntity`表示法[OAuth2.0访问令牌请求](https://tools.ietf.org/html/rfc6749#section-4.1.3)。但是，提供一个自定义`Converter`，将允许你扩展标准令牌请求并添加自定义参数。
+
+要仅自定义请求的参数，可以为`OAuth2AuthorizationCodeGrantRequestEntityConverter.setParametersConverter()`提供自定义的`Converter<OAuth2AuthorizationCodeGrantRequest, MultiValueMap<String, String>>`，以完全覆盖随请求发送的参数。这通常比直接构造`RequestEntity`更简单。
+
+|   |如果你只喜欢添加额外的参数，那么可以为`OAuth2AuthorizationCodeGrantRequestEntityConverter.addParametersConverter()`提供一个自定义的`Converter<OAuth2AuthorizationCodeGrantRequest, MultiValueMap<String, String>>`，它构造一个聚合`Converter`。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+|   |自定义`Converter`必须返回一个OAuth2.0访问令牌请求的有效`RequestEntity`表示，该请求被预期的OAuth2.0提供程序理解。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 自定义访问令牌响应
+
+在另一端，如果需要自定义令牌响应的后处理，则需要为`DefaultAuthorizationCodeTokenResponseClient.setRestOperations()`提供自定义配置的`RestOperations`。默认的`RestOperations`配置如下：
+
+Java
+
+```
+RestTemplate restTemplate = new RestTemplate(Arrays.asList(
+		new FormHttpMessageConverter(),
+		new OAuth2AccessTokenResponseHttpMessageConverter()));
+
+restTemplate.setErrorHandler(new OAuth2ErrorResponseErrorHandler());
+```
+
+Kotlin
+
+```
+val restTemplate = RestTemplate(listOf(
+        FormHttpMessageConverter(),
+        OAuth2AccessTokenResponseHttpMessageConverter()))
+
+restTemplate.errorHandler = OAuth2ErrorResponseErrorHandler()
+```
+
+|   |Spring 在发送OAuth2.0访问令牌请求时，需要使用MVC。|
+|---|---------------------------------------------------------------------------------------------------------------|
+
+`OAuth2AccessTokenResponseHttpMessageConverter`是用于OAuth2.0访问令牌响应的`HttpMessageConverter`。你可以为`OAuth2AccessTokenResponseHttpMessageConverter.setAccessTokenResponseConverter()`提供一个自定义的`Converter<Map<String, Object>, OAuth2AccessTokenResponse>`，用于将OAuth2.0访问令牌响应参数转换为`OAuth2AccessTokenResponse`。
+
+`OAuth2ErrorResponseErrorHandler`是一个`ResponseErrorHandler`，它可以处理OAuth2.0错误，例如400BAD请求。它使用`OAuth2ErrorHttpMessageConverter`将OAuth2.0错误参数转换为`OAuth2Error`。
+
+无论你是自定义`DefaultAuthorizationCodeTokenResponseClient`还是提供你自己的`OAuth2AccessTokenResponseClient`实现，你都需要对其进行配置，如以下示例所示：
+
+例2.访问令牌响应配置
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2ClientSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.oauth2Client(oauth2 -> oauth2
+				.authorizationCodeGrant(codeGrant -> codeGrant
+					.accessTokenResponseClient(this.accessTokenResponseClient())
+					...
+				)
+			);
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class OAuth2ClientSecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            oauth2Client {
+                authorizationCodeGrant {
+                    accessTokenResponseClient = accessTokenResponseClient()
+                }
+            }
+        }
+    }
+}
+```
+
+XML
+
+```
+<http>
+	<oauth2-client>
+		<authorization-code-grant access-token-response-client-ref="accessTokenResponseClient"/>
+	</oauth2-client>
+</http>
+```
+
+## 刷新令牌
+
+|   |有关[刷新令牌](https://tools.ietf.org/html/rfc6749#section-1.5)的更多详细信息，请参阅OAuth2.0授权框架。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 刷新访问令牌
+
+|   |请参阅[访问令牌请求/响应](https://tools.ietf.org/html/rfc6749#section-6)协议流以获取刷新令牌授权。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------|
+
+用于刷新令牌授权的`OAuth2AccessTokenResponseClient`的默认实现是`DefaultRefreshTokenTokenResponseClient`，当在授权服务器的令牌端点刷新访问令牌时，它使用`RestOperations`。
+
+`DefaultRefreshTokenTokenResponseClient`非常灵活，因为它允许你定制令牌请求的预处理和/或令牌响应的后处理。
+
+### 自定义访问令牌请求
+
+如果需要对令牌请求的预处理进行自定义，则可以提供带有自定义`DefaultRefreshTokenTokenResponseClient.setRequestEntityConverter()`的`Converter<OAuth2RefreshTokenGrantRequest, RequestEntity<?>>`。默认的实现`OAuth2RefreshTokenGrantRequestEntityConverter`构建了标准`RequestEntity`表示法[OAuth2.0访问令牌请求](https://tools.ietf.org/html/rfc6749#section-6)。但是，提供一个自定义`Converter`，将允许你扩展标准令牌请求并添加自定义参数。
+
+要仅自定义请求的参数，可以为`OAuth2RefreshTokenGrantRequestEntityConverter.setParametersConverter()`提供自定义的`Converter<OAuth2RefreshTokenGrantRequest, MultiValueMap<String, String>>`，以完全覆盖随请求发送的参数。这通常比直接构造`RequestEntity`更简单。
+
+|   |如果你只喜欢添加额外的参数，那么可以为`OAuth2RefreshTokenGrantRequestEntityConverter.addParametersConverter()`提供一个自定义的`Converter<OAuth2RefreshTokenGrantRequest, MultiValueMap<String, String>>`，它构造一个聚合`Converter`。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+|   |自定义`Converter`必须返回一个OAuth2.0访问令牌请求的有效`RequestEntity`表示，该请求被预期的OAuth2.0提供程序理解。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 自定义访问令牌响应
+
+在另一端，如果需要自定义令牌响应的后处理，则需要为`DefaultRefreshTokenTokenResponseClient.setRestOperations()`提供自定义配置的`RestOperations`。默认的`RestOperations`配置如下：
+
+Java
+
+```
+RestTemplate restTemplate = new RestTemplate(Arrays.asList(
+		new FormHttpMessageConverter(),
+		new OAuth2AccessTokenResponseHttpMessageConverter()));
+
+restTemplate.setErrorHandler(new OAuth2ErrorResponseErrorHandler());
+```
+
+Kotlin
+
+```
+val restTemplate = RestTemplate(listOf(
+        FormHttpMessageConverter(),
+        OAuth2AccessTokenResponseHttpMessageConverter()))
+
+restTemplate.errorHandler = OAuth2ErrorResponseErrorHandler()
+```
+
+|   |Spring 在发送OAuth2.0访问令牌请求时，需要使用MVC。|
+|---|---------------------------------------------------------------------------------------------------------------|
+
+`OAuth2AccessTokenResponseHttpMessageConverter`是用于OAuth2.0访问令牌响应的`HttpMessageConverter`。你可以为`OAuth2AccessTokenResponseHttpMessageConverter.setAccessTokenResponseConverter()`提供一个自定义`Converter<Map<String, Object>, OAuth2AccessTokenResponse>`，用于将OAuth2.0访问令牌响应参数转换为`OAuth2AccessTokenResponse`。
+
+`OAuth2ErrorResponseErrorHandler`是一个`ResponseErrorHandler`，它可以处理OAuth2.0错误，例如400BAD请求。它使用`OAuth2ErrorHttpMessageConverter`将OAuth2.0错误参数转换为`OAuth2Error`。
+
+无论你是自定义`DefaultRefreshTokenTokenResponseClient`还是提供你自己的`OAuth2AccessTokenResponseClient`实现，你都需要对其进行配置，如以下示例所示：
+
+Java
+
+```
+// Customize
+OAuth2AccessTokenResponseClient<OAuth2RefreshTokenGrantRequest> refreshTokenTokenResponseClient = ...
+
+OAuth2AuthorizedClientProvider authorizedClientProvider =
+		OAuth2AuthorizedClientProviderBuilder.builder()
+				.authorizationCode()
+				.refreshToken(configurer -> configurer.accessTokenResponseClient(refreshTokenTokenResponseClient))
+				.build();
+
+...
+
+authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);
+```
+
+Kotlin
+
+```
+// Customize
+val refreshTokenTokenResponseClient: OAuth2AccessTokenResponseClient<OAuth2RefreshTokenGrantRequest> = ...
+
+val authorizedClientProvider = OAuth2AuthorizedClientProviderBuilder.builder()
+        .authorizationCode()
+        .refreshToken { it.accessTokenResponseClient(refreshTokenTokenResponseClient) }
+        .build()
+
+...
+
+authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider)
+```
+
+|   |`OAuth2AuthorizedClientProviderBuilder.builder().refreshToken()`配置`RefreshTokenOAuth2AuthorizedClientProvider`，<br/>，这是用于刷新令牌授权的`OAuth2AuthorizedClientProvider`的实现。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+`OAuth2RefreshToken`可选地在用于`authorization_code`和`password`授予类型的访问令牌响应中返回。如果`OAuth2AuthorizedClient.getRefreshToken()`可用，而`OAuth2AuthorizedClient.getAccessToken()`过期，则`RefreshTokenOAuth2AuthorizedClientProvider`将自动刷新。
+
+## 客户凭据
+
+|   |有关[客户凭据](https://tools.ietf.org/html/rfc6749#section-1.3.4)授权的更多详细信息，请参阅OAuth2.0授权框架。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 请求访问令牌
+
+|   |请参阅[访问令牌请求/响应](https://tools.ietf.org/html/rfc6749#section-4.4.2)协议流以获取客户端凭据授权。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+对于客户端凭据授予，`OAuth2AccessTokenResponseClient`的默认实现是`DefaultClientCredentialsTokenResponseClient`，当在授权服务器的令牌端点请求访问令牌时，它使用`RestOperations`。
+
+`DefaultClientCredentialsTokenResponseClient`非常灵活，因为它允许你定制令牌请求的预处理和/或令牌响应的后处理。
+
+### 自定义访问令牌请求
+
+如果需要定制令牌请求的预处理，则可以提供带有自定义`DefaultClientCredentialsTokenResponseClient.setRequestEntityConverter()`的`Converter<OAuth2ClientCredentialsGrantRequest, RequestEntity<?>>`。默认的实现`OAuth2ClientCredentialsGrantRequestEntityConverter`构建了标准`RequestEntity`表示法[OAuth2.0访问令牌请求](https://tools.ietf.org/html/rfc6749#section-4.4.2)。但是，提供一个自定义`Converter`，将允许你扩展标准令牌请求并添加自定义参数。
+
+要仅自定义请求的参数，可以为`OAuth2ClientCredentialsGrantRequestEntityConverter.setParametersConverter()`提供自定义的`Converter<OAuth2ClientCredentialsGrantRequest, MultiValueMap<String, String>>`，以完全覆盖随请求发送的参数。这通常比直接构造`RequestEntity`更简单。
+
+|   |如果你只喜欢添加额外的参数，那么可以为`OAuth2ClientCredentialsGrantRequestEntityConverter.addParametersConverter()`提供一个自定义的`Converter<OAuth2ClientCredentialsGrantRequest, MultiValueMap<String, String>>`，它构造一个聚合`Converter`。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+|   |自定义`Converter`必须返回一个OAuth2.0访问令牌请求的有效`RequestEntity`表示，该请求被预期的OAuth2.0提供程序理解。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 自定义访问令牌响应
+
+在另一端，如果需要自定义令牌响应的后处理，则需要为`DefaultClientCredentialsTokenResponseClient.setRestOperations()`提供自定义配置的`RestOperations`。默认的`RestOperations`配置如下：
+
+Java
+
+```
+RestTemplate restTemplate = new RestTemplate(Arrays.asList(
+		new FormHttpMessageConverter(),
+		new OAuth2AccessTokenResponseHttpMessageConverter()));
+
+restTemplate.setErrorHandler(new OAuth2ErrorResponseErrorHandler());
+```
+
+Kotlin
+
+```
+val restTemplate = RestTemplate(listOf(
+        FormHttpMessageConverter(),
+        OAuth2AccessTokenResponseHttpMessageConverter()))
+
+restTemplate.errorHandler = OAuth2ErrorResponseErrorHandler()
+```
+
+|   |Spring 在发送OAuth2.0访问令牌请求时，需要使用MVC。|
+|---|---------------------------------------------------------------------------------------------------------------|
+
+`OAuth2AccessTokenResponseHttpMessageConverter`是用于OAuth2.0访问令牌响应的`HttpMessageConverter`。你可以为`OAuth2AccessTokenResponseHttpMessageConverter.setAccessTokenResponseConverter()`提供一个自定义的`Converter<Map<String, Object>, OAuth2AccessTokenResponse>`，用于将OAuth2.0访问令牌响应参数转换为`OAuth2AccessTokenResponse`。
+
+`OAuth2ErrorResponseErrorHandler`是一个`ResponseErrorHandler`，它可以处理OAuth2.0错误，例如400BAD请求。它使用`OAuth2ErrorHttpMessageConverter`将OAuth2.0错误参数转换为`OAuth2Error`。
+
+无论你是自定义`DefaultClientCredentialsTokenResponseClient`还是提供你自己的`OAuth2AccessTokenResponseClient`实现，你都需要对其进行配置，如以下示例所示：
+
+Java
+
+```
+// Customize
+OAuth2AccessTokenResponseClient<OAuth2ClientCredentialsGrantRequest> clientCredentialsTokenResponseClient = ...
+
+OAuth2AuthorizedClientProvider authorizedClientProvider =
+		OAuth2AuthorizedClientProviderBuilder.builder()
+				.clientCredentials(configurer -> configurer.accessTokenResponseClient(clientCredentialsTokenResponseClient))
+				.build();
+
+...
+
+authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);
+```
+
+Kotlin
+
+```
+// Customize
+val clientCredentialsTokenResponseClient: OAuth2AccessTokenResponseClient<OAuth2ClientCredentialsGrantRequest> = ...
+
+val authorizedClientProvider = OAuth2AuthorizedClientProviderBuilder.builder()
+        .clientCredentials { it.accessTokenResponseClient(clientCredentialsTokenResponseClient) }
+        .build()
+
+...
+
+authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider)
+```
+
+|   |`OAuth2AuthorizedClientProviderBuilder.builder().clientCredentials()`配置`ClientCredentialsOAuth2AuthorizedClientProvider`，<br/>，这是用于客户端凭据授权的`OAuth2AuthorizedClientProvider`的实现。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 使用访问令牌
+
+给出了用于OAuth2.0客户端注册的以下 Spring Boot2.x属性：
+
+```
+spring:
+  security:
+    oauth2:
+      client:
+        registration:
+          okta:
+            client-id: okta-client-id
+            client-secret: okta-client-secret
+            authorization-grant-type: client_credentials
+            scope: read, write
+        provider:
+          okta:
+            token-uri: https://dev-1234.oktapreview.com/oauth2/v1/token
+```
+
+…和`OAuth2AuthorizedClientManager``@Bean`:
+
+Java
+
+```
+@Bean
+public OAuth2AuthorizedClientManager authorizedClientManager(
+		ClientRegistrationRepository clientRegistrationRepository,
+		OAuth2AuthorizedClientRepository authorizedClientRepository) {
+
+	OAuth2AuthorizedClientProvider authorizedClientProvider =
+			OAuth2AuthorizedClientProviderBuilder.builder()
+					.clientCredentials()
+					.build();
+
+	DefaultOAuth2AuthorizedClientManager authorizedClientManager =
+			new DefaultOAuth2AuthorizedClientManager(
+					clientRegistrationRepository, authorizedClientRepository);
+	authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);
+
+	return authorizedClientManager;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun authorizedClientManager(
+        clientRegistrationRepository: ClientRegistrationRepository,
+        authorizedClientRepository: OAuth2AuthorizedClientRepository): OAuth2AuthorizedClientManager {
+    val authorizedClientProvider = OAuth2AuthorizedClientProviderBuilder.builder()
+            .clientCredentials()
+            .build()
+    val authorizedClientManager = DefaultOAuth2AuthorizedClientManager(
+            clientRegistrationRepository, authorizedClientRepository)
+    authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider)
+    return authorizedClientManager
+}
+```
+
+你可以按以下方式获得`OAuth2AccessToken`:
+
+Java
+
+```
+@Controller
+public class OAuth2ClientController {
+
+	@Autowired
+	private OAuth2AuthorizedClientManager authorizedClientManager;
+
+	@GetMapping("/")
+	public String index(Authentication authentication,
+						HttpServletRequest servletRequest,
+						HttpServletResponse servletResponse) {
+
+		OAuth2AuthorizeRequest authorizeRequest = OAuth2AuthorizeRequest.withClientRegistrationId("okta")
+				.principal(authentication)
+				.attributes(attrs -> {
+					attrs.put(HttpServletRequest.class.getName(), servletRequest);
+					attrs.put(HttpServletResponse.class.getName(), servletResponse);
+				})
+				.build();
+		OAuth2AuthorizedClient authorizedClient = this.authorizedClientManager.authorize(authorizeRequest);
+
+		OAuth2AccessToken accessToken = authorizedClient.getAccessToken();
+
+		...
+
+		return "index";
+	}
+}
+```
+
+Kotlin
+
+```
+class OAuth2ClientController {
+
+    @Autowired
+    private lateinit var authorizedClientManager: OAuth2AuthorizedClientManager
+
+    @GetMapping("/")
+    fun index(authentication: Authentication?,
+              servletRequest: HttpServletRequest,
+              servletResponse: HttpServletResponse): String {
+        val authorizeRequest: OAuth2AuthorizeRequest = OAuth2AuthorizeRequest.withClientRegistrationId("okta")
+                .principal(authentication)
+                .attributes(Consumer { attrs: MutableMap<String, Any> ->
+                    attrs[HttpServletRequest::class.java.name] = servletRequest
+                    attrs[HttpServletResponse::class.java.name] = servletResponse
+                })
+                .build()
+        val authorizedClient = authorizedClientManager.authorize(authorizeRequest)
+        val accessToken: OAuth2AccessToken = authorizedClient.accessToken
+
+        ...
+
+        return "index"
+    }
+}
+```
+
+|   |`HttpServletRequest`和`HttpServletResponse`都是可选属性。<br/>如果不提供，它将默认为`ServletRequestAttributes`使用`RequestContextHolder.getRequestAttributes()`。|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## 资源所有者密码凭据
+
+|   |有关[资源所有者密码凭据](https://tools.ietf.org/html/rfc6749#section-1.3.3)授权的更多详细信息，请参阅OAuth2.0授权框架。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 请求访问令牌
+
+|   |请参阅[访问令牌请求/响应](https://tools.ietf.org/html/rfc6749#section-4.3.2)协议流以获取资源所有者密码凭据授权。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+对于资源所有者密码凭据授予，`OAuth2AccessTokenResponseClient`的默认实现是`DefaultPasswordTokenResponseClient`，当在授权服务器的令牌端点请求访问令牌时，它使用`RestOperations`。
+
+`DefaultPasswordTokenResponseClient`非常灵活，因为它允许你定制令牌请求的预处理和/或令牌响应的后处理。
+
+### 自定义访问令牌请求
+
+如果需要定制令牌请求的预处理，则可以提供带有自定义`DefaultPasswordTokenResponseClient.setRequestEntityConverter()`的`Converter<OAuth2PasswordGrantRequest, RequestEntity<?>>`。默认的实现`OAuth2PasswordGrantRequestEntityConverter`构建了标准`RequestEntity`表示法[OAuth2.0访问令牌请求](https://tools.ietf.org/html/rfc6749#section-4.3.2)。但是，提供一个自定义`Converter`，将允许你扩展标准令牌请求并添加自定义参数。
+
+要仅自定义请求的参数，可以为`OAuth2PasswordGrantRequestEntityConverter.setParametersConverter()`提供自定义的`Converter<OAuth2PasswordGrantRequest, MultiValueMap<String, String>>`，以完全覆盖随请求发送的参数。这通常比直接构造`RequestEntity`更简单。
+
+|   |如果你只喜欢添加额外的参数，那么可以为`OAuth2PasswordGrantRequestEntityConverter.addParametersConverter()`提供一个自定义的`Converter<OAuth2PasswordGrantRequest, MultiValueMap<String, String>>`，它构造一个聚合`Converter`。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+|   |自定义`Converter`必须返回一个OAuth2.0访问令牌请求的有效`RequestEntity`表示，该请求被预期的OAuth2.0提供程序理解。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 自定义访问令牌响应
+
+在另一端，如果需要自定义令牌响应的后处理，则需要为`DefaultPasswordTokenResponseClient.setRestOperations()`提供自定义配置的`RestOperations`。默认的`RestOperations`配置如下：
+
+Java
+
+```
+RestTemplate restTemplate = new RestTemplate(Arrays.asList(
+		new FormHttpMessageConverter(),
+		new OAuth2AccessTokenResponseHttpMessageConverter()));
+
+restTemplate.setErrorHandler(new OAuth2ErrorResponseErrorHandler());
+```
+
+Kotlin
+
+```
+val restTemplate = RestTemplate(listOf(
+        FormHttpMessageConverter(),
+        OAuth2AccessTokenResponseHttpMessageConverter()))
+
+restTemplate.errorHandler = OAuth2ErrorResponseErrorHandler()
+```
+
+|   |Spring 在发送OAuth2.0访问令牌请求时，需要使用MVC。|
+|---|---------------------------------------------------------------------------------------------------------------|
+
+`OAuth2AccessTokenResponseHttpMessageConverter`是用于OAuth2.0访问令牌响应的`HttpMessageConverter`。你可以为`OAuth2AccessTokenResponseHttpMessageConverter.setAccessTokenResponseConverter()`提供一个自定义的`Converter<Map<String, Object>, OAuth2AccessTokenResponse>`，用于将OAuth2.0访问令牌响应参数转换为`OAuth2AccessTokenResponse`。
+
+`OAuth2ErrorResponseErrorHandler`是一个`ResponseErrorHandler`，它可以处理OAuth2.0错误，例如400BAD请求。它使用`OAuth2ErrorHttpMessageConverter`将OAuth2.0错误参数转换为`OAuth2Error`。
+
+无论你是自定义`DefaultPasswordTokenResponseClient`还是提供你自己的`OAuth2AccessTokenResponseClient`实现，你都需要对其进行配置，如以下示例所示：
+
+Java
+
+```
+// Customize
+OAuth2AccessTokenResponseClient<OAuth2PasswordGrantRequest> passwordTokenResponseClient = ...
+
+OAuth2AuthorizedClientProvider authorizedClientProvider =
+		OAuth2AuthorizedClientProviderBuilder.builder()
+				.password(configurer -> configurer.accessTokenResponseClient(passwordTokenResponseClient))
+				.refreshToken()
+				.build();
+
+...
+
+authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);
+```
+
+Kotlin
+
+```
+val passwordTokenResponseClient: OAuth2AccessTokenResponseClient<OAuth2PasswordGrantRequest> = ...
+
+val authorizedClientProvider = OAuth2AuthorizedClientProviderBuilder.builder()
+        .password { it.accessTokenResponseClient(passwordTokenResponseClient) }
+        .refreshToken()
+        .build()
+
+...
+
+authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider)
+```
+
+|   |`OAuth2AuthorizedClientProviderBuilder.builder().password()`配置`PasswordOAuth2AuthorizedClientProvider`，<br/>，这是用于资源所有者密码凭据授予的`OAuth2AuthorizedClientProvider`的实现。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 使用访问令牌
+
+给出了用于OAuth2.0客户端注册的以下 Spring Boot2.x属性：
+
+```
+spring:
+  security:
+    oauth2:
+      client:
+        registration:
+          okta:
+            client-id: okta-client-id
+            client-secret: okta-client-secret
+            authorization-grant-type: password
+            scope: read, write
+        provider:
+          okta:
+            token-uri: https://dev-1234.oktapreview.com/oauth2/v1/token
+```
+
+…和`OAuth2AuthorizedClientManager``@Bean`:
+
+Java
+
+```
+@Bean
+public OAuth2AuthorizedClientManager authorizedClientManager(
+		ClientRegistrationRepository clientRegistrationRepository,
+		OAuth2AuthorizedClientRepository authorizedClientRepository) {
+
+	OAuth2AuthorizedClientProvider authorizedClientProvider =
+			OAuth2AuthorizedClientProviderBuilder.builder()
+					.password()
+					.refreshToken()
+					.build();
+
+	DefaultOAuth2AuthorizedClientManager authorizedClientManager =
+			new DefaultOAuth2AuthorizedClientManager(
+					clientRegistrationRepository, authorizedClientRepository);
+	authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);
+
+	// Assuming the `username` and `password` are supplied as `HttpServletRequest` parameters,
+	// map the `HttpServletRequest` parameters to `OAuth2AuthorizationContext.getAttributes()`
+	authorizedClientManager.setContextAttributesMapper(contextAttributesMapper());
+
+	return authorizedClientManager;
+}
+
+private Function<OAuth2AuthorizeRequest, Map<String, Object>> contextAttributesMapper() {
+	return authorizeRequest -> {
+		Map<String, Object> contextAttributes = Collections.emptyMap();
+		HttpServletRequest servletRequest = authorizeRequest.getAttribute(HttpServletRequest.class.getName());
+		String username = servletRequest.getParameter(OAuth2ParameterNames.USERNAME);
+		String password = servletRequest.getParameter(OAuth2ParameterNames.PASSWORD);
+		if (StringUtils.hasText(username) && StringUtils.hasText(password)) {
+			contextAttributes = new HashMap<>();
+
+			// `PasswordOAuth2AuthorizedClientProvider` requires both attributes
+			contextAttributes.put(OAuth2AuthorizationContext.USERNAME_ATTRIBUTE_NAME, username);
+			contextAttributes.put(OAuth2AuthorizationContext.PASSWORD_ATTRIBUTE_NAME, password);
+		}
+		return contextAttributes;
+	};
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun authorizedClientManager(
+        clientRegistrationRepository: ClientRegistrationRepository,
+        authorizedClientRepository: OAuth2AuthorizedClientRepository): OAuth2AuthorizedClientManager {
+    val authorizedClientProvider = OAuth2AuthorizedClientProviderBuilder.builder()
+            .password()
+            .refreshToken()
+            .build()
+    val authorizedClientManager = DefaultOAuth2AuthorizedClientManager(
+            clientRegistrationRepository, authorizedClientRepository)
+    authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider)
+
+    // Assuming the `username` and `password` are supplied as `HttpServletRequest` parameters,
+    // map the `HttpServletRequest` parameters to `OAuth2AuthorizationContext.getAttributes()`
+    authorizedClientManager.setContextAttributesMapper(contextAttributesMapper())
+    return authorizedClientManager
+}
+
+private fun contextAttributesMapper(): Function<OAuth2AuthorizeRequest, MutableMap<String, Any>> {
+    return Function { authorizeRequest ->
+        var contextAttributes: MutableMap<String, Any> = mutableMapOf()
+        val servletRequest: HttpServletRequest = authorizeRequest.getAttribute(HttpServletRequest::class.java.name)
+        val username = servletRequest.getParameter(OAuth2ParameterNames.USERNAME)
+        val password = servletRequest.getParameter(OAuth2ParameterNames.PASSWORD)
+        if (StringUtils.hasText(username) && StringUtils.hasText(password)) {
+            contextAttributes = hashMapOf()
+
+            // `PasswordOAuth2AuthorizedClientProvider` requires both attributes
+            contextAttributes[OAuth2AuthorizationContext.USERNAME_ATTRIBUTE_NAME] = username
+            contextAttributes[OAuth2AuthorizationContext.PASSWORD_ATTRIBUTE_NAME] = password
+        }
+        contextAttributes
+    }
+}
+```
+
+你可以按以下方式获得`OAuth2AccessToken`:
+
+Java
+
+```
+@Controller
+public class OAuth2ClientController {
+
+	@Autowired
+	private OAuth2AuthorizedClientManager authorizedClientManager;
+
+	@GetMapping("/")
+	public String index(Authentication authentication,
+						HttpServletRequest servletRequest,
+						HttpServletResponse servletResponse) {
+
+		OAuth2AuthorizeRequest authorizeRequest = OAuth2AuthorizeRequest.withClientRegistrationId("okta")
+				.principal(authentication)
+				.attributes(attrs -> {
+					attrs.put(HttpServletRequest.class.getName(), servletRequest);
+					attrs.put(HttpServletResponse.class.getName(), servletResponse);
+				})
+				.build();
+		OAuth2AuthorizedClient authorizedClient = this.authorizedClientManager.authorize(authorizeRequest);
+
+		OAuth2AccessToken accessToken = authorizedClient.getAccessToken();
+
+		...
+
+		return "index";
+	}
+}
+```
+
+Kotlin
+
+```
+@Controller
+class OAuth2ClientController {
+    @Autowired
+    private lateinit var authorizedClientManager: OAuth2AuthorizedClientManager
+
+    @GetMapping("/")
+    fun index(authentication: Authentication?,
+              servletRequest: HttpServletRequest,
+              servletResponse: HttpServletResponse): String {
+        val authorizeRequest: OAuth2AuthorizeRequest = OAuth2AuthorizeRequest.withClientRegistrationId("okta")
+                .principal(authentication)
+                .attributes(Consumer {
+                    it[HttpServletRequest::class.java.name] = servletRequest
+                    it[HttpServletResponse::class.java.name] = servletResponse
+                })
+                .build()
+        val authorizedClient = authorizedClientManager.authorize(authorizeRequest)
+        val accessToken: OAuth2AccessToken = authorizedClient.accessToken
+
+        ...
+
+        return "index"
+    }
+}
+```
+
+|   |`HttpServletRequest`和`HttpServletResponse`都是可选属性。<br/>如果不提供，它将默认为`ServletRequestAttributes`使用`RequestContextHolder.getRequestAttributes()`。|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## JWT持有人
+
+|   |有关[JWT Bearer](https://datatracker.ietf.org/doc/html/rfc7523)授权的更多详细信息，请参考JSON Web Token配置文件获得OAuth2.0客户端身份验证和授权授权。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 请求访问令牌
+
+|   |请参阅[访问令牌请求/响应](https://datatracker.ietf.org/doc/html/rfc7523#section-2.1)协议流获得JWT承载授权。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+对于JWT承载授权，`OAuth2AccessTokenResponseClient`的默认实现是`DefaultJwtBearerTokenResponseClient`，当在授权服务器的令牌端点请求访问令牌时，它使用`RestOperations`。
+
+`DefaultJwtBearerTokenResponseClient`非常灵活，因为它允许你定制令牌请求的预处理和/或令牌响应的后处理。
+
+### 自定义访问令牌请求
+
+如果需要对令牌请求的预处理进行自定义，则可以提供带有自定义`DefaultJwtBearerTokenResponseClient.setRequestEntityConverter()`的`Converter<JwtBearerGrantRequest, RequestEntity<?>>`。默认的实现`JwtBearerGrantRequestEntityConverter`构建了`RequestEntity`表示[OAuth2.0访问令牌请求](https://datatracker.ietf.org/doc/html/rfc7523#section-2.1)。但是，提供一个自定义`Converter`，将允许你扩展令牌请求并添加自定义参数。
+
+要仅自定义请求的参数，可以为`JwtBearerGrantRequestEntityConverter.setParametersConverter()`提供自定义的`Converter<JwtBearerGrantRequest, MultiValueMap<String, String>>`，以完全覆盖随请求发送的参数。这通常比直接构造`RequestEntity`更简单。
+
+|   |如果你只喜欢添加额外的参数，那么可以为`JwtBearerGrantRequestEntityConverter.addParametersConverter()`提供一个自定义的`Converter<JwtBearerGrantRequest, MultiValueMap<String, String>>`，它构造一个聚合`Converter`。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 自定义访问令牌响应
+
+在另一端，如果需要自定义令牌响应的后处理，则需要为`DefaultJwtBearerTokenResponseClient.setRestOperations()`提供自定义配置的`RestOperations`。默认的`RestOperations`配置如下：
+
+Java
+
+```
+RestTemplate restTemplate = new RestTemplate(Arrays.asList(
+		new FormHttpMessageConverter(),
+		new OAuth2AccessTokenResponseHttpMessageConverter()));
+
+restTemplate.setErrorHandler(new OAuth2ErrorResponseErrorHandler());
+```
+
+Kotlin
+
+```
+val restTemplate = RestTemplate(listOf(
+        FormHttpMessageConverter(),
+        OAuth2AccessTokenResponseHttpMessageConverter()))
+
+restTemplate.errorHandler = OAuth2ErrorResponseErrorHandler()
+```
+
+|   |Spring 在发送OAuth2.0访问令牌请求时，需要使用MVC。|
+|---|---------------------------------------------------------------------------------------------------------------|
+
+`OAuth2AccessTokenResponseHttpMessageConverter`是用于OAuth2.0访问令牌响应的`HttpMessageConverter`。你可以为`OAuth2AccessTokenResponseHttpMessageConverter.setAccessTokenResponseConverter()`提供一个自定义的`Converter<Map<String, Object>, OAuth2AccessTokenResponse>`，用于将OAuth2.0访问令牌响应参数转换为`OAuth2AccessTokenResponse`。
+
+`OAuth2ErrorResponseErrorHandler`是一个`ResponseErrorHandler`，它可以处理OAuth2.0错误，例如400BAD请求。它使用`OAuth2ErrorHttpMessageConverter`将OAuth2.0错误参数转换为`OAuth2Error`。
+
+无论你是自定义`DefaultJwtBearerTokenResponseClient`还是提供你自己的`OAuth2AccessTokenResponseClient`实现，你都需要对其进行配置，如以下示例所示：
+
+Java
+
+```
+// Customize
+OAuth2AccessTokenResponseClient<JwtBearerGrantRequest> jwtBearerTokenResponseClient = ...
+
+JwtBearerOAuth2AuthorizedClientProvider jwtBearerAuthorizedClientProvider = new JwtBearerOAuth2AuthorizedClientProvider();
+jwtBearerAuthorizedClientProvider.setAccessTokenResponseClient(jwtBearerTokenResponseClient);
+
+OAuth2AuthorizedClientProvider authorizedClientProvider =
+		OAuth2AuthorizedClientProviderBuilder.builder()
+				.provider(jwtBearerAuthorizedClientProvider)
+				.build();
+
+...
+
+authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);
+```
+
+Kotlin
+
+```
+// Customize
+val jwtBearerTokenResponseClient: OAuth2AccessTokenResponseClient<JwtBearerGrantRequest> = ...
+
+val jwtBearerAuthorizedClientProvider = JwtBearerOAuth2AuthorizedClientProvider()
+jwtBearerAuthorizedClientProvider.setAccessTokenResponseClient(jwtBearerTokenResponseClient);
+
+val authorizedClientProvider = OAuth2AuthorizedClientProviderBuilder.builder()
+        .provider(jwtBearerAuthorizedClientProvider)
+        .build()
+
+...
+
+authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider)
+```
+
+### 使用访问令牌
+
+给出了用于OAuth2.0客户端注册的以下 Spring Boot2.x属性：
+
+```
+spring:
+  security:
+    oauth2:
+      client:
+        registration:
+          okta:
+            client-id: okta-client-id
+            client-secret: okta-client-secret
+            authorization-grant-type: urn:ietf:params:oauth:grant-type:jwt-bearer
+            scope: read
+        provider:
+          okta:
+            token-uri: https://dev-1234.oktapreview.com/oauth2/v1/token
+```
+
+…和`OAuth2AuthorizedClientManager``@Bean`:
+
+Java
+
+```
+@Bean
+public OAuth2AuthorizedClientManager authorizedClientManager(
+		ClientRegistrationRepository clientRegistrationRepository,
+		OAuth2AuthorizedClientRepository authorizedClientRepository) {
+
+	JwtBearerOAuth2AuthorizedClientProvider jwtBearerAuthorizedClientProvider =
+			new JwtBearerOAuth2AuthorizedClientProvider();
+
+	OAuth2AuthorizedClientProvider authorizedClientProvider =
+			OAuth2AuthorizedClientProviderBuilder.builder()
+					.provider(jwtBearerAuthorizedClientProvider)
+					.build();
+
+	DefaultOAuth2AuthorizedClientManager authorizedClientManager =
+			new DefaultOAuth2AuthorizedClientManager(
+					clientRegistrationRepository, authorizedClientRepository);
+	authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);
+
+	return authorizedClientManager;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun authorizedClientManager(
+        clientRegistrationRepository: ClientRegistrationRepository,
+        authorizedClientRepository: OAuth2AuthorizedClientRepository): OAuth2AuthorizedClientManager {
+    val jwtBearerAuthorizedClientProvider = JwtBearerOAuth2AuthorizedClientProvider()
+    val authorizedClientProvider = OAuth2AuthorizedClientProviderBuilder.builder()
+            .provider(jwtBearerAuthorizedClientProvider)
+            .build()
+    val authorizedClientManager = DefaultOAuth2AuthorizedClientManager(
+            clientRegistrationRepository, authorizedClientRepository)
+    authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider)
+    return authorizedClientManager
+}
+```
+
+你可以按以下方式获得`OAuth2AccessToken`:
+
+Java
+
+```
+@RestController
+public class OAuth2ResourceServerController {
+
+	@Autowired
+	private OAuth2AuthorizedClientManager authorizedClientManager;
+
+	@GetMapping("/resource")
+	public String resource(JwtAuthenticationToken jwtAuthentication) {
+		OAuth2AuthorizeRequest authorizeRequest = OAuth2AuthorizeRequest.withClientRegistrationId("okta")
+				.principal(jwtAuthentication)
+				.build();
+		OAuth2AuthorizedClient authorizedClient = this.authorizedClientManager.authorize(authorizeRequest);
+		OAuth2AccessToken accessToken = authorizedClient.getAccessToken();
+
+		...
+
+	}
+}
+```
+
+Kotlin
+
+```
+class OAuth2ResourceServerController {
+
+    @Autowired
+    private lateinit var authorizedClientManager: OAuth2AuthorizedClientManager
+
+    @GetMapping("/resource")
+    fun resource(jwtAuthentication: JwtAuthenticationToken?): String {
+        val authorizeRequest: OAuth2AuthorizeRequest = OAuth2AuthorizeRequest.withClientRegistrationId("okta")
+                .principal(jwtAuthentication)
+                .build()
+        val authorizedClient = authorizedClientManager.authorize(authorizeRequest)
+        val accessToken: OAuth2AccessToken = authorizedClient.accessToken
+
+        ...
+
+    }
+}
+```
+
+[核心接口和类](core.html)[OAuth2客户端身份验证](client-authentication.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-oauth2-client-authorized-clients.md b/docs/spring-security/servlet-oauth2-client-authorized-clients.md
new file mode 100644
index 0000000..878a5c1
--- /dev/null
+++ b/docs/spring-security/servlet-oauth2-client-authorized-clients.md
@@ -0,0 +1,254 @@
+# 授权客户功能
+
+## 解决授权客户
+
+`@RegisteredOAuth2AuthorizedClient`注释提供了将方法参数解析为`OAuth2AuthorizedClient`类型的参数值的功能。与使用`OAuth2AuthorizedClientManager`或`OAuth2AuthorizedClientService`访问`OAuth2AuthorizedClient`相比，这是一种方便的替代方法。
+
+Java
+
+```
+@Controller
+public class OAuth2ClientController {
+
+	@GetMapping("/")
+	public String index(@RegisteredOAuth2AuthorizedClient("okta") OAuth2AuthorizedClient authorizedClient) {
+		OAuth2AccessToken accessToken = authorizedClient.getAccessToken();
+
+		...
+
+		return "index";
+	}
+}
+```
+
+Kotlin
+
+```
+@Controller
+class OAuth2ClientController {
+    @GetMapping("/")
+    fun index(@RegisteredOAuth2AuthorizedClient("okta") authorizedClient: OAuth2AuthorizedClient): String {
+        val accessToken = authorizedClient.accessToken
+
+        ...
+
+        return "index"
+    }
+}
+```
+
+`@RegisteredOAuth2AuthorizedClient`注释由`OAuth2AuthorizedClientArgumentResolver`处理，它直接使用[`OAuth2AuthorizedClientManager`]（core.html#oAuth2client-authorized-manager-provider），因此继承了它的功能。
+
+## 用于 Servlet 环境的WebClient集成
+
+OAuth2.0客户端支持使用`ExchangeFilterFunction`与`WebClient`集成。
+
+`ServletOAuth2AuthorizedClientExchangeFilterFunction`提供了一种简单的机制，通过使用`OAuth2AuthorizedClient`请求受保护的资源，并将相关的`OAuth2AccessToken`作为承载令牌。它直接使用[`OAuth2AuthorizedClientManager`]（core.html#OAuth2client-authorized-manager-provider），因此继承了以下功能：
+
+* 如果客户端尚未获得授权，则将请求`OAuth2AccessToken`。
+
+  * `authorization_code`-触发授权请求重定向以初始化流
+
+  * `client_credentials`-访问令牌是直接从令牌端点获得的
+
+  * `password`-访问令牌是直接从令牌端点获得的
+
+* 如果`OAuth2AccessToken`过期，如果`OAuth2AuthorizedClientProvider`可用于执行授权，则将刷新（或更新）该权限
+
+下面的代码展示了如何使用OAuth2.0客户端支持配置`WebClient`的示例：
+
+Java
+
+```
+@Bean
+WebClient webClient(OAuth2AuthorizedClientManager authorizedClientManager) {
+	ServletOAuth2AuthorizedClientExchangeFilterFunction oauth2Client =
+			new ServletOAuth2AuthorizedClientExchangeFilterFunction(authorizedClientManager);
+	return WebClient.builder()
+			.apply(oauth2Client.oauth2Configuration())
+			.build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun webClient(authorizedClientManager: OAuth2AuthorizedClientManager?): WebClient {
+    val oauth2Client = ServletOAuth2AuthorizedClientExchangeFilterFunction(authorizedClientManager)
+    return WebClient.builder()
+            .apply(oauth2Client.oauth2Configuration())
+            .build()
+}
+```
+
+### 提供授权客户
+
+通过解析`ClientRequest.attributes()`（请求属性）中的`OAuth2AuthorizedClient`，`ServletOAuth2AuthorizedClientExchangeFilterFunction`确定要使用的客户机（用于请求）。
+
+下面的代码展示了如何将`OAuth2AuthorizedClient`设置为请求属性：
+
+Java
+
+```
+@GetMapping("/")
+public String index(@RegisteredOAuth2AuthorizedClient("okta") OAuth2AuthorizedClient authorizedClient) {
+	String resourceUri = ...
+
+	String body = webClient
+			.get()
+			.uri(resourceUri)
+			.attributes(oauth2AuthorizedClient(authorizedClient))   (1)
+			.retrieve()
+			.bodyToMono(String.class)
+			.block();
+
+	...
+
+	return "index";
+}
+```
+
+Kotlin
+
+```
+@GetMapping("/")
+fun index(@RegisteredOAuth2AuthorizedClient("okta") authorizedClient: OAuth2AuthorizedClient): String {
+    val resourceUri: String = ...
+    val body: String = webClient
+            .get()
+            .uri(resourceUri)
+            .attributes(oauth2AuthorizedClient(authorizedClient)) (1)
+            .retrieve()
+            .bodyToMono()
+            .block()
+
+    ...
+
+    return "index"
+}
+```
+
+|**1**|`oauth2AuthorizedClient()`是`static`中的一个`static`方法。|
+|-----|---------------------------------------------------------------------------------------------------------|
+
+下面的代码展示了如何将`ClientRegistration.getRegistrationId()`设置为请求属性：
+
+Java
+
+```
+@GetMapping("/")
+public String index() {
+	String resourceUri = ...
+
+	String body = webClient
+			.get()
+			.uri(resourceUri)
+			.attributes(clientRegistrationId("okta"))   (1)
+			.retrieve()
+			.bodyToMono(String.class)
+			.block();
+
+	...
+
+	return "index";
+}
+```
+
+Kotlin
+
+```
+@GetMapping("/")
+fun index(): String {
+    val resourceUri: String = ...
+
+    val body: String = webClient
+            .get()
+            .uri(resourceUri)
+            .attributes(clientRegistrationId("okta"))  (1)
+            .retrieve()
+            .bodyToMono()
+            .block()
+
+    ...
+
+    return "index"
+}
+```
+
+|**1**|`clientRegistrationId()`是`static`中的一个`static`方法。|
+|-----|-------------------------------------------------------------------------------------------------------|
+
+### 对授权客户违约
+
+如果`OAuth2AuthorizedClient`或`ClientRegistration.getRegistrationId()`都不作为请求属性提供，则`ServletOAuth2AuthorizedClientExchangeFilterFunction`可以根据其配置来确定要使用的*默认值*客户端。
+
+如果`setDefaultOAuth2AuthorizedClient(true)`被配置并且用户已经使用`HttpSecurity.oauth2Login()`进行了身份验证，则使用与当前`OAuth2AccessToken`关联的`OAuth2AccessToken`。
+
+以下代码显示了具体的配置：
+
+Java
+
+```
+@Bean
+WebClient webClient(OAuth2AuthorizedClientManager authorizedClientManager) {
+	ServletOAuth2AuthorizedClientExchangeFilterFunction oauth2Client =
+			new ServletOAuth2AuthorizedClientExchangeFilterFunction(authorizedClientManager);
+	oauth2Client.setDefaultOAuth2AuthorizedClient(true);
+	return WebClient.builder()
+			.apply(oauth2Client.oauth2Configuration())
+			.build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun webClient(authorizedClientManager: OAuth2AuthorizedClientManager?): WebClient {
+    val oauth2Client = ServletOAuth2AuthorizedClientExchangeFilterFunction(authorizedClientManager)
+    oauth2Client.setDefaultOAuth2AuthorizedClient(true)
+    return WebClient.builder()
+            .apply(oauth2Client.oauth2Configuration())
+            .build()
+}
+```
+
+|   |由于所有HTTP请求都将接收访问令牌，因此建议对此功能保持谨慎。|
+|---|---------------------------------------------------------------------------------------------------------|
+
+或者，如果`setDefaultClientRegistrationId("okta")`被配置为有效的`ClientRegistration`，则使用与`OAuth2AuthorizedClient`关联的`OAuth2AccessToken`。
+
+以下代码显示了具体的配置：
+
+Java
+
+```
+@Bean
+WebClient webClient(OAuth2AuthorizedClientManager authorizedClientManager) {
+	ServletOAuth2AuthorizedClientExchangeFilterFunction oauth2Client =
+			new ServletOAuth2AuthorizedClientExchangeFilterFunction(authorizedClientManager);
+	oauth2Client.setDefaultClientRegistrationId("okta");
+	return WebClient.builder()
+			.apply(oauth2Client.oauth2Configuration())
+			.build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun webClient(authorizedClientManager: OAuth2AuthorizedClientManager?): WebClient {
+    val oauth2Client = ServletOAuth2AuthorizedClientExchangeFilterFunction(authorizedClientManager)
+    oauth2Client.setDefaultClientRegistrationId("okta")
+    return WebClient.builder()
+            .apply(oauth2Client.oauth2Configuration())
+            .build()
+}
+```
+
+|   |由于所有HTTP请求都将接收访问令牌，因此建议对此功能保持谨慎。|
+|---|---------------------------------------------------------------------------------------------------------|
+
+[OAuth2客户端身份验证](client-authentication.html)[OAuth2资源服务器](../resource-server/index.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-oauth2-client-client-authentication.md b/docs/spring-security/servlet-oauth2-client-client-authentication.md
new file mode 100644
index 0000000..b5e11eb
--- /dev/null
+++ b/docs/spring-security/servlet-oauth2-client-client-authentication.md
@@ -0,0 +1,154 @@
+# 客户端身份验证支持
+
+## JWT持有人
+
+|   |有关[JWT Bearer](https://datatracker.ietf.org/doc/html/rfc7523#section-2.2)客户端身份验证的更多详细信息，请参考JSON Web Token配置文件中的OAuth2.0客户端身份验证和授权授予。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+JWT承载客户端身份验证的默认实现是`NimbusJwtClientAuthenticationParametersConverter`，这是一个`Converter`，它通过在`client_assertion`参数中添加签名的JSON Web令牌来定制令牌请求参数。
+
+用于对JWS进行签名的`java.security.PrivateKey`或`javax.crypto.SecretKey`由与`NimbusJwtClientAuthenticationParametersConverter`关联的`com.nimbusds.jose.jwk.JWK`解析器提供。
+
+### 
+使用`private_key_jwt`进行身份验证
+
+给出了OAuth2.0客户端注册的以下 Spring Boot2.x属性：
+
+```
+spring:
+  security:
+    oauth2:
+      client:
+        registration:
+          okta:
+            client-id: okta-client-id
+            client-authentication-method: private_key_jwt
+            authorization-grant-type: authorization_code
+            ...
+```
+
+下面的示例展示了如何配置`DefaultAuthorizationCodeTokenResponseClient`:
+
+Java
+
+```
+Function<ClientRegistration, JWK> jwkResolver = (clientRegistration) -> {
+	if (clientRegistration.getClientAuthenticationMethod().equals(ClientAuthenticationMethod.PRIVATE_KEY_JWT)) {
+		// Assuming RSA key type
+		RSAPublicKey publicKey = ...
+		RSAPrivateKey privateKey = ...
+		return new RSAKey.Builder(publicKey)
+				.privateKey(privateKey)
+				.keyID(UUID.randomUUID().toString())
+				.build();
+	}
+	return null;
+};
+
+OAuth2AuthorizationCodeGrantRequestEntityConverter requestEntityConverter =
+		new OAuth2AuthorizationCodeGrantRequestEntityConverter();
+requestEntityConverter.addParametersConverter(
+		new NimbusJwtClientAuthenticationParametersConverter<>(jwkResolver));
+
+DefaultAuthorizationCodeTokenResponseClient tokenResponseClient =
+		new DefaultAuthorizationCodeTokenResponseClient();
+tokenResponseClient.setRequestEntityConverter(requestEntityConverter);
+```
+
+Kotlin
+
+```
+val jwkResolver: Function<ClientRegistration, JWK> =
+    Function<ClientRegistration, JWK> { clientRegistration ->
+        if (clientRegistration.clientAuthenticationMethod.equals(ClientAuthenticationMethod.PRIVATE_KEY_JWT)) {
+            // Assuming RSA key type
+            var publicKey: RSAPublicKey
+            var privateKey: RSAPrivateKey
+            RSAKey.Builder(publicKey) = //...
+                .privateKey(privateKey) = //...
+                .keyID(UUID.randomUUID().toString())
+                .build()
+        }
+        null
+    }
+
+val requestEntityConverter = OAuth2AuthorizationCodeGrantRequestEntityConverter()
+requestEntityConverter.addParametersConverter(
+    NimbusJwtClientAuthenticationParametersConverter(jwkResolver)
+)
+
+val tokenResponseClient = DefaultAuthorizationCodeTokenResponseClient()
+tokenResponseClient.setRequestEntityConverter(requestEntityConverter)
+```
+
+### 使用`client_secret_jwt`进行身份验证
+
+给出了OAuth2.0客户端注册的以下 Spring Boot2.x属性：
+
+```
+spring:
+  security:
+    oauth2:
+      client:
+        registration:
+          okta:
+            client-id: okta-client-id
+            client-secret: okta-client-secret
+            client-authentication-method: client_secret_jwt
+            authorization-grant-type: client_credentials
+            ...
+```
+
+下面的示例展示了如何配置`DefaultClientCredentialsTokenResponseClient`:
+
+Java
+
+```
+Function<ClientRegistration, JWK> jwkResolver = (clientRegistration) -> {
+	if (clientRegistration.getClientAuthenticationMethod().equals(ClientAuthenticationMethod.CLIENT_SECRET_JWT)) {
+		SecretKeySpec secretKey = new SecretKeySpec(
+				clientRegistration.getClientSecret().getBytes(StandardCharsets.UTF_8),
+				"HmacSHA256");
+		return new OctetSequenceKey.Builder(secretKey)
+				.keyID(UUID.randomUUID().toString())
+				.build();
+	}
+	return null;
+};
+
+OAuth2ClientCredentialsGrantRequestEntityConverter requestEntityConverter =
+		new OAuth2ClientCredentialsGrantRequestEntityConverter();
+requestEntityConverter.addParametersConverter(
+		new NimbusJwtClientAuthenticationParametersConverter<>(jwkResolver));
+
+DefaultClientCredentialsTokenResponseClient tokenResponseClient =
+		new DefaultClientCredentialsTokenResponseClient();
+tokenResponseClient.setRequestEntityConverter(requestEntityConverter);
+```
+
+Kotlin
+
+```
+val jwkResolver = Function<ClientRegistration, JWK?> { clientRegistration: ClientRegistration ->
+    if (clientRegistration.clientAuthenticationMethod == ClientAuthenticationMethod.CLIENT_SECRET_JWT) {
+        val secretKey = SecretKeySpec(
+            clientRegistration.clientSecret.toByteArray(StandardCharsets.UTF_8),
+            "HmacSHA256"
+        )
+        OctetSequenceKey.Builder(secretKey)
+            .keyID(UUID.randomUUID().toString())
+            .build()
+    }
+    null
+}
+
+val requestEntityConverter = OAuth2ClientCredentialsGrantRequestEntityConverter()
+requestEntityConverter.addParametersConverter(
+    NimbusJwtClientAuthenticationParametersConverter(jwkResolver)
+)
+
+val tokenResponseClient = DefaultClientCredentialsTokenResponseClient()
+tokenResponseClient.setRequestEntityConverter(requestEntityConverter)
+```
+
+[OAuth2授权授予](authorization-grants.html)[OAuth2授权客户](authorized-clients.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-oauth2-client-core.md b/docs/spring-security/servlet-oauth2-client-core.md
new file mode 100644
index 0000000..54b8d1c
--- /dev/null
+++ b/docs/spring-security/servlet-oauth2-client-core.md
@@ -0,0 +1,406 @@
+# 核心接口/类
+
+## 客户登记
+
+`ClientRegistration`是在OAuth2.0或OpenID Connect1.0提供程序中注册的客户端的表示。
+
+客户机注册包含信息，例如客户机ID、客户机秘密、授权授予类型、重定向URI、作用域、授权URI、令牌URI和其他详细信息。
+
+`ClientRegistration`及其属性定义如下：
+
+```
+public final class ClientRegistration {
+	private String registrationId;	(1)
+	private String clientId;	(2)
+	private String clientSecret;	(3)
+	private ClientAuthenticationMethod clientAuthenticationMethod;	(4)
+	private AuthorizationGrantType authorizationGrantType;	(5)
+	private String redirectUri;	(6)
+	private Set<String> scopes;	(7)
+	private ProviderDetails providerDetails;
+	private String clientName;	(8)
+
+	public class ProviderDetails {
+		private String authorizationUri;	(9)
+		private String tokenUri;	(10)
+		private UserInfoEndpoint userInfoEndpoint;
+		private String jwkSetUri;	(11)
+		private String issuerUri;	(12)
+        private Map<String, Object> configurationMetadata;  (13)
+
+		public class UserInfoEndpoint {
+			private String uri;	(14)
+            private AuthenticationMethod authenticationMethod;  (15)
+			private String userNameAttributeName;	(16)
+
+		}
+	}
+}
+```
+
+|**1** |`registrationId`:唯一标识`ClientRegistration`的ID。|
+|------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|**2** |`clientId`:客户端标识符。|
+|**3** |`clientSecret`:客户端秘密。|
+|**4** |`clientAuthenticationMethod`:用于与提供程序验证客户端的方法。<br/>支持的值是**客户端\_Secret\_BASIC **，**客户端\_Secret\_post **，**Private\_Key\_JWT **，**客户端\_Secret\_JWT **和**无**[（公众客户）](https://tools.ietf.org/html/rfc6749#section-2.1)。|
+|**5** |`authorizationGrantType`:OAuth2.0授权框架定义了四个[授权授予](https://tools.ietf.org/html/rfc6749#section-1.3)类型。<br/>支持的值是`authorization_code`，`client_credentials`，`password`，以及，扩展授权类型`urn:ietf:params:oauth:grant-type:jwt-bearer`。|
+|**6** |`redirectUri`:客户端注册的重定向URI，在最终用户对客户端进行了身份验证和授权访问之后，*授权服务器*将最终用户的用户代理<br/>重定向到该URI。|
+|**7** |`scopes`:客户端在授权请求流期间请求的范围，例如OpenID、电子邮件或配置文件。|
+|**8** |`clientName`:用于客户机的描述性名称。<br/>该名称可用于某些场景，例如在自动生成的登录页面中显示客户机的名称时。|
+|**9** |`authorizationUri`:授权服务器的授权端点URI。|
+|**10**|`tokenUri`:授权服务器的令牌端点URI。|
+|**11**|`jwkSetUri`:用于从授权服务器检索[JSON Web Key ](https://tools.ietf.org/html/rfc7517)集的URI，<br/>，其中包含用于验证ID令牌的[JSON Web签名](https://tools.ietf.org/html/rfc7515)的加密密钥，以及可选的userinfo响应。|
+|**12**|`issuerUri`:返回OpenID Connect1.0提供程序或OAuth2.0授权服务器的发行者标识符URI。|
+|**13**|`configurationMetadata`:[OpenID提供者配置信息](https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderConfig).<br/>只有在配置了 Spring boot2.x属性`spring.security.oauth2.client.provider.[providerId].issuerUri`时，该信息才可用。|
+|**14**|`(userInfoEndpoint)uri`:用于访问经过身份验证的最终用户的声明/属性的userinfo端点URI。|
+|**15**|`(userInfoEndpoint)authenticationMethod`:向UserInfo端点发送访问令牌时使用的身份验证方法。<br/>支持的值是**页眉**、**形式**和**查询**。|
+|**16**|`userNameAttributeName`:在引用最终用户的名称或标识符的UserInfo响应中返回的属性的名称。|
+
+可以使用发现OpenID Connect提供者的[配置端点](https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderConfig)或授权服务器的[元数据端点](https://tools.ietf.org/html/rfc8414#section-3)来初始配置`ClientRegistration`。
+
+`ClientRegistrations`以这种方式为配置`ClientRegistration`提供了方便的方法，如下例所示：
+
+Java
+
+```
+ClientRegistration clientRegistration =
+    ClientRegistrations.fromIssuerLocation("https://idp.example.com/issuer").build();
+```
+
+Kotlin
+
+```
+val clientRegistration = ClientRegistrations.fromIssuerLocation("https://idp.example.com/issuer").build()
+```
+
+上面的代码将在系列`[https://idp.example.com/issuer/.well-known/openid-configuration](https://idp.example.com/issuer/.well-known/openid-configuration)`中查询，然后`[https://idp.example.com/.well-known/openid-configuration/issuer](https://idp.example.com/.well-known/openid-configuration/issuer)`，最后是`[https://idp.example.com/.well-known/oauth-authorization-server/issuer](https://idp.example.com/.well-known/oauth-authorization-server/issuer)`，在第一次停止时返回200响应。
+
+作为一种替代方法，你可以使用`ClientRegistrations.fromOidcIssuerLocation()`仅查询OpenID Connect提供者的配置端点。
+
+## ClientRegistrationRepository
+
+`ClientRegistrationRepository`充当OAuth2.0/OpenID Connect1.0`ClientRegistration`（s）的存储库。
+
+|   |客户端注册信息最终由关联的授权服务器存储和拥有。<br/>此存储库提供检索主客户端注册信息的子集的能力，该子集与授权服务器一起存储。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+Spring Boot2.x Auto-Configuration将`spring.security.oauth2.client.registration.*[registrationId]*`下的每个属性绑定到`ClientRegistration`的一个实例，然后在`ClientRegistration`中组合每个`ClientRegistration`实例。
+
+|   |`ClientRegistrationRepository`的默认实现是`InMemoryClientRegistrationRepository`。|
+|---|-------------------------------------------------------------------------------------------------------|
+
+自动配置还在`ApplicationContext`中将`ClientRegistrationRepository`注册为`@Bean`，以便在应用程序需要时可用于依赖注入。
+
+下面的清单展示了一个示例：
+
+Java
+
+```
+@Controller
+public class OAuth2ClientController {
+
+	@Autowired
+	private ClientRegistrationRepository clientRegistrationRepository;
+
+	@GetMapping("/")
+	public String index() {
+		ClientRegistration oktaRegistration =
+			this.clientRegistrationRepository.findByRegistrationId("okta");
+
+		...
+
+		return "index";
+	}
+}
+```
+
+Kotlin
+
+```
+@Controller
+class OAuth2ClientController {
+
+    @Autowired
+    private lateinit var clientRegistrationRepository: ClientRegistrationRepository
+
+    @GetMapping("/")
+    fun index(): String {
+        val oktaRegistration =
+                this.clientRegistrationRepository.findByRegistrationId("okta")
+
+        //...
+
+        return "index";
+    }
+}
+```
+
+## OAuth2授权客户端
+
+`OAuth2AuthorizedClient`是授权客户的表示。当最终用户（资源所有者）已向客户端授予访问其受保护资源的授权时，客户端被视为已被授权。
+
+`OAuth2AuthorizedClient`的目的是将`OAuth2AccessToken`（和可选`OAuth2RefreshToken`）关联到`ClientRegistration`（客户端）和资源所有者，后者是授予授权的`Principal`最终用户。
+
+## OAuth2authorizedClientPository/OAuth2authorizedClientService
+
+`OAuth2AuthorizedClientRepository`负责在Web请求之间持久化`OAuth2AuthorizedClient`。然而，`OAuth2AuthorizedClientService`的主要作用是在应用程序级管理`OAuth2AuthorizedClient`。
+
+从开发人员的角度来看，`OAuth2AuthorizedClientRepository`或`OAuth2AuthorizedClientService`提供了查找与客户端关联的`OAuth2AccessToken`的功能，以便可以使用它来发起受保护的资源请求。
+
+下面的清单展示了一个示例：
+
+Java
+
+```
+@Controller
+public class OAuth2ClientController {
+
+    @Autowired
+    private OAuth2AuthorizedClientService authorizedClientService;
+
+    @GetMapping("/")
+    public String index(Authentication authentication) {
+        OAuth2AuthorizedClient authorizedClient =
+            this.authorizedClientService.loadAuthorizedClient("okta", authentication.getName());
+
+        OAuth2AccessToken accessToken = authorizedClient.getAccessToken();
+
+        ...
+
+        return "index";
+    }
+}
+```
+
+Kotlin
+
+```
+@Controller
+class OAuth2ClientController {
+
+    @Autowired
+    private lateinit var authorizedClientService: OAuth2AuthorizedClientService
+
+    @GetMapping("/")
+    fun index(authentication: Authentication): String {
+        val authorizedClient: OAuth2AuthorizedClient =
+            this.authorizedClientService.loadAuthorizedClient("okta", authentication.getName());
+        val accessToken = authorizedClient.accessToken
+
+        ...
+
+        return "index";
+    }
+}
+```
+
+|   |Spring Boot2.x自动配置在`ApplicationContext`中注册一个`OAuth2AuthorizedClientRepository`和/或`OAuth2AuthorizedClientService``@Bean`。<br/>但是，应用程序可以选择重写并注册一个自定义的`OAuth2AuthorizedClientRepository`或`OAuth2AuthorizedClientService`。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+`OAuth2AuthorizedClientService`的默认实现是`InMemoryOAuth2AuthorizedClientService`，它在内存中存储`OAuth2AuthorizedClient`。
+
+或者，可以将JDBC实现`JdbcOAuth2AuthorizedClientService`配置为在数据库中持久化`OAuth2AuthorizedClient`。
+
+|   |`JdbcOAuth2AuthorizedClientService`取决于[OAuth2.0客户端模式](../../appendix/database-schema.html#dbschema-oauth2-client)中描述的表定义。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## OAuth2AuthorizedClientManager/OAuth2AuthorizedClientProvider
+
+`OAuth2AuthorizedClientManager`负责`OAuth2AuthorizedClient`（s）的全面管理。
+
+主要职责包括：
+
+* 使用`OAuth2AuthorizedClientProvider`对OAuth2.0客户端进行授权（或重新授权）。
+
+* 委派`OAuth2AuthorizedClient`的持久性，通常使用`OAuth2AuthorizedClientService`或`OAuth2AuthorizedClientRepository`。
+
+* 当一个OAuth2.0客户端已被成功授权（或重新授权）时，将其委托给`OAuth2AuthorizationSuccessHandler`。
+
+* 当OAuth2.0客户端未能授权（或重新授权）时，将其委托给`OAuth2AuthorizationFailureHandler`。
+
+`OAuth2AuthorizedClientProvider`实现了对OAuth2.0客户端进行授权（或重新授权）的策略。实现通常将实现一种授权授予类型，例如。`authorization_code`，`client_credentials`等。
+
+`OAuth2AuthorizedClientManager`的默认实现是`DefaultOAuth2AuthorizedClientManager`，它与`OAuth2AuthorizedClientProvider`相关联，后者可能使用基于委托的组合来支持多个授权授予类型。`OAuth2AuthorizedClientProviderBuilder`可用于配置和构建基于委托的组合。
+
+下面的代码展示了如何配置和构建`OAuth2AuthorizedClientProvider`组合的示例，该组合为`authorization_code`、`refresh_token`、`client_credentials`和`password`授权授予类型提供支持：
+
+Java
+
+```
+@Bean
+public OAuth2AuthorizedClientManager authorizedClientManager(
+		ClientRegistrationRepository clientRegistrationRepository,
+		OAuth2AuthorizedClientRepository authorizedClientRepository) {
+
+	OAuth2AuthorizedClientProvider authorizedClientProvider =
+			OAuth2AuthorizedClientProviderBuilder.builder()
+					.authorizationCode()
+					.refreshToken()
+					.clientCredentials()
+					.password()
+					.build();
+
+	DefaultOAuth2AuthorizedClientManager authorizedClientManager =
+			new DefaultOAuth2AuthorizedClientManager(
+					clientRegistrationRepository, authorizedClientRepository);
+	authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);
+
+	return authorizedClientManager;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun authorizedClientManager(
+        clientRegistrationRepository: ClientRegistrationRepository,
+        authorizedClientRepository: OAuth2AuthorizedClientRepository): OAuth2AuthorizedClientManager {
+    val authorizedClientProvider = OAuth2AuthorizedClientProviderBuilder.builder()
+            .authorizationCode()
+            .refreshToken()
+            .clientCredentials()
+            .password()
+            .build()
+    val authorizedClientManager = DefaultOAuth2AuthorizedClientManager(
+            clientRegistrationRepository, authorizedClientRepository)
+    authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider)
+    return authorizedClientManager
+}
+```
+
+当授权尝试成功时，`DefaultOAuth2AuthorizedClientManager`将委托给`OAuth2AuthorizationSuccessHandler`，该（默认情况下）将通过`OAuth2AuthorizedClient`保存`OAuth2AuthorizedClient`。在重新授权失败的情况下，例如，刷新令牌不再有效，先前保存的`OAuth2AuthorizedClient`将通过`RemoveAuthorizedClientOAuth2AuthorizationFailureHandler`从`OAuth2AuthorizedClientRepository`中删除。默认行为可以通过`setAuthorizationSuccessHandler(OAuth2AuthorizationSuccessHandler)`和`setAuthorizationFailureHandler(OAuth2AuthorizationFailureHandler)`进行定制。
+
+`DefaultOAuth2AuthorizedClientManager`还与类型`Function<OAuth2AuthorizeRequest, Map<String, Object>>`的`contextAttributesMapper`相关联，它负责将属性从`OAuth2AuthorizeRequest`映射到要与`OAuth2AuthorizationContext`相关联的属性的`Map`。当你需要提供带有Required（Supported）属性的`OAuth2AuthorizedClientProvider`时，这可能是有用的，例如，`PasswordOAuth2AuthorizedClientProvider`要求资源所有者的`username`和`password`在`OAuth2AuthorizationContext.getAttributes()`中可用。
+
+下面的代码显示了`contextAttributesMapper`的示例：
+
+Java
+
+```
+@Bean
+public OAuth2AuthorizedClientManager authorizedClientManager(
+		ClientRegistrationRepository clientRegistrationRepository,
+		OAuth2AuthorizedClientRepository authorizedClientRepository) {
+
+	OAuth2AuthorizedClientProvider authorizedClientProvider =
+			OAuth2AuthorizedClientProviderBuilder.builder()
+					.password()
+					.refreshToken()
+					.build();
+
+	DefaultOAuth2AuthorizedClientManager authorizedClientManager =
+			new DefaultOAuth2AuthorizedClientManager(
+					clientRegistrationRepository, authorizedClientRepository);
+	authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);
+
+	// Assuming the `username` and `password` are supplied as `HttpServletRequest` parameters,
+	// map the `HttpServletRequest` parameters to `OAuth2AuthorizationContext.getAttributes()`
+	authorizedClientManager.setContextAttributesMapper(contextAttributesMapper());
+
+	return authorizedClientManager;
+}
+
+private Function<OAuth2AuthorizeRequest, Map<String, Object>> contextAttributesMapper() {
+	return authorizeRequest -> {
+		Map<String, Object> contextAttributes = Collections.emptyMap();
+		HttpServletRequest servletRequest = authorizeRequest.getAttribute(HttpServletRequest.class.getName());
+		String username = servletRequest.getParameter(OAuth2ParameterNames.USERNAME);
+		String password = servletRequest.getParameter(OAuth2ParameterNames.PASSWORD);
+		if (StringUtils.hasText(username) && StringUtils.hasText(password)) {
+			contextAttributes = new HashMap<>();
+
+			// `PasswordOAuth2AuthorizedClientProvider` requires both attributes
+			contextAttributes.put(OAuth2AuthorizationContext.USERNAME_ATTRIBUTE_NAME, username);
+			contextAttributes.put(OAuth2AuthorizationContext.PASSWORD_ATTRIBUTE_NAME, password);
+		}
+		return contextAttributes;
+	};
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun authorizedClientManager(
+        clientRegistrationRepository: ClientRegistrationRepository,
+        authorizedClientRepository: OAuth2AuthorizedClientRepository): OAuth2AuthorizedClientManager {
+    val authorizedClientProvider = OAuth2AuthorizedClientProviderBuilder.builder()
+            .password()
+            .refreshToken()
+            .build()
+    val authorizedClientManager = DefaultOAuth2AuthorizedClientManager(
+            clientRegistrationRepository, authorizedClientRepository)
+    authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider)
+
+    // Assuming the `username` and `password` are supplied as `HttpServletRequest` parameters,
+    // map the `HttpServletRequest` parameters to `OAuth2AuthorizationContext.getAttributes()`
+    authorizedClientManager.setContextAttributesMapper(contextAttributesMapper())
+    return authorizedClientManager
+}
+
+private fun contextAttributesMapper(): Function<OAuth2AuthorizeRequest, MutableMap<String, Any>> {
+    return Function { authorizeRequest ->
+        var contextAttributes: MutableMap<String, Any> = mutableMapOf()
+        val servletRequest: HttpServletRequest = authorizeRequest.getAttribute(HttpServletRequest::class.java.name)
+        val username: String = servletRequest.getParameter(OAuth2ParameterNames.USERNAME)
+        val password: String = servletRequest.getParameter(OAuth2ParameterNames.PASSWORD)
+        if (StringUtils.hasText(username) && StringUtils.hasText(password)) {
+            contextAttributes = hashMapOf()
+
+            // `PasswordOAuth2AuthorizedClientProvider` requires both attributes
+            contextAttributes[OAuth2AuthorizationContext.USERNAME_ATTRIBUTE_NAME] = username
+            contextAttributes[OAuth2AuthorizationContext.PASSWORD_ATTRIBUTE_NAME] = password
+        }
+        contextAttributes
+    }
+}
+```
+
+`DefaultOAuth2AuthorizedClientManager`被设计用于***内***`HttpServletRequest`的上下文。当操作***外面***的`HttpServletRequest`上下文时，请使用`AuthorizedClientServiceOAuth2AuthorizedClientManager`。
+
+当使用`AuthorizedClientServiceOAuth2AuthorizedClientManager`时，*服务应用程序*是一个常见的用例。服务应用程序通常在后台运行，没有任何用户交互，并且通常在系统级帐户而不是用户帐户下运行。配置为`client_credentials`grant类型的OAuth2.0客户机可以被视为服务应用程序的一种类型。
+
+下面的代码展示了如何配置`AuthorizedClientServiceOAuth2AuthorizedClientManager`的示例，该示例为`client_credentials`grant类型提供支持：
+
+Java
+
+```
+@Bean
+public OAuth2AuthorizedClientManager authorizedClientManager(
+		ClientRegistrationRepository clientRegistrationRepository,
+		OAuth2AuthorizedClientService authorizedClientService) {
+
+	OAuth2AuthorizedClientProvider authorizedClientProvider =
+			OAuth2AuthorizedClientProviderBuilder.builder()
+					.clientCredentials()
+					.build();
+
+	AuthorizedClientServiceOAuth2AuthorizedClientManager authorizedClientManager =
+			new AuthorizedClientServiceOAuth2AuthorizedClientManager(
+					clientRegistrationRepository, authorizedClientService);
+	authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);
+
+	return authorizedClientManager;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun authorizedClientManager(
+        clientRegistrationRepository: ClientRegistrationRepository,
+        authorizedClientService: OAuth2AuthorizedClientService): OAuth2AuthorizedClientManager {
+    val authorizedClientProvider = OAuth2AuthorizedClientProviderBuilder.builder()
+            .clientCredentials()
+            .build()
+    val authorizedClientManager = AuthorizedClientServiceOAuth2AuthorizedClientManager(
+            clientRegistrationRepository, authorizedClientService)
+    authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider)
+    return authorizedClientManager
+}
+```
+
+[OAuth2客户端](index.html)[OAuth2授权授予](authorization-grants.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-oauth2-client.md b/docs/spring-security/servlet-oauth2-client.md
new file mode 100644
index 0000000..2bd3285
--- /dev/null
+++ b/docs/spring-security/servlet-oauth2-client.md
@@ -0,0 +1,154 @@
+# OAuth2.0客户端
+
+OAuth2.0客户机特性为[OAuth2.0授权框架](https://tools.ietf.org/html/rfc6749#section-1.1)中定义的客户机角色提供支持。
+
+在高层次上，可用的核心特性是：
+
+授权赠款支助
+
+* [授权代码](https://tools.ietf.org/html/rfc6749#section-1.3.1)
+
+* [刷新令牌](https://tools.ietf.org/html/rfc6749#section-6)
+
+* [客户凭据](https://tools.ietf.org/html/rfc6749#section-1.3.4)
+
+* [资源所有者密码凭据](https://tools.ietf.org/html/rfc6749#section-1.3.3)
+
+* [JWT Bearer](https://datatracker.ietf.org/doc/html/rfc7523#section-2.1)
+
+客户端身份验证支持
+
+* [JWT Bearer](https://datatracker.ietf.org/doc/html/rfc7523#section-2.2)
+
+HTTP客户端支持
+
+* [`WebClient` Servlet 环境的集成]（授权-clients.html#OAuth2client-Webclient- Servlet）（用于请求受保护的资源）
+
+`HttpSecurity.oauth2Client()`DSL为定制OAuth2.0客户端使用的核心组件提供了许多配置选项。此外，`HttpSecurity.oauth2Client().authorizationCodeGrant()`实现了对授权代码授权的定制。
+
+以下代码显示了`HttpSecurity.oauth2Client()`DSL提供的完整配置选项：
+
+例1. OAuth2客户端配置选项
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2ClientSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.oauth2Client(oauth2 -> oauth2
+				.clientRegistrationRepository(this.clientRegistrationRepository())
+				.authorizedClientRepository(this.authorizedClientRepository())
+				.authorizedClientService(this.authorizedClientService())
+				.authorizationCodeGrant(codeGrant -> codeGrant
+					.authorizationRequestRepository(this.authorizationRequestRepository())
+					.authorizationRequestResolver(this.authorizationRequestResolver())
+					.accessTokenResponseClient(this.accessTokenResponseClient())
+				)
+			);
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class OAuth2ClientSecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            oauth2Client {
+                clientRegistrationRepository = clientRegistrationRepository()
+                authorizedClientRepository = authorizedClientRepository()
+                authorizedClientService = authorizedClientService()
+                authorizationCodeGrant {
+                    authorizationRequestRepository = authorizationRequestRepository()
+                    authorizationRequestResolver = authorizationRequestResolver()
+                    accessTokenResponseClient = accessTokenResponseClient()
+                }
+            }
+        }
+    }
+}
+```
+
+除了`HttpSecurity.oauth2Client()`DSL之外，还支持XML配置。
+
+以下代码显示了[安全命名空间](../../appendix/namespace/http.html#nsa-oauth2-client)中可用的完整配置选项：
+
+例2. OAuth2客户机XML配置选项
+
+```
+<http>
+	<oauth2-client client-registration-repository-ref="clientRegistrationRepository"
+				   authorized-client-repository-ref="authorizedClientRepository"
+				   authorized-client-service-ref="authorizedClientService">
+		<authorization-code-grant
+				authorization-request-repository-ref="authorizationRequestRepository"
+				authorization-request-resolver-ref="authorizationRequestResolver"
+				access-token-response-client-ref="accessTokenResponseClient"/>
+	</oauth2-client>
+</http>
+```
+
+`OAuth2AuthorizedClientManager`负责与一个或多个`OAuth2AuthorizedClientProvider`协作管理OAuth2.0客户端的授权（或重新授权）。
+
+下面的代码展示了如何注册`OAuth2AuthorizedClientManager``@Bean`并将其与`OAuth2AuthorizedClientProvider`复合相关联的示例，该复合提供对`authorization_code`、`refresh_token`、`client_credentials`和`password`授权授予类型的支持：
+
+Java
+
+```
+@Bean
+public OAuth2AuthorizedClientManager authorizedClientManager(
+		ClientRegistrationRepository clientRegistrationRepository,
+		OAuth2AuthorizedClientRepository authorizedClientRepository) {
+
+	OAuth2AuthorizedClientProvider authorizedClientProvider =
+			OAuth2AuthorizedClientProviderBuilder.builder()
+					.authorizationCode()
+					.refreshToken()
+					.clientCredentials()
+					.password()
+					.build();
+
+	DefaultOAuth2AuthorizedClientManager authorizedClientManager =
+			new DefaultOAuth2AuthorizedClientManager(
+					clientRegistrationRepository, authorizedClientRepository);
+	authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);
+
+	return authorizedClientManager;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun authorizedClientManager(
+        clientRegistrationRepository: ClientRegistrationRepository,
+        authorizedClientRepository: OAuth2AuthorizedClientRepository): OAuth2AuthorizedClientManager {
+    val authorizedClientProvider: OAuth2AuthorizedClientProvider = OAuth2AuthorizedClientProviderBuilder.builder()
+            .authorizationCode()
+            .refreshToken()
+            .clientCredentials()
+            .password()
+            .build()
+    val authorizedClientManager = DefaultOAuth2AuthorizedClientManager(
+            clientRegistrationRepository, authorizedClientRepository)
+    authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider)
+    return authorizedClientManager
+}
+```
+
+## 章节摘要
+
+* [核心接口和类](core.html)
+* [OAuth2授权授予](authorization-grants.html)
+* [OAuth2客户端身份验证](client-authentication.html)
+* [OAuth2授权客户](authorized-clients.html)
+
+[高级配置](../login/advanced.html)[核心接口和类](core.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-oauth2-login-advanced.md b/docs/spring-security/servlet-oauth2-login-advanced.md
new file mode 100644
index 0000000..85082e1
--- /dev/null
+++ b/docs/spring-security/servlet-oauth2-login-advanced.md
@@ -0,0 +1,872 @@
+# 高级配置
+
+`HttpSecurity.oauth2Login()`提供了许多用于定制OAuth2.0登录的配置选项。主要配置选项被分组到它们的协议端点对应项中。
+
+例如，`oauth2Login().authorizationEndpoint()`允许配置*授权端点*，而`oauth2Login().tokenEndpoint()`允许配置*令牌端点*。
+
+下面的代码展示了一个示例：
+
+例1.高级OAuth2登录配置
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.oauth2Login(oauth2 -> oauth2
+			    .authorizationEndpoint(authorization -> authorization
+			            ...
+			    )
+			    .redirectionEndpoint(redirection -> redirection
+			            ...
+			    )
+			    .tokenEndpoint(token -> token
+			            ...
+			    )
+			    .userInfoEndpoint(userInfo -> userInfo
+			            ...
+			    )
+			);
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class OAuth2LoginSecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            oauth2Login {
+                authorizationEndpoint {
+                    ...
+                }
+                redirectionEndpoint {
+                    ...
+                }
+                tokenEndpoint {
+                    ...
+                }
+                userInfoEndpoint {
+                    ...
+                }
+            }
+        }
+    }
+}
+```
+
+`oauth2Login()`DSL的主要目标是与规范中定义的命名紧密地保持一致。
+
+OAuth2.0授权框架将[协议端点](https://tools.ietf.org/html/rfc6749#section-3)定义如下：
+
+授权过程使用两个授权服务器端点（HTTP资源）：
+
+* 授权端点：由客户端使用，通过用户代理重定向从资源所有者处获得授权。
+
+* 令牌端点：由客户端使用，用于将授权许可交换为访问令牌，通常与客户端身份验证一起使用。
+
+以及一个客户端端点：
+
+* 重定向端点：授权服务器用于通过资源所有者User-Agent向客户端返回包含授权凭据的响应。
+
+OpenID Connect Core1.0规范将[用户信息端点](https://openid.net/specs/openid-connect-core-1_0.html#UserInfo)定义如下：
+
+UserInfo端点是一个受OAuth2.0保护的资源，它返回关于经过身份验证的最终用户的声明。为了获得所请求的关于最终用户的权利要求，客户端使用通过OpenID Connect身份验证获得的访问令牌向UserInfo端点发出请求。这些权利要求通常由一个JSON对象表示，该对象包含权利要求的名称-值对的集合。
+
+以下代码显示了`oauth2Login()`DSL可用的完整配置选项：
+
+例2. OAuth2登录配置选项
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.oauth2Login(oauth2 -> oauth2
+			    .clientRegistrationRepository(this.clientRegistrationRepository())
+			    .authorizedClientRepository(this.authorizedClientRepository())
+			    .authorizedClientService(this.authorizedClientService())
+			    .loginPage("/login")
+			    .authorizationEndpoint(authorization -> authorization
+			        .baseUri(this.authorizationRequestBaseUri())
+			        .authorizationRequestRepository(this.authorizationRequestRepository())
+			        .authorizationRequestResolver(this.authorizationRequestResolver())
+			    )
+			    .redirectionEndpoint(redirection -> redirection
+			        .baseUri(this.authorizationResponseBaseUri())
+			    )
+			    .tokenEndpoint(token -> token
+			        .accessTokenResponseClient(this.accessTokenResponseClient())
+			    )
+			    .userInfoEndpoint(userInfo -> userInfo
+			        .userAuthoritiesMapper(this.userAuthoritiesMapper())
+			        .userService(this.oauth2UserService())
+			        .oidcUserService(this.oidcUserService())
+			    )
+			);
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class OAuth2LoginSecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            oauth2Login {
+                clientRegistrationRepository = clientRegistrationRepository()
+                authorizedClientRepository = authorizedClientRepository()
+                authorizedClientService = authorizedClientService()
+                loginPage = "/login"
+                authorizationEndpoint {
+                    baseUri = authorizationRequestBaseUri()
+                    authorizationRequestRepository = authorizationRequestRepository()
+                    authorizationRequestResolver = authorizationRequestResolver()
+                }
+                redirectionEndpoint {
+                    baseUri = authorizationResponseBaseUri()
+                }
+                tokenEndpoint {
+                    accessTokenResponseClient = accessTokenResponseClient()
+                }
+                userInfoEndpoint {
+                    userAuthoritiesMapper = userAuthoritiesMapper()
+                    userService = oauth2UserService()
+                    oidcUserService = oidcUserService()
+                }
+            }
+        }
+    }
+}
+```
+
+除了`oauth2Login()`DSL之外，还支持XML配置。
+
+以下代码显示了[安全命名空间](../../appendix/namespace/http.html#nsa-oauth2-login)中可用的完整配置选项：
+
+例3. OAuth2登录XML配置选项
+
+```
+<http>
+	<oauth2-login client-registration-repository-ref="clientRegistrationRepository"
+				  authorized-client-repository-ref="authorizedClientRepository"
+				  authorized-client-service-ref="authorizedClientService"
+				  authorization-request-repository-ref="authorizationRequestRepository"
+				  authorization-request-resolver-ref="authorizationRequestResolver"
+				  access-token-response-client-ref="accessTokenResponseClient"
+				  user-authorities-mapper-ref="userAuthoritiesMapper"
+				  user-service-ref="oauth2UserService"
+				  oidc-user-service-ref="oidcUserService"
+				  login-processing-url="/login/oauth2/code/*"
+				  login-page="/login"
+				  authentication-success-handler-ref="authenticationSuccessHandler"
+				  authentication-failure-handler-ref="authenticationFailureHandler"
+				  jwt-decoder-factory-ref="jwtDecoderFactory"/>
+</http>
+```
+
+以下小节将详细介绍每种可用的配置选项：
+
+* [OAuth2.0登录页面](#oauth2login-advanced-login-page)
+
+* [重定向端点](#oauth2login-advanced-redirection-endpoint)
+
+* [用户信息端点](#oauth2login-advanced-userinfo-endpoint)
+
+* [ID令牌签名验证](#oauth2login-advanced-idtoken-verify)
+
+* [OpenID Connect1.0注销](#oauth2login-advanced-oidc-logout)
+
+## OAuth2.0登录页面
+
+默认情况下，OAuth2.0登录页面是由`DefaultLoginPageGeneratingFilter`自动生成的。默认登录页面显示了每个配置的OAuth客户机，其`ClientRegistration.clientName`作为链接，该链接能够发起授权请求（或OAuth2.0登录）。
+
+|   |为了使`DefaultLoginPageGeneratingFilter`显示用于配置的OAuth客户端的链接，已注册的`ClientRegistrationRepository`还需要实现`Iterable<ClientRegistration>`。<br/>参见`InMemoryClientRegistrationRepository`以供参考。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+每个OAuth客户端的链接目标默认为以下内容：
+
+`OAuth2AuthorizationRequestRedirectFilter.DEFAULT_AUTHORIZATION_REQUEST_BASE_URI + "/{registrationId}"`
+
+下面的一行显示了一个示例：
+
+```
+<a href="/oauth2/authorization/google">Google</a>
+```
+
+若要覆盖默认的登录页面，请配置`oauth2Login().loginPage()`和（可选地）`oauth2Login().authorizationEndpoint().baseUri()`。
+
+下面的清单展示了一个示例：
+
+例4. OAuth2登录页面配置
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.oauth2Login(oauth2 -> oauth2
+			    .loginPage("/login/oauth2")
+			    ...
+			    .authorizationEndpoint(authorization -> authorization
+			        .baseUri("/login/oauth2/authorization")
+			        ...
+			    )
+			);
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class OAuth2LoginSecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            oauth2Login {
+                loginPage = "/login/oauth2"
+                authorizationEndpoint {
+                    baseUri = "/login/oauth2/authorization"
+                }
+            }
+        }
+    }
+}
+```
+
+XML
+
+```
+<http>
+	<oauth2-login login-page="/login/oauth2"
+				  ...
+    />
+</http>
+```
+
+|   |你需要提供一个`@Controller`和一个`@RequestMapping("/login/oauth2")`，它能够呈现自定义登录页面。|
+|---|---------------------------------------------------------------------------------------------------------------------------------|
+
+|   |如前所述，配置`oauth2Login().authorizationEndpoint().baseUri()`是可选的。<br/>但是，如果你选择自定义它，请确保每个OAuth客户机的链接匹配`authorizationEndpoint().baseUri()`。<br/><br/>下面的一行显示了一个示例：<br/><br/>```<br/><a href="/login/oauth2/authorization/google">Google</a><br/>```|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## 重定向端点
+
+授权服务器使用重定向端点通过资源所有者User-Agent将授权响应（其中包含授权凭据）返回给客户端。
+
+|   |OAuth2.0Login利用了授权代码授权。<br/>因此，授权凭据是授权代码。|
+|---|------------------------------------------------------------------------------------------------------------------------------|
+
+默认的授权响应`baseUri`（重定向端点）是`**/login/oauth2/code/***`，它在`OAuth2LoginAuthenticationFilter.DEFAULT_FILTER_PROCESSES_URI`中定义。
+
+如果你想定制授权响应`baseUri`，请按照下面的示例配置它：
+
+例5.重定向端点配置
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.oauth2Login(oauth2 -> oauth2
+			    .redirectionEndpoint(redirection -> redirection
+			        .baseUri("/login/oauth2/callback/*")
+			        ...
+			    )
+			);
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class OAuth2LoginSecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            oauth2Login {
+                redirectionEndpoint {
+                    baseUri = "/login/oauth2/callback/*"
+                }
+            }
+        }
+    }
+}
+```
+
+XML
+
+```
+<http>
+	<oauth2-login login-processing-url="/login/oauth2/callback/*"
+				  ...
+    />
+</http>
+```
+
+|   |你还需要确保`ClientRegistration.redirectUri`与自定义授权响应`baseUri`匹配。<br/><br/>下面的列表显示了一个示例：<br/><br/><br/><br/><br/>
+```
+@EnableWebSecurity
+public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.oauth2Login(oauth2 -> oauth2
+			    .redirectionEndpoint(redirection -> redirection
+			        .baseUri("/login/oauth2/callback/*")
+			        ...
+			    )
+			);
+	}
+}
+```r=“85”/>>>>><gt="73"/>|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## 用户信息端点
+
+UserInfo端点包括许多配置选项，如下文子部分所述：
+
+* [映射用户权限](#oauth2login-advanced-map-authorities)
+
+* [OAuth2.0用户服务](#oauth2login-advanced-oauth2-user-service)
+
+* [OpenID Connect1.0用户服务](#oauth2login-advanced-oidc-user-service)
+
+### 映射用户权限
+
+在用户成功地使用OAuth2.0提供程序进行身份验证之后，`OAuth2User.getAuthorities()`（或`OidcUser.getAuthorities()`）可以被映射到一组新的`GrantedAuthority`实例，在完成身份验证时，该实例将被提供给`OAuth2AuthenticationToken`。
+
+|   |`OAuth2AuthenticationToken.getAuthorities()`用于授权请求，例如在`hasRole('USER')`或`hasRole('ADMIN')`中。|
+|---|----------------------------------------------------------------------------------------------------------------------------------|
+
+在映射用户权限时，有两个选项可供选择：
+
+* [使用grantedauthoritiesmapper ](#oauth2login-advanced-map-authorities-grantedauthoritiesmapper)
+
+* [基于OAuth2UserService的授权策略](#oauth2login-advanced-map-authorities-oauth2userservice)
+
+#### 使用grantedauthoritiesmapper
+
+提供`GrantedAuthoritiesMapper`的实现，并将其配置为以下示例所示：
+
+例6.授予权限映射器配置
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.oauth2Login(oauth2 -> oauth2
+			    .userInfoEndpoint(userInfo -> userInfo
+			        .userAuthoritiesMapper(this.userAuthoritiesMapper())
+			        ...
+			    )
+			);
+	}
+
+	private GrantedAuthoritiesMapper userAuthoritiesMapper() {
+		return (authorities) -> {
+			Set<GrantedAuthority> mappedAuthorities = new HashSet<>();
+
+			authorities.forEach(authority -> {
+				if (OidcUserAuthority.class.isInstance(authority)) {
+					OidcUserAuthority oidcUserAuthority = (OidcUserAuthority)authority;
+
+					OidcIdToken idToken = oidcUserAuthority.getIdToken();
+					OidcUserInfo userInfo = oidcUserAuthority.getUserInfo();
+
+					// Map the claims found in idToken and/or userInfo
+					// to one or more GrantedAuthority's and add it to mappedAuthorities
+
+				} else if (OAuth2UserAuthority.class.isInstance(authority)) {
+					OAuth2UserAuthority oauth2UserAuthority = (OAuth2UserAuthority)authority;
+
+					Map<String, Object> userAttributes = oauth2UserAuthority.getAttributes();
+
+					// Map the attributes found in userAttributes
+					// to one or more GrantedAuthority's and add it to mappedAuthorities
+
+				}
+			});
+
+			return mappedAuthorities;
+		};
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class OAuth2LoginSecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            oauth2Login {
+                userInfoEndpoint {
+                    userAuthoritiesMapper = userAuthoritiesMapper()
+                }
+            }
+        }
+    }
+
+    private fun userAuthoritiesMapper(): GrantedAuthoritiesMapper = GrantedAuthoritiesMapper { authorities: Collection<GrantedAuthority> ->
+        val mappedAuthorities = emptySet<GrantedAuthority>()
+
+        authorities.forEach { authority ->
+            if (authority is OidcUserAuthority) {
+                val idToken = authority.idToken
+                val userInfo = authority.userInfo
+                // Map the claims found in idToken and/or userInfo
+                // to one or more GrantedAuthority's and add it to mappedAuthorities
+            } else if (authority is OAuth2UserAuthority) {
+                val userAttributes = authority.attributes
+                // Map the attributes found in userAttributes
+                // to one or more GrantedAuthority's and add it to mappedAuthorities
+            }
+        }
+
+        mappedAuthorities
+    }
+}
+```
+
+XML
+
+```
+<http>
+	<oauth2-login user-authorities-mapper-ref="userAuthoritiesMapper"
+				  ...
+    />
+</http>
+```
+
+或者，你可以注册一个`GrantedAuthoritiesMapper``@Bean`以使其自动应用于配置，如以下示例所示：
+
+例7.授予权限映射器 Bean 配置
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+		    .oauth2Login(withDefaults());
+	}
+
+	@Bean
+	public GrantedAuthoritiesMapper userAuthoritiesMapper() {
+		...
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class OAuth2LoginSecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            oauth2Login { }
+        }
+    }
+
+    @Bean
+    fun userAuthoritiesMapper(): GrantedAuthoritiesMapper {
+        ...
+    }
+}
+```
+
+#### 基于OAuth2UserService的授权策略
+
+与使用`GrantedAuthoritiesMapper`相比，这种策略是先进的，但是，它也更灵活，因为它允许你访问`OAuth2UserRequest`和`OAuth2User`（当使用OAuth2.0用户服务时）或`OidcUserRequest`和`OidcUser`（当使用OpenID Connect1.0用户服务时）。
+
+`OAuth2UserRequest`（和`OidcUserRequest`）为你提供了对相关`OAuth2AccessToken`的访问，这在*委派者*需要从受保护的资源获取权限信息，然后才能为用户映射自定义权限的情况下非常有用。
+
+下面的示例展示了如何使用OpenID Connect1.0UserService实现和配置基于委托的策略：
+
+例8. OAuth2用户服务配置
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.oauth2Login(oauth2 -> oauth2
+			    .userInfoEndpoint(userInfo -> userInfo
+			        .oidcUserService(this.oidcUserService())
+			        ...
+			    )
+			);
+	}
+
+	private OAuth2UserService<OidcUserRequest, OidcUser> oidcUserService() {
+		final OidcUserService delegate = new OidcUserService();
+
+		return (userRequest) -> {
+			// Delegate to the default implementation for loading a user
+			OidcUser oidcUser = delegate.loadUser(userRequest);
+
+			OAuth2AccessToken accessToken = userRequest.getAccessToken();
+			Set<GrantedAuthority> mappedAuthorities = new HashSet<>();
+
+			// TODO
+			// 1) Fetch the authority information from the protected resource using accessToken
+			// 2) Map the authority information to one or more GrantedAuthority's and add it to mappedAuthorities
+
+			// 3) Create a copy of oidcUser but use the mappedAuthorities instead
+			oidcUser = new DefaultOidcUser(mappedAuthorities, oidcUser.getIdToken(), oidcUser.getUserInfo());
+
+			return oidcUser;
+		};
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class OAuth2LoginSecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            oauth2Login {
+                userInfoEndpoint {
+                    oidcUserService = oidcUserService()
+                }
+            }
+        }
+    }
+
+    @Bean
+    fun oidcUserService(): OAuth2UserService<OidcUserRequest, OidcUser> {
+        val delegate = OidcUserService()
+
+        return OAuth2UserService { userRequest ->
+            // Delegate to the default implementation for loading a user
+            var oidcUser = delegate.loadUser(userRequest)
+
+            val accessToken = userRequest.accessToken
+            val mappedAuthorities = HashSet<GrantedAuthority>()
+
+            // TODO
+            // 1) Fetch the authority information from the protected resource using accessToken
+            // 2) Map the authority information to one or more GrantedAuthority's and add it to mappedAuthorities
+            // 3) Create a copy of oidcUser but use the mappedAuthorities instead
+            oidcUser = DefaultOidcUser(mappedAuthorities, oidcUser.idToken, oidcUser.userInfo)
+
+            oidcUser
+        }
+    }
+}
+```
+
+XML
+
+```
+<http>
+	<oauth2-login oidc-user-service-ref="oidcUserService"
+				  ...
+    />
+</http>
+```
+
+### OAuth2.0用户服务
+
+`DefaultOAuth2UserService`是支持标准OAuth2.0提供者的`OAuth2UserService`的实现。
+
+|   |`OAuth2UserService`从userinfo端点获取最终用户（资源所有者）的用户属性（通过在授权流期间使用授予客户端的访问令牌），并以`OAuth2User`的形式返回`AuthenticatedPrincipal`。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+当在UserInfo端点请求用户属性时，`DefaultOAuth2UserService`使用`RestOperations`。
+
+如果需要自定义用户信息请求的预处理，则可以提供带有自定义`DefaultOAuth2UserService.setRequestEntityConverter()`的`Converter<OAuth2UserRequest, RequestEntity<?>>`。默认实现`OAuth2UserRequestEntityConverter`构建了用户信息请求的`RequestEntity`表示，该表示默认情况下在`Authorization`头中设置`OAuth2AccessToken`。
+
+在另一端，如果需要自定义用户信息响应的后处理，则需要为`DefaultOAuth2UserService.setRestOperations()`提供自定义配置的`RestOperations`。默认的`RestOperations`配置如下：
+
+```
+RestTemplate restTemplate = new RestTemplate();
+restTemplate.setErrorHandler(new OAuth2ErrorResponseErrorHandler());
+```
+
+`OAuth2ErrorResponseErrorHandler`是可以处理OAuth2.0错误（400BAD请求）的`ResponseErrorHandler`。它使用`OAuth2ErrorHttpMessageConverter`将OAuth2.0错误参数转换为`OAuth2Error`。
+
+无论你是自定义`DefaultOAuth2UserService`还是提供你自己的`OAuth2UserService`实现，你都需要对其进行配置，如以下示例所示：
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.oauth2Login(oauth2 -> oauth2
+			    .userInfoEndpoint(userInfo -> userInfo
+			        .userService(this.oauth2UserService())
+			        ...
+			    )
+			);
+	}
+
+	private OAuth2UserService<OAuth2UserRequest, OAuth2User> oauth2UserService() {
+		...
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class OAuth2LoginSecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            oauth2Login {
+                userInfoEndpoint {
+                    userService = oauth2UserService()
+                    // ...
+                }
+            }
+        }
+    }
+
+    private fun oauth2UserService(): OAuth2UserService<OAuth2UserRequest, OAuth2User> {
+        // ...
+    }
+}
+```
+
+### OpenID Connect1.0用户服务
+
+`OidcUserService`是支持OpenID Connect1.0Provider的`OAuth2UserService`的实现。
+
+当在UserInfo端点请求用户属性时，`OidcUserService`利用了`DefaultOAuth2UserService`。
+
+如果需要自定义用户信息请求的预处理和/或用户信息响应的后处理，则需要为`OidcUserService.setOauth2UserService()`提供自定义配置的`DefaultOAuth2UserService`。
+
+无论你是定制`OidcUserService`还是为OpenID Connect1.0Provider提供你自己的`OAuth2UserService`实现，你都需要对其进行配置，如以下示例所示：
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.oauth2Login(oauth2 -> oauth2
+				.userInfoEndpoint(userInfo -> userInfo
+				    .oidcUserService(this.oidcUserService())
+				    ...
+			    )
+			);
+	}
+
+	private OAuth2UserService<OidcUserRequest, OidcUser> oidcUserService() {
+		...
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class OAuth2LoginSecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            oauth2Login {
+                userInfoEndpoint {
+                    oidcUserService = oidcUserService()
+                    // ...
+                }
+            }
+        }
+    }
+
+    private fun oidcUserService(): OAuth2UserService<OidcUserRequest, OidcUser> {
+        // ...
+    }
+}
+```
+
+## ID令牌签名验证
+
+OpenID Connect1.0身份验证引入了[ID Token](https://openid.net/specs/openid-connect-core-1_0.html#IDToken)，这是一种安全令牌，其中包含关于客户端使用授权服务器对最终用户进行身份验证的声明。
+
+ID令牌表示为[JSON网络令牌](https://tools.ietf.org/html/rfc7519)，并且必须使用[JSON网页签名](https://tools.ietf.org/html/rfc7515)进行签名。
+
+`OidcIdTokenDecoderFactory`提供了用于`JwtDecoder`签名验证的`OidcIdToken`。默认的算法是`RS256`，但在客户端注册期间分配时可能会有所不同。对于这些情况，可以将解析器配置为返回为特定客户端分配的预期JWS算法。
+
+JWS算法解析器是一个`Function`，它接受一个`ClientRegistration`，并为客户机返回预期的`JwsAlgorithm`，例如。`SignatureAlgorithm.RS256`或`MacAlgorithm.HS256`
+
+下面的代码显示了如何将`OidcIdTokenDecoderFactory``@Bean`配置为所有`MacAlgorithm.HS256`的默认`MacAlgorithm.HS256`:
+
+Java
+
+```
+@Bean
+public JwtDecoderFactory<ClientRegistration> idTokenDecoderFactory() {
+	OidcIdTokenDecoderFactory idTokenDecoderFactory = new OidcIdTokenDecoderFactory();
+	idTokenDecoderFactory.setJwsAlgorithmResolver(clientRegistration -> MacAlgorithm.HS256);
+	return idTokenDecoderFactory;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun idTokenDecoderFactory(): JwtDecoderFactory<ClientRegistration?> {
+    val idTokenDecoderFactory = OidcIdTokenDecoderFactory()
+    idTokenDecoderFactory.setJwsAlgorithmResolver { MacAlgorithm.HS256 }
+    return idTokenDecoderFactory
+}
+```
+
+|   |对于基于MAC的算法，如`HS256`、`HS384`或`HS512`，对应于`client-secret`的`client-secret`被用作签名验证的对称密钥。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+|   |如果一个以上的`ClientRegistration`被配置为用于OpenID Connect1.0身份验证，则JWS算法解析器可以对提供的`ClientRegistration`进行评估，以确定返回哪个算法。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## OpenID Connect1.0注销
+
+OpenID Connect会话Management1.0允许使用客户端在提供商处注销最终用户。可用的策略之一是[RP启动的注销](https://openid.net/specs/openid-connect-session-1_0.html#RPLogout)。
+
+如果OpenID提供程序同时支持会话管理和[Discovery](https://openid.net/specs/openid-connect-discovery-1_0.html)，则客户端可以从OpenID提供程序的`end_session_endpoint``URL`中获得[发现元数据](https://openid.net/specs/openid-connect-session-1_0.html#OPMetadata)。这可以通过配置`ClientRegistration`和`issuer-uri`来实现，如下例所示：
+
+```
+spring:
+  security:
+    oauth2:
+      client:
+        registration:
+          okta:
+            client-id: okta-client-id
+            client-secret: okta-client-secret
+            ...
+        provider:
+          okta:
+            issuer-uri: https://dev-1234.oktapreview.com
+```
+
+…和`OidcClientInitiatedLogoutSuccessHandler`，它实现RP-initedlogout，可以配置如下：
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Autowired
+	private ClientRegistrationRepository clientRegistrationRepository;
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.authorizeHttpRequests(authorize -> authorize
+				.anyRequest().authenticated()
+			)
+			.oauth2Login(withDefaults())
+			.logout(logout -> logout
+				.logoutSuccessHandler(oidcLogoutSuccessHandler())
+			);
+	}
+
+	private LogoutSuccessHandler oidcLogoutSuccessHandler() {
+		OidcClientInitiatedLogoutSuccessHandler oidcLogoutSuccessHandler =
+				new OidcClientInitiatedLogoutSuccessHandler(this.clientRegistrationRepository);
+
+		// Sets the location that the End-User's User Agent will be redirected to
+		// after the logout has been performed at the Provider
+		oidcLogoutSuccessHandler.setPostLogoutRedirectUri("{baseUrl}");
+
+		return oidcLogoutSuccessHandler;
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class OAuth2LoginSecurityConfig : WebSecurityConfigurerAdapter() {
+    @Autowired
+    private lateinit var clientRegistrationRepository: ClientRegistrationRepository
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            authorizeRequests {
+                authorize(anyRequest, authenticated)
+            }
+            oauth2Login { }
+            logout {
+                logoutSuccessHandler = oidcLogoutSuccessHandler()
+            }
+        }
+    }
+
+    private fun oidcLogoutSuccessHandler(): LogoutSuccessHandler {
+        val oidcLogoutSuccessHandler = OidcClientInitiatedLogoutSuccessHandler(clientRegistrationRepository)
+
+        // Sets the location that the End-User's User Agent will be redirected to
+        // after the logout has been performed at the Provider
+        oidcLogoutSuccessHandler.setPostLogoutRedirectUri("{baseUrl}")
+        return oidcLogoutSuccessHandler
+    }
+}
+```
+
+|   |`OidcClientInitiatedLogoutSuccessHandler`支持`{baseUrl}`占位符。<br/>如果使用的话，应用程序的基本URL，如`[https://app.example.org](https://app.example.org)`，将在请求时替换它。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+[核心配置](core.html)[OAuth2客户端](../client/index.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-oauth2-login-core.md b/docs/spring-security/servlet-oauth2-login-core.md
new file mode 100644
index 0000000..f8b15dc
--- /dev/null
+++ b/docs/spring-security/servlet-oauth2-login-core.md
@@ -0,0 +1,509 @@
+# 核心配置
+
+## Spring 启动2.x示例
+
+Spring Boot2.x为OAuth2.0登录带来了完整的自动配置功能。
+
+本节展示如何使用*谷歌*作为*身份验证提供者*配置[**OAuth2.0登录示例**](https://github.com/spring-projects/spring-security-samples/tree/5.6.x/servlet/spring-boot/java/oauth2/login)，并涵盖以下主题：
+
+* [初始设置](#oauth2login-sample-initial-setup)
+
+* [设置重定向URI](#oauth2login-sample-redirect-uri)
+
+* [配置application.yml](#oauth2login-sample-application-config)
+
+* [启动应用程序](#oauth2login-sample-boot-application)
+
+### 初始设置
+
+要使用Google的OAuth2.0身份验证系统进行登录，你必须在Google API控制台中设置一个项目，以获得OAuth2.0凭据。
+
+|   |用于身份验证的[谷歌的OAuth2.0实现](https://developers.google.com/identity/protocols/OpenIDConnect)符合[OpenID Connect1.0](https://openid.net/connect/)规范，并且是[OpenID认证](https://openid.net/certification/)。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+从“设置OAuth2.0”一节开始，按照[OpenID连接](https://developers.google.com/identity/protocols/OpenIDConnect)页面上的说明进行操作。
+
+在完成“获取OAuth2.0凭据”说明之后，你应该有一个新的OAuth客户机，其凭据由一个客户机ID和一个客户机秘密组成。
+
+### 设置重定向URI
+
+重定向URI是应用程序中的路径，最终用户的用户代理在与Google进行身份验证并授予对同意页面上的OAuth客户端*（[在前一步中创建](#oauth2login-sample-initial-setup)）*的访问权限后，将其重定向回应用程序中的路径。
+
+在“设置重定向URI”子节中，确保将**授权重定向URI**字段设置为`[http://localhost:8080/login/oauth2/code/google](http://localhost:8080/login/oauth2/code/google)`。
+
+|   |默认的重定向URI模板是`{baseUrl}/login/oauth2/code/{registrationId}`。<br/>***注册ID***是[客户登记](../client/index.html#oauth2Client-client-registration)的唯一标识符。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+|   |如果OAuth客户端运行在代理服务器后面，建议检查[代理服务器配置](../../../features/exploits/http.html#http-proxy-server)以确保应用程序配置正确。<br/>此外，请参阅支持的[`URI`模板变量]（../client/Authorization-grants.html#OAuth2client-auth-code-redirect-uri）。|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 配置application.yml
+
+现在，你有了一个新的OAuth客户机和Google，你需要将应用程序配置为使用*认证流程*的OAuth客户机。这样做：
+
+1. 转到`application.yml`并设置以下配置：
+
+   ```
+   spring:
+     security:
+       oauth2:
+         client:
+           registration:	(1)
+             google:	(2)
+               client-id: google-client-id
+               client-secret: google-client-secret
+   ```
+
+   例1. OAuth客户属性
+
+   |**1**|`spring.security.oauth2.client.registration`是OAuth客户机属性的基本属性前缀。|
+   |-----|-------------------------------------------------------------------------------------------------------------------------------------------------|
+   |**2**|在基本属性前缀之后是[客户登记](../client/index.html#oauth2Client-client-registration)的ID，例如Google。|
+
+2. 用前面创建的OAuth2.0凭据替换`client-id`和`client-secret`属性中的值。
+
+### 启动应用程序
+
+启动 Spring Boot2.x示例，然后转到`[http://localhost:8080](http://localhost:8080)`。然后，你将被重定向到默认的*自动生成*登录页面，该页面显示了Google的链接。
+
+点击谷歌链接，然后你将被重定向到谷歌进行身份验证。
+
+在用你的谷歌账号认证后，你看到的下一个页面就是“同意”页面。同意屏幕要求你允许或拒绝访问你之前创建的OAuth客户端。单击**允许**授权OAuth客户端访问你的电子邮件地址和基本配置文件信息。
+
+此时，OAuth客户机从[用户信息端点](https://openid.net/specs/openid-connect-core-1_0.html#UserInfo)检索你的电子邮件地址和基本配置文件信息，并建立经过身份验证的会话。
+
+## Spring 启动2.x属性映射
+
+下表概述了 Spring Boot2.x OAuth客户机属性到[客户登记](../client/index.html#oauth2Client-client-registration)属性的映射。
+
+|Spring 启动2.x|                   ClientRegistration                   |
+|--------------------------------------------------------------------------------------------|--------------------------------------------------------|
+|`spring.security.oauth2.client.registration.*[registrationId]*`|                    `registrationId`                    |
+|`spring.security.oauth2.client.registration.*[registrationId]*.client-id`|                       `clientId`                       |
+|`spring.security.oauth2.client.registration.*[registrationId]*.client-secret`|                     `clientSecret`                     |
+|`spring.security.oauth2.client.registration.*[registrationId]*.client-authentication-method`|              `clientAuthenticationMethod`              |
+|`spring.security.oauth2.client.registration.*[registrationId]*.authorization-grant-type`|                `authorizationGrantType`                |
+|`spring.security.oauth2.client.registration.*[registrationId]*.redirect-uri`|                     `redirectUri`                      |
+|`spring.security.oauth2.client.registration.*[registrationId]*.scope`|                        `scopes`                        |
+|`spring.security.oauth2.client.registration.*[registrationId]*.client-name`|                      `clientName`                      |
+|`spring.security.oauth2.client.provider.*[providerId]*.authorization-uri`|           `providerDetails.authorizationUri`           |
+|`spring.security.oauth2.client.provider.*[providerId]*.token-uri`|               `providerDetails.tokenUri`               |
+|`spring.security.oauth2.client.provider.*[providerId]*.jwk-set-uri`|              `providerDetails.jwkSetUri`               |
+|`spring.security.oauth2.client.provider.*[providerId]*.issuer-uri`|              `providerDetails.issuerUri`               |
+|`spring.security.oauth2.client.provider.*[providerId]*.user-info-uri`|         `providerDetails.userInfoEndpoint.uri`         |
+|`spring.security.oauth2.client.provider.*[providerId]*.user-info-authentication-method`|`providerDetails.userInfoEndpoint.authenticationMethod` |
+|`spring.security.oauth2.client.provider.*[providerId]*.user-name-attribute`|`providerDetails.userInfoEndpoint.userNameAttributeName`|
+
+|   |通过指定`spring.security.oauth2.client.provider.*[providerId]*.issuer-uri`属性，可以使用发现OpenID Connect提供者的[配置端点](https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderConfig)或授权服务器的[元数据端点](https://tools.ietf.org/html/rfc8414#section-3)来初始配置`ClientRegistration`。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## CommonoAuth2Provider
+
+`CommonOAuth2Provider`为许多著名的提供商预先定义了一组默认的客户端属性：Google、GitHub、Facebook和OKTA。
+
+例如，对于提供者，`authorization-uri`、`token-uri`和`user-info-uri`不会经常更改。因此，为了减少所需的配置，提供默认值是有意义的。
+
+如前所述，当我们[配置了一个Google客户端](#oauth2login-sample-application-config)时，只需要`client-id`和`client-secret`属性。
+
+下面的清单展示了一个示例：
+
+```
+spring:
+  security:
+    oauth2:
+      client:
+        registration:
+          google:
+            client-id: google-client-id
+            client-secret: google-client-secret
+```
+
+|   |客户机属性的自动默认在这里无缝地工作，因为`registrationId`（`google`）匹配`GOOGLE``enum`（不区分大小写）中的`CommonOAuth2Provider`。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+对于可能希望指定不同的`registrationId`的情况，例如`google-login`，你仍然可以通过配置`provider`属性来利用客户机属性的自动违约。
+
+下面的清单展示了一个示例：
+
+```
+spring:
+  security:
+    oauth2:
+      client:
+        registration:
+          google-login:	(1)
+            provider: google	(2)
+            client-id: google-client-id
+            client-secret: google-client-secret
+```
+
+|**1**|将`registrationId`设置为`google-login`。|
+|-----|-----------------------------------------------------------------------------------------------------------------------------------------------------------|
+|**2**|将`provider`属性设置为`google`，这将利用`CommonOAuth2Provider.GOOGLE.getBuilder()`中设置的客户机属性的自动违约。|
+
+## 配置自定义提供程序属性
+
+有一些OAuth2.0提供程序支持多租赁，这会导致每个租户（或子域）的协议端点不同。
+
+例如，向OKTA注册的OAuth客户端被分配到特定的子域并具有自己的协议端点。
+
+对于这些情况， Spring Boot2.x为配置自定义提供程序属性提供了以下基本属性：`spring.security.oauth2.client.provider.*[providerId]*`。
+
+下面的清单展示了一个示例：
+
+```
+spring:
+  security:
+    oauth2:
+      client:
+        registration:
+          okta:
+            client-id: okta-client-id
+            client-secret: okta-client-secret
+        provider:
+          okta:	(1)
+            authorization-uri: https://your-subdomain.oktapreview.com/oauth2/v1/authorize
+            token-uri: https://your-subdomain.oktapreview.com/oauth2/v1/token
+            user-info-uri: https://your-subdomain.oktapreview.com/oauth2/v1/userinfo
+            user-name-attribute: sub
+            jwk-set-uri: https://your-subdomain.oktapreview.com/oauth2/v1/keys
+```
+
+|**1**|基本属性（`spring.security.oauth2.client.provider.okta`）允许自定义配置协议端点位置。|
+|-----|---------------------------------------------------------------------------------------------------------------------------------|
+
+## 覆盖 Spring 启动2.x自动配置
+
+OAuth客户端支持的 Spring Boot2.x自动配置类是`OAuth2ClientAutoConfiguration`。
+
+它执行以下任务：
+
+* 从配置的OAuth客户机属性中寄存器`ClientRegistrationRepository``@Bean`组成的`ClientRegistration`。
+
+* 提供`WebSecurityConfigurerAdapter``@Configuration`并通过`httpSecurity.oauth2Login()`启用OAuth2.0登录。
+
+如果需要根据你的特定需求重写自动配置，可以通过以下方式执行：
+
+* [注册一个ClientRegistrationRepository@ Bean](#oauth2login-register-clientregistrationrepository-bean)
+
+* [提供一个WebSecurityConfigureRadapter](#oauth2login-provide-websecurityconfigureradapter)
+
+* [完全覆盖自动配置](#oauth2login-completely-override-autoconfiguration)
+
+### Register a ClientRegistrationRepository @Bean
+
+下面的示例显示了如何注册`ClientRegistrationRepository``@Bean`:
+
+Java
+
+```
+@Configuration
+public class OAuth2LoginConfig {
+
+	@Bean
+	public ClientRegistrationRepository clientRegistrationRepository() {
+		return new InMemoryClientRegistrationRepository(this.googleClientRegistration());
+	}
+
+	private ClientRegistration googleClientRegistration() {
+		return ClientRegistration.withRegistrationId("google")
+			.clientId("google-client-id")
+			.clientSecret("google-client-secret")
+			.clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
+			.authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
+			.redirectUri("{baseUrl}/login/oauth2/code/{registrationId}")
+			.scope("openid", "profile", "email", "address", "phone")
+			.authorizationUri("https://accounts.google.com/o/oauth2/v2/auth")
+			.tokenUri("https://www.googleapis.com/oauth2/v4/token")
+			.userInfoUri("https://www.googleapis.com/oauth2/v3/userinfo")
+			.userNameAttributeName(IdTokenClaimNames.SUB)
+			.jwkSetUri("https://www.googleapis.com/oauth2/v3/certs")
+			.clientName("Google")
+			.build();
+	}
+}
+```
+
+Kotlin
+
+```
+@Configuration
+class OAuth2LoginConfig {
+    @Bean
+    fun clientRegistrationRepository(): ClientRegistrationRepository {
+        return InMemoryClientRegistrationRepository(googleClientRegistration())
+    }
+
+    private fun googleClientRegistration(): ClientRegistration {
+        return ClientRegistration.withRegistrationId("google")
+                .clientId("google-client-id")
+                .clientSecret("google-client-secret")
+                .clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
+                .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
+                .redirectUri("{baseUrl}/login/oauth2/code/{registrationId}")
+                .scope("openid", "profile", "email", "address", "phone")
+                .authorizationUri("https://accounts.google.com/o/oauth2/v2/auth")
+                .tokenUri("https://www.googleapis.com/oauth2/v4/token")
+                .userInfoUri("https://www.googleapis.com/oauth2/v3/userinfo")
+                .userNameAttributeName(IdTokenClaimNames.SUB)
+                .jwkSetUri("https://www.googleapis.com/oauth2/v3/certs")
+                .clientName("Google")
+                .build()
+    }
+}
+```
+
+### 提供一个WebSecurityConfigureRadapter
+
+下面的示例展示了如何使用`@EnableWebSecurity`提供`WebSecurityConfigurerAdapter`并通过`httpSecurity.oauth2Login()`启用OAuth2.0登录：
+
+例2. OAuth2登录配置
+
+Java
+
+```
+@EnableWebSecurity
+public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+			.authorizeHttpRequests(authorize -> authorize
+				.anyRequest().authenticated()
+			)
+			.oauth2Login(withDefaults());
+	}
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class OAuth2LoginSecurityConfig : WebSecurityConfigurerAdapter() {
+
+    override fun configure(http: HttpSecurity) {
+        http {
+            authorizeRequests {
+                authorize(anyRequest, authenticated)
+            }
+            oauth2Login { }
+        }
+    }
+}
+```
+
+### 完全覆盖自动配置
+
+下面的示例展示了如何通过注册一个`ClientRegistrationRepository``@Bean`并提供一个`WebSecurityConfigurerAdapter`来完全覆盖自动配置。
+
+例3.覆盖自动配置
+
+Java
+
+```
+@Configuration
+public class OAuth2LoginConfig {
+
+	@EnableWebSecurity
+	public static class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+		@Override
+		protected void configure(HttpSecurity http) throws Exception {
+			http
+				.authorizeHttpRequests(authorize -> authorize
+					.anyRequest().authenticated()
+				)
+				.oauth2Login(withDefaults());
+		}
+	}
+
+	@Bean
+	public ClientRegistrationRepository clientRegistrationRepository() {
+		return new InMemoryClientRegistrationRepository(this.googleClientRegistration());
+	}
+
+	private ClientRegistration googleClientRegistration() {
+		return ClientRegistration.withRegistrationId("google")
+			.clientId("google-client-id")
+			.clientSecret("google-client-secret")
+			.clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
+			.authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
+			.redirectUri("{baseUrl}/login/oauth2/code/{registrationId}")
+			.scope("openid", "profile", "email", "address", "phone")
+			.authorizationUri("https://accounts.google.com/o/oauth2/v2/auth")
+			.tokenUri("https://www.googleapis.com/oauth2/v4/token")
+			.userInfoUri("https://www.googleapis.com/oauth2/v3/userinfo")
+			.userNameAttributeName(IdTokenClaimNames.SUB)
+			.jwkSetUri("https://www.googleapis.com/oauth2/v3/certs")
+			.clientName("Google")
+			.build();
+	}
+}
+```
+
+Kotlin
+
+```
+@Configuration
+class OAuth2LoginConfig {
+
+    @EnableWebSecurity
+    class OAuth2LoginSecurityConfig: WebSecurityConfigurerAdapter() {
+
+        override fun configure(http: HttpSecurity) {
+            http {
+                authorizeRequests {
+                    authorize(anyRequest, authenticated)
+                }
+                oauth2Login { }
+            }
+        }
+    }
+
+    @Bean
+    fun clientRegistrationRepository(): ClientRegistrationRepository {
+        return InMemoryClientRegistrationRepository(googleClientRegistration())
+    }
+
+    private fun googleClientRegistration(): ClientRegistration {
+        return ClientRegistration.withRegistrationId("google")
+                .clientId("google-client-id")
+                .clientSecret("google-client-secret")
+                .clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
+                .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
+                .redirectUri("{baseUrl}/login/oauth2/code/{registrationId}")
+                .scope("openid", "profile", "email", "address", "phone")
+                .authorizationUri("https://accounts.google.com/o/oauth2/v2/auth")
+                .tokenUri("https://www.googleapis.com/oauth2/v4/token")
+                .userInfoUri("https://www.googleapis.com/oauth2/v3/userinfo")
+                .userNameAttributeName(IdTokenClaimNames.SUB)
+                .jwkSetUri("https://www.googleapis.com/oauth2/v3/certs")
+                .clientName("Google")
+                .build()
+    }
+}
+```
+
+## Java 配置不需要 Spring 启动2.x
+
+如果你不能使用 Spring Boot2.x，并且希望在`CommonOAuth2Provider`中配置一个预定义的提供程序（例如，Google），请应用以下配置：
+
+例4. OAuth2登录配置
+
+Java
+
+```
+@Configuration
+public class OAuth2LoginConfig {
+
+	@EnableWebSecurity
+	public static class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
+
+		@Override
+		protected void configure(HttpSecurity http) throws Exception {
+			http
+				.authorizeHttpRequests(authorize -> authorize
+					.anyRequest().authenticated()
+				)
+				.oauth2Login(withDefaults());
+		}
+	}
+
+	@Bean
+	public ClientRegistrationRepository clientRegistrationRepository() {
+		return new InMemoryClientRegistrationRepository(this.googleClientRegistration());
+	}
+
+	@Bean
+	public OAuth2AuthorizedClientService authorizedClientService(
+			ClientRegistrationRepository clientRegistrationRepository) {
+		return new InMemoryOAuth2AuthorizedClientService(clientRegistrationRepository);
+	}
+
+	@Bean
+	public OAuth2AuthorizedClientRepository authorizedClientRepository(
+			OAuth2AuthorizedClientService authorizedClientService) {
+		return new AuthenticatedPrincipalOAuth2AuthorizedClientRepository(authorizedClientService);
+	}
+
+	private ClientRegistration googleClientRegistration() {
+		return CommonOAuth2Provider.GOOGLE.getBuilder("google")
+			.clientId("google-client-id")
+			.clientSecret("google-client-secret")
+			.build();
+	}
+}
+```
+
+Kotlin
+
+```
+@Configuration
+open class OAuth2LoginConfig {
+    @EnableWebSecurity
+    open class OAuth2LoginSecurityConfig : WebSecurityConfigurerAdapter() {
+        override fun configure(http: HttpSecurity) {
+            http {
+                authorizeRequests {
+                    authorize(anyRequest, authenticated)
+                }
+                oauth2Login { }
+            }
+        }
+    }
+
+    @Bean
+    open fun clientRegistrationRepository(): ClientRegistrationRepository {
+        return InMemoryClientRegistrationRepository(googleClientRegistration())
+    }
+
+    @Bean
+    open fun authorizedClientService(
+        clientRegistrationRepository: ClientRegistrationRepository?
+    ): OAuth2AuthorizedClientService {
+        return InMemoryOAuth2AuthorizedClientService(clientRegistrationRepository)
+    }
+
+    @Bean
+    open fun authorizedClientRepository(
+        authorizedClientService: OAuth2AuthorizedClientService?
+    ): OAuth2AuthorizedClientRepository {
+        return AuthenticatedPrincipalOAuth2AuthorizedClientRepository(authorizedClientService)
+    }
+
+    private fun googleClientRegistration(): ClientRegistration {
+        return CommonOAuth2Provider.GOOGLE.getBuilder("google")
+            .clientId("google-client-id")
+            .clientSecret("google-client-secret")
+            .build()
+    }
+}
+```
+
+XML
+
+```
+<http auto-config="true">
+	<intercept-url pattern="/**" access="authenticated"/>
+	<oauth2-login authorized-client-repository-ref="authorizedClientRepository"/>
+</http>
+
+<client-registrations>
+	<client-registration registration-id="google"
+						 client-id="google-client-id"
+						 client-secret="google-client-secret"
+						 provider-id="google"/>
+</client-registrations>
+
+<b:bean id="authorizedClientService"
+		class="org.springframework.security.oauth2.client.InMemoryOAuth2AuthorizedClientService"
+		autowire="constructor"/>
+
+<b:bean id="authorizedClientRepository"
+		class="org.springframework.security.oauth2.client.web.AuthenticatedPrincipalOAuth2AuthorizedClientRepository">
+	<b:constructor-arg ref="authorizedClientService"/>
+</b:bean>
+```
+
+[OAuth2登录](index.html)[高级配置](advanced.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-oauth2-login.md b/docs/spring-security/servlet-oauth2-login.md
new file mode 100644
index 0000000..a81f1ea
--- /dev/null
+++ b/docs/spring-security/servlet-oauth2-login.md
@@ -0,0 +1,13 @@
+# OAuth2.0登录
+
+OAuth2.0登录功能提供了一个应用程序，该应用程序可以让用户使用他们在OAuth2.0提供商（例如GitHub）或OpenID Connect1.0提供商（例如Google）的现有帐户登录到该应用程序。OAuth2.0Login实现了以下用例：“用Google登录”或“用GitHub登录”。
+
+|   |OAuth2.0登录是通过使用**授权代码授予**实现的，如[OAuth2.0授权框架](https://tools.ietf.org/html/rfc6749#section-4.1)和[OpenID Connect Core1.0](https://openid.net/specs/openid-connect-core-1_0.html#CodeFlowAuth)中所指定的。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## 章节摘要
+
+* [核心配置](core.html)
+* [高级配置](advanced.html)
+
+[OAuth2](../index.html)[核心配置](core.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-oauth2-resource-server-bearer-tokens.md b/docs/spring-security/servlet-oauth2-resource-server-bearer-tokens.md
new file mode 100644
index 0000000..00264a3
--- /dev/null
+++ b/docs/spring-security/servlet-oauth2-resource-server-bearer-tokens.md
@@ -0,0 +1,269 @@
+# OAuth2.0不记名代币
+
+## 不记名令牌解析
+
+默认情况下，Resource Server在`Authorization`头中查找承载令牌。然而，这可以通过几种方式进行定制。
+
+### 从自定义标头读取不记名令牌
+
+例如，你可能需要从自定义报头读取承载令牌。为了实现这一点，你可以将`DefaultBearerTokenResolver`公开为 Bean，或者将一个实例连接到DSL中，正如你在下面的示例中所看到的那样：
+
+例1.自定义承载令牌标头
+
+Java
+
+```
+@Bean
+BearerTokenResolver bearerTokenResolver() {
+    DefaultBearerTokenResolver bearerTokenResolver = new DefaultBearerTokenResolver();
+    bearerTokenResolver.setBearerTokenHeaderName(HttpHeaders.PROXY_AUTHORIZATION);
+    return bearerTokenResolver;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun bearerTokenResolver(): BearerTokenResolver {
+    val bearerTokenResolver = DefaultBearerTokenResolver()
+    bearerTokenResolver.setBearerTokenHeaderName(HttpHeaders.PROXY_AUTHORIZATION)
+    return bearerTokenResolver
+}
+```
+
+XML
+
+```
+<http>
+    <oauth2-resource-server bearer-token-resolver-ref="bearerTokenResolver"/>
+</http>
+
+<bean id="bearerTokenResolver"
+        class="org.springframework.security.oauth2.server.resource.web.DefaultBearerTokenResolver">
+    <property name="bearerTokenHeaderName" value="Proxy-Authorization"/>
+</bean>
+```
+
+或者，在提供者同时使用自定义头和值的情况下，你可以使用`HeaderBearerTokenResolver`。
+
+### 从窗体参数读取承载令牌
+
+或者，你可能希望从一个表单参数读取令牌，这可以通过配置`DefaultBearerTokenResolver`来实现，如下所示：
+
+例2.表单参数承载令牌
+
+Java
+
+```
+DefaultBearerTokenResolver resolver = new DefaultBearerTokenResolver();
+resolver.setAllowFormEncodedBodyParameter(true);
+http
+    .oauth2ResourceServer(oauth2 -> oauth2
+        .bearerTokenResolver(resolver)
+    );
+```
+
+Kotlin
+
+```
+val resolver = DefaultBearerTokenResolver()
+resolver.setAllowFormEncodedBodyParameter(true)
+http {
+    oauth2ResourceServer {
+        bearerTokenResolver = resolver
+    }
+}
+```
+
+XML
+
+```
+<http>
+    <oauth2-resource-server bearer-token-resolver-ref="bearerTokenResolver"/>
+</http>
+
+<bean id="bearerTokenResolver"
+        class="org.springframework.security.oauth2.server.resource.web.HeaderBearerTokenResolver">
+    <property name="allowFormEncodedBodyParameter" value="true"/>
+</bean>
+```
+
+## 承载令牌传播
+
+既然你的资源服务器已经验证了令牌，那么将其传递给下游服务可能会很方便。对于`[ServletBearerExchangeFilterFunction](https://docs.spring.io/spring-security/site/docs/5.6.2/api/org/springframework/security/oauth2/server/resource/web/reactive/function/client/ServletBearerExchangeFilterFunction.html)`，这非常简单，你可以在下面的示例中看到它：
+
+Java
+
+```
+@Bean
+public WebClient rest() {
+    return WebClient.builder()
+            .filter(new ServletBearerExchangeFilterFunction())
+            .build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun rest(): WebClient {
+    return WebClient.builder()
+            .filter(ServletBearerExchangeFilterFunction())
+            .build()
+}
+```
+
+当上面的`WebClient`用于执行请求时， Spring Security将查找当前的`Authentication`并提取任何`[AbstractOAuth2Token](https://docs.spring.io/spring-security/site/docs/5.6.2/api/org/springframework/security/oauth2/core/AbstractOAuth2Token.html)`凭据。然后，它将在`Authorization`头中传播该令牌。
+
+例如：
+
+Java
+
+```
+this.rest.get()
+        .uri("https://other-service.example.com/endpoint")
+        .retrieve()
+        .bodyToMono(String.class)
+        .block()
+```
+
+Kotlin
+
+```
+this.rest.get()
+        .uri("https://other-service.example.com/endpoint")
+        .retrieve()
+        .bodyToMono<String>()
+        .block()
+```
+
+将调用`[https://other-service.example.com/endpoint](https://other-service.example.com/endpoint)`，为你添加承载令牌`Authorization`头。
+
+在需要重写此行为的地方，你只需自己提供标题，就像这样：
+
+Java
+
+```
+this.rest.get()
+        .uri("https://other-service.example.com/endpoint")
+        .headers(headers -> headers.setBearerAuth(overridingToken))
+        .retrieve()
+        .bodyToMono(String.class)
+        .block()
+```
+
+Kotlin
+
+```
+this.rest.get()
+        .uri("https://other-service.example.com/endpoint")
+        .headers{  headers -> headers.setBearerAuth(overridingToken)}
+        .retrieve()
+        .bodyToMono<String>()
+        .block()
+```
+
+在这种情况下，过滤器将向后退，只需将请求转发到Web筛选链的其余部分。
+
+|   |与[OAuth2.0客户端过滤功能](https://docs.spring.io/spring-security/site/docs/5.6.2/api/org/springframework/security/oauth2/client/web/reactive/function/client/ServletOAuth2AuthorizedClientExchangeFilterFunction.html)不同，如果令牌过期，此筛选函数不尝试更新令牌。<br/>要获得此级别的支持，请使用OAuth2.0客户端筛选。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### `RestTemplate`支持
+
+目前还没有`RestTemplate`的`ServletBearerExchangeFilterFunction`等价物，但是你可以使用自己的拦截器非常简单地传播请求的承载令牌：
+
+Java
+
+```
+@Bean
+RestTemplate rest() {
+	RestTemplate rest = new RestTemplate();
+	rest.getInterceptors().add((request, body, execution) -> {
+		Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+		if (authentication == null) {
+			return execution.execute(request, body);
+		}
+
+		if (!(authentication.getCredentials() instanceof AbstractOAuth2Token)) {
+			return execution.execute(request, body);
+		}
+
+		AbstractOAuth2Token token = (AbstractOAuth2Token) authentication.getCredentials();
+	    request.getHeaders().setBearerAuth(token.getTokenValue());
+	    return execution.execute(request, body);
+	});
+	return rest;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun rest(): RestTemplate {
+    val rest = RestTemplate()
+    rest.interceptors.add(ClientHttpRequestInterceptor { request, body, execution ->
+        val authentication: Authentication? = SecurityContextHolder.getContext().authentication
+        if (authentication != null) {
+            execution.execute(request, body)
+        }
+
+        if (authentication!!.credentials !is AbstractOAuth2Token) {
+            execution.execute(request, body)
+        }
+
+        val token: AbstractOAuth2Token = authentication.credentials as AbstractOAuth2Token
+        request.headers.setBearerAuth(token.tokenValue)
+        execution.execute(request, body)
+    })
+    return rest
+}
+```
+
+|   |与[OAuth2.0授权客户经理](https://docs.spring.io/spring-security/site/docs/5.6.2/api/org/springframework/security/oauth2/client/OAuth2AuthorizedClientManager.html)不同的是，如果令牌过期，这个过滤器拦截器不会尝试更新令牌。<br/>要获得这种级别的支持，请使用[OAuth2.0授权客户经理](../client/index.html#oauth2client)创建一个拦截器。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## 承载令牌失败
+
+不记名令牌可能由于多种原因而无效。例如，令牌可能不再是活动的。
+
+在这种情况下，资源服务器抛出一个`InvalidBearerTokenException`。与其他异常一样，这会导致一个OAuth2.0承载令牌错误响应：
+
+```
+HTTP/1.1 401 Unauthorized
+WWW-Authenticate: Bearer error_code="invalid_token", error_description="Unsupported algorithm of none", error_uri="https://tools.ietf.org/html/rfc6750#section-3.1"
+```
+
+此外，它以`AuthenticationFailureBadCredentialsEvent`的形式发布，你可以像这样[在你的应用程序中监听](../../authentication/events.html#servlet-events):
+
+Java
+
+```
+@Component
+public class FailureEvents {
+	@EventListener
+    public void onFailure(AuthenticationFailureBadCredentialsEvent badCredentials) {
+		if (badCredentials.getAuthentication() instanceof BearerTokenAuthenticationToken) {
+		    // ... handle
+        }
+    }
+}
+```
+
+Kotlin
+
+```
+@Component
+class FailureEvents {
+    @EventListener
+    fun onFailure(badCredentials: AuthenticationFailureBadCredentialsEvent) {
+        if (badCredentials.authentication is BearerTokenAuthenticationToken) {
+            // ... handle
+        }
+    }
+}
+```
+
+[多租约](multitenancy.html)[SAML2](../../saml2/index.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-oauth2-resource-server-jwt.md b/docs/spring-security/servlet-oauth2-resource-server-jwt.md
new file mode 100644
index 0000000..04a0a72
--- /dev/null
+++ b/docs/spring-security/servlet-oauth2-resource-server-jwt.md
@@ -0,0 +1,1280 @@
+# OAuth2.0资源服务器JWT
+
+## JWT的最小依赖项
+
+大多数资源服务器支持被收集到`spring-security-oauth2-resource-server`中。然而，对JWTS的解码和验证的支持是`spring-security-oauth2-jose`，这意味着这两个都是必要的，以便拥有一个支持JWT编码的承载令牌的工作资源服务器。
+
+## JWTS的最小配置
+
+当使用[Spring Boot](https://spring.io/projects/spring-boot)时，将应用程序配置为资源服务器包括两个基本步骤。首先，包括所需的依赖关系，其次，指示授权服务器的位置。
+
+### 指定授权服务器
+
+在 Spring 引导应用程序中，要指定使用哪个授权服务器，只需执行以下操作：
+
+```
+spring:
+  security:
+    oauth2:
+      resourceserver:
+        jwt:
+          issuer-uri: https://idp.example.com/issuer
+```
+
+其中`[https://idp.example.com/issuer](https://idp.example.com/issuer)`是授权服务器将发布的JWT令牌的`iss`声明中包含的值。Resource Server将使用此属性进一步自我配置，发现授权服务器的公钥，并随后验证传入的JWTS。
+
+|   |要使用`issuer-uri`属性，还必须证明`[https://idp.example.com/issuer/.well-known/openid-configuration](https://idp.example.com/issuer/.well-known/openid-configuration)`、`[https://idp.example.com/.well-known/openid-configuration/issuer](https://idp.example.com/.well-known/openid-configuration/issuer)`或`[https://idp.example.com/.well-known/oauth-authorization-server/issuer](https://idp.example.com/.well-known/oauth-authorization-server/issuer)`中的一个是授权服务器所支持的端点。<br/>此端点被称为[提供者配置](https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderConfig)端点或[授权服务器元数据](https://tools.ietf.org/html/rfc8414#section-3)端点。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+就这样！
+
+### 创业期望
+
+当使用此属性和这些依赖项时，Resource Server将自动配置自身以验证JWT编码的承载令牌。
+
+它通过一个确定性的启动过程来实现这一点：
+
+1. 查询`jwks_url`属性的提供者配置或授权服务器元数据端点
+
+2. 查询`jwks_url`端点以获得支持的算法
+
+3. 将验证策略配置为查询`jwks_url`中找到的算法的有效公钥
+
+4. 将验证策略配置为针对`[https://idp.example.com](https://idp.example.com)`的每个JWTS`iss`索赔进行验证。
+
+此过程的结果是，为了使资源服务器成功启动，授权服务器必须启动并接收请求。
+
+|   |如果在资源服务器查询时，授权服务器处于关闭状态（给定适当的超时），那么启动将失败。|
+|---|-------------------------------------------------------------------------------------------------------------------------|
+
+### 运行时期望
+
+一旦启动应用程序，Resource Server将尝试处理任何包含`Authorization: Bearer`报头的请求：
+
+```
+GET / HTTP/1.1
+Authorization: Bearer some-token-value # Resource Server will process this
+```
+
+只要表明了该方案，资源服务器就会尝试根据承载令牌规范来处理请求。
+
+给定一个格式良好的JWT，资源服务器将：
+
+1. 根据在启动过程中从`jwks_url`端点获得并与JWT匹配的公钥验证其签名
+
+2. 验证JWT的`exp`和`nbf`时间戳以及JWT的`iss`声明，并
+
+3. 将每个作用域映射到一个前缀`SCOPE_`的权限。
+
+|   |由于授权服务器提供了可用的新密钥， Spring 安全性将自动旋转用于验证JWTS的密钥。|
+|---|-------------------------------------------------------------------------------------------------------------------------------|
+
+默认情况下，生成的`Authentication#getPrincipal`是 Spring security`Jwt`对象，并且`Authentication#getName`映射到JWT的`sub`属性（如果存在）。
+
+从这里开始，考虑跳到：
+
+* [JWT身份验证的工作方式](#oauth2resourceserver-jwt-architecture)
+
+* [如何在不将资源服务器启动与授权服务器的可用性绑定的情况下进行配置](#oauth2resourceserver-jwt-jwkseturi)
+
+* [How to Configure without Spring Boot](#oauth2resourceserver-jwt-sansboot)
+
+## JWT身份验证的工作方式
+
+接下来，让我们看看 Spring Security在基于 Servlet 的应用程序中支持[JWT](https://tools.ietf.org/html/rfc7519)身份验证所使用的体系结构组件，就像我们刚才看到的那样。
+
+[`JwtAuthenticationProvider`]（https://DOCS. Spring.io/ Spring-security/site/DOCS/5.6.2/api/org/springframework/security/oauth2/server/resource/authentication/jwtauthenticationprovider.html）是一个[`AuthenticationProvider`]（../.../././////认证/architectification/architecture.html# Servlet-authentification-authenticationprovider）实现，它利用了一个[<`JwtDecoder`]（#oaut
+
+让我们来看看`JwtAuthenticationProvider`在 Spring 安全性中是如何工作的。该图详细说明了`AuthenticationManager`]（.../../authentication/architecture.html# Servlet-authentication-authenticationmanager）在[读取不记名令牌](#oauth2resourceserver-authentication-bearertokenauthenticationfilter)中的工作原理。
+
+![JWTAutHenticationProvider](https://docs.spring.io/spring-security/reference/_images/servlet/oauth2/jwtauthenticationprovider.png)
+
+图1. `JwtAuthenticationProvider`用法
+
+![number 1](https://docs.spring.io/spring-security/reference/_images/icons/number_1.png)来自[读取不记名令牌](#oauth2resourceserver-authentication-bearertokenauthenticationfilter)的身份验证`Filter`将一个`BearerTokenAuthenticationToken`传递到`AuthenticationManager`，这是由[`ProviderManager`]（.../../authentication/architecture.html# Servlet-authentication-providermanager）实现的。
+
+![number 2](https://docs.spring.io/spring-security/reference/_images/icons/number_2.png)`ProviderManager`被配置为使用[身份验证提供者](../../authentication/architecture.html#servlet-authentication-authenticationprovider)类型的`JwtAuthenticationProvider`。
+
+![number 3](https://docs.spring.io/spring-security/reference/_images/icons/number_3.png)`JwtAuthenticationProvider`使用[`JwtDecoder`]（#OAuth2Resourceserver-JWT-decoder）对`Jwt`进行解码、验证和验证。
+
+![number 4](https://docs.spring.io/spring-security/reference/_images/icons/number_4.png)`JwtAuthenticationProvider`然后使用[`JwtAuthenticationConverter`]（#OAuth2Resourceserver-JWT-Authorization-Extraction）将`Jwt`转换为授予权限的`Collection`。
+
+![number 5](https://docs.spring.io/spring-security/reference/_images/icons/number_5.png)当身份验证成功时，返回的[`Authentication`]（.../../authentication/architecture.html# Servlet-authentication-authentication）类型为`JwtAuthenticationToken`，并且具有一个主体，即由配置的`JwtDecoder`返回的`Jwt`。最终，返回的`JwtAuthenticationToken`将由身份验证`Filter`设置在[`SecurityContextHolder`]（.../authentication/architecture.html# Servlet-authentication-securitycontextholder）上。
+
+## 直接指定授权服务器JWK设置的URI
+
+如果授权服务器不支持任何配置端点，或者如果资源服务器必须能够独立于授权服务器启动，那么也可以提供`jwk-set-uri`:
+
+```
+spring:
+  security:
+    oauth2:
+      resourceserver:
+        jwt:
+          issuer-uri: https://idp.example.com
+          jwk-set-uri: https://idp.example.com/.well-known/jwks.json
+```
+
+|   |JWK集URI不是标准化的，但通常可以在授权服务器的文档中找到。|
+|---|-----------------------------------------------------------------------------------------------------------|
+
+因此，资源服务器不会在启动时对授权服务器进行ping。我们仍然指定`issuer-uri`，以便Resource Server仍然在传入的JWTS上验证`iss`声明。
+
+|   |也可以在[DSL](#oauth2resourceserver-jwt-jwkseturi-dsl)上直接提供此属性。|
+|---|--------------------------------------------------------------------------------------------------|
+
+## 覆盖或替换Boot Auto配置
+
+有两个`@Bean`s， Spring boot代表资源服务器生成。
+
+第一个是将应用程序配置为资源服务器的`WebSecurityConfigurerAdapter`。当包含`spring-security-oauth2-jose`时，这个`WebSecurityConfigurerAdapter`看起来是这样的：
+
+例1.默认的JWT配置
+
+Java
+
+```
+protected void configure(HttpSecurity http) {
+    http
+        .authorizeHttpRequests(authorize -> authorize
+            .anyRequest().authenticated()
+        )
+        .oauth2ResourceServer(OAuth2ResourceServerConfigurer::jwt);
+}
+```
+
+Kotlin
+
+```
+fun configure(http: HttpSecurity) {
+    http {
+        authorizeRequests {
+            authorize(anyRequest, authenticated)
+        }
+        oauth2ResourceServer {
+            jwt { }
+        }
+    }
+}
+```
+
+如果应用程序不公开`WebSecurityConfigurerAdapter` Bean，那么 Spring 引导将公开上面的默认引导。
+
+替换它就像在应用程序中公开 Bean 一样简单：
+
+例2.自定义JWT配置
+
+Java
+
+```
+@EnableWebSecurity
+public class MyCustomSecurityConfiguration extends WebSecurityConfigurerAdapter {
+    protected void configure(HttpSecurity http) {
+        http
+            .authorizeHttpRequests(authorize -> authorize
+                .mvcMatchers("/messages/**").hasAuthority("SCOPE_message:read")
+                .anyRequest().authenticated()
+            )
+            .oauth2ResourceServer(oauth2 -> oauth2
+                .jwt(jwt -> jwt
+                    .jwtAuthenticationConverter(myConverter())
+                )
+            );
+    }
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class MyCustomSecurityConfiguration : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            authorizeRequests {
+                authorize("/messages/**", hasAuthority("SCOPE_message:read"))
+                authorize(anyRequest, authenticated)
+            }
+            oauth2ResourceServer {
+                jwt {
+                    jwtAuthenticationConverter = myConverter()
+                }
+            }
+        }
+    }
+}
+```
+
+对于任何以`/messages/`开头的URL，上面要求`message:read`的范围。
+
+`oauth2ResourceServer`DSL上的方法也将覆盖或替换自动配置。
+
+例如，第二个`@Bean` Spring 引导创建了一个`JwtDecoder`，它[将`String`令牌解码为`Jwt`的验证实例]（#OAuth2Resourceserver-jwt-architecture-jwtdecoder）：
+
+例3. JWT解码器
+
+Java
+
+```
+@Bean
+public JwtDecoder jwtDecoder() {
+    return JwtDecoders.fromIssuerLocation(issuerUri);
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(): JwtDecoder {
+    return JwtDecoders.fromIssuerLocation(issuerUri)
+}
+```
+
+|   |调用`[JwtDecoders#fromIssuerLocation](https://docs.spring.io/spring-security/site/docs/5.6.2/api/org/springframework/security/oauth2/jwt/JwtDecoders.html#fromIssuerLocation-java.lang.String-)`是调用提供程序配置或授权服务器元数据端点以派生JWK集URI的目的。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+如果应用程序不公开`JwtDecoder` Bean，那么 Spring 引导将公开上面的默认引导。
+
+并且其配置可以使用`jwkSetUri()`重写或使用`decoder()`替换。
+
+或者，如果根本不使用 Spring boot，那么这两个组件--过滤器链和`JwtDecoder`都可以用XML指定。
+
+过滤链是这样指定的：
+
+例4.默认的JWT配置
+
+XML
+
+```
+<http>
+    <intercept-uri pattern="/**" access="authenticated"/>
+    <oauth2-resource-server>
+        <jwt decoder-ref="jwtDecoder"/>
+    </oauth2-resource-server>
+</http>
+```
+
+而`JwtDecoder`就像这样：
+
+例5. JWT解码器
+
+XML
+
+```
+<bean id="jwtDecoder"
+        class="org.springframework.security.oauth2.jwt.JwtDecoders"
+        factory-method="fromIssuerLocation">
+    <constructor-arg value="${spring.security.oauth2.resourceserver.jwt.jwk-set-uri}"/>
+</bean>
+```
+
+### `
+
+可以配置授权服务器的JWK集URI[作为配置属性](#oauth2resourceserver-jwt-jwkseturi)，也可以在DSL中提供它：
+
+例6. JWK设置URI配置
+
+Java
+
+```
+@EnableWebSecurity
+public class DirectlyConfiguredJwkSetUri extends WebSecurityConfigurerAdapter {
+    protected void configure(HttpSecurity http) {
+        http
+            .authorizeHttpRequests(authorize -> authorize
+                .anyRequest().authenticated()
+            )
+            .oauth2ResourceServer(oauth2 -> oauth2
+                .jwt(jwt -> jwt
+                    .jwkSetUri("https://idp.example.com/.well-known/jwks.json")
+                )
+            );
+    }
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class DirectlyConfiguredJwkSetUri : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            authorizeRequests {
+                authorize(anyRequest, authenticated)
+            }
+            oauth2ResourceServer {
+                jwt {
+                    jwkSetUri = "https://idp.example.com/.well-known/jwks.json"
+                }
+            }
+        }
+    }
+}
+```
+
+XML
+
+```
+<http>
+    <intercept-uri pattern="/**" access="authenticated"/>
+    <oauth2-resource-server>
+        <jwt jwk-set-uri="https://idp.example.com/.well-known/jwks.json"/>
+    </oauth2-resource-server>
+</http>
+```
+
+使用`jwkSetUri()`优先于任何配置属性。
+
+### `
+
+比`jwkSetUri()`更强大的是`decoder()`，它将完全取代[`JwtDecoder`]（#OAuth2Resourceserver-jwt-architecture-jwtdecoder）的任何引导自动配置：
+
+例7. JWT解码器配置
+
+Java
+
+```
+@EnableWebSecurity
+public class DirectlyConfiguredJwtDecoder extends WebSecurityConfigurerAdapter {
+    protected void configure(HttpSecurity http) {
+        http
+            .authorizeHttpRequests(authorize -> authorize
+                .anyRequest().authenticated()
+            )
+            .oauth2ResourceServer(oauth2 -> oauth2
+                .jwt(jwt -> jwt
+                    .decoder(myCustomDecoder())
+                )
+            );
+    }
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class DirectlyConfiguredJwtDecoder : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            authorizeRequests {
+                authorize(anyRequest, authenticated)
+            }
+            oauth2ResourceServer {
+                jwt {
+                    jwtDecoder = myCustomDecoder()
+                }
+            }
+        }
+    }
+}
+```
+
+XML
+
+```
+<http>
+    <intercept-uri pattern="/**" access="authenticated"/>
+    <oauth2-resource-server>
+        <jwt decoder-ref="myCustomDecoder"/>
+    </oauth2-resource-server>
+</http>
+```
+
+当需要更深的配置时，比如[validation](#oauth2resourceserver-jwt-validation)、[mapping](#oauth2resourceserver-jwt-claimsetmapping)或[请求超时](#oauth2resourceserver-jwt-timeouts)，这是很方便的。
+
+### 曝光`JwtDecoder``@Bean`
+
+或者，暴露[`JwtDecoder`]（#OAuth2Resourceserver-JWT-Architecture-JWTDecoder）`@Bean`具有与`decoder()`相同的效果：
+
+Java
+
+```
+@Bean
+public JwtDecoder jwtDecoder() {
+    return NimbusJwtDecoder.withJwkSetUri(jwkSetUri).build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(): JwtDecoder {
+    return NimbusJwtDecoder.withJwkSetUri(jwkSetUri).build()
+}
+```
+
+## 配置可信算法
+
+默认情况下，`NimbusJwtDecoder`以及资源服务器将仅使用`RS256`信任和验证令牌。
+
+你可以通过[Spring Boot](#oauth2resourceserver-jwt-boot-algorithm)、[NimbusJWTDecoder Builder](#oauth2resourceserver-jwt-decoder-builder)或从[JWK SET响应](#oauth2resourceserver-jwt-decoder-jwk-response)进行自定义。
+
+### 通过 Spring 引导
+
+设置算法的最简单方法是作为一个属性：
+
+```
+spring:
+  security:
+    oauth2:
+      resourceserver:
+        jwt:
+          jws-algorithm: RS512
+          jwk-set-uri: https://idp.example.org/.well-known/jwks.json
+```
+
+### 使用构建器
+
+不过，要获得更大的功率，我们可以使用带有`NimbusJwtDecoder`的建造器：
+
+Java
+
+```
+@Bean
+JwtDecoder jwtDecoder() {
+    return NimbusJwtDecoder.withJwkSetUri(this.jwkSetUri)
+            .jwsAlgorithm(RS512).build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(): JwtDecoder {
+    return NimbusJwtDecoder.withJwkSetUri(this.jwkSetUri)
+            .jwsAlgorithm(RS512).build()
+}
+```
+
+多次调用`jwsAlgorithm`将配置`NimbusJwtDecoder`来信任多个算法，如下所示：
+
+Java
+
+```
+@Bean
+JwtDecoder jwtDecoder() {
+    return NimbusJwtDecoder.withJwkSetUri(this.jwkSetUri)
+            .jwsAlgorithm(RS512).jwsAlgorithm(ES512).build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(): JwtDecoder {
+    return NimbusJwtDecoder.withJwkSetUri(this.jwkSetUri)
+            .jwsAlgorithm(RS512).jwsAlgorithm(ES512).build()
+}
+```
+
+或者，你可以调用`jwsAlgorithms`:
+
+Java
+
+```
+@Bean
+JwtDecoder jwtDecoder() {
+    return NimbusJwtDecoder.withJwkSetUri(this.jwkSetUri)
+            .jwsAlgorithms(algorithms -> {
+                    algorithms.add(RS512);
+                    algorithms.add(ES512);
+            }).build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(): JwtDecoder {
+    return NimbusJwtDecoder.withJwkSetUri(this.jwkSetUri)
+            .jwsAlgorithms {
+                it.add(RS512)
+                it.add(ES512)
+            }.build()
+}
+```
+
+### 来自JWK SET响应
+
+Spring 由于Security的JWT支持是基于Nimbus的，所以你也可以使用它的所有优秀功能。
+
+例如，Nimbus有一个`JWSKeySelector`实现，该实现将基于JWK设置的URI响应来选择一组算法。你可以使用它生成`NimbusJwtDecoder`，如下所示：
+
+Java
+
+```
+@Bean
+public JwtDecoder jwtDecoder() {
+    // makes a request to the JWK Set endpoint
+    JWSKeySelector<SecurityContext> jwsKeySelector =
+            JWSAlgorithmFamilyJWSKeySelector.fromJWKSetURL(this.jwkSetUrl);
+
+    DefaultJWTProcessor<SecurityContext> jwtProcessor =
+            new DefaultJWTProcessor<>();
+    jwtProcessor.setJWSKeySelector(jwsKeySelector);
+
+    return new NimbusJwtDecoder(jwtProcessor);
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(): JwtDecoder {
+    // makes a request to the JWK Set endpoint
+    val jwsKeySelector: JWSKeySelector<SecurityContext> = JWSAlgorithmFamilyJWSKeySelector.fromJWKSetURL<SecurityContext>(this.jwkSetUrl)
+    val jwtProcessor: DefaultJWTProcessor<SecurityContext> = DefaultJWTProcessor()
+    jwtProcessor.jwsKeySelector = jwsKeySelector
+    return NimbusJwtDecoder(jwtProcessor)
+}
+```
+
+## 信任单一的非对称密钥
+
+比支持具有JWK设置端点的资源服务器更简单的方法是对RSA公钥进行硬编码。公钥可以通过[Spring Boot](#oauth2resourceserver-jwt-decoder-public-key-boot)或[使用构建器](#oauth2resourceserver-jwt-decoder-public-key-builder)提供。
+
+### 通过 Spring 引导
+
+通过 Spring 引导指定一个键非常简单。密钥的位置可以这样指定：
+
+```
+spring:
+  security:
+    oauth2:
+      resourceserver:
+        jwt:
+          public-key-location: classpath:my-key.pub
+```
+
+或者，为了允许更复杂的查找，你可以对`RsaKeyConversionServicePostProcessor`进行后处理：
+
+Java
+
+```
+@Bean
+BeanFactoryPostProcessor conversionServiceCustomizer() {
+    return beanFactory ->
+        beanFactory.getBean(RsaKeyConversionServicePostProcessor.class)
+                .setResourceLoader(new CustomResourceLoader());
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun conversionServiceCustomizer(): BeanFactoryPostProcessor {
+    return BeanFactoryPostProcessor { beanFactory ->
+        beanFactory.getBean<RsaKeyConversionServicePostProcessor>()
+                .setResourceLoader(CustomResourceLoader())
+    }
+}
+```
+
+指定你的密钥的位置：
+
+```
+key.location: hfds://my-key.pub
+```
+
+然后自动连接该值：
+
+Java
+
+```
+@Value("${key.location}")
+RSAPublicKey key;
+```
+
+Kotlin
+
+```
+@Value("\${key.location}")
+val key: RSAPublicKey? = null
+```
+
+### 使用构建器
+
+要直接连接`RSAPublicKey`，只需使用适当的`NimbusJwtDecoder`构建器，如下所示：
+
+Java
+
+```
+@Bean
+public JwtDecoder jwtDecoder() {
+    return NimbusJwtDecoder.withPublicKey(this.key).build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(): JwtDecoder {
+    return NimbusJwtDecoder.withPublicKey(this.key).build()
+}
+```
+
+## 信任单一的对称密钥
+
+使用单一的对称密钥也很简单。你可以简单地在`SecretKey`中加载，并使用适当的`NimbusJwtDecoder`构建器，如下所示：
+
+Java
+
+```
+@Bean
+public JwtDecoder jwtDecoder() {
+    return NimbusJwtDecoder.withSecretKey(this.key).build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(): JwtDecoder {
+    return NimbusJwtDecoder.withSecretKey(key).build()
+}
+```
+
+## 配置授权
+
+从OAuth2.0授权服务器发出的JWT通常具有`scope`或`scp`属性，指示已授予的范围（或权限），例如：
+
+`{ …​, "scope" : "messages contacts"}`
+
+在这种情况下，Resource Server将尝试强制将这些作用域放入一个已授予权限的列表中，并在每个作用域前加上字符串“scope\_”。
+
+这意味着，要使用从JWT派生的作用域来保护端点或方法，相应的表达式应该包括以下前缀：
+
+例8.授权配置
+
+Java
+
+```
+@EnableWebSecurity
+public class DirectlyConfiguredJwkSetUri extends WebSecurityConfigurerAdapter {
+    protected void configure(HttpSecurity http) {
+        http
+            .authorizeHttpRequests(authorize -> authorize
+                .mvcMatchers("/contacts/**").hasAuthority("SCOPE_contacts")
+                .mvcMatchers("/messages/**").hasAuthority("SCOPE_messages")
+                .anyRequest().authenticated()
+            )
+            .oauth2ResourceServer(OAuth2ResourceServerConfigurer::jwt);
+    }
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class DirectlyConfiguredJwkSetUri : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            authorizeRequests {
+                authorize("/contacts/**", hasAuthority("SCOPE_contacts"))
+                authorize("/messages/**", hasAuthority("SCOPE_messages"))
+                authorize(anyRequest, authenticated)
+            }
+            oauth2ResourceServer {
+                jwt { }
+            }
+        }
+    }
+}
+```
+
+XML
+
+```
+<http>
+    <intercept-uri pattern="/contacts/**" access="hasAuthority('SCOPE_contacts')"/>
+    <intercept-uri pattern="/messages/**" access="hasAuthority('SCOPE_messages')"/>
+    <oauth2-resource-server>
+        <jwt jwk-set-uri="https://idp.example.org/.well-known/jwks.json"/>
+    </oauth2-resource-server>
+</http>
+```
+
+或类似于方法安全性：
+
+Java
+
+```
+@PreAuthorize("hasAuthority('SCOPE_messages')")
+public List<Message> getMessages(...) {}
+```
+
+Kotlin
+
+```
+@PreAuthorize("hasAuthority('SCOPE_messages')")
+fun getMessages(): List<Message> { }
+```
+
+### 手动提取权限
+
+然而，在许多情况下，这种默认设置是不够的。例如，一些授权服务器不使用`scope`属性，而是具有自己的自定义属性。或者，在其他时候，资源服务器可能需要将属性或属性的组合调整为内在化的权限。
+
+为此， Spring Security附带`JwtAuthenticationConverter`，它负责[将`Jwt`转换为`Authentication`]（#OAuth2Resourceserver-JWT-Architecture-JWTAutoThenticationConverter）。默认情况下， Spring 安全性将用`JwtAuthenticationProvider`的默认实例连接`JwtAuthenticationConverter`。
+
+作为配置`JwtAuthenticationConverter`的一部分，你可以提供一个附属转换器，将其从`Jwt`转换为授予权限的`Collection`。
+
+假设你的授权服务器在一个名为`authorities`的自定义声明中与权威机构通信。在这种情况下，你可以配置[`JwtAuthenticationConverter`]（#OAuth2ResourceServer-JWT-Architecture-JWTAutoThenticationConverter）应该检查的声明，如下所示：
+
+例9.当局声称配置
+
+Java
+
+```
+@Bean
+public JwtAuthenticationConverter jwtAuthenticationConverter() {
+    JwtGrantedAuthoritiesConverter grantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
+    grantedAuthoritiesConverter.setAuthoritiesClaimName("authorities");
+
+    JwtAuthenticationConverter jwtAuthenticationConverter = new JwtAuthenticationConverter();
+    jwtAuthenticationConverter.setJwtGrantedAuthoritiesConverter(grantedAuthoritiesConverter);
+    return jwtAuthenticationConverter;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtAuthenticationConverter(): JwtAuthenticationConverter {
+    val grantedAuthoritiesConverter = JwtGrantedAuthoritiesConverter()
+    grantedAuthoritiesConverter.setAuthoritiesClaimName("authorities")
+
+    val jwtAuthenticationConverter = JwtAuthenticationConverter()
+    jwtAuthenticationConverter.setJwtGrantedAuthoritiesConverter(grantedAuthoritiesConverter)
+    return jwtAuthenticationConverter
+}
+```
+
+XML
+
+```
+<http>
+    <intercept-uri pattern="/contacts/**" access="hasAuthority('SCOPE_contacts')"/>
+    <intercept-uri pattern="/messages/**" access="hasAuthority('SCOPE_messages')"/>
+    <oauth2-resource-server>
+        <jwt jwk-set-uri="https://idp.example.org/.well-known/jwks.json"
+                jwt-authentication-converter-ref="jwtAuthenticationConverter"/>
+    </oauth2-resource-server>
+</http>
+
+<bean id="jwtAuthenticationConverter"
+        class="org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationConverter">
+    <property name="jwtGrantedAuthoritiesConverter" ref="jwtGrantedAuthoritiesConverter"/>
+</bean>
+
+<bean id="jwtGrantedAuthoritiesConverter"
+        class="org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter">
+    <property name="authoritiesClaimName" value="authorities"/>
+</bean>
+```
+
+你也可以将权限前缀配置为不同的。你可以将它更改为`ROLE_`，而不是在每个权限前加上`SCOPE_`，就像这样：
+
+例10.权限前缀配置
+
+Java
+
+```
+@Bean
+public JwtAuthenticationConverter jwtAuthenticationConverter() {
+    JwtGrantedAuthoritiesConverter grantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
+    grantedAuthoritiesConverter.setAuthorityPrefix("ROLE_");
+
+    JwtAuthenticationConverter jwtAuthenticationConverter = new JwtAuthenticationConverter();
+    jwtAuthenticationConverter.setJwtGrantedAuthoritiesConverter(grantedAuthoritiesConverter);
+    return jwtAuthenticationConverter;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtAuthenticationConverter(): JwtAuthenticationConverter {
+    val grantedAuthoritiesConverter = JwtGrantedAuthoritiesConverter()
+    grantedAuthoritiesConverter.setAuthorityPrefix("ROLE_")
+
+    val jwtAuthenticationConverter = JwtAuthenticationConverter()
+    jwtAuthenticationConverter.setJwtGrantedAuthoritiesConverter(grantedAuthoritiesConverter)
+    return jwtAuthenticationConverter
+}
+```
+
+XML
+
+```
+<http>
+    <intercept-uri pattern="/contacts/**" access="hasAuthority('SCOPE_contacts')"/>
+    <intercept-uri pattern="/messages/**" access="hasAuthority('SCOPE_messages')"/>
+    <oauth2-resource-server>
+        <jwt jwk-set-uri="https://idp.example.org/.well-known/jwks.json"
+                jwt-authentication-converter-ref="jwtAuthenticationConverter"/>
+    </oauth2-resource-server>
+</http>
+
+<bean id="jwtAuthenticationConverter"
+        class="org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationConverter">
+    <property name="jwtGrantedAuthoritiesConverter" ref="jwtGrantedAuthoritiesConverter"/>
+</bean>
+
+<bean id="jwtGrantedAuthoritiesConverter"
+        class="org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter">
+    <property name="authorityPrefix" value="ROLE_"/>
+</bean>
+```
+
+或者，你可以通过调用`JwtGrantedAuthoritiesConverter#setAuthorityPrefix("")`来完全删除前缀。
+
+为了具有更大的灵活性，DSL支持用实现`Converter<Jwt, AbstractAuthenticationToken>`的任何类完全替换转换器：
+
+Java
+
+```
+static class CustomAuthenticationConverter implements Converter<Jwt, AbstractAuthenticationToken> {
+    public AbstractAuthenticationToken convert(Jwt jwt) {
+        return new CustomAuthenticationToken(jwt);
+    }
+}
+
+// ...
+
+@EnableWebSecurity
+public class CustomAuthenticationConverterConfig extends WebSecurityConfigurerAdapter {
+    protected void configure(HttpSecurity http) {
+        http
+            .authorizeHttpRequests(authorize -> authorize
+                .anyRequest().authenticated()
+            )
+            .oauth2ResourceServer(oauth2 -> oauth2
+                .jwt(jwt -> jwt
+                    .jwtAuthenticationConverter(new CustomAuthenticationConverter())
+                )
+            );
+    }
+}
+```
+
+Kotlin
+
+```
+internal class CustomAuthenticationConverter : Converter<Jwt, AbstractAuthenticationToken> {
+    override fun convert(jwt: Jwt): AbstractAuthenticationToken {
+        return CustomAuthenticationToken(jwt)
+    }
+}
+
+// ...
+
+@EnableWebSecurity
+class CustomAuthenticationConverterConfig : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+       http {
+            authorizeRequests {
+                authorize(anyRequest, authenticated)
+            }
+           oauth2ResourceServer {
+               jwt {
+                   jwtAuthenticationConverter = CustomAuthenticationConverter()
+               }
+           }
+        }
+    }
+}
+```
+
+## 配置验证
+
+使用[minimal Spring Boot configuration](#oauth2resourceserver-jwt-minimalconfiguration)（表示授权服务器的发行者URI），Resource Server将默认验证`iss`声明以及`exp`和`nbf`时间戳声明。
+
+在需要定制验证的情况下，Resource Server附带两个标准验证器，并且还接受定制的`OAuth2TokenValidator`实例。
+
+### 自定义时间戳验证
+
+JWT通常有一个有效窗口，窗口的开始在`nbf`索赔中指示，结束在`exp`索赔中指示。
+
+然而，每个服务器都可能经历时钟漂移，这可能导致令牌在一台服务器上出现过期，而不是在另一台服务器上出现。随着分布式系统中协作服务器数量的增加，这可能会导致一些实现令人心烦。
+
+Resource Server使用`JwtTimestampValidator`来验证令牌的有效性窗口，并且可以将其配置为`clockSkew`以缓解上述问题：
+
+Java
+
+```
+@Bean
+JwtDecoder jwtDecoder() {
+     NimbusJwtDecoder jwtDecoder = (NimbusJwtDecoder)
+             JwtDecoders.fromIssuerLocation(issuerUri);
+
+     OAuth2TokenValidator<Jwt> withClockSkew = new DelegatingOAuth2TokenValidator<>(
+            new JwtTimestampValidator(Duration.ofSeconds(60)),
+            new JwtIssuerValidator(issuerUri));
+
+     jwtDecoder.setJwtValidator(withClockSkew);
+
+     return jwtDecoder;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(): JwtDecoder {
+    val jwtDecoder: NimbusJwtDecoder = JwtDecoders.fromIssuerLocation(issuerUri) as NimbusJwtDecoder
+
+    val withClockSkew: OAuth2TokenValidator<Jwt> = DelegatingOAuth2TokenValidator(
+            JwtTimestampValidator(Duration.ofSeconds(60)),
+            JwtIssuerValidator(issuerUri))
+
+    jwtDecoder.setJwtValidator(withClockSkew)
+
+    return jwtDecoder
+}
+```
+
+|   |默认情况下，Resource Server配置的时钟偏差为60秒。|
+|---|------------------------------------------------------------------|
+
+### 配置自定义验证器
+
+使用`OAuth2TokenValidator`API添加`aud`声明的检查很简单：
+
+Java
+
+```
+OAuth2TokenValidator<Jwt> audienceValidator() {
+    return new JwtClaimValidator<List<String>>(AUD, aud -> aud.contains("messaging"));
+}
+```
+
+Kotlin
+
+```
+fun audienceValidator(): OAuth2TokenValidator<Jwt?> {
+    return JwtClaimValidator<List<String>>(AUD) { aud -> aud.contains("messaging") }
+}
+```
+
+或者，为了获得更多的控制，你可以实现自己的`OAuth2TokenValidator`:
+
+Java
+
+```
+static class AudienceValidator implements OAuth2TokenValidator<Jwt> {
+    OAuth2Error error = new OAuth2Error("custom_code", "Custom error message", null);
+
+    @Override
+    public OAuth2TokenValidatorResult validate(Jwt jwt) {
+        if (jwt.getAudience().contains("messaging")) {
+            return OAuth2TokenValidatorResult.success();
+        } else {
+            return OAuth2TokenValidatorResult.failure(error);
+        }
+    }
+}
+
+// ...
+
+OAuth2TokenValidator<Jwt> audienceValidator() {
+    return new AudienceValidator();
+}
+```
+
+Kotlin
+
+```
+internal class AudienceValidator : OAuth2TokenValidator<Jwt> {
+    var error: OAuth2Error = OAuth2Error("custom_code", "Custom error message", null)
+
+    override fun validate(jwt: Jwt): OAuth2TokenValidatorResult {
+        return if (jwt.audience.contains("messaging")) {
+            OAuth2TokenValidatorResult.success()
+        } else {
+            OAuth2TokenValidatorResult.failure(error)
+        }
+    }
+}
+
+// ...
+
+fun audienceValidator(): OAuth2TokenValidator<Jwt> {
+    return AudienceValidator()
+}
+```
+
+然后，要添加到资源服务器中，需要指定[`JwtDecoder`]（#OAuth2Resourceserver-jwt-architecture-jwtdecoder）实例：
+
+Java
+
+```
+@Bean
+JwtDecoder jwtDecoder() {
+    NimbusJwtDecoder jwtDecoder = (NimbusJwtDecoder)
+        JwtDecoders.fromIssuerLocation(issuerUri);
+
+    OAuth2TokenValidator<Jwt> audienceValidator = audienceValidator();
+    OAuth2TokenValidator<Jwt> withIssuer = JwtValidators.createDefaultWithIssuer(issuerUri);
+    OAuth2TokenValidator<Jwt> withAudience = new DelegatingOAuth2TokenValidator<>(withIssuer, audienceValidator);
+
+    jwtDecoder.setJwtValidator(withAudience);
+
+    return jwtDecoder;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(): JwtDecoder {
+    val jwtDecoder: NimbusJwtDecoder = JwtDecoders.fromIssuerLocation(issuerUri) as NimbusJwtDecoder
+
+    val audienceValidator = audienceValidator()
+    val withIssuer: OAuth2TokenValidator<Jwt> = JwtValidators.createDefaultWithIssuer(issuerUri)
+    val withAudience: OAuth2TokenValidator<Jwt> = DelegatingOAuth2TokenValidator(withIssuer, audienceValidator)
+
+    jwtDecoder.setJwtValidator(withAudience)
+
+    return jwtDecoder
+}
+```
+
+## 配置索赔集映射
+
+Spring 安全性使用[Nimbus](https://bitbucket.org/connect2id/nimbus-jose-jwt/wiki/Home)库来解析JWTS并验证其签名。因此， Spring 安全性取决于Nimbus对每个字段值的解释以及如何将每个字段值强制为 Java 类型。
+
+例如，因为Nimbus保持 Java 7兼容，所以它不使用`Instant`来表示时间戳字段。
+
+而且完全有可能使用不同的库或用于JWT处理，这可能会做出自己的强制决策，需要进行调整。
+
+或者，非常简单地说，出于特定于域的原因，资源服务器可能希望从JWT中添加或删除声明。
+
+出于这些目的，Resource Server支持用`MappedJwtClaimSetConverter`映射JWT索赔集。
+
+### 定制单个索赔的转换
+
+默认情况下，`MappedJwtClaimSetConverter`将尝试强制将声明转换为以下类型：
+
+|Claim|Java 类型|
+|-----|--------------------|
+|`aud`|`Collection<String>`|
+|`exp`|`Instant`|
+|`iat`|`Instant`|
+|`iss`|`String`|
+|`jti`|`String`|
+|`nbf`|`Instant`|
+|`sub`|`String`|
+
+可以使用`MappedJwtClaimSetConverter.withDefaults`配置单个索赔的转换策略：
+
+Java
+
+```
+@Bean
+JwtDecoder jwtDecoder() {
+    NimbusJwtDecoder jwtDecoder = NimbusJwtDecoder.withJwkSetUri(jwkSetUri).build();
+
+    MappedJwtClaimSetConverter converter = MappedJwtClaimSetConverter
+            .withDefaults(Collections.singletonMap("sub", this::lookupUserIdBySub));
+    jwtDecoder.setClaimSetConverter(converter);
+
+    return jwtDecoder;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(): JwtDecoder {
+    val jwtDecoder = NimbusJwtDecoder.withJwkSetUri(jwkSetUri).build()
+
+    val converter = MappedJwtClaimSetConverter
+            .withDefaults(mapOf("sub" to this::lookupUserIdBySub))
+    jwtDecoder.setClaimSetConverter(converter)
+
+    return jwtDecoder
+}
+```
+
+这将保留所有的默认值，除了它将覆盖`sub`的默认索赔转换器。
+
+### 增加索赔
+
+`MappedJwtClaimSetConverter`还可以用于添加自定义声明，例如，用于适应现有系统：
+
+Java
+
+```
+MappedJwtClaimSetConverter.withDefaults(Collections.singletonMap("custom", custom -> "value"));
+```
+
+Kotlin
+
+```
+MappedJwtClaimSetConverter.withDefaults(mapOf("custom" to Converter<Any, String> { "value" }))
+```
+
+### 删除索赔
+
+删除声明也很简单，使用相同的API:
+
+Java
+
+```
+MappedJwtClaimSetConverter.withDefaults(Collections.singletonMap("legacyclaim", legacy -> null));
+```
+
+Kotlin
+
+```
+MappedJwtClaimSetConverter.withDefaults(mapOf("legacyclaim" to Converter<Any, Any> { null }))
+```
+
+### 重新命名索赔
+
+在更复杂的场景中，例如一次查询多个声明或重命名一个声明，Resource Server接受实现`Converter<Map<String, Object>, Map<String,Object>>`的任何类：
+
+Java
+
+```
+public class UsernameSubClaimAdapter implements Converter<Map<String, Object>, Map<String, Object>> {
+    private final MappedJwtClaimSetConverter delegate =
+            MappedJwtClaimSetConverter.withDefaults(Collections.emptyMap());
+
+    public Map<String, Object> convert(Map<String, Object> claims) {
+        Map<String, Object> convertedClaims = this.delegate.convert(claims);
+
+        String username = (String) convertedClaims.get("user_name");
+        convertedClaims.put("sub", username);
+
+        return convertedClaims;
+    }
+}
+```
+
+Kotlin
+
+```
+class UsernameSubClaimAdapter : Converter<Map<String, Any?>, Map<String, Any?>> {
+    private val delegate = MappedJwtClaimSetConverter.withDefaults(Collections.emptyMap())
+    override fun convert(claims: Map<String, Any?>): Map<String, Any?> {
+        val convertedClaims = delegate.convert(claims)
+        val username = convertedClaims["user_name"] as String
+        convertedClaims["sub"] = username
+        return convertedClaims
+    }
+}
+```
+
+然后，实例可以像正常情况一样提供：
+
+Java
+
+```
+@Bean
+JwtDecoder jwtDecoder() {
+    NimbusJwtDecoder jwtDecoder = NimbusJwtDecoder.withJwkSetUri(jwkSetUri).build();
+    jwtDecoder.setClaimSetConverter(new UsernameSubClaimAdapter());
+    return jwtDecoder;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(): JwtDecoder {
+    val jwtDecoder: NimbusJwtDecoder = NimbusJwtDecoder.withJwkSetUri(jwkSetUri).build()
+    jwtDecoder.setClaimSetConverter(UsernameSubClaimAdapter())
+    return jwtDecoder
+}
+```
+
+## 配置超时
+
+默认情况下，Resource Server使用30秒的连接和套接字超时来与授权服务器进行协调。
+
+在某些情况下，这可能太短了。此外，它没有考虑到更复杂的模式，比如后退和发现。
+
+要调整资源服务器连接到授权服务器的方式，`NimbusJwtDecoder`接受`RestOperations`的实例：
+
+Java
+
+```
+@Bean
+public JwtDecoder jwtDecoder(RestTemplateBuilder builder) {
+    RestOperations rest = builder
+            .setConnectTimeout(Duration.ofSeconds(60))
+            .setReadTimeout(Duration.ofSeconds(60))
+            .build();
+
+    NimbusJwtDecoder jwtDecoder = NimbusJwtDecoder.withJwkSetUri(jwkSetUri).restOperations(rest).build();
+    return jwtDecoder;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(builder: RestTemplateBuilder): JwtDecoder {
+    val rest: RestOperations = builder
+            .setConnectTimeout(Duration.ofSeconds(60))
+            .setReadTimeout(Duration.ofSeconds(60))
+            .build()
+    return NimbusJwtDecoder.withJwkSetUri(jwkSetUri).restOperations(rest).build()
+}
+```
+
+另外，默认情况下，Resource Server会在内存中缓存授权服务器的JWK设置5分钟，你可能需要对其进行调整。此外，它没有考虑更复杂的缓存模式，比如驱逐或使用共享缓存。
+
+要调整资源服务器缓存JWK集的方式，`NimbusJwtDecoder`接受`Cache`的实例：
+
+Java
+
+```
+@Bean
+public JwtDecoder jwtDecoder(CacheManager cacheManager) {
+    return NimbusJwtDecoder.withJwkSetUri(jwkSetUri)
+            .cache(cacheManager.getCache("jwks"))
+            .build();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(cacheManager: CacheManager): JwtDecoder {
+    return NimbusJwtDecoder.withJwkSetUri(jwkSetUri)
+            .cache(cacheManager.getCache("jwks"))
+            .build()
+}
+```
+
+当给定一个`Cache`时，资源服务器将使用JWK设置的URI作为键，并使用JWK设置的JSON作为值。
+
+|   |Spring 不是缓存提供程序，因此你需要确保包含适当的依赖项，比如`spring-boot-starter-cache`和你最喜欢的缓存提供程序。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+|   |不管是套接字超时还是缓存超时，你可能希望直接使用Nimbus。要做到这一点，请记住<br/>附带一个构造函数，该构造函数接受Nimbus的`JWTProcessor`。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+[OAuth2资源服务器](index.html)[不透明令牌](opaque-token.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-oauth2-resource-server-multitenancy.md b/docs/spring-security/servlet-oauth2-resource-server-multitenancy.md
new file mode 100644
index 0000000..8bcb9c0
--- /dev/null
+++ b/docs/spring-security/servlet-oauth2-resource-server-multitenancy.md
@@ -0,0 +1,425 @@
+# OAuth2.0资源服务器多租户
+
+## 支持JWT和不透明令牌
+
+在某些情况下，你可能需要访问这两种令牌。例如，你可能支持多个租户，其中一个租户发行JWTS，而另一个租户发行不透明令牌。
+
+如果这个决定必须在请求时做出，那么你可以使用`AuthenticationManagerResolver`来实现它，如下所示：
+
+Java
+
+```
+@Bean
+AuthenticationManagerResolver<HttpServletRequest> tokenAuthenticationManagerResolver
+        (JwtDecoder jwtDecoder, OpaqueTokenIntrospector opaqueTokenIntrospector) {
+    AuthenticationManager jwt = new ProviderManager(new JwtAuthenticationProvider(jwtDecoder));
+    AuthenticationManager opaqueToken = new ProviderManager(
+            new OpaqueTokenAuthenticationProvider(opaqueTokenIntrospector));
+    return (request) -> useJwt(request) ? jwt : opaqueToken;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun tokenAuthenticationManagerResolver
+        (jwtDecoder: JwtDecoder, opaqueTokenIntrospector: OpaqueTokenIntrospector):
+        AuthenticationManagerResolver<HttpServletRequest> {
+    val jwt = ProviderManager(JwtAuthenticationProvider(jwtDecoder))
+    val opaqueToken = ProviderManager(OpaqueTokenAuthenticationProvider(opaqueTokenIntrospector));
+
+    return AuthenticationManagerResolver { request ->
+        if (useJwt(request)) {
+            jwt
+        } else {
+            opaqueToken
+        }
+    }
+}
+```
+
+|   |`useJwt(HttpServletRequest)`的实现可能取决于自定义的请求材料，如路径。|
+|---|---------------------------------------------------------------------------------------------------------------|
+
+然后在DSL中指定`AuthenticationManagerResolver`:
+
+例1.身份验证管理器解析器
+
+Java
+
+```
+http
+    .authorizeHttpRequests(authorize -> authorize
+        .anyRequest().authenticated()
+    )
+    .oauth2ResourceServer(oauth2 -> oauth2
+        .authenticationManagerResolver(this.tokenAuthenticationManagerResolver)
+    );
+```
+
+Kotlin
+
+```
+http {
+    authorizeRequests {
+        authorize(anyRequest, authenticated)
+    }
+    oauth2ResourceServer {
+        authenticationManagerResolver = tokenAuthenticationManagerResolver()
+    }
+}
+```
+
+XML
+
+```
+<http>
+    <oauth2-resource-server authentication-manager-resolver-ref="tokenAuthenticationManagerResolver"/>
+</http>
+```
+
+## 多重租赁
+
+当存在多个用于验证由某个租户标识符控制的承载令牌的策略时，资源服务器被认为是多租户的。
+
+例如，你的资源服务器可能接受来自两个不同授权服务器的承载令牌。或者，你的授权服务器可能表示多个发行者。
+
+在每种情况下，都需要做两件事，以及与选择如何做这些事情相关的权衡：
+
+1. 解决租户
+
+2. 宣传租户
+
+### 通过索赔来解决承租人的问题
+
+区分租户的一种方法是通过签发人索赔。由于发行者声明伴随着已签名的JWTS，因此可以使用`JwtIssuerAuthenticationManagerResolver`来完成此操作，如下所示：
+
+例2. JWT提出的多重租赁承租人索赔
+
+Java
+
+```
+JwtIssuerAuthenticationManagerResolver authenticationManagerResolver = new JwtIssuerAuthenticationManagerResolver
+    ("https://idp.example.org/issuerOne", "https://idp.example.org/issuerTwo");
+
+http
+    .authorizeHttpRequests(authorize -> authorize
+        .anyRequest().authenticated()
+    )
+    .oauth2ResourceServer(oauth2 -> oauth2
+        .authenticationManagerResolver(authenticationManagerResolver)
+    );
+```
+
+Kotlin
+
+```
+val customAuthenticationManagerResolver = JwtIssuerAuthenticationManagerResolver
+    ("https://idp.example.org/issuerOne", "https://idp.example.org/issuerTwo")
+http {
+    authorizeRequests {
+        authorize(anyRequest, authenticated)
+    }
+    oauth2ResourceServer {
+        authenticationManagerResolver = customAuthenticationManagerResolver
+    }
+}
+```
+
+XML
+
+```
+<http>
+    <oauth2-resource-server authentication-manager-resolver-ref="authenticationManagerResolver"/>
+</http>
+
+<bean id="authenticationManagerResolver"
+        class="org.springframework.security.oauth2.server.resource.authentication.JwtIssuerAuthenticationManagerResolver">
+    <constructor-arg>
+        <list>
+            <value>https://idp.example.org/issuerOne</value>
+            <value>https://idp.example.org/issuerTwo</value>
+        </list>
+    </constructor-arg>
+</bean>
+```
+
+这很好，因为发行者端点是懒洋洋地加载的。实际上，对应的`JwtAuthenticationProvider`只有在发送了与对应的发行者的第一个请求时才被实例化。这允许应用程序启动，该应用程序独立于已启动和可用的那些授权服务器。
+
+#### 动态租户
+
+当然，你可能不希望每次添加新租户时都重新启动应用程序。在这种情况下，你可以使用`JwtIssuerAuthenticationManagerResolver`实例的存储库配置`AuthenticationManager`实例，你可以在运行时对其进行编辑，如下所示：
+
+Java
+
+```
+private void addManager(Map<String, AuthenticationManager> authenticationManagers, String issuer) {
+	JwtAuthenticationProvider authenticationProvider = new JwtAuthenticationProvider
+	        (JwtDecoders.fromIssuerLocation(issuer));
+	authenticationManagers.put(issuer, authenticationProvider::authenticate);
+}
+
+// ...
+
+JwtIssuerAuthenticationManagerResolver authenticationManagerResolver =
+        new JwtIssuerAuthenticationManagerResolver(authenticationManagers::get);
+
+http
+    .authorizeHttpRequests(authorize -> authorize
+        .anyRequest().authenticated()
+    )
+    .oauth2ResourceServer(oauth2 -> oauth2
+        .authenticationManagerResolver(authenticationManagerResolver)
+    );
+```
+
+Kotlin
+
+```
+private fun addManager(authenticationManagers: MutableMap<String, AuthenticationManager>, issuer: String) {
+    val authenticationProvider = JwtAuthenticationProvider(JwtDecoders.fromIssuerLocation(issuer))
+    authenticationManagers[issuer] = AuthenticationManager {
+        authentication: Authentication? -> authenticationProvider.authenticate(authentication)
+    }
+}
+
+// ...
+
+val customAuthenticationManagerResolver: JwtIssuerAuthenticationManagerResolver =
+    JwtIssuerAuthenticationManagerResolver(authenticationManagers::get)
+http {
+    authorizeRequests {
+        authorize(anyRequest, authenticated)
+    }
+    oauth2ResourceServer {
+        authenticationManagerResolver = customAuthenticationManagerResolver
+    }
+}
+```
+
+在这种情况下，你构造`JwtIssuerAuthenticationManagerResolver`，并使用一种策略来获得给定发行人的`AuthenticationManager`。这种方法允许我们在运行时从存储库中添加和删除元素（在代码片段中显示为`Map`）。
+
+|   |简单地获取任何发行者并从中构造`AuthenticationManager`将是不安全的。<br/>发行者应该是代码可以从可信的源（如允许的发行者列表）验证的发行者。|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+#### 只对索赔进行一次分析。
+
+你可能已经注意到，这种策略虽然很简单，但伴随着这样一种权衡：在请求中，JWT先由`AuthenticationManagerResolver`解析一次，然后再由[`JwtDecoder`]（jwt.html#oAuth2Resourceserver-jwt-architecture-jwtdecoder）解析一次。
+
+可以通过直接使用Nimbus中的`JWTClaimsSetAwareJWSKeySelector`配置[`JwtDecoder`]（jwt.html#oAuth2Resourceserver-jwt-architecture-jwtdecoder）来减轻这种额外的解析：
+
+Java
+
+```
+@Component
+public class TenantJWSKeySelector
+    implements JWTClaimsSetAwareJWSKeySelector<SecurityContext> {
+
+	private final TenantRepository tenants; (1)
+	private final Map<String, JWSKeySelector<SecurityContext>> selectors = new ConcurrentHashMap<>(); (2)
+
+	public TenantJWSKeySelector(TenantRepository tenants) {
+		this.tenants = tenants;
+	}
+
+	@Override
+	public List<? extends Key> selectKeys(JWSHeader jwsHeader, JWTClaimsSet jwtClaimsSet, SecurityContext securityContext)
+			throws KeySourceException {
+		return this.selectors.computeIfAbsent(toTenant(jwtClaimsSet), this::fromTenant)
+				.selectJWSKeys(jwsHeader, securityContext);
+	}
+
+	private String toTenant(JWTClaimsSet claimSet) {
+		return (String) claimSet.getClaim("iss");
+	}
+
+	private JWSKeySelector<SecurityContext> fromTenant(String tenant) {
+		return Optional.ofNullable(this.tenantRepository.findById(tenant)) (3)
+		        .map(t -> t.getAttrbute("jwks_uri"))
+				.map(this::fromUri)
+				.orElseThrow(() -> new IllegalArgumentException("unknown tenant"));
+	}
+
+	private JWSKeySelector<SecurityContext> fromUri(String uri) {
+		try {
+			return JWSAlgorithmFamilyJWSKeySelector.fromJWKSetURL(new URL(uri)); (4)
+		} catch (Exception ex) {
+			throw new IllegalArgumentException(ex);
+		}
+	}
+}
+```
+
+Kotlin
+
+```
+@Component
+class TenantJWSKeySelector(tenants: TenantRepository) : JWTClaimsSetAwareJWSKeySelector<SecurityContext> {
+    private val tenants: TenantRepository (1)
+    private val selectors: MutableMap<String, JWSKeySelector<SecurityContext>> = ConcurrentHashMap() (2)
+
+    init {
+        this.tenants = tenants
+    }
+
+    fun selectKeys(jwsHeader: JWSHeader?, jwtClaimsSet: JWTClaimsSet, securityContext: SecurityContext): List<Key?> {
+        return selectors.computeIfAbsent(toTenant(jwtClaimsSet)) { tenant: String -> fromTenant(tenant) }
+                .selectJWSKeys(jwsHeader, securityContext)
+    }
+
+    private fun toTenant(claimSet: JWTClaimsSet): String {
+        return claimSet.getClaim("iss") as String
+    }
+
+    private fun fromTenant(tenant: String): JWSKeySelector<SecurityContext> {
+        return Optional.ofNullable(this.tenants.findById(tenant)) (3)
+                .map { t -> t.getAttrbute("jwks_uri") }
+                .map { uri: String -> fromUri(uri) }
+                .orElseThrow { IllegalArgumentException("unknown tenant") }
+    }
+
+    private fun fromUri(uri: String): JWSKeySelector<SecurityContext?> {
+        return try {
+            JWSAlgorithmFamilyJWSKeySelector.fromJWKSetURL(URL(uri)) (4)
+        } catch (ex: Exception) {
+            throw IllegalArgumentException(ex)
+        }
+    }
+}
+```
+
+|**1**|租户信息的假设来源|
+|-----|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|**2**|由租户标识符键控的`JWKKeySelector`s的缓存|
+|**3**|查找租户比简单地动态计算JWK设置端点更安全-查找充当允许的租户列表|
+|**4**|通过从JWK设置端点返回的键的类型创建`JWSKeySelector`-这里的惰性查找意味着你不需要在启动时配置所有的租户|
+
+上面的键选择器是由许多键选择器组成的。它根据JWT中的`iss`声明选择使用哪个键选择器。
+
+|   |要使用这种方法，请确保将授权服务器配置为将索取集作为令牌签名的一部分。<br/>否则，你无法保证发行者没有被不良参与者更改。|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+接下来，我们可以构造`JWTProcessor`:
+
+Java
+
+```
+@Bean
+JWTProcessor jwtProcessor(JWTClaimSetJWSKeySelector keySelector) {
+	ConfigurableJWTProcessor<SecurityContext> jwtProcessor =
+            new DefaultJWTProcessor();
+	jwtProcessor.setJWTClaimsSetAwareJWSKeySelector(keySelector);
+	return jwtProcessor;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtProcessor(keySelector: JWTClaimsSetAwareJWSKeySelector<SecurityContext>): JWTProcessor<SecurityContext> {
+    val jwtProcessor = DefaultJWTProcessor<SecurityContext>()
+    jwtProcessor.jwtClaimsSetAwareJWSKeySelector = keySelector
+    return jwtProcessor
+}
+```
+
+正如你已经看到的，将租户意识向下移动到这个级别的权衡是更多的配置。我们只有一点点。
+
+接下来，我们仍然希望确保你正在验证发行者。但是，由于每个JWT的发行者可能是不同的，因此你也需要一个具有租户意识的验证器：
+
+Java
+
+```
+@Component
+public class TenantJwtIssuerValidator implements OAuth2TokenValidator<Jwt> {
+	private final TenantRepository tenants;
+	private final Map<String, JwtIssuerValidator> validators = new ConcurrentHashMap<>();
+
+	public TenantJwtIssuerValidator(TenantRepository tenants) {
+		this.tenants = tenants;
+	}
+
+	@Override
+	public OAuth2TokenValidatorResult validate(Jwt token) {
+		return this.validators.computeIfAbsent(toTenant(token), this::fromTenant)
+				.validate(token);
+	}
+
+	private String toTenant(Jwt jwt) {
+		return jwt.getIssuer();
+	}
+
+	private JwtIssuerValidator fromTenant(String tenant) {
+		return Optional.ofNullable(this.tenants.findById(tenant))
+		        .map(t -> t.getAttribute("issuer"))
+				.map(JwtIssuerValidator::new)
+				.orElseThrow(() -> new IllegalArgumentException("unknown tenant"));
+	}
+}
+```
+
+Kotlin
+
+```
+@Component
+class TenantJwtIssuerValidator(tenants: TenantRepository) : OAuth2TokenValidator<Jwt> {
+    private val tenants: TenantRepository
+    private val validators: MutableMap<String, JwtIssuerValidator> = ConcurrentHashMap()
+    override fun validate(token: Jwt): OAuth2TokenValidatorResult {
+        return validators.computeIfAbsent(toTenant(token)) { tenant: String -> fromTenant(tenant) }
+                .validate(token)
+    }
+
+    private fun toTenant(jwt: Jwt): String {
+        return jwt.issuer.toString()
+    }
+
+    private fun fromTenant(tenant: String): JwtIssuerValidator {
+        return Optional.ofNullable(tenants.findById(tenant))
+                .map({ t -> t.getAttribute("issuer") })
+                .map({ JwtIssuerValidator() })
+                .orElseThrow({ IllegalArgumentException("unknown tenant") })
+    }
+
+    init {
+        this.tenants = tenants
+    }
+}
+```
+
+既然我们有了租户感知处理器和租户感知验证器，我们就可以继续创建我们的[`JwtDecoder`]（jwt.html#OAuth2Resourceserver-jwt-architecture-jwtdecoder）：
+
+Java
+
+```
+@Bean
+JwtDecoder jwtDecoder(JWTProcessor jwtProcessor, OAuth2TokenValidator<Jwt> jwtValidator) {
+	NimbusJwtDecoder decoder = new NimbusJwtDecoder(jwtProcessor);
+	OAuth2TokenValidator<Jwt> validator = new DelegatingOAuth2TokenValidator<>
+			(JwtValidators.createDefault(), jwtValidator);
+	decoder.setJwtValidator(validator);
+	return decoder;
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun jwtDecoder(jwtProcessor: JWTProcessor<SecurityContext>?, jwtValidator: OAuth2TokenValidator<Jwt>?): JwtDecoder {
+    val decoder = NimbusJwtDecoder(jwtProcessor)
+    val validator: OAuth2TokenValidator<Jwt> = DelegatingOAuth2TokenValidator(JwtValidators.createDefault(), jwtValidator)
+    decoder.setJwtValidator(validator)
+    return decoder
+}
+```
+
+我们已经谈完了解决租户的问题。
+
+如果你选择通过JWT声明以外的方法来解决租户问题，那么你将需要确保以相同的方式处理下游资源服务器。例如，如果你是通过子域解析它，那么你可能需要使用相同的子域来寻址下游资源服务器。
+
+但是，如果你通过不记名令牌中的一个声明来解决它，请继续阅读以了解[Spring Security’s support for bearer token propagation](bearer-tokens.html#oauth2resourceserver-bearertoken-resolver)。
+
+[不透明令牌](opaque-token.html)[不记名代币](bearer-tokens.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-oauth2-resource-server-opaque-token.md b/docs/spring-security/servlet-oauth2-resource-server-opaque-token.md
new file mode 100644
index 0000000..31d5f28
--- /dev/null
+++ b/docs/spring-security/servlet-oauth2-resource-server-opaque-token.md
@@ -0,0 +1,831 @@
+# OAuth2.0资源服务器不透明令牌
+
+## 用于自省的最小依赖项
+
+如[JWT的最小依赖项](jwt.html#oauth2resourceserver-jwt-minimaldependencies)中所描述的，大多数资源服务器的支持都是在`spring-security-oauth2-resource-server`中收集的。但是，除非提供了自定义[`OpaqueTokenIntrospector`]（#OAuth2Resourceserver-opaque-introspector），否则资源服务器将退回到NimbusOpaquetokenintrospector。这意味着`spring-security-oauth2-resource-server`和`oauth2-oidc-sdk`都是必需的，以便拥有支持不透明承载令牌的工作最小资源服务器。请参阅`spring-security-oauth2-resource-server`以确定`oauth2-oidc-sdk`的正确版本。
+
+## 用于内省的最小配置
+
+通常，可以通过由授权服务器托管的[OAuth2.0内省终点](https://tools.ietf.org/html/rfc7662)来验证不透明令牌。当要求撤销时，这可能很方便。
+
+当使用[Spring Boot](https://spring.io/projects/spring-boot)时，将应用程序配置为使用内省的资源服务器包括两个基本步骤。首先，包括所需的依赖关系，其次，指示内省端点细节。
+
+### 指定授权服务器
+
+要指定内省端点的位置，只需执行以下操作：
+
+```
+security:
+  oauth2:
+    resourceserver:
+      opaque-token:
+        introspection-uri: https://idp.example.com/introspect
+        client-id: client
+        client-secret: secret
+```
+
+其中`[https://idp.example.com/introspect](https://idp.example.com/introspect)`是由授权服务器托管的内省端点，`client-id`和`client-secret`是达到该端点所需的凭据。
+
+Resource Server将使用这些属性进一步自我配置，并随后验证传入的JWTS。
+
+|   |在使用内省时，授权服务器的单词是law。<br/>如果授权服务器响应令牌是有效的，那么它是有效的。|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------|
+
+就这样！
+
+### 创业期望
+
+当使用此属性和这些依赖项时，Resource Server将自动配置自身以验证不透明承载令牌。
+
+这个启动过程比JWTS简单得多，因为不需要发现端点，也不需要添加额外的验证规则。
+
+### 运行时期望
+
+一旦启动应用程序，Resource Server将尝试处理任何包含`Authorization: Bearer`报头的请求：
+
+```
+GET / HTTP/1.1
+Authorization: Bearer some-token-value # Resource Server will process this
+```
+
+只要表明了该方案，资源服务器就会尝试根据承载令牌规范来处理请求。
+
+给定一个不透明的令牌，资源服务器将
+
+1. 使用提供的凭据和令牌查询提供的内省端点
+
+2. 检查`{ 'active' : true }`属性的响应
+
+3. 将每个作用域映射到一个前缀`SCOPE_`的权限
+
+默认情况下，生成的`Authentication#getPrincipal`是 Spring security`[OAuth2AuthenticatedPrincipal](https://docs.spring.io/spring-security/site/docs/5.6.2/api/org/springframework/security/oauth2/core/OAuth2AuthenticatedPrincipal.html)`对象，并且`Authentication#getName`映射到令牌的`sub`属性（如果存在）。
+
+从这里，你可能想跳转到：
+
+* [不透明令牌身份验证的工作方式](#oauth2resourceserver-opaque-architecture)
+
+* [身份验证后查找属性](#oauth2resourceserver-opaque-attributes)
+
+* [手动提取权限](#oauth2resourceserver-opaque-authorization-extraction)
+
+* [使用JWTS进行内省](#oauth2resourceserver-opaque-jwt-introspector)
+
+## 不透明令牌身份验证的工作方式
+
+接下来，让我们看看 Spring Security在基于 Servlet 的应用程序中支持[不透明令牌](https://tools.ietf.org/html/rfc7662)身份验证所使用的体系结构组件，就像我们刚才看到的那样。
+
+[`OpaqueTokenAuthenticationProvider`]（https://DOCS. Spring.io/ Spring-security/site/DOCS/5.6.2/api/org/springframework/security/oauth2/server/resource/authentication/opaquetokenauthenticationprovider.html）是一种[`AuthenticationProvider`]（././../././////./authentification/architection.html.html# Servlet-authentification-authentification-authentication provider）实现，利用不透明的[<gt
+
+让我们来看看`OpaqueTokenAuthenticationProvider`在 Spring 安全性中是如何工作的。该图详细说明了`AuthenticationManager`]（.../../authentication/architecture.html# Servlet-authentication-authenticationmanager）在[读取不记名令牌](#oauth2resourceserver-authentication-bearertokenauthenticationfilter)中的工作原理。
+
+![opaquetokenauthenticationProvider](https://docs.spring.io/spring-security/reference/_images/servlet/oauth2/opaquetokenauthenticationprovider.png)
+
+图1. `OpaqueTokenAuthenticationProvider`用法
+
+![number 1](https://docs.spring.io/spring-security/reference/_images/icons/number_1.png)来自[读取不记名令牌](#oauth2resourceserver-authentication-bearertokenauthenticationfilter)的身份验证`Filter`将一个`BearerTokenAuthenticationToken`传递到`AuthenticationManager`，这是由[`ProviderManager`]（.../../authentication/architecture.html# Servlet-authentication-providermanager）实现的。
+
+![number 2](https://docs.spring.io/spring-security/reference/_images/icons/number_2.png)`ProviderManager`被配置为使用[身份验证提供者](../../authentication/architecture.html#servlet-authentication-authenticationprovider)类型的`OpaqueTokenAuthenticationProvider`。
+
+![number 3](https://docs.spring.io/spring-security/reference/_images/icons/number_3.png)`OpaqueTokenAuthenticationProvider`内省不透明令牌，并使用[`OpaqueTokenIntrospector`]（#OAuth2Resourceserver-opae-introspector）添加授予的权限。当身份验证成功时，返回的[`Authentication`]（.../../authentication/architecture.html# Servlet-authentication-authentication）类型为`BearerTokenAuthentication`，并且具有由配置的[`OpaqueTokenIntrospector`]（#OAuth2resourceserver-ope-introspector）返回的`OAuth2AuthenticatedPrincipal`主体。最终，返回的`BearerTokenAuthentication`将由身份验证`Filter`设置在[`SecurityContextHolder`]（.../authentication/architecture.html# Servlet-authentication-securitycontextholder）上。
+
+## 身份验证后查找属性
+
+一旦对令牌进行了身份验证，就会在`SecurityContext`中设置`BearerTokenAuthentication`的实例。
+
+这意味着当在配置中使用`@EnableWebMvc`时，它在`@Controller`方法中可用：
+
+Java
+
+```
+@GetMapping("/foo")
+public String foo(BearerTokenAuthentication authentication) {
+    return authentication.getTokenAttributes().get("sub") + " is the subject";
+}
+```
+
+Kotlin
+
+```
+@GetMapping("/foo")
+fun foo(authentication: BearerTokenAuthentication): String {
+    return authentication.tokenAttributes["sub"].toString() + " is the subject"
+}
+```
+
+由于`BearerTokenAuthentication`持有`OAuth2AuthenticatedPrincipal`，这也意味着控制器方法也可以使用它：
+
+Java
+
+```
+@GetMapping("/foo")
+public String foo(@AuthenticationPrincipal OAuth2AuthenticatedPrincipal principal) {
+    return principal.getAttribute("sub") + " is the subject";
+}
+```
+
+Kotlin
+
+```
+@GetMapping("/foo")
+fun foo(@AuthenticationPrincipal principal: OAuth2AuthenticatedPrincipal): String {
+    return principal.getAttribute<Any>("sub").toString() + " is the subject"
+}
+```
+
+### 通过SPEL查找属性
+
+当然，这也意味着可以通过SPEL访问属性。
+
+例如，如果使用`@EnableGlobalMethodSecurity`使你可以使用`@PreAuthorize`注释，则可以这样做：
+
+Java
+
+```
+@PreAuthorize("principal?.attributes['sub'] == 'foo'")
+public String forFoosEyesOnly() {
+    return "foo";
+}
+```
+
+Kotlin
+
+```
+@PreAuthorize("principal?.attributes['sub'] == 'foo'")
+fun forFoosEyesOnly(): String {
+    return "foo"
+}
+```
+
+## 覆盖或替换Boot Auto配置
+
+有两个`@Bean`s， Spring boot代表资源服务器生成。
+
+第一个是将应用程序配置为资源服务器的`WebSecurityConfigurerAdapter`。当使用不透明令牌时，这个`WebSecurityConfigurerAdapter`看起来像：
+
+例1.默认不透明令牌配置
+
+Java
+
+```
+protected void configure(HttpSecurity http) {
+    http
+        .authorizeHttpRequests(authorize -> authorize
+            .anyRequest().authenticated()
+        )
+        .oauth2ResourceServer(OAuth2ResourceServerConfigurer::opaqueToken);
+}
+```
+
+Kotlin
+
+```
+override fun configure(http: HttpSecurity) {
+    http {
+        authorizeRequests {
+            authorize(anyRequest, authenticated)
+        }
+        oauth2ResourceServer {
+            opaqueToken { }
+        }
+    }
+}
+```
+
+如果应用程序不公开`WebSecurityConfigurerAdapter` Bean，那么 Spring 引导将公开上面的默认引导。
+
+替换它就像在应用程序中公开 Bean 一样简单：
+
+例2.自定义不透明令牌配置
+
+Java
+
+```
+@EnableWebSecurity
+public class MyCustomSecurityConfiguration extends WebSecurityConfigurerAdapter {
+    protected void configure(HttpSecurity http) {
+        http
+            .authorizeHttpRequests(authorize -> authorize
+                .mvcMatchers("/messages/**").hasAuthority("SCOPE_message:read")
+                .anyRequest().authenticated()
+            )
+            .oauth2ResourceServer(oauth2 -> oauth2
+                .opaqueToken(opaqueToken -> opaqueToken
+                    .introspector(myIntrospector())
+                )
+            );
+    }
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class MyCustomSecurityConfiguration : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            authorizeRequests {
+                authorize("/messages/**", hasAuthority("SCOPE_message:read"))
+                authorize(anyRequest, authenticated)
+            }
+            oauth2ResourceServer {
+                opaqueToken {
+                    introspector = myIntrospector()
+                }
+            }
+        }
+    }
+}
+```
+
+对于任何以`/messages/`开头的URL，上述条件要求`message:read`的范围。
+
+`oauth2ResourceServer`DSL上的方法也将覆盖或替换自动配置。
+
+例如，第二个`@Bean` Spring 引导创建的是一个`OpaqueTokenIntrospector`，[它将`String`令牌解码为`OAuth2AuthenticatedPrincipal`的验证实例]（#OAuth2Resourceserver-ope-architecture-introspector）：
+
+Java
+
+```
+@Bean
+public OpaqueTokenIntrospector introspector() {
+    return new NimbusOpaqueTokenIntrospector(introspectionUri, clientId, clientSecret);
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun introspector(): OpaqueTokenIntrospector {
+    return NimbusOpaqueTokenIntrospector(introspectionUri, clientId, clientSecret)
+}
+```
+
+如果应用程序不公开[`OpaqueTokenIntrospector`]（#OAuth2Resourceserver-opaque-architecture-introspector） Bean，那么 Spring 引导将公开上述默认的引导。
+
+并且它的配置可以使用`introspectionUri()`和`introspectionClientCredentials()`进行重写，或者使用`introspector()`进行替换。
+
+或者，如果你根本不使用 Spring boot，那么这两个组件-过滤器链和[`OpaqueTokenIntrospector`]（#OAuth2Resourceserver-Opaque-Architecture-Introspector）都可以用XML指定。
+
+过滤链是这样指定的：
+
+例3.默认不透明令牌配置
+
+XML
+
+```
+<http>
+    <intercept-uri pattern="/**" access="authenticated"/>
+    <oauth2-resource-server>
+        <opaque-token introspector-ref="opaqueTokenIntrospector"/>
+    </oauth2-resource-server>
+</http>
+```
+
+[`OpaqueTokenIntrospector`]（#OAuth2resourceserver-opaque-architecture-introspector）如下所示：
+
+例4.不透明令牌内省器
+
+XML
+
+```
+<bean id="opaqueTokenIntrospector"
+        class="org.springframework.security.oauth2.server.resource.introspection.NimbusOpaqueTokenIntrospector">
+    <constructor-arg value="${spring.security.oauth2.resourceserver.opaquetoken.introspection_uri}"/>
+    <constructor-arg value="${spring.security.oauth2.resourceserver.opaquetoken.client_id}"/>
+    <constructor-arg value="${spring.security.oauth2.resourceserver.opaquetoken.client_secret}"/>
+</bean>
+```
+
+### `
+
+可以配置授权服务器的内省URI[作为配置属性](#oauth2resourceserver-opaque-introspectionuri)，也可以在DSL中提供它：
+
+例5.内省URI配置
+
+Java
+
+```
+@EnableWebSecurity
+public class DirectlyConfiguredIntrospectionUri extends WebSecurityConfigurerAdapter {
+    protected void configure(HttpSecurity http) {
+        http
+            .authorizeHttpRequests(authorize -> authorize
+                .anyRequest().authenticated()
+            )
+            .oauth2ResourceServer(oauth2 -> oauth2
+                .opaqueToken(opaqueToken -> opaqueToken
+                    .introspectionUri("https://idp.example.com/introspect")
+                    .introspectionClientCredentials("client", "secret")
+                )
+            );
+    }
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class DirectlyConfiguredIntrospectionUri : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            authorizeRequests {
+                authorize(anyRequest, authenticated)
+            }
+            oauth2ResourceServer {
+                opaqueToken {
+                    introspectionUri = "https://idp.example.com/introspect"
+                    introspectionClientCredentials("client", "secret")
+                }
+            }
+        }
+    }
+}
+```
+
+XML
+
+```
+<bean id="opaqueTokenIntrospector"
+        class="org.springframework.security.oauth2.server.resource.introspection.NimbusOpaqueTokenIntrospector">
+    <constructor-arg value="https://idp.example.com/introspect"/>
+    <constructor-arg value="client"/>
+    <constructor-arg value="secret"/>
+</bean>
+```
+
+使用`introspectionUri()`优先于任何配置属性。
+
+### `
+
+比`introspectionUri()`更强大的是`introspector()`，它将完全取代[`OpaqueTokenIntrospector`]（#OAuth2Resourceserver-opae-architecture-introspector）的任何引导自动配置：
+
+例6.内省配置
+
+Java
+
+```
+@EnableWebSecurity
+public class DirectlyConfiguredIntrospector extends WebSecurityConfigurerAdapter {
+    protected void configure(HttpSecurity http) {
+        http
+            .authorizeHttpRequests(authorize -> authorize
+                .anyRequest().authenticated()
+            )
+            .oauth2ResourceServer(oauth2 -> oauth2
+                .opaqueToken(opaqueToken -> opaqueToken
+                    .introspector(myCustomIntrospector())
+                )
+            );
+    }
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class DirectlyConfiguredIntrospector : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            authorizeRequests {
+                authorize(anyRequest, authenticated)
+            }
+            oauth2ResourceServer {
+                opaqueToken {
+                    introspector = myCustomIntrospector()
+                }
+            }
+        }
+    }
+}
+```
+
+XML
+
+```
+<http>
+    <intercept-uri pattern="/**" access="authenticated"/>
+    <oauth2-resource-server>
+        <opaque-token introspector-ref="myCustomIntrospector"/>
+    </oauth2-resource-server>
+</http>
+```
+
+当需要更深的配置时，比如[权限映射](#oauth2resourceserver-opaque-authorization-extraction)、[JWT撤销](#oauth2resourceserver-opaque-jwt-introspector)或[请求超时](#oauth2resourceserver-opaque-timeouts)，这是很方便的。
+
+### 曝光`OpaqueTokenIntrospector``@Bean`
+
+或者，暴露一个[`OpaqueTokenIntrospector`]（#OAuth2resourceserver-opae-architecture-introspector）`@Bean`具有与`introspector()`相同的效果：
+
+```
+@Bean
+public OpaqueTokenIntrospector introspector() {
+    return new NimbusOpaqueTokenIntrospector(introspectionUri, clientId, clientSecret);
+}
+```
+
+## 配置授权
+
+OAuth2.0内省端点通常会返回一个`scope`属性，指示它被授予的作用域（或权限），例如：
+
+`{ …​, "scope" : "messages contacts"}`
+
+在这种情况下，Resource Server将尝试强制将这些作用域放入一个已授予权限的列表中，并在每个作用域前加上字符串“scope\_”。
+
+这意味着，要保护具有由不透明令牌派生的作用域的端点或方法，相应的表达式应该包括以下前缀：
+
+例7.授权不透明令牌配置
+
+Java
+
+```
+@EnableWebSecurity
+public class MappedAuthorities extends WebSecurityConfigurerAdapter {
+    protected void configure(HttpSecurity http) {
+        http
+            .authorizeHttpRequests(authorizeRequests -> authorizeRequests
+                .mvcMatchers("/contacts/**").hasAuthority("SCOPE_contacts")
+                .mvcMatchers("/messages/**").hasAuthority("SCOPE_messages")
+                .anyRequest().authenticated()
+            )
+            .oauth2ResourceServer(OAuth2ResourceServerConfigurer::opaqueToken);
+    }
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class MappedAuthorities : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+       http {
+            authorizeRequests {
+                authorize("/contacts/**", hasAuthority("SCOPE_contacts"))
+                authorize("/messages/**", hasAuthority("SCOPE_messages"))
+                authorize(anyRequest, authenticated)
+            }
+           oauth2ResourceServer {
+               opaqueToken { }
+           }
+        }
+    }
+}
+```
+
+XML
+
+```
+<http>
+    <intercept-uri pattern="/contacts/**" access="hasAuthority('SCOPE_contacts')"/>
+    <intercept-uri pattern="/messages/**" access="hasAuthority('SCOPE_messages')"/>
+    <oauth2-resource-server>
+        <opaque-token introspector-ref="opaqueTokenIntrospector"/>
+    </oauth2-resource-server>
+</http>
+```
+
+或类似于方法安全性：
+
+Java
+
+```
+@PreAuthorize("hasAuthority('SCOPE_messages')")
+public List<Message> getMessages(...) {}
+```
+
+Kotlin
+
+```
+@PreAuthorize("hasAuthority('SCOPE_messages')")
+fun getMessages(): List<Message?> {}
+```
+
+### 手动提取权限
+
+默认情况下，不透明令牌支持将从内省响应中提取范围声明，并将其解析为单个`GrantedAuthority`实例。
+
+例如，如果内省反应是：
+
+```
+{
+    "active" : true,
+    "scope" : "message:read message:write"
+}
+```
+
+然后，资源服务器将生成一个带有两个权限的`Authentication`，一个用于`message:read`，另一个用于`message:write`。
+
+当然，这可以使用自定义[`OpaqueTokenIntrospector`]（#OAuth2Resourceserver-Opaque-Architecture-Introspector）进行自定义，它查看属性集并以自己的方式进行转换：
+
+Java
+
+```
+public class CustomAuthoritiesOpaqueTokenIntrospector implements OpaqueTokenIntrospector {
+    private OpaqueTokenIntrospector delegate =
+            new NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret");
+
+    public OAuth2AuthenticatedPrincipal introspect(String token) {
+        OAuth2AuthenticatedPrincipal principal = this.delegate.introspect(token);
+        return new DefaultOAuth2AuthenticatedPrincipal(
+                principal.getName(), principal.getAttributes(), extractAuthorities(principal));
+    }
+
+    private Collection<GrantedAuthority> extractAuthorities(OAuth2AuthenticatedPrincipal principal) {
+        List<String> scopes = principal.getAttribute(OAuth2IntrospectionClaimNames.SCOPE);
+        return scopes.stream()
+                .map(SimpleGrantedAuthority::new)
+                .collect(Collectors.toList());
+    }
+}
+```
+
+Kotlin
+
+```
+class CustomAuthoritiesOpaqueTokenIntrospector : OpaqueTokenIntrospector {
+    private val delegate: OpaqueTokenIntrospector = NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret")
+    override fun introspect(token: String): OAuth2AuthenticatedPrincipal {
+        val principal: OAuth2AuthenticatedPrincipal = delegate.introspect(token)
+        return DefaultOAuth2AuthenticatedPrincipal(
+                principal.name, principal.attributes, extractAuthorities(principal))
+    }
+
+    private fun extractAuthorities(principal: OAuth2AuthenticatedPrincipal): Collection<GrantedAuthority> {
+        val scopes: List<String> = principal.getAttribute(OAuth2IntrospectionClaimNames.SCOPE)
+        return scopes
+                .map { SimpleGrantedAuthority(it) }
+    }
+}
+```
+
+在此之后，可以简单地将此自定义内省检测器配置为`@Bean`:
+
+Java
+
+```
+@Bean
+public OpaqueTokenIntrospector introspector() {
+    return new CustomAuthoritiesOpaqueTokenIntrospector();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun introspector(): OpaqueTokenIntrospector {
+    return CustomAuthoritiesOpaqueTokenIntrospector()
+}
+```
+
+## 配置超时
+
+默认情况下，Resource Server使用30秒的连接和套接字超时来与授权服务器进行协调。
+
+在某些情况下，这可能太短了。此外，它没有考虑到更复杂的模式，比如后退和发现。
+
+要调整资源服务器连接到授权服务器的方式，`NimbusOpaqueTokenIntrospector`接受`RestOperations`的实例：
+
+Java
+
+```
+@Bean
+public OpaqueTokenIntrospector introspector(RestTemplateBuilder builder, OAuth2ResourceServerProperties properties) {
+    RestOperations rest = builder
+            .basicAuthentication(properties.getOpaquetoken().getClientId(), properties.getOpaquetoken().getClientSecret())
+            .setConnectTimeout(Duration.ofSeconds(60))
+            .setReadTimeout(Duration.ofSeconds(60))
+            .build();
+
+    return new NimbusOpaqueTokenIntrospector(introspectionUri, rest);
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun introspector(builder: RestTemplateBuilder, properties: OAuth2ResourceServerProperties): OpaqueTokenIntrospector? {
+    val rest: RestOperations = builder
+            .basicAuthentication(properties.opaquetoken.clientId, properties.opaquetoken.clientSecret)
+            .setConnectTimeout(Duration.ofSeconds(60))
+            .setReadTimeout(Duration.ofSeconds(60))
+            .build()
+    return NimbusOpaqueTokenIntrospector(introspectionUri, rest)
+}
+```
+
+## 使用JWTS进行内省
+
+一个常见的问题是，内省是否与JWTS兼容。 Spring Security的不透明令牌支持被设计成不关心令牌的格式——它将很乐意将任何令牌传递给所提供的内省端点。
+
+所以，假设你有一个要求，要求你在每个请求上与授权服务器进行检查，以防JWT被撤销。
+
+尽管你使用的是JWT格式的令牌，但你的验证方法是内省，这意味着你希望这样做：
+
+```
+spring:
+  security:
+    oauth2:
+      resourceserver:
+        opaque-token:
+          introspection-uri: https://idp.example.org/introspection
+          client-id: client
+          client-secret: secret
+```
+
+在这种情况下，得到的`Authentication`将是`BearerTokenAuthentication`。对应的`OAuth2AuthenticatedPrincipal`中的任何属性都将是内省端点返回的任何属性。
+
+但是，让我们说，奇怪的是，内省端点只返回令牌是否处于活动状态。现在怎么办？
+
+在这种情况下，你可以创建一个自定义的[`OpaqueTokenIntrospector`]（#OAuth2Resourceserver-opaque-architecture-introspector），它仍然会到达端点，但随后会更新返回的主体，使JWTS声明作为属性：
+
+Java
+
+```
+public class JwtOpaqueTokenIntrospector implements OpaqueTokenIntrospector {
+    private OpaqueTokenIntrospector delegate =
+            new NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret");
+    private JwtDecoder jwtDecoder = new NimbusJwtDecoder(new ParseOnlyJWTProcessor());
+
+    public OAuth2AuthenticatedPrincipal introspect(String token) {
+        OAuth2AuthenticatedPrincipal principal = this.delegate.introspect(token);
+        try {
+            Jwt jwt = this.jwtDecoder.decode(token);
+            return new DefaultOAuth2AuthenticatedPrincipal(jwt.getClaims(), NO_AUTHORITIES);
+        } catch (JwtException ex) {
+            throw new OAuth2IntrospectionException(ex);
+        }
+    }
+
+    private static class ParseOnlyJWTProcessor extends DefaultJWTProcessor<SecurityContext> {
+    	JWTClaimsSet process(SignedJWT jwt, SecurityContext context)
+                throws JOSEException {
+            return jwt.getJWTClaimsSet();
+        }
+    }
+}
+```
+
+Kotlin
+
+```
+class JwtOpaqueTokenIntrospector : OpaqueTokenIntrospector {
+    private val delegate: OpaqueTokenIntrospector = NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret")
+    private val jwtDecoder: JwtDecoder = NimbusJwtDecoder(ParseOnlyJWTProcessor())
+    override fun introspect(token: String): OAuth2AuthenticatedPrincipal {
+        val principal = delegate.introspect(token)
+        return try {
+            val jwt: Jwt = jwtDecoder.decode(token)
+            DefaultOAuth2AuthenticatedPrincipal(jwt.claims, NO_AUTHORITIES)
+        } catch (ex: JwtException) {
+            throw OAuth2IntrospectionException(ex.message)
+        }
+    }
+
+    private class ParseOnlyJWTProcessor : DefaultJWTProcessor<SecurityContext>() {
+        override fun process(jwt: SignedJWT, context: SecurityContext): JWTClaimsSet {
+            return jwt.jwtClaimsSet
+        }
+    }
+}
+```
+
+在此之后，可以简单地将此自定义内省检测器配置为`@Bean`:
+
+Java
+
+```
+@Bean
+public OpaqueTokenIntrospector introspector() {
+    return new JwtOpaqueTokenIntrospector();
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun introspector(): OpaqueTokenIntrospector {
+    return JwtOpaqueTokenIntrospector()
+}
+```
+
+## 调用`/userinfo`端点
+
+一般来说，资源服务器并不关心底层用户，而是关心已被授予的权限。
+
+话虽如此，有时将授权声明与用户绑定在一起可能是有价值的。
+
+如果一个应用程序也在使用`spring-security-oauth2-client`，并且已经设置了适当的`ClientRegistrationRepository`，那么使用自定义[`OpaqueTokenIntrospector`]（#OAuth2Resourceserver-opae-Architecture-Introspector）就非常简单了。下面的实现做了三件事：
+
+* 委托给内省端点，以确认令牌的有效性
+
+* 查找与`/userinfo`端点关联的适当的客户端注册
+
+* 调用并返回来自`/userinfo`端点的响应
+
+Java
+
+```
+public class UserInfoOpaqueTokenIntrospector implements OpaqueTokenIntrospector {
+    private final OpaqueTokenIntrospector delegate =
+            new NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret");
+    private final OAuth2UserService oauth2UserService = new DefaultOAuth2UserService();
+
+    private final ClientRegistrationRepository repository;
+
+    // ... constructor
+
+    @Override
+    public OAuth2AuthenticatedPrincipal introspect(String token) {
+        OAuth2AuthenticatedPrincipal authorized = this.delegate.introspect(token);
+        Instant issuedAt = authorized.getAttribute(ISSUED_AT);
+        Instant expiresAt = authorized.getAttribute(EXPIRES_AT);
+        ClientRegistration clientRegistration = this.repository.findByRegistrationId("registration-id");
+        OAuth2AccessToken token = new OAuth2AccessToken(BEARER, token, issuedAt, expiresAt);
+        OAuth2UserRequest oauth2UserRequest = new OAuth2UserRequest(clientRegistration, token);
+        return this.oauth2UserService.loadUser(oauth2UserRequest);
+    }
+}
+```
+
+Kotlin
+
+```
+class UserInfoOpaqueTokenIntrospector : OpaqueTokenIntrospector {
+    private val delegate: OpaqueTokenIntrospector = NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret")
+    private val oauth2UserService = DefaultOAuth2UserService()
+    private val repository: ClientRegistrationRepository? = null
+
+    // ... constructor
+
+    override fun introspect(token: String): OAuth2AuthenticatedPrincipal {
+        val authorized = delegate.introspect(token)
+        val issuedAt: Instant? = authorized.getAttribute(ISSUED_AT)
+        val expiresAt: Instant? = authorized.getAttribute(EXPIRES_AT)
+        val clientRegistration: ClientRegistration = repository!!.findByRegistrationId("registration-id")
+        val accessToken = OAuth2AccessToken(BEARER, token, issuedAt, expiresAt)
+        val oauth2UserRequest = OAuth2UserRequest(clientRegistration, accessToken)
+        return oauth2UserService.loadUser(oauth2UserRequest)
+    }
+}
+```
+
+如果你AREN不使用`spring-security-oauth2-client`，它仍然很简单。你只需要用你自己的`WebClient`实例调用`/userinfo`:
+
+Java
+
+```
+public class UserInfoOpaqueTokenIntrospector implements OpaqueTokenIntrospector {
+    private final OpaqueTokenIntrospector delegate =
+            new NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret");
+    private final WebClient rest = WebClient.create();
+
+    @Override
+    public OAuth2AuthenticatedPrincipal introspect(String token) {
+        OAuth2AuthenticatedPrincipal authorized = this.delegate.introspect(token);
+        return makeUserInfoRequest(authorized);
+    }
+}
+```
+
+Kotlin
+
+```
+class UserInfoOpaqueTokenIntrospector : OpaqueTokenIntrospector {
+    private val delegate: OpaqueTokenIntrospector = NimbusOpaqueTokenIntrospector("https://idp.example.org/introspect", "client", "secret")
+    private val rest: WebClient = WebClient.create()
+
+    override fun introspect(token: String): OAuth2AuthenticatedPrincipal {
+        val authorized = delegate.introspect(token)
+        return makeUserInfoRequest(authorized)
+    }
+}
+```
+
+无论哪种方式，在创建了你的[`OpaqueTokenIntrospector`]（#OAuth2Resourceserver-opaque-architecture-introspector）之后，你应该将其发布为`@Bean`以覆盖缺省值：
+
+Java
+
+```
+@Bean
+OpaqueTokenIntrospector introspector() {
+    return new UserInfoOpaqueTokenIntrospector(...);
+}
+```
+
+Kotlin
+
+```
+@Bean
+fun introspector(): OpaqueTokenIntrospector {
+    return UserInfoOpaqueTokenIntrospector(...)
+}
+```
+
+[JWT](jwt.html)[多租约](multitenancy.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-oauth2-resource-server.md b/docs/spring-security/servlet-oauth2-resource-server.md
new file mode 100644
index 0000000..51aa22b
--- /dev/null
+++ b/docs/spring-security/servlet-oauth2-resource-server.md
@@ -0,0 +1,54 @@
+# OAuth2.0资源服务器
+
+Spring 安全性支持使用两种形式的OAuth2.0[不记名代币](https://tools.ietf.org/html/rfc6750.html)来保护端点：
+
+* [JWT](https://tools.ietf.org/html/rfc7519)
+
+* 不透明令牌
+
+在应用程序已将其权限管理委托给[授权服务器](https://tools.ietf.org/html/rfc6749)（例如，OKTA或ping标识）的情况下，这很方便。资源服务器可以参考此授权服务器来授权请求。
+
+本节详细介绍了 Spring Security如何为OAuth2.0[不记名代币](https://tools.ietf.org/html/rfc6750.html)提供支持。
+
+|   |[JWTs](https://github.com/spring-projects/spring-security-samples/tree/5.6.x/servlet/spring-boot/java/oauth2/resource-server/jwe)和[不透明令牌](https://github.com/spring-projects/spring-security-samples/tree/5.6.x/servlet/spring-boot/java/oauth2/resource-server/opaque)的工作样例都可以在[Spring Security Samples repository](https://github.com/spring-projects/spring-security-samples/tree/5.6.x)中找到。|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+让我们来看看承载令牌身份验证在 Spring 安全性中是如何工作的。首先，我们看到，像[基本身份验证](../../authentication/passwords/basic.html#servlet-authentication-basic)一样，[WWW-认证](https://tools.ietf.org/html/rfc7235#section-4.1)头被发送回未经验证的客户机。
+
+![BeareRauthenticationCentryPoint](https://docs.spring.io/spring-security/reference/_images/servlet/oauth2/bearerauthenticationentrypoint.png)
+
+图1.发送WWW-身份验证报头
+
+上面的图是基于我们的[`SecurityFilterChain`]（../../architecture.html# Servlet-SecurityFilterchain）图构建的。
+
+![number 1](https://docs.spring.io/spring-security/reference/_images/icons/number_1.png)首先，用户向资源`/private`发出未经授权的请求。
+
+![number 2](https://docs.spring.io/spring-security/reference/_images/icons/number_2.png) Spring security的[`FilterSecurityInterceptor`]（.../授权/authorization/authorization/authorization-requests.html# Servlet-authorization-filtersecurityinterceptor）通过抛出`AccessDeniedException`表示未经验证的请求是*拒绝*。
+
+![number 3](https://docs.spring.io/spring-security/reference/_images/icons/number_3.png)由于用户未经过身份验证，[`ExceptionTranslationFilter`]（..../architecture.html# Servlet-ExceptionTranslationFilter）发起*启动身份验证*。已配置的[`AuthenticationEntryPoint`]（...../authentication/architecture.html# Servlet-authentication-authentryPoint）是[`BearerTokenAuthenticationEntryPoint`]（https://DOCS. Spring.io/ Spring-security/site/DOCS/5.6.2/api/org/springframework/security/oauth2/server/resource/web/bearerertokenauthentrypoint.html）的一个实例，它发送一个WWW-authenticate报`RequestCache`通常是不保存请求的`NullRequestCache`，因为客户机能够重放它最初请求的请求。
+
+当客户端收到`WWW-Authenticate: Bearer`头时，它知道应该使用承载令牌进行重试。下面是正在处理的承载令牌的流程。
+
+![BeareRtoKenAuthenticationFilter](https://docs.spring.io/spring-security/reference/_images/servlet/oauth2/bearertokenauthenticationfilter.png)
+
+图2.不记名令牌的认证
+
+该图构建于我们的[`SecurityFilterChain`]（../../architecture.html# Servlet-SecurityFilterchain）图。
+
+![number 1](https://docs.spring.io/spring-security/reference/_images/icons/number_1.png)当用户提交其承载令牌时，`BearerTokenAuthenticationFilter`通过从`HttpServletRequest`中提取令牌来创建`BearerTokenAuthenticationToken`，这是[`Authentication`]（../../authentication/architecture.html# Servlet-authentication-authentication）的一种类型。
+
+![number 2](https://docs.spring.io/spring-security/reference/_images/icons/number_2.png)接下来，将`HttpServletRequest`传递给`AuthenticationManagerResolver`，后者选择`AuthenticationManager`。将`BearerTokenAuthenticationToken`传递到要进行身份验证的`AuthenticationManager`中。`AuthenticationManager`的详细内容取决于你是为[JWT](jwt.html#oauth2resourceserver-jwt-minimalconfiguration)还是[不透明令牌](opaque-token.html#oauth2resourceserver-opaque-minimalconfiguration)配置的。
+
+![number 3](https://docs.spring.io/spring-security/reference/_images/icons/number_3.png)如果身份验证失败，则*失败*
+
+* [SecurityContextholder](../../authentication/architecture.html#servlet-authentication-securitycontextholder)被清除。
+
+* 调用`AuthenticationEntryPoint`以触发要再次发送的WWW-Authenticate头。
+
+![number 4](https://docs.spring.io/spring-security/reference/_images/icons/number_4.png)如果身份验证成功，则*成功*。
+
+* [认证](../../authentication/architecture.html#servlet-authentication-authentication)设置在[SecurityContextholder](../../authentication/architecture.html#servlet-authentication-securitycontextholder)上。
+
+* `BearerTokenAuthenticationFilter`调用`FilterChain.doFilter(request,response)`以继续应用程序逻辑的其余部分。
+
+[OAuth2授权客户](../client/authorized-clients.html)[JWT](jwt.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-saml2-login-authentication-requests.md b/docs/spring-security/servlet-saml2-login-authentication-requests.md
new file mode 100644
index 0000000..b4384fe
--- /dev/null
+++ b/docs/spring-security/servlet-saml2-login-authentication-requests.md
@@ -0,0 +1,270 @@
+# 产生`<saml2:AuthnRequest>`s
+
+如前所述， Spring Security的SAML2.0支持生成一个`<saml2:AuthnRequest>`，以开始与主张方进行身份验证。
+
+Spring 安全性在一定程度上通过在过滤器链中注册`Saml2WebSsoAuthenticationRequestFilter`来实现这一点。默认情况下，此筛选器响应端点`/saml2/authenticate/{registrationId}`。
+
+例如，如果你被部署到`[https://rp.example.com](https://rp.example.com)`，并且你的注册ID为`okta`，那么你可以导航到：
+
+`[https://rp.example.org/saml2/authenticate/ping](https://rp.example.org/saml2/authenticate/ping)`
+
+结果将是一个重定向，该重定向包含一个`SAMLRequest`参数，该参数包含有符号的、已泄气的和编码的`<saml2:AuthnRequest>`。
+
+## 更改`<saml2:AuthnRequest>`的存储方式
+
+`Saml2WebSsoAuthenticationRequestFilter`使用`Saml2AuthenticationRequestRepository`在[将`<saml2:AuthnRequest>`]（# Servlet-saml2login-sp-initiated-factory）发送给断言方前持久化`AbstractSaml2AuthenticationRequest`实例。
+
+此外，`Saml2WebSsoAuthenticationFilter`和`Saml2AuthenticationTokenConverter`使用`Saml2AuthenticationRequestRepository`来加载任何`AbstractSaml2AuthenticationRequest`作为[验证`<saml2:Response>`]（authentication.html# Servlet-saml2login-attenticate-responses）的一部分。
+
+默认情况下， Spring Security使用`HttpSessionSaml2AuthenticationRequestRepository`，它将`AbstractSaml2AuthenticationRequest`存储在`HttpSession`中。
+
+如果你有`Saml2AuthenticationRequestRepository`的自定义实现，则可以通过将其公开为`@Bean`来配置它，如以下示例所示：
+
+Java
+
+```
+@Bean
+Saml2AuthenticationRequestRepository<AbstractSaml2AuthenticationRequest> authenticationRequestRepository() {
+	return new CustomSaml2AuthenticationRequestRepository();
+}
+```
+
+Kotlin
+
+```
+@Bean
+open fun authenticationRequestRepository(): Saml2AuthenticationRequestRepository<AbstractSaml2AuthenticationRequest> {
+    return CustomSaml2AuthenticationRequestRepository()
+}
+```
+
+## 更改`<saml2:AuthnRequest>`的发送方式
+
+默认情况下， Spring Security对每个`<saml2:AuthnRequest>`进行签名，并将其作为get发送给主张方。
+
+许多有主张的当事人不需要签署`<saml2:AuthnRequest>`。这可以通过`RelyingPartyRegistrations`自动配置，也可以手动提供，例如：
+
+例1.不需要签名的authnrequests
+
+引导
+
+```
+spring:
+  security:
+    saml2:
+      relyingparty:
+        okta:
+          identityprovider:
+            entity-id: ...
+            singlesignon.sign-request: false
+```
+
+Java
+
+```
+RelyingPartyRegistration relyingPartyRegistration = RelyingPartyRegistration.withRegistrationId("okta")
+        // ...
+        .assertingPartyDetails(party -> party
+            // ...
+            .wantAuthnRequestsSigned(false)
+        )
+        .build();
+```
+
+Kotlin
+
+```
+var relyingPartyRegistration: RelyingPartyRegistration =
+    RelyingPartyRegistration.withRegistrationId("okta")
+        // ...
+        .assertingPartyDetails { party: AssertingPartyDetails.Builder -> party
+                // ...
+                .wantAuthnRequestsSigned(false)
+        }
+        .build();
+```
+
+否则，你将需要为`RelyingPartyRegistration#signingX509Credentials`指定一个私钥，以便 Spring Security可以在发送之前对`<saml2:AuthnRequest>`进行签名。
+
+默认情况下， Spring Security将使用`rsa-sha256`对`<saml2:AuthnRequest>`进行签名，尽管一些主张方将需要不同的算法，如其元数据中所示。
+
+你可以基于断言一方的[元数据使用`RelyingPartyRegistrations`]来配置算法（Overview.html# Servlet-SAML2Login-RelyingPartyRegistrationRepository）。
+
+或者，你可以手动提供它：
+
+Java
+
+```
+String metadataLocation = "classpath:asserting-party-metadata.xml";
+RelyingPartyRegistration relyingPartyRegistration = RelyingPartyRegistrations.fromMetadataLocation(metadataLocation)
+        // ...
+        .assertingPartyDetails((party) -> party
+            // ...
+            .signingAlgorithms((sign) -> sign.add(SignatureConstants.ALGO_ID_SIGNATURE_RSA_SHA512))
+        )
+        .build();
+```
+
+Kotlin
+
+```
+var metadataLocation = "classpath:asserting-party-metadata.xml"
+var relyingPartyRegistration: RelyingPartyRegistration =
+    RelyingPartyRegistrations.fromMetadataLocation(metadataLocation)
+        // ...
+        .assertingPartyDetails { party: AssertingPartyDetails.Builder -> party
+                // ...
+                .signingAlgorithms { sign: MutableList<String?> ->
+                    sign.add(
+                        SignatureConstants.ALGO_ID_SIGNATURE_RSA_SHA512
+                    )
+                }
+        }
+        .build();
+```
+
+|   |上面的代码片段使用OpenSAML`SignatureConstants`类来提供算法名称。<br/>但是，这只是为了方便。<br/>因为数据类型是`String`，所以你可以直接提供算法的名称。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+一些主张的缔约方要求张贴`<saml2:AuthnRequest>`。这可以通过`RelyingPartyRegistrations`自动配置，也可以手动提供，例如：
+
+Java
+
+```
+RelyingPartyRegistration relyingPartyRegistration = RelyingPartyRegistration.withRegistrationId("okta")
+        // ...
+        .assertingPartyDetails(party -> party
+            // ...
+            .singleSignOnServiceBinding(Saml2MessageBinding.POST)
+        )
+        .build();
+```
+
+Kotlin
+
+```
+var relyingPartyRegistration: RelyingPartyRegistration? =
+    RelyingPartyRegistration.withRegistrationId("okta")
+        // ...
+        .assertingPartyDetails { party: AssertingPartyDetails.Builder -> party
+            // ...
+            .singleSignOnServiceBinding(Saml2MessageBinding.POST)
+        }
+        .build()
+```
+
+## 定制OpenSAML的`AuthnRequest`实例
+
+你可能需要调整`AuthnRequest`的原因有很多。例如，你可能希望将`ForceAuthN`设置为`true`，而 Spring Security将其默认设置为`false`。
+
+如果你不需要来自`HttpServletRequest`的信息来做出决定，那么最简单的方法是[用OpenSAML注册一个自定义`AuthnRequestMarshaller`]（overview.html# Servlet-saml2login-opensaml-customization）。这将使你能够在序列化之前访问后处理`AuthnRequest`实例。
+
+但是，如果你确实需要来自该请求的某些内容，那么你可以使用创建一个自定义`Saml2AuthenticationRequestContext`实现，然后创建一个`Converter<Saml2AuthenticationRequestContext, AuthnRequest>`来构建自己的`AuthnRequest`，就像这样：
+
+Java
+
+```
+@Component
+public class AuthnRequestConverter implements
+        Converter<Saml2AuthenticationRequestContext, AuthnRequest> {
+
+    private final AuthnRequestBuilder authnRequestBuilder;
+    private final IssuerBuilder issuerBuilder;
+
+    // ... constructor
+
+    public AuthnRequest convert(Saml2AuthenticationRequestContext context) {
+        MySaml2AuthenticationRequestContext myContext = (MySaml2AuthenticationRequestContext) context;
+        Issuer issuer = issuerBuilder.buildObject();
+        issuer.setValue(myContext.getIssuer());
+
+        AuthnRequest authnRequest = authnRequestBuilder.buildObject();
+        authnRequest.setIssuer(issuer);
+        authnRequest.setDestination(myContext.getDestination());
+        authnRequest.setAssertionConsumerServiceURL(myContext.getAssertionConsumerServiceUrl());
+
+        // ... additional settings
+
+        authRequest.setForceAuthn(myContext.getForceAuthn());
+        return authnRequest;
+    }
+}
+```
+
+Kotlin
+
+```
+@Component
+class AuthnRequestConverter : Converter<Saml2AuthenticationRequestContext, AuthnRequest> {
+    private val authnRequestBuilder: AuthnRequestBuilder? = null
+    private val issuerBuilder: IssuerBuilder? = null
+
+    // ... constructor
+    override fun convert(context: Saml2AuthenticationRequestContext): AuthnRequest {
+        val myContext: MySaml2AuthenticationRequestContext = context
+        val issuer: Issuer = issuerBuilder.buildObject()
+        issuer.value = myContext.getIssuer()
+        val authnRequest: AuthnRequest = authnRequestBuilder.buildObject()
+        authnRequest.issuer = issuer
+        authnRequest.destination = myContext.getDestination()
+        authnRequest.assertionConsumerServiceURL = myContext.getAssertionConsumerServiceUrl()
+
+        // ... additional settings
+        authRequest.setForceAuthn(myContext.getForceAuthn())
+        return authnRequest
+    }
+}
+```
+
+然后，可以构造自己的`Saml2AuthenticationRequestContextResolver`和`Saml2AuthenticationRequestFactory`，并将它们发布为`@Bean`s:
+
+Java
+
+```
+@Bean
+Saml2AuthenticationRequestContextResolver authenticationRequestContextResolver() {
+    Saml2AuthenticationRequestContextResolver resolver =
+            new DefaultSaml2AuthenticationRequestContextResolver();
+    return request -> {
+        Saml2AuthenticationRequestContext context = resolver.resolve(request);
+        return new MySaml2AuthenticationRequestContext(context, request.getParameter("force") != null);
+    };
+}
+
+@Bean
+Saml2AuthenticationRequestFactory authenticationRequestFactory(
+        AuthnRequestConverter authnRequestConverter) {
+
+    OpenSaml4AuthenticationRequestFactory authenticationRequestFactory =
+            new OpenSaml4AuthenticationRequestFactory();
+    authenticationRequestFactory.setAuthenticationRequestContextConverter(authnRequestConverter);
+    return authenticationRequestFactory;
+}
+```
+
+Kotlin
+
+```
+@Bean
+open fun authenticationRequestContextResolver(): Saml2AuthenticationRequestContextResolver {
+    val resolver: Saml2AuthenticationRequestContextResolver = DefaultSaml2AuthenticationRequestContextResolver()
+    return Saml2AuthenticationRequestContextResolver { request: HttpServletRequest ->
+        val context = resolver.resolve(request)
+        MySaml2AuthenticationRequestContext(
+            context,
+            request.getParameter("force") != null
+        )
+    }
+}
+
+@Bean
+open fun authenticationRequestFactory(
+    authnRequestConverter: AuthnRequestConverter?
+): Saml2AuthenticationRequestFactory? {
+    val authenticationRequestFactory = OpenSaml4AuthenticationRequestFactory()
+    authenticationRequestFactory.setAuthenticationRequestContextConverter(authnRequestConverter)
+    return authenticationRequestFactory
+}
+```
+
+[SAML2日志概览](overview.html)[SAML2身份验证响应](authentication.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-saml2-login-authentication.md b/docs/spring-security/servlet-saml2-login-authentication.md
new file mode 100644
index 0000000..a8e49e8
--- /dev/null
+++ b/docs/spring-security/servlet-saml2-login-authentication.md
@@ -0,0 +1,357 @@
+# 验证`<saml2:Response>`s
+
+为了验证SAML2.0响应， Spring Security默认使用[`OpenSaml4AuthenticationProvider`]（overview.html# Servlet-saml2login-architecture）。
+
+你可以通过多种方式配置此功能，包括：
+
+1. 设置时钟倾斜以进行时间戳验证
+
+2. 将响应映射到`GrantedAuthority`实例的列表
+
+3. 自定义验证断言的策略
+
+4. 自定义解密响应和断言元素的策略
+
+要配置这些，你可以在DSL中使用`saml2Login#authenticationManager`方法。
+
+## 设置时钟倾斜
+
+主张和依赖方的系统时钟AREN不能完全同步，这并不罕见。出于这个原因，你可以在一定程度上配置`OpenSaml4AuthenticationProvider`的默认断言验证器：
+
+Java
+
+```
+@EnableWebSecurity
+public class SecurityConfig extends WebSecurityConfigurerAdapter {
+
+    @Override
+    protected void configure(HttpSecurity http) throws Exception {
+        OpenSaml4AuthenticationProvider authenticationProvider = new OpenSaml4AuthenticationProvider();
+        authenticationProvider.setAssertionValidator(OpenSaml4AuthenticationProvider
+                .createDefaultAssertionValidator(assertionToken -> {
+                    Map<String, Object> params = new HashMap<>();
+                    params.put(CLOCK_SKEW, Duration.ofMinutes(10).toMillis());
+                    // ... other validation parameters
+                    return new ValidationContext(params);
+                })
+        );
+
+        http
+            .authorizeHttpRequests(authz -> authz
+                .anyRequest().authenticated()
+            )
+            .saml2Login(saml2 -> saml2
+                .authenticationManager(new ProviderManager(authenticationProvider))
+            );
+    }
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+open class SecurityConfig : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        val authenticationProvider = OpenSaml4AuthenticationProvider()
+        authenticationProvider.setAssertionValidator(
+            OpenSaml4AuthenticationProvider
+                .createDefaultAssertionValidator(Converter<OpenSaml4AuthenticationProvider.AssertionToken, ValidationContext> {
+                    val params: MutableMap<String, Any> = HashMap()
+                    params[CLOCK_SKEW] =
+                        Duration.ofMinutes(10).toMillis()
+                    ValidationContext(params)
+                })
+        )
+        http {
+            authorizeRequests {
+                authorize(anyRequest, authenticated)
+            }
+            saml2Login {
+                authenticationManager = ProviderManager(authenticationProvider)
+            }
+        }
+    }
+}
+```
+
+## 与`UserDetailsService`协调
+
+或者，你可能希望包含来自遗留的`UserDetailsService`的用户详细信息。在这种情况下，响应身份验证转换器可以派上用场，如下所示：
+
+Java
+
+```
+@EnableWebSecurity
+public class SecurityConfig extends WebSecurityConfigurerAdapter {
+    @Autowired
+    UserDetailsService userDetailsService;
+
+    @Override
+    protected void configure(HttpSecurity http) throws Exception {
+        OpenSaml4AuthenticationProvider authenticationProvider = new OpenSaml4AuthenticationProvider();
+        authenticationProvider.setResponseAuthenticationConverter(responseToken -> {
+            Saml2Authentication authentication = OpenSaml4AuthenticationProvider
+                    .createDefaultResponseAuthenticationConverter() (1)
+                    .convert(responseToken);
+            Assertion assertion = responseToken.getResponse().getAssertions().get(0);
+            String username = assertion.getSubject().getNameID().getValue();
+            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username); (2)
+            return MySaml2Authentication(userDetails, authentication); (3)
+        });
+
+        http
+            .authorizeHttpRequests(authz -> authz
+                .anyRequest().authenticated()
+            )
+            .saml2Login(saml2 -> saml2
+                .authenticationManager(new ProviderManager(authenticationProvider))
+            );
+    }
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+open class SecurityConfig : WebSecurityConfigurerAdapter() {
+    @Autowired
+    var userDetailsService: UserDetailsService? = null
+
+    override fun configure(http: HttpSecurity) {
+        val authenticationProvider = OpenSaml4AuthenticationProvider()
+        authenticationProvider.setResponseAuthenticationConverter { responseToken: OpenSaml4AuthenticationProvider.ResponseToken ->
+            val authentication = OpenSaml4AuthenticationProvider
+                .createDefaultResponseAuthenticationConverter() (1)
+                .convert(responseToken)
+            val assertion: Assertion = responseToken.response.assertions[0]
+            val username: String = assertion.subject.nameID.value
+            val userDetails = userDetailsService!!.loadUserByUsername(username) (2)
+            MySaml2Authentication(userDetails, authentication) (3)
+        }
+        http {
+            authorizeRequests {
+                authorize(anyRequest, authenticated)
+            }
+            saml2Login {
+                authenticationManager = ProviderManager(authenticationProvider)
+            }
+        }
+    }
+}
+```
+
+|**1**|首先，调用默认的转换器，它从响应中提取属性和权限。|
+|-----|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|**2**|其次，使用相关信息调用[`UserDetailsService`]（../../身份验证/密码/user-details-service.html# Servlet-身份验证-userdetailsService）|
+|**3**|第三，返回包含用户详细信息的自定义身份验证|
+
+|   |它不需要调用`OpenSaml4AuthenticationProvider`的默认身份验证转换器。<br/>它返回一个`Saml2AuthenticatedPrincipal`，其中包含它从`AttributeStatement`s中提取的属性以及单个`ROLE_USER`权限。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## 执行额外的响应验证
+
+`OpenSaml4AuthenticationProvider`在解密`Response`后立即验证`Issuer`和`Destination`值。你可以通过扩展连接到你自己的响应验证器的默认验证器来定制验证，也可以用你自己的响应验证器完全替换它。
+
+例如，你可以抛出带有`Response`对象中可用的任何附加信息的自定义异常，例如：
+
+```
+OpenSaml4AuthenticationProvider provider = new OpenSaml4AuthenticationProvider();
+provider.setResponseValidator((responseToken) -> {
+	Saml2ResponseValidatorResult result = OpenSamlAuthenticationProvider
+		.createDefaultResponseValidator()
+		.convert(responseToken)
+		.concat(myCustomValidator.convert(responseToken));
+	if (!result.getErrors().isEmpty()) {
+		String inResponseTo = responseToken.getInResponseTo();
+		throw new CustomSaml2AuthenticationException(result, inResponseTo);
+	}
+	return result;
+});
+```
+
+## 执行附加的断言验证
+
+`OpenSaml4AuthenticationProvider`对SAML2.0断言执行最小的验证。在验证签名之后，它将：
+
+1. 验证`<AudienceRestriction>`和`<DelegationRestriction>`条件
+
+2. 验证`<SubjectConfirmation>`s，期望获得任何IP地址信息
+
+要执行额外的验证，你可以配置自己的断言验证器，将其委托给`OpenSaml4AuthenticationProvider`的默认值，然后执行自己的断言验证器。
+
+例如，你可以使用OpenSAML的`OneTimeUseConditionValidator`来验证`<OneTimeUse>`条件，如下所示：
+
+Java
+
+```
+OpenSaml4AuthenticationProvider provider = new OpenSaml4AuthenticationProvider();
+OneTimeUseConditionValidator validator = ...;
+provider.setAssertionValidator(assertionToken -> {
+    Saml2ResponseValidatorResult result = OpenSaml4AuthenticationProvider
+            .createDefaultAssertionValidator()
+            .convert(assertionToken);
+    Assertion assertion = assertionToken.getAssertion();
+    OneTimeUse oneTimeUse = assertion.getConditions().getOneTimeUse();
+    ValidationContext context = new ValidationContext();
+    try {
+        if (validator.validate(oneTimeUse, assertion, context) = ValidationResult.VALID) {
+            return result;
+        }
+    } catch (Exception e) {
+        return result.concat(new Saml2Error(INVALID_ASSERTION, e.getMessage()));
+    }
+    return result.concat(new Saml2Error(INVALID_ASSERTION, context.getValidationFailureMessage()));
+});
+```
+
+Kotlin
+
+```
+var provider = OpenSaml4AuthenticationProvider()
+var validator: OneTimeUseConditionValidator = ...
+provider.setAssertionValidator { assertionToken ->
+    val result = OpenSaml4AuthenticationProvider
+        .createDefaultAssertionValidator()
+        .convert(assertionToken)
+    val assertion: Assertion = assertionToken.assertion
+    val oneTimeUse: OneTimeUse = assertion.conditions.oneTimeUse
+    val context = ValidationContext()
+    try {
+        if (validator.validate(oneTimeUse, assertion, context) = ValidationResult.VALID) {
+            [email protected] result
+        }
+    } catch (e: Exception) {
+        [email protected] result.concat(Saml2Error(INVALID_ASSERTION, e.message))
+    }
+    result.concat(Saml2Error(INVALID_ASSERTION, context.validationFailureMessage))
+}
+```
+
+|   |虽然推荐使用，但没有必要调用`OpenSaml4AuthenticationProvider`的默认断言验证器。<br/>如果你不需要它来检查`<AudienceRestriction>`或`<SubjectConfirmation>`，那么你就可以跳过它，因为你是在自己执行这些操作。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## 自定义解密
+
+Spring 安全解密`<saml2:EncryptedAssertion>`，`<saml2:EncryptedAttribute>`，和`<saml2:EncryptedID>`元素，通过使用解密[`Saml2X509Credential`实例]（overview.html# Servlet-saml2login-rpr-creditions）在[`RelyingPartyRegistration`]中注册的（overview.html# Servlet-saml2login-relyingpartyregistration）。
+
+`OpenSaml4AuthenticationProvider`暴露[两种解密策略](overview.html#servlet-saml2login-architecture)。响应Decrypter用于解密`<saml2:Response>`中的加密元素，例如`<saml2:EncryptedAssertion>`。断言解密程序用于解密`<saml2:Assertion>`中的加密元素，例如`<saml2:EncryptedAttribute>`和`<saml2:EncryptedID>`。
+
+可以替换`OpenSaml4AuthenticationProvider’s default decryption strategy with your own. For example, if you have a separate service that decrypts the assertions in a `<saml2:Response>`，可以这样使用：
+
+Java
+
+```
+MyDecryptionService decryptionService = ...;
+OpenSaml4AuthenticationProvider provider = new OpenSaml4AuthenticationProvider();
+provider.setResponseElementsDecrypter((responseToken) -> decryptionService.decrypt(responseToken.getResponse()));
+```
+
+Kotlin
+
+```
+val decryptionService: MyDecryptionService = ...
+val provider = OpenSaml4AuthenticationProvider()
+provider.setResponseElementsDecrypter { responseToken -> decryptionService.decrypt(responseToken.response) }
+```
+
+如果你也在解密`<saml2:Assertion>`中的单个元素，那么也可以自定义断言解密程序：
+
+Java
+
+```
+provider.setAssertionElementsDecrypter((assertionToken) -> decryptionService.decrypt(assertionToken.getAssertion()));
+```
+
+Kotlin
+
+```
+provider.setAssertionElementsDecrypter { assertionToken -> decryptionService.decrypt(assertionToken.assertion) }
+```
+
+|   |由于断言可以与响应分开签名，因此有两个单独的解密器。<br/>在签名验证之前尝试解密签名断言的元素可能会使签名无效。<br/>如果你的断言方只签名响应，那么只使用响应解密器解密所有元素是安全的。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## 使用自定义身份验证管理器
+
+当然，`authenticationManager`DSL方法也可以用于执行完全自定义的SAML2.0身份验证。此身份验证管理器应该期望有一个`Saml2AuthenticationToken`对象，该对象包含SAML2.0响应XML数据。
+
+Java
+
+```
+@EnableWebSecurity
+public class SecurityConfig extends WebSecurityConfigurerAdapter {
+
+    @Override
+    protected void configure(HttpSecurity http) throws Exception {
+        AuthenticationManager authenticationManager = new MySaml2AuthenticationManager(...);
+        http
+            .authorizeHttpRequests(authorize -> authorize
+                .anyRequest().authenticated()
+            )
+            .saml2Login(saml2 -> saml2
+                .authenticationManager(authenticationManager)
+            )
+        ;
+    }
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+open class SecurityConfig : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        val customAuthenticationManager: AuthenticationManager = MySaml2AuthenticationManager(...)
+        http {
+            authorizeRequests {
+                authorize(anyRequest, authenticated)
+            }
+            saml2Login {
+                authenticationManager = customAuthenticationManager
+            }
+        }
+    }
+}
+```
+
+## 使用`Saml2AuthenticatedPrincipal`
+
+在为给定的断言方正确配置了依赖方之后，它就可以接受断言了。一旦依赖方验证了一个断言，结果就是一个`Saml2Authentication`和一个`Saml2AuthenticatedPrincipal`。
+
+这意味着你可以访问控制器中的主体，如下所示：
+
+Java
+
+```
+@Controller
+public class MainController {
+	@GetMapping("/")
+	public String index(@AuthenticationPrincipal Saml2AuthenticatedPrincipal principal, Model model) {
+		String email = principal.getFirstAttribute("email");
+		model.setAttribute("email", email);
+		return "index";
+	}
+}
+```
+
+Kotlin
+
+```
+@Controller
+class MainController {
+    @GetMapping("/")
+    fun index(@AuthenticationPrincipal principal: Saml2AuthenticatedPrincipal, model: Model): String {
+        val email = principal.getFirstAttribute<String>("email")
+        model.setAttribute("email", email)
+        return "index"
+    }
+}
+```
+
+|   |因为SAML2.0规范允许每个属性有多个值，所以你可以调用`getAttribute`来获取属性列表，也可以调用`getFirstAttribute`来获取列表中的第一个。当你知道只有一个值时，`getFirstAttribute`非常方便。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+[SAML2身份验证请求](authentication-requests.html)[SAML2注销](../logout.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-saml2-login-overview.md b/docs/spring-security/servlet-saml2-login-overview.md
new file mode 100644
index 0000000..041899f
--- /dev/null
+++ b/docs/spring-security/servlet-saml2-login-overview.md
@@ -0,0 +1,779 @@
+# SAML2.0登录概述
+
+让我们来看看SAML2.0依赖方身份验证在 Spring 安全性中是如何工作的。首先，我们看到，与[OAuth2.0登录](../../oauth2/login/index.html)类似， Spring 安全性将用户带到第三方进行身份验证。它通过一系列重定向来实现这一点。
+
+![SAML2WebssoAuthenticationRequestFilter](https://docs.spring.io/spring-security/reference/_images/servlet/saml2/saml2webssoauthenticationrequestfilter.png)
+
+图1.重定向到断言的一方身份验证
+
+上图构建了我们的[`SecurityFilterChain`]（../../architecture.html# Servlet-securityfilterchain）和[`AbstractAuthenticationProcessingFilter`]（.../../authentication/architecture.html# Servlet-authentication-abstractprocessingfilter）图：
+
+![number 1](https://docs.spring.io/spring-security/reference/_images/icons/number_1.png)首先，用户向资源`/private`发出未经授权的请求。
+
+![number 2](https://docs.spring.io/spring-security/reference/_images/icons/number_2.png) Spring security的[`FilterSecurityInterceptor`]（.../授权/authorization/authorization/authorization-requests.html# Servlet-authorization-filtersecurityinterceptor）通过抛出`AccessDeniedException`表示未经验证的请求*拒绝*。
+
+![number 3](https://docs.spring.io/spring-security/reference/_images/icons/number_3.png)由于用户缺乏授权，[`ExceptionTranslationFilter`]（../../architecture.html# Servlet-ExceptionTranslationFilter）发起*启动身份验证*。配置的[`AuthenticationEntryPoint`]（../.../authentication/architecture.html# Servlet-authentication-authenticationentryPoint）是[`LoginUrlAuthenticationEntryPoint`]（https://DOCS. Spring.io/ Spring-security/site/DOCS/5.6.2/api/org/springframework/security/web/authentication/loginurlauthenticationentrypoint.html）的一个实例，它会重定向到[`<saml2:AuthnRequest>`-genering-endpoint]（authenticationcentification-exposit或者，如果你已经[配置了多个断言对象](#servlet-saml2login-relyingpartyregistrationrepository)，它将首先重定向到一个选择器页面。
+
+![number 4](https://docs.spring.io/spring-security/reference/_images/icons/number_4.png)下一步，`Saml2WebSsoAuthenticationRequestFilter`使用其配置的[`Saml2AuthenticationRequestFactory`]（# Servlet-saml2login-sp-initiated-factory）创建、签名、序列化和编码`<saml2:AuthnRequest>`。
+
+![number 5](https://docs.spring.io/spring-security/reference/_images/icons/number_5.png)然后，浏览器接收这个`<saml2:AuthnRequest>`并将其呈现给断言的一方。断言一方试图对用户进行身份验证。如果成功，它将返回一个`<saml2:Response>`返回到浏览器。
+
+![number 6](https://docs.spring.io/spring-security/reference/_images/icons/number_6.png)浏览器然后将`<saml2:Response>`发布到断言消费者服务端点。
+
+![SAML2WebssoAuthenticationFilter](https://docs.spring.io/spring-security/reference/_images/servlet/saml2/saml2webssoauthenticationfilter.png)
+
+图2.验证`<saml2:Response>`
+
+这个图是基于我们的[`SecurityFilterChain`]（../../architecture.html# Servlet-SecurityFilterchain）图构建的。
+
+![number 1](https://docs.spring.io/spring-security/reference/_images/icons/number_1.png)当浏览器向应用程序提交`<saml2:Response>`时，它[委托给`Saml2WebSsoAuthenticationFilter`]（authentication.html# Servlet-saml2login-attenticate-responses）。该过滤器调用其配置的`AuthenticationConverter`，通过从`HttpServletRequest`中提取响应来创建`Saml2AuthenticationToken`。该转换器还解析[`重新注册政党`]（# Servlet-saml2login-relyingpartyregistration）并将其提供给`Saml2AuthenticationToken`。
+
+![number 2](https://docs.spring.io/spring-security/reference/_images/icons/number_2.png)接下来，筛选器将令牌传递给其配置的[`AuthenticationManager`]（.../authentication/architecture.html# Servlet-authentication-providermanager）。默认情况下，它将使用[`OpenSAML authentication provider`]（# Servlet-saml2login-architecture）。
+
+![number 3](https://docs.spring.io/spring-security/reference/_images/icons/number_3.png)如果身份验证失败，则*失败*
+
+* [`SecurityContextHolder`]（../../authentication/architecture.html# Servlet-authentication-securitycontextholder）被清除。
+
+* 调用[`AuthenticationEntryPoint`]（../../authentication/architecture.html# Servlet-authentication-authenticationentryPoint）来重新启动身份验证过程。
+
+![number 4](https://docs.spring.io/spring-security/reference/_images/icons/number_4.png)如果身份验证成功，则*成功*。
+
+* [`Authentication`]（../../authentication/architecture.html# Servlet-authentication-authentication）设置在[`SecurityContextHolder`]（../.../authentication/architecture.html# Servlet-authentication-securitycontexolder）上。
+
+* `Saml2WebSsoAuthenticationFilter`调用`FilterChain#doFilter(request,response)`以继续应用程序逻辑的其余部分。
+
+## 最小依赖
+
+SAML2.0服务提供者支持驻留在`spring-security-saml2-service-provider`中。它是在OpenSAML库的基础上构建的。
+
+## 最小配置
+
+当使用[Spring Boot](https://spring.io/projects/spring-boot)时，将应用程序配置为服务提供者包括两个基本步骤。首先，包括所需的依赖关系，其次，指示必要的断言方元数据。
+
+|   |另外，这也意味着你已经[向你的主张方登记了依赖方。](../metadata.html#servlet-saml2login-metadata)了。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 指定身份提供程序元数据
+
+在 Spring 引导应用程序中，要指定身份提供者的元数据，只需执行以下操作：
+
+```
+spring:
+  security:
+    saml2:
+      relyingparty:
+        registration:
+          adfs:
+            identityprovider:
+              entity-id: https://idp.example.com/issuer
+              verification.credentials:
+                - certificate-location: "classpath:idp.crt"
+              singlesignon.url: https://idp.example.com/issuer/sso
+              singlesignon.sign-request: false
+```
+
+哪里
+
+* `[https://idp.example.com/issuer](https://idp.example.com/issuer)`是身份提供程序将发出的SAML响应的`Issuer`属性中包含的值
+
+* `classpath:idp.crt`是 Classpath 上用于验证SAML响应的身份提供程序证书的位置，并且
+
+* `[https://idp.example.com/issuer/sso](https://idp.example.com/issuer/sso)`是标识提供程序期望`AuthnRequest`s的端点。
+
+* `adfs`是[你选择的任意标识符](#servlet-saml2login-relyingpartyregistrationid)
+
+就这样！
+
+|   |标识提供者和声明方是同义词，服务提供者和依赖方也是同义词。<br/>它们通常分别缩写为AP和RP。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 运行时期望
+
+按照上面的配置，应用程序处理任何`POST /login/saml2/sso/{registrationId}`请求，其中包含`SAMLResponse`参数：
+
+```
+POST /login/saml2/sso/adfs HTTP/1.1
+
+SAMLResponse=PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZ...
+```
+
+有两种方法可以看到诱导你的断言一方生成`SAMLResponse`:
+
+* 首先，你可以导航到你的主张的一方。它可能为每个注册的依赖方提供了某种类型的链接或按钮，你可以单击这些链接或按钮发送`SAMLResponse`。
+
+* 其次，你可以导航到应用程序中的受保护页面，例如`[http://localhost:8080](http://localhost:8080)`。然后，你的应用程序将重定向到配置的断言对象，然后发送`SAMLResponse`。
+
+从这里开始，考虑跳到：
+
+* [SAML2.0Login如何与OpenSAML集成](#servlet-saml2login-architecture)
+
+* [如何使用`Saml2AuthenticatedPrincipal`]（authentication.html# Servlet-saml2login-authenticatedprincipal）
+
+* [How to Override or Replace Spring Boot’s Auto Configuration](#servlet-saml2login-sansboot)
+
+## SAML2.0Login如何与OpenSAML集成
+
+Spring Security的SAML2.0支持有两个设计目标：
+
+* 首先，依赖SAML2.0操作和域对象的库。为了实现这一点， Spring Security使用了OpenSAML。
+
+* 其次，确保在使用 Spring Security的SAML支持时不需要这个库。为了实现这一点， Spring Security在契约中使用OpenSAML的任何接口或类都保持封装。这使得你可以将OpenSAML转换为其他一些库，甚至是OpenSAML的不支持版本。
+
+作为上述两个目标的自然结果， Spring Security的SAML API相对于其他模块来说非常小。相反，像`OpenSaml4AuthenticationRequestFactory`和`OpenSaml4AuthenticationProvider`这样的类暴露了在身份验证过程中定制各种步骤的`Converter`s。
+
+例如，一旦应用程序接收到`SAMLResponse`并委托给`Saml2WebSsoAuthenticationFilter`，过滤器将委托给`OpenSaml4AuthenticationProvider`。
+
+|   |对于向后兼容性， Spring Security默认情况下将使用最新的OpenSAML3.，注意，尽管OpenSAML3已经达到了使用寿命，建议更新到OpenSAML4.x。，由于这个原因， Spring Security同时支持OpenSAML3.x和4.x。，如果你将OpenSAML依赖关系管理到4.x，<gt R=“110”/，然后 Spring Security将选择其OpenSAML4.x实现。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+验证OpenSAML`Response`
+
+![OpenSAMLauthenticationProvider](https://docs.spring.io/spring-security/reference/_images/servlet/saml2/opensamlauthenticationprovider.png)
+
+此图构建于[`Saml2WebSsoAuthenticationFilter`图]（# Servlet-SAML2login-Authentication-SAML2WebssoAuthenticationFilter）。
+
+![number 1](https://docs.spring.io/spring-security/reference/_images/icons/number_1.png)the`Saml2WebSsoAuthenticationFilter`表示`Saml2AuthenticationToken`并调用[`AuthenticationManager`]（.././authentication/architecture.html# Servlet-authentication-providermanager）。
+
+![number 2](https://docs.spring.io/spring-security/reference/_images/icons/number_2.png)[`AuthenticationManager`]（../../authentication/architecture.html# Servlet-authentication-providermanager）调用OpenSAML身份验证提供者。
+
+![number 3](https://docs.spring.io/spring-security/reference/_images/icons/number_3.png)身份验证提供程序将响应反序列化为OpenSAML`Response`并检查其签名。如果签名无效，则验证失败。
+
+![number 4](https://docs.spring.io/spring-security/reference/_images/icons/number_4.png)然后，提供程序[解密任何`EncryptedAssertion`元素]（authentication.html# Servlet-saml2login-opensamlauthenticationprovider-decryption）。如果任何解密失败，验证就失败了。
+
+![number 5](https://docs.spring.io/spring-security/reference/_images/icons/number_5.png)接下来，提供程序验证响应的`Issuer`和`Destination`值。如果它们与`RelyingPartyRegistration`中的内容不匹配，则验证失败。
+
+![number 6](https://docs.spring.io/spring-security/reference/_images/icons/number_6.png)之后，提供者验证每个`Assertion`的签名。如果任何签名无效，则验证失败。此外，如果响应和断言都没有签名，则身份验证失败。响应或所有断言都必须具有签名。
+
+![number 7](https://docs.spring.io/spring-security/reference/_images/icons/number_7.png)然后，提供程序[,](authentication.html#servlet-saml2login-opensamlauthenticationprovider-decryption)解密任何`EncryptedID`或`EncryptedAttribute`元素]。如果任何解密失败，验证就失败了。
+
+![number 8](https://docs.spring.io/spring-security/reference/_images/icons/number_8.png)接下来，提供程序验证每个断言的`ExpiresAt`和`NotBefore`时间戳、`<Subject>`和任何`<AudienceRestriction>`条件。如果任何验证失败，则验证失败。
+
+![number 9](https://docs.spring.io/spring-security/reference/_images/icons/number_9.png)之后，提供者获取第一个断言的`AttributeStatement`，并将其映射到`Map<String, List<Object>>`。它还授予`ROLE_USER`授权。
+
+![number 10](https://docs.spring.io/spring-security/reference/_images/icons/number_10.png)最后，它从第一个断言、属性的`Map`和`GrantedAuthority`中获取`NameID`，并构造`Saml2AuthenticatedPrincipal`。然后，它把委托人和当权者归为`Saml2Authentication`。
+
+得到的`Authentication#getPrincipal`是一个 Spring security`Saml2AuthenticatedPrincipal`对象，并且`Authentication#getName`映射到第一个断言的`NameID`元素。`Saml2AuthenticatedPrincipal#getRelyingPartyRegistrationId`保存了关联`RelyingPartyRegistration`的[标识符]（# Servlet-saml2login-relyingpartyregistrationID）。
+
+### 定制OpenSAML配置
+
+同时使用 Spring Security和OpenSAML的任何类都应该在类的开头静态初始化`OpenSamlInitializationService`，如下所示：
+
+Java
+
+```
+static {
+	OpenSamlInitializationService.initialize();
+}
+```
+
+Kotlin
+
+```
+companion object {
+    init {
+        OpenSamlInitializationService.initialize()
+    }
+}
+```
+
+这取代了OpenSAML的`InitializationService#initialize`。
+
+有时，定制OpenSAML构建、Marshalls和unmarshallsSAML对象的方式是很有价值的。在这种情况下，你可能希望调用`OpenSamlInitializationService#requireInitialize(Consumer)`，这样就可以访问OpenSAML的`XMLObjectProviderFactory`。
+
+例如，当发送未签名的authnrequest时，你可能希望强制进行重新身份验证。在这种情况下，你可以注册自己的`AuthnRequestMarshaller`，如下所示：
+
+Java
+
+```
+static {
+    OpenSamlInitializationService.requireInitialize(factory -> {
+        AuthnRequestMarshaller marshaller = new AuthnRequestMarshaller() {
+            @Override
+            public Element marshall(XMLObject object, Element element) throws MarshallingException {
+                configureAuthnRequest((AuthnRequest) object);
+                return super.marshall(object, element);
+            }
+
+            public Element marshall(XMLObject object, Document document) throws MarshallingException {
+                configureAuthnRequest((AuthnRequest) object);
+                return super.marshall(object, document);
+            }
+
+            private void configureAuthnRequest(AuthnRequest authnRequest) {
+                authnRequest.setForceAuthn(true);
+            }
+        }
+
+        factory.getMarshallerFactory().registerMarshaller(AuthnRequest.DEFAULT_ELEMENT_NAME, marshaller);
+    });
+}
+```
+
+Kotlin
+
+```
+companion object {
+    init {
+        OpenSamlInitializationService.requireInitialize {
+            val marshaller = object : AuthnRequestMarshaller() {
+                override fun marshall(xmlObject: XMLObject, element: Element): Element {
+                    configureAuthnRequest(xmlObject as AuthnRequest)
+                    return super.marshall(xmlObject, element)
+                }
+
+                override fun marshall(xmlObject: XMLObject, document: Document): Element {
+                    configureAuthnRequest(xmlObject as AuthnRequest)
+                    return super.marshall(xmlObject, document)
+                }
+
+                private fun configureAuthnRequest(authnRequest: AuthnRequest) {
+                    authnRequest.isForceAuthn = true
+                }
+            }
+            it.marshallerFactory.registerMarshaller(AuthnRequest.DEFAULT_ELEMENT_NAME, marshaller)
+        }
+    }
+}
+```
+
+每个应用程序实例只能调用`requireInitialize`方法一次。
+
+## 覆盖或替换Boot Auto配置
+
+Spring Boot为依赖方生成两个`@Bean`s。
+
+第一种是将应用程序配置为依赖方的`WebSecurityConfigurerAdapter`。当包含`spring-security-saml2-service-provider`时，`WebSecurityConfigurerAdapter`看起来像：
+
+例1.默认的JWT配置
+
+Java
+
+```
+protected void configure(HttpSecurity http) {
+    http
+        .authorizeHttpRequests(authorize -> authorize
+            .anyRequest().authenticated()
+        )
+        .saml2Login(withDefaults());
+}
+```
+
+Kotlin
+
+```
+fun configure(http: HttpSecurity) {
+    http {
+        authorizeRequests {
+            authorize(anyRequest, authenticated)
+        }
+        saml2Login { }
+    }
+}
+```
+
+如果应用程序不公开`WebSecurityConfigurerAdapter` Bean，那么 Spring 引导将公开上面的默认引导。
+
+你可以通过在应用程序中公开 Bean 来替换此选项：
+
+例2.自定义SAML2.0登录配置
+
+Java
+
+```
+@EnableWebSecurity
+public class MyCustomSecurityConfiguration extends WebSecurityConfigurerAdapter {
+    protected void configure(HttpSecurity http) {
+        http
+            .authorizeHttpRequests(authorize -> authorize
+                .mvcMatchers("/messages/**").hasAuthority("ROLE_USER")
+                .anyRequest().authenticated()
+            )
+            .saml2Login(withDefaults());
+    }
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class MyCustomSecurityConfiguration : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            authorizeRequests {
+                authorize("/messages/**", hasAuthority("ROLE_USER"))
+                authorize(anyRequest, authenticated)
+            }
+            saml2Login {
+            }
+        }
+    }
+}
+```
+
+对于任何以`/messages/`开头的URL，上面要求`USER`的角色。
+
+第二个`@Bean` Spring 引导创建的是一个[`RelyingPartyRegistrationRepository`]（https://DOCS. Spring.io/ Spring-security/site/DOCS/5.6.2/api/org/springframework/security/saml2/provider/service/registration/registrationpartyregistrationrepository.html），它代表了主张方和依赖方的元数据。这包括诸如依赖方在请求断言方验证时应使用的SSO端点的位置之类的内容。
+
+你可以通过发布自己的`RelyingPartyRegistrationRepository` Bean 来覆盖默认值。例如，你可以通过点击其元数据端点来查找断言一方的配置，如下所示：
+
+例3.依赖方注册存储库
+
+Java
+
+```
+@Value("${metadata.location}")
+String assertingPartyMetadataLocation;
+
+@Bean
+public RelyingPartyRegistrationRepository relyingPartyRegistrations() {
+    RelyingPartyRegistration registration = RelyingPartyRegistrations
+            .fromMetadataLocation(assertingPartyMetadataLocation)
+            .registrationId("example")
+            .build();
+    return new InMemoryRelyingPartyRegistrationRepository(registration);
+}
+```
+
+Kotlin
+
+```
+@Value("\${metadata.location}")
+var assertingPartyMetadataLocation: String? = null
+
+@Bean
+open fun relyingPartyRegistrations(): RelyingPartyRegistrationRepository? {
+    val registration = RelyingPartyRegistrations
+        .fromMetadataLocation(assertingPartyMetadataLocation)
+        .registrationId("example")
+        .build()
+    return InMemoryRelyingPartyRegistrationRepository(registration)
+}
+```
+
+|   |`registrationId`是你选择的用于区分注册的任意值。|
+|---|-----------------------------------------------------------------------------------------------------|
+
+或者，你可以手动提供每个细节，如下所示：
+
+例4.依赖方注册存储库手动配置
+
+Java
+
+```
+@Value("${verification.key}")
+File verificationKey;
+
+@Bean
+public RelyingPartyRegistrationRepository relyingPartyRegistrations() throws Exception {
+    X509Certificate certificate = X509Support.decodeCertificate(this.verificationKey);
+    Saml2X509Credential credential = Saml2X509Credential.verification(certificate);
+    RelyingPartyRegistration registration = RelyingPartyRegistration
+            .withRegistrationId("example")
+            .assertingPartyDetails(party -> party
+                .entityId("https://idp.example.com/issuer")
+                .singleSignOnServiceLocation("https://idp.example.com/SSO.saml2")
+                .wantAuthnRequestsSigned(false)
+                .verificationX509Credentials(c -> c.add(credential))
+            )
+            .build();
+    return new InMemoryRelyingPartyRegistrationRepository(registration);
+}
+```
+
+Kotlin
+
+```
+@Value("\${verification.key}")
+var verificationKey: File? = null
+
+@Bean
+open fun relyingPartyRegistrations(): RelyingPartyRegistrationRepository {
+    val certificate: X509Certificate? = X509Support.decodeCertificate(verificationKey!!)
+    val credential: Saml2X509Credential = Saml2X509Credential.verification(certificate)
+    val registration = RelyingPartyRegistration
+        .withRegistrationId("example")
+        .assertingPartyDetails { party: AssertingPartyDetails.Builder ->
+            party
+                .entityId("https://idp.example.com/issuer")
+                .singleSignOnServiceLocation("https://idp.example.com/SSO.saml2")
+                .wantAuthnRequestsSigned(false)
+                .verificationX509Credentials { c: MutableCollection<Saml2X509Credential?> ->
+                    c.add(
+                        credential
+                    )
+                }
+        }
+        .build()
+    return InMemoryRelyingPartyRegistrationRepository(registration)
+}
+```
+
+|   |请注意，`X509Support`是一个OpenSAML类，在这里的代码片段中使用它是为了简洁|
+|---|----------------------------------------------------------------------------------|
+
+或者，你可以使用DSL直接连接存储库，这也将覆盖自动配置的`WebSecurityConfigurerAdapter`:
+
+例5.自定义依赖方注册DSL
+
+Java
+
+```
+@EnableWebSecurity
+public class MyCustomSecurityConfiguration extends WebSecurityConfigurerAdapter {
+    protected void configure(HttpSecurity http) {
+        http
+            .authorizeHttpRequests(authorize -> authorize
+                .mvcMatchers("/messages/**").hasAuthority("ROLE_USER")
+                .anyRequest().authenticated()
+            )
+            .saml2Login(saml2 -> saml2
+                .relyingPartyRegistrationRepository(relyingPartyRegistrations())
+            );
+    }
+}
+```
+
+Kotlin
+
+```
+@EnableWebSecurity
+class MyCustomSecurityConfiguration : WebSecurityConfigurerAdapter() {
+    override fun configure(http: HttpSecurity) {
+        http {
+            authorizeRequests {
+                authorize("/messages/**", hasAuthority("ROLE_USER"))
+                authorize(anyRequest, authenticated)
+            }
+            saml2Login {
+                relyingPartyRegistrationRepository = relyingPartyRegistrations()
+            }
+        }
+    }
+}
+```
+
+|   |通过在`RelyingPartyRegistrationRepository`中注册多个依赖方，依赖方可以是多租户。|
+|---|---------------------------------------------------------------------------------------------------------------------------|
+
+## RelyingPartyRegistration
+
+[`RelyingPartyRegistration`]（https://DOCS. Spring.io/ Spring-security/site/DOCS/5.6.2/api/org/springframework/security/saml2/provider/service/registration/registration/relypartyregistration.html）实例表示依赖方和断言方元数据之间的链接。
+
+在`RelyingPartyRegistration`中，你可以提供依赖方的元数据，比如它的`Issuer`值，它希望将SAML响应发送到该值，以及它为签名或解密有效负载而OWNS的任何凭据。
+
+此外，你还可以提供断言方元数据，比如它的`Issuer`值（它期望向其发送authnrequests），以及它为依赖方验证或加密有效负载而OWNS的任何公共凭据。
+
+以下`RelyingPartyRegistration`是大多数设置所需的最低要求：
+
+Java
+
+```
+RelyingPartyRegistration relyingPartyRegistration = RelyingPartyRegistrations
+        .fromMetadataLocation("https://ap.example.org/metadata")
+        .registrationId("my-id")
+        .build();
+```
+
+Kotlin
+
+```
+val relyingPartyRegistration = RelyingPartyRegistrations
+    .fromMetadataLocation("https://ap.example.org/metadata")
+    .registrationId("my-id")
+    .build()
+```
+
+请注意，你也可以从任意的`InputStream`源创建`RelyingPartyRegistration`。一个这样的例子是当元数据存储在数据库中时：
+
+```
+String xml = fromDatabase();
+try (InputStream source = new ByteArrayInputStream(xml.getBytes())) {
+    RelyingPartyRegistration relyingPartyRegistration = RelyingPartyRegistrations
+            .fromMetadata(source)
+            .registrationId("my-id")
+            .build();
+}
+```
+
+尽管更复杂的设置也是可能的，比如：
+
+Java
+
+```
+RelyingPartyRegistration relyingPartyRegistration = RelyingPartyRegistration.withRegistrationId("my-id")
+        .entityId("{baseUrl}/{registrationId}")
+        .decryptionX509Credentials(c -> c.add(relyingPartyDecryptingCredential()))
+        .assertionConsumerServiceLocation("/my-login-endpoint/{registrationId}")
+        .assertingPartyDetails(party -> party
+                .entityId("https://ap.example.org")
+                .verificationX509Credentials(c -> c.add(assertingPartyVerifyingCredential()))
+                .singleSignOnServiceLocation("https://ap.example.org/SSO.saml2")
+        )
+        .build();
+```
+
+Kotlin
+
+```
+val relyingPartyRegistration =
+    RelyingPartyRegistration.withRegistrationId("my-id")
+        .entityId("{baseUrl}/{registrationId}")
+        .decryptionX509Credentials { c: MutableCollection<Saml2X509Credential?> ->
+            c.add(relyingPartyDecryptingCredential())
+        }
+        .assertionConsumerServiceLocation("/my-login-endpoint/{registrationId}")
+        .assertingPartyDetails { party -> party
+                .entityId("https://ap.example.org")
+                .verificationX509Credentials { c -> c.add(assertingPartyVerifyingCredential()) }
+                .singleSignOnServiceLocation("https://ap.example.org/SSO.saml2")
+        }
+        .build()
+```
+
+|   |顶级元数据方法是关于依赖方的详细信息。<br/>`assertingPartyDetails`中的方法是关于断言方的详细信息。|
+|---|---------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+|   |依赖方期望SAML响应的位置是断言消费者服务位置。|
+|---|----------------------------------------------------------------------------------------------------------|
+
+依赖方的`entityId`的默认值是`{baseUrl}/saml2/service-provider-metadata/{registrationId}`。这是在配置主张方以了解你的依赖方时所需的值。
+
+`assertionConsumerServiceLocation`的默认值是`/login/saml2/sso/{registrationId}`。默认情况下，它被映射到过滤器链中的[`Saml2WebSsoAuthenticationFilter`]（# Servlet-SAML2login-Authentication-SAML2WebssoAuthenticationFilter）。
+
+### URI模式
+
+你可能在上面的示例中注意到了`{baseUrl}`和`{registrationId}`占位符。
+
+这些对于生成URI非常有用。因此，依赖方的`entityId`和`assertionConsumerServiceLocation`支持以下占位符：
+
+* `baseUrl`-已部署应用程序的方案、主机和端口
+
+* `registrationId`-此依赖方的注册ID
+
+* `baseScheme`-已部署应用程序的方案
+
+* `baseHost`-已部署应用程序的主机
+
+* `basePort`-已部署应用程序的端口
+
+例如，上面定义的`assertionConsumerServiceLocation`是：
+
+`/my-login-endpoint/{registrationId}`
+
+在已部署的应用程序中，它将转换为
+
+`/my-login-endpoint/adfs`
+
+上述`entityId`定义为：
+
+`{baseUrl}/{registrationId}`
+
+在已部署的应用程序中，它将转换为
+
+`https://rp.example.com/adfs`
+
+### 证书
+
+你还可能注意到了所使用的凭据。
+
+通常情况下，依赖方将使用相同的密钥对有效载荷进行签名和解密。或者，它将使用相同的密钥来验证有效负载并对其进行加密。
+
+因此， Spring Security附带`Saml2X509Credential`，这是一种特定于SAML的凭据，它简化了针对不同用例配置相同密钥的过程。
+
+至少，有必要获得申述方的证明，这样申述方的签名回复才能得到验证。
+
+要构造一个`Saml2X509Credential`来验证来自断言一方的断言，你可以加载该文件并使用`CertificateFactory`，如下所示：
+
+Java
+
+```
+Resource resource = new ClassPathResource("ap.crt");
+try (InputStream is = resource.getInputStream()) {
+    X509Certificate certificate = (X509Certificate)
+            CertificateFactory.getInstance("X.509").generateCertificate(is);
+    return Saml2X509Credential.verification(certificate);
+}
+```
+
+Kotlin
+
+```
+val resource = ClassPathResource("ap.crt")
+resource.inputStream.use {
+    return Saml2X509Credential.verification(
+        CertificateFactory.getInstance("X.509").generateCertificate(it) as X509Certificate?
+    )
+}
+```
+
+让我们假设，主张权利的一方也将对主张进行加密。在这种情况下，依赖方将需要一个私钥来解密加密值。
+
+在这种情况下，你将需要一个`RSAPrivateKey`及其对应的`X509Certificate`。你可以使用 Spring Security的`RsaKeyConverters`实用程序类加载第一个，然后像以前一样加载第二个：
+
+Java
+
+```
+X509Certificate certificate = relyingPartyDecryptionCertificate();
+Resource resource = new ClassPathResource("rp.crt");
+try (InputStream is = resource.getInputStream()) {
+    RSAPrivateKey rsa = RsaKeyConverters.pkcs8().convert(is);
+    return Saml2X509Credential.decryption(rsa, certificate);
+}
+```
+
+Kotlin
+
+```
+val certificate: X509Certificate = relyingPartyDecryptionCertificate()
+val resource = ClassPathResource("rp.crt")
+resource.inputStream.use {
+    val rsa: RSAPrivateKey = RsaKeyConverters.pkcs8().convert(it)
+    return Saml2X509Credential.decryption(rsa, certificate)
+}
+```
+
+|   |当你将这些文件的位置指定为适当的 Spring 引导属性时， Spring 引导将为你执行这些转换。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### 从请求中解决依赖方
+
+到目前为止， Spring Security通过在URI路径中查找注册ID来解析`RelyingPartyRegistration`。
+
+你可能想要定制的原因有很多。其中：
+
+* 你可能知道你永远不会是一个多租户应用程序，因此希望有一个更简单的URL方案
+
+* 你可以通过URI路径以外的方式来识别租户。
+
+要定制解析`RelyingPartyRegistration`的方式，可以配置自定义的`RelyingPartyRegistrationResolver`。默认值从URI的Last PATH元素中查找注册ID，并在`RelyingPartyRegistrationRepository`中查找它。
+
+你可以提供一个更简单的解析器，例如，它总是返回相同的依赖方：
+
+Java
+
+```
+public class SingleRelyingPartyRegistrationResolver implements RelyingPartyRegistrationResolver {
+
+    private final RelyingPartyRegistrationResolver delegate;
+
+    public SingleRelyingPartyRegistrationResolver(RelyingPartyRegistrationRepository registrations) {
+        this.delegate = new DefaultRelyingPartyRegistrationResolver(registrations);
+    }
+
+    @Override
+    public RelyingPartyRegistration resolve(HttpServletRequest request, String registrationId) {
+        return this.delegate.resolve(request, "single");
+    }
+}
+```
+
+Kotlin
+
+```
+class SingleRelyingPartyRegistrationResolver(delegate: RelyingPartyRegistrationResolver) : RelyingPartyRegistrationResolver {
+    override fun resolve(request: HttpServletRequest?, registrationId: String?): RelyingPartyRegistration? {
+        return this.delegate.resolve(request, "single")
+    }
+}
+```
+
+然后，你可以将此解析器提供给适当的过滤器，这些过滤器可以[产生`<saml2:AuthnRequest>`s]（authentication-requests.html# Servlet-saml2login-sp-initiated-factory），[authenticate`<saml2:Response>`s]（authentication.html# Servlet-saml2login-authenticate-responses-responses），和[产生`<saml2:SPSSODescriptor>`元数据]（../metadata.html# Servlet-saml2
+
+|   |请记住，如果你的`RelyingPartyRegistration`中有任何占位符，那么你的解析器实现应该解析它们。|
+|---|--------------------------------------------------------------------------------------------------------------------------------|
+
+### 重复的依赖方配置
+
+当应用程序使用多个断言对象时，在`RelyingPartyRegistration`实例之间会重复一些配置：
+
+* 依赖方的`entityId`
+
+* 其`assertionConsumerServiceLocation`，以及
+
+* 它的凭据，例如它的签名或解密凭据
+
+这种设置的好处是，对于某些身份提供者来说，证书的轮换可能比其他身份提供者更容易。
+
+复制可以通过几种不同的方式来减轻。
+
+首先，在YAML中，可以通过引用来缓解这种情况，例如：
+
+```
+spring:
+  security:
+    saml2:
+      relyingparty:
+        okta:
+          signing.credentials: &relying-party-credentials
+            - private-key-location: classpath:rp.key
+              certificate-location: classpath:rp.crt
+          identityprovider:
+            entity-id: ...
+        azure:
+          signing.credentials: *relying-party-credentials
+          identityprovider:
+            entity-id: ...
+```
+
+其次，在数据库中，不需要复制`RelyingPartyRegistration`的模型。
+
+第三，在 Java 中，你可以创建一个自定义的配置方法，例如：
+
+Java
+
+```
+private RelyingPartyRegistration.Builder
+        addRelyingPartyDetails(RelyingPartyRegistration.Builder builder) {
+
+    Saml2X509Credential signingCredential = ...
+    builder.signingX509Credentials(c -> c.addAll(signingCredential));
+    // ... other relying party configurations
+}
+
+@Bean
+public RelyingPartyRegistrationRepository relyingPartyRegistrations() {
+    RelyingPartyRegistration okta = addRelyingPartyDetails(
+            RelyingPartyRegistrations
+                .fromMetadataLocation(oktaMetadataUrl)
+                .registrationId("okta")).build();
+
+    RelyingPartyRegistration azure = addRelyingPartyDetails(
+            RelyingPartyRegistrations
+                .fromMetadataLocation(oktaMetadataUrl)
+                .registrationId("azure")).build();
+
+    return new InMemoryRelyingPartyRegistrationRepository(okta, azure);
+}
+```
+
+Kotlin
+
+```
+private fun addRelyingPartyDetails(builder: RelyingPartyRegistration.Builder): RelyingPartyRegistration.Builder {
+    val signingCredential: Saml2X509Credential = ...
+    builder.signingX509Credentials { c: MutableCollection<Saml2X509Credential?> ->
+        c.add(
+            signingCredential
+        )
+    }
+    // ... other relying party configurations
+}
+
+@Bean
+open fun relyingPartyRegistrations(): RelyingPartyRegistrationRepository? {
+    val okta = addRelyingPartyDetails(
+        RelyingPartyRegistrations
+            .fromMetadataLocation(oktaMetadataUrl)
+            .registrationId("okta")
+    ).build()
+    val azure = addRelyingPartyDetails(
+        RelyingPartyRegistrations
+            .fromMetadataLocation(oktaMetadataUrl)
+            .registrationId("azure")
+    ).build()
+    return InMemoryRelyingPartyRegistrationRepository(okta, azure)
+}
+```
+
+[SAML2登录](index.html)[SAML2身份验证请求](authentication-requests.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-saml2-login.md b/docs/spring-security/servlet-saml2-login.md
new file mode 100644
index 0000000..13fec3f
--- /dev/null
+++ b/docs/spring-security/servlet-saml2-login.md
@@ -0,0 +1,19 @@
+# SAML2.0登录
+
+SAML2.0登录特性为应用程序提供了充当SAML2.0依赖方的能力，使用户[log in](https://wiki.shibboleth.net/confluence/display/CONCEPT/FlowsAndConfig)通过使用其在SAML2.0声明方（OKTA、ADFS等）的现有帐户来访问应用程序。
+
+|   |SAML2.0登录是通过使用**Web浏览器SSO配置文件**实现的，如[SAML2配置文件](https://www.oasis-open.org/committees/download.php/35389/sstc-saml-profiles-errata-2.0-wd-06-diff.pdf#page=15)中所指定的。|
+|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+自2009年以来，对依赖方的支持以[扩展项目](https://github.com/spring-projects/spring-security-saml/tree/1e013b07a7772defd6a26fcfae187c9bf661ee8f#spring-saml)的形式存在。2019年，该过程开始将其移植到[Spring Security](https://github.com/spring-projects/spring-security)proper中。这个过程类似于2017年开始的[Spring Security’s OAuth 2.0 support](../../oauth2/index.html)的过程。
+
+|   |[SAML2.0登录](https://github.com/spring-projects/spring-security-samples/tree/5.6.x/servlet/spring-boot/java/saml2/login)的工作示例在[Spring Security Samples repository](https://github.com/spring-projects/spring-security-samples/tree/5.6.x)中可用。|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## 章节摘要
+
+* [SAML2日志概览](overview.html)
+* [SAML2身份验证请求](authentication-requests.html)
+* [SAML2身份验证响应](authentication.html)
+
+[SAML2](../index.html)[SAML2日志概览](overview.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-saml2-logout.md b/docs/spring-security/servlet-saml2-logout.md
new file mode 100644
index 0000000..49bc381
--- /dev/null
+++ b/docs/spring-security/servlet-saml2-logout.md
@@ -0,0 +1,282 @@
+# 执行单注销
+
+Spring 安全性支持RP和AP发起的SAML2.0单注销。
+
+简单地说，有两个用例 Spring 安全支持：
+
+* **RP-initiated **-你的应用程序有一个端点，当发送到该端点时，该端点将注销该用户并向断言的一方发送`saml2:LogoutRequest`。在此之后，断言方会返回一个`saml2:LogoutResponse`并允许你的应用程序进行响应
+
+* **AP-initied **-你的应用程序有一个端点，它将从主张方接收`saml2:LogoutRequest`。你的应用程序将在此时完成注销，然后向断言的一方发送`saml2:LogoutResponse`。
+
+|   |在**AP-initied **场景中，应用程序在注销后进行的任何本地重定向都是没有意义的。<br/>一旦应用程序发送了`saml2:LogoutResponse`，它就不再具有对浏览器的控制权。|
+|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## 单注销的最小配置
+
+要使用 Spring Security的SAML2.0单注销功能，你将需要以下功能：
+
+* 首先，断言一方必须支持SAML2.0单注销
+
+* 其次，应该将断言一方配置为签名并发布`saml2:LogoutRequest`s和`saml2:LogoutResponse`s你的应用程序的`/logout/saml2/slo`端点
+
+* 第三，你的应用程序必须具有用于签名`saml2:LogoutRequest`s和`saml2:LogoutResponse`s的PKCS#8私钥和X.509证书
+
+你可以从最初的最小示例开始，然后添加以下配置：
+
+```
+@Value("${private.key}") RSAPrivateKey key;
+@Value("${public.certificate}") X509Certificate certificate;
+
+@Bean
+RelyingPartyRegistrationRepository registrations() {
+    Saml2X509Credential credential = Saml2X509Credential.signing(key, certificate);
+    RelyingPartyRegistration registration = RelyingPartyRegistrations
+            .fromMetadataLocation("https://ap.example.org/metadata")
+            .registrationId("id")
+            .singleLogoutServiceLocation("{baseUrl}/logout/saml2/slo")
+            .signingX509Credentials((signing) -> signing.add(credential)) (1)
+            .build();
+    return new InMemoryRelyingPartyRegistrationRepository(registration);
+}
+
+@Bean
+SecurityFilterChain web(HttpSecurity http, RelyingPartyRegistrationRepository registrations) throws Exception {
+    http
+        .authorizeHttpRequests((authorize) -> authorize
+            .anyRequest().authenticated()
+        )
+        .saml2Login(withDefaults())
+        .saml2Logout(withDefaults()); (2)
+
+    return http.build();
+}
+```
+
+|**1**|\-首先，将你的签名键添加到`RelyingPartyRegistration`实例或[多个实例](login/overview.html#servlet-saml2login-rpr-duplicated)实例|
+|-----|-----------------------------------------------------------------------------------------------------------------------------------------------------------|
+|**2**|\-其次，指示你的应用程序想要使用SAML SLO注销最终用户|
+
+### 运行时期望
+
+给定上述配置，任何登录的用户都可以向你的应用程序发送`POST /logout`，以执行RP发起的SLO。然后，你的应用程序将执行以下操作：
+
+1. 注销用户并使其无效会话
+
+2. 使用`Saml2LogoutRequestResolver`来创建、签名和序列化基于与当前登录用户关联的[`RelyingPartyRegistration`]（login/overview.html# Servlet-saml2login-relyingpartyregistration）的`<saml2:LogoutRequest>`。
+
+3. 根据[`RelyingPartyRegistration`]（login/overview.html# Servlet-saml2login-relyingpartyregistration）向断言的一方发送重定向或帖子
+
+4. 反序列化、验证和处理由断言方发送的`<saml2:LogoutResponse>`
+
+5. 重定向到任何配置成功的注销端点
+
+此外，当断言一方向`<saml2:LogoutRequest>`发送`/logout/saml2/slo`时，你的应用程序可以参与AP发起的注销：
+
+1. 使用`Saml2LogoutRequestHandler`来反序列化、验证和处理由主张方发送的`<saml2:LogoutRequest>`
+
+2. 注销用户并使其无效会话
+
+3. 基于与刚刚注销的用户关联的[`RelyingPartyRegistration`]（login/overview.html# Servlet-saml2login-relyingpartyregistration），创建、签名和序列化`<saml2:LogoutResponse>`
+
+4. 基于[`RelyingPartyRegistration`]（login/overview.html# Servlet-saml2login-relyingpartyregistration）向断言方发一个重定向或发布
+
+|   |添加`saml2Logout`会将注销的功能添加到服务提供程序。<br/>由于它是一种可选功能，因此你需要为每个单独的`RelyingPartyRegistration`启用它。<br/>你可以通过设置`RelyingPartyRegistration.Builder#singleLogoutServiceLocation`属性来实现这一点。|
+|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+## 配置注销端点
+
+不同的端点可以触发三种行为：
+
+* RP-initiated logout，它允许经过身份验证的用户`POST`，并通过向断言的一方发送`<saml2:LogoutRequest>`来触发注销过程。
+
+* AP发起的注销，它允许断言的一方向应用程序发送`<saml2:LogoutRequest>`
+
+* AP注销响应，它允许断言一方发送`<saml2:LogoutResponse>`作为对RP发起的`<saml2:LogoutRequest>`的响应
+
+第一种是当主体类型`Saml2AuthenticatedPrincipal`时，执行正常的`POST /logout`触发。
+
+第二种是通过发送到带有由主张方签名的`SAMLRequest`的`/logout/saml2/slo`端点来触发的。
+
+第三种是通过发送到带有由主张方签名的`SAMLResponse`的`/logout/saml2/slo`端点来触发的。
+
+因为用户已经登录或者原始注销请求是已知的，所以`registrationId`已经是已知的。由于这个原因，`{registrationId}`默认情况下不是这些URL的一部分。
+
+此URL可在DSL中自定义。
+
+例如，如果你正在将你现有的依赖方迁移到 Spring Security，那么你的断言方可能已经指向`GET /SLOService.saml2`。为了减少对断言一方的配置更改，你可以在DSL中配置过滤器，如下所示：
+
+Java
+
+```
+http
+    .saml2Logout((saml2) -> saml2
+        .logoutRequest((request) -> request.logoutUrl("/SLOService.saml2"))
+        .logoutResponse((response) -> response.logoutUrl("/SLOService.saml2"))
+    );
+```
+
+你还应该在`RelyingPartyRegistration`中配置这些端点。
+
+## 自定义`<saml2:LogoutRequest>`分辨率
+
+通常需要在`<saml2:LogoutRequest>`中设置其他值，而不是 Spring Security提供的默认值。
+
+默认情况下， Spring Security将发出`<saml2:LogoutRequest>`并提供：
+
+* `Destination`属性-来自`RelyingPartyRegistration#getAssertingPartyDetails#getSingleLogoutServiceLocation`
+
+* `ID`属性-guid
+
+* `<Issuer>`元素-来自`RelyingPartyRegistration#getEntityId`
+
+* `<NameID>`元素-来自`Authentication#getName`
+
+要添加其他值，可以使用委托，例如：
+
+```
+@Bean
+Saml2LogoutRequestResolver logoutRequestResolver(RelyingPartyRegistrationResolver registrationResolver) {
+	OpenSaml4LogoutRequestResolver logoutRequestResolver
+			new OpenSaml4LogoutRequestResolver(registrationResolver);
+	logoutRequestResolver.setParametersConsumer((parameters) -> {
+		String name = ((Saml2AuthenticatedPrincipal) parameters.getAuthentication().getPrincipal()).getFirstAttribute("CustomAttribute");
+		String format = "urn:oasis:names:tc:SAML:2.0:nameid-format:transient";
+		LogoutRequest logoutRequest = parameters.getLogoutRequest();
+		NameID nameId = logoutRequest.getNameID();
+		nameId.setValue(name);
+		nameId.setFormat(format);
+	});
+	return logoutRequestResolver;
+}
+```
+
+然后，你可以在DSL中提供你的自定义`Saml2LogoutRequestResolver`，如下所示：
+
+```
+http
+    .saml2Logout((saml2) -> saml2
+        .logoutRequest((request) -> request
+            .logoutRequestResolver(this.logoutRequestResolver)
+        )
+    );
+```
+
+## 自定义`<saml2:LogoutResponse>`分辨率
+
+通常需要在`<saml2:LogoutResponse>`中设置其他值，而不是 Spring Security提供的默认值。
+
+默认情况下， Spring Security将发出`<saml2:LogoutResponse>`并提供：
+
+* `Destination`属性-来自`RelyingPartyRegistration#getAssertingPartyDetails#getSingleLogoutServiceResponseLocation`
+
+* `ID`属性-guid
+
+* `<Issuer>`元素-来自`RelyingPartyRegistration#getEntityId`
+
+* `<Status>`元素-`SUCCESS`
+
+要添加其他值，可以使用委托，例如：
+
+```
+@Bean
+public Saml2LogoutResponseResolver logoutResponseResolver(RelyingPartyRegistrationResolver registrationResolver) {
+	OpenSaml4LogoutResponseResolver logoutRequestResolver =
+			new OpenSaml3LogoutResponseResolver(relyingPartyRegistrationResolver);
+	logoutRequestResolver.setParametersConsumer((parameters) -> {
+		if (checkOtherPrevailingConditions(parameters.getRequest())) {
+			parameters.getLogoutRequest().getStatus().getStatusCode().setCode(StatusCode.PARTIAL_LOGOUT);
+		}
+	});
+	return logoutRequestResolver;
+}
+```
+
+然后，你可以在DSL中提供你的自定义`Saml2LogoutResponseResolver`，如下所示：
+
+```
+http
+    .saml2Logout((saml2) -> saml2
+        .logoutRequest((request) -> request
+            .logoutRequestResolver(this.logoutRequestResolver)
+        )
+    );
+```
+
+## 自定义`<saml2:LogoutRequest>`身份验证
+
+要定制验证，你可以实现自己的`Saml2LogoutRequestValidator`。在这一点上，验证是最小的，因此你可以首先委托给默认的`Saml2LogoutRequestValidator`，就像这样：
+
+```
+@Component
+public class MyOpenSamlLogoutRequestValidator implements Saml2LogoutRequestValidator {
+	private final Saml2LogoutRequestValidator delegate = new OpenSamlLogoutRequestValidator();
+
+	@Override
+    public Saml2LogoutRequestValidator logout(Saml2LogoutRequestValidatorParameters parameters) {
+		 // verify signature, issuer, destination, and principal name
+		Saml2LogoutValidatorResult result = delegate.authenticate(authentication);
+
+		LogoutRequest logoutRequest = // ... parse using OpenSAML
+        // perform custom validation
+    }
+}
+```
+
+然后，你可以在DSL中提供你的自定义`Saml2LogoutRequestValidator`，如下所示：
+
+```
+http
+    .saml2Logout((saml2) -> saml2
+        .logoutRequest((request) -> request
+            .logoutRequestAuthenticator(myOpenSamlLogoutRequestAuthenticator)
+        )
+    );
+```
+
+## 自定义`<saml2:LogoutResponse>`身份验证
+
+要定制验证，你可以实现自己的`Saml2LogoutResponseValidator`。在这一点上，验证是最小的，因此你可以首先委托给默认的`Saml2LogoutResponseValidator`，就像这样：
+
+```
+@Component
+public class MyOpenSamlLogoutResponseValidator implements Saml2LogoutResponseValidator {
+	private final Saml2LogoutResponseValidator delegate = new OpenSamlLogoutResponseValidator();
+
+	@Override
+    public Saml2LogoutValidatorResult logout(Saml2LogoutResponseValidatorParameters parameters) {
+		// verify signature, issuer, destination, and status
+		Saml2LogoutValidatorResult result = delegate.authenticate(parameters);
+
+		LogoutResponse logoutResponse = // ... parse using OpenSAML
+        // perform custom validation
+    }
+}
+```
+
+然后，你可以在DSL中提供你的自定义`Saml2LogoutResponseValidator`，如下所示：
+
+```
+http
+    .saml2Logout((saml2) -> saml2
+        .logoutResponse((response) -> response
+            .logoutResponseAuthenticator(myOpenSamlLogoutResponseAuthenticator)
+        )
+    );
+```
+
+## 自定义`<saml2:LogoutRequest>`存储
+
+当应用程序发送`<saml2:LogoutRequest>`时，该值存储在会话中，以便`RelayState`参数和`InResponseTo`属性中的`<saml2:LogoutResponse>`可以被验证。
+
+如果你希望将注销请求存储在会话以外的某个地方，那么可以在DSL中提供你的自定义实现，如下所示：
+
+```
+http
+    .saml2Logout((saml2) -> saml2
+        .logoutRequest((request) -> request
+            .logoutRequestRepository(myCustomLogoutRequestRepository)
+        )
+    );
+```
+
+[SAML2身份验证响应](login/authentication.html)[SAML2元数据](metadata.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-saml2-metadata.md b/docs/spring-security/servlet-saml2-metadata.md
new file mode 100644
index 0000000..eb5652a
--- /dev/null
+++ b/docs/spring-security/servlet-saml2-metadata.md
@@ -0,0 +1,67 @@
+# 生成`<saml2:SPSSODescriptor>`元数据
+
+你可以通过将`Saml2MetadataFilter`添加到筛选链来发布元数据端点，如下所示：
+
+Java
+
+```
+DefaultRelyingPartyRegistrationResolver relyingPartyRegistrationResolver =
+        new DefaultRelyingPartyRegistrationResolver(this.relyingPartyRegistrationRepository);
+Saml2MetadataFilter filter = new Saml2MetadataFilter(
+        relyingPartyRegistrationResolver,
+        new OpenSamlMetadataResolver());
+
+http
+    // ...
+    .saml2Login(withDefaults())
+    .addFilterBefore(filter, Saml2WebSsoAuthenticationFilter.class);
+```
+
+Kotlin
+
+```
+val relyingPartyRegistrationResolver: Converter<HttpServletRequest, RelyingPartyRegistration> =
+    DefaultRelyingPartyRegistrationResolver(this.relyingPartyRegistrationRepository)
+val filter = Saml2MetadataFilter(
+    relyingPartyRegistrationResolver,
+    OpenSamlMetadataResolver()
+)
+
+http {
+    //...
+    saml2Login { }
+    addFilterBefore<Saml2WebSsoAuthenticationFilter>(filter)
+}
+```
+
+你可以使用此元数据端点将你的依赖方注册为你的断言方.这通常很简单，只需找到正确的表单字段来提供元数据端点即可。
+
+默认情况下，元数据端点是`/saml2/service-provider-metadata/{registrationId}`。你可以通过调用过滤器上的`setRequestMatcher`方法来更改这一点：
+
+Java
+
+```
+filter.setRequestMatcher(new AntPathRequestMatcher("/saml2/metadata/{registrationId}", "GET"));
+```
+
+Kotlin
+
+```
+filter.setRequestMatcher(AntPathRequestMatcher("/saml2/metadata/{registrationId}", "GET"))
+```
+
+或者，如果你在构造函数中注册了一个自定义依赖方注册解析器，那么你可以在没有`registrationId`提示的情况下指定一个路径，就像这样：
+
+Java
+
+```
+filter.setRequestMatcher(new AntPathRequestMatcher("/saml2/metadata", "GET"));
+```
+
+Kotlin
+
+```
+filter.setRequestMatcher(AntPathRequestMatcher("/saml2/metadata", "GET"))
+```
+
+[SAML2注销](logout.html)[保护免受剥削](../exploits/index.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-saml2.md b/docs/spring-security/servlet-saml2.md
new file mode 100644
index 0000000..ad7f8a9
--- /dev/null
+++ b/docs/spring-security/servlet-saml2.md
@@ -0,0 +1,11 @@
+# SAML2
+
+Spring 安全性提供了全面的SAML2支持。本节讨论如何将SAML2集成到基于 Servlet 的应用程序中。
+
+## 章节摘要
+
+* [SAML2登录](login/index.html)
+* [SAML2注销](logout.html)
+* [SAML2元数据](metadata.html)
+
+[不记名代币](../oauth2/resource-server/bearer-tokens.html)[SAML2登录](login/index.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-test-method.md b/docs/spring-security/servlet-test-method.md
new file mode 100644
index 0000000..ac63339
--- /dev/null
+++ b/docs/spring-security/servlet-test-method.md
@@ -0,0 +1,554 @@
+# 测试方法安全性
+
+本节演示如何使用 Spring Security的测试支持来测试基于方法的安全性。我们首先介绍一个`MessageService`，它需要对用户进行身份验证才能访问它。
+
+Java
+
+```
+public class HelloMessageService implements MessageService {
+
+	@PreAuthorize("authenticated")
+	public String getMessage() {
+		Authentication authentication = SecurityContextHolder.getContext()
+			.getAuthentication();
+		return "Hello " + authentication;
+	}
+}
+```
+
+Kotlin
+
+```
+class HelloMessageService : MessageService {
+    @PreAuthorize("authenticated")
+    fun getMessage(): String {
+        val authentication: Authentication = SecurityContextHolder.getContext().authentication
+        return "Hello $authentication"
+    }
+}
+```
+
+`getMessage`的结果是对当前 Spring 安全性`Authentication`说“你好”的字符串。下面将显示一个输出示例。
+
+```
+Hello org.springframew[email protected]ca25360: Principal: [email protected]: Username: user; Password: [PROTECTED]; Enabled: true; AccountNonExpired: true; credentialsNonExpired: true; AccountNonLocked: true; Granted Authorities: ROLE_USER; Credentials: [PROTECTED]; Authenticated: true; Details: null; Granted Authorities: ROLE_USER
+```
+
+## 安全测试设置
+
+在使用 Spring 安全测试支持之前，我们必须执行一些设置。下面是一个例子：
+
+Java
+
+```
+@RunWith(SpringJUnit4ClassRunner.class) (1)
+@ContextConfiguration (2)
+public class WithMockUserTests {
+```
+
+Kotlin
+
+```
+@RunWith(SpringJUnit4ClassRunner::class)
+@ContextConfiguration
+class WithMockUserTests {
+```
+
+这是如何设置 Spring 安全性测试的一个基本示例。重点是：
+
+|**1**|`@RunWith`指示 Spring-test模块应该创建`ApplicationContext`。这与使用现有的 Spring 测试支持没有什么不同。有关更多信息，请参阅[Spring Reference](https://docs.spring.io/spring-framework/docs/4.0.x/spring-framework-reference/htmlsingle/#integration-testing-annotations-standard)|
+|-----|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|**2**|`@ContextConfiguration`指示 Spring-test用于创建`ApplicationContext`的配置。由于未指定配置，因此将尝试默认的配置位置。这与使用现有的 Spring 测试支持没有什么不同。有关更多信息，请参阅[Spring Reference](https://docs.spring.io/spring-framework/docs/4.0.x/spring-framework-reference/htmlsingle/#testcontext-ctx-management)|
+
+|   |Spring 使用`WithSecurityContextTestExecutionListener`将安全挂钩到 Spring 测试支持中，这将确保我们的测试与正确的用户一起运行。<br/>它通过在运行我们的测试之前填充`SecurityContextHolder`来实现这一点。<br/>如果你使用的是反应式方法安全，你还需要填充`ReactorContextTestExecutionListener`的`ReactiveSecurityContextHolder`。<br/>测试完成后，它将清除`SecurityContextHolder`。<br/>如果你只需要 Spring 安全相关的支持，则可以将`@ContextConfiguration`替换为`@SecurityTestExecutionListeners`。|
+|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+请记住，我们在我们的`@PreAuthorize`中添加了`HelloMessageService`注释，因此它需要经过身份验证的用户来调用它。如果我们运行以下测试，我们预计以下测试将通过：
+
+Java
+
+```
+@Test(expected = AuthenticationCredentialsNotFoundException.class)
+public void getMessageUnauthenticated() {
+	messageService.getMessage();
+}
+```
+
+Kotlin
+
+```
+@Test(expected = AuthenticationCredentialsNotFoundException::class)
+fun getMessageUnauthenticated() {
+    messageService.getMessage()
+}
+```
+
+## @WithMockuser
+
+问题是“作为一个特定的用户，我们如何才能最容易地运行测试？”答案是使用`@WithMockUser`。下面的测试将以用户名“user”、密码“password”和角色“role\_user”的用户身份运行。
+
+Java
+
+```
+@Test
+@WithMockUser
+public void getMessageWithMockUser() {
+String message = messageService.getMessage();
+...
+}
+```
+
+Kotlin
+
+```
+@Test
+@WithMockUser
+fun getMessageWithMockUser() {
+    val message: String = messageService.getMessage()
+    // ...
+}
+```
+
+具体来说，以下情况是正确的：
+
+* 用户名为“user”的用户不一定存在，因为我们是在嘲笑用户
+
+* 在`SecurityContext`中填充的`Authentication`类型为`UsernamePasswordAuthenticationToken`
+
+* `Authentication`上的主体是 Spring 证券的`User`对象
+
+* `User`将具有“user”的用户名，密码“password”，并使用一个名为“role\_user”的`GrantedAuthority`。
+
+我们的例子很好，因为我们能够利用大量的违约。如果我们想用不同的用户名运行测试，该怎么办？下面的测试将使用用户名“CustomUser”运行。同样，用户不需要实际存在。
+
+Java
+
+```
+@Test
+@WithMockUser("customUsername")
+public void getMessageWithMockUserCustomUsername() {
+	String message = messageService.getMessage();
+...
+}
+```
+
+Kotlin
+
+```
+@Test
+@WithMockUser("customUsername")
+fun getMessageWithMockUserCustomUsername() {
+    val message: String = messageService.getMessage()
+    // ...
+}
+```
+
+我们还可以轻松地定制角色。例如，将使用用户名“admin”以及角色“role\_user”和“role\_admin”来调用此测试。
+
+Java
+
+```
+@Test
+@WithMockUser(username="admin",roles={"USER","ADMIN"})
+public void getMessageWithMockUserCustomUser() {
+	String message = messageService.getMessage();
+	...
+}
+```
+
+Kotlin
+
+```
+@Test
+@WithMockUser(username="admin",roles=["USER","ADMIN"])
+fun getMessageWithMockUserCustomUser() {
+    val message: String = messageService.getMessage()
+    // ...
+}
+```
+
+如果我们不希望该值自动以role\_为前缀，那么我们可以利用Authorities属性。例如，将使用用户名“admin”以及权威机构“user”和“admin”来调用此测试。
+
+Java
+
+```
+@Test
+@WithMockUser(username = "admin", authorities = { "ADMIN", "USER" })
+public void getMessageWithMockUserCustomAuthorities() {
+	String message = messageService.getMessage();
+	...
+}
+```
+
+Kotlin
+
+```
+@Test
+@WithMockUser(username = "admin", authorities = ["ADMIN", "USER"])
+fun getMessageWithMockUserCustomUsername() {
+    val message: String = messageService.getMessage()
+    // ...
+}
+```
+
+当然，在每个测试方法上放置注释可能会有点繁琐。相反，我们可以将注释放在类级别，并且每个测试都将使用指定的用户。例如，下面将对用户名为“admin”、密码为“password”、角色为“role\_user”和“role\_admin”的用户进行每次测试。
+
+Java
+
+```
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+@WithMockUser(username="admin",roles={"USER","ADMIN"})
+public class WithMockUserTests {
+```
+
+Kotlin
+
+```
+@RunWith(SpringJUnit4ClassRunner::class)
+@ContextConfiguration
+@WithMockUser(username="admin",roles=["USER","ADMIN"])
+class WithMockUserTests {
+```
+
+如果你正在使用JUnit5的`@Nested`测试支持，那么你还可以将注释放置在封闭类上，以应用于所有嵌套的类。例如，下面将使用用户名为“admin”、密码为“password”、角色为“role\_user”和“role\_admin”的用户来运行每个测试。
+
+Java
+
+```
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration
+@WithMockUser(username="admin",roles={"USER","ADMIN"})
+public class WithMockUserTests {
+
+	@Nested
+	public class TestSuite1 {
+		// ... all test methods use admin user
+	}
+
+	@Nested
+	public class TestSuite2 {
+		// ... all test methods use admin user
+	}
+}
+```
+
+Kotlin
+
+```
+@ExtendWith(SpringExtension::class)
+@ContextConfiguration
+@WithMockUser(username = "admin", roles = ["USER", "ADMIN"])
+class WithMockUserTests {
+    @Nested
+    inner class TestSuite1 { // ... all test methods use admin user
+    }
+
+    @Nested
+    inner class TestSuite2 { // ... all test methods use admin user
+    }
+}
+```
+
+默认情况下，`SecurityContext`是在`TestExecutionListener.beforeTestMethod`事件期间设置的。这相当于在JUnit`@Before`之前发生的情况。你可以将此更改为在`TestExecutionListener.beforeTestExecution`事件期间发生，该事件发生在JUnit的`@Before`之后，但在调用测试方法之前。
+
+```
+@WithMockUser(setupBefore = TestExecutionEvent.TEST_EXECUTION)
+```
+
+## @withAnonymoususer
+
+使用`@WithAnonymousUser`允许作为匿名用户运行。当你希望与特定用户一起运行大多数测试，但希望以匿名用户的身份运行一些测试时，这一点特别方便。例如，下面将使用[@WithMockuser](#test-method-withmockuser)和匿名者作为匿名用户运行Mockuser1和Mockuser2。
+
+Java
+
+```
+@RunWith(SpringJUnit4ClassRunner.class)
+@WithMockUser
+public class WithUserClassLevelAuthenticationTests {
+
+	@Test
+	public void withMockUser1() {
+	}
+
+	@Test
+	public void withMockUser2() {
+	}
+
+	@Test
+	@WithAnonymousUser
+	public void anonymous() throws Exception {
+		// override default to run as anonymous user
+	}
+}
+```
+
+Kotlin
+
+```
+@RunWith(SpringJUnit4ClassRunner::class)
+@WithMockUser
+class WithUserClassLevelAuthenticationTests {
+    @Test
+    fun withMockUser1() {
+    }
+
+    @Test
+    fun withMockUser2() {
+    }
+
+    @Test
+    @WithAnonymousUser
+    fun anonymous() {
+        // override default to run as anonymous user
+    }
+}
+```
+
+默认情况下，`SecurityContext`是在`TestExecutionListener.beforeTestMethod`事件期间设置的。这相当于发生在JUnit的`@Before`之前。你可以将此更改为在`TestExecutionListener.beforeTestExecution`事件期间发生，该事件发生在JUnit的`@Before`之后，但在调用测试方法之前。
+
+```
+@WithAnonymousUser(setupBefore = TestExecutionEvent.TEST_EXECUTION)
+```
+
+## @withuserdetails
+
+虽然`@WithMockUser`是一种非常方便的启动方式，但它可能并不是在所有实例中都有效。例如，对于应用程序来说，期望`Authentication`主体具有特定类型是很常见的。这样做是为了使应用程序可以将主体称为自定义类型，并减少 Spring 安全性上的耦合。
+
+自定义主体通常是由一个自定义`UserDetailsService`返回的，该自定义主体返回一个对象，该对象实现`UserDetails`和自定义类型。对于这样的情况，使用自定义`UserDetailsService`创建测试用户是有用的。这正是`@WithUserDetails`所做的。
+
+假设我们将`UserDetailsService`作为 Bean 公开，那么下面的测试将使用`Authentication`类型的`UsernamePasswordAuthenticationToken`和从`UserDetailsService`返回的、用户名为“user”的主体来调用。
+
+Java
+
+```
+@Test
+@WithUserDetails
+public void getMessageWithUserDetails() {
+	String message = messageService.getMessage();
+	...
+}
+```
+
+Kotlin
+
+```
+@Test
+@WithUserDetails
+fun getMessageWithUserDetails() {
+    val message: String = messageService.getMessage()
+    // ...
+}
+```
+
+我们还可以自定义用于从`UserDetailsService`中查找用户的用户名。例如，该测试将使用从`UserDetailsService`返回的主体运行，该主体的用户名为“CustomUsername”。
+
+Java
+
+```
+@Test
+@WithUserDetails("customUsername")
+public void getMessageWithUserDetailsCustomUsername() {
+	String message = messageService.getMessage();
+	...
+}
+```
+
+Kotlin
+
+```
+@Test
+@WithUserDetails("customUsername")
+fun getMessageWithUserDetailsCustomUsername() {
+    val message: String = messageService.getMessage()
+    // ...
+}
+```
+
+我们还可以提供一个显式的 Bean 名称来查找`UserDetailsService`。例如，该测试将使用`UserDetailsService`和 Bean 名称“MyUserDetailsService”来查找“CustomUsername”的用户名。
+
+Java
+
+```
+@Test
+@WithUserDetails(value="customUsername", userDetailsServiceBeanName="myUserDetailsService")
+public void getMessageWithUserDetailsServiceBeanName() {
+	String message = messageService.getMessage();
+	...
+}
+```
+
+Kotlin
+
+```
+@Test
+@WithUserDetails(value="customUsername", userDetailsServiceBeanName="myUserDetailsService")
+fun getMessageWithUserDetailsServiceBeanName() {
+    val message: String = messageService.getMessage()
+    // ...
+}
+```
+
+像`@WithMockUser`一样，我们也可以将注释放在类级别，这样每个测试都使用相同的用户。然而，与`@WithMockUser`不同，`@WithUserDetails`要求用户存在。
+
+默认情况下，`SecurityContext`是在`TestExecutionListener.beforeTestMethod`事件期间设置的。这相当于发生在JUnit的`@Before`之前。你可以将此更改为在`TestExecutionListener.beforeTestExecution`事件期间发生，该事件发生在JUnit的`@Before`之后，但在调用测试方法之前。
+
+```
+@WithUserDetails(setupBefore = TestExecutionEvent.TEST_EXECUTION)
+```
+
+## @withSecurityContext
+
+我们已经看到，如果我们不使用自定义的`Authentication`原则，`@WithMockUser`是一个很好的选择。接下来，我们发现`@WithUserDetails`将允许我们使用自定义`UserDetailsService`来创建我们的`Authentication`主体，但需要用户存在。我们现在将看到一个允许最大灵活性的选项。
+
+我们可以创建自己的注释，它使用`@WithSecurityContext`来创建我们想要的任何`SecurityContext`。例如，我们可以创建一个名为`@WithMockCustomUser`的注释，如下所示：
+
+Java
+
+```
+@Retention(RetentionPolicy.RUNTIME)
+@WithSecurityContext(factory = WithMockCustomUserSecurityContextFactory.class)
+public @interface WithMockCustomUser {
+
+	String username() default "rob";
+
+	String name() default "Rob Winch";
+}
+```
+
+Kotlin
+
+```
+@Retention(AnnotationRetention.RUNTIME)
+@WithSecurityContext(factory = WithMockCustomUserSecurityContextFactory::class)
+annotation class WithMockCustomUser(val username: String = "rob", val name: String = "Rob Winch")
+```
+
+你可以看到`@WithMockCustomUser`是用`@WithSecurityContext`注释的。这是向 Spring 安全性测试支持发出的信号，表示我们打算为测试创建`SecurityContext`。`@WithSecurityContext`注释要求我们指定一个`SecurityContextFactory`，给定我们的`@WithMockCustomUser`注释，它将创建一个新的`SecurityContext`注释。你可以在下面找到我们的`WithMockCustomUserSecurityContextFactory`实现：
+
+Java
+
+```
+public class WithMockCustomUserSecurityContextFactory
+	implements WithSecurityContextFactory<WithMockCustomUser> {
+	@Override
+	public SecurityContext createSecurityContext(WithMockCustomUser customUser) {
+		SecurityContext context = SecurityContextHolder.createEmptyContext();
+
+		CustomUserDetails principal =
+			new CustomUserDetails(customUser.name(), customUser.username());
+		Authentication auth =
+			new UsernamePasswordAuthenticationToken(principal, "password", principal.getAuthorities());
+		context.setAuthentication(auth);
+		return context;
+	}
+}
+```
+
+Kotlin
+
+```
+class WithMockCustomUserSecurityContextFactory : WithSecurityContextFactory<WithMockCustomUser> {
+    override fun createSecurityContext(customUser: WithMockCustomUser): SecurityContext {
+        val context = SecurityContextHolder.createEmptyContext()
+        val principal = CustomUserDetails(customUser.name, customUser.username)
+        val auth: Authentication =
+            UsernamePasswordAuthenticationToken(principal, "password", principal.authorities)
+        context.authentication = auth
+        return context
+    }
+}
+```
+
+我们现在可以使用新的注释对测试类或测试方法进行注释，并且 Spring Security的`WithSecurityContextTestExecutionListener`将确保我们的`SecurityContext`被适当地填充。
+
+在创建你自己的`WithSecurityContextFactory`实现时，很高兴知道它们可以使用标准 Spring 注释进行注释。例如，`WithUserDetailsSecurityContextFactory`使用`@Autowired`注释来获取`UserDetailsService`:
+
+Java
+
+```
+final class WithUserDetailsSecurityContextFactory
+	implements WithSecurityContextFactory<WithUserDetails> {
+
+	private UserDetailsService userDetailsService;
+
+	@Autowired
+	public WithUserDetailsSecurityContextFactory(UserDetailsService userDetailsService) {
+		this.userDetailsService = userDetailsService;
+	}
+
+	public SecurityContext createSecurityContext(WithUserDetails withUser) {
+		String username = withUser.value();
+		Assert.hasLength(username, "value() must be non-empty String");
+		UserDetails principal = userDetailsService.loadUserByUsername(username);
+		Authentication authentication = new UsernamePasswordAuthenticationToken(principal, principal.getPassword(), principal.getAuthorities());
+		SecurityContext context = SecurityContextHolder.createEmptyContext();
+		context.setAuthentication(authentication);
+		return context;
+	}
+}
+```
+
+Kotlin
+
+```
+class WithUserDetailsSecurityContextFactory @Autowired constructor(private val userDetailsService: UserDetailsService) :
+    WithSecurityContextFactory<WithUserDetails> {
+    override fun createSecurityContext(withUser: WithUserDetails): SecurityContext {
+        val username: String = withUser.value
+        Assert.hasLength(username, "value() must be non-empty String")
+        val principal = userDetailsService.loadUserByUsername(username)
+        val authentication: Authentication =
+            UsernamePasswordAuthenticationToken(principal, principal.password, principal.authorities)
+        val context = SecurityContextHolder.createEmptyContext()
+        context.authentication = authentication
+        return context
+    }
+}
+```
+
+默认情况下，`SecurityContext`是在`TestExecutionListener.beforeTestMethod`事件期间设置的。这相当于发生在JUnit的`@Before`之前。你可以将此更改为在`TestExecutionListener.beforeTestExecution`事件期间发生，该事件发生在JUnit的`@Before`之后，但在调用测试方法之前。
+
+```
+@WithSecurityContext(setupBefore = TestExecutionEvent.TEST_EXECUTION)
+```
+
+## 测试元注释
+
+如果你经常在测试中重用同一个用户，那么必须反复指定属性是不理想的。例如，如果有许多与用户名为“admin”的管理用户以及角色`ROLE_USER`和`ROLE_ADMIN`相关的测试，则必须编写：
+
+Java
+
+```
+@WithMockUser(username="admin",roles={"USER","ADMIN"})
+```
+
+Kotlin
+
+```
+@WithMockUser(username="admin",roles=["USER","ADMIN"])
+```
+
+我们可以使用元注释，而不是到处重复这一点。例如，我们可以创建一个名为`WithMockAdmin`的元注释：
+
+Java
+
+```
+@Retention(RetentionPolicy.RUNTIME)
+@WithMockUser(value="rob",roles="ADMIN")
+public @interface WithMockAdmin { }
+```
+
+Kotlin
+
+```
+@Retention(AnnotationRetention.RUNTIME)
+@WithMockUser(value = "rob", roles = ["ADMIN"])
+annotation class WithMockAdmin
+```
+
+现在我们可以使用`@WithMockAdmin`，就像使用更详细的`@WithMockUser`一样。
+
+元注释可以与上面描述的任何测试注释一起工作。例如，这意味着我们也可以为`@WithUserDetails("admin")`创建一个元注释。
+
+[Testing](index.html)[MockMVC支持](mockmvc/index.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-test-mockmvc-authentication.md b/docs/spring-security/servlet-test-mockmvc-authentication.md
new file mode 100644
index 0000000..1eef0be
--- /dev/null
+++ b/docs/spring-security/servlet-test-mockmvc-authentication.md
@@ -0,0 +1,237 @@
+# 在 Spring MVC测试中以用户身份运行测试
+
+通常希望以特定用户的身份运行测试。有两种简单的填充用户的方法：
+
+* [在使用RequestPostProcessor的 Spring MVC测试中以用户身份运行](#test-mockmvc-securitycontextholder-rpp)
+
+* [在 Spring MVC测试中以用户身份运行并带有注释](#test-mockmvc-withmockuser)
+
+## Running as a User in Spring MVC Test with RequestPostProcessor
+
+有许多选项可用于将用户关联到当前的`HttpServletRequest`。例如，以下将以用户名“user”、密码“password”和角色“role\_user”作为用户（不需要存在）运行：
+
+|   |该支持通过将用户关联到`HttpServletRequest`来工作。<br/>将请求关联到你需要确保的`SecurityContextHolder``SecurityContextPersistenceFilter`与`MockMvc`实例相关联。<br/>实现此目的的几种方法是：<br/><br/>*调用[`apply(springSecurity())`<br/><br/>*将 Spring 安全性的`FilterChainProxy`添加到<32">r=R=”42“/>”43“/>r=”gt=34"实例可能具有意义使用`MockMvcBuilders.standaloneSetup`时|
+|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+Java
+
+```
+mvc
+	.perform(get("/").with(user("user")))
+```
+
+Kotlin
+
+```
+mvc.get("/") {
+    with(user("user"))
+}
+```
+
+你可以轻松地进行自定义。例如，以下内容将以用户名“admin”、密码“pass”以及角色“role\_user”和“role\_admin”的形式（不需要存在）运行。
+
+Java
+
+```
+mvc
+	.perform(get("/admin").with(user("admin").password("pass").roles("USER","ADMIN")))
+```
+
+Kotlin
+
+```
+mvc.get("/admin") {
+    with(user("admin").password("pass").roles("USER","ADMIN"))
+}
+```
+
+如果你有一个想要使用的自定义`UserDetails`，那么你也可以轻松地指定它。例如，下面将使用指定的`UserDetails`（不需要存在）来运行具有指定的`UsernamePasswordAuthenticationToken`的主体的`UserDetails`:
+
+Java
+
+```
+mvc
+	.perform(get("/").with(user(userDetails)))
+```
+
+Kotlin
+
+```
+mvc.get("/") {
+    with(user(userDetails))
+}
+```
+
+你可以使用以下方式以匿名用户的身份运行：
+
+Java
+
+```
+mvc
+	.perform(get("/").with(anonymous()))
+```
+
+Kotlin
+
+```
+mvc.get("/") {
+    with(anonymous())
+}
+```
+
+如果你运行的是一个默认用户，并且希望以匿名用户的身份处理一些请求，那么这一点尤其有用。
+
+如果你想要自定义`Authentication`（它不需要存在），可以使用以下方法来实现：
+
+Java
+
+```
+mvc
+	.perform(get("/").with(authentication(authentication)))
+```
+
+Kotlin
+
+```
+mvc.get("/") {
+    with(authentication(authentication))
+}
+```
+
+你甚至可以使用以下方法自定义`SecurityContext`:
+
+Java
+
+```
+mvc
+	.perform(get("/").with(securityContext(securityContext)))
+```
+
+Kotlin
+
+```
+mvc.get("/") {
+    with(securityContext(securityContext))
+}
+```
+
+通过使用`MockMvcBuilders`的默认请求，我们还可以确保每个请求都以特定用户的身份运行。例如，以下内容将以用户名“admin”、密码“password”和角色“role\_admin”的用户身份（不需要存在）运行：
+
+Java
+
+```
+mvc = MockMvcBuilders
+		.webAppContextSetup(context)
+		.defaultRequest(get("/").with(user("user").roles("ADMIN")))
+		.apply(springSecurity())
+		.build();
+```
+
+Kotlin
+
+```
+mvc = MockMvcBuilders
+    .webAppContextSetup(context)
+    .defaultRequest<DefaultMockMvcBuilder>(get("/").with(user("user").roles("ADMIN")))
+    .apply<DefaultMockMvcBuilder>(springSecurity())
+    .build()
+```
+
+如果你发现在许多测试中使用的是同一个用户，建议将该用户移动到一个方法。例如，你可以在自己的类`CustomSecurityMockMvcRequestPostProcessors`中指定以下内容：
+
+Java
+
+```
+public static RequestPostProcessor rob() {
+	return user("rob").roles("ADMIN");
+}
+```
+
+Kotlin
+
+```
+fun rob(): RequestPostProcessor {
+    return user("rob").roles("ADMIN")
+}
+```
+
+现在，你可以在`CustomSecurityMockMvcRequestPostProcessors`上执行静态导入，并在测试中使用它：
+
+Java
+
+```
+import static sample.CustomSecurityMockMvcRequestPostProcessors.*;
+
+...
+
+mvc
+	.perform(get("/").with(rob()))
+```
+
+Kotlin
+
+```
+import sample.CustomSecurityMockMvcRequestPostProcessors.*
+
+//...
+
+mvc.get("/") {
+    with(rob())
+}
+```
+
+## Running as a User in Spring MVC Test with Annotations
+
+作为使用`RequestPostProcessor`创建用户的替代方法，你可以使用[测试方法安全性](../method.html)中描述的注释。例如，下面将使用用户名“user”、密码“password”和角色“role\_user”对用户运行测试：
+
+Java
+
+```
+@Test
+@WithMockUser
+public void requestProtectedUrlWithUser() throws Exception {
+mvc
+		.perform(get("/"))
+		...
+}
+```
+
+Kotlin
+
+```
+@Test
+@WithMockUser
+fun requestProtectedUrlWithUser() {
+    mvc
+        .get("/")
+        // ...
+}
+```
+
+或者，下面将使用用户名“user”、密码“password”和角色“role\_admin”对用户运行测试：
+
+Java
+
+```
+@Test
+@WithMockUser(roles="ADMIN")
+public void requestProtectedUrlWithUser() throws Exception {
+mvc
+		.perform(get("/"))
+		...
+}
+```
+
+Kotlin
+
+```
+@Test
+@WithMockUser(roles = ["ADMIN"])
+fun requestProtectedUrlWithUser() {
+    mvc
+        .get("/")
+        // ...
+}
+```
+
+[安全请求后置处理器](request-post-processors.html)[嘲笑CSRF](csrf.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-test-mockmvc-csrf.md b/docs/spring-security/servlet-test-mockmvc-csrf.md
new file mode 100644
index 0000000..e699e89
--- /dev/null
+++ b/docs/spring-security/servlet-test-mockmvc-csrf.md
@@ -0,0 +1,54 @@
+# 用CSRF保护进行测试
+
+在测试任何非安全的HTTP方法并使用 Spring Security的CSRF保护时，必须确保在请求中包含有效的CSRF令牌。要将有效的CSRF令牌指定为请求参数，可以使用CSRF[`RequestPostProcessor`]（request-post-processors.html），如下所示：
+
+Java
+
+```
+mvc
+	.perform(post("/").with(csrf()))
+```
+
+Kotlin
+
+```
+mvc.post("/") {
+    with(csrf())
+}
+```
+
+如果你愿意，可以在标题中包含CSRF令牌：
+
+Java
+
+```
+mvc
+	.perform(post("/").with(csrf().asHeader()))
+```
+
+Kotlin
+
+```
+mvc.post("/") {
+    with(csrf().asHeader())
+}
+```
+
+你还可以使用以下方法测试是否提供了无效的CSRF令牌：
+
+Java
+
+```
+mvc
+	.perform(post("/").with(csrf().useInvalidToken()))
+```
+
+Kotlin
+
+```
+mvc.post("/") {
+    with(csrf().useInvalidToken())
+}
+```
+
+[嘲笑用户](authentication.html)[模拟表单登录](form-login.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-test-mockmvc-form-login.md b/docs/spring-security/servlet-test-mockmvc-form-login.md
new file mode 100644
index 0000000..7d74794
--- /dev/null
+++ b/docs/spring-security/servlet-test-mockmvc-form-login.md
@@ -0,0 +1,51 @@
+# 基于测试表单的身份验证
+
+你可以使用 Spring Security的测试支持轻松地创建一个请求来测试基于表单的身份验证。例如，下面的`formLogin`[`RequestPostProcessor`]（request-post-processors.html）将向“/login”提交一篇文章，其中包含用户名“user”、密码“password”和一个有效的CSRF令牌：
+
+Java
+
+```
+mvc
+	.perform(formLogin())
+```
+
+Kotlin
+
+```
+mvc
+	.perform(formLogin())
+```
+
+定制请求很容易。例如，下面将向“/auth”提交一篇带有用户名“admin”、密码“pass”和有效的CSRF令牌的文章：
+
+Java
+
+```
+mvc
+	.perform(formLogin("/auth").user("admin").password("pass"))
+```
+
+Kotlin
+
+```
+mvc
+    .perform(formLogin("/auth").user("admin").password("pass"))
+```
+
+我们还可以自定义包含用户名和密码的参数名。例如，上面的请求被修改为包括HTTP参数“U”上的用户名和HTTP参数“P”上的密码。
+
+Java
+
+```
+mvc
+	.perform(formLogin("/auth").user("u","admin").password("p","pass"))
+```
+
+Kotlin
+
+```
+mvc
+    .perform(formLogin("/auth").user("u","admin").password("p","pass"))
+```
+
+[嘲笑CSRF ](csrf.html)[模拟HTTP BASIC ](http-basic.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-test-mockmvc-http-basic.md b/docs/spring-security/servlet-test-mockmvc-http-basic.md
new file mode 100644
index 0000000..a72780e
--- /dev/null
+++ b/docs/spring-security/servlet-test-mockmvc-http-basic.md
@@ -0,0 +1,26 @@
+# 测试HTTP基本身份验证
+
+虽然使用HTTP Basic进行身份验证一直是可能的，但记住头名称、格式和对值进行编码有点繁琐。现在可以使用 Spring Security的`httpBasic`[`RequestPostProcessor`]（request-post-processors.html）来完成此操作。例如，下面的代码片段：
+
+Java
+
+```
+mvc
+	.perform(get("/").with(httpBasic("user","password")))
+```
+
+Kotlin
+
+```
+mvc.get("/") {
+    with(httpBasic("user","password"))
+}
+```
+
+将尝试使用HTTP Basic来验证具有用户名“user”和密码“password”的用户，方法是确保在HTTP请求中填充以下头：
+
+```
+Authorization: Basic dXNlcjpwYXNzd29yZA==
+```
+
+[模拟表单登录](form-login.html)[嘲笑OAuth2](oauth2.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-test-mockmvc-logout.md b/docs/spring-security/servlet-test-mockmvc-logout.md
new file mode 100644
index 0000000..327dc76
--- /dev/null
+++ b/docs/spring-security/servlet-test-mockmvc-logout.md
@@ -0,0 +1,35 @@
+# 测试注销
+
+虽然使用标准 Spring MVC测试非常简单，但你可以使用 Spring Security的测试支持来使测试登出变得更容易。例如，下面的`logout`[`RequestPostProcessor`]（request-post-processors.html）将使用有效的CSRF令牌向“/logout”提交一个POST:
+
+Java
+
+```
+mvc
+	.perform(logout())
+```
+
+Kotlin
+
+```
+mvc
+    .perform(logout())
+```
+
+你还可以自定义要发布到的URL。例如，下面的代码片段将使用有效的CSRF标记向“/signout”提交一篇文章：
+
+Java
+
+```
+mvc
+	.perform(logout("/signout"))
+```
+
+Kotlin
+
+```
+mvc
+	.perform(logout("/signout"))
+```
+
+[嘲笑OAuth2](oauth2.html)[安全请求者](request-builders.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-test-mockmvc-oauth2.md b/docs/spring-security/servlet-test-mockmvc-oauth2.md
new file mode 100644
index 0000000..9e61c05
--- /dev/null
+++ b/docs/spring-security/servlet-test-mockmvc-oauth2.md
@@ -0,0 +1,1048 @@
+# 测试OAuth2.0
+
+当涉及到OAuth2.0时，前面介绍的相同原则仍然适用：最终，这取决于你的测试方法在`SecurityContextHolder`中的期望。
+
+例如，对于如下所示的控制器：
+
+Java
+
+```
+@GetMapping("/endpoint")
+public String foo(Principal user) {
+    return user.getName();
+}
+```
+
+Kotlin
+
+```
+@GetMapping("/endpoint")
+fun foo(user: Principal): String {
+    return user.name
+}
+```
+
+它没有特定于OAuth2的内容，因此你可能只需[使用`@WithMockUser`]（../method.html#test-method-withmockuser）就可以了。
+
+但是，在你的控制器绑定到 Spring Security的OAuth2.0支持的某些方面的情况下，例如：
+
+Java
+
+```
+@GetMapping("/endpoint")
+public String foo(@AuthenticationPrincipal OidcUser user) {
+    return user.getIdToken().getSubject();
+}
+```
+
+Kotlin
+
+```
+@GetMapping("/endpoint")
+fun foo(@AuthenticationPrincipal user: OidcUser): String {
+    return user.idToken.subject
+}
+```
+
+然后，安全的测试支持就会派上用场。
+
+## 测试OIDC登录
+
+用 Spring MVC测试来测试上面的方法将需要用授权服务器来模拟某种授予流。当然，这将是一项艰巨的任务，这就是为什么 Spring 安全船支持删除这一样板。
+
+例如，我们可以使用`oidcLogin`[`requestpostprocessor’]（request-post-processors.html）告诉 Spring 安全性包含一个默认的`OidcUser`，就像这样：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint").with(oidcLogin()));
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(oidcLogin())
+}
+```
+
+这样做的目的是将关联的`MockHttpServletRequest`配置为`OidcUser`，其中包括授予权限的简单`OidcIdToken`、`OidcUserInfo`和`Collection`。
+
+具体地说，它将包括一个`OidcIdToken`，其`sub`声明设置为`user`:
+
+Java
+
+```
+assertThat(user.getIdToken().getClaim("sub")).isEqualTo("user");
+```
+
+Kotlin
+
+```
+assertThat(user.idToken.getClaim<String>("sub")).isEqualTo("user")
+```
+
+没有设置索赔要求的`OidcUserInfo`:
+
+Java
+
+```
+assertThat(user.getUserInfo().getClaims()).isEmpty();
+```
+
+Kotlin
+
+```
+assertThat(user.userInfo.claims).isEmpty()
+```
+
+而`Collection`只有一个权限的权限，`SCOPE_read`:
+
+Java
+
+```
+assertThat(user.getAuthorities()).hasSize(1);
+assertThat(user.getAuthorities()).containsExactly(new SimpleGrantedAuthority("SCOPE_read"));
+```
+
+Kotlin
+
+```
+assertThat(user.authorities).hasSize(1)
+assertThat(user.authorities).containsExactly(SimpleGrantedAuthority("SCOPE_read"))
+```
+
+Spring 安全性做了必要的工作，以确保`OidcUser`实例可用于[`@AuthenticationPrincipal`注释]。
+
+此外，它还将`OidcUser`链接到`OAuth2AuthorizedClient`的一个简单实例，该实例将其存入一个模拟`OAuth2AuthorizedClientRepository`。如果你的测试[使用`@RegisteredOAuth2AuthorizedClient`注释]（#testing-oAuth2-client），这将非常方便。
+
+## 配置权限
+
+在许多情况下，你的方法受到过滤器或方法安全性的保护，并且需要你的`Authentication`具有特定的授权来允许请求。
+
+在这种情况下，你可以使用`authorities()`方法提供你需要的授权：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint")
+        .with(oidcLogin()
+            .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
+        )
+    );
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(oidcLogin()
+        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
+    )
+}
+```
+
+## 配置索赔
+
+虽然在所有 Spring 安全中，授予权限是很常见的，但在OAuth2.0的情况下，我们也有主张。
+
+例如，假设你有一个`user_id`声明，它指示了系统中用户的ID。你可以像在控制器中那样访问它：
+
+Java
+
+```
+@GetMapping("/endpoint")
+public String foo(@AuthenticationPrincipal OidcUser oidcUser) {
+    String userId = oidcUser.getIdToken().getClaim("user_id");
+    // ...
+}
+```
+
+Kotlin
+
+```
+@GetMapping("/endpoint")
+fun foo(@AuthenticationPrincipal oidcUser: OidcUser): String {
+    val userId = oidcUser.idToken.getClaim<String>("user_id")
+    // ...
+}
+```
+
+在这种情况下，你需要使用`idToken()`方法来指定该声明：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint")
+        .with(oidcLogin()
+                .idToken(token -> token.claim("user_id", "1234"))
+        )
+    );
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(oidcLogin()
+        .idToken {
+            it.claim("user_id", "1234")
+        }
+    )
+}
+```
+
+由于`OidcUser`从`OidcIdToken`收集其索赔。
+
+## 附加配置
+
+还有其他方法可以用于进一步配置身份验证；它只是取决于控制器所期望的数据：
+
+* `userInfo(OidcUserInfo.Builder)`-用于配置`OidcUserInfo`实例
+
+* `clientRegistration(ClientRegistration)`-用于配置与给定的`ClientRegistration`相关联的`OAuth2AuthorizedClient`
+
+* `oidcUser(OidcUser)`-用于配置完整的`OidcUser`实例
+
+最后一个很方便，如果你：
+1. 有你自己的`OidcUser`的实现，或者
+2. 需要更改名称属性
+
+例如，假设你的授权服务器发送`user_name`声明中的主体名称，而不是`sub`声明中的主体名称。在这种情况下，你可以手动配置`OidcUser`:
+
+Java
+
+```
+OidcUser oidcUser = new DefaultOidcUser(
+        AuthorityUtils.createAuthorityList("SCOPE_message:read"),
+        OidcIdToken.withTokenValue("id-token").claim("user_name", "foo_user").build(),
+        "user_name");
+
+mvc
+    .perform(get("/endpoint")
+        .with(oidcLogin().oidcUser(oidcUser))
+    );
+```
+
+Kotlin
+
+```
+val oidcUser: OidcUser = DefaultOidcUser(
+    AuthorityUtils.createAuthorityList("SCOPE_message:read"),
+    OidcIdToken.withTokenValue("id-token").claim("user_name", "foo_user").build(),
+    "user_name"
+)
+
+mvc.get("/endpoint") {
+    with(oidcLogin().oidcUser(oidcUser))
+}
+```
+
+## 测试OAuth2.0登录
+
+与[测试OIDC登录](#testing-oidc-login)一样，测试OAuth2.0Login也会遇到类似的挑战，即模拟授予流。正因为如此， Spring Security还具有对非OIDC用例的测试支持。
+
+假设我们有一个控制器，可以将登录用户作为`OAuth2User`:
+
+Java
+
+```
+@GetMapping("/endpoint")
+public String foo(@AuthenticationPrincipal OAuth2User oauth2User) {
+    return oauth2User.getAttribute("sub");
+}
+```
+
+Kotlin
+
+```
+@GetMapping("/endpoint")
+fun foo(@AuthenticationPrincipal oauth2User: OAuth2User): String? {
+    return oauth2User.getAttribute("sub")
+}
+```
+
+在这种情况下，我们可以使用`oauth2User`[`RequestPostProcessor`]（request-post-processors.html）告诉 Spring 安全性包含一个默认的`OAuth2User`，就像这样：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint").with(oauth2Login()));
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(oauth2Login())
+}
+```
+
+这样做的目的是将关联的`MockHttpServletRequest`配置为`OAuth2User`，其中包括一个简单的`Map`属性和`Collection`授予权限。
+
+具体地说，它将包括一个`Map`，其键/值对为`sub`/`user`:
+
+Java
+
+```
+assertThat((String) user.getAttribute("sub")).isEqualTo("user");
+```
+
+Kotlin
+
+```
+assertThat(user.getAttribute<String>("sub")).isEqualTo("user")
+```
+
+a`Collection`只有一个权限的权限，`SCOPE_read`:
+
+Java
+
+```
+assertThat(user.getAuthorities()).hasSize(1);
+assertThat(user.getAuthorities()).containsExactly(new SimpleGrantedAuthority("SCOPE_read"));
+```
+
+Kotlin
+
+```
+assertThat(user.authorities).hasSize(1)
+assertThat(user.authorities).containsExactly(SimpleGrantedAuthority("SCOPE_read"))
+```
+
+Spring 安全性做了必要的工作，以确保`OAuth2User`实例可用于[`@AuthenticationPrincipal`注释]。
+
+此外，它还将`OAuth2User`链接到它在模拟`OAuth2AuthorizedClientRepository`中存放的`OAuth2AuthorizedClient`的一个简单实例。如果你的测试[使用`@RegisteredOAuth2AuthorizedClient`注释]（#testing-oAuth2-client），这可能会很方便。
+
+## 配置权限
+
+在许多情况下，你的方法受到过滤器或方法安全性的保护，并且需要你的`Authentication`具有特定的授权来允许请求。
+
+在这种情况下，你可以使用`authorities()`方法提供你需要的授权：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint")
+        .with(oauth2Login()
+            .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
+        )
+    );
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(oauth2Login()
+        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
+    )
+}
+```
+
+## 配置索赔
+
+虽然在所有 Spring 安全中，授予权限是很常见的，但在OAuth2.0的情况下，我们也有主张。
+
+例如，假设你有一个`user_id`属性，该属性指示系统中的用户ID。你可以像在控制器中那样访问它：
+
+Java
+
+```
+@GetMapping("/endpoint")
+public String foo(@AuthenticationPrincipal OAuth2User oauth2User) {
+    String userId = oauth2User.getAttribute("user_id");
+    // ...
+}
+```
+
+Kotlin
+
+```
+@GetMapping("/endpoint")
+fun foo(@AuthenticationPrincipal oauth2User: OAuth2User): String {
+    val userId = oauth2User.getAttribute<String>("user_id")
+    // ...
+}
+```
+
+在这种情况下，你需要使用`attributes()`方法指定该属性：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint")
+        .with(oauth2Login()
+                .attributes(attrs -> attrs.put("user_id", "1234"))
+        )
+    );
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(oauth2Login()
+        .attributes { attrs -> attrs["user_id"] = "1234" }
+    )
+}
+```
+
+## 附加配置
+
+还有其他方法可以用于进一步配置身份验证；它只是取决于控制器所期望的数据：
+
+* `clientRegistration(ClientRegistration)`-用于配置与给定的`ClientRegistration`相关联的`OAuth2AuthorizedClient`
+
+* `oauth2User(OAuth2User)`-用于配置完整的`OAuth2User`实例
+
+最后一个很方便，如果你：
+1. 有你自己的`OAuth2User`的实现，或者
+2. 需要更改名称属性
+
+例如，假设你的授权服务器发送`user_name`声明中的主体名称，而不是`sub`声明中的主体名称。在这种情况下，你可以手动配置`OAuth2User`:
+
+Java
+
+```
+OAuth2User oauth2User = new DefaultOAuth2User(
+        AuthorityUtils.createAuthorityList("SCOPE_message:read"),
+        Collections.singletonMap("user_name", "foo_user"),
+        "user_name");
+
+mvc
+    .perform(get("/endpoint")
+        .with(oauth2Login().oauth2User(oauth2User))
+    );
+```
+
+Kotlin
+
+```
+val oauth2User: OAuth2User = DefaultOAuth2User(
+    AuthorityUtils.createAuthorityList("SCOPE_message:read"),
+    mapOf(Pair("user_name", "foo_user")),
+    "user_name"
+)
+
+mvc.get("/endpoint") {
+    with(oauth2Login().oauth2User(oauth2User))
+}
+```
+
+## 测试OAuth2.0客户端
+
+独立于你的用户如何进行身份验证，你可能有其他令牌和客户端注册，这些令牌和客户端注册正在为你正在测试的请求发挥作用。例如，你的控制器可能依赖于客户机凭据授权来获得一个与用户完全不相关的令牌：
+
+Java
+
+```
+@GetMapping("/endpoint")
+public String foo(@RegisteredOAuth2AuthorizedClient("my-app") OAuth2AuthorizedClient authorizedClient) {
+    return this.webClient.get()
+        .attributes(oauth2AuthorizedClient(authorizedClient))
+        .retrieve()
+        .bodyToMono(String.class)
+        .block();
+}
+```
+
+Kotlin
+
+```
+@GetMapping("/endpoint")
+fun foo(@RegisteredOAuth2AuthorizedClient("my-app") authorizedClient: OAuth2AuthorizedClient?): String? {
+    return this.webClient.get()
+        .attributes(oauth2AuthorizedClient(authorizedClient))
+        .retrieve()
+        .bodyToMono(String::class.java)
+        .block()
+}
+```
+
+用授权服务器模拟这种握手可能会很麻烦。相反，你可以使用`oauth2Client`[`RequestPostProcessor`]（request-post-processors.html）将`OAuth2AuthorizedClient`添加到模拟`OAuth2AuthorizedClientRepository`中：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint").with(oauth2Client("my-app")));
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(
+        oauth2Client("my-app")
+    )
+}
+```
+
+这将创建一个`OAuth2AuthorizedClient`，它具有一个简单的`ClientRegistration`、`OAuth2AccessToken`和资源所有者名称。
+
+具体地说，它将包括一个`ClientRegistration`，其客户端ID为“test-client”，客户端秘密为“test-secret”：
+
+Java
+
+```
+assertThat(authorizedClient.getClientRegistration().getClientId()).isEqualTo("test-client");
+assertThat(authorizedClient.getClientRegistration().getClientSecret()).isEqualTo("test-secret");
+```
+
+Kotlin
+
+```
+assertThat(authorizedClient.clientRegistration.clientId).isEqualTo("test-client")
+assertThat(authorizedClient.clientRegistration.clientSecret).isEqualTo("test-secret")
+```
+
+“user”的资源所有者名称：
+
+Java
+
+```
+assertThat(authorizedClient.getPrincipalName()).isEqualTo("user");
+```
+
+Kotlin
+
+```
+assertThat(authorizedClient.principalName).isEqualTo("user")
+```
+
+以及只有一个作用域`OAuth2AccessToken`的`read`:
+
+Java
+
+```
+assertThat(authorizedClient.getAccessToken().getScopes()).hasSize(1);
+assertThat(authorizedClient.getAccessToken().getScopes()).containsExactly("read");
+```
+
+Kotlin
+
+```
+assertThat(authorizedClient.accessToken.scopes).hasSize(1)
+assertThat(authorizedClient.accessToken.scopes).containsExactly("read")
+```
+
+然后在控制器方法中使用`@RegisteredOAuth2AuthorizedClient`可以正常地检索客户端。
+
+## 配置作用域
+
+在许多情况下，OAuth2.0访问令牌都带有一组作用域。如果你的控制员检查了这些，请这样说：
+
+Java
+
+```
+@GetMapping("/endpoint")
+public String foo(@RegisteredOAuth2AuthorizedClient("my-app") OAuth2AuthorizedClient authorizedClient) {
+    Set<String> scopes = authorizedClient.getAccessToken().getScopes();
+    if (scopes.contains("message:read")) {
+        return this.webClient.get()
+            .attributes(oauth2AuthorizedClient(authorizedClient))
+            .retrieve()
+            .bodyToMono(String.class)
+            .block();
+    }
+    // ...
+}
+```
+
+Kotlin
+
+```
+@GetMapping("/endpoint")
+fun foo(@RegisteredOAuth2AuthorizedClient("my-app") authorizedClient: OAuth2AuthorizedClient): String? {
+    val scopes = authorizedClient.accessToken.scopes
+    if (scopes.contains("message:read")) {
+        return webClient.get()
+            .attributes(oauth2AuthorizedClient(authorizedClient))
+            .retrieve()
+            .bodyToMono(String::class.java)
+            .block()
+    }
+    // ...
+}
+```
+
+然后，你可以使用`accessToken()`方法配置范围：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint")
+        .with(oauth2Client("my-app")
+            .accessToken(new OAuth2AccessToken(BEARER, "token", null, null, Collections.singleton("message:read"))))
+        )
+    );
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(oauth2Client("my-app")
+            .accessToken(OAuth2AccessToken(BEARER, "token", null, null, Collections.singleton("message:read")))
+    )
+}
+```
+
+## 附加配置
+
+还有其他方法可以用于进一步配置身份验证；它只是取决于控制器所期望的数据：
+
+* `principalName(String)`-用于配置资源所有者名称
+
+* `clientRegistration(Consumer<ClientRegistration.Builder>)`-用于配置相关的`ClientRegistration`
+
+* `clientRegistration(ClientRegistration)`-用于配置完整的`ClientRegistration`
+
+如果你想使用真正的`ClientRegistration`，那么最后一个就很方便了。
+
+例如，假设你希望使用你的应用程序的`ClientRegistration`定义之一，如你的`application.yml`中所指定的。
+
+在这种情况下，你的测试可以自动连接`ClientRegistrationRepository`并查找你的测试所需的一个：
+
+Java
+
+```
+@Autowired
+ClientRegistrationRepository clientRegistrationRepository;
+
+// ...
+
+mvc
+    .perform(get("/endpoint")
+        .with(oauth2Client()
+            .clientRegistration(this.clientRegistrationRepository.findByRegistrationId("facebook"))));
+```
+
+Kotlin
+
+```
+@Autowired
+lateinit var clientRegistrationRepository: ClientRegistrationRepository
+
+// ...
+
+mvc.get("/endpoint") {
+    with(oauth2Client("my-app")
+        .clientRegistration(clientRegistrationRepository.findByRegistrationId("facebook"))
+    )
+}
+```
+
+## 测试JWT身份验证
+
+为了在资源服务器上发出授权请求，你需要一个承载令牌。
+
+如果你的资源服务器是为JWTS配置的，那么这将意味着需要对承载令牌进行签名，然后根据JWT规范对其进行编码。所有这一切都可能令人望而生畏，尤其是当这不是测试的重点时。
+
+幸运的是，有许多简单的方法可以克服这个困难，并允许你的测试专注于授权，而不是表示不记名令牌。我们现在来看看其中的两个：
+
+##  RequestPostProcessor`
+
+第一种方法是通过`jwt`[`RequestPostProcessor`]（request-post-processors.html）。其中最简单的例子是这样的：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint").with(jwt()));
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(jwt())
+}
+```
+
+这将创建一个模拟`Jwt`，将其正确地传递给任何身份验证API，以便你的授权机制可以对其进行验证。
+
+默认情况下，它创建的`JWT`具有以下特征：
+
+```
+{
+  "headers" : { "alg" : "none" },
+  "claims" : {
+    "sub" : "user",
+    "scope" : "read"
+  }
+}
+```
+
+结果`Jwt`，如果进行测试，将以以下方式通过：
+
+Java
+
+```
+assertThat(jwt.getTokenValue()).isEqualTo("token");
+assertThat(jwt.getHeaders().get("alg")).isEqualTo("none");
+assertThat(jwt.getSubject()).isEqualTo("sub");
+```
+
+Kotlin
+
+```
+assertThat(jwt.tokenValue).isEqualTo("token")
+assertThat(jwt.headers["alg"]).isEqualTo("none")
+assertThat(jwt.subject).isEqualTo("sub")
+```
+
+当然，可以对这些值进行配置。
+
+任何标题或权利要求都可以配置相应的方法：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint")
+        .with(jwt().jwt(jwt -> jwt.header("kid", "one").claim("iss", "https://idp.example.org"))));
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(
+        jwt().jwt { jwt -> jwt.header("kid", "one").claim("iss", "https://idp.example.org") }
+    )
+}
+```
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint")
+        .with(jwt().jwt(jwt -> jwt.claims(claims -> claims.remove("scope")))));
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(
+        jwt().jwt { jwt -> jwt.claims { claims -> claims.remove("scope") } }
+    )
+}
+```
+
+在这里，对`scope`和`scp`声明的处理方式与在正常的无记名令牌请求中的处理方式相同。但是，只需提供测试所需的`GrantedAuthority`实例的列表，就可以覆盖此内容：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint")
+        .with(jwt().authorities(new SimpleGrantedAuthority("SCOPE_messages"))));
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(
+        jwt().authorities(SimpleGrantedAuthority("SCOPE_messages"))
+    )
+}
+```
+
+或者，如果你有一个自定义的`Jwt`到`Collection<GrantedAuthority>`转换器，那么你也可以使用它来派生权威：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint")
+        .with(jwt().authorities(new MyConverter())));
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(
+        jwt().authorities(MyConverter())
+    )
+}
+```
+
+你还可以指定一个完整的`Jwt`，其中`[Jwt.Builder](https://docs.spring.io/spring-security/site/docs/5.6.2/api/org/springframework/security/oauth2/jwt/Jwt.Builder.html)`非常方便：
+
+Java
+
+```
+Jwt jwt = Jwt.withTokenValue("token")
+    .header("alg", "none")
+    .claim("sub", "user")
+    .claim("scope", "read")
+    .build();
+
+mvc
+    .perform(get("/endpoint")
+        .with(jwt().jwt(jwt)));
+```
+
+Kotlin
+
+```
+val jwt: Jwt = Jwt.withTokenValue("token")
+    .header("alg", "none")
+    .claim("sub", "user")
+    .claim("scope", "read")
+    .build()
+
+mvc.get("/endpoint") {
+    with(
+        jwt().jwt(jwt)
+    )
+}
+```
+
+## ` `RequestPostProcessor`
+
+第二种方法是使用`authentication()`[`RequestPostProcessor`]（request-post-processors.html）。本质上，你可以实例化自己的`JwtAuthenticationToken`并在测试中提供它，如下所示：
+
+Java
+
+```
+Jwt jwt = Jwt.withTokenValue("token")
+    .header("alg", "none")
+    .claim("sub", "user")
+    .build();
+Collection<GrantedAuthority> authorities = AuthorityUtils.createAuthorityList("SCOPE_read");
+JwtAuthenticationToken token = new JwtAuthenticationToken(jwt, authorities);
+
+mvc
+    .perform(get("/endpoint")
+        .with(authentication(token)));
+```
+
+Kotlin
+
+```
+val jwt = Jwt.withTokenValue("token")
+    .header("alg", "none")
+    .claim("sub", "user")
+    .build()
+val authorities: Collection<GrantedAuthority> = AuthorityUtils.createAuthorityList("SCOPE_read")
+val token = JwtAuthenticationToken(jwt, authorities)
+
+mvc.get("/endpoint") {
+    with(
+        authentication(token)
+    )
+}
+```
+
+请注意，作为这些方法的替代方法，你还可以使用`JwtDecoder` Bean 注释来模拟`@MockBean`本身。
+
+## 测试不透明令牌身份验证
+
+与[JWTs](#testing-jwt)类似，不透明令牌需要授权服务器来验证其有效性，这可能会使测试更加困难。 Spring 为了帮助实现这一点，Security提供了对不透明令牌的测试支持。
+
+假设我们有一个控制器，它以`BearerTokenAuthentication`的形式检索身份验证：
+
+Java
+
+```
+@GetMapping("/endpoint")
+public String foo(BearerTokenAuthentication authentication) {
+    return (String) authentication.getTokenAttributes().get("sub");
+}
+```
+
+Kotlin
+
+```
+@GetMapping("/endpoint")
+fun foo(authentication: BearerTokenAuthentication): String {
+    return authentication.tokenAttributes["sub"] as String
+}
+```
+
+在这种情况下，我们可以使用`opaqueToken`[`RequestPostProcessor`]（request-post-processors.html）方法告诉 Spring 安全性包含一个默认的`BearerTokenAuthentication`，就像这样：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint").with(opaqueToken()));
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(opaqueToken())
+}
+```
+
+这样做的目的是将关联的`MockHttpServletRequest`配置为`BearerTokenAuthentication`，其中包括一个简单的`OAuth2AuthenticatedPrincipal`、`Map`的属性，以及`Collection`的授予权限。
+
+具体地说，它将包括一个`Map`，其键/值对为`sub`/`user`:
+
+Java
+
+```
+assertThat((String) token.getTokenAttributes().get("sub")).isEqualTo("user");
+```
+
+Kotlin
+
+```
+assertThat(token.tokenAttributes["sub"] as String).isEqualTo("user")
+```
+
+a`Collection`只有一个权限的权限，`SCOPE_read`:
+
+Java
+
+```
+assertThat(token.getAuthorities()).hasSize(1);
+assertThat(token.getAuthorities()).containsExactly(new SimpleGrantedAuthority("SCOPE_read"));
+```
+
+Kotlin
+
+```
+assertThat(token.authorities).hasSize(1)
+assertThat(token.authorities).containsExactly(SimpleGrantedAuthority("SCOPE_read"))
+```
+
+Spring 安全性做了必要的工作，以确保`BearerTokenAuthentication`实例可用于你的控制器方法。
+
+## 配置权限
+
+在许多情况下，你的方法都受到过滤器或方法安全性的保护，并且需要你的`Authentication`拥有特定的授权来允许请求。
+
+在这种情况下，你可以使用`authorities()`方法提供你需要的授权：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint")
+        .with(opaqueToken()
+            .authorities(new SimpleGrantedAuthority("SCOPE_message:read"))
+        )
+    );
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(opaqueToken()
+        .authorities(SimpleGrantedAuthority("SCOPE_message:read"))
+    )
+}
+```
+
+## 配置索赔
+
+虽然在所有 Spring 安全性中，授予权限是非常常见的，但在OAuth2.0的情况下，我们也有属性。
+
+举个例子，你有一个`user_id`属性，它指示系统中用户的ID。你可以像在控制器中那样访问它：
+
+Java
+
+```
+@GetMapping("/endpoint")
+public String foo(BearerTokenAuthentication authentication) {
+    String userId = (String) authentication.getTokenAttributes().get("user_id");
+    // ...
+}
+```
+
+Kotlin
+
+```
+@GetMapping("/endpoint")
+fun foo(authentication: BearerTokenAuthentication): String {
+    val userId = authentication.tokenAttributes["user_id"] as String
+    // ...
+}
+```
+
+在这种情况下，你需要使用`attributes()`方法指定该属性：
+
+Java
+
+```
+mvc
+    .perform(get("/endpoint")
+        .with(opaqueToken()
+                .attributes(attrs -> attrs.put("user_id", "1234"))
+        )
+    );
+```
+
+Kotlin
+
+```
+mvc.get("/endpoint") {
+    with(opaqueToken()
+        .attributes { attrs -> attrs["user_id"] = "1234" }
+    )
+}
+```
+
+## 附加配置
+
+还有其他方法来进一步配置身份验证；它只是取决于控制器期望的数据。
+
+其中一个是`principal(OAuth2AuthenticatedPrincipal)`，你可以使用它来配置作为`OAuth2AuthenticatedPrincipal`实例基础的完整`BearerTokenAuthentication`实例。
+
+如果你：
+1. 有你自己的`OAuth2AuthenticatedPrincipal`的实现，或者
+2. 想要指定不同的主体名称
+
+例如，假设你的授权服务器发送`user_name`属性中的主体名称，而不是`sub`属性中的主体名称。在这种情况下，你可以手动配置`OAuth2AuthenticatedPrincipal`:
+
+Java
+
+```
+Map<String, Object> attributes = Collections.singletonMap("user_name", "foo_user");
+OAuth2AuthenticatedPrincipal principal = new DefaultOAuth2AuthenticatedPrincipal(
+        (String) attributes.get("user_name"),
+        attributes,
+        AuthorityUtils.createAuthorityList("SCOPE_message:read"));
+
+mvc
+    .perform(get("/endpoint")
+        .with(opaqueToken().principal(principal))
+    );
+```
+
+Kotlin
+
+```
+val attributes: Map<String, Any> = Collections.singletonMap("user_name", "foo_user")
+val principal: OAuth2AuthenticatedPrincipal = DefaultOAuth2AuthenticatedPrincipal(
+    attributes["user_name"] as String?,
+    attributes,
+    AuthorityUtils.createAuthorityList("SCOPE_message:read")
+)
+
+mvc.get("/endpoint") {
+    with(opaqueToken().principal(principal))
+}
+```
+
+请注意，作为使用`opaqueToken()`测试支持的替代方法，你还可以使用`OpaqueTokenIntrospector` Bean 注释来模拟`OpaqueTokenIntrospector`本身。
+
+[模拟HTTP BASIC ](http-basic.html)[模拟注销](logout.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-test-mockmvc-request-builders.md b/docs/spring-security/servlet-test-mockmvc-request-builders.md
new file mode 100644
index 0000000..1f29596
--- /dev/null
+++ b/docs/spring-security/servlet-test-mockmvc-request-builders.md
@@ -0,0 +1,17 @@
+## 安全模型CrequestBuilders
+
+Spring MVC测试还提供了一个`RequestBuilder`接口，该接口可用于创建测试中使用的`MockHttpServletRequest`。 Spring 安全性提供了一些`RequestBuilder`实现，可以用来使测试更容易。为了使用 Spring Security的`RequestBuilder`实现，确保使用以下静态导入：
+
+Java
+
+```
+import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestBuilders.*;
+```
+
+Kotlin
+
+```
+import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestBuilders.*
+```
+
+[模拟注销](logout.html)[安全结果匹配器](result-matchers.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-test-mockmvc-request-post-processors.md b/docs/spring-security/servlet-test-mockmvc-request-post-processors.md
new file mode 100644
index 0000000..7d76748
--- /dev/null
+++ b/docs/spring-security/servlet-test-mockmvc-request-post-processors.md
@@ -0,0 +1,26 @@
+# SecurityMockmvCrequestPostProcessors
+
+为了使用 Spring Security的`RequestPostProcessor`实现，确保使用以下静态导入：
+
+Java
+
+```
+import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.*;
+```
+
+Kotlin
+
+```
+import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.*
+```
+
+## 章节摘要
+
+* [嘲笑用户](authentication.html)
+* [嘲笑CSRF ](csrf.html)
+* [模拟表单登录](form-login.html)
+* [模拟HTTP BASIC ](http-basic.html)
+* [嘲笑OAuth2](oauth2.html)
+* [模拟注销](logout.html)
+
+[MockMVC设置](setup.html)[嘲笑用户](authentication.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-test-mockmvc-result-handlers.md b/docs/spring-security/servlet-test-mockmvc-result-handlers.md
new file mode 100644
index 0000000..7076db0
--- /dev/null
+++ b/docs/spring-security/servlet-test-mockmvc-result-handlers.md
@@ -0,0 +1,54 @@
+### 安全模型cresulthandlers
+
+Spring 安全性提供了一些`ResultHandler`s的实现方式。为了使用 Spring Security的`ResultHandler`s实现，确保使用以下静态导入：
+
+```
+import static org.springframework.security.test.web.servlet.response.SecurityMockMvcResultHandlers.*;
+```
+
+#### 导出SecurityContext
+
+通常情况下，我们希望查询存储库，以查看某些`MockMvc`请求是否确实在数据库中持续存在。在某些情况下，我们的存储库查询使用[Spring Data Integration](../../../features/integrations/data.html)基于当前用户的用户名或任何其他属性来过滤结果。让我们来看一个例子：
+
+存储库接口：
+
+```
+private interface MessageRepository extends JpaRepository<Message, Long> {
+	@Query("SELECT m.content FROM Message m WHERE m.sentBy = ?#{ principal?.name }")
+	List<String> findAllUserMessages();
+}
+```
+
+我们的测试场景：
+
+```
+mvc
+	.perform(post("/message")
+		.content("New Message")
+		.contentType(MediaType.TEXT_PLAIN)
+	)
+	.andExpect(status().isOk());
+
+List<String> userMessages = messageRepository.findAllUserMessages();
+assertThat(userMessages).hasSize(1);
+```
+
+这个测试不会通过，因为在我们的请求完成后，`SecurityContextHolder`将被过滤链清除。然后，我们可以将`TestSecurityContextHolder`导出到`SecurityContextHolder`，并根据需要使用它：
+
+```
+mvc
+	.perform(post("/message")
+		.content("New Message")
+		.contentType(MediaType.TEXT_PLAIN)
+	)
+	.andDo(exportTestSecurityContext())
+	.andExpect(status().isOk());
+
+List<String> userMessages = messageRepository.findAllUserMessages();
+assertThat(userMessages).hasSize(1);
+```
+
+|   |记住在两次测试之间清除`SecurityContextHolder`，否则它可能会在测试之间泄漏。|
+|---|---------------------------------------------------------------------------------------------|
+
+[安全结果匹配器](result-matchers.html)[Appendix](../../appendix/index.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-test-mockmvc-result-matchers.md b/docs/spring-security/servlet-test-mockmvc-result-matchers.md
new file mode 100644
index 0000000..9d4d5c4
--- /dev/null
+++ b/docs/spring-security/servlet-test-mockmvc-result-matchers.md
@@ -0,0 +1,134 @@
+## 安全mckmvcresultmatchers
+
+有时，希望对请求做出各种与安全相关的断言。为了满足这一需求， Spring 安全测试支持实现了 Spring MVC测试的`ResultMatcher`接口。为了使用 Spring Security的`ResultMatcher`实现，确保使用以下静态导入：
+
+Java
+
+```
+import static org.springframework.security.test.web.servlet.response.SecurityMockMvcResultMatchers.*;
+```
+
+Kotlin
+
+```
+import org.springframework.security.test.web.servlet.response.SecurityMockMvcResultMatchers.*
+```
+
+### 未经验证的断言
+
+有时，断言没有经过身份验证的用户与`MockMvc`调用的结果相关联可能是有价值的。例如，你可能想要测试提交的用户名和密码是否无效，并验证是否有用户通过了身份验证。使用 Spring Security的测试支持，你可以很容易地使用以下内容来实现这一点：
+
+Java
+
+```
+mvc
+	.perform(formLogin().password("invalid"))
+	.andExpect(unauthenticated());
+```
+
+Kotlin
+
+```
+mvc
+    .perform(formLogin().password("invalid"))
+    .andExpect { unauthenticated() }
+```
+
+### 经过验证的断言
+
+通常情况下，我们必须断言存在经过身份验证的用户。例如，我们可能想要验证我们的身份验证是否成功。我们可以使用以下代码片段来验证基于表单的登录是否成功：
+
+Java
+
+```
+mvc
+	.perform(formLogin())
+	.andExpect(authenticated());
+```
+
+Kotlin
+
+```
+mvc
+    .perform(formLogin())
+    .andExpect { authenticated() }
+```
+
+如果我们想要确定用户的角色，我们可以改进以前的代码，如下所示：
+
+Java
+
+```
+mvc
+	.perform(formLogin().user("admin"))
+	.andExpect(authenticated().withRoles("USER","ADMIN"));
+```
+
+Kotlin
+
+```
+mvc
+    .perform(formLogin())
+    .andExpect { authenticated().withRoles("USER","ADMIN") }
+```
+
+或者，我们可以验证用户名：
+
+Java
+
+```
+mvc
+	.perform(formLogin().user("admin"))
+	.andExpect(authenticated().withUsername("admin"));
+```
+
+Kotlin
+
+```
+mvc
+    .perform(formLogin().user("admin"))
+    .andExpect { authenticated().withUsername("admin") }
+```
+
+我们也可以将这些断言结合起来：
+
+Java
+
+```
+mvc
+	.perform(formLogin().user("admin"))
+	.andExpect(authenticated().withUsername("admin").withRoles("USER", "ADMIN"));
+```
+
+Kotlin
+
+```
+mvc
+    .perform(formLogin().user("admin"))
+    .andExpect { authenticated().withUsername("admin").withRoles("USER", "ADMIN") }
+```
+
+我们还可以对身份验证进行任意断言。
+
+Java
+
+```
+mvc
+	.perform(formLogin())
+	.andExpect(authenticated().withAuthentication(auth ->
+		assertThat(auth).isInstanceOf(UsernamePasswordAuthenticationToken.class)));
+```
+
+Kotlin
+
+```
+mvc
+    .perform(formLogin())
+    .andExpect {
+        authenticated().withAuthentication { auth ->
+            assertThat(auth).isInstanceOf(UsernamePasswordAuthenticationToken::class.java) }
+        }
+    }
+```
+
+[安全请求者](request-builders.html)[安全结果制造者](result-handlers.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-test-mockmvc-setup.md b/docs/spring-security/servlet-test-mockmvc-setup.md
new file mode 100644
index 0000000..9362a4e
--- /dev/null
+++ b/docs/spring-security/servlet-test-mockmvc-setup.md
@@ -0,0 +1,60 @@
+# 设置mockmvc和 Spring 安全性
+
+为了使用 Spring 安全性与 Spring MVC测试，有必要将 Spring 安全性`FilterChainProxy`添加为`Filter`。还需要添加 Spring security的`TestSecurityContextHolderPostProcessor`以支持[Running as a User in Spring MVC Test with Annotations](#test-mockmvc-withmockuser)。这可以使用 Spring security的`SecurityMockMvcConfigurers.springSecurity()`来完成。例如：
+
+|   |Spring 安全性的测试支持需要 Spring-test-4.1.3.release或更高版本。|
+|---|--------------------------------------------------------------------------------|
+
+Java
+
+```
+import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.*;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = SecurityConfig.class)
+@WebAppConfiguration
+public class CsrfShowcaseTests {
+
+	@Autowired
+	private WebApplicationContext context;
+
+	private MockMvc mvc;
+
+	@Before
+	public void setup() {
+		mvc = MockMvcBuilders
+				.webAppContextSetup(context)
+				.apply(springSecurity()) (1)
+				.build();
+	}
+
+...
+```
+
+Kotlin
+
+```
+@RunWith(SpringJUnit4ClassRunner::class)
+@ContextConfiguration(classes = [SecurityConfig::class])
+@WebAppConfiguration
+class CsrfShowcaseTests {
+
+    @Autowired
+    private lateinit var context: WebApplicationContext
+
+    private var mvc: MockMvc? = null
+
+    @Before
+    fun setup() {
+        mvc = MockMvcBuilders
+            .webAppContextSetup(context)
+            .apply<DefaultMockMvcBuilder>(springSecurity()) (1)
+            .build()
+    }
+// ...
+```
+
+|**1**|`SecurityMockMvcConfigurers.springSecurity()`将执行将 Spring 安全性与 Spring MVC测试集成所需的所有初始设置|
+|-----|---------------------------------------------------------------------------------------------------------------------------------------------|
+
+[MockMVC支持](index.html)[安全请求后置处理器](request-post-processors.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-test-mockmvc.md b/docs/spring-security/servlet-test-mockmvc.md
new file mode 100644
index 0000000..330aab6
--- /dev/null
+++ b/docs/spring-security/servlet-test-mockmvc.md
@@ -0,0 +1,5 @@
+# Spring MVC测试集成
+
+Spring 安全性提供了与[Spring MVC Test](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/testing.html#spring-mvc-test-framework)的全面集成
+
+[方法安全性](../method.html)[MockMVC设置](setup.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet-test.md b/docs/spring-security/servlet-test.md
new file mode 100644
index 0000000..bc1ea19
--- /dev/null
+++ b/docs/spring-security/servlet-test.md
@@ -0,0 +1,19 @@
+# 测试
+
+本节描述 Spring Security提供的测试支持。
+
+要使用 Spring 安全测试支持，你必须将`spring-security-test-5.6.2.jar`作为项目的依赖项。
+
+在高级 Spring 级别，Security的测试支持为以下方面提供集成：
+
+## 章节摘要
+
+* [方法安全性](method.html)
+* [MockMVC支持](mockmvc/index.html)
+* [MockMVC设置](mockmvc/setup.html)
+* [安全请求后置处理器](mockmvc/request-post-processors.html)
+* [安全请求者](mockmvc/request-builders.html)
+* [安全结果匹配器](mockmvc/result-matchers.html)
+* [安全结果制造者](mockmvc/result-handlers.html)
+
+[名称空间配置](../configuration/xml-namespace.html)[方法安全性](method.html)
\ No newline at end of file
diff --git a/docs/spring-security/servlet.md b/docs/spring-security/servlet.md
new file mode 100644
index 0000000..1cd3d13
--- /dev/null
+++ b/docs/spring-security/servlet.md
@@ -0,0 +1,19 @@
+# Servlet 应用程序
+
+Spring 安全性通过使用标准 Servlet `Filter`与 Servlet 容器集成。这意味着它可以与在 Servlet 容器中运行的任何应用程序一起工作。更具体地说，你不需要在基于 Servlet 的应用程序中使用 Spring 来利用 Spring 安全性。
+
+## 章节摘要
+
+* [开始](getting-started.html)
+* [建筑](architecture.html)
+* [认证](authentication/index.html)
+* [授权](authorization/index.html)
+* [OAuth2](oauth2/index.html)
+* [SAML2](saml2/index.html)
+* [保护免受剥削](exploits/index.html)
+* [整合](integrations/index.html)
+* 配置
+* [Testing](test/index.html)
+* [Appendix](appendix/index.html)
+
+[Samples](../samples.html)[开始](getting-started.html)
\ No newline at end of file
diff --git a/docs/spring-security/whats-new.md b/docs/spring-security/whats-new.md
new file mode 100644
index 0000000..8fa11b3
--- /dev/null
+++ b/docs/spring-security/whats-new.md
@@ -0,0 +1,67 @@
+# 最新更新在 Spring 安全性5.6中
+
+Spring 安全性5.6提供了许多新功能。以下是此次发布会的亮点。
+
+* 所有新的[Antora](https://antora.org/)基于[文件](https://docs.spring.io/spring-security/)。
+
+## Servlet
+
+* 核心
+
+  * 介绍了[`SecurityContextChangedListener`]（https://github.com/ Spring-projects/ Spring-security/issues/10226）
+
+  * 改进的[方法安全日志](https://github.com/spring-projects/spring-security/pull/10279)
+
+* 配置
+
+  * 为方法安全性引入了[`AuthorizationManager`]（https://github.com/ Spring-projects/ Spring-security/pull/9630）
+
+* SAML2.0服务提供商
+
+  * 新增[SAML2.0单注销支持](servlet/saml2/logout.html)
+
+  * 新增[SAML2身份验证请求存储库](servlet/saml2/login/authentication-requests.html#servlet-saml2login-store-authn-request)
+
+  * 添加了[`RelyingPartyRegistrationResolver`]（ Servlet/saml2/login/overview.html# Servlet-saml2login-rpr-relyingpartyregistrationresolver）
+
+  * 改进了`Saml2LoginConfigurer`对[`Saml2AuthenticationTokenConverter`]的处理（https://github.com/ Spring-projects/ Spring-security/issues/10268）
+
+* OAuth2.0登录
+
+  * 添加了[`Converter`for`Authentication`结果]（https://github.com/ Spring-projects/ Spring-security/pull/10041）
+
+* OAuth2.0客户端
+
+  * 改进的[客户端凭据编码](https://github.com/spring-projects/spring-security/pull/9791)
+
+  * 改进的[访问令牌响应解析](https://github.com/spring-projects/spring-security/pull/9779)
+
+  * 为授权请求添加了[自定义授权类型支持](https://github.com/spring-projects/spring-security/pull/10155)
+
+  * 推出[JwtEncoder](https://github.com/spring-projects/spring-security/pull/9208)
+
+* 测试
+
+  * 添加对[将TestSecurityContexholder传播到SecurityContexholder](https://github.com/spring-projects/spring-security/pull/9737)的支持
+
+## WebFlux
+
+* OAuth2.0登录
+
+  * 改进的[Active OAuth2.0登录文档](reactive/oauth2/login/index.html)
+
+* OAuth2.0客户端
+
+  * 改进的[客户端凭据编码](https://github.com/spring-projects/spring-security/pull/9791)
+
+  * 为访问令牌请求添加了[自定义头支持](https://github.com/spring-projects/spring-security/pull/10131)
+
+  * 为访问令牌请求添加了[自定义响应解析](https://github.com/spring-projects/spring-security/pull/10269)
+
+  * 为访问令牌请求添加了[JWT-持股人授予类型支持](https://github.com/spring-projects/spring-security/pull/10327)
+
+  * 为访问令牌请求添加了[JWT客户端身份验证支持](https://github.com/spring-projects/spring-security/pull/10336)
+
+  * 改进的[Active OAuth2.0客户端文档](reactive/oauth2/client/index.html)
+
+[Community](community.html)[Getting Spring Security](getting-spring-security.html)
\ No newline at end of file
-- 
GitLab