首页 > 软件编程 > java > Spring Security过滤器执行顺序

Spring Security过滤器执行顺序的自定义配置指南

2026-06-17 08:51:52 作者：知远漫谈

在现代 Web 应用开发中,Spring Security 作为 Java 生态中最主流的安全框架,为开发者提供了强大的认证、授权和安全防护能力,然而,要真正掌握 Spring Security,理解其核心机制过滤器链是必不可少的一步,本文将深入探讨 Spring Security 过滤器的执行顺序原理

引言

在现代 Web 应用开发中，Spring Security 作为 Java 生态中最主流的安全框架，为开发者提供了强大的认证、授权和安全防护能力。然而，要真正掌握 Spring Security，理解其核心机制——过滤器链（Filter Chain） 是必不可少的一步。尤其是在复杂的业务场景中，我们常常需要对默认的过滤器执行顺序进行自定义调整，以满足特定的安全需求或集成第三方服务。

本文将深入探讨 Spring Security 过滤器的执行顺序原理，并通过大量实际代码示例，展示如何灵活地自定义过滤器顺序，从而构建出既安全又符合业务逻辑的 Web 应用。无论你是刚接触 Spring Security 的新手，还是希望深入理解其内部机制的资深开发者，相信都能从中获得实用的知识和启发。

什么是 Spring Security 过滤器链？

在深入讨论自定义配置之前，我们首先需要理解 Spring Security 的核心架构——过滤器链（Filter Chain）。

Servlet 过滤器基础

在 Java Web 开发中，Servlet Filter 是一种用于在请求到达目标资源（如 Servlet、Controller）之前或响应返回客户端之前执行预处理或后处理逻辑的组件。多个 Filter 可以组成一个过滤器链（Filter Chain），按照配置的顺序依次执行。

public interface Filter {
    void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException;
}

当一个 HTTP 请求进入应用时，容器会依次调用链中的每个 Filter，每个 Filter 可以选择：

修改请求或响应
执行额外逻辑（如日志记录、权限检查）
决定是否继续传递请求到下一个 Filter 或目标资源

Spring Security 如何利用过滤器链？

Spring Security 并没有重新发明轮子，而是巧妙地利用了 Servlet 规范中的 Filter 机制。它将整个安全逻辑拆分为多个职责单一的 Filter，并将它们组织成一条有序的过滤器链。每个 Filter 负责处理安全流程中的一个特定环节。

例如：

UsernamePasswordAuthenticationFilter：处理基于表单的用户名/密码认证
BearerTokenAuthenticationFilter：处理 JWT Bearer Token 认证
ExceptionTranslationFilter：处理安全相关的异常（如 AccessDeniedException）
FilterSecurityInterceptor：执行最终的授权决策

这些 Filter 按照严格的顺序执行，确保安全流程的正确性。比如，认证必须在授权之前完成，异常处理必须包裹在整个安全流程之外等。

默认过滤器链的结构

Spring Security 提供了一套完整的默认过滤器链，涵盖了从认证、授权到异常处理的完整流程。虽然我们通常不需要手动配置所有这些 Filter，但了解它们的存在和作用对于调试和自定义至关重要。

以下是 Spring Security 默认过滤器链中一些关键 Filter 的执行顺序（按执行先后排列）：

ChannelProcessingFilter：处理协议转换（如 HTTP 到 HTTPS）
WebAsyncManagerIntegrationFilter：集成 WebAsyncManager
SecurityContextPersistenceFilter：在请求开始时加载 SecurityContext，结束时保存
HeaderWriterFilter：写入安全相关的 HTTP 响应头
CorsFilter：处理跨域资源共享（CORS）
CsrfFilter：处理 CSRF 保护
LogoutFilter：处理用户登出
OAuth2AuthorizationRequestRedirectFilter：处理 OAuth2 授权请求重定向
Saml2WebSsoAuthenticationRequestFilter：处理 SAML2 SSO 请求
X509AuthenticationFilter：处理 X.509 证书认证
AbstractPreAuthenticatedProcessingFilter：处理预认证
CasAuthenticationFilter：处理 CAS 认证
OAuth2LoginAuthenticationFilter：处理 OAuth2 登录
Saml2WebSsoAuthenticationFilter：处理 SAML2 SSO 认证
UsernamePasswordAuthenticationFilter：处理表单登录
ConcurrentSessionFilter：处理并发会话控制
BearerTokenAuthenticationFilter：处理 Bearer Token 认证
BasicAuthenticationFilter：处理 HTTP Basic 认证
RequestCacheAwareFilter：恢复被安全拦截的原始请求
SecurityContextHolderAwareRequestFilter：包装 HttpServletRequest 以支持安全方法
JaasApiIntegrationFilter：集成 JAAS
RememberMeAuthenticationFilter：处理记住我功能
AnonymousAuthenticationFilter：为未认证用户提供匿名身份
OAuth2AuthorizationCodeGrantFilter：处理 OAuth2 授权码授予
SessionManagementFilter：管理会话相关逻辑
ExceptionTranslationFilter：处理安全异常
FilterSecurityInterceptor：执行 URL 级别的授权决策
SwitchUserFilter：处理用户切换

这个列表看起来很复杂，但实际上 Spring Security 会根据你的配置自动启用或禁用相应的 Filter。例如，如果你没有配置表单登录，UsernamePasswordAuthenticationFilter 就不会被加入到过滤器链中。

过滤器执行顺序的重要性

过滤器的执行顺序绝不是随意的，而是经过精心设计的。错误的顺序可能导致严重的安全漏洞或功能异常。例如：

SecurityContextPersistenceFilter 必须在最前面，确保每个请求都有独立的 SecurityContext
ExceptionTranslationFilter 必须包裹在所有可能抛出安全异常的 Filter 外面
FilterSecurityInterceptor 必须在最后（在 ExceptionTranslationFilter 之前），确保在所有认证完成后才进行授权检查

理解这些依赖关系是成功自定义过滤器顺序的前提。接下来，我们将通过 Mermaid 图表直观地展示 Spring Security 过滤器链的执行流程。

现在我们已经建立了对 Spring Security 过滤器链的基本理解，接下来将深入探讨如何自定义过滤器的执行顺序。

为什么需要自定义过滤器执行顺序？

虽然 Spring Security 的默认过滤器链设计得相当完善，但在实际项目开发中，我们经常会遇到需要调整过滤器顺序的情况。以下是一些典型的场景：

场景一：自定义认证逻辑

假设你的应用需要支持一种特殊的认证方式，比如基于 API Key 的认证。这种认证方式需要在标准的用户名/密码认证之前执行，因为 API Key 认证通常用于机器对机器的通信，而用户名/密码认证用于用户交互。

