Interceptor�l�构

让我们再来回��一下之前我们曾�l�用�q�的一张Action LifeCycle的图�Q?

图中�Q�我们可以发玎ͼ�Struts2的Interceptor一层一层，把Action包裹在最里面。这��L��l�构�Q�大概有以下一些特点：

1. 整个�l�构��如同一个堆栈，除了Action以外�Q�堆栈中的其他元素是Interceptor

2. Action位于堆栈的底部。由于堆�?先进后出"的特性，如果我们试图把Action拿出来执行，我们必须首先把位于Action上端的Interceptor拿出来执行。这��P��整个执行��Ş成了一个递归调用

3. 每个位于堆栈中的Interceptor�Q�除了需要完成它自��n的逻辑�Q�还需要完成一个特�D�的执行职责。这个执行职责有3�U�选择�Q?

1) 中止整个执行�Q�直接返回一个字�W�串作�ؓresultCode

2) 通过递归调用负责调用堆栈中下一个Interceptor的执�?/span>

3) 如果在堆栈内已经不存在�Q何的Interceptor�Q�调用Action

Struts2的拦截器�l�构的设计，实际上是一个典型的责�Q链模�?/strong>的应用。首先将整个执行划分成若�q�相同类型的元素�Q�每个元素具备不同的逻辑责�Q�Q��ƈ��他们纳入到一个链式的数据�l�构中（我们可以把堆栈结构也看作是一个递归的链式结构）�Q�而每个元素又有责任负责链式结构中下一个元素的执行调用�?

�q�样的设计，从代码重构的角度来看�Q�实际上是将一个复杂的�pȝ��Q�分而治之，从而��得每个部分的逻辑能够高度重用�q�具备高度可扩展性。所以，Interceptor�l�构实在是Struts2/Xwork设计中的�_�֍�之笔�?

Interceptor执行分析

Interceptor的定�?/span>

我们来看一下Interceptor的接口的定义�Q?

Java代码
public interface Interceptor extends Serializable {

    /**
     * Called to let an interceptor clean up any resources it has allocated.
     */
    void destroy();

    /**
     * Called after an interceptor is created, but before any requests are processed using
     * {@link #intercept(com.opensymphony.xwork2.ActionInvocation) intercept} , giving
     * the Interceptor a chance to initialize any needed resources.
     */
    void init();

    /**
     * Allows the Interceptor to do some processing on the request before and/or after the rest of the processing of the
     * request by the {@link ActionInvocation} or to short-circuit the processing and just return a String return code.
     *
     * @return the return code, either returned from {@link ActionInvocation#invoke()}, or from the interceptor itself.
     * @throws Exception any system-level error, as defined in {@link com.opensymphony.xwork2.Action#execute()}.
     */
    String intercept(ActionInvocation invocation) throws Exception;
}

Interceptor的接口定义没有什么特别的地方�Q�除了init和destory�Ҏ(gu��)��以外�Q�intercept�Ҏ(gu��)��是实现整个拦截器机制的核心方法。而它所依赖的参数ActionInvocation则是我们之前章节中曾�l�提到过的著名的Action调度�?/strong>�?

我们再来看看一个典型的Interceptor的抽象实现类�Q?

Java代码
public abstract class AroundInterceptor extends AbstractInterceptor {

    /* (non-Javadoc)
     * @see com.opensymphony.xwork2.interceptor.AbstractInterceptor#intercept(com.opensymphony.xwork2.ActionInvocation)
     */
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        String result = null;

        before(invocation);
        // 调用下一个拦截器�Q�如果拦截器不存在，则执行Action
        result = invocation.invoke();
        after(invocation, result);

        return result;
    }

    public abstract void before(ActionInvocation invocation) throws Exception;

    public abstract void after(ActionInvocation invocation, String resultCode) throws Exception;

}

