第10章 Spring Security 的未来趋势与高级话题（2024 最新版）（下）-阿里云开发者社区

第10章 Spring Security 的未来趋势与高级话题（2024 最新版）（上）+https://developer.aliyun.com/article/1487172

10.2.3 拓展案例 1：响应式 JWT 认证

在响应式 Spring 应用中集成 JWT 认证，可以为你的应用提供一种无状态的、基于令牌的安全机制，特别适用于微服务架构。这里是如何实现响应式 JWT 认证的详细步骤和代码示例。

步骤 1：引入依赖

首先，确保你的项目中引入了JWT支持所需的依赖。

build.gradle 示例:

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-security'
    implementation 'org.springframework.boot:spring-boot-starter-webflux'
    implementation 'io.jsonwebtoken:jjwt-api:0.11.2'
    runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.11.2'
    runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.11.2'
}

步骤 2：创建 JWT 工具类

创建一个 JWT 工具类，用于生成和解析 JWT 令牌。这个类将负责令牌的创建、签名和验证。

JwtUtil.java 示例:

@Component
public class JwtUtil {
    private String secretKey = "yourSecretKey"; // 应从配置文件中读取
    private long validityInMilliseconds = 3600000; // 1h
    public String createToken(String username, List<String> roles) {
        Claims claims = Jwts.claims().setSubject(username);
        claims.put("roles", roles);
        Date now = new Date();
        Date validity = new Date(now.getTime() + validityInMilliseconds);
        return Jwts.builder()
            .setClaims(claims)
            .setIssuedAt(now)
            .setExpiration(validity)
            .signWith(SignatureAlgorithm.HS256, secretKey)
            .compact();
    }
    public Authentication getAuthentication(String token) {
        UserDetails userDetails = new User(getUsername(token), "", getRoles(token));
        return new UsernamePasswordAuthenticationToken(userDetails, "", userDetails.getAuthorities());
    }
    public String getUsername(String token) {
        return Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token).getBody().getSubject();
    }
    @SuppressWarnings("unchecked")
    public List<String> getRoles(String token) {
        List<String> roles = Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token).getBody().get("roles", List.class);
        return roles.stream().map(role -> "ROLE_" + role).collect(Collectors.toList());
    }
    public boolean validateToken(String token) {
        try {
            Jws<Claims> claims = Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);
            return !claims.getBody().getExpiration().before(new Date());
        } catch (JwtException | IllegalArgumentException e) {
            throw new IllegalStateException("Expired or invalid JWT token");
        }
    }
}

步骤 3：创建响应式 JWT 认证过滤器

创建一个响应式的 JWT 认证过滤器，该过滤器将检查 HTTP 请求中的 JWT 令牌，并进行认证。

JwtTokenAuthenticationFilter.java 示例:

