【Spring Boot 】Spring Boot 统一功能处理

1、用户登录权限校验

⽤户登录权限的发展从之前每个⽅法中⾃⼰验证⽤户登录权限，到现在统⼀的⽤户登录验证处理，它是⼀个逐渐完善和逐渐优化的过程。
⽤户登录验证的实现⽅法有：

1. 最初的用户登录校验： 在每个方法里面获取 session 和 session 中的用户信息，如果存在用户，那么就认为登录成功，否则就登陆失败了
2. 第二版用户登录校验： 提供了统一的方法，在每个需要验证的方法中调用统一的用户登录身份校验方法来判断
3. 第三版用户登录校验： 使用 Spring AOP 来使用统一的用户登录校验
   但是遇到的问题是：没有办法得到 HttpSession 和 Request 对象；实际拦截规则很复杂，使用简单 aspectj 表达式无法满足拦截的需求
4. 第四版用户登录校验： Spring 拦截器来实现用户的统一登录校验

1.1 Spring 拦截器

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

1. 创建⾃定义拦截器，实现 HandlerInterceptor 接⼝的 preHandle（执⾏具体⽅法之前的预处理）⽅法。
2. 将⾃定义拦截器加入到框架的配置中，并且设置拦截规则
   a) 给当前的类添加 @Configuration 注解
   b) 实现WebMvcConfigurer 接口
   c) 重写 addInterceptors 方法

1.1.1 自定义拦截器

package com.example.demo.config;

import org.springframework.web.servlet.HandlerInterceptor;

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

/**
 * 自定义用户登录的拦截器
 * @date 2022/8/15 21:15
 */
public class LoginIntercept implements HandlerInterceptor {
    /**
     * 返回 true 表示拦截通过,可以访问后面的接口
     * 返回 false 表示拦截未通过,直接返回结果给前端
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1.得到HttpSession对象
        HttpSession session= request.getSession(false);
        if(session!=null && session.getAttribute("userinfo")!=null){
            // 表示已经登陆
            return true;
        }
        return false;
    }
}

1.1.2 将自定义拦截器添加系统配置中，并设置拦截的规则

package com.example.demo.config;

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.WebMvcConfigurer;

/**
 * @date 2022/8/15 21:28
 */
@Configuration
public class AppConfig implements WebMvcConfigurer {
    @Autowired
    private LoginIntercept loginIntercept;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginIntercept)
                .addPathPatterns("/**")  // 拦截所有的url
                .excludePathPatterns("/user/login")
                .excludePathPatterns("/user/reg")// 不拦截登录接口
                .excludePathPatterns("/login.html")
                .excludePathPatterns("/reg.html")
                .excludePathPatterns("/**/*.js")
                .excludePathPatterns("/**/*.css")
        ;
    }
}

其中：

• addPathPatterns：表示需要拦截的 URL，“**”表示拦截任意⽅法（也就是所有⽅法）。
• excludePathPatterns：表示需要排除的 URL。

下面让我们来进行测试一下😊😊

package com.example.demo.controller;

import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

/**
 * @date 2022/8/15 21:57
 */
@RestController
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/login")
    public boolean login(String username, String password, HttpServletRequest request){
        boolean result=false;
        if(StringUtils.hasLength(username)&& StringUtils.hasLength(password)){
            if(username.equals("admin") && password.equals("admin")){
                HttpSession session= request.getSession();
                session.setAttribute("userinfo","userinfo");
                return true;
            }
        }
        return result;
    }
    @RequestMapping("/index")
    public String index(String username, String password, HttpServletRequest request){
        return "hello index!";
    }
}

当我们访问index.html页面时：

响应码是200，但并没有返回结果
访问user/index页面时也亦是如此：

因为上面设置拦截的规则的时候没有拦截登录页面，所以登录页面是可以正常显示的：

由于我们在进行登录时往往就是要进行校验，如果不能成功登录的话就要重新返回登录页面进行登录，所以我们可以加入下面的代码：

