Spring 统一登录验证、数据格式返回、异常处理的实现

spring统一功能实现

前言

在上一篇博客我们介绍了Spring AOP以及简单使用了Spring AOP，这篇博客将完整的利用Spring AOP实现统一的功能。

1. 统一用户登录权限验证

⽤户登录权限的发展从之前每个⽅法中⾃⼰验证⽤户登录权限，到现在统⼀的⽤户登录验证处理，它变得更加简洁方便。接下来我们可以对比看看传统与统一功能实现的区别。

1.1 传统实现方式

新建一个UserController类，创建两个业务方法，在两个业务方法中都要进行用户登录判断：

 @RequestMapping("/m1")
    public Object method1(HttpServletRequest request){
//        通过request获取session进行判断
        HttpSession session = request.getSession(false);
        if (session != null && session.getAttribute("userinfo")!=null) {
            return true;
        }else {
            return false;
        }
        //业务逻辑......
        
    }

    @RequestMapping("/m2")
    public Object method2(HttpServletRequest request){
//        通过request获取session进行判断
        HttpSession session = request.getSession(false);
        if (session != null && session.getAttribute("userinfo")!=null) {
            return true;
        }else {
            return false;
        }
        //业务逻辑......
    }

缺点：

1. 每个⽅法中都要单独写⽤户登录验证，即使封装成公共⽅法，也要传参调⽤和在⽅法中进⾏判断，传入参数也可能是变化的所以很复杂。
2. 添加控制器越多，调⽤⽤户登录验证的⽅法也越多，这样就增加了后期的修改成本和维护成本。
3. 这些⽤户登录验证的⽅法和接下来要实现的业务⼏何没有任何关联，但每个⽅法中都要写。

接下来就应用⼀个公共的 AOP ⽅法来进⾏统⼀的⽤户登录权限验证；

1.2 Spring AOP用户统一登录验证

在上一篇文章中我们简单介绍了Spring Aop的实现，在这里我们同样先创建一个切面（UserAscept类），然后创建切点，创建通知。这是Spring AOP的原始实现；但是我们会发现，在项目中定义登录验证的拦截规则较难（项目下面有其他的功能方法，而我们的登录验证只针对需要的），同时在切面类要拿到HttpSession页比较难。

以上问题我们都可以通过Spring 拦截器解决，也是AOP思想的实现

1.2.1 Spring 拦截器

拦截器实现原理： 添加拦截器，就会在原本执行控制器层时，先进行对请求的预处理进行相关的判断或者跳转等操作

源码分析：

Controller 执⾏都会通过⼀个调度器 DispatcherServlet 来实现，这⼀点可以从控制台的打印信息看出，如下图所示：

我们所有的方法都会执⾏ DispatcherServlet 中的 doDispatch 调度⽅法，在该方法中我们可以看到，它调用了预处理方法 applyPreHandle；

// 调⽤预处理【重点】
if (!mappedHandler.applyPreHandle(processedRequest, respon
se)) {
return;
}
// 执⾏ Controller 中的业务
mv = ha.handle(processedRequest, response, mappedHandler.g
etHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}

在 applyPreHandle 中会获取所有的拦截器 HandlerInterceptor 并执行拦截器中的 preHandle ⽅法，所以我们自己定义的拦截器就会实现在controller层业务实现之前执行。

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse res
ponse) throws Exception {
for(int i = 0; i < this.interceptorList.size(); this.interceptorIndex
= i++) {
// 获取项⽬中使⽤的拦截器 HandlerInterceptor
HandlerInterceptor interceptor = (HandlerInterceptor)this.intercep
torList.get(i);
if (!interceptor.preHandle(request, response, this.handler)) {
this.triggerAfterCompletion(request, response, (Exception)null
);
return false;
}
}
return true;
}

拦截器的使用方法：

1. 创建⾃定义拦截器，实现 HandlerInterceptor 接⼝，重写 preHandle（执⾏具体⽅法之前的预处理）方法，编写自己的业务代码。
2. 将⾃定义拦截器加⼊ WebMvcConfigurer 的 addInterceptors ⽅法中。

** 登录拦截器的实现代码**

package com.example.demo_aspect.config;

import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * @author zq
 * @date 2023-07-20 09:46
 * 登录拦截器
 */

public class Logininterceptor implements HandlerInterceptor {

