Spring OAuth2授权服务配置示例

spring-security-oauth2-authorization-server的配置类示例详解，代码版本：

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.7.10</version>
</parent>

<dependencies>
    
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-security</artifactId>
	</dependency>

	<dependency>
		<groupId>org.springframework.security</groupId>
		<artifactId>spring-security-oauth2-authorization-server</artifactId>
		<version>0.4.0</version>
	</dependency>

</dependencies>

配置类展示

import com.nimbusds.jose.jwk.JWKSet;
import com.nimbusds.jose.jwk.RSAKey;
import com.nimbusds.jose.jwk.source.JWKSource;
import com.nimbusds.jose.proc.SecurityContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.oauth2.server.resource.OAuth2ResourceServerConfigurer;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.*;
import org.springframework.security.crypto.scrypt.SCryptPasswordEncoder;
import org.springframework.security.oauth2.core.OAuth2Token;
import org.springframework.security.oauth2.jwt.JwtDecoder;
import org.springframework.security.oauth2.server.authorization.JdbcOAuth2AuthorizationConsentService;
import org.springframework.security.oauth2.server.authorization.JdbcOAuth2AuthorizationService;
import org.springframework.security.oauth2.server.authorization.OAuth2AuthorizationConsentService;
import org.springframework.security.oauth2.server.authorization.OAuth2AuthorizationService;
import org.springframework.security.oauth2.server.authorization.client.JdbcRegisteredClientRepository;
import org.springframework.security.oauth2.server.authorization.client.RegisteredClientRepository;
import org.springframework.security.oauth2.server.authorization.config.annotation.web.configuration.OAuth2AuthorizationServerConfiguration;
import org.springframework.security.oauth2.server.authorization.config.annotation.web.configurers.OAuth2AuthorizationServerConfigurer;
import org.springframework.security.oauth2.server.authorization.config.annotation.web.configurers.OAuth2TokenEndpointConfigurer;
import org.springframework.security.oauth2.server.authorization.oidc.authentication.OidcUserInfoAuthenticationToken;
import org.springframework.security.oauth2.server.authorization.settings.AbstractSettings;
import org.springframework.security.oauth2.server.authorization.settings.AuthorizationServerSettings;
import org.springframework.security.oauth2.server.authorization.token.OAuth2TokenGenerator;
import org.springframework.security.provisioning.JdbcUserDetailsManager;
import org.springframework.security.provisioning.UserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.context.HttpSessionSecurityContextRepository;
import org.springframework.security.web.context.SecurityContextRepository;
import org.springframework.security.web.util.matcher.RequestMatcher;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

@EnableWebSecurity
@Configuration
public class AuthorizationServerConfig {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private InMemorySecurityContextRepository inMemorySecurityContextRepository;

    @Bean
    public SecurityFilterChain authorizationServerSecurityFilterChain(HttpSecurity http) throws Exception {

        // 定义授权服务配置
        OAuth2AuthorizationServerConfigurer configurer = new OAuth2AuthorizationServerConfigurer();

        // 获取授权服务器相关的请求端点
        RequestMatcher endpointsMatcher = configurer.getEndpointsMatcher();

        http
                .authorizeHttpRequests(authorize -> authorize
                        // 配置放行的请求，用于注册客户端与添加用户, login在客户端凭证模式下可以不放行，授权码模式必须放行
                        .antMatchers("/register/**", "/login").permitAll()
                        // 其他任何请求都需要认证
                        .anyRequest().authenticated()
                )
                // 设置登录表单页面
                .formLogin().defaultSuccessUrl("/success.html")
                //.securityContextRepository(inMemorySecurityContextRepository) //配置上下文保存方式
                .and()
                // 忽略掉相关端点的CSRF: 对授权端点的访问不被CSRF拦截
                .csrf(csrf -> csrf.ignoringRequestMatchers(endpointsMatcher))

                // 使用BearerTokenAuthenticationFilter对AccessToken及idToken进行解析验证
                // idToken是开启OIDC时授权服务连同AccessToken一起返回给客户端的，用于客户端验证用户身份，结合此处配置使用BearerTokenAuthenticationFilter来验证idToken
                .oauth2ResourceServer(OAuth2ResourceServerConfigurer::jwt)

                // 应用授权服务器的配置
                .apply(configurer);


        configurer
                //开启oidc，客户端会对资源所有者进行身份认证，确保用户身份的真实性、防止身份伪造、增强安全性。
                // 开启后，除了访问令牌access_token，还会多一个用户身份认证的idToken
                .oidc(Customizer.withDefaults())
//                .oidc(oidcCustomizer -> oidcCustomizer
//                        .userInfoEndpoint(userInfoEndpointCustomizer -> userInfoEndpointCustomizer
//                            .userInfoRequestConverter((request) -> {
//                                Authentication authentication = inMemorySecurityContextRepository.getContext().getAuthentication();
//                                return new OidcUserInfoAuthenticationToken(authentication);
//                            })
//                        )
//                )


                //配置用何种方式保存注册的客户端信息，默认为内存保存，这里配置为数据库保存，表名为'oauth2_registered_client'
                //保存客户端注册信息，主要用于后续各种认证时对比客户端是否有效
                .registeredClientRepository(registeredClientRepository())

                //配置用何种方式保存OAuth2客户端的授权请求的信息。这包括授权码、访问令牌、刷新令牌等。
                // 默认为内存保存，这里配置为数据库保存，表名为'oauth2_authorization'
                //授权信息会作为认证依据，在后续请求token时被读取，不存在授权信息则不给客户端生成token
                .authorizationService(authorizationService())

                //配置用何种方式存储用户对客户端请求的授权同意（consent）信息。
                // 默认为内存保存，这里配置为数据库保存，表名为'oauth2_authorization_consent'
                //请求code时检查是客户端否已授权，未授权不予code
                .authorizationConsentService(authorizationConsentService())

                /**
                 * OAuth2AuthorizationService 与 OAuth2AuthorizationConsentService区别：
                 *  oauth2_authorization 主要与令牌管理相关，负责存储令牌及其生命周期信息。
                 *  oauth2_authorization_consent 主要用于管理用户授权同意的记录，确保用户的授权选择被正确记录和遵守。
                 * */

                //配置OAuth2认证各项端点的http访问路径，如获取授权码的、获取token的、验证token的等等
                .authorizationServerSettings(authorizationServerSettings())



        //配置token生成规则，无特殊情况不用配置，使用默认的即可，会生成JWT的token
        //.tokenGenerator(OAuth2TokenGenerator<? extends OAuth2Token > tokenGenerator)

        /**
         * 配置 OAuth2AuthorizationEndpointFilter 过滤器，用于处理客户端获取授权码的`/oauth2/authorize`请求
         *
         * */
//                .authorizationEndpoint(oAuth2AuthorizationEndpointConfigurer -> oAuth2AuthorizationEndpointConfigurer
//                            .authorizationRequestConverter()  //配置将请求转为权限对象的转换器，传参需实现AuthenticationConverter
//                            .authenticationProvider()         //配置对权限对象做认证的认证类，传参需实现AuthenticationProvider
//                            .authorizationResponseHandler()   //配置认证成功后的处理器，用于认证成功后触发自定义操作，传参需实现AuthenticationSuccessHandler
//                            .errorResponseHandler()           //配置认证失败的处理，用于认证失败后触发自定义操作，传参需实现AuthenticationFailureHandler
//                            .consentPage()                    //配置自定义的授权页面
//                )

        /**
         * 配置 OAuth2TokenEndpointFilter 过滤器，用于处理客户端获取授权码的`/oauth2/token`请求
         *
         * */
//        .tokenEndpoint(tokenEndpointConfigurer -> tokenEndpointConfigurer
//                    .authenticationProvider()      //配置对权限对象做认证的认证类，传参需实现AuthenticationProvider
//                    .accessTokenRequestConverter() //配置将请求转为权限对象的转换器，传参需实现AuthenticationConverter
//                    .accessTokenResponseHandler()  //配置认证成功后的处理器，用于认证成功后触发自定义操作，传参需实现AuthenticationSuccessHandler
//                    .errorResponseHandler()        //配置认证失败的处理，用于认证失败后触发自定义操作，传参需实现AuthenticationFailureHandler
//        )


        /**
         * 用于`/oauth2/token、/oauth2/introspect、/oauth2/revoke`请求的客户端验证，
         * 主要对客户端请求header中携带的Authorization信息做验证，配置生效在 OAuth2ClientAuthenticationFilter 过滤器中
         *
         * */
//                .clientAuthentication(clientAuthenticationConfigurer -> clientAuthenticationConfigurer
//                        .authenticationConverter()        //配置将请求转为权限对象的转换器，传参需实现AuthenticationConverter
//                        .authenticationProvider()         //配置对权限对象做认证的认证类，传参需实现AuthenticationProvider
//                        .authenticationSuccessHandler()   //配置认证成功后的处理器，用于认证成功后触发自定义操作，传参需实现AuthenticationSuccessHandler
//                        .errorResponseHandler()           //配置认证失败的处理，用于认证失败后触发自定义操作，传参需实现AuthenticationFailureHandler
//                )

        /**
         * 针对OAuth2AuthorizationServerMetadataEndpointFilter过滤器的配置，用于配置元数据端点
         * 默认情况下通过访问 http://服务服务ip:port/.well-known/oauth-authorization-server, 可返回授权服务元数据
         *  元数据是json串，包含授权服务支持的认证模式、token签名算法、权限范围等，还有各项认证接口的地址路径
         *
         * */
//                .authorizationServerMetadataEndpoint(metadataEndpointConfigurer -> metadataEndpointConfigurer
//                        .authorizationServerMetadataCustomizer(builder -> {
//                            builder.issuer("https://example.com")
//                                    .authorizationEndpoint("https://example.com/oauth2/authorize")
//                                    .tokenEndpoint("https://example.com/oauth2/token")
//                            // 添加其他自定义元数据
//                            ;
//                        }))

        /**
         * 配置 OAuth2TokenIntrospectionEndpointFilter 过滤器，用于处理客户端获取授权码的`/oauth2/introspect`请求,
         *  用于验证访问令牌的有效性，并返回关于令牌的信息
         *
         * */
//        .tokenIntrospectionEndpoint(tokenIntrospectionEndpointCustomizer -> tokenIntrospectionEndpointCustomizer
//                .authenticationProvider()          //配置对权限对象做认证的认证类，传参需实现AuthenticationProvider
//                .introspectionRequestConverter()    //配置将请求转为权限对象的转换器，传参需实现AuthenticationConverter
//                .introspectionResponseHandler()     //配置认证成功后的处理器，用于认证成功后触发自定义操作，传参需实现AuthenticationSuccessHandler
//                .errorResponseHandler()             //配置认证失败的处理，用于认证失败后触发自定义操作，传参需实现AuthenticationFailureHandler
//        )


        /**
         *  配置 OAuth2TokenRevocationEndpointFilter 过滤器，用于处理客户端获取授权码的`/oauth2/revoke`请求,
         *   用于撤销访问令牌和刷新令牌，使其失效并防止被再次使用
         * */
//        .tokenRevocationEndpoint(tokenRevocationEndpointCustomizer -> tokenRevocationEndpointCustomizer
//                .revocationRequestConverter()   //配置将请求转为权限对象的转换器，传参需实现AuthenticationConverter
//                .authenticationProvider()       //配置对权限对象做认证的认证类，传参需实现AuthenticationProvider
//                .revocationResponseHandler()    //配置认证成功后的处理器，用于认证成功后触发自定义操作，传参需实现AuthenticationSuccessHandler
//                .errorResponseHandler()         //配置认证失败的处理，用于认证失败后触发自定义操作，传参需实现AuthenticationFailureHandler
//        )

        ;


        return http.build();
    }


