SpringBoot -拦截器Interceptor、过滤器 Filter 及设置

Spring Boot拦截器（Interceptor）的概念

- 在Spring Boot中，拦截器是一种AOP的实现方式。它主要用于<font style="color:#DF2A3F;">拦截请求</font>，在请求处理之前和之后执行特定的代码逻辑。与过滤器不同的是，拦截器更侧重于对Spring MVC中的<font style="color:#DF2A3F;">控制器（Controller）</font>进行拦截，能够访问到Spring MVC上下文中的对象，比如获取请求的处理器（Handler）信息、模型（Model）和视图（View）相关信息等。

创建拦截器类

- 要创建拦截器，需要实现`HandlerInterceptor`接口。这个接口有三个方法：* `<font style="color:#DF2A3F;">preHandle()</font>`：在请求处理之前调用。可以进行权限验证、日志记录等操作。如果返回`false`，则请求被中断，不会继续执行后续的处理器（Controller）方法；如果返回`true`，则请求继续传递。* `<font style="color:#DF2A3F;">postHandle()</font>`：在请求处理之后，视图渲染之前调用。可以对模型（Model）和视图（View）进行修改等操作。* `<font style="color:#DF2A3F;">afterCompletion()</font>`：在整个请求完成后（包括视图渲染后）调用。主要用于资源清理等操作。
- 例如，创建一个简单的拦截器来记录请求处理时间：RequestTimeInterceptor对象

public class RequestTimeInterceptor implements HandlerInterceptor {private Date startTime;@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {startTime = new Date();return true;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {Date endTime = new Date();System.out.println("Request processing time: " + (endTime.getTime() - startTime.getTime()) + "ms");}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {// 可以在这里进行资源清理等操作}
}

配置拦截器

方式一：通过实现WebMvcConfigurer接口

- 创建一个配置类，实现`WebMvcConfigurer`接口。
- 在`addInterceptors`方法中添加拦截器并配置拦截路径。
- 例如：

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(new RequestTimeInterceptor()).addPathPatterns("/**");}
}

