关于springboot:springboot-实现拦截的-3-种方式介绍及异步执行的思考

理论我的项目中，咱们常常须要输入申请参数，响应后果，办法耗时，对立的权限校验等。

本文首先为大家介绍 HTTP 申请中三种常见的拦挡实现，并且比拟一下其中的差别。

（1）基于 Aspect 的拦挡形式

（2）基于 HandlerInterceptor 的拦挡形式

（3）基于 ResponseBodyAdvice 的拦挡形式

举荐浏览：

对立日志框架: https://github.com/houbb/auto-log

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

引入必须的 jar 包。

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.8.10</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.10</version>
    </dependency>
</dependencies>
<!-- Package as an executable jar -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

实现最简略的启动类。

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

}

为了演示不便，咱们首先实现一个简略的 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()}

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）办法的调用耗时统计

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 层。

此接口有 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<Object> {

    /**
     * 日志实例
     * @since 1.0.0
     */
    private static final Logger LOG = LoggerFactory.getLogger(MyResponseBodyAdvice.class);

    @Override
    public boolean supports(MethodParameter methodParameter, Class aClass) {
        // 这个中央如果返回 false, 不会执行 beforeBodyWrite 办法
        return true;
    }

    @Override
    public Object beforeBodyWrite(Object resp, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {String uri = serverHttpRequest.getURI().getPath();
        LOG.info("MyResponseBodyAdvice#beforeBodyWrite 申请地址：{}", uri);

        ServletServerHttpRequest servletServerHttpRequest = (ServletServerHttpRequest) serverHttpRequest;
        HttpServletRequest servletRequest = servletServerHttpRequest.getServletRequest();

        // 能够做对立的拦挡形式解决

        // 能够对后果做动静批改等
        LOG.info("MyResponseBodyAdvice#beforeBodyWrite 响应后果：{}", resp);
        return resp;
    }

}

咱们启动利用，页面拜访：

http://localhost:18080/index

页面响应：

{"respCode":"00","respDesc":"胜利","result":"ok"}

后端日志：

c.g.h.s.l.a.a.LogHandlerInterceptor      : LogHandlerInterceptor#preHandle 申请地址：/index
c.g.h.s.l.a.aspect.AspectLogInterceptor  : IndexController.index() 参数: []
IndexController#index：AsyncResp{respCode='00', respDesc='胜利', result='ok'}
c.g.h.s.l.a.aspect.AspectLogInterceptor  : IndexController.index() 后果: AsyncResp{respCode='00', respDesc='胜利', result='ok'}
c.g.h.s.l.a.aspect.MyResponseBodyAdvice  : MyResponseBodyAdvice#beforeBodyWrite 申请地址：/index
c.g.h.s.l.a.aspect.MyResponseBodyAdvice  : MyResponseBodyAdvice#beforeBodyWrite 响应后果：AsyncResp{respCode='00', respDesc='胜利', result='ok'}
c.g.h.s.l.a.a.LogHandlerInterceptor      : LogHandlerInterceptor#postHandle 调用

这里执行的先后顺序也比拟明确，此处不再赘述。

当然，如果只是下面这些内容，并不是本篇文章的重点。

接下来，咱们一起来看下，如果引入了异步执行会怎么样。

springboot 中定义异步线程池，非常简单。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.AsyncTaskExecutor;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

/**
 * 申请异步解决配置
 *
 * @author binbin.hou
 */
@Configuration
@EnableAsync
public class SpringAsyncConfig {@Bean(name = "asyncPoolTaskExecutor")
    public AsyncTaskExecutor taskExecutor() {ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(10);
        executor.setCorePoolSize(10);
        executor.setWaitForTasksToCompleteOnShutdown(true);
        return executor;
    }

}

@RestController
public class MyAsyncController extends BaseAsyncController<String> {

    @Override
    protected String process(HttpServletRequest request) {return "ok";}

    @RequestMapping("/async")
    public AsyncResp hello(HttpServletRequest request) {AsyncResp resp = super.execute(request);

        System.out.println("Controller#async 后果：" + resp);
        return resp;
    }

}

其中 BaseAsyncController 的实现如下：

@RestController
public abstract class BaseAsyncController<T> {protected abstract T process(HttpServletRequest request);

    @Autowired
    private AsyncTaskExecutor taskExecutor;

    protected AsyncResp execute(HttpServletRequest request) {
        // 异步响应后果
        AsyncResp resp = new AsyncResp();
        try {taskExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try {T result = process(request);

                        resp.setRespCode("00");
                        resp.setRespDesc("胜利");
                        resp.setResult(result.toString());

                    } catch (Exception exception) {resp.setRespCode("98");
                        resp.setRespDesc("工作异样");
                    }
                }
            });
        } catch (TaskRejectedException e) {resp.setRespCode("99");
            resp.setRespDesc("工作回绝");
        }

        return resp;
    }

}

