拦截器和过滤器的执行顺序和区别

1. 拦截器和过滤器的概念

1.1. 过滤器概念
过滤器Filter是JavaEE标准，在Servlet的规范中定义的，是Servlet容器支持的，是属于Servlet容器的，依赖Servlet容器；
若用配置文件方式(servlet3.0以下版本)配置，Filter配置在web.xml中，Interceptor配置在Spring MVC的配置文件中。多个过滤器的执行顺序跟在web.xml文件中定义的先后关系有关。多个拦截器它们之间的执行顺序跟在SpringMVC的配置文件中定义的先后顺序有关。
过滤器Filter是基于函数回调实现(容器初始化调用)；拦截器是基于java的反射机制实现，属于面向切面编程(AOP)的一种运用。

一、过滤器Filter
我们在配置web.xml时，总会配置下面一段设置字符编码，不然会导致乱码问题，配置目的是让所有请求都需要进行字符编码设置：

<filter>
<filter-name>encoding</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>

<filter-mapping>
<filter-name>encoding</filter-name>
<servlet-name>/*</servlet-name>
</filter-mapping>
它依赖于servlet容器。它可以对几乎所有请求进行过滤，但是缺点是一个过滤器实例只能在容器初始化时调用一次。使用过滤器的目的，是用来做一些过滤操作，获取我们想要获取的数据，比如：在Javaweb中，对传入的request、response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者Controller进行业务逻辑操作。通常用的场景是：在过滤器中修改字符编码（CharacterEncodingFilter）、在过滤器中修改HttpServletRequest的一些参数（XSSFilter(自定义过滤器)），如：过滤低俗文字、危险字符等。

1.2. 拦截器概念
拦截器是基于java的反射机制的，而过滤器是基于函数回调。
拦截器不依赖与servlet容器，过滤器依赖与servlet容器。
拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
拦截器依赖于Spring框架，所以只能对Controller请求进行拦截而对其他的一些比如直接访问静态资源的请求则没办法进行拦截处理，而过滤器则可以对几乎所有的请求起作用。

拦截器的配置一般在SpringMVC的配置文件中，使用Interceptors标签，具体配置如下：

<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/**" />
<bean class="com.scorpios.atcrowdfunding.web.LoginInterceptor"></bean>
</mvc:interceptor>
<mvc:interceptor>
<mvc:mapping path="/**" />
<bean class="com.scorpios.atcrowdfunding.web.AuthInterceptor"></bean>
</mvc:interceptor>
</mvc:interceptors>
它依赖于web框架。在SpringMVC中就是依赖于SpringMVC框架。在实现上，基于Java的反射机制，属于面向切面编程（AOP）的一种运用，就是在service或者一个方法前，调用一个方法，或者在方法后，调用一个方法，比如动态代理就是拦截器的简单实现，在调用方法前打印出字符串（或者做其它业务逻辑的操作），也可以在调用方法后打印出字符串，甚至在抛出异常的时候做业务逻辑的操作。由于拦截器是基于web框架的调用，因此可以使用Spring的依赖注入（DI）进行一些业务操作，同时一个拦截器实例在一个controller生命周期之内可以多次调用。拦截器可以对静态资源的请求进行拦截处理。

2. 两者区别：

拦截器是基于java的反射机制的，而过滤器是基于函数回调。
拦截器不依赖与servlet容器，过滤器依赖与servlet容器。
拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。
拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。
拦截器Interceptor是Spring的组件之一，是属于Spring框架的，依赖于Spring框架，归Spring管理，配置在Spring的文件中，因此能使用Spring里的任何资源和对象，例如Service对象、数据源、事务管理等(所有Spring容器管理的bean)，所以可以通过Spring的IOC注入方式注入即可，而Filter不可以。
若用配置文件方式(servlet3.0以下版本)配置，Filter配置在web.xml中，Interceptor配置在Spring MVC的配置文件中。多个过滤器的执行顺序跟在web.xml文件中定义的先后关系有关。多个拦截器它们之间的执行顺序跟在SpringMVC的配置文件中定义的先后顺序有关。
过滤器Filter是基于函数回调实现；拦截器是基于java的反射机制实现，属于面向切面编程(AOP)的一种运用。
拦截器是Spring组件之一，所以可以访问action上下文、栈里的对象、Spring容器管理的bean，而过滤器不能访问。
在action上下文的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化是被调用一次。

3. 触发时机

3.1. 代码示例
3.1.1. MyFilter.java
过滤器写法，实现javax.servlet.Filter接口

import javax.servlet.*;
import java.io.IOException;

/**
* @author five-five
* @createTime 2022/3/2 10:37
*/
public class MyFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {

}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
System.out.println("before...");
chain.doFilter(request, response);
System.out.println("after...");
}

