SpringBootWeb案例3--登录认证--登录校验-- 拦截器Interceptor

姜小白程序

已于 2024-05-02 23:06:24 修改

阅读量713

点赞数 19

文章标签： java maven spring intellij-idea tomcat java-ee

于 2024-04-27 21:57:47 首次发布

本文链接：https://blog.csdn.net/m0_59281987/article/details/138258967

版权

学习完了过滤器Filter之后，接下来我们继续学习拦截器Interseptor。

拦截器我们主要分为三个方面进行讲解：

介绍下什么是拦截器，并通过快速入门程序上手拦截器
拦截器的使用细节
通过拦截器Interceptor完成登录校验功能

我们先学习第一块内容：拦截器快速入门

2.5.1 快速入门

什么是拦截器？

是一种动态拦截方法调用的机制，类似于过滤器。
拦截器是Spring框架中提供的，用来动态拦截控制器方法的执行。

拦截器的作用：

拦截请求，在指定方法调用前后，根据业务需要执行预先设定的代码。

在拦截器当中，我们通常也是做一些通用性的操作，比如：我们可以通过拦截器来拦截前端发起的请求，将登录校验的逻辑全部编写在拦截器当中。在校验的过程当中，如发现用户登录了(携带JWT令牌且是合法令牌)，就可以直接放行，去访问spring当中的资源。如果校验时发现并没有登录或是非法令牌，就可以直接给前端响应未登录的错误信息。

下面我们通过快速入门程序，来学习下拦截器的基本使用。拦截器的使用步骤和过滤器类似，也分为两步：

定义拦截器
注册配置拦截器

自定义拦截器：实现HandlerInterceptor接口，并重写其所有方法

//自定义拦截器
@Component
public class LoginCheckInterceptor implements HandlerInterceptor {
//目标资源方法执行前执行。返回true：放行返回false：不放行
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("preHandle .... ");

return true; //true表示放行
}

//目标资源方法执行后执行
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("postHandle ... ");
}

//视图渲染完毕后执行，最后执行
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("afterCompletion .... ");
}
}

注意：

preHandle方法：目标资源方法执行前执行。返回true：放行返回false：不放行

postHandle方法：目标资源方法执行后执行

afterCompletion方法：视图渲染完毕后执行，最后执行

注册配置拦截器：实现WebMvcConfigurer接口，并重写addInterceptors方法

@Configuration
public class WebConfig implements WebMvcConfigurer {

//自定义的拦截器对象
@Autowired
private LoginCheckInterceptor loginCheckInterceptor;

@Override
public void addInterceptors(InterceptorRegistry registry) {
//注册自定义拦截器对象
registry.addInterceptor(loginCheckInterceptor).addPathPatterns("/**");//设置拦截器拦截的请求路径（ /** 表示拦截所有请求）
}
}

重新启动SpringBoot服务，打开postman测试：

接下来我们再来做一个测试：将拦截器中返回值改为false

使用postman，再次点击send发送请求后，没有响应数据，说明请求被拦截了没有放行

2.5.2 Interceptor详解

拦截器的入门程序完成之后，接下来我们来介绍拦截器的使用细节。拦截器的使用细节我们主要介绍两个部分：

拦截器的拦截路径配置
拦截器的执行流程

2.5.2.1 拦截路径

首先我们先来看拦截器的拦截路径的配置，在注册配置拦截器的时候，我们要指定拦截器的拦截路径，通过addPathPatterns("要拦截路径")方法，就可以指定要拦截哪些资源。

在入门程序中我们配置的是/**，表示拦截所有资源，而在配置拦截器时，不仅可以指定要拦截哪些资源，还可以指定不拦截哪些资源，只需要调用excludePathPatterns("不拦截路径")方法，指定哪些资源不需要拦截。

@Configuration
public class WebConfig implements WebMvcConfigurer {

//拦截器对象
@Autowired
private LoginCheckInterceptor loginCheckInterceptor;

@Override
public void addInterceptors(InterceptorRegistry registry) {
//注册自定义拦截器对象
registry.addInterceptor(loginCheckInterceptor)
.addPathPatterns("/**")//设置拦截器拦截的请求路径（ /** 表示拦截所有请求）
.excludePathPatterns("/login");//设置不拦截的请求路径
}
}

package com.itheima.config;

import com.itheima.intercetor.LoginCheckInterceptor;
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;

/**
 * ClassName: WebConfig
 * Package: com.itheima.config
 * Description:
 *
 * @Author 小白
 * @Create 2024/5/2 21:00
 * @Version 1.0
 */
@Configuration   //表示当前类是个配置类
public class WebConfig  implements WebMvcConfigurer {

    //拦截器对象
    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;


    /**
     * 怎么样来注册拦截器
     * 调用registry中的方法addInterceptor()来添加拦截器
     * 指定要加入的是哪一个拦截器
     * 这边我们要加入的拦截器是LoginCheckInterceptor
     * 这个LoginCheckInterceptor已经成为IOC容器中的bean对象了
     *  registry.addInterceptor(loginCheckInterceptor):
     *  注册了一个loginCheckInterceptor拦截器
     *  注册了这个拦截器之后 这个拦截器要拦截什么样的资源呢？
     * 调用addPathPatterns()来指定拦截的资源  .addPathPatterns("/**")
     *
     * @param registry
     */
    //注册拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        registry.addInterceptor(loginCheckInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/login");
    }
}

使用postman测试：http://localhost:8080/login

拦截的

System.out.println("preHandle......");

System.out.println("postHandle........");

这句话都没有输出

因为我们设置login不拦截了是不能拦截登录的请求

使用postman测试：

使用postman测试：http://localhost:8080/depts/5

在拦截器中除了可以设置/**拦截所有资源外，还有一些常见拦截路径设置：

拦截路径	含义	举例
/*	一级路径	能匹配/depts，/emps，/login，不能匹配 /depts/1
/**	任意级路径	能匹配/depts，/depts/1，/depts/1/2
/depts/*	/depts下的一级路径	能匹配/depts/1，不能匹配/depts/1/2，/depts
/depts/**	/depts下的任意级路径	能匹配/depts，/depts/1，/depts/1/2，不能匹配/emps/1

下面主要来演示下/**与/*的区别：

修改拦截器配置，把拦截路径设置为/*

@Configuration
public class WebConfig implements WebMvcConfigurer {

//拦截器对象
@Autowired
private LoginCheckInterceptor loginCheckInterceptor;

@Override
public void addInterceptors(InterceptorRegistry registry) {
//注册自定义拦截器对象
registry.addInterceptor(loginCheckInterceptor)
.addPathPatterns("/*")
.excludePathPatterns("/login");//设置不拦截的请求路径
}
}

package com.itheima.config;

import com.itheima.intercetor.LoginCheckInterceptor;
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;

/**
 * ClassName: WebConfig
 * Package: com.itheima.config
 * Description:
 *
 * @Author 小白
 * @Create 2024/5/2 21:00
 * @Version 1.0
 */
@Configuration   //表示当前类是个配置类
public class WebConfig  implements WebMvcConfigurer {

    //拦截器对象
    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;


    /**
     * 怎么样来注册拦截器
     * 调用registry中的方法addInterceptor()来添加拦截器
     * 指定要加入的是哪一个拦截器
     * 这边我们要加入的拦截器是LoginCheckInterceptor
     * 这个LoginCheckInterceptor已经成为IOC容器中的bean对象了
     *  registry.addInterceptor(loginCheckInterceptor):
     *  注册了一个loginCheckInterceptor拦截器
     *  注册了这个拦截器之后 这个拦截器要拦截什么样的资源呢？
     * 调用addPathPatterns()来指定拦截的资源  .addPathPatterns("/**")
     *
     * @param registry
     */
    //注册拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        registry.addInterceptor(loginCheckInterceptor)
                .addPathPatterns("/*")
                .excludePathPatterns("/login");
    }
}

使用postman测试：http://localhost:8080/depts

使用postman测试：http://localhost:8080/emps/1

