sturts2拦截器执行顺序理解以及拦截器机制实现原理

<?xml version="1.0" encoding="GBK"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.1.7//EN"
"http://struts.apache.org/dtds/struts-2.1.7.dtd">
<struts>
<!-- 通过常量配置Struts 2的国际化资源信息 -->
<constant name="struts.custom.i18n.resources" value="mess"/>
<!-- 通过常量配置Struts 2所使用的解码集-->
<constant name="struts.i18n.encoding" value="GBK"/>
<!-- 配置本系统所使用的包 -->
<package name="lee" extends="struts-default">
<!-- 应用所需使用的拦截器都在该元素下配置 -->
<interceptors>
<!-- 配置mysimple拦截器 -->
<interceptor name="mysimple"
class="org.crazyit.app.interceptor.SimpleInterceptor">
<!-- 为拦截器指定参数值 -->
<param name="name">简单拦截器</param>
</interceptor>
</interceptors>

<action name="loginPro" class="org.crazyit.app.action.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">
<param name="name">第一个</param>
</interceptor-ref>
<interceptor-ref name="mysimple">
<param name="name">第二个</param>
</interceptor-ref>
</action>
<action name="*">
<result>/WEB-INF/content/{1}.jsp</result>
</action>
</package>
</struts>

自定义实现的拦截器类：

package org.crazyit.app.interceptor;

import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
import java.util.*;

import org.crazyit.app.action.*;
/**
* Description:
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br/>Copyright (C), 2001-2012, Yeeku.H.Lee
* <br/>This program is protected by copyright laws.
* <br/>Program Name:
* <br/>Date:
* @author  Yeeku.H.Lee kongyeeku@163.com
* @version  1.0
*/
public class SimpleInterceptor
extends AbstractInterceptor
{
//简单拦截器的名字
private String name;
//为该简单拦截器设置名字的setter方法
public void setName(String name)
{
this.name = name;
}
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;
}
}

访问action结果--执行结果：



分析结果：（上面配置了2个拦截器）

      结果小猜想其中的内部机制：

              拦截前的操作：

              struts2中的filter的StrutsPrepareAndExecuteFilter控制器会拦截用户请求的action,该filter会先先查看配置文件，发现有2个拦截器，从第一个拦截器开始，通过反射生成一个SimpleInterceptor对象，然后调用其intercept()方法，执行该方法中的invocation.invoke()方法，然后该invoke方法会通过interceptors.hasNext去检查是否还有后面的拦截器，于是发现还有第二个拦截器，继续通过反射生成第二个SimpleInterceptor对象，然后再intercept()→invocation.invoke()方法→intercept()→invoke()→递归检查，直到所有拦截器都递归完毕。因此会看到控制台有从第一个拦截器→第二个拦截器。

           拦截后操作：

           因此intercept()→invocation.invoke()方法→intercept()→invoke()→方法是递归实现，也就是栈结构，先进后出，因此当invoke方法执行完后，会按照这个栈结构继续运行，从而出现了拦截后先看到第二个拦截器→第一个拦截器。

       进一步思考：

       struts2中的filter的StrutsPrepareAndExecuteFilter控制器会拦截用户请求的action，该fiter会通过查看看action的配置文件，然后生成该action对应的拦截器Map或者List来保存所配置的拦截器的相关信息。同时也会产生一个ActionInvocation对象来控制action。其中这种控制就包刮拦截，然后调用ActionInvocation对象中的invoke()方法。通过查看实现了ActionInvocation类的代码中的invoke()方法，可以知道该invoke()方法是个递归方法。因此上面两个拦截前后的操作，应该只是在invoke（）方法中完成，一直递归而已。其实这种递归是这样的invoke()→→intercept()→→invoke()→→如此循环。要知道ActionInvocation是控制action的，类似与jdk的动态代理（AOP思想），将拦截器的相关方法横切到相应的action，使各自的任务达到分离！

以上猜想再看下源代码果真是这样的：

DefaultActionInvocation：该类实现了ActionInvacation

public String invoke() throws Exception {
String profileKey = "invoke: ";
try {
UtilTimerStack.push(profileKey);

if (executed) {
throw new IllegalStateException("Action has already executed");
}

if (interceptors.hasNext()) {
final InterceptorMapping interceptor = interceptors.next();
String interceptorMsg = "interceptor: " + interceptor.getName();
UtilTimerStack.push(interceptorMsg);
try {
resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);
}
finally {
UtilTimerStack.pop(interceptorMsg);
}
} else {
resultCode = invokeActionOnly();
}

// this is needed because the result will be executed, then control will return to the Interceptor, which will
// return above and flow through again
if (!executed) {
if (preResultListeners != null) {
for (Object preResultListener : preResultListeners) {
PreResultListener listener = (PreResultListener) preResultListener;

String _profileKey = "preResultListener: ";
try {
UtilTimerStack.push(_profileKey);
listener.beforeResult(this, resultCode);
}
finally {
UtilTimerStack.pop(_profileKey);
}
}
}

// now execute the result, if we're supposed to
if (proxy.getExecuteResult()) {
executeResult();
}

executed = true;
}

return resultCode;
}
finally {
UtilTimerStack.pop(profileKey);
}
}