    /**
     * 注册客户端应用的保存方式, 对应 oauth2_registered_client 表
     */
    @Bean
    public RegisteredClientRepository registeredClientRepository() {
        return new JdbcRegisteredClientRepository(jdbcTemplate);
    }

    /**
     * 令牌的发放记录, 对应 oauth2_authorization 表
     */
    @Bean
    public OAuth2AuthorizationService authorizationService() {
        return new JdbcOAuth2AuthorizationService(jdbcTemplate, registeredClientRepository());
    }

    /**
     * 把资源拥有者授权确认操作保存到数据库, 对应 oauth2_authorization_consent 表
     */
    @Bean
    public OAuth2AuthorizationConsentService authorizationConsentService() {
        return new JdbcOAuth2AuthorizationConsentService(jdbcTemplate, registeredClientRepository());
    }


    /**
     * AuthorizationServerS 的相关配置
     */
    @Bean
    public AuthorizationServerSettings authorizationServerSettings(){

        //使用默认配置
        return AuthorizationServerSettings.builder().build();

        //自定义配置,这里展示的是默认配置，如需自定义请自行修改
//        return AuthorizationServerSettings.builder()
//                .authorizationEndpoint("/oauth2/authorize")
//                .tokenEndpoint("/oauth2/token")
//                .jwkSetEndpoint("/oauth2/jwks")
//                .tokenRevocationEndpoint("/oauth2/revoke")
//                .tokenIntrospectionEndpoint("/oauth2/introspect")
//                .oidcClientRegistrationEndpoint("/connect/register")
//                .oidcUserInfoEndpoint("/userinfo")
//                .build();
    }

//    @Bean
//    public SecurityContextRepository inMemorySecurityContextRepository(){
//        return new InMemorySecurityContextRepository();
//    }

    /**
     * 加载 JWT 资源, 用于生成令牌
     */
    @Bean
    public JWKSource<SecurityContext> jwkSource() {
        KeyPair keyPair;
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(2048);
            keyPair = keyPairGenerator.generateKeyPair();
        } catch (Exception ex) {
            throw new IllegalStateException(ex);
        }

        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        RSAKey rsaKey = new RSAKey.Builder(publicKey)
                .privateKey(privateKey)
                .keyID(UUID.randomUUID().toString())
                .build();

        JWKSet jwkSet = new JWKSet(rsaKey);
        return (jwkSelector, securityContext) -> jwkSelector.select(jwkSet);
    }

    /**
     * JWT 解码
     */
    @Bean
    public JwtDecoder jwtDecoder(JWKSource<SecurityContext> jwkSource) {
        return OAuth2AuthorizationServerConfiguration.jwtDecoder(jwkSource);
    }

    @Resource
    private DataSource dataSource;

    @Bean
    UserDetailsManager userDetailsManager() {
        return new JdbcUserDetailsManager(dataSource);
    }

}

OAuth2AuthorizationServerConfigurer

1.RegisteredClientRepository

对应configurer.registeredClientRepository()

org.springframework.security.oauth2.server.authorization.client.RegisteredClientRepository是Spring Security OAuth2中用于管理注册客户端信息的接口。它定义了以下主要功能:

1. 保存注册客户端信息
   • 存储客户端ID、客户端密钥、授权类型、重定向URI等客户端的注册信息。
     
     
2. 查询注册客户端信息
   • 根据客户端ID查询客户端的注册信息。
   • 获取所有已注册的客户端列表。
   • 进行code或token请求认证时，获取客户端信息进行验证
     
     
3. 更新注册客户端信息
   • 更新客户端的注册信息,如客户端密钥、授权类型等。
     
     
4. 删除注册客户端信息
   • 删除某个客户端的注册信息。

源码中的主要使用点

进行code请求、获取token对客户端进行认证时，使用RegisteredClientRepository获取注册客户端信息进行对比认证，主要涉及到的源码类（列举部分）：

• OAuth2AuthorizationCodeRequestAuthenticationProvider
• ClientSecretAuthenticationProvider
• JwtClientAssertionAuthenticationProvider
• OAuth2AuthorizationConsentAuthenticationProvider
• OAuth2TokenIntrospectionAuthenticationProvider

JdbcRegisteredClientRepository是RegisteredClientRepository的JDBC实现,它会操作以下数据表:

oauth2_registered_client 表

• 存储客户端的注册信息,如客户端ID、客户端密钥、授权类型、重定向URI等。

该表用于存储已注册的客户端信息,主要字段有:

• id: 唯一值标识
• client_id: 客户端 ID
• authorization_grant_type: 授权类型
• client_secret: 客户端密钥
• client_secret_expires_at: 客户端密钥过期时间
• client_name: 客户端名称
• client_authentication_methods: 客户端访问token时的认证方式
• authorization_grant_types: 客户端支持的授权类型
• redirect_uris: 授权服务生成code给客户端的重定向地址
• scopes: 权限范围
• client_settings：客户端配置
• token_settings：token配置

具体的表结构可能会根据Spring Security OAuth2的版本而有所不同。开发者可以根据需要自定义这些表的结构和字段。

总之, JdbcRegisteredClientRepository会使用JDBC操作表来实现RegisteredClientRepository接口定义的功能,如保存、查询、更新和删除客户端的注册信息。

自定义RegisteredClientRepository代码示例

在这个示例中,我们实现了一个基于内存的RegisteredClientRepository。它有以下功能:

1. 使用ConcurrentHashMap存储客户端注册信息。
2. 实现了save、findByClientId和remove方法。
3. 提供了一个initialize方法,用于初始化一些测试客户端数据。实现InitializingBean接口,并在afterPropertiesSet()方法中调用了initializeClients()方法。这样,当应用程序上下文启动时,客户端数据就会自动初始化,无需手动调用initialize()方法。

在实际应用中,你可能需要使用数据库或其他持久化存储来保存客户端信息。此外,你可能还需要考虑客户端信息的安全性和访问控制等问题。

import org.springframework.beans.factory.InitializingBean;
import org.springframework.security.oauth2.server.authorization.client.RegisteredClient;
import org.springframework.security.oauth2.server.authorization.client.RegisteredClientRepository;
import org.springframework.stereotype.Repository;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Repository
public class InMemoryRegisteredClientRepository implements RegisteredClientRepository, InitializingBean {

    private final Map<String, RegisteredClient> clients = new ConcurrentHashMap<>();

    @Override
    public void save(RegisteredClient registeredClient) {
        clients.put(registeredClient.getClientId(), registeredClient);
    }

    @Override
    public RegisteredClient findByClientId(String clientId) {
        return clients.get(clientId);
    }

    @Override
    public void remove(String clientId) {
        clients.remove(clientId);
    }

    @Override
    public void afterPropertiesSet() {
        // 在应用程序上下文启动时自动初始化客户端数据
        initializeClients();
    }

    private void initializeClients() {
        // 初始化一些测试客户端
        RegisteredClient client1 = RegisteredClient.withId("client1")
                .clientId("client1")
                .clientSecret("secret1")
                .redirectUri("https://example.com/callback")
                .authorizationGrantType("authorization_code")
                .build();
        save(client1);

        RegisteredClient client2 = RegisteredClient.withId("client2")
                .clientId("client2")
                .clientSecret("secret2")
                .redirectUri("https://example.org/callback")
                .authorizationGrantType("authorization_code")
                .authorizationGrantType("refresh_token")
                .build();
        save(client2);
    }
}

2.OAuth2AuthorizationService

对应configurer.authorizationService()

org.springframework.security.oauth2.server.authorization.OAuth2AuthorizationService 是 Spring Security OAuth2 中用于管理 OAuth2 授权信息的核心接口。它提供了以下功能:

1. 保存和检索授权信息:
   • 该接口提供了保存和检索 OAuth2 授权信息的方法,如授权码、访问令牌、刷新令牌等。
     
     
2. 授权流程管理:
   • 该接口负责管理整个 OAuth2 授权流程,包括授权码授权、访问令牌颁发、刷新令牌刷新等。
     
     
3. 状态管理:
   • 该接口负责管理 OAuth2 授权的状态,如授权是否过期、是否已撤销等。
     
     
4. 可扩展性:
   • 该接口设计为可扩展的,开发者可以根据自己的需求实现自定义的 OAuth2AuthorizationService 实现。

源码应用

比如：

