SpringMVC配置攔截器

冰雪Love齊跡發表於2017-12-07
SpringMVC

   SpringMVC 中的Interceptor 攔截器也是相當重要和相當有用的，它的主要作用是攔截使用者的請求並進行相應的處理。比如通過它來進行許可權驗證，或者是來判斷使用者是否登陸，或者是像12306 那樣子判斷當前時間是否是購票時間。

   一、定義Interceptor實現類

   SpringMVC 中的Interceptor 攔截請求是通過HandlerInterceptor 來實現的。在SpringMVC 中定義一個Interceptor 非常簡單，主要有兩種方式，第一種方式是要定義的Interceptor類要實現了Spring 的HandlerInterceptor 介面，或者是這個類繼承實現了HandlerInterceptor 介面的類，比如Spring 已經提供的實現了HandlerInterceptor 介面的抽象類HandlerInterceptorAdapter ；第二種方式是實現Spring的WebRequestInterceptor介面，或者是繼承實現了WebRequestInterceptor的類。

   （一）實現HandlerInterceptor介面

   HandlerInterceptor 介面中定義了三個方法，我們就是通過這三個方法來對使用者的請求進行攔截處理的。

   （1 ）preHandle (HttpServletRequest request, HttpServletResponse response, Object handle) 方法，顧名思義，該方法將在請求處理之前進行呼叫。SpringMVC 中的Interceptor 是鏈式的呼叫的，在一個應用中或者說是在一個請求中可以同時存在多個Interceptor 。每個Interceptor 的呼叫會依據它的宣告順序依次執行，而且最先執行的都是Interceptor 中的preHandle 方法，所以可以在這個方法中進行一些前置初始化操作或者是對當前請求的一個預處理，也可以在這個方法中進行一些判斷來決定請求是否要繼續進行下去。該方法的返回值是布林值Boolean 型別的，當它返回為false 時，表示請求結束，後續的Interceptor 和Controller 都不會再執行；當返回值為true 時就會繼續呼叫下一個Interceptor 的preHandle 方法，如果已經是最後一個Interceptor 的時候就會是呼叫當前請求的Controller 方法。

   （2 ）postHandle (HttpServletRequest request, HttpServletResponse response, Object handle, ModelAndView modelAndView) 方法，由preHandle 方法的解釋我們知道這個方法包括後面要說到的afterCompletion 方法都只能是在當前所屬的Interceptor 的preHandle 方法的返回值為true 時才能被呼叫。postHandle 方法，顧名思義就是在當前請求進行處理之後，也就是Controller 方法呼叫之後執行，但是它會在DispatcherServlet 進行檢視返回渲染之前被呼叫，所以我們可以在這個方法中對Controller 處理之後的ModelAndView 物件進行操作。postHandle 方法被呼叫的方向跟preHandle 是相反的，也就是說先宣告的Interceptor 的postHandle 方法反而會後執行，這和Struts2裡面的Interceptor 的執行過程有點型別。Struts2 裡面的Interceptor 的執行過程也是鏈式的，只是在Struts2 裡面需要手動呼叫ActionInvocation 的invoke 方法來觸發對下一個Interceptor 或者是Action 的呼叫，然後每一個Interceptor 中在invoke 方法呼叫之前的內容都是按照宣告順序執行的，而invoke 方法之後的內容就是反向的。

   （3 ）afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handle, Exception ex) 方法，該方法也是需要當前對應的Interceptor 的preHandle 方法的返回值為true 時才會執行。顧名思義，該方法將在整個請求結束之後，也就是在DispatcherServlet 渲染了對應的檢視之後執行。這個方法的主要作用是用於進行資源清理工作的。

下面是一個簡單的程式碼說明：

Java程式碼  收藏程式碼
  1. import javax.servlet.http.HttpServletRequest;  
  2. import javax.servlet.http.HttpServletResponse;  
  3. import org.springframework.web.servlet.HandlerInterceptor;  
  4. import org.springframework.web.servlet.ModelAndView;  
  5. public class SpringMVCInterceptor implements HandlerInterceptor {  
  6.     /** 
  7.      * preHandle方法是進行處理器攔截用的，顧名思義，該方法將在Controller處理之前進行呼叫，SpringMVC中的Interceptor攔截器是鏈式的，可以同時存在 
  8.      * 多個Interceptor，然後SpringMVC會根據宣告的前後順序一個接一個的執行，而且所有的Interceptor中的preHandle方法都會在 
  9.      * Controller方法呼叫之前呼叫。SpringMVC的這種Interceptor鏈式結構也是可以進行中斷的，這種中斷方式是令preHandle的返 
  10.      * 回值為false，當preHandle的返回值為false的時候整個請求就結束了。 
  11.      */  
  12.     @Override  
  13.     public boolean preHandle(HttpServletRequest request,  
  14.             HttpServletResponse response, Object handler) throws Exception {  
  15.         // TODO Auto-generated method stub  
  16.         return false;  
  17.     }  
  18.       
  19.     /** 
  20.      * 這個方法只會在當前這個Interceptor的preHandle方法返回值為true的時候才會執行。postHandle是進行處理器攔截用的，它的執行時間是在處理器進行處理之 
  21.      * 後，也就是在Controller的方法呼叫之後執行，但是它會在DispatcherServlet進行檢視的渲染之前執行，也就是說在這個方法中你可以對ModelAndView進行操 
  22.      * 作。這個方法的鏈式結構跟正常訪問的方向是相反的，也就是說先宣告的Interceptor攔截器該方法反而會後呼叫，這跟Struts2裡面的攔截器的執行過程有點像， 
  23.      * 只是Struts2裡面的intercept方法中要手動的呼叫ActionInvocation的invoke方法，Struts2中呼叫ActionInvocation的invoke方法就是呼叫下一個Interceptor 
  24.      * 或者是呼叫action，然後要在Interceptor之前呼叫的內容都寫在呼叫invoke之前，要在Interceptor之後呼叫的內容都寫在呼叫invoke方法之後。 
  25.      */  
  26.     @Override  
  27.     public void postHandle(HttpServletRequest request,  
  28.             HttpServletResponse response, Object handler,  
  29.             ModelAndView modelAndView) throws Exception {  
  30.         // TODO Auto-generated method stub  
  31.     }  
  32.   
  33.     /** 
  34.      * 該方法也是需要當前對應的Interceptor的preHandle方法的返回值為true時才會執行。該方法將在整個請求完成之後，也就是DispatcherServlet渲染了檢視執行， 
  35.      * 這個方法的主要作用是用於清理資源的，當然這個方法也只能在當前這個Interceptor的preHandle方法的返回值為true時才會執行。 
  36.      */  
  37.     @Override  
  38.     public void afterCompletion(HttpServletRequest request,  
  39.             HttpServletResponse response, Object handler, Exception ex)  
  40.     throws Exception {  
  41.         // TODO Auto-generated method stub  
  42.           
  43.     }  
  44.       
  45. }  

   （二）實現WebRequestInterceptor 介面

  WebRequestInterceptor 中也定義了三個方法，我們也是通過這三個方法來實現攔截的。這三個方法都傳遞了同一個引數WebRequest ，那麼這個WebRequest 是什麼呢？這個WebRequest 是Spring 定義的一個介面，它裡面的方法定義都基本跟HttpServletRequest 一樣，在WebRequestInterceptor 中對WebRequest 進行的所有操作都將同步到HttpServletRequest 中，然後在當前請求中一直傳遞。

   （1 ）preHandle(WebRequest request) 方法。該方法將在請求處理之前進行呼叫，也就是說會在Controller 方法呼叫之前被呼叫。這個方法跟HandlerInterceptor 中的preHandle 是不同的，主要區別在於該方法的返回值是void ，也就是沒有返回值，所以我們一般主要用它來進行資源的準備工作，比如我們在使用Hibernate 的時候可以在這個方法中準備一個Hibernate 的Session 物件，然後利用WebRequest 的setAttribute(name, value, scope) 把它放到WebRequest 的屬性中。這裡可以說說這個setAttribute 方法的第三個引數scope ，該引數是一個Integer 型別的。在WebRequest 的父層介面RequestAttributes 中對它定義了三個常量：

   SCOPE_REQUEST ：它的值是0 ，代表只有在request 中可以訪問。

   SCOPE_SESSION ：它的值是1 ，如果環境允許的話它代表的是一個區域性的隔離的session，否則就代表普通的session，並且在該session範圍內可以訪問。

   SCOPE_GLOBAL_SESSION ：它的值是2 ，如果環境允許的話，它代表的是一個全域性共享的session，否則就代表普通的session，並且在該session 範圍內可以訪問。

   （2 ）postHandle(WebRequest request, ModelMap model) 方法。該方法將在請求處理之後，也就是在Controller 方法呼叫之後被呼叫，但是會在檢視返回被渲染之前被呼叫，所以可以在這個方法裡面通過改變資料模型ModelMap 來改變資料的展示。該方法有兩個引數，WebRequest 物件是用於傳遞整個請求資料的，比如在preHandle 中準備的資料都可以通過WebRequest 來傳遞和訪問；ModelMap 就是Controller 處理之後返回的Model 物件，我們可以通過改變它的屬性來改變返回的Model 模型。

   （3 ）afterCompletion(WebRequest request, Exception ex) 方法。該方法會在整個請求處理完成，也就是在檢視返回並被渲染之後執行。所以在該方法中可以進行資源的釋放操作。而WebRequest 引數就可以把我們在preHandle 中準備的資源傳遞到這裡進行釋放。Exception 參數列示的是當前請求的異常物件，如果在Controller中丟擲的異常已經被Spring 的異常處理器給處理了的話，那麼這個異常物件就是是null 。

 

   下面是一個簡單的程式碼說明：

Java程式碼  收藏程式碼
  1. import org.springframework.ui.ModelMap;  
  2. import org.springframework.web.context.request.WebRequest;  
  3. import org.springframework.web.context.request.WebRequestInterceptor;  
  4.   
  5. public class AllInterceptor implements WebRequestInterceptor {  
  6.       
  7.     /** 
  8.      * 在請求處理之前執行，該方法主要是用於準備資源資料的，然後可以把它們當做請求屬性放到WebRequest中 
  9.      */  
  10.     @Override  
  11.     public void preHandle(WebRequest request) throws Exception {  
  12.         // TODO Auto-generated method stub  
  13.         System.out.println("AllInterceptor...............................");  
  14.         request.setAttribute("request", "request", WebRequest.SCOPE_REQUEST);//這個是放到request範圍內的，所以只能在當前請求中的request中獲取到  
  15.         request.setAttribute("session", "session", WebRequest.SCOPE_SESSION);//這個是放到session範圍內的，如果環境允許的話它只能在區域性的隔離的會話中訪問，否則就是在普通的當前會話中可以訪問  
  16.         request.setAttribute("globalSession", "globalSession", WebRequest.SCOPE_GLOBAL_SESSION);//如果環境允許的話，它能在全域性共享的會話中訪問，否則就是在普通的當前會話中訪問  
  17.     }  
  18.   
  19.     /** 
  20.      * 該方法將在Controller執行之後，返回檢視之前執行，ModelMap表示請求Controller處理之後返回的Model物件，所以可以在 
  21.      * 這個方法中修改ModelMap的屬性，從而達到改變返回的模型的效果。 
  22.      */  
  23.     @Override  
  24.     public void postHandle(WebRequest request, ModelMap map) throws Exception {  
  25.         // TODO Auto-generated method stub  
  26.         for (String key:map.keySet())  
  27.             System.out.println(key + "-------------------------");;  
  28.         map.put("name3", "value3");  
  29.         map.put("name1", "name1");  
  30.     }  
  31.   
  32.     /** 
  33.      * 該方法將在整個請求完成之後，也就是說在檢視渲染之後進行呼叫，主要用於進行一些資源的釋放 
  34.      */  
  35.     @Override  
  36.     public void afterCompletion(WebRequest request, Exception exception)  
  37.     throws Exception {  
  38.         // TODO Auto-generated method stub  
  39.         System.out.println(exception + "-=-=--=--=-=-=-=-=-=-=-=-==-=--=-=-=-=");  
  40.     }  
  41.       
  42. }  
 

 

  二、把定義的攔截器類加到SpringMVC的攔截體系中

         1.在SpringMVC的配置檔案中加上支援MVC的schema

Xml程式碼  收藏程式碼
  1.     xmlns:mvc="http://www.springframework.org/schema/mvc"  
  2.     xsi:schemaLocation=" http://www.springframework.org/schema/mvc  
  3.         http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"  
 

         下面是我的宣告示例：

Xml程式碼  收藏程式碼
  1. <beans xmlns="http://www.springframework.org/schema/beans"  
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
  3.     xmlns:mvc="http://www.springframework.org/schema/mvc"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  5.      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  6.      http://www.springframework.org/schema/context  
  7.      http://www.springframework.org/schema/context/spring-context-3.0.xsd  
  8.      http://www.springframework.org/schema/mvc  
  9.      http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">  

         這樣在SpringMVC的配置檔案中就可以使用mvc標籤了，mvc標籤中有一個mvc:interceptors是用於宣告SpringMVC的攔截器的。

 

        （二）使用mvc:interceptors標籤來宣告需要加入到SpringMVC攔截器鏈中的攔截器

Xml程式碼  收藏程式碼
  1. <mvc:interceptors>  
  2.     <!-- 使用bean定義一個Interceptor，直接定義在mvc:interceptors根下面的Interceptor將攔截所有的請求 -->  
  3.     <bean class="com.host.app.web.interceptor.AllInterceptor"/>  
  4.     <mvc:interceptor>  
  5.         <mvc:mapping path="/test/number.do"/>  
  6.         <!-- 定義在mvc:interceptor下面的表示是對特定的請求才進行攔截的 -->  
  7.         <bean class="com.host.app.web.interceptor.LoginInterceptor"/>  
  8.     </mvc:interceptor>  
  9. </mvc:interceptors>  

          由上面的示例可以看出可以利用mvc:interceptors標籤宣告一系列的攔截器，然後它們就可以形成一個攔截器鏈，攔截器的執行順序是按宣告的先後順序執行的，先宣告的攔截器中的preHandle方法會先執行，然而它的postHandle方法和afterCompletion方法卻會後執行。

          在mvc:interceptors標籤下宣告interceptor主要有兩種方式：

                    （1）直接定義一個Interceptor實現類的bean物件。使用這種方式宣告的Interceptor攔截器將會對所有的請求進行攔截。

                    （2）使用mvc:interceptor標籤進行宣告。使用這種方式進行宣告的Interceptor可以通過mvc:mapping子標籤來定義需要進行攔截的請求路徑。

          經過上述兩步之後，定義的攔截器就會發生作用對特定的請求進行攔截了。

  （三）使用web.xml控制攔截請求

.DispatcherServlet

    SpringMVC具有統一的入口DispatcherServlet，所有的請求都通過DispatcherServlet。
    DispatcherServlet是前置控制器，配置在web.xml檔案中的。攔截匹配的請求，Servlet攔截匹配規則要自已定義，把攔截下來的請求，依據某某規則分發到目標Controller來處理。  所以我們現在web.xml中加入以下配置：
[html] view plain copy
  1. <!-- 初始化 DispatcherServlet時，該框架在 web應用程式WEB-INF目錄中尋找一個名為[servlet-名稱]-servlet.xml的檔案，  
  2.          並在那裡定義相關的Beans，重寫在全域性中定義的任何Beans -->  
  3.    <servlet>  
  4.      <servlet-name>springMybatis</servlet-name>  
  5.      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
  6.      <load-on-startup>1</load-on-startup>  
  7.    </servlet>  
  8.    <servlet-mapping>  
  9.      <servlet-name>springMybatis</servlet-name>  
  10.      <!-- 所有的的請求，都會被DispatcherServlet處理 -->  
  11.      <url-pattern>/</url-pattern>  
  12.    </servlet-mapping>  

2.靜態資源不攔截

       如果只配置攔截類似於*.do格式的url，則對靜態資源的訪問是沒有問題的，但是如果配置攔截了所有的請求（如我們上面配置的“/”），就會造成js檔案、css檔案、圖片檔案等靜態資源無法訪問。
      一般實現攔截器主要是為了許可權管理，主要是攔截一些url請求，所以不對靜態資源進行攔截。要過濾掉靜態資源一般有兩種方式，
      第一種是採用<mvc:default-servlet-handler />，（一般Web應用伺服器預設的Servlet名稱是"default"，所以這裡我們啟用Tomcat的defaultServlet來處理靜態檔案，在web.xml裡配置如下程式碼即可：）
[html] view plain copy
  1. <!--　該servlet為tomcat,jetty等容器提供,將靜態資源對映從/改為/static/目錄，如原來訪問　http://localhost/foo.css　,現在http://localhost/static/foo.css　-->  
  2. <!-- 不攔截靜態檔案 -->  
  3. <servlet-mapping>  
  4.     <servlet-name>default</servlet-name>  
  5.     <url-pattern>/js/*</url-pattern>  
  6.     <url-pattern>/css/*</url-pattern>  
  7.     <url-pattern>/images/*</url-pattern>  
  8.     <url-pattern>/fonts/*</url-pattern>  
  9. </servlet-mapping>  

        Tomcat, Jetty, JBoss, and GlassFish  預設 Servlet的名字 -- "default"
        Resin 預設 Servlet的名字 -- "resin-file"
        WebLogic 預設 Servlet的名字  -- "FileServlet"
        WebSphere  預設 Servlet的名字 -- "SimpleFileServlet"

相關文章