上述代码中，addInterceptor方法添加了RequestTimeInterceptor拦截器，addPathPatterns方法指定了拦截的路径为所有路径（/**`）。

方式二：通过扩展WebMvcConfigurationSupport类（不推荐，可能会覆盖Spring Boot的默认配置）
- 创建一个配置类，继承自WebMvcConfigurationSupport。
- 重写addInterceptors方法来配置拦截器。
- 例如：


public class InterceptorConfiguration extends WebMvcConfigurationSupport {@Overrideprotected void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(new RequestTimeInterceptor()).addPathPatterns("/**");}
}

- 不过这种方式可能会导致Spring Boot自动配置的一些Web相关的配置失效，如静态资源处理等，所以一般推荐使用第一种方式。

拦截器的执行顺序

- 当有多个拦截器时，它们的执行顺序是按照在`InterceptorRegistry`中添加的顺序来执行的。先添加的拦截器先执行`preHandle`方法，后执行`postHandle`和`afterCompletion`方法。例如，假设有拦截器`Interceptor1`和`Interceptor2`，配置如下：

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(new Interceptor1()).addPathPatterns("/**");registry.addInterceptor(new Interceptor2()).addPathPatterns("/**");}
}

- 在这个例子中，`Interceptor1`的`preHandle`方法会先于`Interceptor2`的`preHandle`方法执行。而`Interceptor2`的`postHandle`和`afterCompletion`方法会先于`Interceptor1`的相应方法执行。

过滤器 Filter 的概念

在 Spring Boot 中，过滤器是一种用于拦截和处理请求和响应的组件。它可以在请求到达控制器（Controller）之前进行预处理，例如验证请求头、验证用户身份等，也可以在响应返回客户端之前进行后处理，例如修改响应头、添加日志信息等。过滤器可以对多个请求和响应进行统一的处理，是实现横切关注点（如安全、日志记录等）的重要手段。

实现Filter接口，并使用@WebFilter注解（原生servlet配置方式）

- **使用注解方式（推荐）**：- 在Spring Boot中，更方便的是使用`@WebFilter`注解来创建过滤器。例如：- ```java@WebFilter(urlPatterns = "/*")public class MyFilter implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {// 初始化方法，在过滤器初始化时调用，可以进行一些初始化操作，如加载配置文件等}@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {// 过滤方法，在这里可以对请求进行处理，然后决定是否将请求传递给下一个过滤器或控制器// 例如，可以在这里检查请求头中的令牌（Token）是否有效filterChain.doFilter(servletRequest, servletResponse);// 在调用filterChain.doFilter后，可以对响应进行处理}@Overridepublic void destroy() {// 销毁方法，在过滤器销毁时调用，可以进行一些资源释放等}}

其中@WebFilter(urlPatterns = "/*")注解用于指定过滤器要拦截的 URL 模式，/*表示拦截所有的请求路径。
自动配置使用@WebFilter注解的过滤器：
- 需要在 Spring Boot 的主应用程序类上添加@ServletComponentScan注解，这样 Spring Boot 才能扫描到过滤器并自动进行配置。例如：


@SpringBootApplication
@ServletComponentScan
public class MySpringBootApp {public static void main(String[] args) {SpringApplication.run(MySpringBootApp.class, args);}
}

手动配置（通过FilterRegistrationBean）：
- 有时候可能需要更灵活的配置，例如设置过滤器的执行顺序、添加初始化参数等。可以通过FilterRegistrationBean对象来手动配置过滤器。例如：
- <font style="color:rgb(38, 38, 38);background-color:rgb(242, 242, 247);">FilterRegistrationBean对象可以：</font>
  - 设置实际过滤器 setFilter(）
  - 设置过滤器名 setName(“myFilter”);
  - 设置过滤路径 addUrlPatterns(“/*”);
  - 设置优先级 setOrder(1);


@Configuration
public class FilterConfig {@Beanpublic FilterRegistrationBean<MyFilter> myFilterRegistration() {FilterRegistrationBean<MyFilter> registrationBean = new FilterRegistrationBean<>();registrationBean.setFilter(new MyFilter());registrationBean.addUrlPatterns("/*");registrationBean.setName("myFilter");registrationBean.setOrder(1); // 设置过滤器的执行顺序，数字越小越先执行return registrationBean;}
}

过滤器链（Filter Chain）

- 当有多个过滤器时，它们会形成一个过滤器链。请求会依次经过每个过滤器，每个过滤器都可以对请求进行处理，然后决定是否将请求传递给下一个过滤器。在`doFilter`方法中，通过调用`filterChain.doFilter(servletRequest, servletResponse)`来将请求传递给下一个过滤器或控制器。如果某个过滤器没有调用这个方法，那么请求就会被截断，后续的过滤器和控制器都不会收到这个请求。同样，在响应返回时，也会按照相反的顺序经过各个过滤器，每个过滤器可以对响应进行处理。例如，假设有两个过滤器`Filter1`和`Filter2`，请求首先会到达`Filter1`，`Filter1`处理后传递给`Filter2`，`Filter2`处理后传递给控制器；响应返回时，先经过`Filter2`，再经过`Filter1`，最后返回给客户端。

**1.**通过xml文件配置过滤器链:

    * 创建两个过滤器：CharacterEncodingFilter、LoggingFilter

public class CharacterEncodingFilter implements Filter {private String encoding;@Overridepublic void init(FilterConfig filterConfig) throws ServletException {encoding = filterConfig.getInitParameter("encoding");}@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {servletRequest.setCharacterEncoding(encoding);filterChain.doFilter(servletRequest, servletResponse);}@Overridepublic void destroy() {// 可以在这里进行资源释放等操作}
}

public class LoggingFilter implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {System.out.println("Request received at: " + new Date());filterChain.doFilter(servletRequest, servletResponse);}@Overridepublic void destroy() {}
}

    * **配置过滤器链（在 web.xml 中）*** 在这个配置中，`LoggingFilter`会应用到所有的请求（`/*`）。`CharacterEncodingFilter`会应用到名为`MyServlet`的 Servlet。当请求到来时，会先经过`LoggingFilter`，然后根据请求的目标是`MyServlet`时，再经过`CharacterEncodingFilter`。

<filter><filter - name>LoggingFilter</filter - name><filter - class>com.example.filters.LoggingFilter</filter - class>
</filter>
<filter - mapping><filter - name>LoggingFilter</filter - name><url - pattern>/*</url - pattern>
</filter - mapping><filter><filter - name>CharacterEncodingFilter</filter - name><filter - class>com.example.filters.CharacterEncodingFilter</filter - class><init - param><param - name>encoding</param - name><param - value>UTF - 8</param - value></init - param>
</filter>
<filter - mapping><filter - name>CharacterEncodingFilter</filter - name><servlet - name>MyServlet</servlet - name>
</filter - mapping>

上述代码中，首先定义了一个名为CharacterEncodingFilter的过滤器，并且通过<init - param>标签设置了一个初始化参数encoding为UTF - 8。然后通过<filter - mapping>标签将这个过滤器应用到所有的请求（/*）。当请求到来时，这个过滤器会设置请求的字符编码为UTF - 8，然后将请求传递给下一个过滤器或者目标资源。

**2.**使用注解方式（Servlet 3.0+）实现过滤器链

- 当有多个注解式过滤器时，过滤器的执行顺序是按照类名的字典序来确定的。如果需要更精确地控制顺序，可以使用`@javax.annotation.Priority`注解来指定优先级。数字越小，优先级越高。

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.annotation.Priority;
import java.io.IOException;@WebFilter(filterName = "AuthFilter", urlPatterns = "/*")
@Priority(1)
public class AuthFilter implements Filter {//...
}@WebFilter(filterName = "AnotherFilter", urlPatterns = "/*")
@Priority(2)
public class AnotherFilter implements Filter {//...
}

DelegatingFilterProxyRegistrationBean 对象代理过滤器。

DelegatingFilterProxyRegistrationBean 是 Spring Boot 中用于注册一个代理过滤器（DelegatingFilterProxy）的配置类。它主要用于将一个基于 Servlet 的过滤器集成到 Spring 的应用上下文中，使得这个过滤器能够利用 Spring 的特性，如依赖注入、配置属性等。
这个类在将传统的 Servlet 过滤器与 Spring 应用进行整合时非常有用。例如，在一些安全认证过滤器或者日志记录过滤器的场景下，通过它可以更好地管理和配置这些过滤器，让它们能够从 Spring 的环境配置（如配置文件、环境变量等）中获取必要的参数，并且能够方便地与 Spring 管理的其他组件（如服务层组件、数据源等）进行交互。

·配置**DelegatingFilterProxyRegistrationBean**

假设我们有一个自定义的过滤器MyFilter，并且希望通过DelegatingFilterProxyRegistrationBean 来注册它，使其能够与 Spring 应用上下文集成。

1**.创建一个过滤器：MyFilter**


public class MyFilter implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {// 初始化过滤器，这里可以获取初始化参数等操作}@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {// 执行过滤操作，例如检查请求头、验证用户身份等filterChain.doFilter(servletRequest, servletResponse);}@Overridepublic void destroy() {// 销毁过滤器，释放资源}
}

2.然后，在Spring Boot的配置类中注册DelegatingFilterProxyRegistrationBean：

@Configuration
public class FilterConfig {@Beanpublic FilterRegistrationBean<DelegatingFilterProxy> myFilterRegistration() {FilterRegistrationBean<DelegatingFilterProxy> registrationBean = new FilterRegistrationBean<>();DelegatingFilterProxy delegatingFilterProxy = new DelegatingFilterProxy("myFilter");registrationBean.setFilter(delegatingFilterProxy);registrationBean.addUrlPatterns("/*");return registrationBean;}@Bean(name = "myFilter")public MyFilter myFilter() {return new MyFilter();}
}

在上述配置中，首先创建了一个DelegatingFilterProxyRegistrationBean，并将一个DelegatingFilterProxy 实例设置为其过滤器。DelegatingFilterProxy 的构造函数参数 "myFilter" 是要在 Spring 应用上下文中查找的真正过滤器 Bean 的名称。然后，通过addUrlPatterns("/*") 设置了过滤器拦截的 URL 模式为所有请求。同时，还通过@Bean(name = "myFilter") 方法定义了真正的过滤器MyFilter，这样DelegatingFilterProxy 就能在 Spring 应用上下文中找到它并进行委托。