Struts 2读书笔记-----拦截器之拦截器的使用

一旦定义了拦截器和拦截器栈后，就可以使用这个拦截器或拦截器栈来拦截器Action了。拦截器的拦截行为将会在Action的execute方法执行之前执行。

一、实现拦截器类

虽然Struts 2框架提供了许多拦截器，这些拦截器也实现了Struts 2的大部分功能。但是用户仍然可以开发自己的拦截器。

实现自己的拦截器，应该实现com.opensymphoney.xwork2.interceptor.Interceptor接口

该接口包含三个方法：init() 、destroy()、interceptor(ActionInvocation invocation)；

init()：在该拦截器被实例化之后，在该拦截器执行拦截之前，系统将会回调该方法。该方法主要用于初始化资源。对于每一个拦截器而言，其init()方法只会执行一次。

destroy()：该方法在拦截器实例被销毁之前被系统回调。该方法用于销毁init()方法里打开的资源

interceptor(ActionInvocation invocation)：该方法是用户需要实现的拦截动作。该方法会返回一个字符串，系统将会跳转到该逻辑视图对应的实际视图资源，不会调用被拦截的Action。

Struts 2还提供了一个AbstractInterceptor类，该类提供了一个init和destroy方法的空实现，如果我们实现的拦截器不需要打开资源，则可以无须实现这两个方法。由此可见，继承AbstractInterceptor类来实现自定义拦截器会更加简单。

下面实现一个简单的拦截器：

public class SimpleInterceptor extends AbstractInterceptor {
// 简单拦截器的名字
private String name;

public void setName(String name) {
this.name = name;
}

@Override
public String intercept(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();
System.out.println(name+"拦截器的动作----------执行完该Action的事件为:"+(end-start)+"毫秒");

return result;
}
}

当我们实现interceptor方法时，可以获得ActionInvocation参数，这个参数可以获得被拦截的Action实例，一旦取得了Action实例，几乎获得了全部的控制权。

二、使用拦截器

实现了拦截器类后，就是配置拦截器，使用拦截器。使用拦截器需要以下两个步骤：

1、通过<interceptor.../>元素来定义拦截器。

2、通过<interceptor-ref.../>元素来使用拦截器。

拦截器的配置如下:

<package name="mystruts" extends="struts-default">
<!-- 应用所需使用的拦截器都在改元素下配置 -->
<interceptors>
<!-- 配置没有simple拦截器 -->
<interceptor name="mysimple" class="com.app.interceptor.SimpleInterceptor">
<!-- 为该拦截器指定参数值 -->
<param name="name">简单拦截器</param>
</interceptor>
</interceptors>

<action name="login" class="com.app.action.LoginAction">
<result name="error">/error.jsp</result>
<result name="success">/welcome.jsp</result>
<!-- 配置系统的默认拦截器 -->
<interceptor-ref name="defaultStack"></interceptor-ref>
<!-- 应用自定义的mysimple拦截器 -->
<interceptor-ref name="mysimple">
<param name="name">改名后的拦截器</param>
</interceptor-ref>
</action>
</package>

这个拦截器只是一个简单地在控制台打印一些文本，获取被拦截方法的执行时间信息。

当浏览者在浏览器中对该Action发送请求时，该拦截器将会拦截该Action的execute方法，将会在控制台看到如下结果：



三、拦截方法的拦截器

在默认情况下，如果我们为某个Action定义了拦截器，则这个拦截器会拦截该Action内所有方法，但是有时我们不需要拦截所有方法，只需要拦截指定的方法。此时需要使用Struts 2拦截器的方法过滤特性。

为了实现方法的过滤的特性，Struts 2提供了一个MethodFilterInterceptor类，该类是AbstractInterceptor类的子类如果用户需要自己实现的拦截器支持方法过滤特性，则应该继承MethodFilterInterceptor。并且需要重写doIntercept(ActionInvocation invocation)方法。

实际上实现方法过滤的拦截器与实现普通拦截器并没没什么区别。所以这里就不展示代码了。

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

1、public void setExcludeMethods(String excludeMethods)：排除需要过滤的方法，所有在 excludeMethods字符串中列出的方法都不会被拦截

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

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

通过上面两个方法，我们可以在配置文件中指定需要被拦截，或者不被拦截的方法。

如下：

<interceptor-ref name="myfilter">
<!-- 指定execute方法不需要被拦截 -->
<param name="excludeMethods">execute</param>
<!-- 指定login方法需要被拦截 -->
<param name="includeMethods">login</param>
</interceptor-ref>

如果需要同时指定多个方法不需要被拦截器拦截，则多个方法之间以英文逗号隔开

如下:

<interceptor-ref name="myfilter">
<!-- 指定execute方法和login方法不需要被拦截 -->
<param name="excludeMethods">execute,login</param>
</interceptor-ref>

如果excludeMethods参数和includeMethods参数同时知道指定了一个方法名，则该方法会被拦截器拦截。

如下:

<interceptor-ref name="myfilter">
<!-- 指定execute方法和login方法不需要被拦击 -->
<param name="excludeMethods">execute,login</param>
<!-- 指定login方法需要被拦截 -->
<param name="includeMethods">login</param>
</interceptor-ref>

上面的配置中通过excludeMethods参数指定execute和login方法不需要被拦截，includeMethods参数指定login方法需要被拦截，则拦截器会拦截login方法。

四、拦截器的执行顺序

随着系统中配置拦截器的顺序不同，系统执行拦截器的顺序也会不同。通常认为：先配置的拦截器，会先获得执行机会，但是有时候也会存在一些特殊的情况。

有如下的配置文件：

<package name="mystruts" extends="struts-default">
<!-- 应用所需使用的拦截器都在改元素下配置 -->
<interceptors>
<!-- 配置没有simple拦截器 -->
<interceptor name="mysimple" class="com.app.interceptor.SimpleInterceptor">
<!-- 为该拦截器指定参数值 -->
<param name="name">简单拦截器</param>
</interceptor>
</interceptors>

<action name="login" class="com.app.action.LoginAction">
<result name="error">/error.jsp</result>
<result name="success">/welcome.jsp</result>
<!-- 配置系统的默认拦截器 -->
<interceptor-ref name="defaultStack"></interceptor-ref>
<!-- 应用自定义的mysimple拦截器 -->
<interceptor-ref name="mysimple">
<param name="name">第一个</param>
</interceptor-ref>
<interceptor-ref name="mysimple">
<param name="name">第二个</param>
</interceptor-ref>
</action>
</package>

通过上面的配置文件中我们可以看到，对于上面的名为login的Action，有两次使用了mysimple拦截器拦截该Action。两个拦截器名分别为：第一个、第二个。

当用户再浏览器中向该Action发送请求时，就会看到如下效果：



从上面的效果中可以看到，对于在execute方法之前的动作，第一个拦截器会先起作用，也就是说配置在前面的拦截器会先起作用；对于在execute方法之后的动作，则第二个拦截器先起作用，也就是说，配置在后的拦截器会先起作用。

所有可以得到如下结论：在Action的控制方法执行之前，位于拦截器链前面的拦截器会先起作用。在Action控制方法执行之后，位于拦截器链后面的拦截器会先起作用。

读李刚《轻量级Java EE企业应用实战》