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

[[411912]]

springboot 拦截器

实际项目中，我们经常需要输出请求参数，响应结果，方法耗时，统一的权限校验等。

武昌ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为创新互联的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：13518219792（备注：SSL证书合作）期待与您的合作！

本文首先为大家介绍 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 
  
  
  
  
     
  
  
  
  
 
  
  
  
  
 
  
  
  
  
 
  
  
  
  
     
  
  
  
  
         
  
  
  
  
            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; 
  
  
  
  
 
  
  
  
  
/** 
  
  
  
  
 * 
  
  
  
  
 * @author binbin.hou 
  
  
  
  
 * @since 1.0.0 
  
  
  
  
 */ 
  
  
  
  
@Aspect 
  
  
  
  
@Component 
  
  
  
  
@EnableAspectJAutoProxy 
  
  
  
  
public class AspectLogInterceptor { 
  
  
  
  
 
  
  
  
  
    /** 
  
  
  
  
     * 日志实例 
  
  
  
  
     * @since 1.0.0 
  
  
  
  
     */ 
  
  
  
  
    private static final Logger LOG = LoggerFactory.getLogger(AspectLogInterceptor.class); 
  
  
  
  
 
  
  
  
  
    /** 
  
  
  
  
     * 拦截 controller 下所有的 public方法 
  
  
  
  
     */ 
  
  
  
  
    @Pointcut("execution(public * com.github.houbb.springboot.learn.aspect.controller..*(..))") 
  
  
  
  
    public void pointCut() { 
  
  
  
  
        // 
  
  
  
  
    } 
  
  
  
  
 
  
  
  
  
    /** 
  
  
  
  
     * 拦截处理 
  
  
  
  
     * 
  
  
  
  
     * @param point point 信息 
  
  
  
  
     * @return result 
  
  
  
  
     * @throws Throwable if any 
  
  
  
  
     */ 
  
  
  
  
    @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; 
  
  
  
  
 
  
  
  
  
/** 
  
  
  
  
 * @author binbin.hou 
  
  
  
  
 * @since 1.0.0 
  
  
  
  
 */ 
  
  
  
  
@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; 
  
  
  
  
 
  
  
  
  
/** 
  
  
  
  
 * spring mvc 配置 
  
  
  
  
 * @since 1.0.0 
  
  
  
  
 */ 
  
  
  
  
@Configuration 
  
  
  
  
public class SpringMvcConfig extends WebMvcConfigurerAdapter { 
  
  
  
  
 
  
  
  
  
    @Autowired 
  
  
  
  
    private LogHandlerInterceptor logHandlerInterceptor; 
  
  
  
  
 
  
  
  
  
    @Override 
  
  
  
  
    public void addInterceptors(InterceptorRegistry registry) { 
  
  
  
  
        registry.addInterceptor(logHandlerInterceptor) 
  
  
  
  
                .addPathPatterns("/**") 
  
  
  
  
                .excludePathPatterns("/version"); 
  
  
  
  
        super.addInterceptors(registry); 
  
  
  
  
    } 
  
  
  
  
 
  
  
  
  
} 
 
 
 
 

这种方式的优点就是可以根据 url 灵活指定不同的拦截器。

缺点是主要用于 Controller 层。

基于 ResponseBodyAdvice

此接口有beforeBodyWrite方法，参数body是响应对象response中的响应体，那么我们就可以用此方法来对响应体做一些统一的操作。

比如加密，签名等。

 
 
 
 

  
  
  
  
import org.slf4j.Logger; 
  
  
  
  
import org.slf4j.LoggerFactory; 
  
  
  
  
import org.springframework.core.MethodParameter; 
  
  
  
  
import org.springframework.http.MediaType; 
  
  
  
  
import org.springframework.http.converter.HttpMessageConverter; 
  
  
  
  
import org.springframework.http.server.ServerHttpRequest; 
  
  
  
  
import org.springframework.http.server.ServerHttpResponse; 
  
  
  
  
import org.springframework.http.server.ServletServerHttpRequest; 
  
  
  
  
import org.springframework.web.bind.annotation.ControllerAdvice; 
  
  
  
  
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice; 
  
  
  
  
 
  
  
  
  
import javax.servlet.http.HttpServletRequest; 
  
  
  
  
 
  
  
  
  
/** 
  
  
  
  
 * @author binbin.hou 
  
  
  
  
 * @since 1.0.0 
  
  
  
  
 */ 
  
  
  
  
@ControllerAdvice 
  
  
  
  
public class MyResponseBodyAdvice implements ResponseBodyAdvice