springboot 实现拦截器的 3 种方式介绍及异步执行的思考

本文首先为大家介绍 HTTP 请求中三种常见的拦截实现，并且比较一下其中的差异。

(1)基于 Aspect 的拦截器

(2)基于 HandlerInterceptor 的拦截器

(3)基于 ResponseBodyAdvice 的拦截器

springboot 入门案例

为了便于大家学习，我们首先从最基本的 springboot 例子讲起。

maven 引入

引入必须的 jar 包。

 
    org.springframework.boot 
    spring-boot-starter-parent 
    1.5.9.RELEASE 
 
 
 
     
        org.springframework.boot 
        spring-boot-starter-web 
     
     
        org.aspectj 
        aspectjrt 
        1.8.10 
     
     
        org.aspectj 
        aspectjweaver 
        1.8.10 
     
 
-- Package as an executable jar --> 
 
     
         
            org.springframework.boot 
            spring-boot-maven-plugin 
         
     
 

启动类

实现最简单的启动类。

@SpringBootApplication 
public class Application { 
 
    public static void main(String[] args) { 
        SpringApplication.run(Application.class, args); 
    } 
 
} 

定义 Controller

为了演示方便，我们首先实现一个简单的 controller。

@RestController 
public class IndexController { 
 
    @RequestMapping("/index") 
    public AsyncResp index() { 
        AsyncResp asyncResp = new AsyncResp(); 
        asyncResp.setResult("ok"); 
        asyncResp.setRespCode("00"); 
        asyncResp.setRespDesc("成功"); 
 
        System.out.println("IndexController#index：" + asyncResp); 
        return asyncResp; 
    } 
 
} 

其中 AsyncResp 的定义如下：

public class AsyncResp { 
 
    private String respCode; 
 
    private String respDesc; 
 
    private String result; 
 
 
    // getter & setter & toString() 
} 

拦截器定义

基于 Aspect

import org.aspectj.lang.ProceedingJoinPoint; 
import org.aspectj.lang.annotation.Around; 
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Pointcut; 
import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
import org.springframework.context.annotation.EnableAspectJAutoProxy; 
import org.springframework.stereotype.Component; 
 
import java.util.Arrays; 
 
 
@Aspect 
@Component 
@EnableAspectJAutoProxy 
public class AspectLogInterceptor { 
 
     
    private static final Logger LOG = LoggerFactory.getLogger(AspectLogInterceptor.class); 
 
     
    @Pointcut("execution(public * com.github.houbb.springboot.learn.aspect.controller..*(..))") 
    public void pointCut() { 
        // 
    } 
 
     
    @Around("pointCut()") 
    public Object around(ProceedingJoinPoint point) throws Throwable { 
        try { 
            //1. 设置 MDC 
 
            // 获取当前拦截的方法签名 
            String signatureShortStr = point.getSignature().toShortString(); 
            //2. 打印入参信息 
            Object[] args = point.getArgs(); 
            LOG.info("{} 参数: {}", signatureShortStr, Arrays.toString(args)); 
 
            //3. 打印结果 
            Object result = point.proceed(); 
            LOG.info("{} 结果: {}", signatureShortStr, result); 
            return result; 
        } finally { 
            // 移除 mdc 
        } 
    } 
 
} 

这种实现的优点是比较通用，可以结合注解实现更加灵活强大的功能。

是个人非常喜欢的一种方式。

主要用途：

(1)日志的出参/入参

(2)统一设置 TraceId

(3)方法的调用耗时统计

基于 HandlerInterceptor

import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
import org.springframework.stereotype.Component; 
import org.springframework.web.servlet.HandlerInterceptor; 
import org.springframework.web.servlet.ModelAndView; 
 
import javax.servlet.DispatcherType; 
import javax.servlet.http.HttpServletRequest; 
import javax.servlet.http.HttpServletResponse; 
 
 
@Component 
public class LogHandlerInterceptor implements HandlerInterceptor { 
 
    private Logger logger = LoggerFactory.getLogger(LogHandlerInterceptor.class); 
 
    @Override 
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
        // 统一的权限校验、路由等 
        logger.info("LogHandlerInterceptor#preHandle 请求地址：{}", request.getRequestURI()); 
 
        if (request.getDispatcherType().equals(DispatcherType.ASYNC)) { 
            return true; 
        } 
 
        return true; 
    } 
 
    @Override 
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { 
        logger.info("LogHandlerInterceptor#postHandle 调用"); 
    } 
 
    @Override 
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { 
 
    } 
 
} 

然后需要指定对应的 url 和拦截器之间的关系才会生效：

import com.github.houbb.springboot.learn.aspect.aspect.LogHandlerInterceptor; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.context.annotation.Configuration; 
import org.springframework.web.servlet.config.annotation.InterceptorRegistry; 
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter; 
 
 
@Configuration 
public class SpringMvcConfig extends WebMvcConfigurerAdapter { 
 
    @Autowired 
    private LogHandlerInterceptor logHandlerInterceptor; 
 
    @Override 
    public void addInterceptors(InterceptorRegistry registry) { 
        registry.addInterceptor(logHandlerInterceptor) 
                .addPathPatterns(" 
@ControllerAdvice 
public class MyResponseBodyAdvice implements ResponseBodyAdvice