    /**
     * 返回true说明验证成功反之验证失败
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//        用户登录业务注解
        HttpSession session = request.getSession(false);
        if (session!=null&&session.getAttribute("userinfo")!=null){
            return  true;
        }
          //跳转到登录页面
        response.sendRedirect("/login.html");
        return false;
    }
}

加入配置代码：

package com.example.demo_aspect.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @author zq
 * @date 2023-07-20 10:02
 */

@Configuration //随着项目启动
public class AppConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry){

        registry.addInterceptor(new Logininterceptor())
                .addPathPatterns("/**")  //拦截所有请求
                .excludePathPatterns("/user/login") //排除不拦截的url地址
                .excludePathPatterns("/user/reg");
    }
}

我们在UserController类构造请求测试是否拦截我们设置拦截的请求：

 @RequestMapping("/getuser")
    public String getUser(){
        System.out.println("执行力getUser");
        return "get user";
    }
    @RequestMapping("/login")
    public String login(){
        System.out.println("执行力login");
        return "login";
    }

在网站访问http://localhost:8080/user/login，可以发现我们执行了login方法，没有拦截该请求;

!在这里插入图片描述

我们访问http://localhost:8080/user/getuser时，他会拦截，并且验证失败给我们自动跳转到了login.html.

以上就实现了对用户的统一登录验证；接下来我们看如何实现统一数据格式的返回。

2. 统一数据格式返回

为什么需要统一数据格式返回？

1. ⽅便前端程序员更好的接收和解析后端数据接⼝返回的数据。
2. 降低前端程序员和后端程序员的沟通成本，按照某个格式实现就就可以，所有接⼝都同样返回的。
3. 有利于项⽬统⼀数据的维护和修改。
4. 有利于后端技术部⻔的统⼀规范的标准制定，不会有各种各样的返回内容。

统一数据格式返回的实现：

1. 创建一个类，添加@ControllerAdvice注解
2. 实现ResponseBodyAdvice接口，重写supports和beforeBodyWrite方法。

创建ResponseAdvice类的代码如下，注意我们通过springboot进行格式转换时，string类型需要单独自行处理；

package com.example.demo_aspect.config;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

import java.util.HashMap;

/**
 * @author zq
 * @date 2023-07-20 11:57
 */

@ControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice {
    @Autowired
//    用于格式化转换
    private ObjectMapper objectMapper;

    /**
     * 该方法返回true就会执行下面的beforBodyWrite方法
     * 相当于开关
     * @param returnType
     * @param converterType
     * @return
     */
    @Override
    public boolean supports(MethodParameter returnType, Class converterType) {
        return true;
    }

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
//        构造新的格式，以hashmap格式返回


        HashMap<String,Object> res = new HashMap<>();
        res.put("code","200");
//        放入数据,只要数据不是string类型都能返回标准数据格式

        //        所以对string单独处理
        if (body instanceof String ){
            try {
               return objectMapper.writeValueAsString(res);
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        }
        res.put("data",body);
        return  res;
    }
}

在UserController类可以创建不同返回值的方法，访问地址查看前端页面数据是否是键值对格式。

3. 统一异常处理

统⼀异常处理使⽤的是 @ControllerAdvice + @ExceptionHandler 来实现的，@ControllerAdvice 表示控制器通知类，@ExceptionHandler 是异常处理器，两个结合表示当出现异常的时候执⾏某个通知。

实现步骤：

1. 创建异常类，标识@ControllerAdvice
   

2. 添加方法使用注解来订阅并处理异常。

package com.example.demo_aspect.config;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import java.util.HashMap;

/**
 * @author zq
 * @date 2023-07-20 11:19
 */
@ControllerAdvice
@ResponseBody
public class MyExeceptionHandle {

    /**
     * 拦截所有的空指针异常并进行数据返回
     * @param e
     * @return
     */
    @ExceptionHandler(NullPointerException.class)//标识订阅空指针异常
    public HashMap<String,Object> nullEx(NullPointerException e){
        HashMap<String,Object> res = new HashMap<>();
        res.put("code","-1");
        res.put("msg","空指针异常："+e.getMessage());//获取错误信息
        return res;
    }
}

同样的我们在UserControlle类构造含义空指针异常，算数异常的请求，分别访问我们可以发现，空指针异常会向我们的前端返回我们的错误，而没有进行统一异常处理的算数异常直接进行报错；