1. OAuth2AuthorizationEndpointFilter在接收到客户端的"/oauth2/authorize"请求生成授权码时，会调用OAuth2AuthorizationCodeRequestAuthenticationProvider，该Provider会在生成授权码后，使用OAuth2AuthorizationService将本次授权信息进行保存。
2. 在OAuth2AuthorizationEndpointFilter过滤器对客户端token请求进行认证时，会在OAuth2AuthorizationCodeAuthenticationProvider中使用OAuth2AuthorizationService去根据授权码查找授权信息（对应上一步），如果用JDBC实现，会去oauth2_authorization表中进行查询，将结果转为OAuth2Authorization对象，如果找不到就会抛出INVALID_GRANT异常。

其他方面，进行授权登录、token验证、token刷新、token撤销时，都会使用OAuth2AuthorizationService去进行授权信息得删除及保存操作

OAuth2AuthorizationService 接口的主要方法如下

• save(OAuth2Authorization authorization): 保存 OAuth2 授权信息。
• findById(String id): 根据 ID 查找 OAuth2 授权信息。
• remove(OAuth2Authorization authorization): 移除 OAuth2 授权信息。
• findByToken(String token, OAuth2TokenType tokenType): 根据令牌查找 OAuth2 授权信息。

在 Spring Security OAuth2 中,默认提供了 InMemoryOAuth2AuthorizationService 和 JdbcOAuth2AuthorizationService 两种实现。前者使用内存存储授权信息,后者使用数据库存储授权信息。

开发者可以根据自己的需求,实现自定义的 OAuth2AuthorizationService 接口,例如:

• 使用其他类型的数据库存储授权信息,如 MongoDB、Redis 等。
• 实现基于事件的授权信息管理,如授权信息变更时触发事件。
• 增加授权信息的额外属性或自定义查询逻辑。

总的来说, OAuth2AuthorizationService 是 Spring Security OAuth2 中管理 OAuth2 授权信息的核心组件,开发者可以根据实际需求进行扩展和自定义。

在 OAuth2AuthorizationService的 JdbcOAuth2AuthorizationService 的实现中,会将授权信息保存到以下数据库表中:

1.oauth2_authorization表:

• 该表用于存储 OAuth2 授权信息,包括授权码、访问令牌、刷新令牌等。该表作用：

  存储授权码(authorization_code): 当客户端使用授权码授权模式时,授权服务器会将授权码信息存储在这张表中。
  
  存储访问令牌(access_token): 当客户端成功获取访问令牌时,授权服务器会将该令牌的信息存储在这张表中。
  
  存储刷新令牌(refresh_token): 当客户端成功获取刷新令牌时,授权服务器会将该令牌的信息存储在这张表中。
  
  存储用户ID(principal_name): 每个授权信息都与一个用户ID (principal_name) 相关联,这有助于追溯授权的来源。
  
  存储授权状态和元数据: 该表还存储了授权的状态(如ACTIVE, REVOKED等)以及一些授权相关的元数据,如授权时间、过期时间等。
  

  当"/oauth2/authorize"请求经过授权后，权限提供者OAuth2AuthorizationCodeRequestAuthenticationProvider会执行this.authorizationService.save(authorization)将code相关信息保存到oauth2_authorization表。
  
  

2. 主要字段有:

• id: 授权信息的唯一标识符
• registered_client_id: 客户端 ID
• principal_name: 授权主体的名称
• authorization_grant_type: 授权类型
• authorized_scopes: 授权的 scope
• attributes: 授权信息的附加属性
• state: 授权状态
• authorization_code_value: 授权码
• authorization_code_issued_at: 授权码颁发时间
• authorization_code_expires_at: 授权码过期时间
• access_token_value: 访问令牌
• access_token_issued_at: 访问令牌颁发时间
• access_token_expires_at: 访问令牌过期时间
• refresh_token_value: 刷新令牌
• refresh_token_issued_at: 刷新令牌颁发时间
• refresh_token_expires_at: 刷新令牌过期时间

在 save 操作中,JdbcOAuth2AuthorizationService 会根据授权信息的类型,将数据保存到对应的数据库表中。例如,当保存访问令牌时,会更新 oauth2_authorization 表。

这种基于 JDBC 的实现方式可以方便地集成到基于关系型数据库的应用程序中,并且可以根据需求对数据库表结构进行自定义。

3.OAuth2AuthorizationConsentService

对应configurer.authorizationConsentService()

org.springframework.security.oauth2.server.authorization.OAuth2AuthorizationConsentService是Spring Security OAuth2中用于管理用户对客户端的授权同意信息的服务接口。它的主要作用包括:

1. 存储用户授权同意信息:
   • 当用户授权某个客户端访问自己的资源时,需要记录下这种授权同意关系。
   • OAuth2AuthorizationConsentService负责存储这种用户与客户端之间的授权同意信息。
     
     
2. 查询用户授权同意信息:
   • 当用户再次访问某个客户端时,需要检查之前是否已经授权过。
   • OAuth2AuthorizationConsentService提供了查询用户授权同意信息的方法。
     
     
3. 管理授权同意的生命周期:
   • 用户授权同意信息通常有一定的有效期,过期后需要重新授权。
   • OAuth2AuthorizationConsentService负责管理这些授权同意信息的生命周期。
     
     
4. 支持多种持久化实现:
   • OAuth2AuthorizationConsentService是一个抽象接口,允许开发者根据需要自行实现不同的持久化方式,如内存、数据库等。

总的来说, OAuth2AuthorizationConsentService是Spring Security OAuth2中用于管理用户授权同意信息的核心服务。它为开发者提供了统一的API,隐藏了具体的存储实现细节。开发者可以根据需求选择合适的实现方式。

源码应用

客户端请求授权码时，OAuth2AuthorizationEndpointFilter过滤器使用OAuth2AuthorizationCodeRequestAuthenticationProvider ，该Provider会使用authorizationConsentService查询客户端是否存在授权记录，存在才可以生成授权码

Spring Security OAuth2提供了JdbcOAuth2AuthorizationConsentService作为OAuth2AuthorizationConsentService的JDBC实现。该实现操作的数据表是oauth2_authorization_consent表。

oauth2_authorization_consent表的主要作用是存储用户对于客户端的授权同意信息。它包含以下几个主要字段:

1. registered_client_id: 授权客户端的ID。
2. principal_name: 授权用户的标识符(通常是用户ID)。
3. authorities: 用户授权给客户端的权限范围。
4. created_at: 授权同意记录的创建时间。
5. updated_at: 授权同意记录的最后更新时间。

当用户授权某个客户端访问自己的资源时,JdbcOAuth2AuthorizationConsentService会将这种授权同意关系记录到oauth2_authorization_consent表中。

之后当用户再次访问该客户端时,JdbcOAuth2AuthorizationConsentService会查询该表,检查是否存在有效的授权同意记录,从而确定是否允许访问。

如果需要自定义授权同意的存储逻辑,开发者可以自行实现OAuth2AuthorizationConsentService接口,并替换掉默认的JdbcOAuth2AuthorizationConsentService实现。

4.AuthorizationServerSettings

对应configurer.authorizationServerSettings()

org.springframework.security.oauth2.server.authorization.settings.AuthorizationServerSettings是Spring Security OAuth2中用于配置授权服务器端点请求路径的类。

通过配置自定义 OAuth2 授权服务器的各种端点路径，以满足特定的应用需求。这种灵活性允许将授权服务器集成到现有的系统中，并确保各个端点的路径符合系统的路由和安全要求。

下面是一个全面设置 AuthorizationServerSettings 的代码示例:

OAuth2AuthorizationServerConfigurer configurer = new OAuth2AuthorizationServerConfigurer();
configurer.authorizationServerSettings(authorizationServerSettings())

@Bean
public AuthorizationServerSettings authorizationServerSettings(){

	//使用默认配置
	//return AuthorizationServerSettings.builder().build();

	//自定义配置,这里展示的是默认配置，如需自定义请自行修改
	return AuthorizationServerSettings.builder()
		.authorizationEndpoint("/oauth2/authorize")
		.tokenEndpoint("/oauth2/token")
		.jwkSetEndpoint("/oauth2/jwks")
		.tokenRevocationEndpoint("/oauth2/revoke")
		.tokenIntrospectionEndpoint("/oauth2/introspect")
		.oidcClientRegistrationEndpoint("/connect/register")
		.oidcUserInfoEndpoint("/userinfo")
		.build();
}

该代码配置了 AuthorizationServerSettings，这是用于配置 OAuth2 授权服务器端点的自定义设置。以下是具体配置项的解释：

1. authorizationEndpoint(“/oauth2/authorize”)
   • 用途: 配置授权端点，用于处理授权请求。
   • 默认路径: /oauth2/authorize
   • 作用: 客户端应用请求用户授权，获取授权码或隐式授权。
     
     
2. tokenEndpoint(“/oauth2/token”)
   • 用途: 配置令牌端点，用于处理令牌请求。
   • 默认路径: /oauth2/token
   • 作用: 客户端应用通过此端点请求访问令牌（Access Token）和刷新令牌（Refresh Token）。
     
     
3. jwkSetEndpoint(“/oauth2/jwks”)
   • 用途: 配置 JSON Web Key Set (JWKS) 端点，用于发布服务的公钥。
   • 默认路径: /oauth2/jwks
   • 作用: 用于验证由授权服务器签名的 JWT（JSON Web Tokens）。
     
     
4. tokenRevocationEndpoint(“/oauth2/revoke”)
   • 用途: 配置令牌撤销端点，用于处理令牌撤销请求。
   • 默认路径: /oauth2/revoke
   • 作用: 客户端应用请求撤销访问令牌或刷新令牌。
     
     
5. tokenIntrospectionEndpoint(“/oauth2/introspect”)
   • 用途: 配置令牌内省端点，用于令牌状态检查。
   • 默认路径: /oauth2/introspect
   • 作用: 客户端应用或资源服务器检查访问令牌的有效性和相关信息。
     
     
