使用联合身份提供商时，能否禁用Spring Authorization Server的数据库配置？

完全可以在使用联合身份提供商的场景下跳过或禁用内部数据库依赖，Spring Authorization Server本身就支持无数据库的轻量化配置方式，以下是具体实现步骤：

1. 排除数据库自动配置 #

在Spring Boot启动类上排除数据源和JPA的自动配置类，避免框架自动初始化数据库相关组件：

@SpringBootApplication(exclude = {
    DataSourceAutoConfiguration.class,
    HibernateJpaAutoConfiguration.class
})
public class AuthServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(AuthServerApplication.class, args);
    }
}

2. 用内存方式存储客户端信息 #

不需要数据库存储客户端配置时，直接使用InMemoryRegisteredClientRepository来注册客户端：

@Bean
public RegisteredClientRepository registeredClientRepository() {
    RegisteredClient oidcClient = RegisteredClient.withId(UUID.randomUUID().toString())
            .clientId("external-idp-client")
            .clientSecret("{noop}secret")
            .clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
            .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
            .authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN)
            .redirectUri("https://your-app/callback")
            .postLogoutRedirectUri("https://your-app/logout")
            .scope(OidcScopes.OPENID)
            .scope(OidcScopes.PROFILE)
            .clientSettings(ClientSettings.builder().requireAuthorizationConsent(true).build())
            .build();

    return new InMemoryRegisteredClientRepository(oidcClient);
}

3. 配置联合身份提供商认证对接 #

通过Spring Security的OIDC客户端配置，将用户认证委托给外部联合身份提供商，无需从内部数据库读取用户信息：

@Bean
public SecurityFilterChain oauth2ClientSecurityFilterChain(HttpSecurity http) throws Exception {
    http
        .authorizeHttpRequests(authorize -> authorize
            .anyRequest().authenticated()
        )
        .oauth2Login(oauth2 -> oauth2
            .authorizationEndpoint(endpoint -> endpoint
                .baseUri("/oauth2/authorize")
            )
            .redirectionEndpoint(endpoint -> endpoint
                .baseUri("/oauth2/callback/*")
            )
        );
    return http.build();
}

4. 使用无状态JWT令牌（可选） #

如果不需要持久化令牌，可配置JWT作为访问令牌，通过非对称密钥签名实现无状态验证，完全无需数据库存储令牌：

@Bean
public JWKSource<SecurityContext> jwkSource() {
    RSAKey rsaKey = generateRsa();
    JWKSet jwkSet = new JWKSet(rsaKey);
    return (jwkSelector, securityContext) -> jwkSelector.select(jwkSet);
}

private static RSAKey generateRsa() {
    KeyPair keyPair = generateRsaKey();
    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    return new RSAKey.Builder(publicKey)
            .privateKey(privateKey)
            .keyID(UUID.randomUUID().toString())
            .build();
}

private static KeyPair generateRsaKey() {
    try {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(2048);
        return keyPairGenerator.generateKeyPair();
    } catch (Exception ex) {
        throw new IllegalStateException(ex);
    }
}

这种配置下，Authorization Server完全依赖外部联合身份提供商处理用户认证，客户端和令牌相关信息都在内存或通过JWT签名维护，无需任何内部数据库。

内容的提问来源于stack exchange，提问作者Peter Penzov