如果不调整顺序，可能会出现以下问题：

API Key 请求被误认为是未认证的用户请求，触发了表单登录重定向
API Key 认证逻辑在用户名/密码认证之后执行，导致不必要的性能开销

场景二：集成第三方安全服务

在企业级应用中，经常需要集成第三方安全服务，如：

WAF（Web Application Firewall） 集成
审计日志服务，需要在认证前后都记录相关信息
多因素认证（MFA） 服务，需要在初始认证后执行额外的验证步骤

这些服务通常需要在特定的时机介入安全流程，这就要求我们能够精确控制自定义过滤器的插入位置。

场景三：处理特殊的安全需求

某些业务场景有特殊的安全需求，例如：

IP 白名单检查：需要在任何认证之前执行，快速拒绝非法 IP
速率限制（Rate Limiting）：需要在认证之前执行，防止恶意用户通过大量认证请求耗尽系统资源
自定义 CSRF 保护：可能需要替换或增强默认的 CsrfFilter

场景四：微服务架构中的安全协调

在微服务架构中，不同的服务可能有不同的安全策略。网关服务可能负责统一的认证，而下游服务负责细粒度的授权。这时可能需要：

在网关层移除某些过滤器（如表单登录相关）
在下游服务中添加特定的过滤器来验证来自网关的认证信息

场景五：性能优化

有时为了性能考虑，我们需要调整过滤器顺序。例如：

将轻量级的检查（如 IP 白名单）放在前面，快速失败
将重量级的操作（如数据库查询）放在后面，只在必要时执行

Spring Security 过滤器顺序的底层机制

要有效地自定义过滤器顺序，我们需要理解 Spring Security 是如何管理和排序过滤器的。

SecurityFilterChain 的作用

Spring Security 5.0 引入了 SecurityFilterChain 接口，它代表了一条完整的过滤器链。一个应用可以配置多条 SecurityFilterChain，每条链负责处理匹配特定请求模式的请求。

@FunctionalInterface
public interface SecurityFilterChain {
    boolean matches(HttpServletRequest request);
    List<Filter> getFilters();
}

SecurityFilterChain 的核心是 getFilters() 方法，它返回一个按正确顺序排列的 Filter 列表。

FilterComparator 和 FilterOrder

Spring Security 使用 FilterComparator 来对过滤器进行排序。这个比较器基于每个 Filter 的顺序值（Order Value） 进行比较。

每个 Filter 都有一个对应的顺序常量，定义在 SecurityProperties.Filter 类中（在 Spring Boot 中）或 FilterOrderRegistration 中（在纯 Spring Security 中）。

例如：

SecurityProperties.DEFAULT_FILTER_ORDER = -100
ChannelProcessingFilter 的顺序是 Ordered.HIGHEST_PRECEDENCE + 10
SecurityContextPersistenceFilter 的顺序是 SecurityProperties.DEFAULT_FILTER_ORDER - 10

这些顺序值确保了过滤器按照正确的逻辑顺序执行。

FilterRegistrationBean 的影响

在 Spring Boot 应用中，如果你直接注册一个 Filter 作为 Spring Bean，Spring Boot 会自动将其包装在 FilterRegistrationBean 中。这可能会导致该 Filter 被添加到 Servlet 容器的过滤器链中，而不是 Spring Security 的过滤器链中。

这是一个常见的陷阱！Spring Security 的过滤器链和 Servlet 容器的过滤器链是两个不同的概念：

Servlet 容器过滤器链：由 Web 容器（如 Tomcat）管理，包含所有注册的 Filter
Spring Security 过滤器链：由 Spring Security 管理，只包含安全相关的 Filter

Spring Security 本身是通过一个特殊的 Filter（通常是 DelegatingFilterProxy）集成到 Servlet 容器过滤器链中的。DelegatingFilterProxy 会将请求委托给 Spring Security 的内部过滤器链。

因此，要将自定义 Filter 添加到 Spring Security 的过滤器链中，不能简单地将其注册为普通的 Spring Bean，而需要通过 Spring Security 的配置机制。

自定义过滤器顺序的多种方法

Spring Security 提供了多种方式来自定义过滤器的执行顺序。我们将逐一介绍这些方法，并提供详细的代码示例。

方法一：使用 addFilterBefore()、addFilterAfter()、addFilterAt()

这是最常用和直观的方法。通过 HttpSecurity 的配置方法，我们可以将自定义 Filter 插入到指定位置。

addFilterBefore() - 在指定过滤器之前添加

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        // 创建自定义过滤器
        IpWhitelistFilter ipWhitelistFilter = new IpWhitelistFilter();
        
        http
            .authorizeHttpRequests(authz -> authz
                .anyRequest().authenticated()
            )
            .formLogin(Customizer.withDefaults())
            // 在 UsernamePasswordAuthenticationFilter 之前添加 IP 白名单过滤器
            .addFilterBefore(ipWhitelistFilter, UsernamePasswordAuthenticationFilter.class);
            
        return http.build();
    }
}

对应的自定义过滤器实现：

public class IpWhitelistFilter extends OncePerRequestFilter {
    
    private static final Set<String> WHITELISTED_IPS = Set.of("192.168.1.1", "10.0.0.1");
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        
        String clientIp = getClientIpAddress(request);
        
        if (!WHITELISTED_IPS.contains(clientIp)) {
            response.setStatus(HttpStatus.FORBIDDEN.value());
            response.getWriter().write("IP not allowed: " + clientIp);
            return;
        }
        
        // 继续执行过滤器链
        filterChain.doFilter(request, response);
    }
    
    private String getClientIpAddress(HttpServletRequest request) {
        String xForwardedFor = request.getHeader("X-Forwarded-For");
        if (xForwardedFor != null && !xForwardedFor.isEmpty()) {
            return xForwardedFor.split(",")[0].trim();
        }
        return request.getRemoteAddr();
    }
}

在这个例子中，IpWhitelistFilter 会在 UsernamePasswordAuthenticationFilter 之前执行，确保只有白名单中的 IP 才能进行后续的认证流程。

addFilterAfter() - 在指定过滤器之后添加

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        AuditLogFilter auditLogFilter = new AuditLogFilter();
        
        http
            .authorizeHttpRequests(authz -> authz
                .anyRequest().authenticated()
            )
            .formLogin(Customizer.withDefaults())
            // 在认证完成后添加审计日志过滤器
            .addFilterAfter(auditLogFilter, UsernamePasswordAuthenticationFilter.class);
            
        return http.build();
    }
}

审计日志过滤器实现：

public class AuditLogFilter extends OncePerRequestFilter {
    
