聊聊java 过滤器、监听器、拦截器的区别(终结篇)

时间：2022-09-11 08:48:41

过滤器、监听器、拦截器概念

概念

1、servlet：servlet是一种运行服务器端的java应用程序，具有独立于平台和协议的特性，

可以动态生成web页面它工作在客户端请求与服务器响应的中间层；

2、filter：filter是一个可以复用的代码片段，可以用来转换HTTP请求，响应和头信息。

它不能产生一个请求或者响应，它只是修改对某一资源的请求或者响应；

3、listener：监听器，通过listener可以坚挺web服务器中某一执行动作，并根据其要求作出相应的响应。

就是在application，session，request三个对象创建消亡或者往其中添加修改删除属性时自动执行代码的功能组件；

4、interceptor：拦截器是对过滤器更加细化的应用，他不仅可以应用在service方法前后还可以应用到其他方法的前后 拦截器；

5、servlet，filter，listener是配置到web.xml中，interceptor不配置到web.xml中，struts的拦截器配置到struts。xml中。

spring的拦截器配置到spring.xml中；

过滤器和拦截器的区别

先说最易混淆的过滤器和拦截器的区别：

1、拦截器是基于java的反射机制的，而过滤器是基于函数回调。

2、拦截器不依赖与servlet容器，过滤器依赖与servlet容器。

3、拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。

4、拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。

5、在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。

6、拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。

过滤器、监听器、拦截器的生命周期

1、servlet

servle的生命周期开始于被装入web服务器的内存中，并在web服务终止或者重新装入servlet的时候结束；

servlet一旦被装入web服务器，一般不会从web服务器内存中删除；直到web服务器关闭；

装入：启动服务器时加载servlet的实例；

初始化：web服务器接收到请求时，或者两者之间的某个时刻启动，调用init（）

调用：从第一次到以后的多次访问，都只调用doGet（）或dopost）（）方法；

销毁；停止服务器时调用destroy（）方法，销毁实例；

2、filter

需要实现javax.servlet包的Filter接口的三个方法init（），doFilter（），destroy（）；

加载：启动服务器时加载过滤器的实例，并调用init（）方法；

调用：每次请求的时候只调用方法doFilter（）进行处理；

销毁：服务器关闭前调用destroy（）方法，销毁实例；

3、listener

web.xml的加载顺序是：context-param->listener->filter->servlet

4、interceptor

加载配置文件后初始化拦截器，当有对action的请求的时候，调用interceptor方法，最后也是根据服务器停止进行销毁；

过滤器、监听器、拦截器的职责

1、servlet

创建并返回一个包含基于客户请求性质的动态内容的完整的html页面

创建可嵌入到现有的html页面中的一部分html页面（html片段）

读取客户端发来的隐藏数据

读取客户端发来的显示数据

与其他服务器资源（包括数据库和java的应用程序）进行通信

2、filter

filter能够在一个请求到达servlet之前预处理用户请求，也可以在离开servlet时处理http响应：

在执行servlet之前，首先执行filter程序，并为之做一些预处理工作；

在servlet被调用之后截获servlet的执行

3、listener

servlet2.4规范提供了8个listener接口，可以将其分为三类，分别如下；

第一类：与HttpContext有关的listener接口，包括：ServletContextListener、ServletContextAttributeListener

第二类：与HttpSession有关的listner接口。包括：HttpSessionListener、HttpSessionAttributeListener、 HttpSessionBindingListener、 HttpSessionActivationListener、

第三类：与ServletRequest有关的Listener接口，包括：ServletRequestListener、ServletRequestAttributeListener

4、interceptor

与过滤器类似，通过层层拦截，处理用户的请求和响应；

过滤器、监听器、拦截器的图解

这个很重要,注意在shiro或者springsecurity配置安全相关的时候，如果异常无法捕获，往往就是web请求顺序导致的，

比如你配置了全局异常，但是异常请求如果没有到达controller层，那么全局异常依然无法捕捉到这类异常，因为请求都没有发到控制层(servlet那一层)，

在Filter层已经报权限不足异常那么直接就返回了，所以在前后端分离传递jwt配置的token校验时，如果异常返回的403无法以想要的json3段式或者4段式返回。

同样AOP日志也是无法捕获的，包括各种增强，连环绕增强都无法捕获这个安全框架的403异常

1、servlet：

聊聊java 过滤器、监听器、拦截器的区别(终结篇)

2、filter

聊聊java 过滤器、监听器、拦截器的区别(终结篇)

3、listener

聊聊java 过滤器、监听器、拦截器的区别(终结篇)

4、interceptor

