① 定义拦截器：实现 HandlerInterceptor 接口#

1
@Slf4j
2
@Component // 交给 Spring 管理——注册时才能把它注入到配置类里
3
public class DemoInterceptor implements HandlerInterceptor {
4
    //在目标资源方法运行之前运行 —— 返回值：true 放行，false 不放行
5
    @Override
6
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
7
        log.info("preHandle ....");
8
        return true;
9
    }
10

11
    //在目标资源方法运行之后运行
12
    @Override
13
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
14
        log.info("postHandle ....");
15
    }
16

17
    //视图渲染完毕后运行（最后执行）
18
    @Override
19
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
20
        log.info("afterCompletion ....");
21
    }
22
}

② 注册拦截器：配置类实现 WebMvcConfigurer#

1
@Configuration
2
public class WebConfig implements WebMvcConfigurer {
3

4
    @Autowired
5
    private DemoInterceptor demoInterceptor; // 注入要注册的拦截器
6

7
    @Override
8
    public void addInterceptors(InterceptorRegistry registry) {
9
        registry.addInterceptor(demoInterceptor) // 注册拦截器
10
                .addPathPatterns("/**");         // 拦截所有请求
11
    }
12
}

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

必答问答（PPT 第 47 页）#

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

1. 拦截器的定位：一种动态拦截方法调用的机制，类似于过滤器；Spring 框架中提供的，主要用来动态拦截控制器方法的执行
2. 拦截器的作用：拦截请求，在指定的方法调用前后，根据业务需要执行预先设定的代码
3. 快速入门两步：定义——实现 HandlerInterceptor 接口并重写三个方法；注册——写一个配置类实现 WebMvcConfigurer，在 addInterceptors 里注册
4. 三个方法的执行时机：preHandle——目标资源方法执行前（返回 true 放行、false 不放行）；postHandle——目标资源方法执行后；afterCompletion——视图渲染完毕后执行，最后执行
5. “放行/拦截”的表达：拦截器统一用 preHandle 的返回值——return true 放行、return false 不放行（返回 false 时 Controller 方法和后面两个方法都不会执行）
6. 注册时的两个方法：addPathPatterns(...) 配”要拦截哪些资源”、excludePathPatterns(...) 配”不需要拦截哪些资源”（课程的登录校验就是 /** + 排除 /login）
7. 拦截路径的四种写法：/* 一级路径（/depts、/emps、/login，不含 /depts/1）；/** 任意级路径；/depts/* /depts 下的一级路径（/depts/1，不含 /depts/1/2，也不含 /depts 本身）；/depts/** /depts 下的任意级路径
8. Filter 与 Interceptor 的两点区别：接口规范不同（Filter vs HandlerInterceptor）；拦截范围不同（过滤器拦所有资源，拦截器拦 Spring 环境中的资源）
9. 拦截范围的实测修正：拦截器方案下不带 token 访问 resources/static/test-page.html 同样返回 HTTP 401——静态资源由 Spring MVC 的 ResourceHttpRequestHandler 处理，照样过拦截器；真正拦不到的是不进 DispatcherServlet 的请求
10. 本机实测：注册 TokenInterceptor（/** + 排除 /login）后——无 token 访问 /emps → 401；带合法 token → 200；POST /login → 放行（excludePathPatterns 生效）

二、裸写题#

• 2-1 写一个入门拦截器，观察三个方法谁先谁后 需求：给工程加一个”记事”拦截器：Controller 方法执行前输出一行、Controller 方法执行后输出一行、整个请求彻底结束（最后收尾）时再输出一行。要求它不拦任何请求（接口都正常返回数据）；写完再把它注册成”拦截所有请求”。 （练习文件 test_84_注册拦截器.java 的题目2-1 里给了写作区。）

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

  一级 · 思路：分两段写——一段是拦截器本身（三个方法，一个管”放不放行”、两个管”前后记一笔”），一段是配置类把它注册进去 二级 · 方法：拦截器实现 HandlerInterceptor、加 @Component；配置类加 @Configuration 并实现 WebMvcConfigurer，在 addInterceptors(InterceptorRegistry registry) 里 registry.addInterceptor(...).addPathPatterns("/**") 三级 · 骨架：

  1
  @Component
  2
  public class DemoInterceptor implements ____ {
  3
      public boolean ____(HttpServletRequest req, HttpServletResponse resp, Object handler) { return ____; }
  4
      public void ____(HttpServletRequest req, HttpServletResponse resp, Object handler, ModelAndView mv) { …… }
  5
      public void ____(HttpServletRequest req, HttpServletResponse resp, Object handler, Exception ex) { …… }
  6
  }
  7
  
  8
  @Configuration
  9
  public class WebConfig implements ____ {
  10
      @Autowired private DemoInterceptor demoInterceptor;
  11
      @Override public void ____(____ registry) {
  12
          registry.____(demoInterceptor).____("/**");
  13
      }
  14
  }

  参考答案（做完再点开）

  1
  @Slf4j
  2
  @Component
  3
  public class DemoInterceptor implements HandlerInterceptor {
  4
      //在目标资源方法运行之前运行 —— 返回值：true 放行，false 不放行
  5
      @Override
  6
      public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  7
          log.info("preHandle ....");
  8
          return true;
  9
      }
  10
  
  11
      //在目标资源方法运行之后运行
  12
      @Override
  13
      public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
  14
          log.info("postHandle ....");
  15
      }
  16
  
  17
      //视图渲染完毕后运行（最后执行）
  18
      @Override
  19
      public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  20
          log.info("afterCompletion ....");
  21
      }
  22
  }

  显示更多显示更少

  1
  @Configuration
  2
  public class WebConfig implements WebMvcConfigurer {
  3
      @Autowired
  4
      private DemoInterceptor demoInterceptor;
  5
  
  6
      @Override
  7
      public void addInterceptors(InterceptorRegistry registry) {
  8
          registry.addInterceptor(demoInterceptor).addPathPatterns("/**");
  9
      }
  10
  }

  自查：① 一次请求的日志顺序是 preHandle →（Controller 自己的日志）→ postHandle → afterCompletion，说明三个方法正好夹在 Controller 前后和请求收尾；② 把 preHandle 的 return true 改成 return false，接口就再也拿不到数据了，而且 postHandle / afterCompletion 都不会打印——这就是”不放行”；③ 拦截器类忘了加 @Component 时，配置类里的 @Autowired 会注入失败（启动直接报错），因为注册的对象得先由 Spring 管理。

• 2-2 把”没带令牌就拦下”的校验逻辑改成拦截器实现 需求：原来写在过滤器里的那套校验（没令牌、或令牌不合法 → 401；登录请求放行）改成用拦截器实现。要求：校验逻辑写在拦截器里；登录请求的”例外”通过注册时排除来实现（不要又在代码里判断路径里有没有 login）；拦截范围仍然是所有请求。 （练习文件 test_84_登录校验拦截器.java 的题目2-2 里给了写作区。）

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

  一级 · 思路：校验的六步和过滤器版本一样，变的只有两处——“不放行”不再用”不调用放行”，而是”返回一个布尔值”；登录例外不在代码里判路径，而是写进注册时的排除名单 二级 · 方法：preHandle 返回 boolean（return true 放行、return false 不放行）；类上加 @Component（配置类里要注入它）；401 用 HttpServletResponse.SC_UNAUTHORIZED；解析令牌用 JwtUtils.parseToken(token) 并用 try/catch 包住；注册时 addPathPatterns("/**") + excludePathPatterns("/login") 三级 · 骨架：

  1
  @Component
  2
  public class TokenInterceptor implements ____ {
  3
      public boolean ____(HttpServletRequest request, HttpServletResponse response, Object handler) {
  4
          String token = request.____("token");
  5
          if (token == null || token.isEmpty()) { response.setStatus(____); return ____; }
  6
          try { ____.____(token); } catch (Exception e) { response.setStatus(____); return ____; }
  7
          return ____;
  8
      }
  9
  }
  10
  // 注册：registry.addInterceptor(tokenInterceptor).addPathPatterns("____").excludePathPatterns("____");

  参考答案（做完再点开）

  1
  @Slf4j
  2
  @Component
  3
  public class TokenInterceptor implements HandlerInterceptor {
  4
      @Override
  5
      public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  6
          //1. 获取请求头中的 token
  7
          String token = request.getHeader("token");
  8
  
  9
          //2. 判断 token 是否存在，如果不存在，说明用户没有登录，返回 401
  10
          if (token == null || token.isEmpty()) {
  11
              log.info("令牌为空, 响应401");
  12
              response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); // 401
  13
              return false; // 不放行
  14
          }
  15
  
  16
          //3. 如果 token 存在，校验令牌，如果校验失败 -> 返回 401
  17
          try {
  18
              JwtUtils.parseToken(token);
  19
          } catch (Exception e) {
  20
              log.info("令牌非法, 响应401");
  21
              response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); // 401
  22
              return false; // 不放行
  23
          }
  24
  
  25
          //4. 校验通过，放行
  26
          log.info("令牌合法, 放行");
  27
          return true; // 放行
  28
      }
  29
  }

  显示更多显示更少

  注册（配置类里）：

  1
  @Configuration
  2
  public class WebConfig implements WebMvcConfigurer {
  3
      @Autowired
  4
      private TokenInterceptor tokenInterceptor;
  5
  
  6
      @Override
  7
      public void addInterceptors(InterceptorRegistry registry) {
  8
          registry.addInterceptor(tokenInterceptor)
  9
                  .addPathPatterns("/**")          // 拦截所有请求
  10
                  .excludePathPatterns("/login");  // 不拦截登录请求
  11
      }
  12
  }

  自查：① 两个”拦下”分支都是 return false，通过时才是 return true；② 注册里必须有 excludePathPatterns("/login")，否则登录请求会被这个拦截器挡在门外、用户永远登不上（本机实测里 /login 能正常返回登录结果，就是这一行在起作用）；③ 本机实测的三种结果：无 token → 401、带合法 token → 200、POST /login → 放行；④ 和过滤器版本对照一下：拦截器版本的代码里已经没有判断请求路径那两步了。

• 2-3 判断四种路径写法各能匹配什么 需求：从 /depts、/depts/1、/depts/1/2、/emps/1 这几个路径里，分别挑出下面四种拦截路径能匹配和不能匹配的：① /* ② /** ③ /depts/* ④ /depts/**。写完再回答两个小问题：Ⅰ 想拦截 /depts 下面的一级路径怎么写？Ⅱ 想拦截 /depts 本身和它下面的任意级怎么写？ （练习文件 test_84_注册拦截器.java 的题目2-3 里给了写作区。）

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

  一级 · 思路：* 与 ** 的区别就是”吃一段”还是”吃任意段”；前面带上具体目录，就表示”只在这个目录下” 二级 · 方法：/* 一级路径；/** 任意级路径；/depts/* 是 /depts 下的一级路径（/depts 本身不算）；/depts/** 是 /depts 下的任意级路径（包含 /depts 本身） 三级 · 骨架：① /* → 能匹配____，不能匹配____；② /** → ____；③ /depts/* → ____；④ /depts/** → ____；Ⅰ 用 ____；Ⅱ 用 ____

  参考答案（做完再点开）

  ① /*（一级路径）：能匹配 /depts；不能匹配 /depts/1、/depts/1/2、/emps/1。 ② /**（任意级路径）：/depts、/depts/1、/depts/1/2、/emps/1 都能匹配（任意层级、任意路径）。 ③ /depts/*（/depts 下的一级路径）：能匹配 /depts/1；不能匹配 /depts/1/2（层级太深），也不能匹配 /depts（后面没跟段，* 顶不上）；/emps/1 更不在它的管辖范围内。 ④ /depts/**（/depts 下的任意级路径）：能匹配 /depts、/depts/1、/depts/1/2；不能匹配 /emps/1（不在 /depts 下）。 Ⅰ 拦截 /depts 下的一级路径：/depts/*。 Ⅱ 拦截 /depts 本身和它下面的任意级：/depts/**。 顺带回答课程的两个选择：登录校验注册的是 /**——因为它要保护系统里所有接口（全都在 /depts、/emps 这些不同前缀下），只把 /login 放进排除名单。

• 2-4 说清”过滤器与拦截器的区别”，并解释一个实测现象 需求：有人按 PPT 的说法跟你说——“拦截器只拦 Spring 环境中的资源，所以 resources/static/test-page.html 这种静态页面不会被拦截器拦，只有过滤器才会拦它”。请回答：① 过滤器与拦截器的两点区别分别是什么？② 上面这句话对不对？为什么？③ 那”拦截器拦不到”的到底该是什么样的请求？ （练习文件 test_84_注册拦截器.java 的题目2-4 里给了写作区。）

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

  一级 · 思路：区别从”实现哪个接口”和”拦的范围”两头说；第 ② 问先回忆一件事——Spring Boot 里的静态资源到底是谁在处理？ 二级 · 方法：接口规范——Filter（Servlet 规范）与 HandlerInterceptor（Spring MVC）；范围——过滤器靠 @WebFilter 的路径配到 /* 就拦所有；Spring Boot 的静态资源由 Spring MVC 的 ResourceHttpRequestHandler 处理，所以要过 HandlerMapping → 拦截器；真正躲过拦截器的是”根本没进 DispatcherServlet”的请求（例如另一个 Servlet 自己映射的路径、容器直接处理的资源） 三级 · 骨架：① 接口规范不同：；拦截范围不同：；② 这句话____（对/不对），本机实测不带 token 访问 test-page.html 返回的是____，因为____；③ 拦不到的是____

  参考答案（做完再点开）

  ① 接口规范不同：过滤器实现 Filter 接口（Servlet 规范，jakarta.servlet 包）；拦截器实现 HandlerInterceptor 接口（Spring MVC，org.springframework.web.servlet 包）。拦截范围不同：过滤器会拦截所有资源；拦截器只拦截 Spring 环境中的资源。 ② 这句话不能按字面理解（不能推出”静态页面不会被拦”）。本机实测：拦截器方案下不带 token 访问 /test-page.html 返回 HTTP 401——静态页照样被拦住了。原因：Spring Boot 的静态资源是交给 Spring MVC 的 ResourceHttpRequestHandler 处理的，请求要经过 HandlerMapping（没有匹配的 @RequestMapping 就落到这个资源处理器）→ 一样会经过拦截器。 ③ 所以”只拦截 Spring 环境中的资源”的现实含义是”请求只要进了 DispatcherServlet 就会被拦到”；真正拦不到的是不进 DispatcherServlet 的请求——比如另一个 Servlet 自己映射的路径、由 web 容器直接处理的资源。实际开发中别指望靠”换路径”躲开拦截器，反而要注意把不需要登录的接口、静态资源这类路径写进排除名单（excludePathPatterns）。

三、综合题#

• 3-1 把登录校验从过滤器方案切换成拦截器方案，并补一次静态资源实测 这一题的重点有两个：一是亲身体会”两套方案做同一件事”，二是把”拦截范围”这句话用实测钉死。

  1. 让原来的过滤器失效（把过滤器类上那个让它生效的注解注释掉），确认工程里没有过滤器在拦请求；
  2. 在配置类里注入拦截器并注册：拦截所有请求、排除登录请求；
  3. 启动工程，发三种请求并记录状态码：不带 token 访问 /emps、带合法 token 访问 /emps、POST /login；
  4. 在 src/main/resources/static/ 下放一个 test-page.html（随便写几行字），不带 token 访问它，记录状态码；
  5. 把第 4 步的状态码和 PPT 第 52 页”拦截器只会拦截 Spring 环境中的资源”这句话摆在一起，解释为什么会是这个结果；
  6. 收尾回答两个问题。

  （练习文件 test_84_登录校验拦截器.java 的”综合题”一段里按这 6 步给了写作区。）

  回答：① 同一个”登录校验”，Filter 方案和 Interceptor 方案各方便在哪？（各说一条）② 如果有一个请求既没进 DispatcherServlet、也不在过滤器的拦截路径里，它会被两套方案拦住吗？

  涉及知识点

  知识点	在这里的应用
  拦截器概念与作用（PPT 45）	第 1、2 步——用拦截器替换过滤器来做同一件事
  HandlerInterceptor 三方法（PPT 46～47）	第 2 步——校验写在 preHandle，用返回值表达放行
  WebMvcConfigurer 注册（PPT 46～47）	第 2、3 步——addPathPatterns / excludePathPatterns
  拦截器的六步流程（PPT 49）	第 2、3 步——无 token 401、令牌非法 401、通过放行
  拦截路径（PPT 51）	第 2、3 步——/** 拦所有 + 排除 /login
  执行流程与两点区别（PPT 52）	第 4、5 步——静态资源的实测与解释

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

  一级 · 思路：先把过滤器”关掉”避免两套方案同时生效（否则 401 可能来自过滤器，实验就说不清了），再用拦截器把同样的三种请求跑一遍，最后加一个静态页做”拦截范围”的对照 二级 · 方法：过滤器失效靠注释 @WebFilter；拦截器注册在 WebMvcConfigurer 的 addInterceptors 里；静态页放在 src/main/resources/static/ 下、访问路径是 /test-page.html；状态码用 401 / 200 记 三级 · 骨架：① 注释掉 @____(urlPatterns = "/*")；② registry.addInterceptor(tokenInterceptor).addPathPatterns("____").excludePathPatterns("____")；③ POST http://localhost:8080/____，其余两个带/不带请求头 ____: <token>；④ 访问 http://localhost:8080/____.html

  参考答案（做完再点开）

  1～2. 过滤器失效：把 TokenFilter 上的 @WebFilter(urlPatterns = "/*") 注释掉；注册拦截器：配置类里 registry.addInterceptor(tokenInterceptor).addPathPatterns("/**").excludePathPatterns("/login")（拦截器代码见题目 2-2 的答案）。 3. 本机实测：

  1
  不带 token 访问 /emps     → HTTP 401
  2
  带合法 token 访问 /emps   → HTTP 200
  3
  POST /login               → 放行（excludePathPatterns 生效，能正常登录）

  和 83 篇的 Filter 方案结果完全一致——说明两套方案在”登录校验”这件事上是等价可替换的。 4～5. 本机实测：不带 token 访问 /test-page.html → HTTP 401，静态页也被拦住了。PPT 说”拦截器只拦截 Spring 环境中的资源”，而 Spring Boot 的静态资源由 Spring MVC 的 ResourceHttpRequestHandler 处理（请求会经过 HandlerMapping），所以它在 Spring 的环境中、照样被拦。这句话不能被读成”静态资源不受拦截器管辖”；正确的理解是”请求只要进了 DispatcherServlet 就会被拦，真正拦不到的是不进 DispatcherServlet 的请求”。 6. 两个回答： ① Filter 方案方便在”一网打尽”：一个 @WebFilter(urlPatterns = "/*") 就能管住所有请求（连演示接口 /c1、/c2 都跑不掉），静态资源、非 Spring 的 Servlet 路径都在它的射程内；Interceptor 方案方便在”精确控制 + 更贴 Spring”：addPathPatterns / excludePathPatterns 能在配置里写清楚”拦哪些、不拦哪些”（不用在代码里判断路径），而且三个方法能在 Controller 前后、请求收尾各插一段代码（preHandle 的参数里还带着 handler，能知道这次要执行的是哪个方法）。 ② 不会。两套方案的判断依据都是”请求有没有经过自己”：过滤器只拦它配的路径范围内的请求，DispatcherServlet 之外的请求根本不进 Spring MVC，拦截器就更看不到了——这正是二者”拦截范围”差别里”拦不到”那一半的真实含义。