登录认证功能的统一拦截技术（过滤器）

青旅半醒 2023-09-27 17:14 14阅读 0赞

**目录**

1.前言

2.过滤器

(1)说明

(2)使用步骤

(3)说明示例

(4)具体示例

(5)过滤器详细说明

3.登录校验的过滤器实现

(1)实现流程

(2)具体实现

--------------------

### 1.前言 ###

前端发起请求，每次都会在请求头中携带JWT令牌到服务端，而服务端需要统一拦截所有的请求，从而判断是否携带的有合法的JWT令牌。那怎么样来统一拦截到所有的请求校验令牌的有效性呢？这里我们会学习两种解决方案：

1. Filter过滤器  
2. Interceptor拦截器

### 2.过滤器 ###

#### (1)说明 ####

Filter表示过滤器，是 JavaWeb三大组件(Servlet、Filter、Listener)之一。  
过滤器可以把对资源的请求拦截下来，从而实现一些特殊的功能  
使用了过滤器之后，要想访问web服务器上的资源，必须先经过滤器，过滤器处理完毕之后，才可以访问对应的资源。  
过滤器一般完成一些通用的操作，比如：登录校验、统一编码处理、敏感字符处理等。

#### (2)使用步骤 ####

第1步，定义过滤器 ：定义一个类，实现 Filter 接口，并重写其所有方法。

第2步，配置过滤器：Filter类上加 @WebFilter 注解，配置拦截资源的路径。引导类上加 @ServletComponentScan 开启Servlet组件支持。

#### (3)说明示例 ####

定义过滤器

@WebFilter(urlPatterns = "/*") //配置过滤器要拦截的请求路径（ /* 表示拦截浏览器的所有请求 ）
    public class DemoFilter 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);
        }
    
        @Override //销毁方法, 只调用一次
        public void destroy() {
            System.out.println("destroy 销毁方法执行了");
        }
    }

init方法：过滤器的初始化方法。在web服务器启动的时候会自动的创建Filter过滤器对象，在创建过滤器对象的时候会自动调用init初始化方法，这个方法只会被调用一次。  
doFilter方法：这个方法是在每一次拦截到请求之后都会被调用，所以这个方法是会被调用多次的，每拦截到一次请求就会调用一次doFilter()方法。  
destroy方法： 是销毁的方法。当我们关闭服务器的时候，它会自动的调用销毁方法destroy，而这个销毁方法也只会被调用一次。

在定义完Filter之后，Filter其实并不会生效，还需要完成Filter的配置，Filter的配置非常简单，只需要在Filter类上添加一个注解：@WebFilter，并指定属性urlPatterns，通过这个属性指定过滤器要拦截哪些请求。

在启动类上面加上一个注解@ServletComponentScan，通过这个@ServletComponentScan注解来开启SpringBoot项目对于Servlet组件的支持。

@ServletComponentScan
    @SpringBootApplication
    public class TliasWebManagementApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(TliasWebManagementApplication.class, args);
        }
    
    }

#### (4)具体示例 ####

过滤器：

package com.example.demo.filter;
    
    import javax.servlet.*;
    import javax.servlet.annotation.WebFilter;
    import java.io.IOException;
    
    /**
     * @Author linaibo
     * @Date 2023/4/8 21:36
     * @PackageName:com.example.demo.filter
     * @ClassName: DemoFilter
     * @Version 1.0
     */
    @WebFilter("/*") // 配置过滤器要拦截的请求路径（ /* 表示拦截浏览器的所有请求 ）
    public class DemoFilter implements Filter {
        @Override //初始化方法, 只调用一次
        public void init(FilterConfig filterConfig) throws ServletException {
            Filter.super.init(filterConfig);
            System.out.println("初始化方法执行");
        }
    
        @Override //拦截到请求之后调用, 调用多次
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            // 放行前逻辑
            System.out.println("拦截到了请求，放行前的逻辑");
            // 放行到后面进行处理，如果没有拦截器，直接进入controller，如果有，则进入拦截器
            filterChain.doFilter(servletRequest, servletResponse);
            // 放行后逻辑
            System.out.println("拦截到了请求，放行后的逻辑");
        }
    
        @Override //销毁方法, 只调用一次
        public void destroy() {
            System.out.println("销毁方法执行了");
            Filter.super.destroy();
        }
    }

启动类：

package com.example.demo;
    
    import com.example.demo.domain.Student;
    import com.example.demo.service.IBmsBillMemoService;
    import com.example.demo.service.impl.BmsBillMemoServiceImpl;
    import org.apache.commons.beanutils.PropertyUtils;
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.boot.web.servlet.ServletComponentScan;
    import org.springframework.context.ConfigurableApplicationContext;
    import org.springframework.context.annotation.Bean;
    import org.springframework.scheduling.annotation.EnableScheduling;
    import org.springframework.web.client.RestTemplate;
    
    import java.lang.reflect.InvocationTargetException;
    import java.util.Map;
    
    @SpringBootApplication
    //开启定时任务功能
    @EnableScheduling
    // @EnableConfigurationProperties(Student.class)
    //@MapperScan("com.example.demo.mapper")
    @ServletComponentScan
    public class DemoApplication {
    
    //    @Bean
    //    public RestTemplate getRestTemplate(){
    //        return new RestTemplate();
    //    }
        public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
            ConfigurableApplicationContext ctx = SpringApplication.run(DemoApplication.class, args);
            Object bean = ctx.getBean("bmsBillMemoServiceImpl");
            System.out.println(bean);
            IBmsBillMemoService bean1 = ctx.getBean(IBmsBillMemoService.class);
            System.out.println(bean1);
            BmsBillMemoServiceImpl bean2 = ctx.getBean("bmsBillMemoServiceImpl", BmsBillMemoServiceImpl.class);
            System.out.println(bean2);
            Object get = ctx.getBean("get");
            System.out.println(get);
            Map<String, Object> get1 = PropertyUtils.describe("get");
            Student bean3 = ctx.getBean(Student.class);
            System.out.println(bean3.toString());
        }
    
    }

