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

springboot 拦截器

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

本文首先为大家介绍 HTTP 请求中三种常见的拦截实现，并且比较一下其中的差异。
（1）基于 Aspect 的拦截器
（2）基于 HandlerInterceptor 的拦截器
（3）基于 ResponseBodyAdvice 的拦截器

推荐阅读：

统一日志框架: https://github.com/houbb/auto-log

springboot 入门案例

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

maven 引入

引入必须的 jar 包。

1. <parent>
2. <groupId>org.springframework.boot</groupId>
3. <artifactId>spring-boot-starter-parent</artifactId>
4. <version>1.5.9.RELEASE</version>
5. </parent>
6.  
7. <dependencies>
8. <dependency>
9. <groupId>org.springframework.boot</groupId>
10. <artifactId>spring-boot-starter-web</artifactId>
11. </dependency>
12. <dependency>
13. <groupId>org.aspectj</groupId>
14. <artifactId>aspectjrt</artifactId>
15. <version>1.8.10</version>
16. </dependency>
17. <dependency>
18. <groupId>org.aspectj</groupId>
19. <artifactId>aspectjweaver</artifactId>
20. <version>1.8.10</version>
21. </dependency>
22. </dependencies>
23. <!-- Package as an executable jar -->
24. <build>
25. <plugins>
26. <plugin>
27. <groupId>org.springframework.boot</groupId>
28. <artifactId>spring-boot-maven-plugin</artifactId>
29. </plugin>
30. </plugins>
31. </build>

启动类

实现最简单的启动类。

1. @SpringBootApplication
2. public class Application {
3.  
4. public static void main(String[] args) {
5. SpringApplication.run(Application.class, args);
6. }
7.  
8. }

定义 Controller

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

1. @RestController
2. public class IndexController {
3.  
4. @RequestMapping("/index")
5. public AsyncResp index() {
6. AsyncResp asyncResp = new AsyncResp();
7. asyncResp.setResult("ok");
8. asyncResp.setRespCode("00");
9. asyncResp.setRespDesc("成功");
10.  
11. System.out.println("IndexController#index：" + asyncResp);
12. return asyncResp;
13. }
14.  
15. }

其中 AsyncResp 的定义如下：

1. public class AsyncResp {
2.  
3. private String respCode;
4.  
5. private String respDesc;
6.  
7. private String result;
8.  
9. // getter & setter & toString()
10. }

拦截器定义

 

基于 Aspect

1. import org.aspectj.lang.ProceedingJoinPoint;
2. import org.aspectj.lang.annotation.Around;
3. import org.aspectj.lang.annotation.Aspect;
4. import org.aspectj.lang.annotation.Pointcut;
5. import org.slf4j.Logger;
6. import org.slf4j.LoggerFactory;
7. import org.springframework.context.annotation.EnableAspectJAutoProxy;
8. import org.springframework.stereotype.Component;
9.  
10. import java.util.Arrays;
11.  
12. /**
13. *
14. * @author binbin.hou
15. * @since 1.0.0
16. */
17. @Aspect
18. @Component
19. @EnableAspectJAutoProxy
20. public class AspectLogInterceptor {
21.  
22. /**
23. * 日志实例
24. * @since 1.0.0
25. */
26. private static final Logger LOG = LoggerFactory.getLogger(AspectLogInterceptor.class);
27.  
28. /**
29. * 拦截 controller 下所有的 public方法
30. */
31. @Pointcut("execution(public * com.github.houbb.springboot.learn.aspect.controller..*(..))")
32. public void pointCut() {
33. //
34. }
35.  
36. /**
37. * 拦截处理
38. *
39. * @param point point 信息
40. * @return result
41. * @throws Throwable if any
42. */
43. @Around("pointCut()")
44. public Object around(ProceedingJoinPoint point) throws Throwable {
45. try {
46. //1. 设置 MDC
47.  
48. // 获取当前拦截的方法签名
49. String signatureShortStr = point.getSignature().toShortString();
50. //2. 打印入参信息
51. Object[] args = point.getArgs();
52. LOG.info("{} 参数: {}", signatureShortStr, Arrays.toString(args));
53.  
54. //3. 打印结果
55. Object result = point.proceed();
56. LOG.info("{} 结果: {}", signatureShortStr, result);
57. return result;
58. } finally {
59. // 移除 mdc
60. }
61. }
62. }

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

是个人非常喜欢的一种方式。
主要用途：
（1）日志的出参/入参
（2）统一设置 TraceId
（3）方法的调用耗时统计

基于 HandlerInterceptor

1. import org.slf4j.Logger;
2. import org.slf4j.LoggerFactory;
3. import org.springframework.stereotype.Component;
4. import org.springframework.web.servlet.HandlerInterceptor;
5. import org.springframework.web.servlet.ModelAndView;
6.  
7. import javax.servlet.DispatcherType;
8. import javax.servlet.http.HttpServletRequest;
9. import javax.servlet.http.HttpServletResponse;
10.  
11. /**
12. * @author binbin.hou
13. * @since 1.0.0
14. */
15. @Component
16. public class LogHandlerInterceptor implements HandlerInterceptor {
17.  
18. private Logger logger = LoggerFactory.getLogger(LogHandlerInterceptor.class);
19.  
20. @Override
21. public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
22. // 统一的权限校验、路由等
23. logger.info("LogHandlerInterceptor#preHandle 请求地址：{}", request.getRequestURI());
24.  
25. if (request.getDispatcherType().equals(DispatcherType.ASYNC)) {
26. return true;
27. }
28.  
29. return true;
30. }
31.  
32. @Override
33. public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
34. logger.info("LogHandlerInterceptor#postHandle 调用");
35. }
36.  
37. @Override
38. public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
39.  
40. }
41. }

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