@Override
public void destroy() {

}
}

3.1.2. MyInterceptor.java
拦截器写法，实现org.springframework.web.servlet.HandlerInterceptor接口，也可继承org.springframework.web.servlet.HandlerInterceptor

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
* @author five-five
* @createTime 2022/3/2 10:38
*/
public class MyInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
System.out.println("preHandle");
return true;
}

@Override
public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
System.out.println("postHandle");
}

@Override
public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
System.out.println("afterCompletion");
}
}
3.2. 说明
3.2.1. 过滤器说明
过滤器的触发时机是容器后，servlet之前，所以过滤器的doFilter(ServletRequest request, ServletResponse response, FilterChain chain)方法的入参是ServletRequest，而不是httpservletrequest。因为过滤器是在httpservlet之前。

过滤器是在请求进入容器后，但请求进入servlet之前进行预处理的。请求结束返回也是，是在servlet处理完后，返回给前端之前。

chain.doFilter(request, response);这个方法的调用作为分水岭。事实上调用Servlet的doService()方法(处理请求，写过Servlet原生的就会知道)是在chain.doFilter(request, response);这个方法中进行的。

3.2.2. 拦截器说明
a.preHandle()这个方法是在过滤器的chain.doFilter(request, response)方法的前一步执行，也就是在

System.out.println("before...");
chain.doFilter(request, response);
之间执行。

postHandle()方法之后，在return ModelAndView之前进行，可以操控Controller的ModelAndView内容。

afterCompletion()方法是在过滤器返回给前端前一步执行，也就是在

chain.doFilter(request, response);
System.out.println("after...");
之间执行。

SpringMVC的机制是由同一个Servlet来分发请求给不同的Controller，其实这一步是在Servlet的service()方法中执行的。

3.2.3. 执行顺序
所以过滤器、拦截器、service()方法，dispatch()方法的执行顺序应该是这样的。

4. 代码测试

下面在一个项目中我们使用既有多个过滤器，又有多个拦截器，并观察它们的执行顺序：

1.第一个过滤器：

public class TestFilter1 implements Filter {

@Override
protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
//在DispatcherServlet之前执行
System.out.println("############TestFilter1 doFilterInternal executed############");
filterChain.doFilter(request, response);
//在视图页面返回给客户端之前执行，但是执行顺序在Interceptor之后
System.out.println("############TestFilter1 doFilter after############");
}
}
2.第二个过滤器：

public class TestFilter2 implements Filter {

@Override
protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
//在DispatcherServlet之前执行
System.out.println("############TestFilter2 doFilterInternal executed############");
filterChain.doFilter(request, response);
//在视图页面返回给客户端之前执行，但是执行顺序在Interceptor之后
System.out.println("############TestFilter2 doFilter after############");
}
}
3.web.xml中注册这两个过滤器：

<filter>
<filter-name>testFilter1</filter-name>
<filter-class>com.scorpios.filter.TestFilter1</filter-class>
</filter>
<filter-mapping>
<filter-name>testFilter1</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>


<filter>
<filter-name>testFilter2</filter-name>
<filter-class>com.scorpios.filter.TestFilter2</filter-class>
</filter>
<filter-mapping>
<filter-name>testFilter2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
再定义两个拦截器：

