【Spring Boot】拦截器与统一功能处理

xyk:

已于 2023-08-07 09:49:01 修改

阅读量1k

点赞数 1

分类专栏： JavaEE进阶文章标签： spring boot 后端 java java-ee

于 2023-08-07 09:48:19 首次发布

本文链接：https://blog.csdn.net/asad21654864/article/details/132139097

版权

JavaEE进阶专栏收录该内容

9 篇文章 0 订阅

订阅专栏

博主简介：想进大厂的打工人
博主主页：@xyk:
所属专栏: JavaEE进阶

上一篇文章我们讲解了Spring AOP是一个基于面向切面编程的框架，用于将某方面具体问题集中处理，通过代理对象来进行传递，但使用原生Spring AOP实现统一的拦截是非常繁琐的。而在本节，我们将使用一种简单的方式进行统一功能处理，具体如下：

统一用户登录权限验证
统一数据格式返回
统一异常处理

文章目录

0、我们先来回顾⼀下最初⽤户登录验证的实现方法：

一、统一用户登录权限验证

1.1 使用原生Spring AOP 实现统一拦截

1.2 使用Spring 拦截器实现统一用户登录验证

0、我们先来回顾⼀下最初用户登录验证的实现方法：

@RestController
@RequestMapping("/user")
public class UserController {
    /**
     * 某⽅法 1
     */
    @RequestMapping("/m1")
    public Object method(HttpServletRequest request) {
// 有 session 就获取，没有不会创建
        HttpSession session = request.getSession(false);
        if (session != null && session.getAttribute("userinfo") != null) {
// 说明已经登录，业务处理
            return true;
        } else {
// 未登录
            return false;
        }
    }
    /**
     * 某⽅法 2
     */
    @RequestMapping("/m2")
    public Object method2(HttpServletRequest request) {
// 有 session 就获取，没有不会创建
        HttpSession session = request.getSession(false);
        if (session != null && session.getAttribute("userinfo") != null) {
// 说明已经登录，业务处理
            return true;
        } else {
// 未登录
            return false;
        }
    }
// 其他⽅法...
}

从上述代码可以看出，每个⽅法中都有相同的⽤户登录验证权限，它的缺点是：
1. 每个⽅法中都要单独写⽤户登录验证的⽅法，即使封装成公共⽅法，也⼀样要传参调⽤和在⽅法中进⾏判断。
2. 添加控制器越多，调⽤⽤户登录验证的⽅法也越多，这样就增加了后期的修改成本和维护成本。
3. 这些⽤户登录验证的⽅法和接下来要实现的业务⼏何没有任何关联，但每个⽅法中都要写⼀遍。

一、统一用户登录权限验证

1.1 使用原生Spring AOP 实现统一拦截

我们上一篇文章讲解了原生AOP：【Spring】Spring AOP 初识及实现原理解析

以使用原生 Spring AOP 来实现⽤户统⼀登录验证为例，主要是使用前置通知和环绕通知实现的，具体实现如下：

package com.example.demo.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component // 随着框架的启动而启动
@Aspect // 告诉框架我是一个切面类
public class UserAspect {

    // 定义切点(配置拦截规则)
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
    public void pointcut(){

    }

    @Before("pointcut()")
    public void beforeAdvice(){
        System.out.println("执行了前置通知~");
    }

    @After("pointcut()")
    public void AfterAdvice(){
        System.out.println("执行了后置通知~");
    }

    /**
     * 环绕通知
     * @param joinPoint
     * @return
     */
    @Around("pointcut()")
    public Object aroundAdvice(ProceedingJoinPoint joinPoint){
        System.out.println("进入了环绕通知~");
        Object obj = null;
        try {
            obj = joinPoint.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("退出了环绕通知~");
        return obj;
    }

}

从上面代码可以看出，使用原生的 Spring AOP 实现统一拦截的难点比较复杂，不易实现。定义拦截规则非常困难。如注册⽅法和登录⽅法是不拦截的，这样的话排除⽅法的规则很难定义，甚⾄没办法定义。而且在切面类中拿到 HttpSession 比较难。

为了解决Spring AOP的问题，Spring 提供了拦截器~

1.2 使用Spring 拦截器实现统一用户登录验证

要使用Spring 拦截器，需要先创建一个实现了 HandlerInterceptor 接口的拦截器类，该接口定义了三个方法：preHandle、postHandle和afterCompletion。

preHandle方法在请求到达控制器之前执行，可以用于进行身份验证、参数校验等；
postHandle方法在控制器处理完请求后执行，可以对模型和视图进行操作；
afterCompletion方法在视图渲染完成后执行，用于清理资源或记录日志。

拦截器的实现分为以下两个步骤：

1. 创建⾃定义拦截器，实现 HandlerInterceptor 接⼝的 preHandle（执⾏具体⽅法之前的预处理）方法。

2. 将⾃定义拦截器加入 WebMvcConfigurer 的 addInterceptors 方法中

具体实现如下：

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;

public class LoginInterceptor implements HandlerInterceptor {