加上这行代码后再访问上面的index页面等就会跳到login.html页面

直到当我们登录成功写⼊ session 之后，拦截的⻚⾯可正常访问后：

登录成功后再访问其他页面：

1.2 拦截器实现原理

正常情况下的调⽤顺序：

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

1.2.1 实现原理源码分析

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

⽽所有⽅法都会执⾏ DispatcherServlet 中的 doDispatch 调度⽅法，doDispatch 源码如下：

重点是下面的这些代码，在开始执⾏ Controller 之前，会先调⽤ 预处理⽅法 applyPreHandle：

applyPreHandle ⽅法的实现源码如下：

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
        for(int i = 0; i < this.interceptorList.size(); this.interceptorIndex = i++) {
            HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
            if (!interceptor.preHandle(request, response, this.handler)) {
                this.triggerAfterCompletion(request, response, (Exception)null);
                return false;
            }
        }

        return true;
    }

从上述源码可以看出，在 applyPreHandle 中会获取所有的拦截器 HandlerInterceptor 并执⾏拦截器中的 preHandle ⽅法，这样就会咱们前⾯定义的拦截器对应上了，如下图所示：

此时⽤户登录权限的验证⽅法就会执⾏，这就是拦截器的实现原理。

1.2.2 拦截器小结

通过上⾯的源码分析，我们可以看出，Spring 中的拦截器也是通过动态代理和环绕通知的思想实现的，⼤体的调⽤流程如下：

1.3 扩展: 统一访问前缀添加

所有请求地址添加 api 前缀：

测试前记得把上面的拦截器代码注释掉，否则可能会干扰我们的测试结果：

2、统⼀异常处理

1. 给当前的类加上 @ControllerAdvice/@RestControllerAdvice
2. 给方法上添加 @ExceptionHandler(xxx.class)，添加异常返回的业务代码

package com.example.demo.config;

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.HashMap;

/**
 * @date 2022/8/16 11:24
 */
@RestControllerAdvice  // 当前是针对Controller的通知类（增强类）
public class MyExceptionAdvice {
    @ExceptionHandler(ArithmeticException.class)
    public HashMap<String,Object>arithmeticExceptionAdvice(ArithmeticException e){
        HashMap<String,Object>result=new HashMap<>();
        result.put("state",-1);
        result.put("data",null);
        result.put("msg","算术异常："+e.getMessage());
        return result;
    }
    @ExceptionHandler(NullPointerException.class)
    public HashMap<String,Object>nullPointerExceptionAdvice(NullPointerException e){
        HashMap<String,Object>result=new HashMap<>();
        result.put("state",-1);
        result.put("data",null);
        result.put("msg","空指针异常："+e.getMessage());
        return result;
    }
    @ExceptionHandler(Exception.class)
    public HashMap<String,Object>exceptionAdvice(Exception e){
        HashMap<String,Object>result=new HashMap<>();
        result.put("state",-1);
        result.put("data",null);
        result.put("msg","异常："+e.getMessage());
        return result;
    }
}

测试结果如下：

3、统⼀数据格式封装

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

统⼀数据返回格式的优点有很多，比如：

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

3.2 统⼀数据返回格式的实现

1. 给当前类添加 @ControllerAdvice
2. 实现 ResponseBodyAdvice 重写其方法

实现代码如下：

package com.example.demo.config;

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;

/**
 * @date 2022/8/16 19:49
 */
@ControllerAdvice
public class MyResponseAdvice implements ResponseBodyAdvice {
    /**
     * 返回一个 boolean 值，true 表示返回数据之前对数据进行重写，也就是会进入 beforeBodyWrite 方法，再返回
     * 如果返回 false 表示对结果不进行任何处理，直接返回
     */
    @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<String,Object> result=new HashMap<>();
        result.put("state",1);
        result.put("data",body);
        result.put("msg","");
        return result;
    }
}

测试结果如下：


当登录失败时：

当进行注册时：