    private static final Logger logger = LoggerFactory.getLogger(AuditLogFilter.class);
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        
        // 记录请求开始时间
        long startTime = System.currentTimeMillis();
        
        // 继续执行过滤器链
        filterChain.doFilter(request, response);
        
        // 请求处理完成后记录审计日志
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        String username = authentication != null ? authentication.getName() : "anonymous";
        String method = request.getMethod();
        String uri = request.getRequestURI();
        int status = response.getStatus();
        long duration = System.currentTimeMillis() - startTime;
        
        logger.info("AUDIT: User={} Method={} URI={} Status={} Duration={}ms", 
                   username, method, uri, status, duration);
    }
}

注意：addFilterAfter() 添加的过滤器会在指定过滤器之后执行，但在响应阶段（即 filterChain.doFilter() 之后的代码）会在整个过滤器链执行完成后才运行。这是因为 Servlet Filter 的响应处理是在调用栈回溯时执行的。

addFilterAt() - 替换指定位置的过滤器

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        CustomCsrfFilter customCsrfFilter = new CustomCsrfFilter();
        
        http
            .authorizeHttpRequests(authz -> authz
                .anyRequest().authenticated()
            )
            .formLogin(Customizer.withDefaults())
            // 替换默认的 CsrfFilter
            .addFilterAt(customCsrfFilter, CsrfFilter.class);
            
        return http.build();
    }
}

自定义 CSRF 过滤器：

public class CustomCsrfFilter extends OncePerRequestFilter {
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        
        // 自定义 CSRF 逻辑
        if ("POST".equals(request.getMethod())) {
            String csrfToken = request.getHeader("X-CSRF-TOKEN");
            String expectedToken = getExpectedCsrfToken(request);
            
            if (csrfToken == null || !csrfToken.equals(expectedToken)) {
                response.setStatus(HttpStatus.FORBIDDEN.value());
                response.getWriter().write("Invalid CSRF token");
                return;
            }
        }
        
        filterChain.doFilter(request, response);
    }
    
    private String getExpectedCsrfToken(HttpServletRequest request) {
        // 从 session 或其他存储中获取预期的 CSRF token
        HttpSession session = request.getSession(false);
        return session != null ? (String) session.getAttribute("CSRF_TOKEN") : null;
    }
}

方法二：实现 Ordered 接口或使用 @Order 注解

另一种方法是让自定义 Filter 实现 Ordered 接口或使用 @Order 注解来指定顺序值。

@Component
@Order(100) // 指定顺序值
public class RateLimitingFilter extends OncePerRequestFilter implements Ordered {
    
    private final RateLimiter rateLimiter = RateLimiter.create(10.0); // 每秒10个请求
    
    @Override
    public int getOrder() {
        return 100; // 返回顺序值
    }
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        
        String clientIp = getClientIpAddress(request);
        
        if (!rateLimiter.tryAcquire()) {
            response.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
            response.getWriter().write("Rate limit exceeded for IP: " + clientIp);
            return;
        }
        
        filterChain.doFilter(request, response);
    }
    
    private String getClientIpAddress(HttpServletRequest request) {
        String xForwardedFor = request.getHeader("X-Forwarded-For");
        if (xForwardedFor != null && !xForwardedFor.isEmpty()) {
            return xForwardedFor.split(",")[0].trim();
        }
        return request.getRemoteAddr();
    }
}

然后在 Security 配置中添加：

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Autowired
    private RateLimitingFilter rateLimitingFilter;
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authz -> authz
                .anyRequest().authenticated()
            )
            .formLogin(Customizer.withDefaults())
            .addFilterBefore(rateLimitingFilter, SecurityContextPersistenceFilter.class);
            
        return http.build();
    }
}

需要注意的是，仅仅实现 Ordered 接口或使用 @Order 注解并不足以将 Filter 添加到 Spring Security 的过滤器链中。你仍然需要使用 addFilterBefore() 等方法显式地将其添加到安全配置中。

方法三：自定义 SecurityFilterChain

对于更复杂的场景，你可能需要完全自定义 SecurityFilterChain。这在多租户应用或需要不同安全策略的场景中很有用。

@Configuration
@EnableWebSecurity
public class MultiSecurityConfig {

    // API 安全配置 - 用于 REST API
    @Bean
    @Order(1)
    public SecurityFilterChain apiSecurityFilterChain(HttpSecurity http) throws Exception {
        ApiKeyAuthFilter apiKeyAuthFilter = new ApiKeyAuthFilter();
        
        http
            .securityMatcher("/api/**") // 只匹配 /api/** 路径
            .authorizeHttpRequests(authz -> authz
                .anyRequest().authenticated()
            )
            .addFilterBefore(apiKeyAuthFilter, BearerTokenAuthenticationFilter.class)
            .csrf(csrf -> csrf.disable()) // API 通常禁用 CSRF
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS));
                
        return http.build();
    }
    
    // Web 安全配置 - 用于 Web 页面
    @Bean
    @Order(2)
    public SecurityFilterChain webSecurityFilterChain(HttpSecurity http) throws Exception {
        http
            .securityMatcher("/web/**", "/login", "/logout") // 匹配 Web 路径
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/login").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .permitAll()
            )
            .logout(logout -> logout
                .logoutUrl("/logout")
                .permitAll()
            );
            
        return http.build();
    }
    
    // 默认安全配置 - 捕获所有其他请求
    @Bean
    @Order(3)
    public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authz -> authz
                .anyRequest().denyAll() // 默认拒绝所有
            );
        return http.build();
    }
}

API Key 认证过滤器实现：

public class ApiKeyAuthFilter extends OncePerRequestFilter {
    
    private static final String API_KEY_HEADER = "X-API-KEY";
    private static final String VALID_API_KEY = "your-secret-api-key";
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        
        String apiKey = request.getHeader(API_KEY_HEADER);
        
        if (apiKey == null || !apiKey.equals(VALID_API_KEY)) {
            response.setStatus(HttpStatus.UNAUTHORIZED.value());
            response.getWriter().write("Invalid or missing API key");
            return;
        }
        
        // 创建认证对象
        UsernamePasswordAuthenticationToken authentication = 
            new UsernamePasswordAuthenticationToken("api-user", null, 
                AuthorityUtils.createAuthorityList("ROLE_API_USER"));
        authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
        
        // 设置到 SecurityContext
        SecurityContextHolder.getContext().setAuthentication(authentication);
        
        filterChain.doFilter(request, response);
    }
}

这种方法的优势在于可以为不同的 URL 路径配置完全不同的安全策略和过滤器链。

方法四：使用 DelegatingFilterProxy 和自定义 FilterChainProxy

在极少数情况下，你可能需要完全控制 FilterChainProxy 的创建过程。这通常用于非常复杂的集成场景。

