spring过滤器和拦截器的区别和联系

一 简介

（1）过滤器（Filter）：

依赖于servlet容器,是JavaEE标准,是在请求进入容器之后，还未进入Servlet之前进行预处理，并且在请求结束返回给前端这之间进行后期处理。在实现上基于函数回调，可以对几乎所有请求进行过滤，但是缺点是一个过滤器实例只能在容器初始化时调用一次。使用过滤器的目的是用来做一些过滤操作。过滤器可以简单理解为“取你所想取”，忽视掉那些你不想要的东西，比如：在过滤器中修改字符编码；在过滤器中修改HttpServletRequest的一些参数，包括：过滤低俗文字、危险字符等。过滤器底层实现方式是基于函数回调的，自定义过滤器实现一个 doFilter()方法（init()和destroy()方法可以不实现，有默认实现），这个方法有一个FilterChain 参数，而实际上它是一个回调接口，基于函数回调实现。ApplicationFilterChain是它的实现类， 这个实现类内部也有一个 doFilter() 方法就是回调方法。过滤器Filter触发时机是在请求进入容器后，但在进入servlet(StandWrapper类)之前进行预处理，请求结束是在servlet(StandWrapper类)处理完以后。也可以通过@WebFilter注解实现对特定url拦截。

关于过滤器的一些用法可以参考我写过的这些文章：

  • 继承HttpServletRequestWrapper以实现在Filter中修改HttpServletRequest的参数：https://www.zifangsky.cn/677.html

  • 在SpringMVC中使用过滤器（Filter）过滤容易引发XSS的危险字符：https://www.zifangsky.cn/683.html

（2）拦截器：

拦截器不依赖与servlet容器，依赖于web框架。一个Spring组件，并由Spring容器管理，并不依赖Tomcat等容器，是可以单独使用的。不仅能应用在web程序中，也可以用于Application、Swing等程序中。在SpringMVC中就是依赖于SpringMVC框架，在SSH框架中，就是依赖于Struts框架。在实现上基于Java的反射机制，属于面向切面编程（AOP）的一种运用。由于拦截器是基于web框架的调用，因此可以使用spring的依赖注入（DI）获取IOC容器中的各个bean,进行一些业务操作，同时一个拦截器实例在一个controller生命周期之内可以多次调用。但是缺点是只能对controller请求进行拦截，即⑴请求还没有到controller层时进行拦截，⑵请求走出controller层次，还没有到渲染时图层时进行拦截，⑶结束视图渲染，但是还没有到servlet的结束时进行拦截。对其他的一些比如直接访问静态资源的请求则没办法进行拦截处理,拦截器功在对请求权限鉴定方面确实很有用处。它可以简单理解为“拒你所想拒”。拦截器底层实现方式是基于Java的反射机制（动态代理）实现的。拦截器Interceptor触发时机是在请求进入servlet(StandWrapper类)后，在进入Controller之前进行预处理的，Controller 中渲染了对应的视图之后请求结束。拦截器通过实现HandlerInterceptor接口来实现的，有三个方法preHandle()，postHandle()，afterCompletion()。拦截器是基于Java的反射机制实现，也就是动态代理。

关于过滤器的一些用法可以参考我写过的这些文章：

  • 在SpringMVC中使用拦截器（interceptor）拦截CSRF攻击（修）：https://www.zifangsky.cn/671.html

  • SpringMVC中使用Interceptor+cookie实现在一定天数之内自动登录：https://www.zifangsky.cn/700.html

二 多个过滤器与拦截器的代码执行顺序

如果在一个项目中仅仅只有一个拦截器或者过滤器，那么我相信相对来说理解起来是比较容易的。但是我们是否思考过：如果一个项目中有多个拦截器或者过滤器，那么它们的执行顺序应该是什么样的？或者再复杂点，一个项目中既有多个拦截器，又有多个过滤器，这时它们的执行顺序又是什么样的呢？

下面我将用简单的代码来测试说明：

（1）先定义两个过滤器：

i）过滤器1：

[java] view plain copy
 
  1. <a target="_blank" href="http://www.07net01.com/tags-package-0.html" class="infotextkey" style="background:transparent; color:rgb(66,139,202)">package</a> cn.zifangsky.filter;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.FilterChain;  
  6. import javax.servlet.ServletException;  
  7. import javax.servlet.http.HttpServletRequest;  
  8. import javax.servlet.http.HttpServletResponse;  
  9.   
  10. import org.springframework.web.filter.OncePerRequestFilter;  
  11.   
  12. public class TestFilter1 extends OncePerRequestFilter {  
  13.   
  14.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)  
  15.             throws ServletException, IOException {  
  16.         //在DispatcherServlet之前执行  
  17.         <a target="_blank" href="http://www.07net01.com/tags-system-0.html" class="infotextkey" style="background:transparent; color:rgb(66,139,202)">system</a>.out.println("############TestFilter1 doFilterInternal executed############");  
  18.         filterChain.doFilter(request, response);  
  19.         //在视图页面返回给<a target="_blank" href="http://www.07net01.com/tags-%E5%AE%A2%E6%88%B7%E7%AB%AF-0.html" class="infotextkey" >客户端</a>之前执行，但是执行顺序在Interceptor之后  
  20.         System.out.println("############TestFilter1 doFilter after############");  
  21. //      try {  
  22. //          Thread.sleep(10000);  
  23. //      } catch (InterruptedException e) {  
  24. //          e.printStackTrace();  
  25. //      }  
  26.     }  
  27.   
  28. }  

ii）过滤器2：

[java] view plain copy
 
  1. package cn.zifangsky.filter;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.FilterChain;  
  6. import javax.servlet.ServletException;  
  7. import javax.servlet.http.HttpServletRequest;  
  8. import javax.servlet.http.HttpServletResponse;  
  9.   
  10. import org.springframework.web.filter.OncePerRequestFilter;  
  11.   
  12. public class TestFilter2 extends OncePerRequestFilter {  
  13.   
  14.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)  
  15.             throws ServletException, IOException {  
  16.         System.out.println("############TestFilter2 doFilterInternal executed############");  
  17.         filterChain.doFilter(request, response);  
  18.         System.out.println("############TestFilter2 doFilter after############");  
  19.   
  20.     }  
  21.   
  22. }  

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

[xml] view plain copy
 
  1.     <!-- 自定义过滤器：testFilter1 -->   
  2.    <filter>  
  3.         <filter-name>testFilter1</filter-name>  
  4.         <filter-class>cn.zifangsky.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>cn.zifangsky.filter.TestFilter2</filter-class>  
  14.     </filter>  
  15.     <filter-mapping>  
  16.         <filter-name>testFilter2</filter-name>  
  17.         <url-pattern>/*</url-pattern>  
  18.     </filter-mapping>  

 

（2）再定义两个拦截器：

i）拦截器1，基本拦截器：

[java] view plain copy
 
  1. package cn.zifangsky.interceptor;  
  2.   
  3. import javax.servlet.http.HttpServletRequest;  
  4. import javax.servlet.http.HttpServletResponse;  
  5.   
  6. import org.springframework.web.servlet.HandlerInterceptor;  
  7. import org.springframework.web.servlet.ModelAndView;  
  8.   
  9. public class BaseInterceptor implements HandlerInterceptor{  
  10.       
  11.     /** 
  12.      * 在DispatcherServlet之前执行 
  13.      * */  
  14.     public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {  
  15.         System.out.println("************BaseInterceptor preHandle executed**********");  
  16.         return true;  
  17.     }  
  18.   
  19.     /** 
  20.      * 在controller执行之后的DispatcherServlet之后执行 
  21.      * */  
  22.     public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3)  
  23.             throws Exception {  
  24.         System.out.println("************BaseInterceptor postHandle executed**********");  
  25.     }  
  26.       
  27.     /** 
  28.      * 在页面渲染完成返回给客户端之前执行 
  29.      * */  
  30.     public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)  
  31.             throws Exception {  
  32.         System.out.println("************BaseInterceptor afterCompletion executed**********");  
  33. //      Thread.sleep(10000);  
  34.     }  
  35.   
  36. }  

ii）指定controller请求的拦截器：

[java] view plain copy
 
  1. package cn.zifangsky.interceptor;  
  2.   
  3. import javax.servlet.http.HttpServletRequest;  
  4. import javax.servlet.http.HttpServletResponse;  
  5.   
  6. import org.springframework.web.servlet.HandlerInterceptor;  
  7. import org.springframework.web.servlet.ModelAndView;  
  8.   
  9. public class TestInterceptor implements HandlerInterceptor {  
  10.   
  11.     public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {  
  12.         System.out.println("************TestInterceptor preHandle executed**********");  
  13.         return true;  
  14.     }  
  15.   
  16.     public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3)  
  17.             throws Exception {  
  18.         System.out.println("************TestInterceptor postHandle executed**********");  
  19.     }  
  20.   
  21.     public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)  
  22.             throws Exception {  
  23.         System.out.println("************TestInterceptor afterCompletion executed**********");  
  24.     }  
  25. }  

iii）在SpringMVC的配置文件中注册这两个拦截器：

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

（3）定义一个测试使用的controller：

[java] view plain copy
 
  1. package cn.zifangsky.controller;  
  2.   
  3. import org.springframework.stereotype.Controller;  
  4. import org.springframework.web.bind.annotation.RequestMapping;  
  5. import org.springframework.web.servlet.ModelAndView;  
  6.   
  7. @Controller  
  8. public class TestController {  
  9.       
  10.     @RequestMapping("/test.html")  
  11.     public ModelAndView handleRequest(){  
  12.         System.out.println("---------TestController executed--------");  
  13.         return new ModelAndView("test");  
  14.     }  
  15. }  

（4）视图页面test.jsp：

[html] view plain copy
 
  1. <%@ page language="java" contentType="text/html; charset=UTF-8"  
  2.     pageEncoding="UTF-8"%>  
  3. <%  
  4. String path = request.getContextPath();  
  5. String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";  
  6. %>      
  7. <html>  
  8. <head>  
  9. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
  10. <base href="http://983836259.blog.51cto.com/7311475/">  
  11. <title>FilterDemo</title>  
  12. </head>  
  13. <body>  
  14.     <%  
  15.         System.out.println("test.jsp is loading");  
  16.     %>  
  17.     <div align="center">  
  18.         This is test page  
  19.     </div>  
  20. </body>  
  21. </html>  

 

（5）测试效果：

启动此测试项目，可以看到控制台中输出如下：

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

接着清空控制台中的输出内容并访问：http://localhost:9180/FilterDemo/test.html

可以看到，此时的控制台输出结果如下：

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

注：对于整个SpringMVC的执行流程来说，如果加上上面的拦截器和过滤器，其最终的执行流程就如下图所示：

 

大家还可以参考一下这个电子书的截图：

 

本文转自:http://blog.csdn.net/xiaoyaotan_111/article/details/53817918

https://m.toutiaocdn.com/i6834310440495874563/?app=news_article&timestamp=1591280115&use_new_style=1&req_id=2020060422151501001405107801648124&group_id=6834310440495874563&tt_from=mobile_qq&utm_source=mobile_qq&utm_medium=toutiao_android&utm_campaign=client_share

posted @ 2017-04-27 14:26  ppjj  阅读(25703)  评论(1)  编辑  收藏  举报