控制台没有输出拦截器中的日志信息，说明/*没有匹配到拦截路径/emp/1 。

2.5.2.2 执行流程

介绍完拦截路径的配置之后，接下来我们再来介绍拦截器的执行流程。通过执行流程，大家就能够清晰的知道过滤器与拦截器的执行时机。

当我们打开浏览器来访问部署在web服务器当中的web应用时，此时我们所定义的过滤器会拦截到这次请求。拦截到这次请求之后，它会先执行放行前的逻辑，然后再执行放行操作。而由于我们当前是基于springboot开发的，所以放行之后是进入到了spring的环境当中，也就是要来访问我们所定义的controller当中的接口方法。
Tomcat并不识别所编写的Controller程序，但是它识别Servlet程序，所以在Spring的Web环境中提供了一个非常核心的Servlet：DispatcherServlet（前端控制器），所有请求都会先进行到DispatcherServlet，再将请求转给Controller。
当我们定义了拦截器后，会在执行Controller的方法之前，请求被拦截器拦截住。执行preHandle()方法，这个方法执行完成后需要返回一个布尔类型的值，如果返回true，就表示放行本次操作，才会继续访问controller中的方法；如果返回false，则不会放行（controller中的方法也不会执行）。
在controller当中的方法执行完毕之后，再回过来执行postHandle()这个方法以及afterCompletion() 方法，然后再返回给DispatcherServlet，最终再来执行过滤器当中放行后的这一部分逻辑的逻辑。执行完毕之后，最终给浏览器响应数据。

接下来我们就来演示下过滤器和拦截器同时存在的执行流程：

开启LoginCheckInterceptor拦截器

@Component
public class LoginCheckInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("preHandle .... ");

return true; //true表示放行
}

@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("postHandle ... ");
}

@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("afterCompletion .... ");
}
}

@Configuration
public class WebConfig implements WebMvcConfigurer {

//拦截器对象
@Autowired
private LoginCheckInterceptor loginCheckInterceptor;

@Override
public void addInterceptors(InterceptorRegistry registry) {
//注册自定义拦截器对象
registry.addInterceptor(loginCheckInterceptor)
.addPathPatterns("/**")//拦截所有请求
.excludePathPatterns("/login");//不拦截登录请求
}
}

开启DemoFilter过滤器

@WebFilter(urlPatterns = "/*")
public class DemoFilter implements Filter {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
System.out.println("DemoFilter 放行前逻辑.....");

//放行请求
filterChain.doFilter(servletRequest,servletResponse);

System.out.println("DemoFilter 放行后逻辑.....");
}
}

重启SpringBoot服务后，清空日志，打开Postman，测试查询部门：

package com.itheima.intercetor;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

/**
 * ClassName: LoginCheckInterceptor
 * Package: com.itheima.intercetor
 * Description:
 *
 * @Author 小白
 * @Create 2024/5/2 20:51
 * @Version 1.0
 */
//自定义拦截器
@Component //当前拦截器对象由Spring创建和管理
@Slf4j
public class LoginCheckInterceptor   implements  HandlerInterceptor {


    @Override   //目标资源方法运行前运行，返回true:放行，放回false,不放行
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle......");
        return  true;
    }

    @Override   //目标资源方法运行后运行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle........");
    }

    @Override  //视图渲染完毕后运行，最后运行
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion.......");
    }
}

package com.itheima.config;

import com.itheima.intercetor.LoginCheckInterceptor;
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;

/**
 * ClassName: WebConfig
 * Package: com.itheima.config
 * Description:
 *
 * @Author 小白
 * @Create 2024/5/2 21:00
 * @Version 1.0
 */
@Configuration   //表示当前类是个配置类
public class WebConfig  implements WebMvcConfigurer {

    //拦截器对象
    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;


    /**
     * 怎么样来注册拦截器
     * 调用registry中的方法addInterceptor()来添加拦截器
     * 指定要加入的是哪一个拦截器
     * 这边我们要加入的拦截器是LoginCheckInterceptor
     * 这个LoginCheckInterceptor已经成为IOC容器中的bean对象了
     *  registry.addInterceptor(loginCheckInterceptor):
     *  注册了一个loginCheckInterceptor拦截器
     *  注册了这个拦截器之后 这个拦截器要拦截什么样的资源呢？
     * 调用addPathPatterns()来指定拦截的资源  .addPathPatterns("/**")
     *
     * @param registry
     */
    //注册拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        registry.addInterceptor(loginCheckInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/login");
    }
}

package com.itheima.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

/**
 * ClassName: DemoFiler
 * Package: com.itheima.filter
 * Description:
 *
 *
 *
 * @Author 小白
 * @Create 2024/5/1 23:08
 * @Version 1.0
 *
 * Filter是javaweb三大主件之一  并不是springboot提供的功能  在springboot项目中 要想使用  javaweb的三大主件
 * 必须要在启动类上加上一个注解@ServletComponentScan
 *
 */
@WebFilter(urlPatterns = "/*") //配置过滤器要拦截的请求路径（ /* 表示拦截浏览器的所有请求 ）
public class DemoFiler  implements Filter {

