SpringBoot统一功能处理

hi,大家好,今天为大家带来SpringBoot统一功能处理的知识点

主要分为三个板块

🧊1.统⼀⽤户登录权限验证

说白了这个用户登录权限验证就是一个拦截器的实现
先新创建一个项目,在configuration下写这个拦截器,因为拦截器也属于配置中的

🚀1.自定义拦截器

package com.example.demo.comfig;

import com.example.demo.common.config;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

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


//自定义拦截器
  @Component
public class UserInterceptor  implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpSession  session=request.getSession(false);
        if(session!=null&&session.getAttribute(config.SESSION_KEY)!=null){
        //用户已经登录,执行后续流程
            return true;
        }


        return false;


    }
}

🚀2.将自定义的拦截设置到当前项目的配置文件中,并设置拦截规则

@Configuration
public class APPconfig implements WebMvcConfigurer {

        @Autowired
        private  UserInterceptor userInterceptor;
    //加入拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(userInterceptor)
        .addPathPatterns("/**")//拦截所有请求
        .excludePathPatterns("/user/get")//从拦截的所有请求中放行的请求
        .excludePathPatterns("/user/login")
        ;
    }
}

@RestController
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/get")
    public String get(){
        System.out.println("执行get请求");
        return "get";
    }
    @RequestMapping("login")
    public  String login(){
        System.out.println("执行login请求");
        return "login";
    }
    @RequestMapping("/todo")
    public String todo(){
        System.out.println("执行todo方法");
        return "todo";
    }
}

方法已经写好了,我们来验证一下
这个方法是未拦截的的方法


解释一下为什么执行完get方法还要执行拦截器呢,因为这个是浏览器默认会拦截的网站的图标,如图所示

这个是无法避免访问的,我们可以采用postman来进行访问


这样就是正确的结果了
再来执行一个被拦截的

一片空白,被拦截了,

👀排除所有的静态资源
比如有各种格式的图片的时候,
把所有图片放到static目录下,然后放行

拦截器实现原理

所有的Controller执行时，都会通过一个调度器DispatcherServlet来进行实现

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

        try {
            try {
                ModelAndView mv = null;
                Object dispatchException = null;

                try {
                    processedRequest = this.checkMultipart(request);
                    multipartRequestParsed = processedRequest != request;
                    mappedHandler = this.getHandler(processedRequest);
                    if (mappedHandler == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }

                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
                    String method = request.getMethod();
                    boolean isGet = HttpMethod.GET.matches(method);
                    if (isGet || HttpMethod.HEAD.matches(method)) {
                        long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                        if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
                            return;
                        }
                    }

                    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                        return;
                    }

                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }

                    this.applyDefaultViewName(processedRequest, mv);
            //调⽤预处理   
                 mappedHandler.applyPostHandle(processedRequest, response, mv);
                } catch (Exception var20) {
                    dispatchException = var20;
                } catch (Throwable var21) {
                    dispatchException = new NestedServletException("Handler dispatch failed", var21);
                }

                this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
            } catch (Exception var22) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
            } catch (Throwable var23) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
            }

        } finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            } else if (multipartRequestParsed) {
                this.cleanupMultipart(processedRequest);
            }

        }
    }

开始执⾏ Controller 之前，会先调⽤ 预处理⽅法 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 ⽅法

这和我们自己实现的拦截器原理是一样的

具体来说，Spring的拦截器包括了HandlerInterceptor和WebRequestInterceptor两个接口，用于拦截web请求和处理程序的执行。
在SpringMVC中，拦截器是DispatcherServlet和处理程序之间执行的。当一个请求到达DispatcherServlet时，它会首先在拦截器链中执行所有的拦截器，然后再将请求转发给适当的处理程序进行处理。
拦截器链是通过HandlerInterceptor和WebRequestInterceptor接口定义的。这些接口定义了拦截器的生命周期方法，在请求处理程序的前后执行适当的拦截器方法，以实现对请求的拦截和处理。
Spring通过代理模式来实现拦截器的执行。在DispatcherServlet(代理对象)中，每个处理程序都会被代理，(controller才是实际对象)以便在执行前后执行拦截器的适当方法。当请求被拦截器链中的任何一个拦截器拦截时，处理程序的实际执行就被终止了。

因此，拦截器的实现原理是基于AOP和代理模式的。通过代理模式来代理处理程序的执行，在执行前后执行适当的拦截器方法，从而实现对请求的拦截和处理。

🧊2.统⼀异常处理

统一异常处理使用的是@ControllerAdvice+@ExceptionHandler实现
@ControllerAdvice:控制器通知类
@ExceptionHandler:异常处理器
二者同时使用表明当出现异常的时候执行某个通知,也就是执行某个方法实现**
我们先把拦截器屏蔽掉看看报错的时候

对象为空,hashcode当然打印不出来

这个异常前端不认识,用户不认识,所以后端需要对出现的异常进行统一处理
方法如下
1.新建一个类
2.添加相应注解@ControllerAdvice+@ExceptionHandler(写统一返回的对象)

@RestControllerAdvice//等于上面两个注解加起来
public class ExceptionAdvice {
        @ExceptionHandler(NullPointerException.class)
        public ResultJson doNullPointerException(NullPointerException e){
            ResultJson resultJson=new ResultJson();
            resultJson.setCode(-1);//一般来说用负数 描述状态码
            resultJson.setMsg("空指针异常"+e.getMessage());
            resultJson.setData(null);
            return resultJson;
        }
}

创建统一返回的对象

package com.example.demo.common;

import lombok.Data;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: WHY
 * Date: 2023-08-12
 * Time: 10:12
 */
//定义统一返回的对象
@Data
public class ResultJson {
    private  int code;//状态码
    private String msg;//状态码描述信息
    private Object data;//返回数据
}

这个是针对空指针异常的,但是异常有很多种,所以我们要设置一个默认异常

实验一下

可以看到虽然有异常但是进行了异常处理,返回的数据前端可以认识

🧊3.统⼀数据格式返回

为什么要统一数据返回格式
统一数据返回格式的好处如下：

1.降低开发成本：由于统一的数据返回格式，可以减少前端和后端的沟通成本，也可以减少编写前后端接口文档的工作量。。

2.提高代码可读性和可维护性：由于统一数据返回格式，前端和后端的开发人员都可以清楚地了解数据的结构和含义，从而更方便地阅读和修改代码。

3.增强系统的健壮性和可靠性：统一数据返回格式可以避免因为不同接口返回数据格式不一致而导致的系统异常和错误。

4.提高用户体验：由于统一数据返回格式可以减少前端请求接口的时间，提高响应速度，从而提升用户体验。

@Data
public class ResultJson {
    private  int code;//状态码
    private String msg;//状态码描述信息
    private Object data;//返回数据

    public static ResultJson success(Object data){
        ResultJson resultJson=new ResultJson();
        resultJson.setCode(200);
        resultJson.setMsg("");
        resultJson.setData(data);
        return resultJson;
    }
    public  static ResultJson success(String msg,Object data){
        ResultJson resultJson=new ResultJson();
        resultJson.setCode(200);
        resultJson.setMsg(msg);
        resultJson.setData(data);
        return resultJson;
    }
    public static  ResultJson fail(int code,String msg){
        ResultJson resultJson=new ResultJson();
        resultJson.setCode(code);
        resultJson.setMsg(msg);
        resultJson.setData(null);
        return resultJson;
    }
    public static  ResultJson fail(int code,String msg,Object data){
        ResultJson resultJson=new ResultJson();
        resultJson.setCode(code);
        resultJson.setMsg(msg);
        resultJson.setData(data);
        return resultJson;
    }
}

接下来就要改造代码,让所有方法返回的不是String类型,而是ResultJson对象


当不小心把方法写成不是Result的时候,此时需要
进行强制处理
1.添加@ControllerAdvice注解
2.实现@RespnseBodyAdvice接口,重写两个方法,supports返回TRUE,beforeBodyWrite进行重新判断和重写操作

package com.example.demo.comfig;



import com.example.demo.common.ResultJson;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.SneakyThrows;
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;

/**
 * 统一返回值的处理
 */
@ControllerAdvice
public class ReponseAdvice implements ResponseBodyAdvice {
    @Autowired
    private ObjectMapper objectMapper;
    @Override
    public boolean supports(MethodParameter returnType, Class converterType) {
        return true;//这里返回TRUE,才会调用beforebodywrite方法
    }

    @SneakyThrows
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType,
                                  MediaType selectedContentType,
                                  Class selectedConverterType,
                                  ServerHttpRequest request,
                                  ServerHttpResponse response) {
        //已经包装好的策略
        if(body instanceof ResultJson)
                return body;
    //执行改代码有两个处理器,一个是String类型,另一个是非String,当返回对象是非string,就返回下面方法的
            //如果返回值是String类型,String处理器还没准备好,就无法正确返回,所以此处需要进行String的单独处理
//注入jackson,直接将对象转换为json格式
        if(body instanceof ResultJson){
           ResultJson resultJson= ResultJson.success(body);
         return  objectMapper.writeValueAsString(resultJson);
        }
        return ResultJson.success(body);
    }
}

今天的讲解就到这里,我们下期再见,88!