一、Filter过滤器

前面我们学会了最先进的会话跟踪技术jwt令牌，那么我们要让用户使用某些功能时就要根据jwt令牌来验证用户身份，来决定他是否登陆了、让不让用户访问这个页面（或功能）

但是这样一来，没发一个请求，后端都要执行一次jwt逻辑判断的逻辑，就会很麻烦

那就需要一个工具：【Filter过滤器】，前端发完请求之后卡在中间，执行一次jwt令牌校验，先过他这关再访问

另外我们前面了解过Servlet是什么了，那么Filter其实也就是【Servlet容器】的【过滤器】，也是Servlet新增的一个功能。“广义上” Filter就是Servlet里的一个【子类】，“狭义上” Filter是Servlet里的一个【接口】

完整官方的表述就是：【实现了javax.servlet.Filter接口的类】

那么【javax.servlet.Filter接口】里定义了三个方法：

1、init( )：初始化Filter

；

2、doFilter( )：执行拦截、过滤逻辑操作

；

3、destory( )：销毁Filter

；

我们不用了解这里面究竟怎么实现，代码是怎样的，这个结构是人家想个半死写出来的，底层结构就是这样，我们只需要记住【Filter就这么三个结构】

那么我们需要怎么用Filter？

简单的Filter实现类的大致结构：

1、Filter是【实现了javax.servlet.Filter接口的类】嘛，那就 “implement” 【实现】这个接口

注意：它是Servlet的“儿子”，那就只能到这个包【javax.servlet】

（如果你实在是搞不清楚导【javax.servlet.annotation.WebFilter】还是导【jakarta.servlet.annotation.WebFilter】包，那么就直接多加一个注解【@Component】，因为当你在一个类上使用【@Component】注解时，Spring 容器会在类路径下扫描这个注解，并自动注册该类作为一个 Bean。

；

2、既然它实现的接口，那【接口实现类】就必须【实现接口的所有抽象方法】

（但是这里有个例外：因为可能很多开发者也意识【init】和【destroy】没什么用，所以有没有都无所谓，所以不写这两个方法也可以）

；

3、最后加上两个注解：

在【Filter实现类】上加【@WebFilter(urlPatterns = "/*")】，代表Filter要拦截的是哪些路径，【"/*"】代表所有路径，后续会详细讲具体拦哪些路径要怎么写

在【......Application启动类】上加【@ServletComponentScan】

我们运行整个spring boot都是通过运行【......Application启动类】来引导，那就要加上对Serevlet组件的使用引导

测试发送请求，后端控制台显示拦截成功

另外注意：spring的扫描机制是基于【启动类Application】扫描跟它同级目录的文件、以及同级目录包里的文件。如果层级再深一点，不用一些特殊注解是不会自动扫描到的。

Filter结构中间的【doFilter( )】方法详解：

那么我们能够知道一个大致的Filter结构是怎么样，很显然，我们根本不需要了解【第一部分init( )】和【最后一部分destroy( )】，只要知道有这两玩意，记得写（复制粘贴）上去就行

重点是中间的【doFilter( )】方法，该如何执行这个方法进行逻辑操作？

很简单

第一步：加一个【chain.doFilter(request , response);】，就可以取消拦截而【放行】

：

【chain.doFilter(? , ?);】方法就是放行拦截，里面要传一个【ServletRequest请求对象】和一个【ServletResponse响应对象】；

给【chain.doFilter(request , response);】打个断点，【chain.doFilter(request , response);】未执行时，拦截请求

【chain.doFilter(request , response);】执行后，请求成功

：

；

第二步：了解【doFilter( )】执行逻辑

前面说过，【doFilter( )】会执行多次，那么逻辑就是【doFilter( )】的运行周期也分为三部分：【chain.doFilter( )前：放行前】、【chain.doFilter( )：放行】、【chain.doFilter( )后：放行后】