6. oidcClientRegistrationEndpoint(“/connect/register”)
   • 用途: 配置 OpenID Connect (OIDC) 客户端注册端点。
   • 默认路径: /connect/register
   • 作用: 允许 OIDC 客户端动态注册自己，以便与授权服务器进行交互。
     
     
7. oidcUserInfoEndpoint(“/userinfo”)
   • 用途: 配置 OIDC 用户信息端点。
   • 默认路径: /userinfo
   • 作用: 允许客户端应用通过此端点获取经过授权用户的用户信息。

5.OAuth2TokenGenerator

对应configurer.tokenGenerator()

org.springframework.security.oauth2.server.authorization.token.OAuth2TokenGenerator 是 Spring Security OAuth2 中一个非常重要的接口

它的主要作用包括:

1. 生成 OAuth2 令牌:
   • OAuth2TokenGenerator 负责生成各种类型的 OAuth2 令牌,包括访问令牌、刷新令牌和 ID 令牌。
   • 它根据具体的令牌类型和相关的令牌请求信息,生成合法的令牌。
     
     
2. 支持可扩展的令牌生成策略:
   • OAuth2TokenGenerator 是一个接口,不同的实现类可以提供不同的令牌生成策略（默认JWT）。
   • 例如,可以生成 JWT 格式的令牌、或者使用随机字符串生成令牌等。
     
     
3. 支持令牌自定义:
   • 开发者可以通过实现自定义的 OAuth2TokenGenerator 来修改令牌的生成逻辑。
   • 比如,可以在令牌中添加额外的自定义声明(claim)信息。
     
     
4. 与授权服务器集成:
   • OAuth2TokenGenerator 通常由授权服务器组件(如 AuthorizationServerController)使用,以生成和返回所需的令牌。
   • 它与授权服务器的其他组件(如令牌存储)协作,确保令牌的正确生成和管理。

总的来说, OAuth2TokenGenerator 是 Spring Security OAuth2 中负责令牌生成的核心组件。它提供了可扩展的令牌生成策略,支持自定义令牌内容,并与授权服务器的其他组件协作,确保整个授权流程的正确运行。

实现类DelegatingOAuth2TokenGenerator

DelegatingOAuth2TokenGenerator 是 Spring Security OAuth2 中一个非常有用的 OAuth2TokenGenerator 实现类。它的主要特点和作用如下:

1. 委托式设计:
   • DelegatingOAuth2TokenGenerator 采用了委托模式,它可以委托给其他具体的 OAuth2TokenGenerator 实现类来生成不同类型的令牌。
   • 这种设计可以让 DelegatingOAuth2TokenGenerator 更加灵活和可扩展,无需自己实现所有类型的令牌生成逻辑。
     
     
2. 支持多种令牌类型:
   • DelegatingOAuth2TokenGenerator 可以同时处理访问令牌、刷新令牌和 ID 令牌的生成。
   • 对于不同类型的令牌,它会委托给对应的具体实现类来完成生成工作。
     
     
3. 可配置的委托关系:
   • 开发者可以通过配置的方式,指定 DelegatingOAuth2TokenGenerator 应该委托给哪些具体的实现类。
   • 这种灵活的配置方式,使得 DelegatingOAuth2TokenGenerator 能够适应不同的授权场景需求。
     
     
4. 简化授权服务器的实现:
   • 在授权服务器的实现中,使用 DelegatingOAuth2TokenGenerator 可以大大简化令牌生成的逻辑。
   • 授权服务器只需要配置好委托关系,就可以让 DelegatingOAuth2TokenGenerator 自动处理各种类型的令牌生成工作。

总的来说, DelegatingOAuth2TokenGenerator 是一个非常强大和灵活的 OAuth2TokenGenerator 实现类。它利用委托模式,可以整合多种具体的令牌生成策略,为授权服务器提供统一的令牌生成能力。这种设计有助于提高授权服务器的可维护性和可扩展性。

实现类JwtGenerator

org.springframework.security.oauth2.server.authorization.token.JwtGenerator 是 Spring Security OAuth2 中一个重要的 JWT 生成器实现类。它的主要作用如下:

1. 生成 JWT 格式的 OAuth2 令牌:
   • JwtGenerator 专门用于生成 JWT (JSON Web Token) 格式的 OAuth2 令牌,包括访问令牌、刷新令牌和 ID 令牌。
   • 它基于 Spring Security 的 JwtEncoder 接口提供的功能,生成符合 JWT 标准的令牌。
     
     
2. 自定义 JWT 头部和负载:
   • JwtGenerator 允许开发者自定义 JWT 头部和负载部分的内容。
   • 开发者可以添加自定义的声明(claim)信息到令牌中,以满足特定的应用需求。
     
     
3. 支持多种签名算法:
   • JwtGenerator 支持多种签名算法,包括对称密钥算法(HMAC)、非对称算法(RSA、EC)等。
   • 开发者可以根据具体的安全需求,选择合适的签名算法来保护 JWT 令牌的完整性。
     
     
4. 与授权服务器集成:
   • JwtGenerator 通常由授权服务器组件使用,以生成所需的 JWT 格式的 OAuth2 令牌。
   • 它与授权服务器的其他组件(如令牌存储)协作,确保令牌的正确生成和管理。
     
     
5. 灵活的配置和扩展:
   • JwtGenerator 提供了丰富的配置选项,开发者可以灵活地定制令牌的各种属性,如过期时间、颁发者等。
   • 此外,开发者还可以通过扩展 JwtGenerator 来实现自定义的 JWT 生成逻辑,满足特殊的应用需求。

总的来说, org.springframework.security.oauth2.server.authorization.token.JwtGenerator 是 Spring Security OAuth2 中一个非常重要的 JWT 生成器实现类。它专注于生成 JWT 格式的 OAuth2 令牌,提供了丰富的自定义选项,并与授权服务器的其他组件集成,满足各种复杂的 OAuth2 应用场景需求。

---

JwtGenerator 的更多细节和使用场景:

1. Token 生成流程:
   • JwtGenerator 通过调用 Spring Security 的 JwtEncoder 接口来生成 JWT 格式的 OAuth2 令牌。
   • 在生成令牌时,它会根据配置的选项,设置 JWT 头部和负载中的各种声明信息,如 sub、iss、exp 等标准声明,以及自定义声明。
   • 最后,JwtGenerator 会使用配置的签名算法对 JWT 进行签名,生成最终的 JWT 字符串。
     
     
2. 支持的签名算法:
   • JwtGenerator 支持多种签名算法,包括对称密钥算法(HMAC)和非对称算法(RSA、EC)。
   • 对称算法适用于授权服务器和客户端共享密钥的场景,非对称算法则更适合授权服务器使用私钥,客户端使用公钥的场景。
   • 开发者可以根据具体的安全需求,选择合适的签名算法来保护 JWT 令牌的完整性。
     
     
3. 与授权服务器的集成:
   • JwtGenerator 通常由授权服务器组件使用,以生成所需的 JWT 格式的 OAuth2 令牌。
   • 在授权服务器的实现中,JwtGenerator 会与其他组件(如令牌存储)协作,确保令牌的正确生成和管理。
   • 例如,授权服务器在颁发令牌时,会使用 JwtGenerator 生成 JWT 格式的访问令牌和刷新令牌。
     
     
4. 扩展性和可定制性:
   • JwtGenerator 提供了丰富的配置选项,开发者可以灵活地定制令牌的各种属性,如过期时间、颁发者等。
   • 此外,开发者还可以通过扩展 JwtGenerator 来实现自定义的 JWT 生成逻辑,满足特殊的应用需求。
   • 例如,开发者可以实现一个自定义的 JwtGenerator 实现类,在生成 JWT 时添加特定的声明信息。

总的来说, JwtGenerator 是 Spring Security OAuth2 中一个非常强大和灵活的 JWT 生成器实现类。它提供了丰富的配置和扩展选项,可以轻松地满足各种复杂的 OAuth2 应用场景下对 JWT 令牌生成的需求。

实现类OAuth2AccessTokenGenerator

org.springframework.security.oauth2.server.authorization.token.OAuth2AccessTokenGenerator 是 Spring Security OAuth2 中专门用于生成 OAuth2 访问令牌的实现类。它的主要作用和功能如下:

1. 生成 OAuth2 访问令牌:
   • OAuth2AccessTokenGenerator 的主要职责是生成符合 OAuth2 规范的访问令牌。
   • 它可以生成各种类型的访问令牌,如 Bearer 令牌、MAC 令牌等。
     
     
2. Token 格式:
   • OAuth2AccessTokenGenerator 支持生成不同格式的访问令牌,包括 JWT (JSON Web Token) 和非 JWT 格式。
   • 对于 JWT 格式,它会借助 JwtGenerator 来生成 JWT 格式的访问令牌。
   • 对于非 JWT 格式,它会生成一个随机字符串作为访问令牌。
     
     
3. 配置选项:
   • OAuth2AccessTokenGenerator 提供了丰富的配置选项,开发者可以定制访问令牌的各种属性,如过期时间、作用域等。
   • 这些配置选项使 OAuth2AccessTokenGenerator 能够灵活地满足不同应用场景下的访问令牌需求。
     
     
4. 与授权服务器集成:
   • OAuth2AccessTokenGenerator 通常由授权服务器组件使用,以生成所需的访问令牌。
   • 它与授权服务器的其他组件(如令牌存储)协作,确保访问令牌的正确生成和管理。
     
     
5. 扩展性:
   • OAuth2AccessTokenGenerator 是一个可扩展的接口,开发者可以实现自定义的访问令牌生成逻辑。
   • 例如,开发者可以实现一个自定义的 OAuth2AccessTokenGenerator 实现类,在生成访问令牌时添加特定的属性。

总的来说, OAuth2AccessTokenGenerator 是 Spring Security OAuth2 中专门用于生成 OAuth2 访问令牌的实现类。它提供了丰富的配置选项,支持不同格式的访问令牌生成,并与授权服务器的其他组件集成,满足各种复杂的 OAuth2 应用场景需求。同时,它也具有良好的可扩展性,方便开发者根据需求进行定制和扩展。

