① 定义 Filter：实现 Filter 接口#

1
@WebFilter(urlPatterns = "/*") // 拦截所有请求
2
@Slf4j
3
public class DemoFilter implements Filter {
4
    //初始化方法，web 服务器启动、创建 Filter 实例时调用，只调用一次
5
    @Override
6
    public void init(FilterConfig filterConfig) throws ServletException {
7
        log.info("init 初始化方法 ....");
8
    }
9

10
    //拦截到请求时调用，可以调用多次
11
    @Override
12
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
13
        log.info("拦截到了请求.... 放行前 .... ");
14
        //放行
15
        filterChain.doFilter(servletRequest, servletResponse);
16
        log.info("拦截到了请求.... 放行后 .... ");
17
    }
18

19
    //销毁方法，web 服务器关闭时调用，只调用一次
20
    @Override
21
    public void destroy() {
22
        log.info("destroy 销毁方法 ....");
23
    }
24
}

② 引导类：开启 Servlet 组件扫描#

1
@ServletComponentScan // 开启 Servlet 组件（Servlet、Filter、Listener）的支持
2
@SpringBootApplication
3
public class TliasManagementApplication {
4
    public static void main(String[] args) {
5
        SpringApplication.run(TliasManagementApplication.class, args);
6
    }
7
}

@WebFilter 是 Servlet 规范里的注解，Spring Boot 默认不认识它——引导类上加了 @ServletComponentScan，Spring Boot 才会去扫描项目里的 @WebFilter（顺便也扫描 @WebServlet、@WebListener）并把过滤器注册进 web 容器。少了这个注解，过滤器就是一个普通的类，永远不会被调用。

三个方法分别在什么时候执行#

必答问答（PPT 第 34 页）#

先想两个问题（PPT 第 36 页）#

PPT 在画流程图之前先抛出两个问题，答案也写在同一页上：

令牌校验的六步流程（PPT 第 37 页）#

第 37 页把上面两个问题的答案展开成了六步，左边是画出来的流程图，右边是文字步骤：

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

1
请求 ──▶ 获取请求路径 ──▶ 路径里包含 login ？ ──是──▶ 放行
2
                          │否
3
                          ▼
4
                    获取请求头 token ──▶ 有 token ？ ──否──▶ 响应 401
5
                          │是
6
                          ▼
7
                    解析 token ──▶ 解析成功？ ──否──▶ 响应 401
8
                          │是
9
                          ▼
10
                        放行

流程图底下还给了两条对照用的真实路径：http://localhost:8080/login（走”包含 login → 放行”这条最左边的捷径）和 http://localhost:8080/emps（走完全部六步才放行）。

写成代码：TokenFilter#

课程工程里的实现（com.itheima.filter.TokenFilter），每一步都和上面的六步一一对应：

1
@Slf4j
2
@WebFilter(urlPatterns = "/*") // 拦截所有请求
3
public class TokenFilter implements Filter {
4
    @Override
5
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
6
        HttpServletRequest request = (HttpServletRequest) servletRequest;
7
        HttpServletResponse response = (HttpServletResponse) servletResponse;
8

9
        //1. 获取到请求路径
10
        String requestURI = request.getRequestURI(); // 例如 /login、/emps
11

12
        //2. 判断是否是登录请求，如果路径中包含 /login，说明是登录操作，放行
13
        if (requestURI.contains("/login")) {
14
            log.info("登录请求, 放行");
15
            filterChain.doFilter(request, response);
16
            return;
17
        }
18

19
        //3. 获取请求头中的 token
20
        String token = request.getHeader("token");
21

22
        //4. 判断 token 是否存在，如果不存在，说明用户没有登录，返回错误信息（响应 401 状态码）
23
        if (token == null || token.isEmpty()) {
24
            log.info("令牌为空, 响应401");
25
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); // 401
26
            return;
27
        }
28

29
        //5. 如果 token 存在，校验令牌，如果校验失败 -> 返回错误信息（响应 401 状态码）
30
        try {
31
            JwtUtils.parseToken(token);
32
        } catch (Exception e) {
33
            log.info("令牌非法, 响应401");
34
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); // 401
35
            return;
36
        }
37

38
        //6. 校验通过，放行
39
        log.info("令牌合法, 放行");
40
        filterChain.doFilter(request, response);
41
    }
42
}

几处细节值得单独记一下：