那么【chain.doFilter( )前：放行前】的内容只会执行一次，然后执行完一次【doFilter( )】后会再次循环回到【doFilter( )】，但是不会执行【chain.doFilter( )前：放行前】的内容，只会执行【chain.doFilter( )后：放行后】的内容

：

；

第三步：了解放行路径

前面我们讲过【@WebFilter（urlPatterns = "路径"）】表示拦截的路径

那么一共有这么几种拦截路径，看你喜欢来选

这里我就不想演示了，你们自己试试。

；

；

第四步：了解过滤器链

这个我也不想多说，简单解释就是：在刚刚那个案例Filter类的基础上，我们再新建N个Filter类，直接把刚刚那个Filter类里的代码原封不动复制粘贴给这N个Filter类，那么当发送请求时，就会链式连着将所有Filter类都执行一遍，然后再连着返回响应。

；

那么怎么区分哪个Filter类先执行，哪个后执行？看他们【类名】，根据首字母在24个字母的排序来分优先级。比如：【AAA建材王哥Filter.class】就比【z你佬.class】优先执行

利用Filter实现登录校验

首先大体流程：

注意三个点：

1、【登录】接口是例外，不应该被拦截；那么如果不是登录请求，那么再校验令牌，对了通行，不对不通行

‘

2、然后校验令牌也分为两种错误情况：1、没有令牌  2、有令牌，但是是错的（根据【签名密钥】来【解析令牌】，只要【解析令牌】不报错就说明是对的，只要令牌有一个符号变了，就会报错）

’

3、其实JWT令牌的传递是通过【token】这个东西传递的，他跟Cookie的传递很类似，只不过它可以通过【请求头】传递、也可通过【请求体】，一般是在【请求头】

（我上一篇文章讲过）

接下来我们来写一下代码：

这里我累了，你们看代码吧，我不想解释了

package com.czm.tliaswebmanagement.filter;

import com.alibaba.fastjson.JSONObject;
import com.czm.tliaswebmanagement.pojo.Result;
import com.czm.tliaswebmanagement.utils.JwtUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import javax.servlet.annotation.WebFilter;

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

@WebFilter(urlPatterns = "/*" )
public class DemoFilter implements Filter {
    @Autowired
    private JwtUtils jwtUtils;

    @Override //执行拦截、过滤逻辑操作，【执行多次】
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //【HttpServletRequest】是【ServletRequest】的父类，【HttpServletResponse】是【ServletResponse】的父类
        //为什么强转request和response的类型？因为ServletRequest没有【.getRequestURI()】获取【请求url】的功能
        //ServletResponse也没有【.getWriter().write("...")】可以直接把内容写进【响应头】的方法
        javax.servlet.http.HttpServletRequest req = (javax.servlet.http.HttpServletRequest) request;
        javax.servlet.http.HttpServletResponse res = (javax.servlet.http.HttpServletResponse) response;

        //1、获取请求url
        String url = req.getRequestURI();

        //2、判断url中是否含有登录接口（/login），是登录接口（/login）就放行
        if(url.contains("login")){
            //放行
            chain.doFilter(request , response);
            return;//然后结束【doFilter】，不再执行下面内容
        }

        //3、获取【请求头】里的【token】里存着的【jwt令牌】
        //HttpServletRequest 的 getHeader("...");可以获取到请求头的某个属性的值
        String jwt = req.getHeader("token");

        //4、判断令牌是否存在，如果不存在，返回错误结果（未登录）
        //【StringUtils.hasLength(字符串)】可以判断有没有字符串
        //  StringUtils选这个【org.springframework.util】包！！！
        if(!StringUtils.hasLength(jwt)){
            //为什么不能直接return这个【Result.error()】信息？
            //因为那是在controller层，有【@RestController】注解帮我们把【对象】转成【json】给回前端
            //但是在现在这是在Filter类里，要我们手动把【对象】转成【json】，再return
            Result error = Result.error("未登录");

            //调用阿里巴巴的【fastjson】帮忙转
            String notLogin = JSONObject.toJSONString(error);
            //然后HttpServletResponse 的 getWriter().write("...")可以直接把内容写进【响应头】
            res.getWriter().write(notLogin);
            return;
        }

