拦截器与过滤器

Spring MVC 提供了两种强大的请求处理组件：拦截器（Interceptor）和过滤器（Filter）。这两个组件都允许在请求处理的不同阶段执行自定义代码，但它们有不同的工作方式、作用范围和使用场景。本文将详细介绍这两种组件的特点以及如何有效使用它们。

拦截器（Interceptor）

拦截器是 Spring MVC 框架的一部分，它允许在请求处理的不同阶段执行代码，实现了 AOP（面向切面编程）的思想。

拦截器的工作原理

拦截器基于 Java 的反射机制，只能拦截 Controller 中的方法。拦截器在请求处理过程中有三个执行点：

preHandle：在 Controller 处理请求前执行
postHandle：在 Controller 处理请求后、视图渲染前执行
afterCompletion：在整个请求处理完成后执行，包括视图渲染结束后

拦截器的实现方式

实现 HandlerInterceptor 接口

java

public class LoggingInterceptor implements HandlerInterceptor {
    
    private static final Logger logger = LoggerFactory.getLogger(LoggingInterceptor.class);
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, 
            Object handler) throws Exception {
        request.setAttribute("startTime", System.currentTimeMillis());
        logger.info("Incoming request to: {} {}", request.getMethod(), request.getRequestURI());
        
        // 如果返回false，请求将被中断
        return true;
    }
    
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, 
            Object handler, ModelAndView modelAndView) throws Exception {
        
        logger.info("Request processed, ModelAndView: {}", modelAndView);
        
        // 这里可以修改ModelAndView
        if (modelAndView != null) {
            modelAndView.addObject("serverTime", LocalDateTime.now().toString());
        }
    }
    
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
            Object handler, Exception ex) throws Exception {
            
        long startTime = (Long) request.getAttribute("startTime");
        long executionTime = System.currentTimeMillis() - startTime;
        
        logger.info("Completed {} {} in {}ms", 
                request.getMethod(), request.getRequestURI(), executionTime);
        
        if (ex != null) {
            logger.error("Exception during request processing: ", ex);
        }
    }
}

继承 HandlerInterceptorAdapter 类（已弃用）

在 Spring 5.3 之前，还可以通过继承 HandlerInterceptorAdapter 类来实现拦截器。但从 Spring 5.3 开始，这个类已被标记为弃用，因为 HandlerInterceptor 接口现在有了默认方法实现。

注册拦截器

在 Spring MVC 中注册拦截器需要实现 WebMvcConfigurer 接口：

java

@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    @Autowired
    private LoggingInterceptor loggingInterceptor;
    
    @Autowired
    private SecurityInterceptor securityInterceptor;
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 添加日志拦截器，应用于所有请求
        registry.addInterceptor(loggingInterceptor)
                .addPathPatterns("/**");
        
        // 添加安全拦截器，只应用于特定路径
        registry.addInterceptor(securityInterceptor)
                .addPathPatterns("/admin/**", "/api/secured/**")
                .excludePathPatterns("/api/public/**");
    }
}

拦截器的执行顺序

当多个拦截器应用于同一个请求时，它们的执行顺序遵循以下规则：

preHandle 方法按照拦截器注册的顺序执行（从前到后）
postHandle 方法按照拦截器注册的顺序逆序执行（从后到前）
afterCompletion 方法按照拦截器注册的顺序逆序执行（从后到前）

如果某个拦截器的 preHandle 方法返回 false，则后续拦截器不会执行，并且该拦截器和之前已执行的拦截器的 postHandle 方法都不会被调用，但之前执行的拦截器的 afterCompletion 方法会被调用。

过滤器（Filter）

过滤器是 Servlet 规范的一部分，不属于 Spring 框架。它能够拦截和处理所有进入应用的请求，不仅限于 Controller 方法。

过滤器的工作原理

过滤器基于函数回调，在请求到达 Servlet 容器之前和响应离开 Servlet 容器之后执行。过滤器可以修改 HTTP 请求和响应对象，甚至可以阻止请求继续传递，直接返回响应。

过滤器的实现方式

实现 javax.servlet.Filter 接口

java

public class RequestResponseLoggingFilter implements Filter {
    
    private static final Logger logger = LoggerFactory.getLogger(RequestResponseLoggingFilter.class);
    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 过滤器初始化代码
        logger.info("Filter initialized");
    }
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
            FilterChain chain) throws IOException, ServletException {
        
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse res = (HttpServletResponse) response;
        
        logger.info("Filter processing: {} {}", req.getMethod(), req.getRequestURI());
        
        // 包装请求或响应对象（可选）
        // HttpServletRequestWrapper customRequest = new CustomRequestWrapper(req);
        
        long startTime = System.currentTimeMillis();
        
        // 继续过滤器链
        chain.doFilter(request, response);
        
        long endTime = System.currentTimeMillis();
        logger.info("Request processed in {}ms", endTime - startTime);
        
        // 后处理，此时请求已完成
    }
    
    @Override
    public void destroy() {
        // 过滤器销毁代码
        logger.info("Filter destroyed");
    }
}

注册过滤器

在 Spring Boot 中，注册过滤器可以通过以下几种方式：

使用 @Component 注解（适用于自定义过滤器）

java

@Component
public class RequestResponseLoggingFilter implements Filter {
    // 实现代码
}

使用 FilterRegistrationBean 注册

java

@Configuration
public class FilterConfig {
    
    @Bean
    public FilterRegistrationBean<RequestResponseLoggingFilter> loggingFilter() {
        FilterRegistrationBean<RequestResponseLoggingFilter> registrationBean = 
                new FilterRegistrationBean<>();
        
        registrationBean.setFilter(new RequestResponseLoggingFilter());
        registrationBean.addUrlPatterns("/*");
        registrationBean.setOrder(1);  // 设置过滤器顺序
        registrationBean.setName("loggingFilter");
        
        return registrationBean;
    }
    
    @Bean
    public FilterRegistrationBean<ContentSecurityFilter> securityFilter() {
        FilterRegistrationBean<ContentSecurityFilter> registrationBean = 
                new FilterRegistrationBean<>();
        
        registrationBean.setFilter(new ContentSecurityFilter());
        registrationBean.addUrlPatterns("/admin/*", "/secure/*");
        registrationBean.setOrder(2);  // 会在 loggingFilter 之后执行
        
        return registrationBean;
    }
}

在 web.xml 中配置（传统 Spring MVC 项目）

xml

<filter>
    <filter-name>loggingFilter</filter-name>
    <filter-class>com.example.filters.RequestResponseLoggingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>loggingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

过滤器的执行顺序

过滤器的执行顺序由其注册顺序或指定的 order 值决定。order 值越小，过滤器执行顺序越靠前。当请求进入应用时，过滤器按照顺序从前往后执行；当响应离开应用时，过滤器按照相反的顺序从后往前执行。