Spring Boot Filter、Interceptor、AOP 的使用场景与选型_filter+interceptor+aop 使用场景-优快云博客

在 Spring Boot 应用程序开发中，Filter（过滤器）、Interceptor（拦截器）和 AOP（面向切面编程）是三种常见的横切关注点实现方式。

它们各有特点和适用场景，正确的选择和使用这些技术对于构建高质量的应用程序至关重要。

一、基本概念与执行顺序

1. Filter（过滤器）

Filter 是 Servlet 规范中定义的组件，位于 Web 容器中，在请求到达 Servlet 之前和响应返回客户端之前进行处理。

@Component
public class LogFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        
        log.info("请求URL: {}", req.getRequestURI());
        
        // 继续执行过滤器链
        chain.doFilter(request, response);
        
        log.info("响应已完成");
    }
}

2. Interceptor（拦截器）

Interceptor 是 Spring MVC 框架提供的组件，位于 DispatcherServlet 之后，Controller 处理之前。

@Component
public class AuthInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, 
                            Object handler) throws Exception {
        // 在Controller方法执行前调用
        String token = request.getHeader("token");
        if (StringUtils.isEmpty(token)) {
            response.setStatus(HttpStatus.UNAUTHORIZED.value());
            return false;
        }
        return true;
    }
    
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, 
                          Object handler, ModelAndView modelAndView) throws Exception {
        // 在Controller方法执行后，视图渲染前调用
    }
    
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
                               Object handler, Exception ex) throws Exception {
        // 在整个请求完成后调用
    }
}

3. AOP（面向切面编程）

AOP 是 Spring 框架提供的一种编程范式，可以在不修改源代码的情况下为方法添加功能。

@Aspect
@Component
public class PerformanceAspect {
    @Around("execution(* com.example.service.*.*(..))")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        
        Object result = joinPoint.proceed();
        
        long executionTime = System.currentTimeMillis() - start;
        log.info("{} 执行耗时 {} ms", joinPoint.getSignature(), executionTime);
        
        return result;
    }
}

执行顺序

请求处理的顺序为：Filter -> Interceptor -> AOP -> Controller -> AOP -> Interceptor -> Filter

二、使用场景对比

特性	Filter	Interceptor	AOP
作用范围	所有请求	匹配的URL请求	指定的方法
实现层面	Servlet容器	Spring MVC	Spring容器
能否获取方法及类信息	否	是	是
应用场景	请求过滤、字符编码等	用户认证、日志记录等	事务、日志、权限等

三、使用场景分析

1. Filter 适用场景

请求/响应预处理：如字符编码设置、CORS跨域处理 请求内容转换：如请求体解析、加解密 身份验证：如JWT令牌验证 日志记录：记录所有请求的访问日志 敏感信息过滤：过滤敏感词汇

@Component
public class EncodingFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
            throws IOException, ServletException {
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");
        chain.doFilter(request, response);
    }
}

2. Interceptor 适用场景

用户认证：检查用户是否已登录 权限控制：检查用户是否有权限访问特定资源 性能监控：监控控制器方法执行时间 日志记录：记录请求处理过程中的详细信息 国际化处理：根据请求设置语言环境

@Component
public class PermissionInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, 
                            Object handler) throws Exception {
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }
        
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        RequiresPermission annotation = handlerMethod.getMethodAnnotation(RequiresPermission.class);
        
        if (annotation != null) {
            String requiredPermission = annotation.value();
            // 检查用户权限
            if (!hasPermission(request, requiredPermission)) {
                response.setStatus(HttpStatus.FORBIDDEN.value());
                return false;
            }
        }
        
        return true;
    }
    
    private boolean hasPermission(HttpServletRequest request, String permission) {
        // 权限检查逻辑
        return true;
    }
}

3. AOP 适用场景

事务管理：方法执行前开启事务，执行后提交或回滚 方法性能监控：记录方法执行时间 日志记录：记录方法调用的参数和返回值 缓存处理：方法执行前查询缓存，执行后更新缓存 异常处理：统一处理特定异常

@Aspect
@Component
public class CacheAspect {
    @Autowired
    private CacheManager cacheManager;
    
    @Around("@annotation(com.example.annotation.Cacheable)")
    public Object cache(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        Cacheable cacheable = method.getAnnotation(Cacheable.class);
        
        String cacheKey = generateCacheKey(joinPoint, cacheable);
        Object cachedValue = cacheManager.get(cacheKey);
        
        if (cachedValue != null) {
            return cachedValue;
        }
        
        Object result = joinPoint.proceed();
        cacheManager.put(cacheKey, result);
        
        return result;
    }
    
    private String generateCacheKey(ProceedingJoinPoint joinPoint, Cacheable cacheable) {
        // 生成缓存键
        return cacheable.value();
    }
}