java中過濾器、監聽器和攔截器三者的區別是什么

這篇文章給大家介紹java中過濾器、監聽器和攔截器三者的區別是什么，內容非常詳細，感興趣的小伙伴們可以參考借鑒，希望對大家能有所幫助。

過濾器、監聽器、攔截器概念

概念

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：

2、filter

3、listener

4、interceptor

補充：攔截器（Interceptor）和過濾器（Filter）的執行順序和區別

一、引言

本來想記錄一下關于用戶登陸和登陸之后的權限管理、菜單管理的問題，想到解決這個問題用到Interceptor，但想到了Interceptor，就想到了Filter，于是就想說一下它們的執行順序和區別。

關于Interceptor解決權限和菜單管理的問題，在放在下一篇寫吧，就醬紫。

二、區別

1、過濾器（Filter）

首先說一下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>

配置這個地方的目的，是讓所有的請求都需要進行字符編碼的設置，下面來介紹一下Filter。

（1）過濾器(Filter)：

它依賴于servlet容器。在實現上，基于函數回調，它可以對幾乎所有請求進行過濾，但是缺點是一個過濾器實例只能在容器初始化時調用一次。

使用過濾器的目的，是用來做一些過濾操作，獲取我們想要獲取的數據，比如：在Javaweb中，對傳入的request、response提前過濾掉一些信息，或者提前設置一些參數，然后再傳入servlet或者Controller進行業務邏輯操作。

通常用的場景是：在過濾器中修改字符編碼（CharacterEncodingFilter）、在過濾器中修改HttpServletRequest的一些參數（XSSFilter(自定義過濾器)），如：過濾低俗文字、危險字符等。

2、攔截器（Interceptor）

攔截器的配置一般在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>

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

在實現上,基于Java的反射機制，屬于面向切面編程（AOP）的一種運用，就是在service或者一個方法前，調用一個方法，或者在方法后，調用一個方法，比如動態代理就是攔截器的簡單實現，在調用方法前打印出字符串（或者做其它業務邏輯的操作），也可以在調用方法后打印出字符串，甚至在拋出異常的時候做業務邏輯的操作。

由于攔截器是基于web框架的調用，因此可以使用Spring的依賴注入（DI）進行一些業務操作，同時一個攔截器實例在一個controller生命周期之內可以多次調用。

但是缺點是只能對controller請求進行攔截，對其他的一些比如直接訪問靜態資源的請求則沒辦法進行攔截處理。

三、代碼

下面在一個項目中我們使用既有多個過濾器，又有多個攔截器，并觀察它們的執行順序：

（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中注冊這兩個過濾器：

 <!-- 自定義過濾器：testFilter1 --> 
 <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> 
 <!-- 自定義過濾器：testFilter2 --> 
 <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> 
 <!-- 對/test.html進行攔截 --> 
  <mvc:mapping path="/test.html"/> 
  <!-- 特定請求的攔截器只能有一個 --> 
  <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，可以看到控制臺中輸出如下：

這就說明了過濾器的運行是依賴于servlet容器，跟springmvc等框架并沒有關系。并且，多個過濾器的執行順序跟xml文件中定義的先后關系有關。

接著清空控制臺，并訪問：http://www.localhost:8080/demo/test，再次看控制臺的輸出：

從這個控制臺打印輸出，就可以很清晰地看到有多個攔截器和過濾器存在時的整個執行順序了。當然，對于多個攔截器它們之間的執行順序跟在SpringMVC的配置文件中定義的先后順序有關。

四、總結

對于上述過濾器和攔截器的測試，可以得到如下結論：

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

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

（3）、Filter的執行順序在Interceptor之前，具體的流程見下圖；

（4）、兩者的本質區別：攔截器（Interceptor）是基于Java的反射機制，而過濾器（Filter）是基于函數回調。

從靈活性上說攔截器功能更強大些，Filter能做的事情，都能做，而且可以在請求前，請求后執行，比較靈活。

Filter主要是針對URL地址做一個編碼的事情、過濾掉沒用的參數、安全校驗（比較泛的，比如登錄不登錄之類），太細的話，還是建議用interceptor。不過還是根據不同情況選擇合適的。

關于java中過濾器、監聽器和攔截器三者的區別是什么就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。