        //5、如果有令牌，那就判断令牌有无有误（错的令牌在【解析jwt】时就会直接报错）
        try {
            //调用jwtUtils工具【解析jwt】
            jwtUtils.parseJWT(jwt);
        } catch (Exception e){
            e.printStackTrace();
            Result error = Result.error("未登录");

            //调用阿里巴巴的【fastjson】帮忙转
            String notLogin = JSONObject.toJSONString(error);
            //然后HttpServletResponse 的 getWriter().write("...")可以直接把内容写进【响应头】
            res.getWriter().write(notLogin);
        }

        //6、如果不是【登录】请求，也不存在【4】【5】的令牌错误，那就说明这个用户令牌无误，给他放行
        chain.doFilter(request, response);
    }
}

注意三个地方：

1、代码第【4】处，因为在controller层时，有【@RestController】注解帮我们把【对象】转成【json】给回前端，但是在现在这是在Filter类里，要我们手动把【对象】转成【json】，再return，那我们就要用到【阿里巴巴的fastjson】

首先在pom.xml引入依赖：

<!-- 阿里巴巴转JSON依赖 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.0</version>
</dependency>

然后使用【JSONObject.toJSONString(对象信息);】就可以转成【JSON字符串】了

；

2、【StringUtils.hasLength(字符串)】可以判断有没有字符串，但是要注意导包不能错！！

；

3、注意【HttpServletRequest】和【HttpServletResponse】到底导哪个包，只导【javax.servlet】的！

二、Interceptor拦截器

Interceptor是区别于Filter的一种【动态】拦截器，基于springMVC技术实现，简单说Filter就是一个傻楞的门卫挡在城门外，然后Interceptor就是在城区里动态拦你路的烦人保安，这里只做简单解释，结尾我会详细讲它两的区别

简单入门（大体上就两步）：

（注意，这里跟Filter一样比较绕脑，但是千万别去理解为什么要这么做！！你要做的就是记住我这里的步骤，你只要知道你要按步骤做就行，别记代码！别研究为什么这么做！）

第一步：注册拦截器

        先新建一个【interceptor】目录，里面创建一个【interceptor类】（跟一个Filter类的类名一样，名字随你起）

        Interceptor其实就是【HandleInterceptor】接口的实现类！所以我们要让它implement【HandleInterceptor】

        然后还是老样子，实现类要重写父接口类的【抽象方法】，直接【Ctrl + O】选择实现上面三个方法

        然后看着三个结构，跟Filter很像，也先简单理解为分为【前】【中】【后】，只是要留意一下第一部分，跟Filter不同的是它是在第一部分拦截住了，return true是放行，rerturn false是不放行

        最后要加一个【Component】让这个【注册好的拦截器工具】放入IOC容器，让外面能用

；

第二步：配置注册类

        刚刚我们注册好了一个Interceptor拦截器类，但是跟Filter不一样，Filter只要在【启动类】加一个【@ServletComponentScan】开启对Servlet组件支持，就能被扫描、运行到；但是Interceptor拦截器不是Servlet的东西，它是属于springMVC的，所以还要通过springMVC的配置来实现它

；

        首先我们创建一个新包名叫【config】，这不单单是为了Interceptor的配置类而创建的，以后我们还会用到很多配置类，所有的【配置类】就统一放这个【config】包；然后我们创建一个Interceptor的配置类，名字随你起

        然后我们要实现的是springMVC里的【WebMvcConfigurer】这个接口父类

        然后老生常谈，【Ctrl + O】，只重写实现这个方法【addInterceptor( )】这个方法

        然后调用它给的那个参数registry的【addIntercepter()】和【addPathPatterns()】方法

先不用管参数registry是啥，他给你了就直接用

        然后【addIntercepter()】方法就是来配置你刚刚注册好的那个【Interceptor类】

