【Spring Boot】拦截器使用和常用功能统一封装

转x33g5p2x  于2022-08-17 转载在 Spring  
字(6.9k)|赞(0)|评价(0)|浏览(600)

1. 拦截器

1.1 拦截器的使用

Spring 中提供了拦截器 HandlerInteceptor，它的具体使用分为以下两个步骤：

  1. 创建自定义拦截器，实现 HandlerInteceptor 接口的 preHandle（执行具体方法之前的预处理）方法。
  2. 将自定义拦截器加入 WebMvcConfigurer 的 addInterceptors 方法中。

1.2 拦截器的原理

通过使用拦截器，业务的执行流程一般如下：

其中所有 controller 的执行都会通过一个调度器 DispatcherServlet 来实现，而所有的方法都会执行 DispatcherServlet 中的 doDispatch 调度方法，doDispatch 的源码如下：

  1. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
  2.     HttpServletRequest processedRequest = request;
  3.     HandlerExecutionChain mappedHandler = null;
  4.     boolean multipartRequestParsed = false;
  5.     WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
  7.     try {
  8.         try {
  9.             ModelAndView mv = null;
  10.             Object dispatchException = null;
  12.             try {
  13.                 processedRequest = this.checkMultipart(request);
  14.                 multipartRequestParsed = processedRequest != request;
  15.                 mappedHandler = this.getHandler(processedRequest);
  16.                 if (mappedHandler == null) {
  17.                     this.noHandlerFound(processedRequest, response);
  18.                     return;
  19.                 }
  21.                 HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
  22.                 String method = request.getMethod();
  23.                 boolean isGet = "GET".equals(method);
  24.                 if (isGet || "HEAD".equals(method)) {
  25.                     long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
  26.                     if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
  27.                         return;
  28.                     }
  29.                 }
  30. 				
  31.                 // 调用预处理
  32.                 if (!mappedHandler.applyPreHandle(processedRequest, response)) {
  33.                     return;
  34.                 }
  35. 				
  36.                 // 执行 controller 中的业务
  37.                 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
  38.                 if (asyncManager.isConcurrentHandlingStarted()) {
  39.                     return;
  40.                 }
  42.                 this.applyDefaultViewName(processedRequest, mv);
  43.                 mappedHandler.applyPostHandle(processedRequest, response, mv);
  44.             } catch (Exception var20) {
  45.                 dispatchException = var20;
  46.             } catch (Throwable var21) {
  47.                 dispatchException = new NestedServletException("Handler dispatch failed", var21);
  48.             }
  50.             this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
  51.         } catch (Exception var22) {
  52.             this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
  53.         } catch (Throwable var23) {
  54.             this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
  55.         }
  57.     } finally {
  58.         if (asyncManager.isConcurrentHandlingStarted()) {
  59.             if (mappedHandler != null) {
  60.                 mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
  61.             }
  62.         } else if (multipartRequestParsed) {
  63.             this.cleanupMultipart(processedRequest);
  64.         }
  66.     }
  67. }

在上述源码中标注了预处理和执行 controller 中业务的位置，而预处理即就是我们要探索的拦截器源码的位置，其中使用了 applyPreHandle 方法，applyPreHandle 方法的源码如下：

  1. boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
  2.     HandlerInterceptor[] interceptors = this.getInterceptors();
  3.     if (!ObjectUtils.isEmpty(interceptors)) {
  4.         for(int i = 0; i < interceptors.length; this.interceptorIndex = i++) {
  5.             HandlerInterceptor interceptor = interceptors[i];
  6.             if (!interceptor.preHandle(request, response, this.handler)) {
  7.                 this.triggerAfterCompletion(request, response, (Exception)null);
  8.                 return false;
  9.             }
  10.         }
  11.     }
  13.     return true;
  14. }

我们可以发现预处理中首先获取到了所有的拦截器，并进行遍历，如果当前拦截器的返回值为 true 则不进行拦截，如果返回值为 false 则提前结束，而在预处理中则会直接 return。

以上就是对拦截器源码的解析，在 applyRreHandle 中会获取所有拦截器 HandlerInterceptor，并执行拦截器的 preHandle 方法，这样就会与个人自定义的拦截器对应上。

而本质上 Spring 中的拦截器也是通过动态代理和环绕通知的思想实现的，大体的调用流程如下：

2. 用户登录权限校验

  1. 定义用户登录权限校验的拦截器。
  1. public class LoginInterceptor implements HandlerInterceptor {
  2.     @Override
  3.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  4.         HttpSession session = request.getSession(false);
  5.         if (session != null && session.getAttribute("user") != null){
  6.             return true;
  7.         }
  8.         response.setStatus(401);
  9.         return false;
  10.     }
  11. }
  1. 将自定义拦截器加入到系统配置。
  1. @Configuration
  2. public class InterceptorConfig implements WebMvcConfigurer {
  3.     /**
  4.      * 添加拦截器和指定拦截规则
  5.      * @param registry
  6.      */
  7.     @Override
  8.     public void addInterceptors(InterceptorRegistry registry) {
  9.         registry.addInterceptor(new LoginInterceptor())
  10.                 .addPathPatterns("/**") // 拦截所有请求
  11.                 .excludePathPatterns("/user/**"); // 放行 user 的请求
  12.     }
  13. }

