Struts 2 之拦截器

拦截器概述

Struts2拦截器是在访问某个Action或Action的某个方法，字段之前或之后实施拦截，并且Struts2拦截器是可插拔的，拦截器是AOP（Aspect Oriented Programming，面向切面编程）的一种实现

拦截器栈（InterceptorStack）。Struts2拦截器栈就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，Struts2拦截器链中的拦截器就会按其之前定义的顺序被调用。

Struts2规定用户自定义拦截器必须实现com.opensymphony.xwork2.interceptor.Interceptor接口，该接口声明了3个方法

void init();

void destroy();

Stringintercept(ActionInvocation invocation) throws Exception;

其中，init和destroy方法会在程序开始和结束时各执行一遍，不管使用了该拦截器与否，只要在struts.xml中声明了该Struts2拦截器就会被执行。

intercept方法就是拦截的主体了，每次拦截器生效时都会执行其中的逻辑

不过，struts中又提供了几个抽象类来简化这一步骤

public abstractclass AbstractInterceptor implementsInterceptor;

public abstractclass MethodFilterInterceptorextends AbstractInterceptor;

都是模板方法实现的。

其中AbstractInterceptor提供了init()和destroy()的空实现，使用时只需要覆盖intercept()方法；

而MethodFilterInterceptor则提供了includeMethods和excludeMethods两个属性，用来过滤执行该过滤器的action的方法。可以通过param来加入或者排除需要过滤的方法。

实例

直接实现Interceptor接口

public class MyInterceptor implements Interceptor {
      public void destroy() {
             // TODO Auto-generated method stub
      }
      public void init() {
             // TODO Auto-generated method stub
      }
      public String intercept(ActionInvocationinvocation) throws Exception {
             System.out.println("Action执行前插入 代码");
             //执行目标方法 (调用下一个拦截器, 或执行Action)
             final String res =invocation.invoke();
             System.out.println("Action执行后插入 代码");
             return res;
      }
}

配置

<package name="default" extends="struts-default">
      <interceptors>
             <interceptor name="MyInterceptor" class="interceptor.MyInterceptor"></interceptor>
             <interceptor-stack name="myInterceptorStack">
                    <interceptor-ref name="MyInterceptor"/>
                    <interceptor-ref name="defaultStack"/>
             </interceptor-stack>
</interceptors>

      <action name="loginAction" class="loginAction">
             <result name="fail">/index.jsp</result>
             <result name="success">/success.jsp</result>
             <interceptor-ref name="myInterceptorStack"></interceptor-ref>
      </action>
</package>

特别注意，在使用拦截器的时候，最后一定要引用struts2自带的拦截器缺省堆栈defaultStack，否则出错

继承AbstractInterceptor抽象类

我们尝试编写一个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(ActionInvocationactionInvocation) throws Exception {

        System.out.println("begin checklogin interceptor!");
        // 对LoginAction不做该项拦截
        Object action = actionInvocation.getAction();
        if (action instanceof LoginAction) {
            System.out.println("exit checklogin, 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("alreadylogin!");
            return actionInvocation.invoke();
        } else {
            // 否则终止后续操作，返回LOGIN
            System.out.println("no login,forward login page!");
            return LOGIN_PAGE;
        }
    }
}

注册拦截器

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

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

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

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

继承MethodFilterInterceptor抽象类

MethodFilterInterceptor类重写了AbstractInterceptor类的intercept(ActionInvocationinvocation)方法，但提供了一个doIntercept(ActionInvocation invocation)抽象方法。从这种设计方式可以看出，MethodFilterInterceptor类的intercept已经实现了对Action的拦截行为（只是实现了方法过滤的逻辑），但真正的拦截逻辑还需要开发者提供，也就是通过回调doIntercept方法实现。可见，如果用户需要实现自己的拦截逻辑，则应该重写doIntercept(ActionInvocation
invocation)方法。

下面是一个简单的方法过滤的示例应用，方法过滤的拦截器代码如下。

//拦截方法的拦截器，应该继承MethodFilterInterceptor抽象类

public class MyFilterInterceptor extends MethodFilterInterceptor{

	//简单拦截器的名字
	private String name;
	//为该简单拦截器设置名字的setter方法
	public void setName(String name){
  		this.name = name;
	}