执行结果：

![e2572741172d43688cdd8231a88f82d9.png][]

执行完初始化方法之后，先执行放行前的逻辑，然后进入拦截器，或者进入controller，处理完成之后，再执行放行后的逻辑，然后再返回前端。

#### (5)过滤器详细说明 ####

1.过滤器执行流程

![708254a09b4c4cbfa846c412c4a2a6df.png][]

过滤器当中我们拦截到了请求之后，如果希望继续访问后面的web资源，就要执行放行操作，放行就是调用 FilterChain对象当中的doFilter()方法，在调用doFilter()这个方法之前所编写的代码属于放行之前的逻辑。

在放行后访问完 web 资源之后还会回到过滤器当中，回到过滤器之后如有需求还可以执行放行之后的逻辑，放行之后的逻辑我们写在doFilter()这行代码之后。

2.拦截路径

![029730eb2d6c4ee080b574ed89b71480.png][]

3.过滤器链

所谓过滤器链指的是在一个web应用程序当中，可以配置多个过滤器，多个过滤器就形成了一个过滤器链。

比如：在我们web服务器当中，定义了两个过滤器，这两个过滤器就形成了一个过滤器链。

而这个链上的过滤器在执行的时候会一个一个的执行，会先执行第一个Filter，放行之后再来执行第二个Filter，如果执行到了最后一个过滤器放行之后，才会访问对应的web资源。

访问完web资源之后，按照我们刚才所介绍的过滤器的执行流程，还会回到过滤器当中来执行过滤器放行后的逻辑，而在执行放行后的逻辑的时候，顺序是反着的。

先要执行过滤器2放行之后的逻辑，再来执行过滤器1放行之后的逻辑，最后在给浏览器响应数据。

过滤器执行的顺序和类名有关，以注解方式配置的Filter过滤器，它的执行优先级是按时过滤器类名的自动排序确定的，类名排名越靠前，优先级越高。

### 3.登录校验的过滤器实现 ###

#### (1)实现流程 ####

登录校验的基本流程：

*  要进入到后台管理系统，我们必须先完成登录操作，此时就需要访问登录接口login。
 *  登录成功之后，我们会在服务端生成一个JWT令牌，并且把JWT令牌返回给前端，前端会将JWT令牌存储下来。
 *  在后续的每一次请求当中，都会将JWT令牌携带到服务端，请求到达服务端之后，要想去访问对应的业务功能，此时我们必须先要校验令牌的有效性。
 *  对于校验令牌的这一块操作，我们使用登录校验的过滤器，在过滤器当中来校验令牌的有效性。如果令牌是无效的，就响应一个错误的信息，也不会再去放行访问对应的资源了。如果令牌存在，并且它是有效的，此时就会放行去访问对应的web资源，执行相应的业务操作。

大概清楚了在Filter过滤器的实现步骤了，那在正式开发登录校验过滤器之前，我们思考两个问题：

1. 所有的请求，拦截到了之后，都需要校验令牌吗？  
答案：\*\*登录请求例外\*\*  
2. 拦截到请求后，什么情况下才可以放行，执行业务操作？  
答案：\*\*有令牌，且令牌校验通过(合法)；否则都返回未登录错误结果

基于上面的业务流程，我们分析出具体的操作步骤：

1. 获取请求url  
2. 判断请求url中是否包含login，如果包含，说明是登录操作，放行  
3. 获取请求头中的令牌（token）  
4. 判断令牌是否存在，如果不存在，返回错误结果（未登录）  
5. 解析token，如果解析失败，返回错误结果（未登录）  
6. 放行

#### (2)具体实现 ####

@Slf4j
    @WebFilter(urlPatterns = "/*") //拦截所有请求
    public class LoginCheckFilter implements Filter {
    
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws IOException, ServletException {
            //前置：强制转换为http协议的请求对象、响应对象 （转换原因：要使用子类中特有方法）
            HttpServletRequest request = (HttpServletRequest) servletRequest;
            HttpServletResponse response = (HttpServletResponse) servletResponse;
    
            //1.获取请求url
            String url = request.getRequestURL().toString();
            log.info("请求路径：{}", url); //请求路径：http://localhost:8080/login
    
    
            //2.判断请求url中是否包含login，如果包含，说明是登录操作，放行
            if(url.contains("/login")){
                chain.doFilter(request, response);//放行请求
                return;//结束当前方法的执行
            }
    
    
            //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);
                response.setContentType("application/json;charset=utf-8");
                //响应
                response.getWriter().write(json);
    
                return;
            }
    
            //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;
            }
    
    
            //6.放行
            chain.doFilter(request, response);
    
        }
    }

[e2572741172d43688cdd8231a88f82d9.png]: https://img-blog.csdnimg.cn/e2572741172d43688cdd8231a88f82d9.png
[708254a09b4c4cbfa846c412c4a2a6df.png]: https://img-blog.csdnimg.cn/708254a09b4c4cbfa846c412c4a2a6df.png
[029730eb2d6c4ee080b574ed89b71480.png]: https://img-blog.csdnimg.cn/029730eb2d6c4ee080b574ed89b71480.png