介绍一下傻傻分不清的两个兄弟：过滤器和拦截器之拦截器

在上一篇文章中我们讲到了过滤器。他可以实现很多的功能，例如身份验证和授权、日志记录和性能监控等等，那么拦截器又是什么呢？它跟过滤器又有什么区别呢？？

实际上，拦截器可以被视为一种对过滤器的封装。在Spring框架中，拦截器提供了更加灵活和强大的功能，可以与Spring MVC等框架无缝集成，并且通常用于处理请求的前置和后置逻辑。拦截器可以实现过滤器的大部分功能，并且在Spring应用程序中更为常见。

拦截器也可以用于日志记录、权限验证、性能监控、异常处理等场景。在Spring框架中，拦截器通过实现HandlerInterceptor接口来定义，并可以在请求处理之前、之后或完成后执行相应的任务。现在我们来学习一下如何使用拦截器。

搭建拦截器

第一步，新建一个spring boot项目。

和上一篇文章一样我们也新建一个spring boot项目

java 复制代码

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>3.2.0</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.masiyi</groupId>
	<artifactId>Interceptor</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>Interceptor</name>
	<description>Interceptor</description>
	<properties>
		<java.version>17</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

第二步，新建controller类

java 复制代码

package com.masiyi.interceptor;
 
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/filter")
public class MyController {
 
	@RequestMapping("/test")
	public String test1(String a) {
		System.out.println("test1:" + a);
		return "test1";
	}
	
}

这里其实和上一篇文章的controller是一模一样的，这里就不再过多的赘述。

第三步，新建拦截器类

java 复制代码

package com.masiyi.interceptor;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.lang.Nullable;

/**
 * 自定义拦截器
 */
public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle");
        // 返回 true: 正常执行   false:该请求停止向下运行
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
        System.out.println("afterCompletion");
    }

}

实现了HandlerInterceptor接口。在这个拦截器中，有三个方法分别是preHandle、postHandle和afterCompletion。

preHandle方法在请求处理之前被调用，允许进行一些前置处理，比如权限验证或日志记录。如果preHandle返回true，则请求继续向下执行；如果返回false，则请求停止向下执行。
postHandle方法在请求处理之后、视图渲染之前被调用，允许进行一些后置处理，比如修改ModelAndView。
afterCompletion方法在整个请求处理完成后被调用，允许进行一些资源清理或日志记录等工作。

这里可以看到其实和我们上一篇文章的几个方法是非常非常非常非常类似的。但是不一样的是，我们好像没有编辑它的访问路径，也就是说它并没有拦截谁。我们现在也不知道他需要拦截谁。所以说我们现在要做的就是把他交给spring来管理。

第四步，编写配置类

java 复制代码

package com.masiyi.interceptor;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {
 
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor()).addPathPatterns("/**");
        // .excludePathPatterns("/user/get")/.addPathPatterns(). 可以排除和指定设置
    }
 
    @Bean
    public MyInterceptor myInterceptor() {
        return new MyInterceptor();
    }
}

这里的目的就是用于注册自定义的拦截器 MyInterceptor。在 addInterceptors 方法中，通过 registry.addInterceptor(myInterceptor()).addPathPatterns("/**") 注册了 MyInterceptor 并指定了拦截的路径为 "/"，这意味着 MyInterceptor 将会拦截所有的请求。同时，通过 @Bean 注解的 myInterceptor 方法将 MyInterceptor 注入到 Spring 容器中，以便在拦截器中使用。

之后调用我们的接口就可以发现我们代码里面所有的信息都被打印在了控制台里面。可以看到它的执行顺序是依次从上往下的。

至此我们已经完成了拦截器的使用，但是我相信很多同学看到这里还是会有一个疑问，我感觉他们两个都差不多，甚至他们都可以在spring boot中使用。那他们之间到底存在着什么联系呢？

其实，过滤器（Filter）和拦截器（Interceptor）在 Spring Boot 中都可以用来实现对请求的处理和拦截，但它们的作用范围和实现方式有所不同。

过滤器是基于 Servlet 规范的组件，它可以在请求到达 Servlet 之前拦截请求，并在响应返回客户端之前处理响应。过滤器可以用于处理请求的编码、安全校验、日志记录等。

拦截器是 Spring 框架提供的，它是基于 AOP 的，可以在请求处理的各个阶段进行处理，如请求处理前、请求处理后、视图渲染前等。拦截器可以访问 Spring 上下文中的 Bean，并且可以实现更细粒度的控制和处理。

因此，虽然它们在 Spring Boot 中都可以使用，但过滤器是基于 Servlet 规范的，而拦截器是 Spring 框架提供的，两者的作用范围和实现方式有所不同。

我们可以打一个生活中的例子，过滤器就像是机场安检，负责在你进入机场之前检查你的身份和行李，确保安全和合规性。而拦截器则类似于机场内的安保人员，负责在你登机过程中提供安全保障和服务。虽然它们都在你旅行的整个过程中发挥作用，但它们的职责和作用范围是不同的。

执行顺序

既然看到这里，我相信动手能力强的很多同学一定有这样的疑问。如果说我过滤器跟拦截器写在一个项目中，我执行请求他们的顺序会是怎样呢？接下来我们就开始动手实践一下，把过滤器跟拦截器写在一个项目中，并且让他们拦截同样的地址。可以看到结果如下

大家也可以直接从我的代码仓库里面看一下，这段代码，这里就不详细的赘述了。

gitee.com/WangFuGui-M...

java 复制代码

filter的init
filter的doFilter(前)
Interceptor的preHandle
_Controller_test1:null
Interceptor的postHandle
Interceptor的afterCompletion
filter的doFilter(后)
filter的destroy

我们可以使用一个流程图，把下面的执行过程给画出来。

在图中我们可以了解到的信息是拦截器其实是被括在过滤器里面的，而真正调用我们的服务是在两个的中间。所以执行顺序如下：

过滤器的初始化（init）
过滤器的过滤处理（doFilter）（前）
拦截器的预处理（preHandle）
控制器（Controller）的处理
拦截器的后处理（postHandle）
拦截器的完成处理（afterCompletion）
过滤器的过滤处理（doFilter）（后）
过滤器的销毁（destroy）

尽管它们在实现方式和使用场景上有所不同，但它们都是Web应用中重要的组件，能够帮助我们实现诸如验证、日志记录、字符编码转换等功能。希望本文能够帮助读者更好地理解和区分这两个兄弟组件，为Web应用开发提供更多的选择和灵活性。