【addPathPatterns()】方法是拦截哪些接口的请求，区别于Filter的拦截的是，"/**"才是全部路径

        最后加一个注解【@Configuration】标注它是一个配置类，然后spring boot运行时就会扫描它，然后找到里面要配置的Interceptor，从而扫描到Interceptor类

；

第三步：启动一下

        因为前面我们设置了Filter过滤器的类，那就把那些Filter全注释了，以免影响我们运行

        然后运行，然后我们到apifox尝试发送一个请求试一下

可以清晰看到控制台里Interceptor的拦截流程

详细讲解：

那为什么说他是动态的呢？看下图

例子：

那么我们现在结合登录校验案例来实现Interceptor的逻辑

超嗨简单，逻辑跟Filter一模一样！！我们只要记住三个区别：

1、拦截的方法位置不同

        Filter过滤器的拦截是在中间的那个【doFilter( )】方法

        Interceptor拦截器是在第一部分【preHandle( )】方法！！注意这两的拦截逻辑写的位置！！

；

2、放行的机制不同

        Filter过滤器的放行是通过在中间部分调用【chain.doFilter( request , responnse )】方法

        Interceptor拦截器是通过在第一部分【return true或false】来控制放行

；

3、参数不同，一个要强转类型一个不用

        Filter过滤器的中间的拦截方法【doFilter( )】里传的是【ServletRequest  和  ServletResponse】类型的请求和响应对象参数，所以要强转这两个对象参数类型成【HttpServletRequest  和  HttpServletResponse】才能用；

        Interceptor拦截器的【preHandle( )】方法里传的直接就是【HttpServletRequest  和  HttpServletResponse】，所以不用强转类型，直接爽用好爽啊

所以你就可以直接复制粘贴Filter那的代码，然后改完这三个地方直接用了：

package com.czm.tliaswebmanagement.interceptor;

import com.alibaba.fastjson.JSONObject;
import com.czm.tliaswebmanagement.pojo.Result;
import com.czm.tliaswebmanagement.utils.JwtUtils;
import org.springframework.beans.factory.annotation.Autowired;
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;

@Component
public class LoginCheckInterceptor implements HandlerInterceptor {
    @Autowired
    private JwtUtils jwtUtils;

    @Override//目标资源方法运行前运行，返回true：放行；返回false：不放行
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle，执行【目标资源方法】前");
        //为什么这里不用强转两个参数的类型？因为request就是【HttpServletRequest】类型啊，response就是【HttpServletResponse】类型啊

        //1、获取请求url
        String url = request.getRequestURI();

        //2、判断url中是否含有登录接口（/login），是登录接口（/login）就放行
        if(url.contains("login")){
            //放行
            return true;
        }

        //3、获取【请求头】里的【token】里存着的【jwt令牌】
        //getHeader("...");可以获取到请求头的某个属性的值
        String jwt = request.getHeader("token");

        //4、判断令牌是否存在，如果不存在，返回错误结果（未登录）
        if(!StringUtils.hasLength(jwt)){
            Result error = Result.error("未登录");

            //调用阿里巴巴的【fastjson】手动帮忙转json返回值
            String notLogin = JSONObject.toJSONString(error);
            response.getWriter().write(notLogin);

            //不放行
            return false;
        }

        //5、如果有令牌，那就判断令牌有无有误（错的令牌在【解析jwt】时就会直接报错）
        try {
            //调用jwtUtils工具【解析jwt】
            jwtUtils.parseJWT(jwt);
        } catch (Exception e){
            e.printStackTrace();
            Result error = Result.error("未登录");

            //调用阿里巴巴的【fastjson】帮忙转
            String notLogin = JSONObject.toJSONString(error);
            response.getWriter().write(notLogin);

            //不放行
            return false;
        }

        //6、如果不是【登录】请求，也不存在【4】【5】的令牌错误，那就说明这个用户令牌无误，给他放行
        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,最后执行【视图渲染完毕】后");
    }
}

用apifox请求验证一下

先【不登陆】，发送一下别的接口的请求

