跳到主要内容
版本：7.0.2

DeepSeek V3 中英对照 OAuth2 Authorization Grants #

授权许可支持

本节介绍 Spring Security 对授权许可的支持。

授权码​

备注

有关 授权码 授权的更多详细信息，请参阅 OAuth 2.0 授权框架。

获取授权​

备注

请参考授权码许可的授权请求/响应协议流程。

发起授权请求​

OAuth2AuthorizationRequestRedirectWebFilter 使用 ServerOAuth2AuthorizationRequestResolver 来解析 OAuth2AuthorizationRequest，并通过将终端用户的用户代理重定向到授权服务器的授权端点来启动授权码授权流程。

ServerOAuth2AuthorizationRequestResolver 的主要作用是从提供的 Web 请求中解析出 OAuth2AuthorizationRequest。默认实现 DefaultServerOAuth2AuthorizationRequestResolver 会匹配（默认的）路径 /oauth2/authorization/{registrationId}，提取其中的 registrationId，并使用它来为关联的 ClientRegistration 构建 OAuth2AuthorizationRequest。

给定以下用于 OAuth 2.0 客户端注册的 Spring Boot 属性：

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 的请求将由 OAuth2AuthorizationRequestRedirectWebFilter 发起授权请求重定向，并最终启动授权码授权流程。

备注

AuthorizationCodeReactiveOAuth2AuthorizedClientProvider 是 ReactiveOAuth2AuthorizedClientProvider 针对授权码（Authorization Code）授权模式的一个实现，它还会通过 OAuth2AuthorizationRequestRedirectWebFilter 发起授权请求的重定向。

如果 OAuth 2.0 客户端是一个公共客户端，请按如下方式配置 OAuth 2.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"
            # ...

公共客户端支持使用代码交换证明密钥（PKCE）。如果客户端运行在不可信的环境中（例如：原生应用程序或基于Web浏览器的应用程序），因此无法保持其凭据的机密性，则在满足以下条件时将自动使用PKCE：

  1. client-secret 被省略（或为空）

  2. client-authentication-method 被设置为 "none" (ClientAuthenticationMethod.NONE)

或

  1. 当 ClientRegistration.clientSettings.requireProofKey 为 true 时（此时 ClientRegistration.authorizationGrantType 必须为 authorization_code）
提示

如果 OAuth 2.0 提供者支持为机密客户端使用 PKCE，你可以（可选地）通过 DefaultServerOAuth2AuthorizationRequestResolver.setAuthorizationRequestCustomizer(OAuth2AuthorizationRequestCustomizers.withPkce()) 来配置它。

DefaultServerOAuth2AuthorizationRequestResolver 也支持使用 UriComponentsBuilder 为 redirect-uri 设置 URI 模板变量。

以下配置使用了所有支持的 URI 模板变量：

spring:
  security:
    oauth2:
      client:
        registration:
          okta:
            # ...
            redirect-uri: "{baseScheme}://{baseHost}{basePort}{basePath}/authorized/{registrationId}"
            # ...
备注

{baseUrl} 解析为 {baseScheme}://{baseHost}{basePort}{basePath}

配置 redirect-uri 时使用 URI 模板变量尤其适用于 OAuth 2.0 客户端运行在代理服务器后方的情况。这确保了在扩展 redirect-uri 时会使用 X-Forwarded-* 头部信息。

自定义授权请求​

ServerOAuth2AuthorizationRequestResolver 的主要用例之一是能够通过添加超出 OAuth 2.0 授权框架定义的标准参数之外的额外参数，来自定义授权请求。

例如，OpenID Connect 为授权码流程定义了额外的 OAuth 2.0 请求参数，这些参数扩展自OAuth 2.0 授权框架中定义的标准参数。其中一个扩展参数就是 prompt 参数。

备注

prompt 参数是可选的。它是一个由空格分隔、大小写敏感的 ASCII 字符串值列表，用于指定授权服务器是否提示最终用户进行重新认证和同意。已定义的值包括：none、login、consent 和 select_account。

以下示例展示了如何配置 DefaultServerOAuth2AuthorizationRequestResolver，通过一个 Consumer<OAuth2AuthorizationRequest.Builder> 来自定义 oauth2Login() 的授权请求，具体方式是在请求中包含参数 prompt=consent。

@Configuration
@EnableWebFluxSecurity
public class OAuth2LoginSecurityConfig {

	@Autowired
	private ReactiveClientRegistrationRepository clientRegistrationRepository;

	@Bean
	public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
		http
			.authorizeExchange((authorize) -> authorize
				.anyExchange().authenticated()
			)
			.oauth2Login((oauth2) -> oauth2
				.authorizationRequestResolver(
					authorizationRequestResolver(this.clientRegistrationRepository)
				)
			);
		return http.build();
	}

	private ServerOAuth2AuthorizationRequestResolver authorizationRequestResolver(
			ReactiveClientRegistrationRepository clientRegistrationRepository) {

		DefaultServerOAuth2AuthorizationRequestResolver authorizationRequestResolver =
				new DefaultServerOAuth2AuthorizationRequestResolver(
						clientRegistrationRepository);
		authorizationRequestResolver.setAuthorizationRequestCustomizer(
				authorizationRequestCustomizer());

		return  authorizationRequestResolver;
	}

	private Consumer<OAuth2AuthorizationRequest.Builder> authorizationRequestCustomizer() {
		return customizer -> customizer
					.additionalParameters((params) -> params.put("prompt", "consent"));
	}
}

对于简单的使用场景，如果某个特定提供商的额外请求参数始终相同，可以直接将其添加到 authorization-uri 属性中。

例如，如果对于提供商 okta，请求参数 prompt 的值始终为 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 属性。

private Consumer<OAuth2AuthorizationRequest.Builder> authorizationRequestCustomizer() {
	return customizer -> customizer
			.authorizationRequestUri((uriBuilder) -> uriBuilder
					.queryParam("prompt", "consent").build());
}

存储授权请求​

ServerAuthorizationRequestRepository 负责在授权请求发起至授权响应接收（回调）期间对 OAuth2AuthorizationRequest 进行持久化存储。

提示

OAuth2AuthorizationRequest 用于关联和验证授权响应。

ServerAuthorizationRequestRepository的默认实现是WebSessionOAuth2ServerAuthorizationRequestRepository，它将OAuth2AuthorizationRequest存储在WebSession中。

如果你有自定义的 ServerAuthorizationRequestRepository 实现，可以按以下示例进行配置：

@Configuration
@EnableWebFluxSecurity
public class OAuth2ClientSecurityConfig {