4.第一个拦截器：

public class BaseInterceptor implements HandlerInterceptor{

/**
* 在DispatcherServlet之前执行
* */
public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {
System.out.println("************BaseInterceptor preHandle executed**********");
return true;
}

/**
* 在controller执行之后的DispatcherServlet之后执行
* */
public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3) throws Exception {
System.out.println("************BaseInterceptor postHandle executed**********");
}

/**
* 在页面渲染完成返回给客户端之前执行
* */
public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)
throws Exception {
System.out.println("************BaseInterceptor afterCompletion executed**********");
}
}
5.第二个拦截器：

public class TestInterceptor implements HandlerInterceptor {

public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {
System.out.println("************TestInterceptor preHandle executed**********");
return true;
}

public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3) throws Exception {
System.out.println("************TestInterceptor postHandle executed**********");
}

public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3) throws Exception {
System.out.println("************TestInterceptor afterCompletion executed**********");
}
}
6.在SpringMVC的配置文件中，加上拦截器的配置：

<mvc:interceptors>

<bean name="baseInterceptor" class="com.scorpios.interceptor.BaseInterceptor" />

<mvc:interceptor>

<mvc:mapping path="/test.jsp"/>

<bean class="com.scorpios.interceptor.TestInterceptor" />
</mvc:interceptor>
</mvc:interceptors>
7.定义一个Controller控制器：

package com.scorpios.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class TestController {
@RequestMapping("/test")
public ModelAndView handleRequest(){
System.out.println("---------TestController executed--------");
return new ModelAndView("test");
}
}
8.测试结果：

启动测试项目，地址如下：http://www.localhost:8080/demo，可以看到控制台中输出如下：

说明：

1.过滤器的运行是依赖于servlet容器，跟springmvc等框架并没有关系

2.多个过滤器的执行顺序跟xml文件中定义的先后关系有关

接着清空控制台，并访问：http://www.localhost:8080/test，再次看控制台的输出：

说明：

1.可以很清晰地看到有多个拦截器和过滤器存在时的整个执行顺序了

2.多个拦截器它们之间的执行顺序跟在SpringMVC的配置文件中定义的先后顺序有关

5.总结

灵活性上说拦截器Interceptor功能更强大些，Filter能做的事情，Interceptor都能做，而且可以在请求前，请求后执行，异常抛出时，比较灵活。
Filter主要是针对URL地址做一个编码的事情、过滤掉没用的参数、安全校验（比较泛的，比如登录不登录之类），太细的话，还是建议用interceptor。

对于上述过滤器和拦截器的测试，可以得到如下结论：

Filter需要在web.xml中配置，依赖于Servlet

Interceptor需要在SpringMVC中配置，依赖于框架

Filter的执行顺序在Interceptor之前，如图：

从灵活性上说拦截器功能更强大些，Filter能做的事情，都能做，而且可以在请求前，请求后执行，比较灵活。Filter主要是针对URL地址做一个编码的事情、过滤掉没用的参数、安全校验（比较泛的，比如登录不登录之类），太细的话，还是建议用interceptor。不过还是根据不同情况选择合适的。

拦截器

反射机制

只对action请求起作用

可以访问action上下文、值栈里的对象

多次被调用

过滤器

函数回调

可以对几乎所有的请求起作用

不能访问

只能在容器初始化时被调用一次

posted @ 2022-09-05 14:41 liftsail 阅读(552) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

liftsail

不积跬步，无以至千里；不积小流，无以成江海。

拦截器和过滤器的执行顺序和区别

1. 拦截器和过滤器的概念

2. 两者区别：

3. 触发时机

4. 代码测试

5.总结

公告

liftsail

不积跬步，无以至千里； 不积小流，无以成江海。

拦截器和过滤器的执行顺序和区别

1. 拦截器和过滤器的概念

2. 两者区别：

3. 触发时机

4. 代码测试

5.总结

公告

不积跬步，无以至千里；不积小流，无以成江海。