public class JwtTokenAuthenticationFilter implements WebFilter {
    @Autowired
    private JwtUtil jwtUtil;
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        String token = resolveToken(exchange.getRequest());
        if (token != null && jwtUtil.validateToken(token)) {
            Authentication auth = jwtUtil.getAuthentication(token);
            return chain.filter(exchange).contextWrite(ReactiveSecurityContextHolder.withAuthentication(auth));
        }
        return chain.filter(exchange);
    }
    private String resolveToken(ServerHttpRequest request) {
        String bearerToken = request.getHeaders().getFirst(HttpHeaders.AUTHORIZATION);
        if (bearerToken != null && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

步骤 4：配置安全过滤链

在 Spring Security 配置中添加 JWT 认证过滤器。

SecurityConfig.java 示例:

@EnableWebFluxSecurity
public class SecurityConfig {
    @Bean
    public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
        http
            .authorizeExchange()
            .pathMatchers("/api/**").authenticated()
            .anyExchange().permitAll()
            .and().
csrf().disable()
            .addFilterAt(jwtTokenAuthenticationFilter(), SecurityWebFiltersOrder.AUTHENTICATION);
        return http.build();
    }
    @Bean
    public JwtTokenAuthenticationFilter jwtTokenAuthenticationFilter() {
        return new JwtTokenAuthenticationFilter();
    }
}

测试 JWT 认证

编写集成测试以验证 JWT 认证机制是否正常工作。

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureWebTestClient
public class JwtAuthenticationTests {
    @Autowired
    private WebTestClient webTestClient;
    @Autowired
    private JwtUtil jwtUtil;
    @Test
    public void testJwtAuthentication() {
        String token = jwtUtil.createToken("user", Arrays.asList("USER"));
        webTestClient.get().uri("/api/user")
            .header(HttpHeaders.AUTHORIZATION, "Bearer " + token)
            .exchange()
            .expectStatus().isOk();
    }
}

通过这个案例，你将能够在响应式 Spring 应用中实现 JWT 认证，为你的应用提供一种灵活且安全的认证机制。这不仅增强了应用的安全性，也提高了其性能和可伸缩性。

10.2.4 拓展案例 2：响应式方法级安全

在响应式应用中实现方法级安全可以让你精细控制对服务层方法的访问权限，Spring Security 提供了对响应式方法安全的支持，让开发者能够以声明式的方式控制方法的访问权限。以下是如何在响应式 Spring 应用中实现方法级安全的详细步骤和代码示例。

步骤 1：启用响应式方法级安全

首先，确保在你的配置类中启用了响应式方法级安全。这可以通过在配置类上添加 @EnableReactiveMethodSecurity 注解来实现。

MethodSecurityConfig.java 示例:

@Configuration
@EnableReactiveMethodSecurity
public class MethodSecurityConfig {
    // 这个配置类可能不需要包含其他配置，除非你需要自定义方法安全行为
}

步骤 2：使用安全注解保护服务方法

然后，在你的服务类中，使用 Spring Security 提供的安全注解（如 @PreAuthorize）来声明方法的访问控制规则。

UserService.java 示例:

@Service
public class UserService {
    @PreAuthorize("hasRole('ADMIN')")
    public Mono<User> findUser(String id) {
        // 模拟查找用户的逻辑
        return Mono.just(new User(id, "username"));
    }
}

这个例子中，findUser 方法被配置为只有拥有 ADMIN 角色的用户才能调用。

步骤 3：配置自定义权限评估逻辑

如果你需要更复杂的权限逻辑，可以实现 ReactivePermissionEvaluator 接口，并在配置中注册你的自定义权限评估器。

CustomPermissionEvaluator.java 示例:

public class CustomPermissionEvaluator implements ReactivePermissionEvaluator {
    @Override
    public Mono<Boolean> hasPermission(Authentication authentication, Object targetDomainObject, Object permission) {
        // 实现自定义的权限评估逻辑
        return Mono.just(true); // 示例逻辑，应根据实际情况进行判断
    }
    @Override
    public Mono<Boolean> hasPermission(Authentication authentication, Serializable targetId, String targetType, Object permission) {
        // 实现自定义的权限评估逻辑
        return Mono.just(false); // 示例逻辑，应根据实际情况进行判断
    }
}

在配置中注册自定义权限评估器:

@Configuration
@EnableReactiveMethodSecurity
public class MethodSecurityConfig {
    @Bean
    public CustomPermissionEvaluator customPermissionEvaluator() {
        return new CustomPermissionEvaluator();
    }
}

测试方法级安全配置

最后，编写测试用例以验证方法级安全配置是否按预期工作。

@SpringBootTest
public class UserServiceTests {
    @Autowired
    private UserService userService;
    @Test
    @WithMockUser(roles = "ADMIN")
    public void testFindUserWithAdminRole() {
        StepVerifier.create(userService.findUser("1"))
            .expectNextMatches(user -> "username".equals(user.getUsername()))
            .verifyComplete();
    }
    @Test
    @WithMockUser(roles = "USER")
    public void testFindUserWithUserRole() {
        StepVerifier.create(userService.findUser("1"))
            .expectError(AccessDeniedException.class)
            .verify();
    }
}

通过实施这些步骤，你的响应式 Spring 应用将能够利用方法级安全来精细控制对服务方法的访问权限，确保只有具备适当权限的用户才能执行敏感操作。这种方式提高了应用的安全性，同时保持了代码的清晰和易于管理。

通过这个案例，你可以看到在响应式应用中使用 Spring Security 不仅能够保持应用的反应式特性，还能提供强大的安全保障。无论是基于角色的访问控制、JWT 认证，还是方法级安全，Spring Security 都能以响应式的方式完美支持，确保你的应用既快速响应又安全可靠。

10.3 扩展 Spring Security

在这个章节中，我们将深入探讨如何扩展 Spring Security，以适应更复杂和特定的安全需求。Spring Security 的可扩展性是其强大功能的核心之一，让开发者能够定制和增强框架的默认行为。

10.3.1 基础知识

在深入探讨如何扩展 Spring Security 之前，了解一些核心概念和技术将帮助我们更好地理解和应用这些高级特性。Spring Security 是一个强大的安全框架，它提供了全面的安全解决方案，但有时候我们需要根据特定的业务需求来定制和扩展它的功能。

自定义用户认证

UserDetailsService: Spring Security 中用于加载用户特定数据的核心接口。如果你的用户信息存储在非标准的来源，如数据库、LDAP 或远程服务，你可以实现这个接口来定义加载用户信息的逻辑。
PasswordEncoder: 用于密码的加密和匹配。在定义自己的 UserDetailsService 时，通常也需要提供一个密码加密器来保证安全性。

自定义认证逻辑

AuthenticationProvider: 定义认证的逻辑。当你需要支持新的认证方式（如短信验证码、生物识别等）时，实现这个接口可以让你完全控制认证过程。
AuthenticationToken: 认证过程中使用的令牌，存储了认证信息，如用户名、密码、权限等。定义新的 AuthenticationToken 类型，可以支持不同的认证信息和逻辑。

安全过滤器定制

WebSecurityConfigurerAdapter: 配置安全过滤器链的基本类。通过重写这个类的方法，你可以添加或移除特定的过滤器，改变安全配置的行为。
OncePerRequestFilter: 用于创建自定义过滤器的便捷基类。当需要在请求处理过程中执行特定的安全检查或逻辑时，可以扩展这个类。

访问控制和权限评估

AccessDecisionManager: 决定是否允许对某个资源的访问。你可以定义自己的访问决策管理器来实现复杂的访问控制策略。
PermissionEvaluator: 用于方法级安全的接口，允许基于方法调用的上下文评估权限。实现这个接口可以支持更细粒度的权限控制，如基于用户属性或资源状态的动态权限检查。

了解这些基础知识和组件后，我们就可以开始探索如何通过扩展这些组件和实现自定义逻辑来满足特定的安全需求了。这种灵活性和可扩展性是 Spring Security 成为企业级应用首选安全框架的重要原因之一。

10.3.2 重点案例：自定义用户认证流程

在这个案例中，我们将通过实现一个基于短信验证码的认证流程来展示如何自定义用户认证流程。这种认证方式在移动应用或需要二次验证的场景中非常有用。

步骤 1：定义短信验证码认证令牌

首先，定义一个代表短信验证码认证信息的 AuthenticationToken。这个令牌将在认证过程中使用，以携带用户的手机号和短信验证码。

public class SmsAuthenticationToken extends AbstractAuthenticationToken {
    private final Object principal;
    private final Object credentials;
    public SmsAuthenticationToken(String mobile, String code) {
        super(Collections.emptyList());
        this.principal = mobile;
        this.credentials = code;
        setAuthenticated(false); // 初始化时未认证
    }
    @Override
    public Object getCredentials() {
        return credentials;
    }
    @Override
    public Object getPrincipal() {
        return principal;
    }
    // 认证成功后，设置用户权限并标记为已认证
    void setAuthorities(Collection<? extends GrantedAuthority> authorities) {
        super.setAuthenticated(true); // 必须在设置权限前调用
        super.setAuthorities(authorities);
    }
}

步骤 2：实现短信验证码认证提供者

接着，创建一个 AuthenticationProvider 实现，用于处理 SmsAuthenticationToken 的认证逻辑。

@Component
public class SmsAuthenticationProvider implements AuthenticationProvider {
    @Autowired
    private UserDetailsService userDetailsService;
    @Autowired
    private SmsCodeService smsCodeService; // 假设这是你的服务，用于验证短信验证码
    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        SmsAuthenticationToken authRequest = (SmsAuthenticationToken) authentication;
        String mobile = (String) authRequest.getPrincipal();
        String code = (String) authRequest.getCredentials();
        // 调用短信验证码服务验证验证码
        if (!smsCodeService.validateCode(mobile, code)) {
            throw new BadCredentialsException("Invalid SMS verification code.");
        }
        // 验证码正确，加载用户详情
        UserDetails userDetails = userDetailsService.loadUserByUsername(mobile);
        // 创建已认证的令牌，包含用户详情和权限
        SmsAuthenticationToken authResult = new SmsAuthenticationToken(userDetails, null);
        authResult.setAuthorities(userDetails.getAuthorities());
        return authResult;
    }
    @Override
    public boolean supports(Class<?> authentication) {
        return SmsAuthenticationToken.class.isAssignableFrom(authentication);
    }
}