实现类OAuth2AuthorizationCodeGenerator

org.springframework.security.oauth2.server.authorization.authentication.OAuth2AuthorizationCodeGenerator 是 Spring Security OAuth2 中专门用于生成 OAuth2 授权码的实现类。它的主要作用和功能如下:

1. 生成授权码:
   • OAuth2AuthorizationCodeGenerator 的主要职责是生成符合 OAuth2 规范的授权码。
   • 它会根据传入的授权请求参数,生成一个随机的、唯一的授权码字符串。
     
     
2. 授权码格式:
   • 授权码本身是一个简单的字符串,不需要任何特殊的格式。
   • 但 OAuth2AuthorizationCodeGenerator 在生成授权码时,会确保其满足 OAuth2 规范的要求,比如长度、字符集等。
     
     
3. 授权码属性:
   • OAuth2AuthorizationCodeGenerator 会为生成的授权码设置一些属性,如过期时间、关联的客户端 ID 等。
   • 这些属性可以通过配置选项进行自定义,以满足不同应用场景的需求。
     
     
4. 与授权服务器集成:
   • OAuth2AuthorizationCodeGenerator 通常由授权服务器组件使用,以生成所需的授权码。
   • 它与授权服务器的其他组件(如授权码存储)协作,确保授权码的正确生成和管理。
   • 例如,在授权码模式下,授权服务器会使用 OAuth2AuthorizationCodeGenerator 生成授权码,并将其存储在授权码存储中。
     
     
5. 扩展性:
   • OAuth2AuthorizationCodeGenerator 是一个可扩展的接口,开发者可以实现自定义的授权码生成逻辑。
   • 例如,开发者可以实现一个自定义的 OAuth2AuthorizationCodeGenerator 实现类,在生成授权码时添加特定的属性或使用特定的算法。

总的来说, OAuth2AuthorizationCodeGenerator 是 Spring Security OAuth2 中专门用于生成 OAuth2 授权码的实现类。它提供了丰富的配置选项,可以满足不同应用场景下对授权码生成的需求。同时,它也具有良好的可扩展性,方便开发者根据需求进行定制和扩展。

实现类OAuth2RefreshTokenGenerator

org.springframework.security.oauth2.server.authorization.token.OAuth2RefreshTokenGenerator 是 Spring Security OAuth2 中专门用于生成 OAuth2 刷新令牌的实现类。它的主要作用和功能如下:

1. 生成刷新令牌:
   • OAuth2RefreshTokenGenerator 的主要职责是生成符合 OAuth2 规范的刷新令牌。
   • 它可以生成各种类型的刷新令牌,比如 Bearer 令牌、MAC 令牌等。
     
     
2. 刷新令牌格式:
   • OAuth2RefreshTokenGenerator 支持生成不同格式的刷新令牌,包括 JWT (JSON Web Token) 和非 JWT 格式。
   • 对于 JWT 格式,它会借助 JwtGenerator 来生成 JWT 格式的刷新令牌。
   • 对于非 JWT 格式,它会生成一个随机字符串作为刷新令牌。
     
     
3. 配置选项:
   • OAuth2RefreshTokenGenerator 提供了丰富的配置选项,开发者可以定制刷新令牌的各种属性,如过期时间、作用域等。
   • 这些配置选项使 OAuth2RefreshTokenGenerator 能够灵活地满足不同应用场景下的刷新令牌需求。
     
     
4. 与授权服务器集成:
   • OAuth2RefreshTokenGenerator 通常由授权服务器组件使用,以生成所需的刷新令牌。
   • 它与授权服务器的其他组件(如令牌存储)协作,确保刷新令牌的正确生成和管理。
     
     
5. 扩展性:
   • OAuth2RefreshTokenGenerator 是一个可扩展的接口,开发者可以实现自定义的刷新令牌生成逻辑。
   • 例如,开发者可以实现一个自定义的 OAuth2RefreshTokenGenerator 实现类,在生成刷新令牌时添加特定的属性。

总的来说, OAuth2RefreshTokenGenerator 是 Spring Security OAuth2 中专门用于生成 OAuth2 刷新令牌的实现类。它提供了丰富的配置选项,支持不同格式的刷新令牌生成,并与授权服务器的其他组件集成,满足各种复杂的 OAuth2 应用场景需求。同时,它也具有良好的可扩展性,方便开发者根据需求进行定制和扩展。

6.OAuth2ClientAuthenticationConfigurer

对应configurer.clientAuthentication()

用于定制 OAuth2 授权服务器的客户端身份验证配置

在 OAuth2AuthorizationServerConfigurer 类中，方法 clientAuthentication 使用 Customizer<OAuth2ClientAuthenticationConfigurer> 来配置客户端身份验证。以下是详细的解释和配置内容：

方法签名

OAuth2AuthorizationServerConfigurer类中的OAuth2ClientAuthenticationConfigurer配置

public OAuth2AuthorizationServerConfigurer clientAuthentication(Customizer<OAuth2ClientAuthenticationConfigurer> clientAuthenticationCustomizer) {
    clientAuthenticationCustomizer.customize(getConfigurer(OAuth2ClientAuthenticationConfigurer.class));
    return this;
}

方法作用

该方法用于自定义 OAuth2 授权服务器的客户端身份验证配置。具体来说，它通过一个 Customizer 对象来配置 OAuth2ClientAuthenticationConfigurer，后者负责处理客户端的身份验证过程。

参数说明

• clientAuthenticationCustomizer: 一个 Customizer<OAuth2ClientAuthenticationConfigurer> 对象，用于定义如何自定义客户端身份验证配置。

详细解释

1. 获取配置器:

   getConfigurer(OAuth2ClientAuthenticationConfigurer.class)
   

   这行代码获取一个 OAuth2ClientAuthenticationConfigurer 配置器实例，它负责客户端身份验证的具体配置。

2. 自定义配置:

   clientAuthenticationCustomizer.customize(getConfigurer(OAuth2ClientAuthenticationConfigurer.class));
   

   调用 clientAuthenticationCustomizer 的 customize 方法，对获取到的 OAuth2ClientAuthenticationConfigurer 实例进行定制。这允许开发人员通过传递一个自定义器来灵活配置客户端身份验证。

3. 返回当前配置器:

   return this;
   

   返回当前的 OAuth2AuthorizationServerConfigurer 实例，使得配置器方法可以链式调用。

配置解释

基于 OAuth2ClientAuthenticationConfigurer 类中的源码片段，下面是详细解释OAuth2ClientAuthenticationConfigurer 各方法的作用和配置方式。

1. authenticationConverter 方法：

   public OAuth2ClientAuthenticationConfigurer authenticationConverter(AuthenticationConverter authenticationConverter) {
       Assert.notNull(authenticationConverter, "authenticationConverter cannot be null");
       this.authenticationConverters.add(authenticationConverter);
       return this;
   }
   

这个方法用于添加一个 AuthenticationConverter，它负责将 HTTP 请求转换为 Authentication 对象。这个转换器用于从请求中提取认证信息。

2. authenticationConverters 方法：

   public OAuth2ClientAuthenticationConfigurer authenticationConverters(Consumer<List<AuthenticationConverter>> authenticationConvertersConsumer) {
       Assert.notNull(authenticationConvertersConsumer, "authenticationConvertersConsumer cannot be null");
       this.authenticationConvertersConsumer = authenticationConvertersConsumer;
       return this;
   }
   

   这个方法设置一个 Consumer，它提供对默认和自定义添加的 AuthenticationConverter 列表的访问，允许添加、删除或自定义特定的 AuthenticationConverter。

3. authenticationProvider 方法：

   public OAuth2ClientAuthenticationConfigurer authenticationProvider(AuthenticationProvider authenticationProvider) {
       Assert.notNull(authenticationProvider, "authenticationProvider cannot be null");
       this.authenticationProviders.add(authenticationProvider);
       return this;
   }
   

   这个方法添加一个 AuthenticationProvider，用于验证 OAuth2ClientAuthenticationToken。AuthenticationProvider 负责处理具体的认证逻辑。

4. authenticationProviders 方法：

   public OAuth2ClientAuthenticationConfigurer authenticationProviders(Consumer<List<AuthenticationProvider>> authenticationProvidersConsumer) {
       Assert.notNull(authenticationProvidersConsumer, "authenticationProvidersConsumer cannot be null");
       this.authenticationProvidersConsumer = authenticationProvidersConsumer;
       return this;
   }
   

   这个方法设置一个 Consumer，它提供对默认和自定义添加的 AuthenticationProvider 列表的访问，允许添加、删除或自定义特定的 AuthenticationProvider。

5. authenticationSuccessHandler 方法：

   public OAuth2ClientAuthenticationConfigurer authenticationSuccessHandler(AuthenticationSuccessHandler authenticationSuccessHandler) {
       this.authenticationSuccessHandler = authenticationSuccessHandler;
       return this;
   }
   

   这个方法设置一个 AuthenticationSuccessHandler，用于处理客户端认证成功后的操作，并将 OAuth2ClientAuthenticationToken 关联到 SecurityContext。

6. errorResponseHandler 方法：

   public OAuth2ClientAuthenticationConfigurer errorResponseHandler(AuthenticationFailureHandler errorResponseHandler) {
       this.errorResponseHandler = errorResponseHandler;
       return this;
   }
   

   这个方法设置一个 AuthenticationFailureHandler，用于处理客户端认证失败后的操作，并返回 OAuth2Error 错误响应。

示例用法

以下是一个示例，展示如何使用 OAuth2ClientAuthenticationConfigurer 来配置客户端认证：

@Configuration
public class AuthorizationServerConfig {

