SpringBoot 统一功能处理

Posted 2023-01-27 yyhgo_

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了SpringBoot 统一功能处理相关的知识，希望对你有一定的参考价值。

SpringBoot 统一功能处理

前言
一、用户登录权限效验
二、统一异常处理
三、统一数据返回格式

前言

接下来是 Spring Boot 统⼀功能处理模块了，也是 AOP 的实战环节，要实现的课程⽬标有以下 3 个：

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

接下我们⼀个⼀个来看。

一、用户登录权限效验

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

1.1 最初的用户登录验证

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

@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;
        
    
    // 其他⽅法...

从上述代码可以看出，每个⽅法中都有相同的⽤户登录验证权限，它的缺点是：

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

所以提供⼀个公共的 AOP ⽅法来进⾏统⼀的⽤户登录权限验证迫在眉睫。

1.2 Spring AOP 用户统一登录验证的问题

说到统⼀的⽤户登录验证，我们想到的第⼀个实现⽅案是 Spring AOP 前置通知或环绕通知来实现，具体实现代码如下：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class UserAspect 
    // 定义切点⽅法 controller 包下、⼦孙包下所有类的所有⽅法
    @Pointcut("execution(* com.example.demo.controller..*.*(..))")
    public void pointcut() 
    // 前置⽅法
    @Before("pointcut()")
    public void doBefore()

    

    // 环绕⽅法
    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint)
        Object obj = null;
        System.out.println("Around ⽅法开始执⾏");
        try 
            // 执⾏拦截⽅法
            obj = joinPoint.proceed();
         catch (Throwable throwable) 
            throwable.printStackTrace();
        
        System.out.println("Around ⽅法结束执⾏");
        return obj;

如果要在以上 Spring AOP 的切⾯中实现⽤户登录权限效验的功能，有以下两个问题：

没办法获取到 HttpSession 对象。
我们要对⼀部分⽅法进⾏拦截，⽽另⼀部分⽅法不拦截，如注册⽅法和登录⽅法是不拦截的，这样的话排除⽅法的规则很难定义，甚⾄没办法定义。

那这样如何解决呢？

1.3 Spring 拦截器

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

创建⾃定义拦截器，实现 HandlerInterceptor 接⼝的 preHandle（执⾏具体⽅法之前的预处理）⽅法。
将⾃定义拦截器加⼊ WebMvcConfigurer 的 addInterceptors ⽅法中。

具体实现如下。

补充 过滤器：
过滤器是Web容器提供的。触发的时机比拦截器更靠前，Spring 初始化前就执行了，所以并不能处理用户登录权限效验等问题。

1.3.1 准备工作

package com.example.demo.controller;

import lombok.extern.slf4j.Slf4j;
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;

@RestController
@RequestMapping("/user")
@Slf4j
public class UserController 

    @RequestMapping("/login")
    public boolean login(HttpServletRequest request,
                         String username, String password) 
//        // 1.非空判断
//        if (username != null && username != "" &&
//                password != null && username != "") 
//            // 2.验证用户名和密码是否正确
//        

        // 1.非空判断
        if (StringUtils.hasLength(username) && StringUtils.hasLength(password)) 
            // 2.验证用户名和密码是否正确
            if ("admin".equals(username) && "admin".equals(password)) 
                // 登录成功
                HttpSession session = request.getSession();
                session.setAttribute("userinfo", "admin");
                return true;
             else 
                // 用户名或密码输入错误
                return false;
            
        
        return false;
    

    @RequestMapping("/getinfo")
    public String getInfo() 
        log.debug("执行了 getinfo 方法");
        return "执行了 getinfo 方法";
    

    @RequestMapping("/reg")
    public String reg() 
        log.debug("执行了 reg 方法");
        return "执行了 reg 方法";

1.3.2 自定义拦截器

接下来使⽤代码来实现⼀个⽤户登录的权限效验，⾃定义拦截器是⼀个普通类，具体实现代码如下：

package com.example.demo.config;