	//重写doIntercept方法，实现对Action的拦截逻辑
	public String doIntercept(ActionInvocation invocation)  throws Exception{

  //取得被拦截的Action实例
  LoginAction action = (LoginAction)invocation.getAction();

  //打印执行开始的时间
  System.out.println(name + " 拦截器的动作---------"
    + "开始执行登录Action的时间为：" + new Date());

  //取得开始执行Action的时间
  long start = System.currentTimeMillis();

  //执行该拦截器的后一个拦截器，或者直接指定Action的execute方法
  String result = invocation.invoke();

  //打印执行结束的时间
  System.out.println(name + " 拦截器的动作---------"
    + "执行完登录Action的时间为：" + new Date());
  long end = System.currentTimeMillis();

  //打印执行该Action所花费的时间
  System.out.println(name + " 拦截器的动作---------"
    + "执行完该Action的事件为" + (end - start) + "毫秒");

  return result;
	}
}

从上面的代码中可以看出，上面拦截器的拦截逻辑与前面简单拦截器的拦截逻辑相似，只是之前是需要重写intercept方法，现在是重写doIntercept方法。

实际上，实现方法过滤的拦截器与实现普通拦截器并没有太大的区别，只需要注意两个地方：实现方法过滤的拦截器需要继承MethodFilterInterceptor抽象类，并且重写doIntercept方法定义对Action的拦截逻辑。

在MethodFilterInterceptor方法中，额外增加了如下两个方法：

public void setExcludeMethods(String excludeMethods)：排除需要过滤的方法——设置方法“黑名单”，所有在excludeMethods字符串中列出的方法都不会被拦截。

public void setIncludeMethods(String includeMethods)：设置需要过滤的方法——设置方法“白名单”，所有在includeMethods字符串中列出的方法都会被拦截。

注意：如果一个方法同时在excludeMethods和includeMethods中列出，则该方法会被拦截。

因为MethodFilterInterceptor类包含了如上的两个方法，则该拦截器的子类也会获得这两个方法。可以在配置文件中指定需要被拦截，或者不需要被拦截的方法。

方法过滤示例应用的配置片段如下：

<!-- 配置本系统所使用的包 -->
<package name="clf" extends="struts-default">

<!-- 应用所需使用的拦截器都在该元素下配置 -->
<interceptors>
  <!-- 配置mysimple拦截器 -->
  <interceptor name="mysimple"   class="com.clf.MyFilterInterceptor">
    <!-- 为拦截器指定参数值 -->
    <param name="name">拦截方法的拦截器</param>
  </interceptor>
</interceptors>

<action name="loginPro" class="com.clf.LoginAction">
  <result name="error">/WEB-INF/content/error.jsp</result>
  <result name="success">/WEB-INF/content/welcome.jsp</result>

  <!-- 配置系统的默认拦截器 -->
  <interceptor-ref name="defaultStack"/>
  <!-- 应用自定义的mysimple拦截器 -->
  <interceptor-ref name="mysimple">
    <!-- 重新指定name属性的属性值 -->
    <param name="name">改名后的拦截方法过滤拦截器</param>
    <!-- 指定execute方法不需要被拦截 -->
    <param name="excludeMethods">execute</param>
  </interceptor-ref>
</action>
<action name="*">
  <result>/WEB-INF/content/{1}.jsp</result>
</action>
</package>

上面配置文件的代码通过excludeMethods属性指定了execute方法无须被拦截，如果浏览者在浏览器中再次向login的Action发送请求，在Tomcat控制台将看不到任何输出，表明该拦截器没有拦截Action的execute方法。

如果需要同时指定多个方法不被该拦截器拦截，则多个方法之间以英文逗号（,）隔开。看如下的配置片段：

Struts 2中提供了这种方法过滤的拦截器有如下几个：

TokenInterceptor

TokenSessionStoreInterceptor

DefaultWorkflowInterceptor

ValidationInterceptor

Struts2自带拦截器

Alias Interceptor                          alias

在不同请求之间将请求参数在不同名字件转换，请求内容不变

Chaining Interceptor                      chain

让前一个Action的属性可以被后一个Action访问，现在和chain类型的result（<resulttype=＂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 WaitInterceptor        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得到的结果放在ValueStack中。

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

注册并引用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>

上述说明的拦截器在默认的Struts2应用中，根据惯例配置了若干个拦截器堆栈，详细情参看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>
 

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

<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 – 使用拦截器的方法。

拦截器执行的顺序按照定义的顺序执行