    @Bean
    public SecurityFilterChain authorizationServerSecurityFilterChain(HttpSecurity http) throws Exception {
        OAuth2AuthorizationServerConfigurer authorizationServerConfigurer = new OAuth2AuthorizationServerConfigurer();
        
        authorizationServerConfigurer
            .clientAuthentication(clientAuthenticationConfigurer -> {
                // 添加自定义的 AuthenticationConverter
                clientAuthenticationConfigurer.authenticationConverter(new CustomAuthenticationConverter());

                // 设置一个 Consumer 来自定义 AuthenticationConverter 列表
                clientAuthenticationConfigurer.authenticationConverters(converters -> {
                    converters.add(new AnotherCustomAuthenticationConverter());
                    // 可以移除或修改现有的 converters
                });

                // 添加自定义的 AuthenticationProvider
                clientAuthenticationConfigurer.authenticationProvider(new CustomAuthenticationProvider());

                // 设置一个 Consumer 来自定义 AuthenticationProvider 列表
                clientAuthenticationConfigurer.authenticationProviders(providers -> {
                    providers.add(new AnotherCustomAuthenticationProvider());
                    // 可以移除或修改现有的 providers
                });

                // 设置自定义的成功处理器
                clientAuthenticationConfigurer.authenticationSuccessHandler(new CustomAuthenticationSuccessHandler());

                // 设置自定义的错误响应处理器
                clientAuthenticationConfigurer.errorResponseHandler(new CustomAuthenticationFailureHandler());
            });

        // 其他配置...

        return http.apply(authorizationServerConfigurer).build();
    }
}

在这个示例中，我们通过 OAuth2AuthorizationServerConfigurer 来配置 OAuth2 授权服务器，并使用 clientAuthentication 方法来定制客户端认证逻辑。我们添加了自定义的 AuthenticationConverter 和 AuthenticationProvider，以及自定义的成功和失败处理器。这样可以根据具体需求灵活地配置客户端认证。

总结

clientAuthentication 方法允许开发人员通过传入一个 Customizer<OAuth2ClientAuthenticationConfigurer> 对象，来定制 OAuth2 授权服务器的客户端身份验证配置。这种方式提供了高度的灵活性，使得开发人员能够根据特定需求定制身份验证逻辑。

7.OAuth2AuthorizationServerMetadataEndpointConfigurer

对应configurer.authorizationServerMetadataEndpoint()

OAuth2AuthorizationServerMetadataEndpointConfigurer 是 Spring Security OAuth2 组件中的一个配置类，用于配置 OAuth2 授权服务器元数据端点。这个端点提供了关于授权服务器的元数据信息，包括其支持的 OAuth2 授权类型、令牌端点、授权端点等信息。

以下是详细的解释和作用：

作用

OAuth2AuthorizationServerMetadataEndpointConfigurer 的主要作用是配置和暴露授权服务器的元数据端点。这些元数据对于客户端应用程序（如 OAuth2 客户端）非常重要，因为它们提供了与授权服务器进行交互所需的所有关键信息。

配置内容

1. 元数据端点：
   OAuth2AuthorizationServerMetadataEndpointConfigurer 负责配置元数据端点。这个端点通常位于 .well-known/openid-configuration，并返回一个 JSON 响应，其中包含授权服务器的配置信息。

2. 支持的授权类型：
   该配置器会提供授权服务器支持的授权类型（如授权码、客户端凭证、隐式等），让客户端知道可以使用哪些方式进行授权。

3. 端点 URL：
   配置器会提供各种端点的 URL，比如授权端点、令牌端点、用户信息端点、JWK（JSON Web Key）端点等。这些 URL 是客户端与授权服务器交互的关键路径。

4. 其他元数据信息：
   还可能包括支持的签名算法、Scopes、响应类型等信息。

使用方法

在配置 Spring Security OAuth2 授权服务器时，可以通过 OAuth2AuthorizationServerConfigurer 来启用和定制元数据端点。以下是一个简单的配置示例：

@Configuration
public class AuthorizationServerConfig {

    @Bean
    public SecurityFilterChain authorizationServerSecurityFilterChain(HttpSecurity http) throws Exception {
        OAuth2AuthorizationServerConfigurer authorizationServerConfigurer = new OAuth2AuthorizationServerConfigurer();

        authorizationServerConfigurer
            .metadataEndpoint(metadataEndpointConfigurer -> metadataEndpointConfigurer
                .authorizationServerMetadataCustomizer(builder -> {
                    builder.issuer("https://example.com")
                           .authorizationEndpoint("https://example.com/oauth2/authorize")
                           .tokenEndpoint("https://example.com/oauth2/token")
                           .jwkSetUri("https://example.com/oauth2/jwks");
                    // 添加其他自定义元数据
                })
            );

        http.apply(authorizationServerConfigurer);

        return http.build();
    }

    @Bean
    public RegisteredClientRepository registeredClientRepository() {
        // 配置和注册客户端
    }

    @Bean
    public JWKSource<SecurityContext> jwkSource() {
        // 配置 JWK 源
    }

    @Bean
    public AuthorizationServerSettings authorizationServerSettings() {
        return AuthorizationServerSettings.builder().build();
    }
}

在这个配置类中，通过 OAuth2AuthorizationServerConfigurer 配置授权服务器。在 metadataEndpoint 方法中，使用 authorizationServerMetadataCustomizer 自定义元数据。

元数据端点示例响应

元数据端点通常返回类似以下的 JSON 响应：

{
  "issuer": "https://example.com",
  "authorization_endpoint": "https://example.com/oauth2/authorize",
  "token_endpoint": "https://example.com/oauth2/token",
  "jwks_uri": "https://example.com/oauth2/jwks",
  "response_types_supported": ["code", "token"],
  "subject_types_supported": ["public"],
  "id_token_signing_alg_values_supported": ["RS256"],
  "scopes_supported": ["openid", "profile", "email"],
  "token_endpoint_auth_methods_supported": ["client_secret_basic", "client_secret_post"]
}

这个响应告诉客户端应用程序有关授权服务器的所有关键信息，使得客户端能够正确地进行 OAuth2 流程的实现。

元数据端点解释

在 OAuth2 和 OpenID Connect 规范中，元数据端点返回的信息帮助客户端应用程序了解授权服务器的配置和能力。以下是你提供的元数据各字段的解释：

1. issuer

   "issuer": "https://example.com"
   

   发行者（Issuer）标识授权服务器的标识符 URI，通常是授权服务器的根 URL。客户端和资源服务器使用这个字段来验证授权服务器的身份。并且，authorization_endpoint、token_endpoint、jwks_uri三个端点的路径要包含issuer。
   
   

2. authorization_endpoint

   "authorization_endpoint": "https://example.com/oauth2/authorize"
   

   授权端点的 URL。客户端使用此 URL 进行授权请求，获取授权码或令牌（取决于使用的授权类型）。/oauth2/authorize的前部分url为issuer的路径。
   
   

3. token_endpoint

   "token_endpoint": "https://example.com/oauth2/token"
   

   令牌端点的 URL。客户端使用此 URL 通过授权码、客户端凭证等方式交换访问令牌。/oauth2/token的前部分url为issuer的路径。
   
   

4. jwks_uri

   "jwks_uri": "https://example.com/oauth2/jwks"
   

   JSON Web Key Set（JWKS）文档的 URL。这个文档包含授权服务器用来签署令牌的公钥。客户端和资源服务器使用这些公钥来验证令牌的签名。/oauth2/jwks的前部分url为issuer的路径。
   
   

5. response_types_supported

   "response_types_supported": ["code", "token"]
   

   支持的响应类型。常见的响应类型包括：

   • code: 表示授权码授权类型
   • token: 表示隐式授权类型
     
     

6. subject_types_supported

   "subject_types_supported": ["public"]
   

   支持的主体类型（subject type）。public 表示使用公共主体标识符，客户端和资源服务器使用相同的标识符。
   
   

7. id_token_signing_alg_values_supported

   "id_token_signing_alg_values_supported": ["RS256"]
   

   支持的 ID 令牌签名算法。RS256 表示使用 RSA SHA-256 算法签署 ID 令牌。客户端使用这些算法来验证 ID 令牌的签名。
   
   

8. scopes_supported

   "scopes_supported": ["openid", "profile", "email"]
   

   授权服务器支持的范围（scopes）。常见的范围包括：

   • openid: 用于 OpenID Connect，表示请求 ID 令牌
   • profile: 请求用户的基本信息（如姓名、性别等）
   • email: 请求用户的电子邮件地址
     
     

9. token_endpoint_auth_methods_supported

   "token_endpoint_auth_methods_supported": ["client_secret_basic", "client_secret_post"]
   

   支持的令牌端点认证方法。常见的认证方法包括：

   • client_secret_basic: 客户端使用 HTTP Basic Authentication 发送其客户端 ID 和客户端密钥
   • client_secret_post: 客户端在 POST 请求体中发送其客户端 ID 和客户端密钥

这些元数据字段为客户端应用程序提供了与授权服务器交互的关键信息，使其能够正确地执行授权流程和令牌管理。这些字段包括了授权服务器的基本信息、支持的功能和配置选项，确保客户端能够有效地使用授权服务器的服务。

获取元数据端点信息的方法

在不知道授权服务器端点信息的情况下，可以通过一个标准的发现文档（discovery document）来获取这些信息。在 OpenID Connect 和 OAuth 2.0 中，授权服务器通常会公开一个 .well-known 端点，其中包含了授权服务器的配置信息。

步骤

1. 构建发现文档 URL：
   发现文档通常位于 issuer URL 的子路径 .well-known/openid-configuration。例如，如果已知 issuer 是 https://example.com，那么发现文档的 URL 通常是 https://example.com/.well-known/openid-configuration。

2. 发送请求获取发现文档：
   发送一个 HTTP GET 请求到发现文档的 URL，获取授权服务器的元数据信息。

3. 解析响应：
   响应是一个 JSON 文档，包含授权服务器的各种端点信息和支持的特性。

示例

假设已知 issuer 是 https://example.com，可以通过以下步骤获取元数据：

使用 cURL 命令行工具

curl -s https://example.com/.well-known/openid-configuration

使用 JavaScript (例如在 Node.js 中)

const fetch = require('node-fetch');

const issuer = 'https://example.com';
const wellKnownEndpoint = `${issuer}/.well-known/openid-configuration`;