在这个实现类中，实际上已�l�实��C��最��单的拦截器的雏�Ş。或许大家对�q�样的代码还比较陌生�Q�这没有关系。我在这里需要指出的是一个很重要的方�?invocation.invoke()。这是ActionInvocation中的�Ҏ(gu��)��Q�而ActionInvocation是Action调度者，所以这个方法具备以�?层含义：

1. 如果拦截器堆栈中�q�有其他的Interceptor�Q�那么invocation.invoke()��调用堆栈中下一个Interceptor的执行�?/strong>

2. 如果拦截器堆栈中只有Action了，那么invocation.invoke()��调用Action执行�?/strong>

所以，我们可以发现�Q�invocation.invoke()�q�个�Ҏ(gu��)��其实是整个拦截器框架的实现核心。基于这��L��实现机制�Q�我们还可以得到下面2个非帔R��要的推论�Q?

1. 如果在拦截器中，我们不��用invocation.invoke()来完成堆栈中下一个元素的调用�Q�而是直接�q�回一个字�W�串作�ؓ执行�l�果�Q�那么整个执行将被中止�?/strong>

2. 我们可以以invocation.invoke()为界�Q�将拦截器中的代码分�?个部分，在invocation.invoke()之前的代码，��会�?Action之前被依�ơ执行，而在invocation.invoke()之后的代码，��会在Action之后被逆序执行�?/strong>

由此�Q�我们就可以通过invocation.invoke()作�ؓAction代码真正的拦截点�Q�从而实现AOP�?

Interceptor拦截�c�d��

从上面的分析�Q�我们知道，整个拦截器的核心部分是invocation.invoke()�q�个函数的调用位�|�。事实上�Q�我们也正式�Ҏ(gu��)��q�句代码的调用位�|�，来进行拦截类型的区分的。在Struts2中，Interceptor的拦截类型，分成以下三类�Q?

1. before

before拦截�Q�是指在拦截器中定义的代码，它们存在于invocation.invoke()代码执行之前。这些代码，��依照拦截器定义的顺序，��序执行�?

2. after

after拦截�Q�是指在拦截器中定义的代码，它们存在于invocation.invoke()代码执行之后。这些代码，��一招拦截器定义的顺序，逆序执行�?

3. PreResultListener

有的时候，before拦截和after拦截�Ҏ(gu��)��们来说是不够的，因�ؓ我们需要在Action执行完之后，但是�q�没有回到视囑ֱ�之前�Q�做一些事情。Struts2同样支持�q�样的拦截，�q�种拦截方式�Q�是通过在拦截器中注册一个PreResultListener的接口来实现的�?

Java代码
public interface PreResultListener {

    /**
     * This callback method will be called after the Action execution and before the Result execution.
     *
     * @param invocation
     * @param resultCode
     */
    void beforeResult(ActionInvocation invocation, String resultCode);
}

在这里，我们看到�Q�Struts2能够支持如此多的拦截�c�d��Q�与其本�w�的数据�l�构和整体设计有很大的关�p�R��正如我在之前的文章中所提到的：

downpour 写道
因�ؓAction是一个普通的Java�c�，而不是一个Servlet�c�，完全��q��于Web容器�Q�所以我们就能够更加方便地对Control层进行合理的层次设计�Q�从而抽象出许多公共的逻辑�Q��ƈ��这些逻辑��q��出Action对象本��n�?/div>

我们可以看到�Q�Struts2对于整个执行的划分，从Interceptor到Action一直到Result�Q�每一层都职责明确。不仅如此，Struts2�q��ؓ每一个层�ơ之前都讄��了恰如其分的插入炏V��得整个Action层的扩展性得��C��史无前例的提升�?

Interceptor执行��序

Interceptor的执行顺序或许是我们在整个过�E�中最最兛_��的部分。根据上面所提到的概念，我们实际上已�l�能够大致明白了Interceptor的执行机理。我们来看看Struts2的Reference对Interceptor执行��序的一个�Ş象的例子�?

