spring中mvc拦截器应用实例

《Java Web编程从入门到实践（15小时高清晰、交互式视频教学）》第23章SSpring的Web架构，本章结合实例讲解了Spring MVC框架的各个组件的使用方法、Spring拦截器和数据验证的使用方法，以及Spring和Struts 2集成的实现方法。本节为大家介绍使用拦截器。
23.4  使用拦截器
和Struts2一样，Spring MVC也可以使用拦截器对请求进行拦截处理，用户可以自定义拦截器来实现特定的功能，自定义的拦截器必须实现HandlerInterceptor接口。

【示例23-9】HandlerInterceptor接口的代码如下：

1.    package org.springframework.web.servlet;  

2.    import Javax.servlet.http.HttpServletRequest;  

3.    import Javax.servlet.http.HttpServletResponse;  

4.    public interface HandlerInterceptor {  

5.        // preHandle()方法在业务处理器处理请求之前被调用 

6.        boolean preHandle(HttpServletRequest request, 
HttpServletResponse response,  

7.        Object handler)  

8.            throws Exception;  

9.        // postHandle()方法在业务处理器处理请求之后被调用 

10.     void postHandle(  

11.             HttpServletRequest request, HttpServletResponse 
response, Object  

12.             handler, ModelAndView modelAndView)  

13.             throws Exception;  

14.     // afterCompletion()方法在DispatcherServlet完全处理完请求后被调用 

15.     void afterCompletion(  

16.             HttpServletRequest request, HttpServletResponse
response, Object  

17.             handler, Exception ex)  

18.             throws Exception;  

19.  

20. } 

下面对代码中的三个方法进行解释。

preHandle()：这个方法在业务处理器处理请求之前被调用，在该方法中对用户请求request进行处理。如果程序员决定该拦截器对请求进 行拦截处理后还要调用其他的拦截器，或者是业务处理器去进行处理，则返回true；如果程序员决定不需要再调用其他的组件去处理请求，则返回false。

postHandle()：这个方法在业务处理器处理完请求后，但是DispatcherServlet向客户端返回请求前被调用，在该方法中对用户请求request进行处理。

afterCompletion()：这个方法在DispatcherServlet完全处理完请求后被调用，可以在该方法中进行一些资源清理的操作。

下面通过一个例子来说明如何使用Spring MVC框架的拦截器。

【示例23-10】要求编写一个拦截器，拦截所有不在工作时间的请求，把这些请求转发到一个特定的静态页面，而不对它们的请求进行处理。

首先编写TimeInterceptor.Java，代码如下：

1.    package com.examp.ch23;  

2.    import Java.util.Calendar;  

3.    import Javax.servlet.http.HttpServletRequest;  

4.    import Javax.servlet.http.HttpServletResponse;  

5.    import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;  

6.     

7.    public class TimeInterceptor extends HandlerInterceptorAdapter {  

8.                                            //继承HandlerInterceptorAdapter类 

9.     

10.     private int openingTime;            //openingTime 属性指定上班时间 

11.     private int closingTime;            //closingTime属性指定下班时间 

12.     private String outsideOfficeHoursPage;  

13.                                         //outsideOfficeHoursPage属性指定错误 

14.                                           提示页面的URL  

15.     public void setOpeningTime(int openingTime) {  

16.         this.openingTime = openingTime;  

17.     }  

18.     public void setClosingTime(int closingTime) {  

19.         this.closingTime = closingTime;  

20.     }  

21.     public void setOutsideOfficeHoursPage(String outsideOfficeHoursPage) {  

22.         this.outsideOfficeHoursPage = outsideOfficeHoursPage;  

23.     }  

24.     //重写 preHandle()方法，在业务处理器处理请求之前对该请求进行拦截处理 

25.     public boolean preHandle(  

26.             HttpServletRequest request,  

27.             HttpServletResponse response,  

28.             Object handler)  

29.     throws Exception {  

30.         Calendar cal = Calendar.getInstance();  

31.         int hour = cal.get(Calendar.HOUR_OF_DAY);       //获取当前时间 

32.         if (openingTime<=hour && hour<closingTime) {    //判断当前是否处于工作 

33.                                                           时间段内  

34.             return true;  

35.         } else {  

36.             response.sendRedirect(outsideOfficeHoursPage);  //返回提示页面 

37.             return false;  

38.         }  

39.     }  

40. } 

可以看出，上面的代码重载了preHandle()方法，该方法在业务处理器处理请求之前被调用。在该方法中，首先获得当前的时间，判断其是否在 openingTime和closingTime之间，如果在，返回true，这样才会调用业务控制器去处理该请求；否则直接转向一个静态页面，返回 false，这样该请求就不会被处理。

下面是在dispatcherServlet-servlet.xml中对拦截器进行的配置，代码如下：

1.    <bean id="urlMapping" class="org.springframework.web.servlet.handler.Simple-  

2.    UrlHandlerMapping">  

3.            <property name="mappings">  

4.                <props>  

5.                    <prop key="helloWorld.do">helloWorldAction</prop>  

6.                    <prop key="login.do">loginController</prop>  

7.                </props>  

8.            </property>  

9.            <property name="interceptors">  

10.                                 <!--在interceptors 属性中定义所有的拦截器-->  

11.             <list>  

12.                 <ref bean="officeHoursInterceptor"/>  

13.                                 <!--引用officeHoursInterceptor 拦截器-->  

14.             </list>  

15.         </property>  

16.           

17. </bean>  

18. <!--定义TimeInterceptor拦截器，id为officeHoursInterceptor -->  

19. <bean id="officeHoursInterceptor" 

20.       class="com.examp.ch23.TimeInterceptor">  

21.     <!--openingTime 属性指定上班时间-->  

22.     <property name="openingTime"><value>9</value></property>  

23.     <!--closingTime属性指定下班时间-->  

24.     <property name="closingTime"><value>18</value></property>  

25.      <!--outsideOfficeHoursPage属性指定提示页面的URL-->  

26.     <property name="outsideOfficeHoursPage"><value>http://localhost:8080/  

27.     ch23/outsideOfficeHours.html</value></property>  

28. </bean> 

可以看出，上面代码用bean标签去定义TimeInterceptor，令其id为officeHoursInterceptor，并给它的3个 属性赋值。在urlMapping中通过<property name="interceptors">去指定officeHoursInterceptor为一个拦截器，读者可以在<list> 和</list>之间定义多个拦截器。

outsideOfficeHours.html的代码很简单，只是输出一句提示语。

运行程序，在浏览器中随便访问一个页面，如果请求的时间在9点～18点之间，则该请求可以被处理；否则，返回一句提示语，

 说 明：在第22章中介绍过控制反转是Spring框架的核心思想，即用一个接口去定义一些操作，在接口的实现类中去重写这些操作，然后在Spring的配置 文件中去把该接口的实现类注入到应有框架中，这样就可以通过调用接口去调用接口的实现类。本节讲的拦截器就体现了这种思想，即实现 HandlerInterceptorAdapter接口，重写preHandle()方法并在配置文件中实现TimeInterceptor的注入。这 样当框架调用HandlerInterceptorAdapter时，就可以调用到TimeInterceptor类的preHandle()方法