1.用户登录权限校验

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

1.1最初用户登录

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

@RestController
@RequestMapping("/user2")
public class User2Controller {
    /**
     * 
     * 某方法1
     */
    @RequestMapping("/m")
    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){
        HttpSession session=request.getSession(false);
        if(session!=null&&session.getAttribute("userinfo")!=null){
            return true;
        }else {
            return false;
        }
    }

}

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

1. 每个⽅法中都要单独写⽤户登录验证的⽅法，即使封装成公共⽅法，也⼀样要传参调⽤和在⽅法中进⾏判断。

2. 添加控制器越多，调⽤⽤户登录验证的⽅法也越多，这样就增加了后期的修改成本和维护成本。

3. 这些⽤户登录验证的⽅法和接下来要实现的业务⼏何没有任何关联，但每个⽅法中都要写⼀遍。

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

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

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

@Slf4j
@Aspect//定义了一个切点
@Component  //演示统一功能，先去掉
public class LoginAspect {
    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        Object oj=null;
        long start=System.currentTimeMillis();
        //调用目标方法
        try {
            //执行连接点的方法
            oj = joinPoint.proceed();
        } catch (Throwable e) {
            throw e;
        }
        log.info(joinPoint.getSignature().toString()+"耗时："(System.currentTimeMillis()-start));
        //必须要写返回结果
        return oj;
    }

    @Before("execution(* com.example.springaopdemo.controller.TestController.* (..))")
    public void before2(){
        log.info("before");
    }
}

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

1. 没办法获取到 HttpSession 对象。

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

那这样如何解决呢？

3Spring拦截器

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

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

2. 将⾃定义拦截器加⼊ WebMvcConfigurer 的 addInterceptors ⽅法中。

具体实现如下。

3.1自定义拦截器

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

/**
 * 创建一个拦截器
 */
@Component

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("username")!=null){
            //通过,不进行处理
            return true;
        }
        //表示没有权限
        response.setStatus(401);
        return false;
    }
}

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

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

@Configuration
public class AppConfig implements WebMvcConfigurer {
    @Autowired
    private LoginInterceptor loginInterceptor;
    //添加拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //添加拦截器
        registry.addInterceptor(loginInterceptor)
                //拦截哪些url
                .addPathPatterns("/**")
                //放过哪些url
                .excludePathPatterns("/api/user/login")
                .excludePathPatterns("/api/user/reg");
    }
    // 所有的接⼝添加 api 前缀
    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        configurer.addPathPrefix("api", c -> true);
    }

}

其中：

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

●excludePathPatterns：表示需要排除的 URL。

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

排除所有的静态资源

// 拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
 registry.addInterceptor(new LoginInterceptor())
 .addPathPatterns("/**") // 拦截所有接⼝
 .excludePathPatterns("/**/*.js")
 .excludePathPatterns("/**/*.css")
 .excludePathPatterns("/**/*.jpg")
 .excludePathPatterns("/login.html")
 .excludePathPatterns("/**/login"); // 排除接⼝
}

登录拦截器：

@Slf4j
@RequestMapping("/user")
@RestController
public class UserController {
    @RequestMapping("/get")
    //获取用户信息
    public String getInfo(){
        log.info("get info");
        return "get info";
    }
    //注册
    @RequestMapping("/reg")
    public String reg(){
        log.info("reg");
//        int a=10/0;
        return "reg";
    }
    @RequestMapping("/login")
    public boolean login(HttpServletRequest request,String username,String password){

        log.info("login");
        //判断username和password是否为空
//        if(username!=null && "".equals(username)&& password!=null &&"".equals(password)){
//
//        }
        //Spring
        if(!StringUtils.hasLength(username)||!StringUtils.hasLength(password)){
            return false;
        }
        if(!"admin".equals(username) || !"admin".equals(password)) {
            return true;
        }
        HttpSession session = request.getSession(true);
        session.setAttribute("username", username);
        return true;



    }


}

直接访问get会被拦截，表示拦截器创建成功

4拦截器实现原理

正常情况下的调⽤顺序：

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

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;
                Exception 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;
                    }
					// 执行Contorller层的逻辑
                    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 ⽅法，这样就会咱们前⾯定义的拦截器对应上了，如下图所示：

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

4.2拦截器小结

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

5拓展：统一前缀访问

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

    // 所有的接⼝添加 api 前缀
    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        configurer.addPathPrefix("api", c -> true);
    }

其中第⼆个参数是⼀个表达式，设置为 true 表示启动前缀。

我们在访问这个程序时，就要加上api前缀才能访问到，否则会被拦截：