如果我们有一个interceptor-stack的定义如下：

Xml代码







那么�Q�整个执行的��序大概像这��P��

在这里，我稍微改了一下Struts2的Reference中的执行��序�C�Z��Q��得整个执行顺序更加能够被理解。我们可以看刎ͼ�递归调用保证了各�U�各��L��拦截�c�d��的执行能够井井有条�?

��h��意在�q�里�Q�每个拦截器中的代码的执行顺序，在Action之前�Q�拦截器的执行顺序与堆栈中定义的一��_��而在Action和Result之后�Q�拦截器的执行顺序与堆栈中定义的��序相反�?

源码解析
接下来我们就来看看源码，看看Struts2是如何保证拦截器、Action与Result三者之间的执行��序的�?

之前我曾�l�提刎ͼ�ActionInvocation是Struts2中的调度器，所以事实上�Q�这些代码的调度执行�Q�是�?ActionInvocation的实现类中完成的�Q�这里，我抽取了DefaultActionInvocation中的invoke()�Ҏ(gu��)��Q�它?y��u)��向�?们展�C�Z��切�?

Java代码
/**
* @throws ConfigurationException If no result can be found with the returned code
*/
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 = (InterceptorMapping) interceptors.next();
            UtilTimerStack.profile("interceptor: "+interceptor.getName(),
                    new UtilTimerStack.ProfilingBlock() {
                        public String doProfiling() throws Exception {
                         // ��ActionInvocation作�ؓ参数�Q�调用interceptor中的intercept�Ҏ(gu��)��执行
                            resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);
                            return null;
                        }
            });
        } 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) {
            // 执行PreResultListener
            if (preResultListeners != null) {
                for (Iterator iterator = preResultListeners.iterator();
                    iterator.hasNext();) {
                    PreResultListener listener = (PreResultListener) iterator.next();

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

            // now execute the result, if we're supposed to
            // action与interceptor执行完毕�Q�执行Result
            if (proxy.getExecuteResult()) {
                executeResult();
            }

            executed = true;
        }

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

从源码中�Q�我们可以看刎ͼ�我们之前提到的Struts2的Action层的4个不同的层次�Q�在�q�个�Ҏ(gu��)��中都有体玎ͼ�他们分别是：拦截�?�Q�Interceptor�Q�、Action、PreResultListener和Result。在�q�个�Ҏ(gu��)��中，保证了这些层�ơ的有序调用和执行。由此我们也可以看出Struts2在Action层次设计上的众多考虑�Q�每个层�ơ都具备了高度的扩展性和插入点，使得�E�序员可以在��M��喜欢的层�ơ加入自��q��实现机制改变Action的行为�?/span>

在这里，需要特别强调的�Q�是其中拦截器部分的执行调用�Q?

Java代码
resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);

表面上，它只是执行了拦截器中的intercept�Ҏ(gu��)��Q�如果我们结合拦截器来看�Q�就能看出点端倪来�Q?

Java代码
public String intercept(ActionInvocation invocation) throws Exception {
    String result = null;

        before(invocation);
        // 调用invocation的invoke()�Ҏ(gu��)��Q�在�q�里形成了递归调用
        result = invocation.invoke();
        after(invocation, result);

        return result;
}

原来在intercept()�Ҏ(gu��)��又对ActionInvocation的invoke()�Ҏ(gu��)��q�行递归调用�Q�ActionInvocation 循环嵌套在intercept()中，一直到语句result = invocation.invoke()执行�l�束。这��P��Interceptor又会按照刚开始执行的逆向��序依次执行�l�束�?/div>

hellxoul 2012-12-14 10:41 发表评论

国产亚洲精品观看91在线,亚洲精品夜夜夜妓女网,亚洲午夜精品一级在线播放放

�?�?[ - ]

Interceptor�l�构

Interceptor执行分析

源码解析