教你如何使用Struts2拦截器并且定义自己的拦截器

看到网上很多介绍关于拦截器的文章，感觉都不错，但是都没有很详细全面的介绍，所以我就博众家之长，呵呵，写了篇关于struts拦截器的东西。 

 
拦截器的工作原理如上图，在工作的时候每一个Action请求都被包装在一堆拦截器的内部。拦截器可以在Action执行直线做相似的操作也可以在Action执行直后做回收操作。 

每一个Action既可以将操作转交给下面的拦截器，Action也可以直接退出操作返回客户既定的画面。 

下面我们来讲讲如何使用struts2拦截器，或者是自定义拦截器。 

先说说使用Struts自带的拦截器： 
在Struts2中已经在struts-default.xml中预定义了一些自带的拦截器，如timer、params等。如果在<package>标签中继承struts-default，则当前package就会自动拥有struts-default.xml中的所有配置。代码如下： 

<package name="demo" extends="struts-default" > ... </package> 

在struts-default.xml中有一个默认的引用，在默认情况下（也就是<action>中未引用拦截器时）会自动引用一些拦截器。这个默认的拦截器引用如下： 

Xml代码  

1. <interceptor-stack name="defaultStack">  
2.     <interceptor-ref name="exception"/>  
3.     <interceptor-ref name="alias"/>  
4.     <interceptor-ref name="servletConfig"/>  
5.     <interceptor-ref name="prepare"/>  
6.     <interceptor-ref name="i18n"/>  
7.     <interceptor-ref name="chain"/>  
8.     <interceptor-ref name="debugging"/>  
9.     <interceptor-ref name="profiling"/>  
10.     <interceptor-ref name="scopedModelDriven"/>  
11.     <interceptor-ref name="modelDriven"/>  
12.     <interceptor-ref name="fileUpload"/>  
13.     <interceptor-ref name="checkbox"/>  
14.     <interceptor-ref name="staticParams"/>  
15.     <interceptor-ref name="params">  
16.       <param name="excludeParams">dojo\..*</param>  
17.     </interceptor-ref>  
18.     <interceptor-ref name="conversionError"/>  
19.     <interceptor-ref name="validation">  
20.         <param name="excludeMethods">input,back,cancel,browse</param>  
21.     </interceptor-ref>  
22.     <interceptor-ref name="workflow">  
23.         <param name="excludeMethods">input,back,cancel,browse</param>  
24.     </interceptor-ref>  
25. </interceptor-stack>  

上面在defaultStack中引用的拦截器都可以在<action>中不经过引用就可以使用（如果在<action>中引用了任何拦截器后，要使用在defaultStack中定义的拦截器，也需要在<action>中重新引用，在后面的“二、通过请求调用Action的setter方法(params)”将详细讲解）。 
下面我们来看几个简单的拦截器的使用方法。 

一、记录拦截器和execute方法的执行时间(timer拦截器) 

timer是Struts2中最简单的拦截器，这个拦截器对应的类是com.opensymphony.xwork2.interceptor.TimerInterceptor。它的功能是记录execute方法和其他拦截器（在timer后面定义的拦截器）的intercept方法执行的时间总和。如下面的配置代码所示： 

Xml代码  

1. <action name="first" class="action.FirstAction">  
2.     <interceptor-ref name="logger"/>  
3.     <interceptor-ref name="timer" />  
4. </action>  

由于在timer后面没有其他的拦截器定义，因此，timer只能记录execute方法的执行时间，在访问first动作时，会在控制台输出类似下面的一条信息： 

信息: Executed action [/test/first!execute] took 16 ms. 

在使用timer拦截器时，需要commons-logging.jar的支持。将logger引用放到timer的后面，就可以记录logger拦截器的intercept方法和Action的execute方法的执行时间总和，代码如下： 

Xml代码  

1. <action name="first" class="action.FirstAction">  
2.     <interceptor-ref name="timer" />  
3.     <interceptor-ref name="logger"/>  
4. </action>  

大家可以使用如下的Action类来测试一下timer拦截器： 

Java代码  

1. package action;  
2.   
3. import com.opensymphony.xwork2.ActionSupport;  
4.   
5. public class FirstAction extends ActionSupport            
6.   
7. {  
8.        public String execute() throws Exception  
9.   
10.        {  
11.            Thread.sleep(2000); // 延迟2秒  
12.            return null;  
13.        }  
14.   
15. }  

如果只记录execute方法的执行时间，一般会输出如下的信息： 

信息: Executed action [/test/first!execute] took 2000 ms. 

二、通过请求调用Action的setter方法(params) 


    当客户端的一个form向服务端提交请求时，如有一个textfield，代码如下： 

Jsp代码  

1. <s:form action="first" namespace="/test">  
2.    <s:textfield name="name"/>  
3.    <s:submit/>  
4. </s:form>  