结果拦截了，不放行，不返回要的数据

；

；

然后【登录】，发现请求路径里有login，是登录接口请求，直接放行并生成token令牌返回

；

；

然后在登录后再【回到其他接口】发请求，在请求头带上token参数，然后成功放行请求了

好爽啊！！！！爽啊！！！好舒服啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊！！！！

三、Filter过滤器与Interceptor拦截器的区别！！！

那么这两玩意到底有什么区别？不都是拦截吗？下面我就以几个重点分析一下：

1、身世不同

Filter是【Servlet】“家族”的人，写Filter类的时候你们也能发现必须要到Servlet的包

而Interceptor是【springMVC】“家族”的人，写Interceptor的配置类的时候就用到springMVC

2、实现逻辑不同

Filter过滤器是基于函数回调

我们写代码时会发现每个Filter类都有三个参数，其中最后一个参数是【FilterChain】类参数，这就是一个接口参数

然后每个类都有一个【doFilter( )】函数，而我们执行放行的操作不就是在【doFilter( )】函数里调用那个【FilterChain】的【doFilter( )】函数吗？写的时候会不会觉得很奇怪，其实这就是在回调这个【FilterChain】父接口的【doFilter( )】函数，说起来可能不明白，看图：

而Interceptor则是基于Java的反射机制（动态代理）实现的

不好解释我也不知道怎么解释，反正就是直接return回一个布尔值，然后在拦截器接口内部调用其他方法，根据return回来的布尔值来处理放不放行，具体源代码内部逻辑我也没研究所以我不会.......

3、拦截的位置、范围不一样

Filter的拦截的位置是【在Servlet容器里面、SpringMVC容器外面】就进行过滤拦截了

那么它的拦截范围也就是对【所有访问、资源】都进行拦截

Interceptor的拦截位置是【在SpringMVC容器里面、Controller接口前面】

那么它的拦截范围也就是【针对Spring MVC的访问】进行拦截

（多看几张图加深一下记忆，图片都是来自别的博主文章摘录）

4、触发时机不同

既然位置不同，那么触发时机肯定就不一样了，Filter在外面阻拦，那肯定先执行它；然后再到Interceptor；结束了Interceptor之后又回到Filter

5、使用范围不同、实现接口不同

        Filter过滤器实现的是【 javax.servlet.Filter 】接口，而这个接口是在Servlet规范中定义的，也就是说过滤器Filter 的使用要依赖于Tomcat等容器，导致它只能在web程序中使用

        而Interceptor拦截器是一个【Spring MVC组件】，实现的是【Handler Interceptor】接口，并由【Spring MVC容器】管理，并不依赖Tomcat等容器，是可以单独使用的。不仅能应用在web程序中，也可以用于Application、Swing等程序中

另外：DispatcherServlet

Spring环境下，Servlet还提供了一个组件【DispatcherServlet】，它是在Spring MVC容器里的最前面的，在Interceptor拦截器前面，那么大致流程就是：Filter过滤器先过滤拦截外部请求访问——>然后放到DispatcherServlet——>DispatcherServlet再往Controller传，但又遇到Interceptor拦截器阻拦——>最后Interceptor放行，请求资源到达Controller层

我最后最后用最通俗易懂的话来解释：

外部请求是一个乘客，买了一张高铁票要上高铁

Filter就是高铁检票的N多个闸机，它就固定在那，你要进去大厅、进站台就得被它拦一次

然后DispatcherServlet就是站台，你终于通过重重难关来到站台，等待高铁到来然后坐到座位

Interceptor就是检票员，你终于准备要找到高铁座位，准备坐下，Interceptor检票员就动态随机的出现在你面前，要检查你的高铁票，发现你是逃票、站票就让你滚一边呆着，是坐票你就坐着

最后到家的时候，你还是原路返回，只不过Interceptor检票员不会查你了，而是直接放行；你回到站台；到了大厅，过了检票闸机；最后回家，让你爸妈获得你这个宝贝儿子/女儿。