fetch(wellKnownEndpoint)
  .then(response => response.json())
  .then(data => {
    console.log(data);
  })
  .catch(error => {
    console.error('Error fetching discovery document:', error);
  });

示例响应

以下是一个示例响应，展示了发现文档的内容：

{
  "issuer": "https://example.com",
  "authorization_endpoint": "https://example.com/oauth2/authorize",
  "token_endpoint": "https://example.com/oauth2/token",
  "jwks_uri": "https://example.com/oauth2/jwks",
  "response_types_supported": ["code", "token"],
  "subject_types_supported": ["public"],
  "id_token_signing_alg_values_supported": ["RS256"],
  "scopes_supported": ["openid", "profile", "email"],
  "token_endpoint_auth_methods_supported": ["client_secret_basic", "client_secret_post"]
}

总结

OAuth2AuthorizationServerMetadataEndpointConfigurer 是 Spring Security OAuth2 框架中一个用于配置授权服务器元数据端点的重要类。通过提供详细的元数据信息，它使得客户端应用程序能够正确地发现和使用授权服务器的功能。这个配置器简化了授权服务器的设置，并确保它能够提供所有必要的元数据给客户端。

8.OAuth2AuthorizationEndpointConfigurer

对应configurer.authorizationEndpoint()

OAuth2AuthorizationEndpointConfigurer 是 Spring Security OAuth2 框架中的一个配置类，用于配置 OAuth2 授权端点/oauth2/authorize。该配置类提供了多种方法，可以自定义授权请求、认证提供者、响应处理器和同意页面等。

主要配置项及其作用

下面结合其源码中的方法讲解其配置

authorizationRequestConverter

public OAuth2AuthorizationEndpointConfigurer authorizationRequestConverter(AuthenticationConverter authorizationRequestConverter) {
    Assert.notNull(authorizationRequestConverter, "authorizationRequestConverter cannot be null");
    this.authorizationRequestConverters.add(authorizationRequestConverter);
    return this;
}

• 作用：添加一个 AuthenticationConverter 用于将授权请求转换为 Authentication 对象。
• 说明：自定义授权请求转换器，可以对请求参数进行解析和转换。

authorizationRequestConverters

public OAuth2AuthorizationEndpointConfigurer authorizationRequestConverters(
        Consumer<List<AuthenticationConverter>> authorizationRequestConvertersConsumer) {
    Assert.notNull(authorizationRequestConvertersConsumer, "authorizationRequestConvertersConsumer cannot be null");
    this.authorizationRequestConvertersConsumer = authorizationRequestConvertersConsumer;
    return this;
}

• 作用：提供一个 Consumer 以访问和修改默认及自定义的 AuthenticationConverter 列表。
• 说明：可以添加、删除或自定义特定的授权请求转换器。

authenticationProvider

public OAuth2AuthorizationEndpointConfigurer authenticationProvider(AuthenticationProvider authenticationProvider) {
    Assert.notNull(authenticationProvider, "authenticationProvider cannot be null");
    this.authenticationProviders.add(authenticationProvider);
    return this;
}

• 作用：添加一个 AuthenticationProvider 用于处理 Authentication 对象的认证。
• 说明：自定义认证提供者，可以处理特定的认证逻辑。

authenticationProviders

public OAuth2AuthorizationEndpointConfigurer authenticationProviders(
        Consumer<List<AuthenticationProvider>> authenticationProvidersConsumer) {
    Assert.notNull(authenticationProvidersConsumer, "authenticationProvidersConsumer cannot be null");
    this.authenticationProvidersConsumer = authenticationProvidersConsumer;
    return this;
}

• 作用：提供一个 Consumer 以访问和修改默认及自定义的 AuthenticationProvider 列表。
• 说明：可以添加、删除或自定义特定的认证提供者。

authorizationResponseHandler

public OAuth2AuthorizationEndpointConfigurer authorizationResponseHandler(AuthenticationSuccessHandler authorizationResponseHandler) {
    this.authorizationResponseHandler = authorizationResponseHandler;
    return this;
}

• 作用：设置一个 AuthenticationSuccessHandler 以处理成功的授权请求。
• 说明：自定义成功处理逻辑，例如重定向或返回特定的响应。

errorResponseHandler

public OAuth2AuthorizationEndpointConfigurer errorResponseHandler(AuthenticationFailureHandler errorResponseHandler) {
    this.errorResponseHandler = errorResponseHandler;
    return this;
}

• 作用：设置一个 AuthenticationFailureHandler 以处理失败的授权请求。
• 说明：自定义失败处理逻辑，例如返回错误消息或重定向到错误页面。

consentPage

public OAuth2AuthorizationEndpointConfigurer consentPage(String consentPage) {
    this.consentPage = consentPage;
    return this;
}

• 作用：设置自定义的同意页面 URL。
• 说明：指定用户在授权过程中看到的同意页面。

addAuthorizationCodeRequestAuthenticationValidator

void addAuthorizationCodeRequestAuthenticationValidator(
        Consumer<OAuth2AuthorizationCodeRequestAuthenticationContext> authenticationValidator) {
    this.authorizationCodeRequestAuthenticationValidator =
            this.authorizationCodeRequestAuthenticationValidator == null ?
                    authenticationValidator :
                    this.authorizationCodeRequestAuthenticationValidator.andThen(authenticationValidator);
}

• 作用：添加一个 Consumer 以验证授权码请求的认证上下文。
• 说明：自定义授权码请求验证逻辑。

实际开发中的应用示例

以下是一个实际开发中如何自定义 OAuth2AuthorizationEndpointConfigurer 的示例：

@Configuration
public class AuthorizationServerConfig {

    @Bean
    public SecurityFilterChain authorizationServerSecurityFilterChain(HttpSecurity http) throws Exception {
        OAuth2AuthorizationServerConfigurer authorizationServerConfigurer = new OAuth2AuthorizationServerConfigurer();

        authorizationServerConfigurer.authorizationEndpoint(authorizationEndpointConfigurer -> 
            authorizationEndpointConfigurer
                .authorizationRequestConverter(new CustomAuthorizationRequestConverter())
                .authorizationRequestConverters(converters -> {
                    converters.add(new AnotherCustomAuthorizationRequestConverter());
                })
                .authenticationProvider(new CustomAuthenticationProvider())
                .authenticationProviders(providers -> {
                    providers.add(new AnotherCustomAuthenticationProvider());
                })
                .authorizationResponseHandler(new CustomAuthorizationSuccessHandler())
                .errorResponseHandler(new CustomAuthorizationFailureHandler())
                .consentPage("/custom-consent")
        );

        http.apply(authorizationServerConfigurer);

        return http.build();
    }

    @Bean
    public RegisteredClientRepository registeredClientRepository() {
        // 配置和注册客户端
    }

    @Bean
    public JWKSource<SecurityContext> jwkSource() {
        // 配置 JWK 源
    }

    @Bean
    public AuthorizationServerSettings authorizationServerSettings() {
        return AuthorizationServerSettings.builder().build();
    }
}

在这个配置类中，通过 OAuth2AuthorizationServerConfigurer 配置授权服务器的授权端点。可以自定义请求转换器、认证提供者、响应处理器和同意页面等，以满足具体的业务需求。

总结

OAuth2AuthorizationEndpointConfigurer 提供了多种方法，可以对 OAuth2 授权端点，即/oauth2/authorize请求进行全面的自定义配置。通过自定义授权请求转换器、认证提供者、响应处理器和同意页面等，可以灵活地适应各种实际业务场景，增强授权服务器的功能和安全性。

9.OAuth2TokenEndpointConfigurer

对应configurer.tokenEndpoint()

对 OAuth2 令牌端点，即"/oauth2/token"请求的行为进行灵活的定制。这些方法允许我们配置令牌请求的转换、认证提供者、成功和失败的响应处理器等，以满足不同场景下的需求。

下面结合其源码中的配置方法进行说明，这些方法主要用于配置 OAuth2 令牌端点的行为，包括令牌请求的转换、认证提供者、成功和失败的响应处理器等。现在让我们结合源码来详细说明每个方法的作用，并提供一个示例配置。

方法说明：

1. accessTokenRequestConverter 和 accessTokenRequestConverters：

   • 用于配置将令牌请求转换为 Authentication 对象的转换器，以便进行后续的认证处理。
   • 可以添加自定义的令牌请求转换器，以满足特定需求。

2. authenticationProvider 和 authenticationProviders：

   • 用于配置认证提供者，处理 OAuth2 令牌端点中的认证过程。
   • 可以添加自定义的认证提供者，以实现特定的认证逻辑。

3. accessTokenResponseHandler：

   • 设置成功生成访问令牌时的处理器，用于处理成功生成令牌的情况。
   • 例如，返回 OAuth2 访问令牌响应。

4. errorResponseHandler：

   • 设置处理 OAuth2 认证异常时的处理器，用于返回错误响应。
   • 例如，返回 OAuth2 错误信息。

示例配置：

下面是一个示例配置，演示了如何使用 OAuth2TokenEndpointConfigurer 进行配置：

@Configuration
@EnableAuthorizationServer
public class OAuth2AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.authenticationManager(authenticationManager)
                 .tokenServices(tokenServices())
                 .accessTokenConverter(accessTokenConverter())
                 .accessTokenResponseHandler(accessTokenResponseHandler())
                 .errorResponseHandler(errorResponseHandler())
                 .accessTokenRequestConverters(converters -> {
                     converters.add(new CustomAccessTokenRequestConverter());
                 });
    }

    @Bean
    public TokenServices tokenServices() {
        // 配置令牌服务
    }

    @Bean
    public AccessTokenConverter accessTokenConverter() {
        // 配置令牌转换器
    }

    @Bean
    public AuthenticationSuccessHandler accessTokenResponseHandler() {
        // 配置访问令牌响应处理器
    }

    @Bean
    public AuthenticationFailureHandler errorResponseHandler() {
        // 配置错误响应处理器
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        // 配置客户端详情服务
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        // 配置授权服务器安全策略
    }
}

