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

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

[img]http://zhaoshg.iteye.com/upload/picture/pic/34221/a38f9a47-ec81-3434-a9eb-a476a27cc555.jpg[/img]
拦截器的工作原理如上图，在工作的时候每一个Action请求都被包装在一堆拦截器的内部。拦截器可以在Action执行直线做相似的操作也可以在Action执行直后做回收操作。

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

下面我们来讲讲[size=x-large]如何使用struts2拦截器，或者是自定义拦截器[/size]。

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

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

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

<interceptor-stack name="defaultStack">
    <interceptor-ref name="exception"/>
    <interceptor-ref name="alias"/>
    <interceptor-ref name="servletConfig"/>
    <interceptor-ref name="prepare"/>
    <interceptor-ref name="i18n"/>
    <interceptor-ref name="chain"/>
    <interceptor-ref name="debugging"/>
    <interceptor-ref name="profiling"/>
    <interceptor-ref name="scopedModelDriven"/>
    <interceptor-ref name="modelDriven"/>
    <interceptor-ref name="fileUpload"/>
    <interceptor-ref name="checkbox"/>
    <interceptor-ref name="staticParams"/>
    <interceptor-ref name="params">
      <param name="excludeParams">dojo\..*</param>
    </interceptor-ref>
    <interceptor-ref name="conversionError"/>
    <interceptor-ref name="validation">
        <param name="excludeMethods">input,back,cancel,browse</param>
    </interceptor-ref>
    <interceptor-ref name="workflow">
        <param name="excludeMethods">input,back,cancel,browse</param>
    </interceptor-ref>
</interceptor-stack>

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

[size=large]一、记录拦截器和execute方法的执行时间(timer拦截器)[/size]

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

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

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

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

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

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

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

package action;

import com.opensymphony.xwork2.ActionSupport;

public class FirstAction extends ActionSupport          

{
       public String execute() throws Exception

       {
           Thread.sleep(2000); // 延迟2秒
           return null;
       }

}

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

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

[size=large]二、通过请求调用Action的setter方法(params)[/size]


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

<s:form action="first" namespace="/test">
   <s:textfield name="name"/>
   <s:submit/>
</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方法。如下面的配置代码所示：

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

[size=large]三、通过配置参数调用Action的setter方法(static-params)[/size]

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

<action name="first" class="action.FirstAction">
    <interceptor-ref name="timer" />
    <param name="who">比尔</param>
    <interceptor-ref name="params"/>
    <interceptor-ref name="static-params"/>
</action>

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

[size=large]四、使用拦截器栈[/size]

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

<package name="demo" extends="struts-default" >
    <interceptors>
        <interceptor-stack name="mystack">
            <interceptor-ref name="timer" />
            <interceptor-ref name="logger" />
            <interceptor-ref name="params" />
            <interceptor-ref name="static-params" />
        </interceptor-stack>
    </interceptors>

    <action name="first" class="action.FirstAction">
        <param name="who">比尔</param>
        <interceptor-ref name="mystack"/>            
    </action>
</package>

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



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

public interface Interceptor extends Serializable {

    void destroy();

    void init();

    String intercept(ActionInvocation invocation) throws Exception;
}

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

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

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

public abstract class AbstractInterceptor implements Interceptor {

     public void init() {
    }

    public void destroy() {
    }


    public abstract String intercept(ActionInvocation invocation) throws Exception;
}

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

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

public class CheckLoginInterceptor extends AbstractInterceptor {
    public static final String LOGIN_KEY = "LOGIN";
    public static final String LOGIN_PAGE = "global.login";

    public String intercept(ActionInvocation actionInvocation) throws Exception {

        System.out.println("begin check login interceptor!");
        // 对LoginAction不做该项拦截
        Object action = actionInvocation.getAction();
        if (action instanceof LoginAction) {
            System.out.println("exit check login, because this is login action.");
            return actionInvocation.invoke();
        }

        // 确认Session中是否存在LOGIN
        Map session = actionInvocation.getInvocationContext().getSession();
        String login = (String) session.get(LOGIN_KEY);
        if (login != null && login.length() > 0) {
            // 存在的情况下进行后续操作。
            System.out.println("already login!");
            return actionInvocation.invoke();
        } else {
            // 否则终止后续操作，返回LOGIN
            System.out.println("no login, forward login page!");
            return LOGIN_PAGE;
        }
    }
}

注册拦截器

<interceptors>
            <interceptor
name="login" 
class="com.jpleasure.teamware.util.CheckLoginInterceptor"/>
            <interceptor-stack name="teamwareStack">
                <interceptor-ref name="login"/>
                <interceptor-ref name="defaultStack"/>
            </interceptor-stack>
</interceptors>

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

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

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

注册并引用Interceptor

<package name="default" extends="struts-default">
   <interceptors>
       <interceptor name="timer" class=".."/>
       <interceptor name="logger" class=".."/>
   </interceptors>

   <action name="login" class="tutorial.Login">
        <interceptor-ref name="timer"/>
        <interceptor-ref name="logger"/>
        <result name="input">login.jsp</result>
        <result name="success"
            type="redirect-action">/secure/home</result>
   </action>
</package>

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

<package name="default" extends="struts-default">
   <interceptors>
        <interceptor name="timer" class=".."/>
        <interceptor name="logger" class=".."/>
        <interceptor-stack name="myStack">
           <interceptor-ref name="timer"/>
           <interceptor-ref name="logger"/>
        </interceptor-stack>
    </interceptors>

    <action name="login" class="tutuorial.Login">
         <interceptor-ref name="myStack"/>
         <result name="input">login.jsp</result>
         <result name="success"
             type="redirect-action">/secure/home</result>
    </action>
</package>

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

<interceptor-ref name="validation">
  <param name="excludeMethods">myValidationExcudeMethod</param>
</interceptor-ref>
<interceptor-ref name="workflow">
  <param name="excludeMethods">myWorkflowExcludeMethod</param>
</interceptor-ref>

或者

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

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

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

<interceptor-stack name="xaStack">
  <interceptor-ref name="thisWillRunFirstInterceptor"/>
  <interceptor-ref name="thisWillRunNextInterceptor"/>
  <interceptor-ref name="followedByThisInterceptor"/>
  <interceptor-ref name="thisWillRunLastInterceptor"/>
</interceptor-stack>

的执行顺序为：

thisWillRunFirstInterceptor
  thisWillRunNextInterceptor
    followedByThisInterceptor
      thisWillRunLastInterceptor
        MyAction1
        MyAction2 (chain)
        MyPreResultListener
        MyResult (result)
      thisWillRunLastInterceptor
    followedByThisInterceptor
  thisWillRunNextInterceptor
thisWillRunFirstInterceptor

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

<action name="login"  class="tutorial.Login">
     <interceptor-ref name="timer"/>
     <interceptor-ref name="logger"/>
     <interceptor-ref name="default-stack"/>

     <result name="input">login.jsp</result>
     <result type="redirect-action">/secure/home</result>
</action>

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

<interceptors>
     <interceptor-stack name="myStack">
        <interceptor-ref name="timer"/>
        <interceptor-ref name="logger"/>
        <interceptor-ref name="default-stack"/>
     </interceptor-stack>
</interceptors>

<default-interceptor-ref name="myStack"/>

<action name="login"  class="tutorial.Login">
       <result name="input">login.jsp</result>
       <result type="redirect-action">/secure/home</result>
</action>

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

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

或者实现相应的接口：

HttpSession            SessionAware
HttpServletRequest     ServletRequestAware
HttpServletResponse    ServletResponseAware

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

[list]
[*]拦截器 名字 说明

[*]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

[/list]