@Configuration
public class CustomFilterChainProxyConfig {

    @Bean
    public Filter springSecurityFilterChain() {
        // 创建自定义的 SecurityFilterChain
        List<SecurityFilterChain> securityFilterChains = new ArrayList<>();
        
        // 创建过滤器列表
        List<Filter> filters = new ArrayList<>();
        filters.add(new SecurityContextPersistenceFilter());
        filters.add(new CustomIpWhitelistFilter());
        filters.add(new HeaderWriterFilter());
        filters.add(new CustomApiKeyAuthFilter());
        filters.add(new ExceptionTranslationFilter(new Http403ForbiddenEntryPoint()));
        filters.add(new FilterSecurityInterceptor());
        
        // 创建 SecurityFilterChain
        SecurityFilterChain customChain = new DefaultSecurityFilterChain(
            new AntPathRequestMatcher("/**"), 
            filters
        );
        securityFilterChains.add(customChain);
        
        // 创建 FilterChainProxy
        FilterChainProxy filterChainProxy = new FilterChainProxy(securityFilterChains);
        filterChainProxy.setFilterChainValidator(new NullFilterChainValidator());
        
        return filterChainProxy;
    }
}

这种方法提供了最大的灵活性，但也失去了 Spring Security 自动配置的便利性，通常不推荐在普通应用中使用。

实际案例：构建多层安全防护体系

让我们通过一个完整的实际案例来演示如何综合运用上述方法，构建一个多层安全防护体系。

业务需求

假设我们正在开发一个企业级应用，需要满足以下安全要求：

IP 白名单：只有公司内网 IP 才能访问管理后台
速率限制：防止暴力破解攻击
多因素认证：管理员登录需要短信验证码
API Key 认证：第三方系统通过 API Key 访问 REST API
详细审计日志：记录所有敏感操作

解决方案设计

我们需要构建两条独立的安全过滤器链：

Web 过滤器链：处理 Web 页面访问，包含 IP 白名单、速率限制、MFA 等
API 过滤器链：处理 REST API 访问，包含 API Key 认证和速率限制

代码实现

首先，定义共享的组件：

// 速率限制器
@Component
public class RateLimiterService {
    
    private final Map<String, RateLimiter> ipRateLimiters = new ConcurrentHashMap<>();
    private final double permitsPerSecond = 5.0; // 每秒5个请求
    
    public boolean tryAcquire(String ip) {
        RateLimiter rateLimiter = ipRateLimiters.computeIfAbsent(ip, 
            k -> RateLimiter.create(permitsPerSecond));
        return rateLimiter.tryAcquire();
    }
    
    public void clearExpired() {
        // 清理长时间未使用的限流器（可选）
        ipRateLimiters.entrySet().removeIf(entry -> 
            System.currentTimeMillis() - entry.getValue().getLastAccessTime() > 3600000);
    }
}

// 审计日志服务
@Service
public class AuditLogService {
    
    private static final Logger logger = LoggerFactory.getLogger(AuditLogService.class);
    
    public void logAccess(String username, String ipAddress, String method, 
                         String uri, int status, long duration) {
        logger.info("ACCESS_LOG: user={}, ip={}, method={}, uri={}, status={}, duration={}ms", 
                   username, ipAddress, method, uri, status, duration);
    }
    
    public void logSecurityEvent(String eventType, String username, String ipAddress, String details) {
        logger.warn("SECURITY_EVENT: type={}, user={}, ip={}, details={}", 
                   eventType, username, ipAddress, details);
    }
}

接下来，实现各个自定义过滤器：

// IP 白名单过滤器
public class IpWhitelistFilter extends OncePerRequestFilter {
    
    private final Set<String> whitelistedIps;
    private final AuditLogService auditLogService;
    
    public IpWhitelistFilter(Set<String> whitelistedIps, AuditLogService auditLogService) {
        this.whitelistedIps = whitelistedIps;
        this.auditLogService = auditLogService;
    }
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        
        String clientIp = getClientIpAddress(request);
        
        if (!whitelistedIps.contains(clientIp)) {
            auditLogService.logSecurityEvent("IP_BLOCKED", "unknown", clientIp, 
                                           "IP not in whitelist");
            response.setStatus(HttpStatus.FORBIDDEN.value());
            response.getWriter().write("Access denied from IP: " + clientIp);
            return;
        }
        
        filterChain.doFilter(request, response);
    }
    
    private String getClientIpAddress(HttpServletRequest request) {
        String xForwardedFor = request.getHeader("X-Forwarded-For");
        if (xForwardedFor != null && !xForwardedFor.isEmpty()) {
            return xForwardedFor.split(",")[0].trim();
        }
        return request.getRemoteAddr();
    }
}

// 速率限制过滤器
public class RateLimitingFilter extends OncePerRequestFilter {
    
    private final RateLimiterService rateLimiterService;
    private final AuditLogService auditLogService;
    
    public RateLimitingFilter(RateLimiterService rateLimiterService, 
                            AuditLogService auditLogService) {
        this.rateLimiterService = rateLimiterService;
        this.auditLogService = auditLogService;
    }
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        
        String clientIp = getClientIpAddress(request);
        
        if (!rateLimiterService.tryAcquire(clientIp)) {
            auditLogService.logSecurityEvent("RATE_LIMIT_EXCEEDED", "unknown", clientIp, 
                                           "Too many requests");
            response.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
            response.getWriter().write("Rate limit exceeded");
            return;
        }
        
        filterChain.doFilter(request, response);
    }
    
    private String getClientIpAddress(HttpServletRequest request) {
        String xForwardedFor = request.getHeader("X-Forwarded-For");
        if (xForwardedFor != null && !xForwardedFor.isEmpty()) {
            return xForwardedFor.split(",")[0].trim();
        }
        return request.getRemoteAddr();
    }
}

// 多因素认证过滤器
public class MfaVerificationFilter extends OncePerRequestFilter {
    
    private final AuditLogService auditLogService;
    
    public MfaVerificationFilter(AuditLogService auditLogService) {
        this.auditLogService = auditLogService;
    }
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        
        // 只处理 POST /mfa-verify 请求
        if (!"POST".equals(request.getMethod()) || 
            !"/mfa-verify".equals(request.getRequestURI())) {
            filterChain.doFilter(request, response);
            return;
        }
        
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        
        // 检查是否已经通过初始认证
        if (authentication == null || !authentication.isAuthenticated()) {
            response.setStatus(HttpStatus.UNAUTHORIZED.value());
            response.getWriter().write("Initial authentication required");
            return;
        }
        
        // 验证 MFA 代码
        String mfaCode = request.getParameter("mfaCode");
        String expectedCode = getExpectedMfaCode(authentication.getName());
        