聊聊java 过滤器、监听器、拦截器的区别(终结篇)

聊聊java 过滤器、监听器、拦截器的区别(终结篇)

聊聊java 过滤器、监听器、拦截器的区别(终结篇)

补充：拦截器（Interceptor）和过滤器（Filter）的执行顺序和区别

一、引言

本来想记录一下关于用户登陆和登陆之后的权限管理、菜单管理的问题，想到解决这个问题用到Interceptor，但想到了Interceptor，就想到了Filter，于是就想说一下它们的执行顺序和区别。

关于Interceptor解决权限和菜单管理的问题，在放在下一篇写吧，就酱紫。

二、区别

1、过滤器（Filter）

首先说一下Filter的使用地方，我们在配置web.xml时，总会配置下面一段设置字符编码，不然会导致乱码问题：

  1. <filter>
  2. <filter-name>encoding</filter-name>
  3. <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  4. <init-param>
  5. <param-name>encoding</param-name>
  6. <param-value>UTF-8</param-value>
  7. </init-param>
  8. <init-param>
  9. <param-name>forceEncoding</param-name>
  10. <param-value>true</param-value>
  11. </init-param>
  12. </filter>
  13. <filter-mapping>
  14. <filter-name>encoding</filter-name>
  15. <servlet-name>/*</servlet-name>
  16. </filter-mapping>

配置这个地方的目的，是让所有的请求都需要进行字符编码的设置，下面来介绍一下Filter。

（1）过滤器(Filter)：

它依赖于servlet容器。在实现上，基于函数回调，它可以对几乎所有请求进行过滤，但是缺点是一个过滤器实例只能在容器初始化时调用一次。

使用过滤器的目的，是用来做一些过滤操作，获取我们想要获取的数据，比如：在Javaweb中，对传入的request、response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者Controller进行业务逻辑操作。

通常用的场景是：在过滤器中修改字符编码（CharacterEncodingFilter）、在过滤器中修改HttpServletRequest的一些参数（XSSFilter(自定义过滤器)），如：过滤低俗文字、危险字符等。

2、拦截器（Interceptor）

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

  1. <mvc:interceptors>
  2. <mvc:interceptor>
  3. <mvc:mapping path="/**" />
  4. <bean class="com.scorpios.atcrowdfunding.web.LoginInterceptor"></bean>
  5. </mvc:interceptor>
  6. <mvc:interceptor>
  7. <mvc:mapping path="/**" />
  8. <bean class="com.scorpios.atcrowdfunding.web.AuthInterceptor"></bean>
  9. </mvc:interceptor>
  10. </mvc:interceptors>

（2）拦截器（Interceptor）：它依赖于web框架，在SpringMVC中就是依赖于SpringMVC框架。

在实现上,基于Java的反射机制，属于面向切面编程（AOP）的一种运用，就是在service或者一个方法前，调用一个方法，或者在方法后，调用一个方法，比如动态代理就是拦截器的简单实现，在调用方法前打印出字符串（或者做其它业务逻辑的操作），也可以在调用方法后打印出字符串，甚至在抛出异常的时候做业务逻辑的操作。

由于拦截器是基于web框架的调用，因此可以使用Spring的依赖注入（DI）进行一些业务操作，同时一个拦截器实例在一个controller生命周期之内可以多次调用。

但是缺点是只能对controller请求进行拦截，对其他的一些比如直接访问静态资源的请求则没办法进行拦截处理。

三、代码

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

（1）第一个过滤器：

  1. public class TestFilter1 implements Filter {
  2. @Override
  3. protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
  4. //在DispatcherServlet之前执行
  5. System.out.println("############TestFilter1 doFilterInternal executed############");
  6. filterChain.doFilter(request, response);
  7. //在视图页面返回给客户端之前执行，但是执行顺序在Interceptor之后
  8. System.out.println("############TestFilter1 doFilter after############");
  9. }
  10. }

（2）第二个过滤器：

  1. public class TestFilter2 implements Filter {
  2.  
  3. @Override
  4. protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
  5. //在DispatcherServlet之前执行
  6. System.out.println("############TestFilter2 doFilterInternal executed############");
  7. filterChain.doFilter(request, response);
  8. //在视图页面返回给客户端之前执行，但是执行顺序在Interceptor之后
  9. System.out.println("############TestFilter2 doFilter after############");
  10. }
  11. }

（3）在web.xml中注册这两个过滤器：

  1. <!-- 自定义过滤器：testFilter1 -->
  2. <filter>
  3. <filter-name>testFilter1</filter-name>
  4. <filter-class>com.scorpios.filter.TestFilter1</filter-class>
  5. </filter>
  6. <filter-mapping>
  7. <filter-name>testFilter1</filter-name>
  8. <url-pattern>/*</url-pattern>
  9. </filter-mapping>
  10. <!-- 自定义过滤器：testFilter2 -->
  11. <filter>
  12. <filter-name>testFilter2</filter-name>
  13. <filter-class>com.scorpios.filter.TestFilter2</filter-class>
  14. </filter>
  15. <filter-mapping>
  16. <filter-name>testFilter2</filter-name>
  17. <url-pattern>/*</url-pattern>
  18. </filter-mapping>

再定义两个拦截器：

（4）第一个拦截器：

  1. public class BaseInterceptor implements HandlerInterceptor{
  2.  
  3. /**
  4. * 在DispatcherServlet之前执行
  5. * */
  6. public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {
  7. System.out.println("************BaseInterceptor preHandle executed**********");
  8. return true;
  9. }
  10.  
  11. /**
  12. * 在controller执行之后的DispatcherServlet之后执行
  13. * */
  14. public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3) throws Exception {
  15. System.out.println("************BaseInterceptor postHandle executed**********");
  16. }
  17.  
  18. /**
  19. * 在页面渲染完成返回给客户端之前执行
  20. * */
  21. public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)
  22. throws Exception {
  23. System.out.println("************BaseInterceptor afterCompletion executed**********");
  24. }
  25. }

（5）第二个拦截器：

  1. public class TestInterceptor implements HandlerInterceptor {
  2. public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {
  3. System.out.println("************TestInterceptor preHandle executed**********");
  4. return true;
  5. }
  6.  
  7. public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3) throws Exception {
  8. System.out.println("************TestInterceptor postHandle executed**********");
  9. }
  10.  
  11. public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3) throws Exception {
  12. System.out.println("************TestInterceptor afterCompletion executed**********");
  13. }
  14. }

（6）、在SpringMVC的配置文件中，加上拦截器的配置：

  1. <!-- 拦截器 -->
  2. <mvc:interceptors>
  3. <!-- 对所有请求都拦截，公共拦截器可以有多个 -->
  4. <bean name="baseInterceptor" class="com.scorpios.interceptor.BaseInterceptor" />
  5.  
  6. <mvc:interceptor>
  7. <!-- 对/test.html进行拦截 -->
  8. <mvc:mapping path="/test.html"/>
  9. <!-- 特定请求的拦截器只能有一个 -->
  10. <bean class="com.scorpios.interceptor.TestInterceptor" />
  11. </mvc:interceptor>
  12. </mvc:interceptors>

（7）、定义一个Controller控制器：

  1. package com.scorpios.controller;
  2. import org.springframework.stereotype.Controller;
  3. import org.springframework.web.bind.annotation.RequestMapping;
  4. import org.springframework.web.servlet.ModelAndView;
  5.  
  6. @Controller
  7. public class TestController {
  8. @RequestMapping("/test")
  9. public ModelAndView handleRequest(){
  10. System.out.println("---------TestController executed--------");
  11. return new ModelAndView("test");
  12. }
  13. }

（8）、测试结果：

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

聊聊java 过滤器、监听器、拦截器的区别(终结篇)

这就说明了过滤器的运行是依赖于servlet容器，跟springmvc等框架并没有关系。并且，多个过滤器的执行顺序跟xml文件中定义的先后关系有关。

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

聊聊java 过滤器、监听器、拦截器的区别(终结篇)

从这个控制台打印输出，就可以很清晰地看到有多个拦截器和过滤器存在时的整个执行顺序了。当然，对于多个拦截器它们之间的执行顺序跟在SpringMVC的配置文件中定义的先后顺序有关。

四、总结

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

（1）、Filter需要在web.xml中配置，依赖于Servlet；

（2）、Interceptor需要在SpringMVC中配置，依赖于框架；

（3）、Filter的执行顺序在Interceptor之前，具体的流程见下图；

聊聊java 过滤器、监听器、拦截器的区别(终结篇)

（4）、两者的本质区别：拦截器（Interceptor）是基于Java的反射机制，而过滤器（Filter）是基于函数回调。

从灵活性上说拦截器功能更强大些，Filter能做的事情，都能做，而且可以在请求前，请求后执行，比较灵活。

Filter主要是针对URL地址做一个编码的事情、过滤掉没用的参数、安全校验（比较泛的，比如登录不登录之类），太细的话，还是建议用interceptor。不过还是根据不同情况选择合适的。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。如有错误或未考虑完全的地方，望不吝赐教。

原文链接：https://blog.csdn.net/kangbin825/article/details/105029501

标签：

相关文章