	@Bean
	public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
		http
			.oauth2Client((oauth2) -> oauth2
				.authorizationRequestRepository(this.authorizationRequestRepository())
				// ...
			);
		return http.build();
	}
}

请求访问令牌​

备注

请参考授权码许可的 访问令牌请求/响应 协议流程。

ReactiveOAuth2AccessTokenResponseClient 的默认实现针对授权码授权类型是 WebClientReactiveAuthorizationCodeTokenResponseClient，它使用 WebClient 在授权服务器的令牌端点交换授权码以获取访问令牌。

要自定义 WebClientReactiveAuthorizationCodeTokenResponseClient，只需像以下示例那样提供一个 Bean，它将被默认的 ReactiveOAuth2AuthorizedClientManager 自动拾取：

@Bean
public ReactiveOAuth2AccessTokenResponseClient<OAuth2AuthorizationCodeGrantRequest> accessTokenResponseClient() {
	WebClientReactiveAuthorizationCodeTokenResponseClient accessTokenResponseClient =
		new WebClientReactiveAuthorizationCodeTokenResponseClient();
	// ...
	return accessTokenResponseClient;
}

WebClientReactiveAuthorizationCodeTokenResponseClient 非常灵活，为授权码授予（Authorization Code grant）的 OAuth 2.0 访问令牌请求和响应提供了多种自定义选项。请从以下用例中选择以了解更多信息：

自定义访问令牌请求​

WebClientReactiveAuthorizationCodeTokenResponseClient 提供了用于自定义令牌请求的 HTTP 头部和请求参数的钩子。

自定义请求头​

自定义 HTTP 标头有两种方式：

  • 通过调用 addHeadersConverter() 来添加额外的头部信息

  • 通过调用 setHeadersConverter() 来完全自定义头部信息

你可以通过 addHeadersConverter() 添加额外的请求头，而不会影响每个请求的默认请求头。以下示例展示了当 registrationId 为 spring 时，如何向请求中添加 User-Agent 请求头：

WebClientReactiveAuthorizationCodeTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveAuthorizationCodeTokenResponseClient();
accessTokenResponseClient.addHeadersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	HttpHeaders headers = new HttpHeaders();
	if (clientRegistration.getRegistrationId().equals("spring")) {
		headers.set(HttpHeaders.USER_AGENT, "my-user-agent");
	}
	return headers;
});

您可以通过复用 DefaultOAuth2TokenRequestHeadersConverter 或使用 setHeadersConverter() 提供自定义实现来完全自定义请求头。以下示例复用 DefaultOAuth2TokenRequestHeadersConverter 并禁用 encodeClientCredentials，从而不再使用 application/x-www-form-urlencoded 对 HTTP Basic 凭据进行编码：

DefaultOAuth2TokenRequestHeadersConverter headersConverter =
	new DefaultOAuth2TokenRequestHeadersConverter();
headersConverter.setEncodeClientCredentials(false);

WebClientReactiveAuthorizationCodeTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveAuthorizationCodeTokenResponseClient();
accessTokenResponseClient.setHeadersConverter(headersConverter);

自定义请求参数​

自定义请求参数有三种选项：

  • 通过调用 addParametersConverter() 添加额外参数

  • 通过调用 setParametersConverter() 覆盖参数

  • 通过调用 setParametersCustomizer() 完全自定义参数

备注

使用 setParametersConverter() 无法完全自定义参数，因为这需要用户自行提供所有默认参数。默认参数始终会被提供，但可以通过调用 setParametersCustomizer() 来完全自定义或省略这些参数。

你可以使用 addParametersConverter() 来添加额外的参数，而不会影响每个请求中默认添加的参数。以下示例展示了当 registrationId 为 keycloak 时，向请求中添加一个 audience 参数：

WebClientReactiveAuthorizationCodeTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveAuthorizationCodeTokenResponseClient();
accessTokenResponseClient.addParametersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	MultiValueMap<String, String> parameters = new LinkedMultiValueMap<String, String>();
	if (clientRegistration.getRegistrationId().equals("keycloak")) {
		parameters.set(OAuth2ParameterNames.AUDIENCE, "my-audience");
	}
	return parameters;
});

你可以使用 setParametersConverter() 来覆盖默认参数。以下示例在 registrationId 为 okta 时覆盖 client_id 参数：

WebClientReactiveAuthorizationCodeTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveAuthorizationCodeTokenResponseClient();
accessTokenResponseClient.setParametersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	LinkedMultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
	if (clientRegistration.getRegistrationId().equals("okta")) {
		parameters.set(OAuth2ParameterNames.CLIENT_ID, "my-client");
	}
	return parameters;
});

你可以通过 setParametersCustomizer() 完全自定义参数（包括省略默认参数）。以下示例展示了当请求中包含 client_assertion 参数时，省略 client_id 参数的情况：

WebClientReactiveAuthorizationCodeTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveAuthorizationCodeTokenResponseClient();
accessTokenResponseClient.setParametersCustomizer(parameters -> {
	if (parameters.containsKey(OAuth2ParameterNames.CLIENT_ASSERTION)) {
		parameters.remove(OAuth2ParameterNames.CLIENT_ID);
	}
});

自定义访问令牌响应​

WebClientReactiveAuthorizationCodeTokenResponseClient 提供了用于自定义 OAuth 2.0 访问令牌响应的钩子。

自定义响应参数​

您可以通过调用 setBodyExtractor() 来自定义 Token Response 参数到 OAuth2AccessTokenResponse 的转换。默认实现由 OAuth2BodyExtractors.oauth2AccessTokenResponse() 提供，它会解析响应并相应地处理错误。

以下示例为自定义令牌响应参数转换为 OAuth2AccessTokenResponse 提供了起点：

WebClientReactiveAuthorizationCodeTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveAuthorizationCodeTokenResponseClient();

BodyExtractor<Mono<Map<String, Object>>, ReactiveHttpInputMessage> bodyExtractor =
	BodyExtractors.toMono(new ParameterizedTypeReference<>() {});
accessTokenResponseClient.setBodyExtractor((inputMessage, context) ->
	bodyExtractor.extract(inputMessage, context)
		.map((parameters) -> parameters.withToken("custom-token")
			// ...
			.build()
		)
);
警告

当提供自定义的 BodyExtractor 时，您需要负责检测 OAuth 2.0 错误响应，并根据响应参数将其转换为带有 OAuth2Error 的 Mono.error()。

自定义 WebClient​

或者，如果你的需求更为复杂，可以通过向 setWebClient() 提供一个预配置的 WebClient 来完全控制请求和/或响应，如下例所示：