execute 的实现也比较简单：

（1）主线程创立一个 AsyncResp，用于返回。

（2）线程池异步执行具体的子类办法，并且设置对应的值。

接下来，问大家一个问题。

如果咱们申请 http://localhost:18080/async，那么：

（1）页面失去的返回值是什么？

（2）Aspect 日志输入的返回值是？

（3）ResponseBodyAdvice 日志输入的返回值是什么？

你能够在这里略微停一下，记录下你的答案。

咱们页面申请 http://localhost:18080/async。

页面响应如下：

{"respCode":"00","respDesc":"胜利","result":"ok"}

后端的日志：

c.g.h.s.l.a.a.LogHandlerInterceptor      : LogHandlerInterceptor#preHandle 申请地址：/async
c.g.h.s.l.a.aspect.AspectLogInterceptor  : MyAsyncController.hello(..) 参数: [org.apache.catalina.connector.RequestFacade@7e931750]
Controller#async 后果：AsyncResp{respCode='null', respDesc='null', result='null'}
c.g.h.s.l.a.aspect.AspectLogInterceptor  : MyAsyncController.hello(..) 后果: AsyncResp{respCode='null', respDesc='null', result='null'}
c.g.h.s.l.a.aspect.MyResponseBodyAdvice  : MyResponseBodyAdvice#beforeBodyWrite 申请地址：/async
c.g.h.s.l.a.aspect.MyResponseBodyAdvice  : MyResponseBodyAdvice#beforeBodyWrite 响应后果：AsyncResp{respCode='00', respDesc='胜利', result='ok'}
c.g.h.s.l.a.a.LogHandlerInterceptor      : LogHandlerInterceptor#postHandle 调用

比照一下，能够发现咱们下面问题的答案：

（1）页面失去的返回值是什么？

{"respCode":"00","respDesc":"胜利","result":"ok"}

能够获取到异步执行实现的后果。

（2）Aspect 日志输入的返回值是？

AsyncResp{respCode='null', respDesc='null', result='null'}

无奈获取异步后果。

（3）ResponseBodyAdvice 日志输入的返回值是什么？

AsyncResp{respCode='00', respDesc='胜利', result='ok'}

能够获取到异步执行实现的后果。

这个看起来有些奇怪，实质上起因是什么呢？又怎么验证呢？

实质上，异步执行和 spring 自身的机制关系不大。

只不过是异步执行的办法自身须要工夫，拦挡形式越靠后，如果异步执行完了，刚好就能够获取到对应的信息而已。

如何验证这个猜测呢？

咱们在 process 中增加一个 sleep 即可。

BaseAsyncController.java

execute 中增加一些执行的日志信息，便于查看工夫。

taskExecutor.execute(new Runnable() {
    @Override
    public void run() {
        try {logger.info("AsyncResp#execute 异步开始执行。");
            T result = process(request);
            resp.setRespCode("00");
            resp.setRespDesc("胜利");
            resp.setResult(result.toString());
            logger.info("AsyncResp#execute 异步实现执行。");
        } catch (Exception exception) {resp.setRespCode("98");
            resp.setRespDesc("工作异样");
        }
    }
});

MyAsyncController.java

执行时增加沉睡工夫。