1. import com.github.houbb.springboot.learn.aspect.aspect.LogHandlerInterceptor;
2. import org.springframework.beans.factory.annotation.Autowired;
3. import org.springframework.context.annotation.Configuration;
4. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
5. import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
6.  
7. /**
8. * spring mvc 配置
9. * @since 1.0.0
10. */
11. @Configuration
12. public class SpringMvcConfig extends WebMvcConfigurerAdapter {
13.  
14. @Autowired
15. private LogHandlerInterceptor logHandlerInterceptor;
16.  
17. @Override
18. public void addInterceptors(InterceptorRegistry registry) {
19. registry.addInterceptor(logHandlerInterceptor)
20. .addPathPatterns("/**")
21. .excludePathPatterns("/version");
22. super.addInterceptors(registry);
23. }
24. }

这种方式的优点就是可以根据 url 灵活指定不同的拦截器。
缺点是主要用于 Controller 层。

基于 ResponseBodyAdvice

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

比如加密，签名等。

1. import org.slf4j.Logger;
2. import org.slf4j.LoggerFactory;
3. import org.springframework.core.MethodParameter;
4. import org.springframework.http.MediaType;
5. import org.springframework.http.converter.HttpMessageConverter;
6. import org.springframework.http.server.ServerHttpRequest;
7. import org.springframework.http.server.ServerHttpResponse;
8. import org.springframework.http.server.ServletServerHttpRequest;
9. import org.springframework.web.bind.annotation.ControllerAdvice;
10. import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
11.  
12. import javax.servlet.http.HttpServletRequest;
13.  
14. /**
15. * @author binbin.hou
16. * @since 1.0.0
17. */
18. @ControllerAdvice
19. public class MyResponseBodyAdvice implements ResponseBodyAdvice<Object> {
20.  
21. /**
22. * 日志实例
23. * @since 1.0.0
24. */
25. private static final Logger LOG = LoggerFactory.getLogger(MyResponseBodyAdvice.class);
26.  
27. @Override
28. public boolean supports(MethodParameter methodParameter, Class aClass) {
29. //这个地方如果返回false, 不会执行 beforeBodyWrite 方法
30. return true;
31. }
32.  
33. @Override
34. public Object beforeBodyWrite(Object resp, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
35. String uri = serverHttpRequest.getURI().getPath();
36. LOG.info("MyResponseBodyAdvice#beforeBodyWrite 请求地址：{}", uri);
37.  
38. ServletServerHttpRequest servletServerHttpRequest = (ServletServerHttpRequest) serverHttpRequest;
39. HttpServletRequest servletRequest = servletServerHttpRequest.getServletRequest();
40.  
41. // 可以做统一的拦截器处理
42.  
43. // 可以对结果做动态修改等
44. LOG.info("MyResponseBodyAdvice#beforeBodyWrite 响应结果：{}", resp);
45. return resp;
46. }
47. }

 

测试

我们启动应用，页面访问：
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 中定义异步线程池，非常简单。

1. import org.springframework.context.annotation.Bean;
2. import org.springframework.context.annotation.Configuration;
3. import org.springframework.core.task.AsyncTaskExecutor;
4. import org.springframework.scheduling.annotation.EnableAsync;
5. import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
6.  
7. /**
8. * 请求异步处理配置
9. *
10. * @author binbin.hou
11. */
12. @Configuration
13. @EnableAsync
14. public class SpringAsyncConfig {
15.  
16. @Bean(name = "asyncPoolTaskExecutor")
17. public AsyncTaskExecutor taskExecutor() {
18. ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
19. executor.setMaxPoolSize(10);
20. executor.setQueueCapacity(10);
21. executor.setCorePoolSize(10);
22. executor.setWaitForTasksToCompleteOnShutdown(true);
23. return executor;
24. }
25.  
26. }

异步执行的 Controller

1. @RestController
2. public class MyAsyncController extends BaseAsyncController<String> {
3.  
4. @Override
5. protected String process(HttpServletRequest request) {
6. return "ok";
7. }
8.  
9. @RequestMapping("/async")
10. public AsyncResp hello(HttpServletRequest request) {
11. AsyncResp resp = super.execute(request);
12.  
13. System.out.println("Controller#async 结果：" + resp);
14. return resp;
15. }
16. }

其中 BaseAsyncController 的实现如下：

1. @RestController
2. public abstract class BaseAsyncController<T> {
3.  
4. protected abstract T process(HttpServletRequest request);
5.  
6. @Autowired
7. private AsyncTaskExecutor taskExecutor;
8.  
9. protected AsyncResp execute(HttpServletRequest request) {
10. // 异步响应结果
11. AsyncResp resp = new AsyncResp();
12. try {
13. taskExecutor.execute(new Runnable() {
14. @Override
15. public void run() {
16. try {
17. T result = process(request);
18.  
19. resp.setRespCode("00");
20. resp.setRespDesc("成功");
21. resp.setResult(result.toString());
22.  
23. } catch (Exception exception) {
24. resp.setRespCode("98");
25. resp.setRespDesc("任务异常");
26. }
27. }
28. });
29. } catch (TaskRejectedException e) {
30. resp.setRespCode("99");
31. resp.setRespDesc("任务拒绝");
32. }
33.  
34. return resp;
35. }
36. }

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 对于页面的响应也许和我们想的有些不一样，并不是直接获取同步结果。
写到这里，发现自己对于 mvc 的理解一直只是停留在表面，没有真正理解整个流程。
Aspect 的形式在很多框架中都会使用，不过这里会发现无法获取异步的执行结果，存在一定问题。

到此这篇关于springboot实现拦截器的3种方式及异步执行的思考的文章就介绍到这了,更多相关springboot 拦截器内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://juejin.cn/post/6982562317040877582