• Spring 统一处理（JavaEE进阶系列6）

    目录

    前言：

    1.用户登录权限的校验

    2.Spring拦截器

    2.1自定义拦截器

    2.2将自定义拦截器加入到系统配置

    2.3拦截器练习

    2.4拦截器的实现原理

    3.统一异常处理

    4.统一数据的返回格式

    结束语：

    前言：

    接下来就是Spring Boot中的统一功能处理模块了，也就是AOP的实战环节，这节中我们主要学习的有以下三点：1.统一用户登录权限验证。2.统一数据格式返回。3.统一异常处理。话不多说我们一起来了解吧！

    1.用户登录权限的校验

    用户登录权限的发展从之前每个方法中自己验证用户登录权限，到现在的统一的用户登录验证处理，它是一个逐渐完成和逐渐优化的过程。

    最初我们实现用户登录功能的时候会有很多缺点，在每个方法中都有相同的用户登录验证权限：

    • 每个⽅法中都要单独写⽤户登录验证的⽅法，即使封装成公共⽅法，也⼀样要传参调⽤和在⽅法中进⾏判断。
    • 添加控制器越多，调⽤⽤户登录验证的⽅法也越多，这样就增加了后期的修改成本和维护成本。
    • 这些⽤户登录验证的⽅法和接下来要实现的业务⼏何没有任何关联，但每个⽅法中都要写⼀遍。所以提供⼀个公共的 AOP ⽅法来进⾏统⼀的⽤户登录权限验证迫在眉睫。

    在我们之前学习过Spring AOP之后，如果再次提到要实现统一用户登录验证的时候，我们的第一想法应该就是Spring AOP的前置通知或通过环绕通知来实现。

    但是使用我们之前的的方法来实现的话，会发现存在两个问题：

    • 没有办法获取到HttpSession对象。
    • 我们要对一部分方法进行拦截，而另一部分方法不拦截，如注册方法和登录方法是不拦截的，这样的话排除方法的规则就很难定义，甚至没有办法定义。

    所以这针对于上述的问题我们就提出一个新的解决方案使用Spring中的拦截器。

    2.Spring拦截器

    对于上述的问题Spring中提供了具体的实现拦截器：HandlerInterceptor，拦截器的实现分为以下两步：

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

    2.1自定义拦截器

    具体的实现如下所示：

    代码展示：

    config层代码：

    1. package com.example.demo.config;
    2.  
    3. import com.example.demo.common.AppVar;
    4. import org.springframework.stereotype.Component;
    5. import org.springframework.web.servlet.HandlerInterceptor;
    6.  
    7. import javax.servlet.http.HttpServletRequest;
    8. import javax.servlet.http.HttpServletResponse;
    9. import javax.servlet.http.HttpSession;
    10.  
    11. /**
    12.  * 自定义拦截器
    13.  */
    14. @Component
    15. public class UserInterceptor implements HandlerInterceptor {
    16.     /**
    17.      * 返回true -> 拦截器验证成功，继续执行后续的方法
    18.      * 返回false -> 拦截器验证失败，不会执行后续的目标方法
    19.      * @param request
    20.      * @param response
    21.      * @param handler
    22.      * @return
    23.      * @throws Exception
    24.      */
    25.     @Override
    26.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    27.         System.out.println("do UserInterceptor");
    28.         //业务方法
    29.         HttpSession session = request.getSession(false);
    30.         if (session != null && session.getAttribute(AppVar.SESSION_KEY) != null) {
    31.             //用户已经登录
    32.             return true;//继续执行后续的流程
    33.         }
    34.         response.sendRedirect("https://www.baidu.com");
    35.         return false;
    36.     }
    37. }

    common代码：

    1. package com.example.demo.common;
    2.  
    3. /**
    4.  * 全局变量
    5.  */
    6. public class AppVar {
    7.     //Session Key
    8.     public static final String SESSION_KEY = "SESSION_KEY";
    9. }

    Controller层代码：

    1. package com.example.demo.controller;
    2.  
    3. import org.springframework.web.bind.annotation.RequestMapping;
    4. import org.springframework.web.bind.annotation.RestController;
    5.  
    6. @RestController
    7. @RequestMapping("/user")
    8. public class UserController {
    9.  
    10.     @RequestMapping("/reg")
    11.     public String reg() {
    12.         System.out.println("do reg()");
    13.         Object obj = null;
    14.         System.out.println(obj.hashCode());
    15.         return "reg";
    16.     }
    17.  
    18.     @RequestMapping("/login")
    19.     public String login() {
    20.         System.out.println("do login()");
    21.         return "login";
    22.     }
    23. }

    结果展示：

    如果已经登录：

    如果没有登录：

    这里我们使用以下的方式来模拟没有登录的场景：

     

    2.2将自定义拦截器加入到系统配置

    上述自定好了一个拦截器之后接下来我们就需要将自定义的拦截器设置到当前项目的配置文件中，并设置拦截的规则。

    1. package com.example.demo.config;
    2.  
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    5. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    6.  
    7. public class AppConfig implements WebMvcConfigurer {
    8.     @Autowired
    9.     private UserInterceptor userInterceptor;
    10.     @Override
    11.     public void addInterceptors(InterceptorRegistry registry) {
    12.         registry.addInterceptor(userInterceptor)
    13.                 .addPathPatterns("/**") //拦截所有的请求
    14.                 .excludePathPatterns("user/reg") //除去拦截reg注册请求
    15.                 .excludePathPatterns("user/login"); //除去拦截login登录请求
    16.     }
    17. }
    其中：
    • addPathPatterns：表示需要拦截的 URL，“**”表示拦截任意⽅法（也就是所有⽅法）。
    • excludePathPatterns：表示需要排除的URL。

    ​​​​​​​2.3拦截器练习

    接下来我们来实现一下面的这个登录拦截器的练习题：

    • 登录、注册⻚⾯不拦截，其他⻚⾯都拦截。
    • 当登录成功写⼊ session 之后，拦截的⻚⾯可正常访问。

    首先我们先来导入一个博客系统的静态页面：

    大家可以从我的Gitee中进行下载☞博客系统静态页面: 博客系统的静态页面

    导入静态页面之后我们就可以开始编写拦截器的规则了。

    1. package com.example.demo.config;
    2.  
    3. import org.springframework.context.annotation.Configuration;
    4. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    5. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    6.  
    7. import javax.annotation.Resource;
    8.  
    9. @Configuration
    10. public class AppConfig implements WebMvcConfigurer {
    11.     @Resource
    12.     private UserInterceptor userInterceptor;
    13.  
    14.     @Override
    15.     public void addInterceptors(InterceptorRegistry registry) {
    16.         registry.addInterceptor(userInterceptor)
    17.                 .addPathPatterns("/**") //拦截所有的请求
    18.                 .excludePathPatterns("/user/reg")
    19.                 .excludePathPatterns("/reg.html")
    20.                 .excludePathPatterns("/login.html")
    21.                 .excludePathPatterns("/css/**")
    22.                 .excludePathPatterns("/editor.md/**")
    23.                 .excludePathPatterns("/img/**")
    24.                 .excludePathPatterns("/js/**")
    25.                 .excludePathPatterns("/user/login");
    26.     }
    27. }

    接下来就可以正常访问页面了。

    2.4拦截器的实现原理

    正常情况下的调用顺序：

    然而有了拦截器之后，会在调用Controller之前进行相应的业务处理，执行的流程如下所示：

     

    首先所有的Controller执行都会通过一个调度器DispathcherServlet来实现，这一点可以在Spring Boot的控制台打印信息中看出来。

    而所有的方法都会执行 DispathcherServlet 中的doDispatch调度方法，通过分析doDispatch源码我们可以看出在开始执行Controller之前，会先调用预处理方法applyPreHandle，在applyPreHandle中会获取所有的拦截器HandleInterceptor并执行拦截器中的preHandle方法，这样就和我们之前定义的拦截器可以对应上了。这就是拦截器的实现原理。

    3.统一异常处理

    统一异常处理使用的是@ControllerAdvice/@RestControllerAdvice + @ExceptionHandler来实现的，@ControllerAdvice表示控制器通知类，@ExceptionHandler是异常处理器，两个结合表示当出现异常的时候执行某个通知，也就是执行某个方法事件。

    代码如下所示：

    1. package com.example.demo.common;
    2.  
    3. import lombok.Data;
    4.  
    5. /**
    6.  * 统一对象
    7.  */
    8. @Data
    9. public class ResultAjax {
    10.     private int code; // 状态码
    11.     private String msg; // 状态码的描述信息
    12.     private Object data; // 返回数据
    13.  
    14.     /**
    15.      * 返回成功对象
    16.      * @param data
    17.      * @return
    18.      */
    19.     public static ResultAjax succ(Object data) {
    20.         ResultAjax resultAjax = new ResultAjax();
    21.         resultAjax.setCode(200);
    22.         resultAjax.setMsg("");
    23.         resultAjax.setData(data);
    24.         return resultAjax;
    25.     }
    26.  
    27.     public static ResultAjax succ(String msg, Object data) {
    28.         ResultAjax resultAjax = new ResultAjax();
    29.         resultAjax.setCode(200);
    30.         resultAjax.setMsg(msg);
    31.         resultAjax.setData(data);
    32.         return resultAjax;
    33.     }
    34.  
    35.     /**
    36.      * 返回失败对象
    37.      * @param code
    38.      * @param msg
    39.      * @return
    40.      */
    41.     public static ResultAjax fail(int code,String msg){
    42.         ResultAjax resultAjax = new ResultAjax();
    43.         resultAjax.setCode(code);
    44.         resultAjax.setMsg(msg);
    45.         resultAjax.setData(null);
    46.         return resultAjax;
    47.     }
    48.  
    49.     public static ResultAjax fail(int code,String msg,Object data){
    50.         ResultAjax resultAjax = new ResultAjax();
    51.         resultAjax.setCode(code);
    52.         resultAjax.setMsg(msg);
    53.         resultAjax.setData(data);
    54.         return resultAjax;
    55.     }
    56.  
    57. }
    1. package com.example.demo.config;
    2.  
    3. import com.example.demo.common.ResultAjax;
    4. import org.springframework.web.bind.annotation.ExceptionHandler;
    5. import org.springframework.web.bind.annotation.RestControllerAdvice;
    6.  
    7. @RestControllerAdvice //表示控制器的通知类
    8. public class ExceptionAdvice {
    9.     @ExceptionHandler //统一返回的对象
    10.     public ResultAjax doNullPointerException(NullPointerException e) {
    11.         ResultAjax resultAjax = new ResultAjax();
    12.         resultAjax.setCode(-1);
    13.         resultAjax.setMsg("空指针异常：" + e.getMessage());
    14.         resultAjax.setData(null);
    15.         return resultAjax;
    16.     }
    17. }

    这里需要将Controller里面的返回值进行修改。

    结果如下所示：

    这样当出现异常的时候前端拿到的就不是之前报一大堆的错误了，就是可以直接在页面中显示出错误的信息了。

    当然上述过程中我们只是处理了空指针异常，那么异常那么多难道要将没一种情况都写进去吗？

    当然不是我们可以使用Exception来进行异常处理。如下代码所示：

    4.统一数据的返回格式

    为什么我们需要统一数据的返回格式呢？统一数据的返回格式优点有以下几点：

    • 方便前端程序员更好的接收和解析后端数据接口返回的数据。
    • 降低前端程序员和后端程序员的沟通成本，按照某个格式实现就行了，因为所有接口都是这样返回的。
    • 有利于项目统一数据的维护和修改。
    • 有利于后端技术部门的统一规范的标准制定，不会出现稀奇古怪的返回内容。

    统一的数据返回格式可以使用@ControllerAdvice + ResponseBodyAdvice的方式来实现，具体实现代码如下所示：

    1. package com.example.demo.config;
    2.  
    3. import com.example.demo.common.ResultAjax;
    4. import com.fasterxml.jackson.core.JsonProcessingException;
    5. import com.fasterxml.jackson.databind.ObjectMapper;
    6. import org.springframework.core.MethodParameter;
    7. import org.springframework.http.MediaType;
    8. import org.springframework.http.server.ServerHttpRequest;
    9. import org.springframework.http.server.ServerHttpResponse;
    10. import org.springframework.web.bind.annotation.ControllerAdvice;
    11. import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
    12.  
    13. import javax.annotation.Resource;
    14.  
    15. @ControllerAdvice
    16. public class ResponseAdvice implements ResponseBodyAdvice {
    17.     @Resource
    18.     private ObjectMapper objectMapper;
    19.  
    20.     /**
    21.      * true -> 才会调用 beforeBodyWrite 方法，
    22.      * 反之则永远不会调用 beforeBodyWrite 方法
    23.      *
    24.      * @param returnType
    25.      * @param converterType
    26.      * @return
    27.      */
    28.     @Override
    29.     public boolean supports(MethodParameter returnType, Class converterType) {
    30.         return true;
    31.     }
    32.  
    33.     @Override
    34.     public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
    35.         //已经包装好的对象
    36.         //instanceof - 判断类型
    37.         if (body instanceof ResultAjax) {
    38.             return body;
    39.         }
    40.         //对字符串进行判断和处理
    41.         if(body instanceof String) {
    42.             ResultAjax resultAjax = ResultAjax.succ(body);
    43.             try {
    44.                 return objectMapper.writeValueAsString(resultAjax);
    45.             } catch (JsonProcessingException e) {
    46.                 e.printStackTrace();
    47.             }
    48.         }
    49.         return ResultAjax.succ(body);
    50.     }
    51. }

    结束语：

    好了这节小编就给大分享到这里啦，希望这节对大家有关于Spring中的统一处理的基础知识的了解有一定帮助，想要学习的同学记得关注小编和小编一起学习吧！如果文章中有任何错误也欢迎各位大佬及时为小编指点迷津（在此小编先谢过各位大佬啦！）

  • 相关阅读:
    python操作数据库，django操作数据库
    左神：中级提升班5
    AEB前装搭载率逼近50%，沃尔沃「标配」激光雷达释放信号
    centos start ssh service
    解决React遍历每次渲染多个根元素导致无法为元素赋值key的问题
    案例分享：某汽车企业通过龙智拓展Jira功能，实现高效项目管理
    学习ASP.NET Core Blazor编程系列二——第一个Blazor应用程序（中）
    《Weisfeiler and Leman Go Neural Higher-order Graph Neural Networks》阅读笔记
    新的Ubuntu服务器上如何安装深度学习环境的docker
    前端总结——性能优化与重绘重排
  • 原文地址：https://blog.csdn.net/weixin_61599986/article/details/133657079