在提交后，Struts2将会自动调用first动作类中的setName方法，并将name文本框中的值通过setName方法的参数传入。实际上，这个操作是由params拦截器完成的，params对应的类是com.opensymphony.xwork2.interceptor.ParametersInterceptor。由于params已经在defaultStack中定义，因此，在未引用拦截器的<action>中是会自动引用params的，如下面的配置代码，在访问first动作时，Struts2是会自动执行相应的setter方法的。 

<action name="first" class="action.FirstAction"> 

    ... ... 

</action> 

但如果在<action>中引用了其他的拦截器，就必须再次引用params拦截器，Struts2才能调用相应的setter方法。如下面的配置代码所示： 

Xml代码  

1. <action name="first" class="action.FirstAction">  
2.     <interceptor-ref name="timer" />  
3.     <interceptor-ref name="params"/>  
4. </action>  

三、通过配置参数调用Action的setter方法(static-params) 

    static-params拦截器可以通过配置<params>标签来调用Action类的相应的setter方法，static-params拦截器对应的类是com.opensymphony.xwork2.interceptor.StaticParametersInterceptor。 
    下面配置代码演示了如何使用static-params拦截器： 

Xml代码  

1. <action name="first" class="action.FirstAction">  
2.     <interceptor-ref name="timer" />  
3.     <param name="who">比尔</param>  
4.     <interceptor-ref name="params"/>  
5.     <interceptor-ref name="static-params"/>  
6. </action>  

如果first动作使用上面的配置，在访问first动作时，Struts2会自动调用setWho方法将“比尔”作为参数值传入setWho方法。 

四、使用拦截器栈 

为了能在多个动作中方便地引用同一个或几个拦截器，可以使用拦截器栈将这些拦截器作为一个整体来引用。拦截器栈要在<package>标签中使用<interceptors>和子标签<interceptor-stack>来定义。代码如下： 

Xml代码  

1. <package name="demo" extends="struts-default" >  
2.     <interceptors>  
3.         <interceptor-stack name="mystack">  
4.             <interceptor-ref name="timer" />  
5.             <interceptor-ref name="logger" />  
6.             <interceptor-ref name="params" />  
7.             <interceptor-ref name="static-params" />  
8.         </interceptor-stack>  
9.     </interceptors>  
10.   
11.     <action name="first" class="action.FirstAction">  
12.         <param name="who">比尔</param>  
13.         <interceptor-ref name="mystack"/>              
14.     </action>  
15. </package>  

这样以来，我们就可以象使用拦截器一样使用拦截器栈。 





如何自定义一个拦截器？ 
自定义一个拦截器，我们需要三步就可以完成了： 
1 自定义一个实现Interceptor接口（或者继承自AbstractInterceptor）的类。 
2 在strutx.xml中注册上一步中定义的拦截器。 
3 在需要使用的Action中引用上述定义的拦截器，为了方便也可将拦截器定义为默认的拦截器，这样在不加特殊声明的情况下所有的Action都被这个拦截器拦截。 

Interceptor接口声明了三个方法： 

Java代码  

1. public interface Interceptor extends Serializable {  
2.    
3.     void destroy();  
4.    
5.     void init();  
6.    
7.     String intercept(ActionInvocation invocation) throws Exception;  
8. }  

Init方法在拦截器类被创建之后，在对Action镜像拦截之前调用，相当于一个post-constructor方法，使用这个方法可以给拦截器类做必要的初始话操作。 

Destroy方法在拦截器被垃圾回收之前调用，用来回收init方法初始化的资源。 

Intercept是拦截器的主要拦截方法，如果需要调用后续的Action或者拦截器，只需要在该方法中调用invocation.invoke()方法即可，在该方法调用的前后可以插入Action调用前后拦截器需要做的方法。如果不需要调用后续的方法，则返回一个String类型的对象即可，例如Action.SUCCESS。 
另外AbstractInterceptor提供了一个简单的Interceptor的实现，这个实现为： 

Java代码  

1. public abstract class AbstractInterceptor implements Interceptor {  
2.    
3.      public void init() {  
4.     }  
5.      
6.     public void destroy() {  
7.     }  
8.    
9.    
10.     public abstract String intercept(ActionInvocation invocation) throws Exception;  
11. }  

在不需要编写init和destroy方法的时候，只需要从AbstractInterceptor继承而来，实现intercept方法即可。 

我们尝试编写一个Session过滤用的拦截器，该拦截器查看用户Session中是否存在特定的属性（LOGIN属性）如果不存在，中止后续操作定位到LOGIN，否则执行原定操作，代码为： 

Java代码  

1. public class CheckLoginInterceptor extends AbstractInterceptor {  
2.     public static final String LOGIN_KEY = "LOGIN";  
3.     public static final String LOGIN_PAGE = "global.login";  
4.    
5.     public String intercept(ActionInvocation actionInvocation) throws Exception {  
6.    
7.         System.out.println("begin check login interceptor!");  
8.         // 对LoginAction不做该项拦截  
9.         Object action = actionInvocation.getAction();  
10.         if (action instanceof LoginAction) {  
11.             System.out.println("exit check login, because this is login action.");  
12.             return actionInvocation.invoke();  
13.         }  
14.    
15.         // 确认Session中是否存在LOGIN  
16.         Map session = actionInvocation.getInvocationContext().getSession();  
17.         String login = (String) session.get(LOGIN_KEY);  
18.         if (login != null && login.length() > 0) {  
19.             // 存在的情况下进行后续操作。  
20.             System.out.println("already login!");  
21.             return actionInvocation.invoke();  
22.         } else {  
23.             // 否则终止后续操作，返回LOGIN  
24.             System.out.println("no login, forward login page!");  
25.             return LOGIN_PAGE;  
26.         }  
27.     }  
28. }  

注册拦截器 

Xml代码  

1. <interceptors>  
2.             <interceptor  
3. name="login"   
4. class="com.jpleasure.teamware.util.CheckLoginInterceptor"/>  
5.             <interceptor-stack name="teamwareStack">  
6.                 <interceptor-ref name="login"/>  
7.                 <interceptor-ref name="defaultStack"/>  
8.             </interceptor-stack>  
9. </interceptors>  

将上述拦截器设定为默认拦截器： 

Java代码  

1. <default-interceptor-ref name="teamwareStack"/>  

这样在后续同一个package内部的所有Action执行之前都会被login拦截。 

注册并引用Interceptor 

Xml代码  

1. <package name="default" extends="struts-default">  
2.    <interceptors>  
3.        <interceptor name="timer" class=".."/>  
4.        <interceptor name="logger" class=".."/>  
5.    </interceptors>  
6.    
7.    <action name="login" class="tutorial.Login">  
8.         <interceptor-ref name="timer"/>  
9.         <interceptor-ref name="logger"/>  
10.         <result name="input">login.jsp</result>  
11.         <result name="success"  
12.             type="redirect-action">/secure/home</result>  
13.    </action>  
14. </package>  
15.    

可以将多个拦截器合并在一起作为一个堆栈调用，当一个拦截器堆栈被附加到一个Action的时候，要想Action执行，必须执行拦截器堆栈中的每一个拦截器。 

Xml代码  

1. <package name="default" extends="struts-default">  
2.    <interceptors>  
3.         <interceptor name="timer" class=".."/>  
4.         <interceptor name="logger" class=".."/>  
5.         <interceptor-stack name="myStack">  
6.            <interceptor-ref name="timer"/>  
7.            <interceptor-ref name="logger"/>  
8.         </interceptor-stack>  
9.     </interceptors>  
10.    
11.     <action name="login" class="tutuorial.Login">  
12.          <interceptor-ref name="myStack"/>  
13.          <result name="input">login.jsp</result>  
14.          <result name="success"  
15.              type="redirect-action">/secure/home</result>  
16.     </action>  
17. </package>  

每一个拦截器都可以配置参数，有两种方式配置参数，一是针对每一个拦截器定义参数，二是针对一个拦截器堆栈统一定义所有的参数，例如： 

Xml代码  

1. <interceptor-ref name="validation">  
2.   <param name="excludeMethods">myValidationExcudeMethod</param>  
3. </interceptor-ref>  
4. <interceptor-ref name="workflow">  
5.   <param name="excludeMethods">myWorkflowExcludeMethod</param>  
6. </interceptor-ref>  

或者 

Xml代码  

1. <interceptor-ref name="defaultStack">  
2.     <param name="validation.excludeMethods">myValidationExcludeMethod</param>  
3.     <param name="workflow.excludeMethods">myWorkflowExcludeMethod</param>  
4. </interceptor-ref>  

每一个拦截器都有两个默认的参数： 
excludeMethods - 过滤掉不使用拦截器的方法和 
includeMethods – 使用拦截器的方法。 

需要说明的几点： 
1 拦截器执行的顺序按照定义的顺序执行，例如： 

Xml代码  

1. <interceptor-stack name="xaStack">  
2.   <interceptor-ref name="thisWillRunFirstInterceptor"/>  
3.   <interceptor-ref name="thisWillRunNextInterceptor"/>  
4.   <interceptor-ref name="followedByThisInterceptor"/>  
5.   <interceptor-ref name="thisWillRunLastInterceptor"/>  
6. </interceptor-stack>  

的执行顺序为： 

Xml代码  

1. thisWillRunFirstInterceptor  
2.   thisWillRunNextInterceptor  
3.     followedByThisInterceptor  
4.       thisWillRunLastInterceptor  
5.         MyAction1  
6.         MyAction2 (chain)  
7.         MyPreResultListener  
8.         MyResult (result)  
9.       thisWillRunLastInterceptor  
10.     followedByThisInterceptor  
11.   thisWillRunNextInterceptor  
12. thisWillRunFirstInterceptor  

2 使用默认拦截器配置每个Action都需要的拦截器堆栈，例如： 

Xml代码  

1. <action name="login"  class="tutorial.Login">  
2.      <interceptor-ref name="timer"/>  
3.      <interceptor-ref name="logger"/>  
4.      <interceptor-ref name="default-stack"/>  
5.    
6.      <result name="input">login.jsp</result>  
7.      <result type="redirect-action">/secure/home</result>  
8. </action>  

可以按照如下的方式定义： 

Xml代码  

1. <interceptors>  
2.      <interceptor-stack name="myStack">  
3.         <interceptor-ref name="timer"/>  
4.         <interceptor-ref name="logger"/>  
5.         <interceptor-ref name="default-stack"/>  
6.      </interceptor-stack>  
7. </interceptors>  
8.    
9. <default-interceptor-ref name="myStack"/>  
10.    
11. <action name="login"  class="tutorial.Login">  
12.        <result name="input">login.jsp</result>  
13.        <result type="redirect-action">/secure/home</result>  
14. </action>  

3 如何访问HttpServletRequest，HttpServletResponse或者HttpSession 
有两种方法可以达到效果，使用ActionContext： 

Java代码  

1. Map attibutes = ActionContext.getContext().getSession();  

或者实现相应的接口： 

Java代码  

1. HttpSession            SessionAware  
2. HttpServletRequest     ServletRequestAware  
3. HttpServletResponse    ServletResponseAware  

Struts2（XWork）提供的拦截器的功能说明： 

• 拦截器                名字                       说明
• Alias Interceptor——alias——在不同请求之间将请求参数在不同名字件转换，请求内容不变
• Chaining Interceptor——chain——让前一个Action的属性可以被后一个Action访问，现在和chain类型的result（<result type=”chain”>）结合使用。
• Checkbox Interceptor——checkbox——添加了checkbox自动处理代码，将没有选中的checkbox的内容设定为false，而html默认情况下不提交没有选中的checkbox。
• Cookies Interceptor—— Cookies—— 使用配置的name,value来是指cookies
• Conversion Error Interceptor—— conversionError—— 将错误从ActionContext中添加到Action的属性字段中。
• Create Session Interceptor—— createSession—— 自动的创建HttpSession，用来为需要使用到HttpSession的拦截器服务。
• Debugging Interceptor—— Debugging—— 提供不同的调试用的页面来展现内部的数据状况。
• Execute and Wait Interceptor—— execAndWait—— 在后台执行Action，同时将用户带到一个中间的等待页面。
• Exception Interceptor—— exception—— 将异常定位到一个画面
• File Upload Interceptor—— fileUpload—— 提供文件上传功能
• I18n Interceptor—— i18n—— 记录用户选择的locale
• Logger Interceptor—— logger—— 输出Action的名字
• Message Store Interceptor—— store—— 存储或者访问实现ValidationAware接口的Action类出现的消息，错误，字段错误等。
• Model Driven Interceptor—— model-driven—— 如果一个类实现了ModelDriven，将getModel得到的结果放在Value Stack中。
• Scoped Model Driven—— scoped-model-driven—— 如果一个Action实现了ScopedModelDriven，则这个拦截器会从相应的Scope中取出model调用Action的setModel方法将其放入Action内部。
• Parameters Interceptor—— params—— 将请求中的参数设置到Action中去。
• Prepare Interceptor—— Prepare—— 如果Acton实现了Preparable，则该拦截器调用Action类的prepare方法。
• Scope Interceptor—— Scope—— 将Action状态存入session和application的简单方法。
• Servlet Config Interceptor—— servletConfig—— 提供访问HttpServletRequest和HttpServletResponse的方法，以Map的方式访问。
• Static Parameters Interceptor—— staticParams—— 从struts.xml文件中将<action>中的<param>中的内容设置到对应的Action中。
• Roles Interceptor—— roles—— 确定用户是否具有JAAS指定的Role，否则不予执行。
• Timer Interceptor—— timer—— 输出Action执行的时间
• Token Interceptor—— token—— 通过Token来避免双击
• Token Session Interceptor—— tokenSession—— 和Token Interceptor一样，不过双击的时候把请求的数据存储在Session中
• Validation Interceptor—— validation—— 使用action-validation.xml文件中定义的内容校验提交的数据。
• Workflow Interceptor—— workflow—— 调用Action的validate方法，一旦有错误返回，重新定位到INPUT画面
• Parameter Filter Interceptor—— N/A—— 从参数列表中删除不必要的参数
• Profiling Interceptor—— profiling—— 通过参数激活profile