    @Override   //初始化方法, 只调用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init 初始化方法执行了");


    }



    @Override //拦截到请求之后调用, 调用多次
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("Demo 拦截到了请求...放行前逻辑");

        //放行请求
        chain.doFilter(request,response);

        System.out.println("Demo 拦截后到了请求...放行前逻辑");


    }


    @Override  //销毁方法, 只调用一次
    public void destroy() {
        System.out.println("destroy 销毁方法执行了");
    }


}

以上就是拦截器的执行流程。通过执行流程分析，大家应该已经清楚了过滤器和拦截器之间的区别，其实它们之间的区别主要是两点：

接口规范不同：过滤器需要实现Filter接口，而拦截器需要实现HandlerInterceptor接口。
拦截范围不同：过滤器Filter会拦截所有的资源，而Interceptor只会拦截Spring环境中的资源。

执行流程：

当我们打开浏览器来访问部署在web服务器当中的web应用时，此时我们所定义的过滤器会拦截到这次请求。拦截到这次请求之后，它会先执行放行前的逻辑，(Demo 拦截到了请求...放行前逻辑"); 所以是过滤器先执行然后过滤器再执行放行操作doFilter() 之后在执行才放行给了拦截器才会执行拦截器中的preHandle()方法在preHandle()方法中由于我们设置返回值为true 代表放行然后就可以去执行Conteroller中的方法 Conteroller中的方法执行完毕之后在执行拦截器中的postHandle........ afterCompletion.......方法 postHandle........ afterCompletion.......方法二个这二个方法执行完毕之后在执行过滤器中放行之后的逻辑（Demo 拦截后到了请求...放行前逻辑）

2.5.3 登录校验- Interceptor

讲解完了拦截器的基本操作之后，接下来我们需要完成最后一步操作：通过拦截器来完成案例当中的登录校验功能。

登录校验的业务逻辑以及操作步骤我们前面已经分析过了，和登录校验Filter过滤器当中的逻辑是完全一致的。现在我们只需要把这个技术方案由原来的过滤器换成拦截器interceptor就可以了。

登录校验拦截器

//自定义拦截器
@Component //当前拦截器对象由Spring创建和管理
@Slf4j
public class LoginCheckInterceptor implements HandlerInterceptor {
//前置方式
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("preHandle .... ");
//1.获取请求url
//2.判断请求url中是否包含login，如果包含，说明是登录操作，放行

//3.获取请求头中的令牌（token）
String token = request.getHeader("token");
log.info("从请求头中获取的令牌：{}",token);

//4.判断令牌是否存在，如果不存在，返回错误结果（未登录）
if(!StringUtils.hasLength(token)){
log.info("Token不存在");

//创建响应结果对象
Result responseResult = Result.error("NOT_LOGIN");
//把Result对象转换为JSON格式字符串 (fastjson是阿里巴巴提供的用于实现对象和json的转换工具类)
String json = JSONObject.toJSONString(responseResult);
//设置响应头（告知浏览器：响应的数据类型为json、响应的数据编码表为utf-8）
response.setContentType("application/json;charset=utf-8");
//响应
response.getWriter().write(json);

return false;//不放行
}

//5.解析token，如果解析失败，返回错误结果（未登录）
try {
JwtUtils.parseJWT(token);
}catch (Exception e){
log.info("令牌解析失败!");

//创建响应结果对象
Result responseResult = Result.error("NOT_LOGIN");
//把Result对象转换为JSON格式字符串 (fastjson是阿里巴巴提供的用于实现对象和json的转换工具类)
String json = JSONObject.toJSONString(responseResult);
//设置响应头
response.setContentType("application/json;charset=utf-8");
//响应
response.getWriter().write(json);

return false;
}

//6.放行
return true;
}

注册配置拦截器

@Configuration
public class WebConfig implements WebMvcConfigurer {
//拦截器对象
@Autowired
private LoginCheckInterceptor loginCheckInterceptor;

@Override
public void addInterceptors(InterceptorRegistry registry) {
//注册自定义拦截器对象
registry.addInterceptor(loginCheckInterceptor)
.addPathPatterns("/**")
.excludePathPatterns("/login");
}
}

package com.itheima.intercetor;

import com.alibaba.fastjson.JSONObject;
import com.itheima.pojo.Result;
import com.itheima.utils.JwtUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

/**
 * ClassName: LoginCheckInterceptor
 * Package: com.itheima.intercetor
 * Description:
 *
 * @Author 小白
 * @Create 2024/5/2 20:51
 * @Version 1.0
 */
//自定义拦截器
@Component //当前拦截器对象由Spring创建和管理
@Slf4j
public class LoginCheckInterceptor1 implements  HandlerInterceptor {

    @Override   //目标资源方法运行前运行，返回true:放行，放回false,不放行
    public boolean preHandle(HttpServletRequest req, HttpServletResponse resp, Object handler) throws Exception {

        //1.获取请求url  调用getRequestURI()方法得url
        String url = req.getRequestURI().toString();
        log.info("请求的url: {}",url);  请求路径：http://localhost:8080/login
        //2.判断请求url中是否包含login，如果包含，说明是登录操作，放行
        if(url.contains("/login")){
            log.info("登录操作，放行....");
            return  true;
        }
        //3.获取请求头中的令牌（token）
        String jwt = req.getHeader("token");

        //4.判断令牌是否存在，如果不存在，返回错误结果（未登录）
        if (!StringUtils.hasLength(jwt)){
            log.info("请求头:token为空，返回未登录信息");
            Result error = Result.error("NOT_LOGIN");  //
            String notLogin = JSONObject.toJSONString(error);
            resp.getWriter().write(notLogin);
            return  false;

        }
        //5.解析token，如果解析失败，返回错误结果（未登录）
        try {
            JwtUtils.parseJWT(jwt);  //jwt令牌解析成功
        } catch (Exception e) {   //jwt令牌解析失败
            e.printStackTrace();
            log.info("令牌解析失败! 返回未登录的信息");

            Result error = Result.error("NOT_LOGIN");  //
            String notLogin = JSONObject.toJSONString(error);
            resp.getWriter().write(notLogin);
            return  false;
        }
        //6.放行   如果令牌存在并且合法  我们就要放行
        log.info("令牌合法，放行");
        return  true;




    }




    @Override   //目标资源方法运行后运行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle........");
    }

    @Override  //视图渲染完毕后运行，最后运行
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion.......");
    }
}