3. 统一异常处理

统一异常处理使用的是 @ControllerAdvice 和 @ExceptionHandler 来实现的，@ControllerAdvice 表示控制器通知类，@ExceptionHandler 是异常处理器，两个结合表示当出现异常的时候执行某个通知，也就是执行某个方法，具体实现步骤如下：

  1. 创建一个类，并在此类上添加 @ControllerAdvice 和 @ResponseBody 注解。
  1. @ControllerAdvice // 表示控制器通知类
  2. @ResponseBody
  3. public class ExceptionAdvice {
  4.     
  5. }
  1. 编写异常返回数据的方法，在该方法上加上 @ExceptionHandler 注解。
  1. @ControllerAdvice // 表示控制器通知类
  2. @ResponseBody
  3. public class ExceptionAdvice {
  5.     @ExceptionHandler(Exception.class)
  6.     public Object Exeception(Exception e){
  7.         HashMap<String, Object> map = new HashMap<>();
  8.         map.put("code", 0); // 状态码（设置0为异常，1为正常）
  9.         map.put("data", null); // 返回数据
  10.         map.put("msg", e.getMessage()); // 异常信息
  11.         return map;
  12.     }
  13. }
  1. 当有多个异常通知时，匹配顺序为存在的当前类及其子类向上依次匹配。如统一异常代码如下：
  1. @ControllerAdvice // 表示控制器通知类
  2. @ResponseBody
  3. public class ExceptionAdvice {
  5.     @ExceptionHandler(Exception.class)
  6.     public Object Exeception(Exception e){
  7.         HashMap<String, Object> map = new HashMap<>();
  8.         map.put("code", 0); // 状态码（设置0为异常，1为正常）
  9.         map.put("data", null); // 返回数据
  10.         map.put("msg", "总的异常信息：" + e.getMessage()); // 异常信息
  11.         return map;
  12.     }
  14.     @ExceptionHandler(ArithmeticException.class)
  15.     public Object ArithmeticException(ArithmeticException e){
  16.         HashMap<String, Object> map = new HashMap<>();
  17.         map.put("code", 0);
  18.         map.put("data", null);
  19.         map.put("msg", "算数异常信息：" + e.getMessage());
  20.         return map;
  21.     }
  22. }

当出现算数异常时，返回的结果应该是 ArithmeticException 方法通知的异常。

4. 统一数据返回格式

对于统一数据的格式可以手动进行封装，代码如下：

  1. @Data
  2. public class Response implements Serializable {
  3.     private int code; // 状态码（-1-失败 0-成功 1-空）
  4.     private Object data; // 数据
  5.     private String msg; // 异常信息
  7.     public static String success(Object data){
  8.         Response response = new Response();
  9.         response.code = 0;
  10.         response.data = data;
  11.         response.msg = null;
  12.         return JSON.toJSONString(response);
  13.     }
  15.     public static String success(){
  16.         Response response = new Response();
  17.         response.code = 0;
  18.         response.data = null;
  19.         response.msg = null;
  20.         return JSON.toJSONString(response);
  21.     }
  23.     public static String fail(String msg){
  24.         Response response = new Response();
  25.         response.code = -1;
  26.         response.data = null;
  27.         response.msg = msg;
  28.         return JSON.toJSONString(response);
  29.     }
  31.     public static String fail(){
  32.         Response response = new Response();
  33.         response.code = -1;
  34.         response.data = null;
  35.         response.msg = null;
  36.         return JSON.toJSONString(response);
  37.     }
  39.     public static String Empty(){
  40.         Response response = new Response();
  41.         response.code = 1;
  42.         response.data = null;
  43.         response.msg = "没有找到数据！";
  44.         return JSON.toJSONString(response);
  45.     }
  46. }

也可以通过 @ControllerAdvice 注解和实现 ResponseBodyAdvice 接口来实现自动的封装。实现方式如下：

  1. 创建一个类，给类上添加 @ControllerAdvice 注解，并实现 ResponseBodyAdvice 接口。
  1. @ControllerAdvice
  2. public class MyResponseBodyAdvice implements ResponseBodyAdvice {
  4. }

  • 重写 ResponseBodyAdvice 接口的两个方法。

  • supports 方法表示是否在返回数据之前重写数据，返回值为 true 表示重写。

  • beforeBodyWrite 方法用来重写方法返回的数据，将数据封装后返回给前端。

  1. @ControllerAdvice
  2. public class MyResponseBodyAdvice implements ResponseBodyAdvice {
  4.     /**
  5.      * 将 supports 的返回值设置为 true 来表示在返回数据前重写数据
  6.      */
  7.     @Override
  8.     public boolean supports(MethodParameter methodParameter, Class aClass) {
  9.         return true;
  10.     }
  12.     /**
  13.      * 封装要重写的数据
  14.      */
  15.     @Override
  16.     public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
  17.         HashMap<String, Object> map = new HashMap<>();
  18.         map.put("code", 1);
  19.         map.put("data", o);
  20.         map.put("msg", null);
  21.         return map;
  22.     }
  23. }

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://t4dmw.blog.csdn.net/article/details/126149473

内容来源于网络，如有侵权，请联系作者删除！

Javaspringjavaee

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com