WebClient webClient = WebClient.builder()
	// ...
	.build();

WebClientReactiveAuthorizationCodeTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveAuthorizationCodeTokenResponseClient();
accessTokenResponseClient.setWebClient(webClient);

使用 DSL 自定义​

无论你是自定义 WebClientReactiveAuthorizationCodeTokenResponseClient 还是提供自己的 ReactiveOAuth2AccessTokenResponseClient 实现，都可以通过 DSL 进行配置（作为发布 Bean 的替代方案），如下例所示：

@Configuration
@EnableWebFluxSecurity
public class OAuth2ClientSecurityConfig {

	@Bean
	public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
		http
			.oauth2Client((oauth2) -> oauth2
				.authenticationManager(this.authorizationCodeAuthenticationManager())
				// ...
			);
		return http.build();
	}

	private ReactiveAuthenticationManager authorizationCodeAuthenticationManager() {
		WebClientReactiveAuthorizationCodeTokenResponseClient accessTokenResponseClient =
				new WebClientReactiveAuthorizationCodeTokenResponseClient();
		// ...

		return new OAuth2AuthorizationCodeReactiveAuthenticationManager(accessTokenResponseClient);
	}
}

刷新令牌​

备注

有关刷新令牌的更多详细信息，请参阅 OAuth 2.0 授权框架。

刷新访问令牌​

备注

请参考访问令牌请求/响应协议流程以了解刷新令牌授权。

ReactiveOAuth2AccessTokenResponseClient 针对刷新令牌（Refresh Token）授权的默认实现是 WebClientReactiveRefreshTokenTokenResponseClient，它在授权服务器的令牌端点（Token Endpoint）刷新访问令牌时使用 WebClient。

要自定义 WebClientReactiveRefreshTokenTokenResponseClient，只需提供一个如下例所示的 Bean，默认的 ReactiveOAuth2AuthorizedClientManager 会自动获取它：

@Bean
public ReactiveOAuth2AccessTokenResponseClient<OAuth2RefreshTokenGrantRequest> accessTokenResponseClient() {
	WebClientReactiveRefreshTokenTokenResponseClient accessTokenResponseClient =
		new WebClientReactiveRefreshTokenTokenResponseClient();
	// ...
	return accessTokenResponseClient;
}

WebClientReactiveRefreshTokenTokenResponseClient 非常灵活，为自定义 OAuth 2.0 刷新令牌授权中的访问令牌请求和响应提供了多种选项。请从以下用例中选择以了解更多信息：

自定义访问令牌请求​

WebClientReactiveRefreshTokenTokenResponseClient 提供了用于自定义令牌请求的 HTTP 头部和请求参数的钩子。

自定义请求头​

自定义 HTTP 标头有以下两种方式：

  • 通过调用 addHeadersConverter() 添加额外的头部信息

  • 通过调用 setHeadersConverter() 完全自定义头部信息

您可以使用 addHeadersConverter() 添加额外的请求头，而不会影响每个请求的默认请求头。以下示例在 registrationId 为 spring 时，向请求添加 User-Agent 请求头：

WebClientReactiveRefreshTokenTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveRefreshTokenTokenResponseClient();
accessTokenResponseClient.addHeadersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	HttpHeaders headers = new HttpHeaders();
	if (clientRegistration.getRegistrationId().equals("spring")) {
		headers.set(HttpHeaders.USER_AGENT, "my-user-agent");
	}
	return headers;
});

您可以通过复用 DefaultOAuth2TokenRequestHeadersConverter 或使用 setHeadersConverter() 提供自定义实现来完全自定义请求头。以下示例复用 DefaultOAuth2TokenRequestHeadersConverter 并禁用 encodeClientCredentials，从而不再使用 application/x-www-form-urlencoded 对 HTTP Basic 凭据进行编码：

DefaultOAuth2TokenRequestHeadersConverter headersConverter =
	new DefaultOAuth2TokenRequestHeadersConverter();
headersConverter.setEncodeClientCredentials(false);

WebClientReactiveRefreshTokenTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveRefreshTokenTokenResponseClient();
accessTokenResponseClient.setHeadersConverter(headersConverter);

自定义请求参数​

自定义请求参数有三种选项：

  • 通过调用 addParametersConverter() 添加额外参数

  • 通过调用 setParametersConverter() 覆盖参数

  • 通过调用 setParametersCustomizer() 完全自定义参数

备注

使用 setParametersConverter() 无法完全自定义参数，因为这需要用户自行提供所有默认参数。默认参数始终会被提供，但可以通过调用 setParametersCustomizer() 来完全自定义或省略它们。

你可以使用 addParametersConverter() 来添加额外的参数，而不会影响每个请求中默认添加的参数。以下示例展示了当 registrationId 为 keycloak 时，向请求中添加一个 audience 参数：

WebClientReactiveRefreshTokenTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveRefreshTokenTokenResponseClient();
accessTokenResponseClient.addParametersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	MultiValueMap<String, String> parameters = new LinkedMultiValueMap<String, String>();
	if (clientRegistration.getRegistrationId().equals("keycloak")) {
		parameters.set(OAuth2ParameterNames.AUDIENCE, "my-audience");
	}
	return parameters;
});

你可以使用 setParametersConverter() 来覆盖默认参数。以下示例在 registrationId 为 okta 时覆盖 client_id 参数：

WebClientReactiveRefreshTokenTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveRefreshTokenTokenResponseClient();
accessTokenResponseClient.setParametersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	LinkedMultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
	if (clientRegistration.getRegistrationId().equals("okta")) {
		parameters.set(OAuth2ParameterNames.CLIENT_ID, "my-client");
	}
	return parameters;
});

你可以通过 setParametersCustomizer() 完全自定义参数（包括省略默认参数）。以下示例展示了当请求中包含 client_assertion 参数时，省略 client_id 参数的情况：

WebClientReactiveRefreshTokenTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveRefreshTokenTokenResponseClient();
accessTokenResponseClient.setParametersCustomizer(parameters -> {
	if (parameters.containsKey(OAuth2ParameterNames.CLIENT_ASSERTION)) {
		parameters.remove(OAuth2ParameterNames.CLIENT_ID);
	}
});

自定义访问令牌响应​

WebClientReactiveRefreshTokenTokenResponseClient 提供了用于自定义 OAuth 2.0 访问令牌响应的钩子。

自定义响应参数​

您可以通过调用 setBodyExtractor() 来自定义 Token Response 参数到 OAuth2AccessTokenResponse 的转换。默认实现由 OAuth2BodyExtractors.oauth2AccessTokenResponse() 提供，它会解析响应并相应地处理错误。