        if (mfaCode == null || !mfaCode.equals(expectedCode)) {
            auditLogService.logSecurityEvent("MFA_FAILED", authentication.getName(), 
                                           getClientIpAddress(request), "Invalid MFA code");
            response.setStatus(HttpStatus.UNAUTHORIZED.value());
            response.getWriter().write("Invalid MFA code");
            return;
        }
        
        // MFA 验证成功，更新认证状态
        List<GrantedAuthority> authorities = new ArrayList<>(authentication.getAuthorities());
        authorities.add(new SimpleGrantedAuthority("MFA_VERIFIED"));
        
        UsernamePasswordAuthenticationToken newAuth = 
            new UsernamePasswordAuthenticationToken(
                authentication.getPrincipal(),
                authentication.getCredentials(),
                authorities
            );
        newAuth.setDetails(authentication.getDetails());
        
        SecurityContextHolder.getContext().setAuthentication(newAuth);
        
        // 重定向到主页
        response.sendRedirect("/dashboard");
    }
    
    private String getExpectedMfaCode(String username) {
        // 从缓存或数据库中获取预期的 MFA 代码
        // 这里简化为固定值
        return "123456";
    }
    
    private String getClientIpAddress(HttpServletRequest request) {
        String xForwardedFor = request.getHeader("X-Forwarded-For");
        if (xForwardedFor != null && !xForwardedFor.isEmpty()) {
            return xForwardedFor.split(",")[0].trim();
        }
        return request.getRemoteAddr();
    }
}

// API Key 认证过滤器
public class ApiKeyAuthenticationFilter extends OncePerRequestFilter {
    
    private final String apiKeyHeader;
    private final String validApiKey;
    private final AuditLogService auditLogService;
    
    public ApiKeyAuthenticationFilter(String apiKeyHeader, String validApiKey, 
                                    AuditLogService auditLogService) {
        this.apiKeyHeader = apiKeyHeader;
        this.validApiKey = validApiKey;
        this.auditLogService = auditLogService;
    }
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        
        String apiKey = request.getHeader(apiKeyHeader);
        
        if (apiKey == null || !apiKey.equals(validApiKey)) {
            String clientIp = getClientIpAddress(request);
            auditLogService.logSecurityEvent("API_KEY_INVALID", "unknown", clientIp, 
                                           "Invalid or missing API key");
            response.setStatus(HttpStatus.UNAUTHORIZED.value());
            response.getWriter().write("Invalid API key");
            return;
        }
        
        // 创建认证对象
        UsernamePasswordAuthenticationToken authentication = 
            new UsernamePasswordAuthenticationToken("api-client", null, 
                AuthorityUtils.createAuthorityList("ROLE_API_CLIENT"));
        authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
        
        SecurityContextHolder.getContext().setAuthentication(authentication);
        
        filterChain.doFilter(request, response);
    }
    
    private String getClientIpAddress(HttpServletRequest request) {
        String xForwardedFor = request.getHeader("X-Forwarded-For");
        if (xForwardedFor != null && !xForwardedFor.isEmpty()) {
            return xForwardedFor.split(",")[0].trim();
        }
        return request.getRemoteAddr();
    }
}

// 审计日志过滤器
public class AuditLogFilter extends OncePerRequestFilter {
    
    private final AuditLogService auditLogService;
    
    public AuditLogFilter(AuditLogService auditLogService) {
        this.auditLogService = auditLogService;
    }
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        
        long startTime = System.currentTimeMillis();
        String method = request.getMethod();
        String uri = request.getRequestURI();
        String clientIp = getClientIpAddress(request);
        
        try {
            filterChain.doFilter(request, response);
        } finally {
            // 记录审计日志
            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
            String username = authentication != null ? authentication.getName() : "anonymous";
            int status = response.getStatus();
            long duration = System.currentTimeMillis() - startTime;
            
            auditLogService.logAccess(username, clientIp, method, uri, status, duration);
        }
    }
    
    private String getClientIpAddress(HttpServletRequest request) {
        String xForwardedFor = request.getHeader("X-Forwarded-For");
        if (xForwardedFor != null && !xForwardedFor.isEmpty()) {
            return xForwardedFor.split(",")[0].trim();
        }
        return request.getRemoteAddr();
    }
}

现在，配置多条安全过滤器链：

@Configuration
@EnableWebSecurity
public class EnterpriseSecurityConfig {

    @Value("${security.ip-whitelist:192.168.0.0/16,10.0.0.0/8}")
    private String ipWhitelist;
    
    @Value("${security.api-key:secret-api-key}")
    private String apiKey;
    
    private final RateLimiterService rateLimiterService;
    private final AuditLogService auditLogService;
    
    public EnterpriseSecurityConfig(RateLimiterService rateLimiterService, 
                                 AuditLogService auditLogService) {
        this.rateLimiterService = rateLimiterService;
        this.auditLogService = auditLogService;
    }
    
    // 管理后台安全配置
    @Bean
    @Order(1)
    public SecurityFilterChain adminSecurityFilterChain(HttpSecurity http) throws Exception {
        Set<String> whitelistedIps = parseIpWhitelist(ipWhitelist);
        
        IpWhitelistFilter ipWhitelistFilter = new IpWhitelistFilter(whitelistedIps, auditLogService);
        RateLimitingFilter rateLimitingFilter = new RateLimitingFilter(rateLimiterService, auditLogService);
        MfaVerificationFilter mfaVerificationFilter = new MfaVerificationFilter(auditLogService);
        AuditLogFilter auditLogFilter = new AuditLogFilter(auditLogService);
        
        http
            .securityMatcher("/admin/**", "/mfa-verify")
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/admin/login").permitAll()
                .requestMatchers("/mfa-verify").authenticated()
                .anyRequest().hasAuthority("MFA_VERIFIED")
            )
            .formLogin(form -> form
                .loginPage("/admin/login")
                .loginProcessingUrl("/admin/login")
                .defaultSuccessUrl("/mfa-required", true)
                .permitAll()
            )
            .logout(logout -> logout
                .logoutUrl("/admin/logout")
                .logoutSuccessUrl("/admin/login")
                .permitAll()
            )
            .sessionManagement(session -> session
                .maximumSessions(1)
                .expiredUrl("/admin/login?expired")
            )
            // 添加自定义过滤器
            .addFilterBefore(ipWhitelistFilter, SecurityContextPersistenceFilter.class)
            .addFilterAfter(rateLimitingFilter, IpWhitelistFilter.class)
            .addFilterAfter(mfaVerificationFilter, UsernamePasswordAuthenticationFilter.class)
            .addFilterAfter(auditLogFilter, FilterSecurityInterceptor.class);
            