在这个示例配置中，我们通过 OAuth2TokenEndpointConfigurer 中的方法对令牌端点进行了配置。我们自定义了令牌请求转换器、认证成功和失败的响应处理器等，以满足特定的业务需求。

总结：

通过使用 OAuth2TokenEndpointConfigurer 提供的方法，可以对 OAuth2 令牌端点的行为进行灵活的定制。这些方法允许我们配置令牌请求的转换、认证提供者、成功和失败的响应处理器等，以满足不同场景下的需求。

10.OAuth2TokenIntrospectionEndpointConfigurer

对应configurer.tokenIntrospectionEndpoint()

说明

OAuth2TokenIntrospectionEndpointConfigurer 的作用是配置 OAuth2 的令牌内省端点，即"/oauth2/introspect"请求。

令牌内省端点用于验证访问令牌的有效性，并返回关于令牌的信息。以下是其源码配置方法的说明：

1. introspectionRequestConverter 和 introspectionRequestConverters：
   • 用于配置将内省请求转换为 Authentication 对象的转换器，以便进行后续的认证处理。
   • 可以添加自定义的内省请求转换器，以满足特定需求。
     
     
2. authenticationProvider 和 authenticationProviders：
   • 用于配置认证提供者，处理 OAuth2 令牌内省端点中的认证过程。
   • 可以添加自定义的认证提供者，以实现特定的认证逻辑。
     
     
3. introspectionResponseHandler：
   • 设置成功内省访问令牌时的处理器，用于处理成功内省令牌的情况。
   • 例如，返回内省令牌响应。
     
     
4. errorResponseHandler：
   • 设置处理 OAuth2 认证异常时的处理器，用于返回错误响应。
   • 例如，返回 OAuth2 错误信息。

通过配置这些选项，可以定制令牌内省端点的行为，以满足特定的需求。

示例配置

以下是一个示例配置，演示了如何使用 OAuth2TokenIntrospectionEndpointConfigurer 进行配置：

@Configuration
@EnableAuthorizationServer
public class OAuth2AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.authenticationManager(authenticationManager)
                 .tokenIntrospectionEndpoint(tokenIntrospectionEndpoint())
                 .introspectionRequestConverters(converters -> {
                     converters.add(new CustomIntrospectionRequestConverter());
                 });
    }

    @Bean
    public TokenIntrospectionEndpoint tokenIntrospectionEndpoint() {
        return new TokenIntrospectionEndpoint();
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        // 配置客户端详情服务
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        // 配置授权服务器安全策略
    }
}

在这个示例配置中，我们通过 OAuth2TokenIntrospectionEndpointConfigurer 中的方法对令牌内省端点进行了配置。我们添加了自定义的内省请求转换器，以及设置了成功内省访问令牌时的处理器和处理异常时的处理器，以满足特定的业务需求。

总结

具体来说，OAuth2TokenIntrospectionEndpointConfigurer 中的配置项，如内省请求转换器、认证提供者、响应处理器等，都会在 OAuth2TokenIntrospectionEndpointFilter 中被应用。这意味着通过配置 OAuth2TokenIntrospectionEndpointConfigurer，可以定制化内省端点的行为，包括如何解析请求、如何进行认证、如何处理成功和失败的响应等。

所以，任何在 OAuth2TokenIntrospectionEndpointConfigurer 中自定义的配置都将会在 OAuth2TokenIntrospectionEndpointFilter 中生效，并影响到内省端点的实际行为。

11.OAuth2TokenRevocationEndpointFilter

对应configurer.tokenRevocationEndpoint()

说明

OAuth2TokenRevocationEndpointConfigurer 的作用是配置 OAuth2 的令牌撤销端点，即"/oauth2/revoke"。该端点用于撤销访问令牌和刷新令牌，使其失效并防止被再次使用。以下是各个方法的说明：

1. revocationRequestConverter 和 revocationRequestConverters：
   • 用于配置将撤销请求转换为 Authentication 对象的转换器，以便进行后续的认证处理。
   • 可以添加自定义的撤销请求转换器，以满足特定需求。
     
     
2. authenticationProvider 和 authenticationProviders：
   • 用于配置认证提供者，处理 OAuth2 令牌撤销端点中的认证过程。
   • 可以添加自定义的认证提供者，以实现特定的认证逻辑。
     
     
3. revocationResponseHandler：
   • 设置成功撤销访问令牌时的处理器，用于处理成功撤销令牌的情况。
   • 例如，返回撤销成功的响应。
     
     
4. errorResponseHandler：
   • 设置处理 OAuth2 认证异常时的处理器，用于返回错误响应。
   • 例如，返回 OAuth2 错误信息。

通过配置这些选项，可以定制化令牌撤销端点的行为，包括如何解析请求、如何进行认证、如何处理成功和失败的响应等。

示例配置

以下是一个示例配置，演示了如何使用 OAuth2TokenRevocationEndpointConfigurer 进行配置：

@Configuration
@EnableAuthorizationServer
public class OAuth2AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.tokenRevocationEndpoint()
                 .revocationRequestConverters(converters -> {
                     converters.add(new CustomRevocationRequestConverter());
                 })
                 .revocationResponseHandler(revocationResponseHandler())
                 .errorResponseHandler(errorResponseHandler());
    }

    @Bean
    public TokenRevocationEndpointFilter revocationEndpointFilter() {
        return new TokenRevocationEndpointFilter();
    }

    @Bean
    public RevocationSuccessHandler revocationResponseHandler() {
        // 配置撤销成功处理器
    }

    @Bean
    public RevocationFailureHandler errorResponseHandler() {
        // 配置撤销失败处理器
    }

    // 其他配置...
}

在这个示例中，我们通过 OAuth2TokenRevocationEndpointConfigurer 中的方法对令牌撤销端点进行了配置。我们添加了自定义的撤销请求转换器，并设置了成功撤销访问令牌时的处理器和处理异常时的处理器，以满足特定的业务需求。

总结

通过对 OAuth2TokenRevocationEndpointConfigurer 进行自定义配置所做的更改将会影响到 OAuth2TokenRevocationEndpointFilter 的行为。配置在 OAuth2TokenRevocationEndpointConfigurer 中的内容将会在过滤器中生效，因为过滤器是实际处理 OAuth2 令牌撤销请求的组件。

具体来说，OAuth2TokenRevocationEndpointConfigurer 中的配置项，如撤销请求转换器、认证提供者、响应处理器等，都会在 OAuth2TokenRevocationEndpointFilter 中被应用。这意味着通过配置 OAuth2TokenRevocationEndpointConfigurer，可以定制化撤销端点的行为，包括如何解析请求、如何进行认证、如何处理成功和失败的响应等。

因此，任何在 OAuth2TokenRevocationEndpointConfigurer 中自定义的配置都将会在 OAuth2TokenRevocationEndpointFilter 中生效，并影响到撤销端点的实际行为。

12.OidcConfigurer

对应configurer.oidc()

OidcConfigurer 是用于配置 OpenID Connect（OIDC）相关端点的配置器。OIDC 是建立在 OAuth 2.0 之上的标识层协议，用于对用户进行身份验证，并提供用户信息的访问。

以下是 OidcConfigurer 中的几个方法及其作用：

1. providerConfigurationEndpoint 方法：
   • 用于配置 OpenID Connect Provider Configuration Endpoint，即 OpenID Connect Provider 的配置端点。
   • 通过该端点，客户端可以获取 OpenID Connect Provider 的配置信息，包括授权端点、令牌端点、用户信息端点等。
   • 可以通过参数 providerConfigurationEndpointCustomizer 进行定制化配置，以满足特定需求。
     
     
2. clientRegistrationEndpoint 方法：
   • 用于配置 OpenID Connect Dynamic Client Registration 1.0 Endpoint，即 OpenID Connect 客户端注册端点。
   • 通过该端点，客户端可以动态地注册自身作为 OpenID Connect 客户端，并获取客户端标识和秘钥等信息。
   • 可以通过参数 clientRegistrationEndpointCustomizer 进行定制化配置，以满足特定需求。
     
     
3. userInfoEndpoint 方法：
   • 用于配置 OpenID Connect 1.0 UserInfo Endpoint，即 OpenID Connect 用户信息端点。
   • 通过该端点，客户端可以获取已认证用户的详细信息，如姓名、电子邮件等。
   • 可以通过参数 userInfoEndpointCustomizer 进行定制化配置，以满足特定需求。

通过 OidcConfigurer 中提供的这些方法，可以方便地配置 OpenID Connect 相关端点，包括 Provider 配置、客户端注册、用户信息等，以实现 OIDC 协议的完整支持。


以下是一个示例配置，展示了如何使用 OidcConfigurer 进行配置：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/login").permitAll()
                .anyRequest().authenticated()
            .and()
            .oauth2Login()
                .userInfoEndpoint()
                    .oidcConfigurer(oidc -> oidc.userInfoEndpoint(this::customizeUserInfoEndpoint));
    }

    private void customizeUserInfoEndpoint(OidcUserInfoEndpointConfigurer userInfoEndpoint) {
        userInfoEndpoint
            .oidcConfigurer(oidc -> oidc
                .clientRegistrationEndpoint(this::customizeClientRegistrationEndpoint)
                .providerConfigurationEndpoint(this::customizeProviderConfigurationEndpoint)
            );
    }

    private void customizeClientRegistrationEndpoint(OidcClientRegistrationEndpointConfigurer clientRegistrationEndpoint) {
        // 配置客户端注册端点
    }

    private void customizeProviderConfigurationEndpoint(OidcProviderConfigurationEndpointConfigurer providerConfigurationEndpoint) {
        // 配置 Provider 配置端点
    }

    // 其他配置...
}

在这个示例中，我们通过 oidcConfigurer 方法配置了用户信息端点的定制化处理。在 customizeUserInfoEndpoint 方法中，我们再次调用了 oidcConfigurer 方法，配置了客户端注册端点和 Provider 配置端点的定制化处理。在 customizeClientRegistrationEndpoint 和 customizeProviderConfigurationEndpoint 方法中，我们可以根据实际需求配置客户端注册和 Provider 配置的细节。