package com.itheima.config;

import com.itheima.intercetor.LoginCheckInterceptor;
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;

/**
 * ClassName: WebConfig
 * Package: com.itheima.config
 * Description:
 *
 * @Author 小白
 * @Create 2024/5/2 21:00
 * @Version 1.0
 */
@Configuration   //表示当前类是个配置类
public class WebConfig  implements WebMvcConfigurer {

    //拦截器对象
    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;


    /**
     * 怎么样来注册拦截器
     * 调用registry中的方法addInterceptor()来添加拦截器
     * 指定要加入的是哪一个拦截器
     * 这边我们要加入的拦截器是LoginCheckInterceptor
     * 这个LoginCheckInterceptor已经成为IOC容器中的bean对象了
     *  registry.addInterceptor(loginCheckInterceptor):
     *  注册了一个loginCheckInterceptor拦截器
     *  注册了这个拦截器之后 这个拦截器要拦截什么样的资源呢？
     * 调用addPathPatterns()来指定拦截的资源  .addPathPatterns("/**")
     * .excludePathPatterns("/login");不用拦截的资源
     *
     * @param registry
     */
    //注册拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        registry.addInterceptor(loginCheckInterceptor)
                .addPathPatterns("/**")  //设置拦截器拦截的请求路径（ /** 表示拦截所有请求）
                .excludePathPatterns("/login");  //设置不拦截的请求路径
    }
}

登录校验的拦截器编写完成后，接下来我们就可以重新启动服务来做一个测试：（关闭登录校验Filter过滤器）

测试

测试1：未登录是否可以访问部门管理页面

首先关闭浏览器，重新打开浏览器，在地址栏中输入：http://localhost:9528/#/system/dept

由于用户没有登录，校验机制返回错误信息，前端页面根据返回的错误信息结果，自动跳转到登录页面了

测试2：先进行登录操作，再访问部门管理页面

登录校验成功之后，可以正常访问相关业务操作页面

到此我们也就验证了所开发的登录校验的拦截器也是没问题的。登录校验的过滤器和拦截器，我们只需要使用其中的一种就可以了。

姜小白程序

关注

19
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
SpringBootWeb案例3--登录认证--登录校验-- 拦截器Interceptor

实现HandlerInterceptor接口，并重写其所有方法//自定义拦截器@Component//目标资源方法执行前执行。返回true：放行返回false：不放行@Override//true表示放行//目标资源方法执行后执行@Override//视图渲染完毕后执行，最后执行@Override注意：preHandle方法：目标资源方法执行前执行。返回true：放行返回false：不放行。
复制链接

扫一扫