步骤 3：配置自定义认证提供者

在 Spring Security 配置中注册你的自定义认证提供者。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private SmsAuthenticationProvider smsAuthenticationProvider;
    @Override
    protected void configure(AuthenticationManagerBuilder auth) {
        auth.authenticationProvider(smsAuthenticationProvider);
    }
    // 配置其他安全细节...
}

步骤 4：创建接收短信验证码的控制器

最后，创建一个控制器来接收短信验证码认证请求。

@RestController
public class SmsAuthenticationController {
    @Autowired
    private AuthenticationManager authenticationManager;
    @PostMapping("/login/sms")
    public String login(@RequestParam String mobile, @RequestParam String code) {
        SmsAuthenticationToken authRequest = new SmsAuthenticationToken(mobile, code);
        Authentication authResult = authenticationManager.authenticate(authRequest);
        // 假设有一个方法来为认证用户生成JWT令牌
        String token = jwtTokenService.generateToken(authResult);
        return token;
    }
}

通过这个案例，你可以看到在 Spring Security 中自定义认证流程是完全可行的。这种方式为应用提供了极大的灵活性，允许你根据具体的业务需求实现各种认证机制。

10.3.3 拓展案例 1：自定义权限验证

自定义权限验证允许你实现更复杂的安全需求，比如基于用户属性或请求上下文的动态权限检查。以下案例展示了如何在 Spring Security 中实现属性基访问控制（ABAC）。

