目录
前端发起请求，每次都会在请求头中携带JWT令牌到服务端，而服务端需要统一拦截所有的请求，从而判断是否携带的有合法的JWT令牌。那怎么样来统一拦截到所有的请求校验令牌的有效性呢？这里我们会学习两种解决方案：
1. Filter过滤器
2. Interceptor拦截器
Filter表示过滤器，是 JavaWeb三大组件(Servlet、Filter、Listener)之一。
过滤器可以把对资源的请求拦截下来，从而实现一些特殊的功能
使用了过滤器之后，要想访问web服务器上的资源，必须先经过滤器，过滤器处理完毕之后，才可以访问对应的资源。
过滤器一般完成一些通用的操作，比如：登录校验、统一编码处理、敏感字符处理等。
第1步，定义过滤器 ：定义一个类，实现 Filter 接口，并重写其所有方法。
第2步，配置过滤器：Filter类上加 @WebFilter 注解，配置拦截资源的路径。引导类上加 @ServletComponentScan 开启Servlet组件支持。
定义过滤器
@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);
}
}过滤器：
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());
}
}
执行结果：
执行完初始化方法之后，先执行放行前的逻辑，然后进入拦截器，或者进入controller，处理完成之后，再执行放行后的逻辑，然后再返回前端。
1.过滤器执行流程
过滤器当中我们拦截到了请求之后，如果希望继续访问后面的web资源，就要执行放行操作，放行就是调用 FilterChain对象当中的doFilter()方法，在调用doFilter()这个方法之前所编写的代码属于放行之前的逻辑。
在放行后访问完 web 资源之后还会回到过滤器当中，回到过滤器之后如有需求还可以执行放行之后的逻辑，放行之后的逻辑我们写在doFilter()这行代码之后。
2.拦截路径
3.过滤器链
所谓过滤器链指的是在一个web应用程序当中，可以配置多个过滤器，多个过滤器就形成了一个过滤器链。
比如：在我们web服务器当中，定义了两个过滤器，这两个过滤器就形成了一个过滤器链。
而这个链上的过滤器在执行的时候会一个一个的执行，会先执行第一个Filter，放行之后再来执行第二个Filter，如果执行到了最后一个过滤器放行之后，才会访问对应的web资源。
访问完web资源之后，按照我们刚才所介绍的过滤器的执行流程，还会回到过滤器当中来执行过滤器放行后的逻辑，而在执行放行后的逻辑的时候，顺序是反着的。
先要执行过滤器2放行之后的逻辑，再来执行过滤器1放行之后的逻辑，最后在给浏览器响应数据。
过滤器执行的顺序和类名有关，以注解方式配置的Filter过滤器，它的执行优先级是按时过滤器类名的自动排序确定的，类名排名越靠前，优先级越高。
登录校验的基本流程：
大概清楚了在Filter过滤器的实现步骤了，那在正式开发登录校验过滤器之前，我们思考两个问题：
1. 所有的请求，拦截到了之后，都需要校验令牌吗？
答案：**登录请求例外**
2. 拦截到请求后，什么情况下才可以放行，执行业务操作？
答案：**有令牌，且令牌校验通过(合法)；否则都返回未登录错误结果
基于上面的业务流程，我们分析出具体的操作步骤：
1. 获取请求url
2. 判断请求url中是否包含login，如果包含，说明是登录操作，放行
3. 获取请求头中的令牌（token）
4. 判断令牌是否存在，如果不存在，返回错误结果（未登录）
5. 解析token，如果解析失败，返回错误结果（未登录）
6. 放行
@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);
}
}