@Override
protected String process(HttpServletRequest request) {
    try {TimeUnit.SECONDS.sleep(5);
        return "ok";
    } catch (InterruptedException e) {return "error";}
}

页面拜访 http://localhost:18080/async

页面返回如下：

{"respCode":null,"respDesc":null,"result":null}

对应的日志如下：

2021-07-10 09:16:08.661  INFO 11008 --- [io-18080-exec-1] c.g.h.s.l.a.a.LogHandlerInterceptor      : LogHandlerInterceptor#preHandle 申请地址：/async
2021-07-10 09:16:08.685  INFO 11008 --- [io-18080-exec-1] c.g.h.s.l.a.aspect.AspectLogInterceptor  : MyAsyncController.hello(..) 参数: [org.apache.catalina.connector.RequestFacade@1d491e0]
Controller#async 后果：AsyncResp{respCode='null', respDesc='null', result='null'}
2021-07-10 09:16:08.722  INFO 11008 --- [io-18080-exec-1] c.g.h.s.l.a.aspect.AspectLogInterceptor  : MyAsyncController.hello(..) 后果: AsyncResp{respCode='null', respDesc='null', result='null'}
2021-07-10 09:16:08.722  INFO 11008 --- [lTaskExecutor-1] c.g.h.s.l.a.c.BaseAsyncController        : AsyncResp#execute 异步开始执行。2021-07-10 09:16:08.777  INFO 11008 --- [io-18080-exec-1] c.g.h.s.l.a.aspect.MyResponseBodyAdvice  : MyResponseBodyAdvice#beforeBodyWrite 申请地址：/async
2021-07-10 09:16:08.777  INFO 11008 --- [io-18080-exec-1] c.g.h.s.l.a.aspect.MyResponseBodyAdvice  : MyResponseBodyAdvice#beforeBodyWrite 响应后果：AsyncResp{respCode='null', respDesc='null', result='null'}
2021-07-10 09:16:08.797  INFO 11008 --- [io-18080-exec-1] c.g.h.s.l.a.a.LogHandlerInterceptor      : LogHandlerInterceptor#postHandle 调用
2021-07-10 09:16:13.729  INFO 11008 --- [lTaskExecutor-1] c.g.h.s.l.a.c.BaseAsyncController        : AsyncResp#execute 异步实现执行。

能够发现 spring 自身仍然依照失常的流程执行，因为 process 的执行工夫过长，导致三种拦挡形式都是无奈获取异步内容。

写到这里，本人的播种还是不少。

（1）拦截器的叫法问题

平时会习惯的叫日志拦截器之类的，所以一开始题目应用的是 3 种拦截器，诚然，谨严的说并不能将这些一概而论。

否则，就如评论区所言，filter 也能够称为拦截器了。

所以将拦截器对立修改为拦挡形式。

（2）对常识的了解问题

第一次实现的时候，因为 process 工夫太短，让人产生误以为 spring 会有非凡的解决机制。

学习自身还是要谨严一些，所以本文从新做了修改。

心愿本文对你有帮忙，如果有其余想法的话，也能够评论区和大家分享哦。

各位极客的点赞珍藏转发，是老马继续写作的最大能源！

我是老马，期待与你的下次重逢。

关于springboot:springboot-实现拦截的-3-种方式介绍及异步执行的思考

springboot 拦挡形式

springboot 入门案例

maven 引入

启动类

定义 Controller

拦挡形式定义

基于 Aspect

基于 HandlerInterceptor

基于 ResponseBodyAdvice

测试

异步执行

定义异步线程池

异步执行的 Controller

思考

测试

异步执行

起因

验证形式

代码调整

测试

反思

小结

Just My Socks（注册教程内含优惠码）

关于springboot:springboot-实现拦截的-3-种方式介绍及异步执行的思考

springboot 拦挡形式

springboot 入门案例

maven 引入

启动类

定义 Controller

拦挡形式定义

基于 Aspect

基于 HandlerInterceptor

基于 ResponseBodyAdvice

测试

异步执行

定义异步线程池

异步执行的 Controller

思考

测试

异步执行

起因

验证形式

代码调整

测试

反思

小结

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）