以下示例为自定义令牌响应参数转换为 OAuth2AccessTokenResponse 提供了起点：

WebClientReactiveRefreshTokenTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveRefreshTokenTokenResponseClient();

BodyExtractor<Mono<Map<String, Object>>, ReactiveHttpInputMessage> bodyExtractor =
	BodyExtractors.toMono(new ParameterizedTypeReference<>() {});
accessTokenResponseClient.setBodyExtractor((inputMessage, context) ->
	bodyExtractor.extract(inputMessage, context)
		.map((parameters) -> parameters.withToken("custom-token")
			// ...
			.build()
		)
);
警告

当提供自定义的 BodyExtractor 时，您需要负责根据响应参数检测 OAuth 2.0 错误响应，并将其转换为带有 OAuth2Error 的 Mono.error()。

自定义 WebClient​

或者，如果你的需求更为复杂，可以通过向 setWebClient() 提供一个预配置的 WebClient 来完全控制请求和/或响应，如下例所示：

WebClient webClient = WebClient.builder()
	// ...
	.build();

WebClientReactiveRefreshTokenTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveRefreshTokenTokenResponseClient();
accessTokenResponseClient.setWebClient(webClient);

使用构建器进行自定义​

无论您自定义 WebClientReactiveRefreshTokenTokenResponseClient 还是提供自己的 ReactiveOAuth2AccessTokenResponseClient 实现，都可以通过 ReactiveOAuth2AuthorizedClientProviderBuilder 进行配置（作为发布 Bean 的替代方案），具体方式如下：

// Customize
ReactiveOAuth2AccessTokenResponseClient<OAuth2RefreshTokenGrantRequest> refreshTokenTokenResponseClient = ...

ReactiveOAuth2AuthorizedClientProvider authorizedClientProvider =
		ReactiveOAuth2AuthorizedClientProviderBuilder.builder()
				.authorizationCode()
				.refreshToken((configurer) -> configurer.accessTokenResponseClient(refreshTokenTokenResponseClient))
				.build();

// ...

authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);
备注

ReactiveOAuth2AuthorizedClientProviderBuilder.builder().refreshToken() 配置了一个 RefreshTokenReactiveOAuth2AuthorizedClientProvider，这是一个用于刷新令牌授权的 ReactiveOAuth2AuthorizedClientProvider 实现。

OAuth2RefreshToken 可选择性地在 authorization_code 授权类型的访问令牌响应中返回。如果 OAuth2AuthorizedClient.getRefreshToken() 可用且 OAuth2AuthorizedClient.getAccessToken() 已过期，RefreshTokenReactiveOAuth2AuthorizedClientProvider 将自动刷新访问令牌。

客户端凭证​

备注

关于 客户端凭证 授权方式的更多详细信息，请参考 OAuth 2.0 授权框架。

请求访问令牌​

备注

请参考访问令牌请求/响应协议流程，了解客户端凭据授权方式。

ReactiveOAuth2AccessTokenResponseClient 针对客户端凭据授权的默认实现是 WebClientReactiveClientCredentialsTokenResponseClient，它在授权服务器的令牌端点请求访问令牌时使用 WebClient。

要自定义 WebClientReactiveClientCredentialsTokenResponseClient，只需像以下示例一样提供一个 Bean，它将被默认的 ReactiveOAuth2AuthorizedClientManager 自动拾取：

@Bean
public ReactiveOAuth2AccessTokenResponseClient<OAuth2ClientCredentialsGrantRequest> accessTokenResponseClient() {
	WebClientReactiveClientCredentialsTokenResponseClient accessTokenResponseClient =
		new WebClientReactiveClientCredentialsTokenResponseClient();
	// ...
	return accessTokenResponseClient;
}

WebClientReactiveClientCredentialsTokenResponseClient 非常灵活，为自定义客户端凭据授权模式的 OAuth 2.0 访问令牌请求和响应提供了多种选项。请从以下用例中选择以了解更多信息：

自定义访问令牌请求​

WebClientReactiveClientCredentialsTokenResponseClient 提供了用于自定义令牌请求的 HTTP 头部和请求参数的钩子。

自定义请求头​

自定义 HTTP 标头有以下两种方式：

  • 通过调用 addHeadersConverter() 添加额外的头部信息

  • 通过调用 setHeadersConverter() 完全自定义头部信息

您可以使用 addHeadersConverter() 添加额外的请求头，而不会影响每个请求的默认请求头。以下示例在 registrationId 为 spring 时，向请求添加 User-Agent 请求头：

WebClientReactiveClientCredentialsTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveClientCredentialsTokenResponseClient();
accessTokenResponseClient.addHeadersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	HttpHeaders headers = new HttpHeaders();
	if (clientRegistration.getRegistrationId().equals("spring")) {
		headers.set(HttpHeaders.USER_AGENT, "my-user-agent");
	}
	return headers;
});

您可以通过复用 DefaultOAuth2TokenRequestHeadersConverter 或使用 setHeadersConverter() 提供自定义实现来完全自定义请求头。以下示例复用 DefaultOAuth2TokenRequestHeadersConverter 并禁用 encodeClientCredentials，从而不再使用 application/x-www-form-urlencoded 对 HTTP Basic 凭据进行编码：

DefaultOAuth2TokenRequestHeadersConverter headersConverter =
	new DefaultOAuth2TokenRequestHeadersConverter();
headersConverter.setEncodeClientCredentials(false);

WebClientReactiveClientCredentialsTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveClientCredentialsTokenResponseClient();
accessTokenResponseClient.setHeadersConverter(headersConverter);

自定义请求参数​

自定义请求参数有三种选项：

  • 通过调用 addParametersConverter() 添加额外参数

  • 通过调用 setParametersConverter() 覆盖参数

  • 通过调用 setParametersCustomizer() 完全自定义参数

备注

使用 setParametersConverter() 无法完全自定义参数，因为这需要用户自行提供所有默认参数。默认参数始终会被提供，但可以通过调用 setParametersCustomizer() 来完全自定义或省略它们。

你可以使用 addParametersConverter() 来添加额外的参数，而不会影响每个请求中默认添加的参数。以下示例展示了当 registrationId 为 keycloak 时，向请求中添加一个 audience 参数：

WebClientReactiveClientCredentialsTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveClientCredentialsTokenResponseClient();
accessTokenResponseClient.addParametersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	MultiValueMap<String, String> parameters = new LinkedMultiValueMap<String, String>();
	if (clientRegistration.getRegistrationId().equals("keycloak")) {
		parameters.set(OAuth2ParameterNames.AUDIENCE, "my-audience");
	}
	return parameters;
});

