碼上快樂

相關內容    簡體    繁體

spring過濾器和攔截器的區別和聯系

本文轉載自   查看原文   2017-04-27 14:26   21789    sping

一 簡介

（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


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Spring 過濾器和攔截器的區別和聯系 Spring Aop、攔截器、過濾器的區別 Spring 中攔截器與過濾器的區別 spring boot 過濾器、攔截器的區別與使用 Spring--攔截器和過濾器的區別 Spring Aop、攔截器、過濾器的區別 spring boot 過濾器、攔截器的區別與使用 spring:過濾器和攔截器 過濾器與攔截器的區別 過濾器和攔截器的區別
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM