如何在Spring Boot OAuth2资源服务器中添加本地用户邮箱校验？

如果你的JWT已经通过Google的JWKS端点验证签名有效，且JWT里的email_verified声明值为true，完全可以信任该邮箱地址。原因如下：

• Google作为授权服务器，在颁发包含email声明的JWT前，已经验证过用户对该邮箱的所有权（比如邮箱验证码、账号关联验证）。
• 通过JWKS验证签名能确保令牌未被篡改，email字段的内容是Google官方颁发的，不存在伪造风险。

注意：如果JWT里没有email_verified声明或其值为false，则不能直接信任该邮箱，因为可能是未验证的邮箱账号。

在Spring Security OAuth2资源服务器场景下，推荐两种最优实现方式：

方式1：自定义JWT认证转换器（推荐） #

这种方式贴合Spring Security的认证流程，在JWT转换为Authentication对象的阶段完成邮箱校验，逻辑更内聚：

1. 先写一个查询数据库的服务类，用于校验邮箱是否已注册：

@Service
public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // 检查邮箱是否存在于本地数据库
    public boolean isEmailRegistered(String email) {
        return userRepository.existsByEmail(email);
    }
}

2. 自定义JwtAuthenticationConverter，在转换过程中加入邮箱校验：

@Component
public class CustomJwtAuthenticationConverter implements JwtAuthenticationConverter {
    private final UserService userService;
    private final JwtAuthenticationConverter defaultConverter = new JwtAuthenticationConverter();

    public CustomJwtAuthenticationConverter(UserService userService) {
        this.userService = userService;
        // 保留默认的权限转换逻辑（如果需要处理权限的话）
        defaultConverter.setJwtGrantedAuthoritiesConverter(new JwtGrantedAuthoritiesConverter());
    }

    @Override
    public Authentication convert(Jwt jwt) {
        // 先完成默认的JWT转Authentication逻辑
        Authentication auth = defaultConverter.convert(jwt);
        String email = jwt.getClaimAsString("email");
        
        // 校验邮箱是否在本地数据库中
        if (email == null || !userService.isEmailRegistered(email)) {
            throw new BadCredentialsException("未授权的邮箱地址");
        }
        
        // 可选：把邮箱设置为认证对象的用户名，方便后续业务使用
        return new JwtAuthenticationToken(jwt, auth.getAuthorities(), email);
    }
}

3. 在Security配置类中替换默认的转换器：

@Configuration
public class SecurityConfigurationO2Auth {
    private static Logger logger = LoggerFactory.getLogger(SecurityConfigurationO2Auth.class);

    @Value("${spring.security.oauth2.resourceserver.jwt.jwt-set-uri}")
    private String jwkSetUri;
    
    private final CustomJwtAuthenticationConverter customConverter;

    public SecurityConfigurationO2Auth(CustomJwtAuthenticationConverter customConverter) {
        this.customConverter = customConverter;
    }

    @Bean
    public JwtDecoder jwtDecoder() {
        return NimbusJwtDecoder.withJwkSetUri(jwkSetUri).build();
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests()
                .anyRequest().authenticated()
                .and()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .oauth2ResourceServer()
                .jwt()
                .decoder(jwtDecoder())
                .jwtAuthenticationConverter(customConverter) // 配置自定义转换器
                .and()
                .and()
                .cors()
                .and()
                .csrf().disable();

        return http.build();
    }
}

方式2：添加全局认证后置过滤器 #

如果希望校验逻辑和认证流程解耦，可以添加一个OncePerRequestFilter，在认证完成后统一校验邮箱：

1. 编写自定义过滤器：

@Component
public class EmailValidationFilter extends OncePerRequestFilter {
    private final UserService userService;

    public EmailValidationFilter(UserService userService) {
        this.userService = userService;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        
        // 只处理已通过JWT认证的用户
        if (auth instanceof JwtAuthenticationToken) {
            Jwt jwt = ((JwtAuthenticationToken) auth).getToken();
            String email = jwt.getClaimAsString("email");
            
            if (email == null || !userService.isEmailRegistered(email)) {
                SecurityContextHolder.clearContext();
                response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "未授权的邮箱地址");
                return;
            }
        }
        
        filterChain.doFilter(request, response);
    }
}

2. 在Security配置中注册该过滤器，放在认证过滤器之后：

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http, EmailValidationFilter emailFilter) throws Exception {
    http.authorizeHttpRequests()
            .anyRequest().authenticated()
            .and()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .oauth2ResourceServer()
            .jwt()
            .decoder(jwtDecoder())
            .and()
            .and()
            .addFilterAfter(emailFilter, OAuth2AuthorizationRequestRedirectFilter.class) // 放在认证流程之后
            .cors()
            .and()
            .csrf().disable();

    return http.build();
}

方案对比 #

• 方式1更贴合Spring Security的认证生命周期，异常会被框架统一处理，返回标准的401响应。
• 方式2更灵活，适合需要在认证后添加多步校验的场景，但需要自行处理响应逻辑。

内容的提问来源于stack exchange，提问作者FRANCOIS Nicolas