您可以通过 setParametersConverter() 方法覆盖默认参数。以下示例展示了当 registrationId 为 okta 时，如何覆盖 client_id 参数：

WebClientReactiveClientCredentialsTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveClientCredentialsTokenResponseClient();
accessTokenResponseClient.setParametersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	LinkedMultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
	if (clientRegistration.getRegistrationId().equals("okta")) {
		parameters.set(OAuth2ParameterNames.CLIENT_ID, "my-client");
	}
	return parameters;
});

你可以通过 setParametersCustomizer() 完全自定义参数（包括省略默认参数）。以下示例展示了当请求中存在 client_assertion 参数时，省略 client_id 参数的情况：

WebClientReactiveClientCredentialsTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveClientCredentialsTokenResponseClient();
accessTokenResponseClient.setParametersCustomizer(parameters -> {
	if (parameters.containsKey(OAuth2ParameterNames.CLIENT_ASSERTION)) {
		parameters.remove(OAuth2ParameterNames.CLIENT_ID);
	}
});

自定义访问令牌响应​

WebClientReactiveClientCredentialsTokenResponseClient 提供了用于自定义 OAuth 2.0 访问令牌响应的钩子。

自定义响应参数​

您可以通过调用 setBodyExtractor() 来自定义 Token Response 参数到 OAuth2AccessTokenResponse 的转换。默认实现由 OAuth2BodyExtractors.oauth2AccessTokenResponse() 提供，它会解析响应并相应地处理错误。

以下示例为自定义将令牌响应参数转换为 OAuth2AccessTokenResponse 提供了起点：

WebClientReactiveClientCredentialsTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveClientCredentialsTokenResponseClient();

BodyExtractor<Mono<Map<String, Object>>, ReactiveHttpInputMessage> bodyExtractor =
	BodyExtractors.toMono(new ParameterizedTypeReference<>() {});
accessTokenResponseClient.setBodyExtractor((inputMessage, context) ->
	bodyExtractor.extract(inputMessage, context)
		.map((parameters) -> parameters.withToken("custom-token")
			// ...
			.build()
		)
);
警告

当提供自定义的 BodyExtractor 时，您需要负责检测 OAuth 2.0 错误响应，并根据响应参数将其转换为带有 OAuth2Error 的 Mono.error()。

自定义 WebClient​

或者，如果你的需求更为复杂，可以通过向 setWebClient() 提供一个预配置的 WebClient 来完全控制请求和/或响应，如下例所示：

WebClient webClient = WebClient.builder()
	// ...
	.build();

WebClientReactiveClientCredentialsTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveClientCredentialsTokenResponseClient();
accessTokenResponseClient.setWebClient(webClient);

使用构建器进行自定义​

无论您自定义 WebClientReactiveClientCredentialsTokenResponseClient 还是提供自己的 ReactiveOAuth2AccessTokenResponseClient 实现，都可以通过 ReactiveOAuth2AuthorizedClientProviderBuilder 进行配置（作为发布 Bean 的替代方案），具体操作如下：

// Customize
ReactiveOAuth2AccessTokenResponseClient<OAuth2ClientCredentialsGrantRequest> clientCredentialsTokenResponseClient = ...

ReactiveOAuth2AuthorizedClientProvider authorizedClientProvider =
		ReactiveOAuth2AuthorizedClientProviderBuilder.builder()
				.clientCredentials((configurer) -> configurer.accessTokenResponseClient(clientCredentialsTokenResponseClient))
				.build();

// ...

authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);
备注

ReactiveOAuth2AuthorizedClientProviderBuilder.builder().clientCredentials() 配置了一个 ClientCredentialsReactiveOAuth2AuthorizedClientProvider，这是一个针对客户端凭证（Client Credentials）授权类型的 ReactiveOAuth2AuthorizedClientProvider 实现。

使用访问令牌​

给定以下用于 OAuth 2.0 客户端注册的 Spring Boot 属性：

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

…​以及 ReactiveOAuth2AuthorizedClientManager @Bean：

@Bean
public ReactiveOAuth2AuthorizedClientManager authorizedClientManager(
		ReactiveClientRegistrationRepository clientRegistrationRepository,
		ServerOAuth2AuthorizedClientRepository authorizedClientRepository) {

	ReactiveOAuth2AuthorizedClientProvider authorizedClientProvider =
			ReactiveOAuth2AuthorizedClientProviderBuilder.builder()
					.clientCredentials()
					.build();

	DefaultReactiveOAuth2AuthorizedClientManager authorizedClientManager =
			new DefaultReactiveOAuth2AuthorizedClientManager(
					clientRegistrationRepository, authorizedClientRepository);
	authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);

	return authorizedClientManager;
}

你可以通过以下方式获取 OAuth2AccessToken：

@Controller
public class OAuth2ClientController {

	@Autowired
	private ReactiveOAuth2AuthorizedClientManager authorizedClientManager;

	@GetMapping("/")
	public Mono<String> index(Authentication authentication, ServerWebExchange exchange) {
		OAuth2AuthorizeRequest authorizeRequest = OAuth2AuthorizeRequest.withClientRegistrationId("okta")
				.principal(authentication)
				.attribute(ServerWebExchange.class.getName(), exchange)
				.build();

		return this.authorizedClientManager.authorize(authorizeRequest)
				.map(OAuth2AuthorizedClient::getAccessToken)
				// ...
				.thenReturn("index");
	}
}
备注

ServerWebExchange 是一个可选属性。如果未提供，将通过键 ServerWebExchange.class 从 Reactor 的 Context 中获取。

JWT Bearer​

备注

有关 JWT Bearer 授权的更多详细信息，请参阅《OAuth 2.0 客户端认证与授权许可的 JSON Web Token (JWT) 规范》。

请求访问令牌​

备注

请参考 JWT Bearer 授权方式的 访问令牌请求/响应 协议流程。

ReactiveOAuth2AccessTokenResponseClient 针对 JWT Bearer 授权的默认实现是 WebClientReactiveJwtBearerTokenResponseClient，它在授权服务器的令牌端点请求访问令牌时使用 WebClient。

要自定义 WebClientReactiveJwtBearerTokenResponseClient，只需像以下示例那样提供一个 Bean，它就会被默认的 ReactiveOAuth2AuthorizedClientManager 自动拾取：

@Bean
public ReactiveOAuth2AccessTokenResponseClient<JwtBearerGrantRequest> accessTokenResponseClient() {
	WebClientReactiveJwtBearerTokenResponseClient accessTokenResponseClient =
		new WebClientReactiveJwtBearerTokenResponseClient();
	// ...
	return accessTokenResponseClient;
}