import lombok.extern.slf4j.Slf4j;
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
@Slf4j
public class LoginInterceptor implements HandlerInterceptor 

    @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;
        
        log.error("当前用户没有访问权限");
        response.setStatus(401);
        return false;

返回 boolean 类型。

相当于一层安保：
为 false 则不能继续往下执行；为 true 则可以。

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

将上⼀步中的⾃定义拦截器加⼊到系统配置信息中，具体实现代码如下：

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.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration // 一定不要忘记
public class MyConfig implements WebMvcConfigurer 

    @Autowired
    private LoginInterceptor loginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) 
        registry.addInterceptor(loginInterceptor)
                .addPathPatterns("/**") // 拦截所有请求
                .excludePathPatterns("/user/login") // 排除不拦截的 url
//                .excludePathPatterns("/**/*.html")
//                .excludePathPatterns("/**/*.js")
//                .excludePathPatterns("/**/*.css")
                .excludePathPatterns("/user/reg"); // 排除不拦截的 url

或者：

package com.example.demo.common;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.ArrayList;
import java.util.List;

@Configuration
public class AppConfig implements WebMvcConfigurer 

    // 不拦截的 url 集合
    List<String> excludes = new ArrayList<String>() 
        add("/**/*.html");
        add("/js/**");
        add("/editor.md/**");
        add("/css/**");
        add("/img/**"); // 放行 static/img 下的所有文件
        add("/user/login"); // 放行登录接口
        add("/user/reg"); // 放行注册接口
        add("/art/detail"); // 放行文章详情接口
        add("/art/list"); // 放行文章分页列表接口
        add("/art/totalpage"); // 放行文章分页总页数接口
    ;

    @Autowired
    private LoginInterceptor loginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) 
        // 配置拦截器
        InterceptorRegistration registration =
                registry.addInterceptor(loginInterceptor);
        registration.addPathPatterns("/**");
        registration.excludePathPatterns(excludes);

如果不注入对象的话，addInterceptor() 的参数也可以直接 new 一个对象：

@Configuration // 一定不要忘记
public class MyConfig implements WebMvcConfigurer 

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

其中：

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

说明：以上拦截规则可以拦截此项⽬中的使⽤ URL，包括静态⽂件 (图⽚⽂件、JS 和 CSS 等⽂件)。

1.4 拦截器实现原理

正常情况下的调⽤顺序：

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

1.4.1 实现原理源码分析

所有的 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.g
                            etHandler());
                    String method = request.getMethod();
                    boolean isGet = HttpMethod.GET.matches(method);
                    if (isGet || HttpMethod.HEAD.matches(method)) 
                        long lastModified = ha.getLastModified(request, mapped
                                Handler.getHandler());
                        if ((new ServletWebRequest(request, response)).checkNo
                        tModified(lastModified) && isGet) 
                            return;
                        
                    
                    // 调⽤预处理【重点】
                    if (!mappedHandler.applyPreHandle(processedRequest, respon
                            se)) 
                        return;
                    
                    // 执⾏ Controller 中的业务
                    mv = ha.handle(processedRequest, response, mappedHandler.g
                            etHandler());
                    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 di
                            spatch failed", var21);
                
                this.processDispatchResult(processedRequest, response, mappedH
                        andler, mv, (Exception)dispatchException);
             catch (Exception var22) 
                this.triggerAfterCompletion(processedRequest, response, mapped
                        Handler, var22);
             catch (Throwable var23) 
                this.triggerAfterCompletion(processedRequest, response, mapped
                        Handler, new NestedServletException("Handler processing failed", var23));
            
         finally 
            if (asyncManager.isConcurrentHandlingStarted()) 
                if (mappedHandler != null) 
                    mappedHandler.applyAfterConcurrentHandlingStarted(processe
                            dRequest, 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.sizeSpringBoot 统一功能处理
 Springboot使用validator进行参数校验
 Springboot使用validator进行参数校验
 Springboot使用validator进行参数校验
 Springboot使用validator进行参数校验
 JS实现统一社会信用代码的效验(组织机构代码效验)