        return http.build();
    }
    
    // API 安全配置
    @Bean
    @Order(2)
    public SecurityFilterChain apiSecurityFilterChain(HttpSecurity http) throws Exception {
        RateLimitingFilter rateLimitingFilter = new RateLimitingFilter(rateLimiterService, auditLogService);
        ApiKeyAuthenticationFilter apiKeyAuthFilter = new ApiKeyAuthenticationFilter(
            "X-API-Key", apiKey, auditLogService);
        AuditLogFilter auditLogFilter = new AuditLogFilter(auditLogService);
        
        http
            .securityMatcher("/api/**")
            .authorizeHttpRequests(authz -> authz
                .anyRequest().authenticated()
            )
            .addFilterBefore(rateLimitingFilter, SecurityContextPersistenceFilter.class)
            .addFilterAfter(apiKeyAuthFilter, RateLimitingFilter.class)
            .addFilterAfter(auditLogFilter, ApiKeyAuthenticationFilter.class)
            .csrf(csrf -> csrf.disable())
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS));
                
        return http.build();
    }
    
    // 默认安全配置
    @Bean
    @Order(3)
    public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authz -> authz
                .anyRequest().denyAll()
            );
        return http.build();
    }
    
    private Set<String> parseIpWhitelist(String ipWhitelist) {
        return Arrays.stream(ipWhitelist.split(","))
                    .map(String::trim)
                    .collect(Collectors.toSet());
    }
}

还需要配置一些辅助的 Controller：

@Controller
public class AdminController {
    
    @GetMapping("/admin/login")
    public String loginPage() {
        return "admin/login";
    }
    
    @GetMapping("/mfa-required")
    public String mfaRequiredPage() {
        return "admin/mfa-required";
    }
    
    @PostMapping("/mfa-verify")
    public String verifyMfa() {
        // 这个请求会被 MfaVerificationFilter 处理
        // 如果验证成功，会被重定向到 /dashboard
        return "redirect:/dashboard";
    }
    
    @GetMapping("/admin/dashboard")
    @PreAuthorize("hasAuthority('MFA_VERIFIED')")
    public String dashboard() {
        return "admin/dashboard";
    }
}

@RestController
@RequestMapping("/api")
public class ApiController {
    
    @GetMapping("/users")
    public List<String> getUsers() {
        return Arrays.asList("user1", "user2", "user3");
    }
    
    @PostMapping("/orders")
    public String createOrder(@RequestBody Map<String, Object> order) {
        return "Order created successfully";
    }
}

这个完整的案例展示了如何在实际项目中综合运用各种自定义过滤器顺序的技术，构建一个多层次、全方位的安全防护体系。

常见陷阱和最佳实践

在自定义 Spring Security 过滤器顺序的过程中，开发者经常会遇到一些陷阱。了解这些陷阱并遵循最佳实践可以帮助你避免常见错误。

常见陷阱

1. 混淆 Servlet Filter 和 Spring Security Filter

如前所述，Spring Security Filter 和普通的 Servlet Filter 是不同的概念。直接将自定义 Filter 注册为 Spring Bean 会导致它被添加到 Servlet 容器的过滤器链中，而不是 Spring Security 的过滤器链中。

错误做法：

@Component
public class MyCustomFilter extends OncePerRequestFilter {
    // ...
}

// 这样注册会让 Filter 成为 Servlet Filter，而不是 Security Filter

正确做法：

// 不要使用 @Component
public class MyCustomFilter extends OncePerRequestFilter {
    // ...
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        MyCustomFilter myCustomFilter = new MyCustomFilter();
        http.addFilterBefore(myCustomFilter, UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }
}

2. 忘记调用 filterChain.doFilter()

在自定义 Filter 中，如果在某些条件下提前返回（如拒绝请求），一定要确保不要调用 filterChain.doFilter()。反之，如果要继续处理请求，必须调用它。

错误做法：

@Override
protected void doFilterInternal(HttpServletRequest request, 
                              HttpServletResponse response, 
                              FilterChain filterChain) throws ServletException, IOException {
    if (!isValidRequest(request)) {
        response.sendError(HttpStatus.BAD_REQUEST.value());
        // 忘记 return，会导致继续执行后续过滤器
    }
    filterChain.doFilter(request, response); // 这行不应该执行
}

正确做法：

@Override
protected void doFilterInternal(HttpServletRequest request, 
                              HttpServletResponse response, 
                              FilterChain filterChain) throws ServletException, IOException {
    if (!isValidRequest(request)) {
        response.sendError(HttpStatus.BAD_REQUEST.value());
        return; // 重要：提前返回
    }
    filterChain.doFilter(request, response);
}

3. 在错误的位置设置 SecurityContext

SecurityContextPersistenceFilter 负责在请求开始时加载 SecurityContext，在请求结束时保存它。如果你的自定义 Filter 在它之前执行，那么你在其中设置的 Authentication 会被覆盖。

错误做法：

// 在 SecurityContextPersistenceFilter 之前设置认证
http.addFilterBefore(customAuthFilter, SecurityContextPersistenceFilter.class);

正确做法：

// 在 SecurityContextPersistenceFilter 之后设置认证
http.addFilterAfter(customAuthFilter, SecurityContextPersistenceFilter.class);

4. 忽略异常处理

自定义 Filter 中可能抛出异常，如果没有适当的异常处理，可能会导致 500 错误而不是友好的错误页面。

改进做法：

@Override
protected void doFilterInternal(HttpServletRequest request, 
                              HttpServletResponse response, 
                              FilterChain filterChain) throws ServletException, IOException {
    try {
        // 自定义逻辑
        processRequest(request, response);
        filterChain.doFilter(request, response);
    } catch (CustomSecurityException e) {
        // 转换为 Spring Security 异常，以便 ExceptionTranslationFilter 处理
        throw new BadCredentialsException("Custom security error", e);
    }
}

最佳实践

1. 继承 OncePerRequestFilter

Spring 提供了 OncePerRequestFilter 抽象类，它确保每个请求只被过滤一次（即使在转发或包含的情况下）。建议所有自定义 Filter 都继承这个类。

public class CustomSecurityFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        // 实现具体的过滤逻辑
    }
}

2. 使用构造函数注入依赖

避免在 Filter 中使用字段注入，因为 Filter 可能不是 Spring Bean。使用构造函数注入来传递依赖。

public class RateLimitingFilter extends OncePerRequestFilter {
    
    private final RateLimiterService rateLimiterService;
    
    // 构造函数注入
    public RateLimitingFilter(RateLimiterService rateLimiterService) {
        this.rateLimiterService = rateLimiterService;
    }
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        // 使用注入的服务
        if (!rateLimiterService.tryAcquire(getClientIp(request))) {
            // ...
        }
    }
}

3. 考虑线程安全性

Filter 实例通常是单例的，会被多个线程同时调用。确保你的 Filter 是线程安全的，避免使用实例变量存储请求相关数据。

// 错误：实例变量在多线程环境下不安全
public class UnsafeFilter extends OncePerRequestFilter {
    private String currentRequestData; // 危险！
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        currentRequestData = request.getParameter("data"); // 线程不安全
        // ...
    }
}

// 正确：使用局部变量
public class SafeFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        String currentRequestData = request.getParameter("data"); // 安全
        // ...
    }
}

4. 合理选择插入位置

仔细考虑你的自定义 Filter 应该插入到哪个位置。参考 Spring Security 的默认过滤器顺序，选择合适的锚点 Filter。

// 对于认证前的检查（如 IP 白名单、速率限制）
http.addFilterBefore(customFilter, SecurityContextPersistenceFilter.class);

// 对于认证后的处理（如审计日志、额外验证）
http.addFilterAfter(customFilter, UsernamePasswordAuthenticationFilter.class);

// 对于替换默认功能
http.addFilterAt(customFilter, CsrfFilter.class);

5. 充分测试过滤器顺序

编写集成测试来验证过滤器的执行顺序是否符合预期。

@SpringBootTest
@AutoConfigureTestDatabase
@Import(TestSecurityConfig.class)
class FilterOrderTest {

    @Autowired
    private MockMvc mockMvc;
    
    @Test
    void testIpWhitelistBlocksInvalidIp() throws Exception {
        mockMvc.perform(get("/admin/dashboard")
                .header("X-Forwarded-For", "1.2.3.4")) // 非白名单 IP
                .andExpect(status().isForbidden())
                .andExpect(content().string(containsString("Access denied")));
    }
    
    @Test
    void testRateLimitingWorks() throws Exception {
        // 发送超过限制的请求
        for (int i = 0; i < 10; i++) {
            mockMvc.perform(get("/api/users")
                    .header("X-API-Key", "valid-key"))
                    .andExpect(status().isOk());
        }
        
        // 第11个请求应该被限流
        mockMvc.perform(get("/api/users")
                .header("X-API-Key", "valid-key"))
                .andExpect(status().isTooManyRequests());
    }
}

高级主题：动态过滤器链和条件过滤

在某些高级场景中，你可能需要根据运行时条件动态调整过滤器链，或者有条件地启用/禁用某些过滤器。

动态 SecurityFilterChain

你可以创建一个动态的 SecurityFilterChain，根据请求属性或其他条件决定使用哪条过滤器链。

@Configuration
@EnableWebSecurity
public class DynamicSecurityConfig {

    @Bean
    @Order(1)
    public SecurityFilterChain dynamicSecurityFilterChain(HttpSecurity http) throws Exception {
        http
            .securityMatcher(new RequestMatcher() {
                @Override
                public boolean matches(HttpServletRequest request) {
                    // 根据请求头、参数或其他条件动态匹配
                    String tenantId = request.getHeader("X-Tenant-ID");
                    return tenantId != null && isValidTenant(tenantId);
                }
            })
            .authorizeHttpRequests(authz -> authz
                .anyRequest().authenticated()
            )
            .addFilterBefore(new TenantValidationFilter(), SecurityContextPersistenceFilter.class);
            
        return http.build();
    }
    
    private boolean isValidTenant(String tenantId) {
        // 验证租户 ID 是否有效
        return tenantId.matches("^[a-zA-Z0-9]+$");
    }
}

条件过滤器启用

使用 Spring 的 @ConditionalOnProperty 或其他条件注解来控制过滤器的启用。

@Configuration
@EnableWebSecurity
public class ConditionalSecurityConfig {

    @Bean
    @ConditionalOnProperty(name = "security.mfa.enabled", havingValue = "true", matchIfMissing = false)
    public MfaVerificationFilter mfaVerificationFilter(AuditLogService auditLogService) {
        return new MfaVerificationFilter(auditLogService);
    }
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http, 
                                         @Autowired(required = false) MfaVerificationFilter mfaFilter) 
                                         throws Exception {
        http
            .authorizeHttpRequests(authz -> authz
                .anyRequest().authenticated()
            )
            .formLogin(Customizer.withDefaults());
            
        // 仅在 MFA 过滤器存在时添加
        if (mfaFilter != null) {
            http.addFilterAfter(mfaFilter, UsernamePasswordAuthenticationFilter.class);
        }
        
        return http.build();
    }
}

然后在 application.yml 中控制：

security:
  mfa:
    enabled: true

运行时过滤器修改

在极少数情况下，你可能需要在运行时修改过滤器链。这可以通过访问 FilterChainProxy 来实现。

@Service
public class RuntimeFilterChainModifier {
    
    @Autowired
    private FilterChainProxy springSecurityFilterChain;
    
    public void addRuntimeFilter(Filter newFilter, Class<? extends Filter> beforeFilter) {
        List<SecurityFilterChain> filterChains = springSecurityFilterChain.getFilterChains();
        
        for (SecurityFilterChain chain : filterChains) {
            if (chain instanceof DefaultSecurityFilterChain) {
                DefaultSecurityFilterChain defaultChain = (DefaultSecurityFilterChain) chain;
                List<Filter> filters = new ArrayList<>(defaultChain.getFilters());
                
                // 找到插入位置
                int insertIndex = -1;
                for (int i = 0; i < filters.size(); i++) {
                    if (beforeFilter.isInstance(filters.get(i))) {
                        insertIndex = i;
                        break;
                    }
                }
                
                if (insertIndex != -1) {
                    filters.add(insertIndex, newFilter);
                    // 注意：这里需要反射或其他方式来修改私有字段
                    // 实际上不推荐这样做，因为 FilterChainProxy 的过滤器列表通常是不可变的
                }
            }
        }
    }
}

注意：运行时修改过滤器链是非常危险的操作，通常不推荐。更好的做法是在应用启动时就确定好过滤器链的结构。

性能考虑和监控

自定义过滤器不仅影响安全性，还可能影响应用性能。以下是一些性能相关的考虑和监控建议。

性能优化建议

1. 快速失败原则

将轻量级的检查放在过滤器链的前面，实现快速失败。

// 好的做法：先检查 IP 白名单（轻量级），再进行速率限制（稍微重一些），最后进行认证（最重）
http
    .addFilterBefore(ipWhitelistFilter, SecurityContextPersistenceFilter.class)
    .addFilterAfter(rateLimitingFilter, IpWhitelistFilter.class)
    .addFilterAfter(authenticationFilter, RateLimitingFilter.class);