步骤 1：定义自定义权限评估逻辑

首先，创建一个实现了 PermissionEvaluator 接口的类，以提供自定义的权限评估逻辑。

@Component
public class CustomPermissionEvaluator implements PermissionEvaluator {
    @Autowired
    private UserRepository userRepository; // 假设这是你的用户仓库
    @Override
    public boolean hasPermission(Authentication authentication, Object targetDomainObject, Object permission) {
        if ((authentication == null) || (targetDomainObject == null) || !(permission instanceof String)) {
            return false;
        }
        String targetType = targetDomainObject.getClass().getSimpleName().toUpperCase();
        
        return hasPrivilege(authentication, targetType, permission.toString().toUpperCase());
    }
    @Override
    public boolean hasPermission(Authentication authentication, Serializable targetId, String targetType, Object permission) {
        if ((authentication == null) || (targetType == null) || !(permission instanceof String)) {
            return false;
        }
        
        return hasPrivilege(authentication, targetType.toUpperCase(), permission.toString().toUpperCase());
    }
    private boolean hasPrivilege(Authentication authentication, String targetType, String permission) {
        String username = authentication.getName();
        User user = userRepository.findByUsername(username);
        
        // 示例：基于用户属性和目标类型进行权限验证
        if ("SOME_RESOURCE".equals(targetType)) {
            return user.getDepartment().equals("IT") && permission.equals("READ");
        }
        
        return false;
    }
}

步骤 2：注册自定义权限评估逻辑

接着，在你的 Spring Security 配置中注册这个自定义的 PermissionEvaluator。

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {
    @Autowired
    private CustomPermissionEvaluator customPermissionEvaluator;
    @Override
    protected MethodSecurityExpressionHandler createExpressionHandler() {
        DefaultMethodSecurityExpressionHandler expressionHandler = new DefaultMethodSecurityExpressionHandler();
        expressionHandler.setPermissionEvaluator(customPermissionEvaluator);
        return expressionHandler;
    }
}

步骤 3：使用自定义权限验证

现在，你可以在你的服务或控制器方法上使用 @PreAuthorize 或 @PostAuthorize 注解，利用自定义的权限评估逻辑来控制访问权限。

@RestController
public class SomeResourceController {
    @GetMapping("/some-resource/{id}")
    @PreAuthorize("hasPermission(#id, 'SOME_RESOURCE', 'READ')")
    public ResponseEntity<SomeResource> getSomeResource(@PathVariable Long id) {
        // 查询并返回资源
        return ResponseEntity.ok(new SomeResource());
    }
}

这个案例展示了如何通过实现 PermissionEvaluator 接口来扩展 Spring Security，实现基于属性的访问控制（ABAC）。这种方式使得权限验证更加灵活和强大，能够满足更复杂的业务需求。

10.3.4 拓展案例 2：自定义安全事件监听器

监听和响应安全相关事件，如登录成功、登录失败或访问被拒绝等，对于安全审计、实时监控或触发某些业务逻辑非常重要。以下是如何在 Spring Security 中实现自定义安全事件监听器的详细步骤和代码示例。

步骤 1：创建自定义安全事件监听器

首先，定义一个或多个事件监听器来处理你感兴趣的安全事件。Spring Security 发布了多种类型的事件，包括认证成功、认证失败、以及访问决策事件等。

@Component
public class CustomSecurityEventListener {
    private static final Logger log = LoggerFactory.getLogger(CustomSecurityEventListener.class);
    @EventListener
    public void handleAuthenticationSuccess(AuthenticationSuccessEvent event) {
        String username = ((User) event.getAuthentication().getPrincipal()).getUsername();
        log.info("Authentication success for user: {}", username);
        // 这里可以添加更多的业务逻辑，如更新用户的登录时间、记录登录日志等
    }
    @EventListener
    public void handleAuthenticationFailure(AbstractAuthenticationFailureEvent event) {
        String username = event.getAuthentication().getName();
        log.error("Authentication failed for user: {} due to: {}", username, event.getException().getMessage());
        // 这里可以添加更多的业务逻辑，如记录失败尝试、发送警报等
    }
    @EventListener
    public void handleAccessDenied(AuthorizationFailureEvent event) {
        Authentication authentication = event.getAuthentication();
        String username = authentication != null ? authentication.getName() : "anonymous";
        log.warn("Access denied for user: {}. Target object: {}. Required authority: {}", username, event.getSource(), event.getAccessDeniedException().getMessage());
        // 这里可以添加更多的业务逻辑，如记录访问拒绝事件、发送通知等
    }
}

步骤 2：配置 Spring Security 以发布事件

确保 Spring Security 能够发布你感兴趣的事件。大多数标准事件（如认证成功和失败）默认已经启用，但某些事件可能需要额外的配置。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            // 配置安全规则
            .authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .formLogin().successHandler((request, response, authentication) -> {
                // 如果需要，这里可以显式地发布事件
            })
            .failureHandler((request, response, exception) -> {
                // 如果需要，这里也可以显式地发布事件
            });
    }
}

步骤 3：测试自定义安全事件监听器

最后，编写测试来验证自定义事件监听器是否按预期工作。

@SpringBootTest
@AutoConfigureMockMvc
public class SecurityEventListenerTests {
    @Autowired
    private MockMvc mockMvc;
    @Test
    public void testAuthenticationSuccessEvent() throws Exception {
        // 使用 MockMvc 发起一个认证成功的请求
        mockMvc.perform(formLogin("/login").user("user").password("password"))
            .andExpect(authenticated());
        // 验证 handleAuthenticationSuccess 方法被调用
    }
    @Test
    public void testAuthenticationFailureEvent() throws Exception {
        // 使用 MockMvc 发起一个认证失败的请求
        mockMvc.perform(formLogin("/login").user("user").password("wrongpassword"))
            .andExpect(unauthenticated());
        // 验证 handleAuthenticationFailure 方法被调用
    }
}

通过这个案例，你可以看到如何在 Spring Security 中实现自定义事件监听器，以便在发生安全相关事件时执行自定义逻辑。这使得你的应用能够响应各种安全事件，从而提高安全性、促进审计和监控，并根据业务需求触发相应的操作。

通过这些案例，你可以看到扩展 Spring Security 并不复杂，只需要了解框架提供的扩展点并实现相应的接口或类即可。这种灵活性和可扩展性使得 Spring Security 成为构建安全 Java 应用的强大工具。

第10章 Spring Security 的未来趋势与高级话题（2024 最新版）（下）

10.2.3 拓展案例 1：响应式 JWT 认证

10.2.4 拓展案例 2：响应式方法级安全

10.3 扩展 Spring Security

10.3.1 基础知识

10.3.2 重点案例：自定义用户认证流程

10.3.3 拓展案例 1：自定义权限验证

10.3.4 拓展案例 2：自定义安全事件监听器

热门文章

最新文章

相关课程

相关电子书

相关实验场景