    /**
     * 此方法返回一个 boolean,如果为 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;
        }
        // 可以跳转到登录页面 or 返回一个 401 / 403 没有权限码
        response.sendRedirect("/login.html");
//        response.setStatus(403);
        return false;

    }
}

2.配置拦截器并设置拦截规则：

package com.example.demo.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.PathMatchConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class AppConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**") // 拦截所有请求
                .excludePathPatterns("/user/login") // 排除的url地址
                .excludePathPatterns("/user/reg")
                .excludePathPatterns("/**/*.html");
    }
}

1.3 拦截器实现原理

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

1.4 实现原理源码分析

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

而所有的方法都会执行 DispatcherServlet 中的 doDispatch 调度方法，doDispatch 源码如下：

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;
                    }
                    // 执⾏ Controller 中的业务
                    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，⽽
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 ⽅法，这样就会我们前⾯定义的拦截器对应上了，如下图所示：

此时，相应的preHandle中的业务逻辑就会执行。

二、统一异常处理

统一异常处理是指在应用程序中定义一个公共的异常处理机制，用来处理所有的异常情况。

本文讲述的统一异常处理使用的是 @ControllerAdvice + @ExceptionHandler 来实现的：

@ControllerAdvice 表示控制器通知类。
@ExceptionHandler 异常处理器。

以上两个注解组合使用，表示当出现异常的时候执行某个通知，即执行某个方法事件，具体实现代码如下：

package com.example.demo.config;

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;

/**
 * @author xyk的电脑
 * @version 1.0
 * @description: TODO
 * @date 2023/7/15 18:49
 */

@ControllerAdvice
@ResponseBody
public class MyExHandler {

    /**
     * 拦截所有的空指针异常，进行统一的数据返回了
     * @param e
     * @return
     */
    @ExceptionHandler(NullPointerException.class)
    public HashMap<String,Object> nullException(NullPointerException e){
        HashMap<String,Object> result = new HashMap<>();
        result.put("code",-1);
        result.put("msg","空指针异常:" + e.getMessage()); // 错误码的描述信息
        result.put("data",null);
        return result;
    }

    @ExceptionHandler(Exception.class)
    public HashMap<String,Object> exception(Exception e){
        HashMap<String,Object> result = new HashMap<>();
        result.put("code",-1);
        result.put("msg","异常:" + e.getMessage()); // 错误码的描述信息
        result.put("data",null);
        return result;
    }


}

上述代码中，实现了对所有空指针异常和所有异常的保底措施的拦截并进行统一的数据返回。

三、统一数据返回格式

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

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

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

统⼀的数据返回格式可以使⽤ @ControllerAdvice + ResponseBodyAdvice 的⽅式实现，具体实现代码如下：

1.创建一个类，并添加@ControllerAdvice注解

2.实现ResponseBodyAdvice接口，并重写 supports 和 beforeBodyWrite方法

package com.example.demo.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 xyk的电脑
 * @version 1.0
 * @description: TODO
 * @date 2023/7/15 19:18
 */

@ControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice {
    @Autowired
    private ObjectMapper objectMapper;

    /**
     * 此方法返回 true 则执行下面 beforeBodyWrite 方法
     * 反之则不执行
     */
    @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("code",200);
        result.put("msg","");
        result.put("data",body);
        if (body instanceof String){
            // 需要特殊处理，因为 String 在转换的时候会报错
            try {
                return objectMapper.writeValueAsString(result);
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        }
        return result;
    }
}

注意，如果返回的 body 原始数据类型是 String ，则会出现类型转化异常，因为当我们返回给前端Spring引用类型时，Spring的渲染引擎还没有加载好就已经返回给前端了，会出现ClassCastException。因此，如果原始返回数据类型为 String ，则需要使用 jackson 进行单独处理。

结语

创作不易，如果你有任何问题，欢迎评论区讨论哦~~

xyk:

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【Spring Boot】拦截器与统一功能处理

上一篇文章我们讲解了Spring AOP是一个基于面向切面编程的框架，用于将某方面具体问题集中处理，通过代理对象来进行传递，但使用原生Spring AOP实现统一的拦截是非常繁琐的。而在本节，我们将使用一种简单的方式进行统一功能处理，具体如下：统一用户登录权限验证，统一数据格式返回，统一异常处理。
复制链接

扫一扫