2. 缓存昂贵的操作

如果过滤器中包含昂贵的操作（如数据库查询），考虑使用缓存。

public class CachedApiKeyValidator {
    
    private final LoadingCache<String, Boolean> apiKeyCache = 
        CacheBuilder.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .build(new CacheLoader<String, Boolean>() {
                @Override
                public Boolean load(String apiKey) throws Exception {
                    return validateApiKeyInDatabase(apiKey);
                }
            });
    
    public boolean isValid(String apiKey) {
        try {
            return apiKeyCache.get(apiKey);
        } catch (ExecutionException e) {
            return false;
        }
    }
}

3. 异步非阻塞操作

对于不影响安全决策的操作（如审计日志），考虑使用异步处理。

public class AsyncAuditLogFilter extends OncePerRequestFilter {
    
    private final ExecutorService executor = Executors.newFixedThreadPool(4);
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        
        long startTime = System.currentTimeMillis();
        
        filterChain.doFilter(request, response);
        
        // 异步记录审计日志
        executor.submit(() -> {
            try {
                recordAuditLog(request, response, System.currentTimeMillis() - startTime);
            } catch (Exception e) {
                // 记录日志错误，但不要影响主流程
                logger.error("Failed to record audit log", e);
            }
        });
    }
}

监控和指标

为自定义过滤器添加监控指标，便于性能分析和问题排查。

public class MonitoredRateLimitingFilter extends OncePerRequestFilter {
    
    private final MeterRegistry meterRegistry;
    private final Counter allowedRequests;
    private final Counter blockedRequests;
    private final Timer processingTime;
    
    public MonitoredRateLimitingFilter(RateLimiterService rateLimiterService, 
                                     MeterRegistry meterRegistry) {
        this.rateLimiterService = rateLimiterService;
        this.meterRegistry = meterRegistry;
        this.allowedRequests = Counter.builder("security.requests.allowed")
                                    .register(meterRegistry);
        this.blockedRequests = Counter.builder("security.requests.blocked")
                                    .register(meterRegistry);
        this.processingTime = Timer.builder("security.filter.processing.time")
                                 .register(meterRegistry);
    }
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        
        Timer.Sample sample = Timer.start(meterRegistry);
        
        try {
            String clientIp = getClientIpAddress(request);
            
            if (!rateLimiterService.tryAcquire(clientIp)) {
                blockedRequests.increment();
                response.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
                return;
            }
            
            allowedRequests.increment();
            filterChain.doFilter(request, response);
            
        } finally {
            sample.stop(processingTime);
        }
    }
}

使用 Micrometer 这样的指标库可以轻松集成到各种监控系统中，如 Prometheus、Datadog 等。

总结与展望

通过本文的深入探讨，我们全面了解了 Spring Security 过滤器执行顺序的自定义配置。从基本概念到高级技巧，从理论原理到实际案例，我们覆盖了这一主题的各个方面。

关键要点回顾

理解过滤器链的重要性：Spring Security 的核心是过滤器链，正确理解其执行顺序是自定义配置的基础。

掌握多种自定义方法：

addFilterBefore()、addFilterAfter()、addFilterAt() 是最常用的方法
实现 Ordered 接口或使用 @Order 注解可以指定顺序值
多 SecurityFilterChain 配置适用于复杂场景
完全自定义 FilterChainProxy 提供最大灵活性

避免常见陷阱：

区分 Servlet Filter 和 Spring Security Filter
正确处理 filterChain.doFilter() 调用
在合适的位置设置 SecurityContext
考虑异常处理和线程安全性

遵循最佳实践：

继承 OncePerRequestFilter
使用构造函数注入依赖
合理选择插入位置
充分测试过滤器顺序

考虑性能和监控：

应用快速失败原则
缓存昂贵操作
添加监控指标

未来发展方向

随着微服务架构和云原生应用的普及，Spring Security 也在不断演进。未来的安全架构可能会更加关注：

零信任安全模型：不再假设网络边界内的请求是可信的
服务网格集成：将安全逻辑下沉到基础设施层
OAuth 2.1 和 OpenID Connect：标准化的身份认证和授权协议
响应式编程支持：在 WebFlux 环境下的安全过滤器链

Spring Security 6.0+ 已经开始支持更多的现代化安全特性，如 OAuth 2.1 和改进的响应式安全支持。作为开发者，我们需要持续学习和适应这些变化。

记住，安全是一个持续的过程，而不是一次性的配置。通过合理地自定义 Spring Security 过滤器顺序，你可以构建出既安全又灵活的应用程序，为用户提供可靠的保护。

以上就是Spring Security过滤器执行顺序的自定义配置指南的详细内容，更多关于Spring Security过滤器执行顺序的资料请关注脚本之家其它相关文章！

Spring Security过滤器执行顺序的自定义配置指南

引言

什么是 Spring Security 过滤器链？

Servlet 过滤器基础

Spring Security 如何利用过滤器链？

默认过滤器链的结构

过滤器执行顺序的重要性

为什么需要自定义过滤器执行顺序？

场景一：自定义认证逻辑

场景二：集成第三方安全服务

场景三：处理特殊的安全需求

场景四：微服务架构中的安全协调

场景五：性能优化

Spring Security 过滤器顺序的底层机制

SecurityFilterChain 的作用

FilterComparator 和 FilterOrder

FilterRegistrationBean 的影响

自定义过滤器顺序的多种方法

方法一：使用 addFilterBefore()、addFilterAfter()、addFilterAt()

addFilterBefore() - 在指定过滤器之前添加

addFilterAfter() - 在指定过滤器之后添加

addFilterAt() - 替换指定位置的过滤器

方法二：实现 Ordered 接口或使用 @Order 注解

方法三：自定义 SecurityFilterChain

方法四：使用 DelegatingFilterProxy 和自定义 FilterChainProxy

实际案例：构建多层安全防护体系

业务需求

解决方案设计

代码实现

常见陷阱和最佳实践

常见陷阱

1. 混淆 Servlet Filter 和 Spring Security Filter

2. 忘记调用 filterChain.doFilter()

3. 在错误的位置设置 SecurityContext

4. 忽略异常处理

最佳实践

1. 继承 OncePerRequestFilter

2. 使用构造函数注入依赖

3. 考虑线程安全性

4. 合理选择插入位置

5. 充分测试过滤器顺序

高级主题：动态过滤器链和条件过滤

动态 SecurityFilterChain

条件过滤器启用

运行时过滤器修改

性能考虑和监控

性能优化建议

1. 快速失败原则

2. 缓存昂贵的操作

3. 异步非阻塞操作

监控和指标

总结与展望

关键要点回顾

未来发展方向

您可能感兴趣的文章: