spring 自定义拦截器

nannan408

浏览: 1771179 次
性别:
来自: 深圳

最近访客更多访客>>

greatwqs

c332030

hexin1985

yb2008qq

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

1.前言.
本文转自:http://blog.csdn.net/tjcyjd/article/details/7498236
2.内容。
 经过一天的奋战，终于会使用了SpringMVC，下面讲下他的拦截器。使用SpringMVC拦截器和Struts2一样，Spring MVC也可以使用拦截器对请求进行拦截处理，用户可以自定义拦截器来实现特定的功能，自定义的拦截器必须实现HandlerInterceptor接口。完整的例子可以到我的资源下载：http://download.csdn.net/download/tjcyjd/4255319
HandlerInterceptor接口的代码如下：

[java] view plaincopyprint?
01.package org.springframework.web.servlet;
02.import Javax.servlet.http.HttpServletRequest;
03.import Javax.servlet.http.HttpServletResponse;
04.public interface HandlerInterceptor {
05. // preHandle()方法在业务处理器处理请求之前被调用
06. boolean preHandle(HttpServletRequest request,
07.HttpServletResponse response,
08. Object handler)
09. throws Exception;
10. // postHandle()方法在业务处理器处理请求之后被调用
11. void postHandle(
12. HttpServletRequest request, HttpServletResponse
13.response, Object
14. handler, ModelAndView modelAndView)
15. throws Exception;
16. // afterCompletion()方法在DispatcherServlet完全处理完请求后被调用
17. void afterCompletion(
18. HttpServletRequest request, HttpServletResponse
19.response, Object
20. handler, Exception ex)
21. throws Exception;
22.
23. }
package org.springframework.web.servlet;
import Javax.servlet.http.HttpServletRequest;
import Javax.servlet.http.HttpServletResponse;
public interface HandlerInterceptor {
 // preHandle()方法在业务处理器处理请求之前被调用
 boolean preHandle(HttpServletRequest request,
HttpServletResponse response,
 Object handler)
 throws Exception;
 // postHandle()方法在业务处理器处理请求之后被调用
 void postHandle(
 HttpServletRequest request, HttpServletResponse
response, Object
 handler, ModelAndView modelAndView)
 throws Exception;
 // afterCompletion()方法在DispatcherServlet完全处理完请求后被调用
 void afterCompletion(
 HttpServletRequest request, HttpServletResponse
response, Object
 handler, Exception ex)
 throws Exception;

}

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

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

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

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

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

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

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

[sql] view plaincopyprint?
01.package com.yjde.web.interceptor;
02.
03.import java.util.Calendar;
04.
05.import javax.servlet.http.HttpServletRequest;
06.import javax.servlet.http.HttpServletResponse;
07.
08.import org.springframework.web.servlet.ModelAndView;
09.import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
10.
11.public class TimeInterceptor extends HandlerInterceptorAdapter {
12. // 继承HandlerInterceptorAdapter类
13.
14. private int openingTime; // openingTime 属性指定上班时间
15. private int closingTime; // closingTime属性指定下班时间
16. private String outsideOfficeHoursPage;// outsideOfficeHoursPage属性指定错误提示页面的URL
17.
18. // 重写 preHandle()方法，在业务处理器处理请求之前对该请求进行拦截处理
19. public boolean preHandle(HttpServletRequest request,
20. HttpServletResponse response, Object handler) throws Exception {
21. Calendar cal = Calendar.getInstance();
22. int hour = cal.get(Calendar.HOUR_OF_DAY); // 获取当前时间
23. if (openingTime <= hour && hour < closingTime) { // 判断当前是否处于工作时间段内
24. return true;
25. } else {
26. response.sendRedirect(outsideOfficeHoursPage); // 返回提示页面
27. return false;
28. }
29. }
30.
31. public void postHandle(HttpServletRequest request,
32. HttpServletResponse response, Object o, ModelAndView mav)
33. throws Exception {
34. System.out.println("postHandle");
35. }
36.
37. public void afterCompletion(HttpServletRequest request,
38. HttpServletResponse response, Object o, Exception excptn)
39. throws Exception {
40. System.out.println("afterCompletion");
41. }
42.
43. public int getOpeningTime() {
44. return openingTime;
45. }
46.
47. public void setOpeningTime(int openingTime) {
48. this.openingTime = openingTime;
49. }
50.
51. public int getClosingTime() {
52. return closingTime;
53. }
54.
55. public void setClosingTime(int closingTime) {
56. this.closingTime = closingTime;
57. }
58.
59. public String getOutsideOfficeHoursPage() {
60. return outsideOfficeHoursPage;
61. }
62.
63. public void setOutsideOfficeHoursPage(String outsideOfficeHoursPage) {
64. this.outsideOfficeHoursPage = outsideOfficeHoursPage;
65. }
66.
67.}
68.// 可以看出，上面的代码重载了preHandle()方法，该方法在业务处理器处理请求之前被调用。在该方法中，首先获得当前的时间，判断其是否在
69.// openingTime和closingTime之间，如果在，返回true，这样才会调用业务控制器去处理该请求；否则直接转向一个页面，返回false，这样该请求就不会被处理。
package com.yjde.web.interceptor;

import java.util.Calendar;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

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

public class TimeInterceptor extends HandlerInterceptorAdapter {
// 继承HandlerInterceptorAdapter类

private int openingTime; // openingTime 属性指定上班时间
private int closingTime; // closingTime属性指定下班时间
private String outsideOfficeHoursPage;// outsideOfficeHoursPage属性指定错误提示页面的URL

// 重写 preHandle()方法，在业务处理器处理请求之前对该请求进行拦截处理
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {
Calendar cal = Calendar.getInstance();
int hour = cal.get(Calendar.HOUR_OF_DAY); // 获取当前时间
if (openingTime <= hour && hour < closingTime) { // 判断当前是否处于工作时间段内
return true;
} else {
response.sendRedirect(outsideOfficeHoursPage); // 返回提示页面
return false;
}
}

public void postHandle(HttpServletRequest request,
HttpServletResponse response, Object o, ModelAndView mav)
throws Exception {
System.out.println("postHandle");
}

public void afterCompletion(HttpServletRequest request,
HttpServletResponse response, Object o, Exception excptn)
throws Exception {
System.out.println("afterCompletion");
}

public int getOpeningTime() {
return openingTime;
}

public void setOpeningTime(int openingTime) {
this.openingTime = openingTime;
}

public int getClosingTime() {
return closingTime;
}

public void setClosingTime(int closingTime) {
this.closingTime = closingTime;
}

public String getOutsideOfficeHoursPage() {
return outsideOfficeHoursPage;
}

public void setOutsideOfficeHoursPage(String outsideOfficeHoursPage) {
this.outsideOfficeHoursPage = outsideOfficeHoursPage;
}

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

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

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

[java] view plaincopyprint?
01.<PRE class=html name="code"><?xml version="1.0" encoding="UTF-8"?>
02.<beans xmlns="http://www.springframework.org/schema/beans"
03. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
04. xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
05. xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
06. xsi:schemaLocation="http://www.springframework.org/schema/beans
07. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
08. http://www.springframework.org/schema/context
09. http://www.springframework.org/schema/context/spring-context-3.0.xsd
10. http://www.springframework.org/schema/aop
11. http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
12. http://www.springframework.org/schema/tx
13. http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
14. http://www.springframework.org/schema/mvc
15. http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
16. http://www.springframework.org/schema/context
17. http://www.springframework.org/schema/context/spring-context-3.0.xsd">
18. 
21. <context:component-scan base-package="com.yjde.web.controller" />
22.
23. <bean id="viewResolver"
24. class="org.springframework.web.servlet.view.InternalResourceViewResolver"
25. p:prefix="/WEB-INF/jsp/" p:suffix=".jsp" />
26. <mvc:interceptors>
27. <mvc:interceptor>
28. 
29. <mvc:mapping path="/login1.htm" />
30. <mvc:mapping path="/login2.htm" />
31. <bean class="com.yjde.web.interceptor.TimeInterceptor">
32. 
33. <property name="openingTime">
34. <value>12</value>
35. </property>
36. 
37. <property name="closingTime">
38. <value>14</value>
39. </property>
40. 
41. <property name="outsideOfficeHoursPage">
42. <value>http://localhost:8080/SpringMVCInterceptor/jsp/outsideOfficeHours.jsp
43. </value>
44. </property>
45. </bean>
46. </mvc:interceptor>
47. </mvc:interceptors>
48. <bean id="messageSource"
49. class="org.springframework.context.support.ResourceBundleMessageSource"
50. p:basename="message">
51. </bean>
52.</beans></PRE> 
53. 
54.<PRE></PRE>
55.
56.<PRE></PRE>
57.
58.可以看出，上面代码用bean标签去定义TimeInterceptor，令其id为officeHoursInterceptor，并给它的3个属性赋值。具体的大家可以运行一下项目看看。
59. 
60.说明：控制反转是Spring框架的核心思想，即用一个接口去定义一些操作，在接口的实现类中去重写这些操作，然后在Spring的配置文件中去把该接口的实现类注入到应有框架中，这样就可以通过调用接口去调用接口的实现类。此次讲的拦截器就体现了这种思想，即实现 HandlerInterceptorAdapter接口，重写preHandle()方法并在配置文件中实现TimeInterceptor的注入。这
61. 样当框架调用HandlerInterceptorAdapter时，就可以调用到TimeInterceptor类的preHandle()方法。
62.
63.<H4><A name=t1></A>完整的例子可以到我的资源下载：<A href="http://download.csdn.net/download/tjcyjd/4255319">http://download.csdn.net/download/tjcyjd/4255319</A></H4>
64.
65. 
66.
67.

分享到：