WebClientReactiveJwtBearerTokenResponseClient 非常灵活，为自定义 JWT Bearer 授权方式的 OAuth 2.0 访问令牌请求和响应提供了多种选项。请从以下用例中选择以了解更多信息：

自定义访问令牌请求​

WebClientReactiveJwtBearerTokenResponseClient 提供了用于自定义令牌请求的 HTTP 头部和请求参数的钩子。

自定义请求头​

自定义 HTTP 标头有以下两种方式：

  • 通过调用 addHeadersConverter() 来添加额外的头部信息

  • 通过调用 setHeadersConverter() 来完全自定义头部信息

您可以使用 addHeadersConverter() 添加额外的请求头，而不会影响每个请求默认添加的请求头。以下示例在 registrationId 为 spring 时，向请求添加一个 User-Agent 请求头：

WebClientReactiveJwtBearerTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveJwtBearerTokenResponseClient();
accessTokenResponseClient.addHeadersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	HttpHeaders headers = new HttpHeaders();
	if (clientRegistration.getRegistrationId().equals("spring")) {
		headers.set(HttpHeaders.USER_AGENT, "my-user-agent");
	}
	return headers;
});

您可以通过复用 DefaultOAuth2TokenRequestHeadersConverter 或使用 setHeadersConverter() 提供自定义实现来完全自定义请求头。以下示例复用 DefaultOAuth2TokenRequestHeadersConverter 并禁用 encodeClientCredentials，从而不再使用 application/x-www-form-urlencoded 编码 HTTP Basic 凭据：

DefaultOAuth2TokenRequestHeadersConverter headersConverter =
	new DefaultOAuth2TokenRequestHeadersConverter();
headersConverter.setEncodeClientCredentials(false);

WebClientReactiveJwtBearerTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveJwtBearerTokenResponseClient();
accessTokenResponseClient.setHeadersConverter(headersConverter);

自定义请求参数​

自定义请求参数有三种选项：

  • 通过调用 addParametersConverter() 添加额外参数

  • 通过调用 setParametersConverter() 覆盖参数

  • 通过调用 setParametersCustomizer() 完全自定义参数

备注

使用 setParametersConverter() 无法完全自定义参数，因为这需要用户自行提供所有默认参数。默认参数始终会被提供，但可以通过调用 setParametersCustomizer() 来完全自定义或省略它们。

你可以使用 addParametersConverter() 来添加额外的参数，而不会影响每个请求中默认添加的参数。以下示例展示了当 registrationId 为 keycloak 时，向请求中添加一个 audience 参数：

WebClientReactiveJwtBearerTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveJwtBearerTokenResponseClient();
accessTokenResponseClient.addParametersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	MultiValueMap<String, String> parameters = new LinkedMultiValueMap<String, String>();
	if (clientRegistration.getRegistrationId().equals("keycloak")) {
		parameters.set(OAuth2ParameterNames.AUDIENCE, "my-audience");
	}
	return parameters;
});

你可以使用 setParametersConverter() 来覆盖默认参数。以下示例在 registrationId 为 okta 时覆盖了 client_id 参数：

WebClientReactiveJwtBearerTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveJwtBearerTokenResponseClient();
accessTokenResponseClient.setParametersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	LinkedMultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
	if (clientRegistration.getRegistrationId().equals("okta")) {
		parameters.set(OAuth2ParameterNames.CLIENT_ID, "my-client");
	}
	return parameters;
});

你可以通过 setParametersCustomizer() 完全自定义参数（包括省略默认参数）。以下示例展示了当请求中包含 client_assertion 参数时，省略 client_id 参数的情况：

WebClientReactiveJwtBearerTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveJwtBearerTokenResponseClient();
accessTokenResponseClient.setParametersCustomizer(parameters -> {
	if (parameters.containsKey(OAuth2ParameterNames.CLIENT_ASSERTION)) {
		parameters.remove(OAuth2ParameterNames.CLIENT_ID);
	}
});

自定义访问令牌响应​

WebClientReactiveJwtBearerTokenResponseClient 提供了用于自定义 OAuth 2.0 访问令牌响应的钩子。

自定义响应参数​

您可以通过调用 setBodyExtractor() 来自定义 Token Response 参数到 OAuth2AccessTokenResponse 的转换。默认实现由 OAuth2BodyExtractors.oauth2AccessTokenResponse() 提供，它会解析响应并相应地处理错误。

以下示例为自定义令牌响应参数到 OAuth2AccessTokenResponse 的转换提供了一个起点：

WebClientReactiveJwtBearerTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveJwtBearerTokenResponseClient();

BodyExtractor<Mono<Map<String, Object>>, ReactiveHttpInputMessage> bodyExtractor =
	BodyExtractors.toMono(new ParameterizedTypeReference<>() {});
accessTokenResponseClient.setBodyExtractor((inputMessage, context) ->
	bodyExtractor.extract(inputMessage, context)
		.map((parameters) -> parameters.withToken("custom-token")
			// ...
			.build()
		)
);
警告

当提供自定义的 BodyExtractor 时，您需要负责检测 OAuth 2.0 错误响应，并根据响应参数将其转换为带有 OAuth2Error 的 Mono.error()。

自定义 WebClient​

或者，如果你的需求更为复杂，可以通过向 setWebClient() 提供一个预配置的 WebClient 来完全控制请求和/或响应，如下例所示：

WebClient webClient = WebClient.builder()
	// ...
	.build();

WebClientReactiveJwtBearerTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveJwtBearerTokenResponseClient();
accessTokenResponseClient.setWebClient(webClient);

使用构建器进行自定义​

无论您自定义 WebClientReactiveJwtBearerTokenResponseClient 还是提供自己的 ReactiveOAuth2AccessTokenResponseClient 实现，都可以通过 ReactiveOAuth2AuthorizedClientProviderBuilder 进行配置（作为发布 Bean 的替代方案），具体如下：

// Customize
ReactiveOAuth2AccessTokenResponseClient<JwtBearerGrantRequest> jwtBearerTokenResponseClient = ...

JwtBearerReactiveOAuth2AuthorizedClientProvider jwtBearerAuthorizedClientProvider = new JwtBearerReactiveOAuth2AuthorizedClientProvider();
jwtBearerAuthorizedClientProvider.setAccessTokenResponseClient(jwtBearerTokenResponseClient);

ReactiveOAuth2AuthorizedClientProvider authorizedClientProvider =
		ReactiveOAuth2AuthorizedClientProviderBuilder.builder()
				.provider(jwtBearerAuthorizedClientProvider)
				.build();

// ...

authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);

使用访问令牌​

给定以下用于 OAuth 2.0 客户端注册的 Spring Boot 属性：

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：

@Bean
public ReactiveOAuth2AuthorizedClientManager authorizedClientManager(
		ReactiveClientRegistrationRepository clientRegistrationRepository,
		ServerOAuth2AuthorizedClientRepository authorizedClientRepository) {

	JwtBearerReactiveOAuth2AuthorizedClientProvider jwtBearerAuthorizedClientProvider =
			new JwtBearerReactiveOAuth2AuthorizedClientProvider();

	ReactiveOAuth2AuthorizedClientProvider authorizedClientProvider =
			ReactiveOAuth2AuthorizedClientProviderBuilder.builder()
					.provider(jwtBearerAuthorizedClientProvider)
					.build();

	DefaultReactiveOAuth2AuthorizedClientManager authorizedClientManager =
			new DefaultReactiveOAuth2AuthorizedClientManager(
					clientRegistrationRepository, authorizedClientRepository);
	authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);

	return authorizedClientManager;
}

你可以通过以下方式获取 OAuth2AccessToken：

@RestController
public class OAuth2ResourceServerController {

	@Autowired
	private ReactiveOAuth2AuthorizedClientManager authorizedClientManager;

	@GetMapping("/resource")
	public Mono<String> resource(JwtAuthenticationToken jwtAuthentication, ServerWebExchange exchange) {
		OAuth2AuthorizeRequest authorizeRequest = OAuth2AuthorizeRequest.withClientRegistrationId("okta")
				.principal(jwtAuthentication)
				.build();

		return this.authorizedClientManager.authorize(authorizeRequest)
				.map(OAuth2AuthorizedClient::getAccessToken)
				// ...
				.thenReturn("index");
	}
}
备注

默认情况下，JwtBearerReactiveOAuth2AuthorizedClientProvider 通过 OAuth2AuthorizationContext.getPrincipal().getPrincipal() 来解析 Jwt 断言，因此在前面的示例中使用了 JwtAuthenticationToken。

提示

如果你需要从不同的来源解析 Jwt 断言，可以通过 JwtBearerReactiveOAuth2AuthorizedClientProvider.setJwtAssertionResolver() 方法提供一个自定义的 Function<OAuth2AuthorizationContext, Mono<Jwt>>。

令牌交换​

备注

关于 令牌交换 授权的更多详细信息，请参阅 OAuth 2.0 令牌交换规范。

请求访问令牌​

备注

关于令牌交换授权，请参考令牌交换请求与响应协议流程。

ReactiveOAuth2AccessTokenResponseClient 对于令牌交换（Token Exchange）授权的默认实现是 WebClientReactiveTokenExchangeTokenResponseClient，它在授权服务器的令牌端点（Token Endpoint）请求访问令牌时使用 WebClient。

要自定义 WebClientReactiveTokenExchangeTokenResponseClient，只需按照以下示例提供一个 Bean，它将被默认的 ReactiveOAuth2AuthorizedClientManager 自动获取：

@Bean
public ReactiveOAuth2AccessTokenResponseClient<TokenExchangeGrantRequest> accessTokenResponseClient() {
	WebClientReactiveTokenExchangeTokenResponseClient accessTokenResponseClient =
		new WebClientReactiveTokenExchangeTokenResponseClient();
	// ...
	return accessTokenResponseClient;
}

WebClientReactiveTokenExchangeTokenResponseClient 非常灵活，提供了多种选项用于自定义令牌交换授权（Token Exchange grant）的 OAuth 2.0 访问令牌请求和响应。请从以下用例中选择以了解更多信息：

自定义访问令牌请求​

WebClientReactiveTokenExchangeTokenResponseClient 提供了用于自定义令牌请求的 HTTP 头部和请求参数的钩子。

自定义请求头​

自定义 HTTP 标头有以下两种方式：

  • 通过调用 addHeadersConverter() 添加额外的头部信息

  • 通过调用 setHeadersConverter() 完全自定义头部信息

您可以使用 addHeadersConverter() 添加额外的请求头，而不会影响每个请求默认添加的请求头。以下示例在 registrationId 为 spring 时，向请求添加一个 User-Agent 请求头：

WebClientReactiveTokenExchangeTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveTokenExchangeTokenResponseClient();
accessTokenResponseClient.addHeadersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	HttpHeaders headers = new HttpHeaders();
	if (clientRegistration.getRegistrationId().equals("spring")) {
		headers.set(HttpHeaders.USER_AGENT, "my-user-agent");
	}
	return headers;
});

您可以通过复用 DefaultOAuth2TokenRequestHeadersConverter 或使用 setHeadersConverter() 提供自定义实现来完全自定义请求头。以下示例复用 DefaultOAuth2TokenRequestHeadersConverter 并禁用 encodeClientCredentials，从而不再使用 application/x-www-form-urlencoded 编码 HTTP Basic 凭据：

DefaultOAuth2TokenRequestHeadersConverter headersConverter =
	new DefaultOAuth2TokenRequestHeadersConverter();
headersConverter.setEncodeClientCredentials(false);

WebClientReactiveTokenExchangeTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveTokenExchangeTokenResponseClient();
accessTokenResponseClient.setHeadersConverter(headersConverter);

自定义请求参数​

自定义请求参数有三种选项：

  • 通过调用 addParametersConverter() 添加额外参数

  • 通过调用 setParametersConverter() 覆盖参数

  • 通过调用 setParametersCustomizer() 完全自定义参数

备注

使用 setParametersConverter() 无法完全自定义参数，因为这需要用户自行提供所有默认参数。默认参数始终会被提供，但可以通过调用 setParametersCustomizer() 来完全自定义或省略这些参数。

你可以使用 addParametersConverter() 来添加额外的参数，而不会影响每个请求中默认添加的参数。以下示例展示了当 registrationId 为 keycloak 时，向请求中添加一个 audience 参数：

WebClientReactiveTokenExchangeTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveTokenExchangeTokenResponseClient();
accessTokenResponseClient.addParametersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	MultiValueMap<String, String> parameters = new LinkedMultiValueMap<String, String>();
	if (clientRegistration.getRegistrationId().equals("keycloak")) {
		parameters.set(OAuth2ParameterNames.AUDIENCE, "my-audience");
	}
	return parameters;
});

你可以使用 setParametersConverter() 来覆盖默认参数。以下示例在 registrationId 为 okta 时覆盖 client_id 参数：

WebClientReactiveTokenExchangeTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveTokenExchangeTokenResponseClient();
accessTokenResponseClient.setParametersConverter(grantRequest -> {
	ClientRegistration clientRegistration = grantRequest.getClientRegistration();
	LinkedMultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
	if (clientRegistration.getRegistrationId().equals("okta")) {
		parameters.set(OAuth2ParameterNames.CLIENT_ID, "my-client");
	}
	return parameters;
});

你可以通过 setParametersCustomizer() 完全自定义参数（包括省略默认参数）。以下示例展示了当请求中包含 client_assertion 参数时，省略 client_id 参数的情况：

WebClientReactiveTokenExchangeTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveTokenExchangeTokenResponseClient();
accessTokenResponseClient.setParametersCustomizer(parameters -> {
	if (parameters.containsKey(OAuth2ParameterNames.CLIENT_ASSERTION)) {
		parameters.remove(OAuth2ParameterNames.CLIENT_ID);
	}
});

自定义访问令牌响应​

WebClientReactiveTokenExchangeTokenResponseClient 提供了用于自定义 OAuth 2.0 访问令牌响应的钩子。

自定义响应参数​

您可以通过调用 setBodyExtractor() 来自定义 Token Response 参数到 OAuth2AccessTokenResponse 的转换。默认实现由 OAuth2BodyExtractors.oauth2AccessTokenResponse() 提供，它会解析响应并相应地处理错误。

以下示例为自定义令牌响应参数到 OAuth2AccessTokenResponse 的转换提供了起点：

WebClientReactiveTokenExchangeTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveTokenExchangeTokenResponseClient();

BodyExtractor<Mono<Map<String, Object>>, ReactiveHttpInputMessage> bodyExtractor =
	BodyExtractors.toMono(new ParameterizedTypeReference<>() {});
accessTokenResponseClient.setBodyExtractor((inputMessage, context) ->
	bodyExtractor.extract(inputMessage, context)
		.map((parameters) -> parameters.withToken("custom-token")
			// ...
			.build()
		)
);
警告

当提供自定义的 BodyExtractor 时，您需要负责根据响应参数检测 OAuth 2.0 错误响应，并将其转换为带有 OAuth2Error 的 Mono.error()。

自定义 WebClient​

或者，如果你的需求更为复杂，可以通过向 setWebClient() 提供一个预配置的 WebClient 来完全控制请求和/或响应，如下例所示：

WebClient webClient = WebClient.builder()
	// ...
	.build();

WebClientReactiveTokenExchangeTokenResponseClient accessTokenResponseClient =
	new WebClientReactiveTokenExchangeTokenResponseClient();
accessTokenResponseClient.setWebClient(webClient);

使用构建器进行自定义​

无论您自定义 WebClientReactiveTokenExchangeTokenResponseClient 还是提供自己的 ReactiveOAuth2AccessTokenResponseClient 实现，都可以通过 ReactiveOAuth2AuthorizedClientProviderBuilder 进行配置（作为发布 Bean 的替代方案），具体操作如下：

// Customize
ReactiveOAuth2AccessTokenResponseClient<TokenExchangeGrantRequest> tokenExchangeTokenResponseClient = ...

TokenExchangeReactiveOAuth2AuthorizedClientProvider tokenExchangeAuthorizedClientProvider = new TokenExchangeReactiveOAuth2AuthorizedClientProvider();
tokenExchangeAuthorizedClientProvider.setAccessTokenResponseClient(tokenExchangeTokenResponseClient);

ReactiveOAuth2AuthorizedClientProvider authorizedClientProvider =
		ReactiveOAuth2AuthorizedClientProviderBuilder.builder()
				.provider(tokenExchangeAuthorizedClientProvider)
				.build();

// ...

authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);

使用访问令牌​

给定以下用于 OAuth 2.0 客户端注册的 Spring Boot 属性：

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:token-exchange
            scope: read
        provider:
          okta:
            token-uri: https://dev-1234.oktapreview.com/oauth2/v1/token

…​以及 OAuth2AuthorizedClientManager @Bean：

@Bean
public ReactiveOAuth2AuthorizedClientManager authorizedClientManager(
		ReactiveClientRegistrationRepository clientRegistrationRepository,
		ServerOAuth2AuthorizedClientRepository authorizedClientRepository) {

	TokenExchangeReactiveOAuth2AuthorizedClientProvider tokenExchangeAuthorizedClientProvider =
			new TokenExchangeReactiveOAuth2AuthorizedClientProvider();

	ReactiveOAuth2AuthorizedClientProvider authorizedClientProvider =
			ReactiveOAuth2AuthorizedClientProviderBuilder.builder()
					.provider(tokenExchangeAuthorizedClientProvider)
					.build();

	DefaultReactiveOAuth2AuthorizedClientManager authorizedClientManager =
			new DefaultReactiveOAuth2AuthorizedClientManager(
					clientRegistrationRepository, authorizedClientRepository);
	authorizedClientManager.setAuthorizedClientProvider(authorizedClientProvider);

	return authorizedClientManager;
}

你可以通过以下方式获取 OAuth2AccessToken：

@RestController
public class OAuth2ResourceServerController {

	@Autowired
	private ReactiveOAuth2AuthorizedClientManager authorizedClientManager;

	@GetMapping("/resource")
	public Mono<String> resource(JwtAuthenticationToken jwtAuthentication) {
		OAuth2AuthorizeRequest authorizeRequest = OAuth2AuthorizeRequest.withClientRegistrationId("okta")
				.principal(jwtAuthentication)
				.build();

		return this.authorizedClientManager.authorize(authorizeRequest)
				.map(OAuth2AuthorizedClient::getAccessToken)
				// ...
				.thenReturn("index");
	}
}
备注

默认情况下，TokenExchangeReactiveOAuth2AuthorizedClientProvider 通过 OAuth2AuthorizationContext.getPrincipal().getPrincipal() 解析主体令牌（作为 OAuth2Token），因此在前面的示例中使用了 JwtAuthenticationToken。默认情况下，执行者令牌不会被解析。

提示

如果你需要从不同的来源解析主体令牌，可以通过 TokenExchangeReactiveOAuth2AuthorizedClientProvider.setSubjectTokenResolver() 方法提供一个自定义的 Function<OAuth2AuthorizationContext, Mono<OAuth2Token>>。

提示

如果你需要解析一个委托者令牌（actor token），可以通过 TokenExchangeReactiveOAuth2AuthorizedClientProvider.setActorTokenResolver() 方法提供一个自定义的 Function<OAuth2AuthorizationContext, Mono<OAuth2Token>>。