• request.getHeader("token")：令牌是前端放在请求头里带过来的，键名就是课程约定的 token（82 篇里登录成功后前端保存令牌、之后每次请求带上它）。
• HttpServletResponse.SC_UNAUTHORIZED：常量值就是 401，语义是”未认证”——没登录、令牌无效都归它。三个”拦下来”的分支都只写 setStatus(401) 然后 return——return 之后没有调用 chain.doFilter，就是”不放行”，接口不会被执行。
• JwtUtils.parseToken(token) 放在 try/catch 里：解析失败（签名对不上、令牌被篡改、令牌过期）会抛异常，82 篇讲过具体是 SignatureException / ExpiredJwtException——这里不关心是哪种，只要抛了异常就统一回 401。
• 第 2 步的路径判断用的是 contains("/login") 而不是 equals：只要路径里包含 login 就放行，写法更宽松。另一种更”Spring”的思路是不写这个 if，改在注册的时候把 /login 排除掉——那正是 84 篇拦截器方案的做法。

一、知识回顾（读完直接做下面的实践题）#

1. 过滤器的定位：Filter 是 JavaWeb 三大组件（Servlet、Filter、Listener）之一；作用是把对资源的请求拦截下来，实现一些特殊的功能
2. 过滤器的典型场景：一般做通用操作——登录校验、统一编码处理、敏感字符处理等
3. 三个方法的调用时机：init——web 服务器启动、创建 Filter 实例时调用，只调用一次；doFilter——拦截到请求时调用，可以调用多次；destroy——web 服务器关闭时调用，只调用一次
4. 快速入门两步：定义——写一个类实现 Filter 接口（重写三个方法）；配置——类上加 @WebFilter(urlPatterns = "/*")，引导类上加 @ServletComponentScan 开启 Servlet 组件支持（少了它过滤器不会被扫描到）
5. 放行的写法：chain.doFilter(request, response)；如果过滤器中不执行放行操作，拦截到请求之后就不会访问对应的资源
6. 执行流程：放行前 → 放行 → 资源 → 放行后；资源执行完会回到 Filter，执行的是放行后的逻辑（不是重新执行一遍）
7. 令牌校验的六步：① 取请求路径 → ② 路径里包含 login 就放行 → ③ 取请求头里的 token → ④ 没有 token 响应 401 → ⑤ JwtUtils.parseToken 解析失败 响应 401 → ⑥ 校验通过放行
8. 拦截路径的三种写法：/login（拦截具体路径）、/emps/*（目录拦截，/emps 下的所有资源）、/*（拦截所有）
9. 过滤器链：一个应用里配置多个过滤器就形成过滤器链；注解配置的 Filter 优先级按过滤器类名（字符串）的自然排序（工程里 DemoFilter → TokenFilter → XyzFilter）
10. 本机实测：不带 token 访问 /emps → HTTP 401；带合法 token → 200；篡改 token → 401；POST /login → 放行；另外 /c1、/c2 这类演示接口也被 /* 的过滤器拦住（“一网打尽”）

二、裸写题#

• 2-1 写一个入门过滤器，看三个方法分别在什么时候被调用 需求：给工程加一个”什么都不做、只是记事”的过滤器：服务器启动时输出一行 init 初始化方法 ....；每当有请求进来，在真正访问资源之前输出一行、在资源处理完之后再输出一行；服务器关闭时输出一行 destroy 销毁方法 ....。要求它拦截所有请求，并且不能挡住任何请求（接口该照常返回数据）。 （练习文件 test_83_Filter快速入门.java 的题目2-1 里给了写作区。）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：一个类分三段——启动时一次、每次请求两次（去一趟、回一趟）、关闭时一次；“不能挡请求”意味着必须做”放行”这个动作 二级 · 方法：类实现 Filter 接口（要写 init / doFilter / destroy）；类上加 @WebFilter(urlPatterns = "/*")；引导类上加 @ServletComponentScan；放行是 chain.doFilter(request, response) 三级 · 骨架：

  1
  @____(urlPatterns = "/*")
  2
  public class DemoFilter implements ____ {
  3
      public void init(____ filterConfig) throws ServletException { …… }
  4
      public void doFilter(____ req, ____ resp, ____ chain) throws Exception {
  5
          // 放行前逻辑
  6
          ____.____(req, resp);     // 放行
  7
          // 放行后逻辑
  8
      }
  9
      public void destroy() { …… }
  10
  }

  参考答案（做完再点开）

  1
  @WebFilter(urlPatterns = "/*") // 拦截所有请求
  2
  @Slf4j
  3
  public class DemoFilter implements Filter {
  4
      //初始化方法，web 服务器启动、创建 Filter 实例时调用，只调用一次
  5
      @Override
  6
      public void init(FilterConfig filterConfig) throws ServletException {
  7
          log.info("init 初始化方法 ....");
  8
      }
  9
  
  10
      //拦截到请求时调用，可以调用多次
  11
      @Override
  12
      public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
  13
          log.info("拦截到了请求.... 放行前 .... ");
  14
          //放行
  15
          filterChain.doFilter(servletRequest, servletResponse);
  16
          log.info("拦截到了请求.... 放行后 .... ");
  17
      }
  18
  
  19
      //销毁方法，web 服务器关闭时调用，只调用一次
  20
      @Override
  21
      public void destroy() {
  22
          log.info("destroy 销毁方法 ....");
  23
      }
  24
  }

  显示更多显示更少

  引导类上别忘了：

  1
  @ServletComponentScan // 开启 Servlet 组件支持
  2
  @SpringBootApplication
  3
  public class TliasManagementApplication { …… }

  自查：① 应用启动时打印一次 init（在这之前不会有别的输出）；② 每发一次请求，放行前 先打、放行后 后打，中间隔着 Controller 自己的日志——这个先后顺序正好证明了”资源执行完还会回到 Filter”；③ 关闭应用时打印一次 destroy；④ 接口的响应数据一切正常（说明放行成功了）。

• 2-2 写一个过滤器，把没带令牌的请求挡在外面 需求：后台接口（员工 /emps、部门 /depts、报表……）只有登录过的用户才能访问：请求头里带了合法令牌的，放过去执行；没带令牌、或者令牌被改过（解析不通过）的，直接返回 401，不要让后面的接口执行。另外，登录请求本身（路径里包含 /login）必须能正常访问。这个过滤器要管住所有请求。 （练习文件 test_83_登录校验Filter.java 的题目2-2 里给了写作区。）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：按”先认出登录请求直接放行 → 再从请求头取令牌 → 没令牌/令牌不合法就 401 → 合法才放行”这个顺序写六段逻辑 二级 · 方法：request.getRequestURI() 取请求路径（判断里用 contains("/login")）；request.getHeader("token") 取请求头里的令牌；401 用 HttpServletResponse.SC_UNAUTHORIZED；解析用工程里已有的 JwtUtils.parseToken(token)（解析失败会抛异常，要 try/catch 包住）；“拦下来”就是只 return、不调用放行；“放行”是 chain.doFilter(request, response) 三级 · 骨架：

  1
  //1. 获取请求路径 → String requestURI = request.____();
  2
  //2. 路径中包含 "login" → 放行 + return
  3
  //3. 获取请求头 token → String token = request.____("____");
  4
  //4. token 为空 → response.setStatus(____); return;
  5
  //5. try { ____.____(token); } catch (Exception e) { 401; return; }
  6
  //6. 放行

  参考答案（做完再点开）

  1
  @Slf4j
  2
  @WebFilter(urlPatterns = "/*") // 拦截所有请求
  3
  public class TokenFilter implements Filter {
  4
      @Override
  5
      public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
  6
          HttpServletRequest request = (HttpServletRequest) servletRequest;
  7
          HttpServletResponse response = (HttpServletResponse) servletResponse;
  8
  
  9
          //1. 获取到请求路径
  10
          String requestURI = request.getRequestURI(); // 例如 /login、/emps
  11
  
  12
          //2. 判断是否是登录请求，如果路径中包含 /login，说明是登录操作，放行
  13
          if (requestURI.contains("/login")) {
  14
              log.info("登录请求, 放行");
  15
              filterChain.doFilter(request, response);
  16
              return;
  17
          }
  18
  
  19
          //3. 获取请求头中的 token
  20
          String token = request.getHeader("token");
  21
  
  22
          //4. 判断 token 是否存在，如果不存在，说明用户没有登录，返回 401
  23
          if (token == null || token.isEmpty()) {
  24
              log.info("令牌为空, 响应401");
  25
              response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); // 401
  26
              return;
  27
          }
  28
  
  29
          //5. 如果 token 存在，校验令牌，如果校验失败 -> 返回 401
  30
          try {
  31
              JwtUtils.parseToken(token);
  32
          } catch (Exception e) {
  33
              log.info("令牌非法, 响应401");
  34
              response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); // 401
  35
              return;
  36
          }
  37
  
  38
          //6. 校验通过，放行
  39
          log.info("令牌合法, 放行");
  40
          filterChain.doFilter(request, response);
  41
      }
  42
  }

  显示更多显示更少

  自查：① 两个”拦下”分支里都没有 chain.doFilter——所以接口不会被调用；② 401 用常量 SC_UNAUTHORIZED 写，别记错成 SC_FORBIDDEN（那是 403，语义不同）；③ 本机实测的四种结果：无 token → 401、带合法 token → 200、篡改 token → 401、POST /login → 放行；④ 注意 @WebFilter 配的是 /*，所以连 /c1、/c2 这种跟登录无关的演示接口也会被拦住——这正是”一网打尽”。

• 2-3 只拦一个目录，并说出”为什么登录校验的过滤器必须拦所有” 需求：先把上面这个过滤器改成”只拦 /emps 目录下的所有资源”（其他路径一律不管）；改完回答两个问题：① /emps/* 与 /* 分别是什么意思？② 如果登录校验的过滤器真的写成 /emps/*，系统会出什么问题？ （练习文件 test_83_登录校验Filter.java 的题目2-3 里给了写作区。）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：过滤器本身一个字都不用改，改的只是类上那个注解里的”拦截路径”值；第 ② 问从”拦截路径表的含义 + 系统里都有哪些接口”两头推 二级 · 方法：@WebFilter(urlPatterns = "/emps/*")；/emps/* 是目录拦截、/* 是拦截所有 三级 · 骨架：@WebFilter(urlPatterns = "____")；① /emps/* = 访问 /emps 下的____都会被拦截，/* = ；② 因为 /depts、报表这些接口不在 /emps 下，

  参考答案（做完再点开）

  改动只有一行：

  1
  @WebFilter(urlPatterns = "/emps/*") // 只拦截 /emps 目录下的资源

  ① /emps/*：目录拦截——访问 /emps 下的所有资源都会被拦截（/emps、/emps/1、/emps/list 之类）；/*：拦截所有——访问所有资源都会被拦截（整个系统的任意请求）。 ② 如果登录校验的过滤器写成 /emps/*，只有员工相关的接口被保护，部门管理 /depts、报表等接口就”裸奔”了——未登录也能直接访问，81 篇联调时发现的那个问题（未登录也能访问部门、员工、报表）只解决了一小半。登录校验要保护的是整个后台系统，所以课程用的是 /*。（顺便一提：写成 /emps/* 时登录接口确实也能访问——但那是”因为它不在 /emps 下而侥幸穿过”，不是有意放行，一旦把范围改大就会把登录接口一起挡住。）

• 2-4 说出过滤器链的执行顺序 需求：工程里有三个过滤器类，类名分别是 DemoFilter、TokenFilter、XyzFilter，它们都用注解配置成拦截所有请求，也没有做任何额外的排序设置。请回答：① 一个请求会按什么顺序经过它们？② “放行后”的输出顺序和”放行前”相比是正序还是反序？为什么？③ 如果希望 XyzFilter 最先执行，应该怎么改？ （练习文件 test_83_Filter快速入门.java 的题目2-4 里给了写作区。）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：注解配置的过滤器有一套固定的排序依据，这个依据跟”类名”本身有关，而不是代码里写的顺序；把过滤器链想成一叠”套娃”，请求是钻进去再钻出来 二级 · 方法：注解配置的 Filter 优先级按照过滤器类名（字符串）的自然排序；想让某个过滤器排前面，最直接的办法就是让它的类名排前面（改类名） 三级 · 骨架：① ____Filter → ____Filter → ____Filter；② 放行后是____序，因为放行是”先进后出”；③ 把类名改成排序靠前的名字，比如把 XyzFilter 改成 ____Filter

  参考答案（做完再点开）

  ① 按类名的自然排序：DemoFilter（D）→ TokenFilter（T）→ XyzFilter（X）。所以请求依次经过三者的放行前逻辑。（工程里默认只打开了 TokenFilter 的 @WebFilter，另外两个是演示空壳；把它们的注释放开，就能在控制台亲眼看到这个顺序。） ② 反序：放行后的输出顺序是 XyzFilter → TokenFilter → DemoFilter。因为每一层过滤器都是”放行 → 里面所有东西（包括更内层的过滤器和资源）干完 → 才继续执行放行后逻辑”，越靠近资源的过滤器越早走完放行前、也就越早开始放行后；整体是先进后出（套娃式）。 ③ 让 XyzFilter 的名字排到最前面即可，比如改名成 AXyzFilter（A < D < T）。这也说明了为什么不要随手动工程里过滤器的类名——名字动了，链里的位置就变了。

三、综合题#

• 3-1 照着课程给 Tlias 加上登录校验过滤器，并把四种请求实测一遍 这一题把本节从头到尾走一遍，重点在”用状态码和日志把六步流程验证出来”。

  1. 新建过滤器类，按六步写好登录校验逻辑，“拦下”的分支只响应 401、不放行；
  2. 类上配置成拦截所有请求；引导类上确认已开启 Servlet 组件扫描；
  3. 启动工程，不带 token 访问员工列表接口（/emps），记录 HTTP 状态码；
  4. 用登录接口拿到令牌（POST /login，请求体是 {"username":"...","password":"..."}），把响应里的 token 抄下来；
  5. 在请求头里带上这个令牌，再访问一次 /emps，记录状态码；
  6. 把令牌末尾随便改一个字符（篡改）后再访问一次，记录状态码；
  7. 访问登录接口本身，确认它没有被拦（能正常返回登录结果）；
  8. 去服务端日志里找出四种分支各自的输出（登录请求放行 / 令牌为空 / 令牌非法 / 令牌合法）；
  9. 收尾回答下面的两个问题。

  （练习文件 test_83_登录校验Filter.java 的”综合题”一段里按这 9 步给了写作区。）

  回答：① 第 6 步为什么会失败？（想一想解析令牌时到底在校验什么）② 如果把第 5 步的令牌换成一个”12 小时以前生成的”，结果会怎样、为什么？

  涉及知识点

  知识点	在这里的应用
  过滤器概念与场景（PPT 32）	第 1 步——为什么这件事要交给过滤器而不是写在 Controller 里
  三个方法与 @WebFilter、@ServletComponentScan（PPT 33～34）	第 1、2 步——定义 + 让过滤器被扫描到
  放行的含义（PPT 33～34、39）	第 1、3、5、6 步——chain.doFilter 调没调用，直接决定接口能不能执行
  令牌校验六步流程（PPT 36～37）	第 1、4、5、6、7 步——登录放行、无令牌 401、解析失败 401
  拦截路径（PPT 40）	第 2、7 步——/* 一网打尽，登录请求靠代码里的判断放行

  提示（先自己想，实在想不出再点开）

  一级 · 思路：先让”没令牌的 401、有令牌的 200”两条对照跑通，再动令牌做破坏性测试；日志里的四种分支就是流程六步的”打卡记录” 二级 · 方法：请求头键名 token；401 用 HttpServletResponse.SC_UNAUTHORIZED；解析用 JwtUtils.parseToken(token)（try/catch 捕获异常）；登录用 POST /login + JSON 请求体 三级 · 骨架：① 六步里的关键词——getRequestURI()、contains("____")、getHeader("____")、setStatus(____)、____.parseToken(token)、chain.____(request, response)；④ POST http://localhost:8080/____；⑤ 请求头 ____: <token>；⑧ 四种日志：登录请求, 放行 / 令牌为空, 响应401 / 令牌非法, 响应401 / 令牌合法, 放行

  参考答案（做完再点开）

  1. 过滤器代码见题目 2-2 的答案（六步流程），配置见题目 2-1 的答案（@WebFilter(urlPatterns = "/*") + 引导类 @ServletComponentScan）。
  2. 拦截所有请求：@WebFilter(urlPatterns = "/*")。 3～7. 本机实测的四种结果：

     1
     不带 token 访问 /emps       → HTTP 401
     2
     带合法 token 访问 /emps     → HTTP 200
     3
     篡改 token（末尾加字符）    → HTTP 401
     4
     POST /login                → 正常放行（路径里包含 "/login"）

  3. 本机实测的四条日志分支：登录请求, 放行、令牌为空, 响应401、令牌非法, 响应401、令牌合法, 放行——正好对应六步流程里的四个出口。
  4. 两个回答： ① 因为 JWT 的签名是服务端用秘钥对”头.载荷”算出来的，改掉令牌里任何一个字符，重新算出来的签名就和令牌里带的那个对不上；JwtUtils.parseToken 在校验签名时会直接抛异常，过滤器把它统一转成 401（82 篇讲过的 SignatureException）。这也正是”签名防篡改”的设计目的：客户端保存的令牌即使被改，也伪造不出合法的。 ② 会同样被拦下、返回 401：课程里令牌的有效期是 12 小时，12 小时以前生成的令牌已经过期，解析时会抛 ExpiredJwtException（82 篇本机实测过这个报错），过滤器照样 catch 到异常 → 401。用户侧的表现就是”登录状态失效了、需要重新登录”。