精品一区二区三区免费毛片,亚洲国产第一页,在线欧美一区

Mon, 02 Mar 2009 07:24:00 GMT

转自�Q�http://www.javaeye.com/wiki/struts2/1397-deep-into-struts2-interceptors#top

在之前的文章中，我们已经涉及��C��拦截器（Interceptor�Q�的概念�?

downpour 写道

拦截器是AOP中的概念�Q�它本��n是一�D�代码，可以通过定义“�l�入�?#8221;�Q�来指定拦截器的代码�?#8220;�l�入�?#8221;的前后执行，从而�v到拦截的作用。正如上�?Struts2的Reference中讲�q�的�Q�Struts2的Interceptor�Q�其拦截的对象是Action代码�Q�可以定义在Action代码之前或者之后执行拦截器的代码�?

接下来，我们��重点讨��Z��下Struts2中的拦截器的内部�l�构和执行顺序，�q�结合源码进行分析�?

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;
}

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�Ҏ��以外�Q�intercept�Ҏ��是实现整个拦截器机制的核心方法。而它所依赖的参数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;

}

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中的�Ҏ��Q�而ActionInvocation是Action调度者，所以这个方法具备以�?层含义：

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

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

所以，我们可以发现�Q�invocation.invoke()�q�个�Ҏ��其实是整个拦截器框架的实现核心。基于这��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�我们也正式�Ҏ��q�句代码的调用位�|�，来进行拦截类型的区分的。在Struts2中，Interceptor的拦截类型，分成以下三类�Q?

1. before

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

2. after

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

3. PreResultListener

有的时候，before拦截和after拦截�Ҏ��们来说是不够的，因�ؓ我们需要在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);
}

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代码

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

那么�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()�Ҏ��Q�它��向我们展示一切�?

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�Ҏ��执行
                            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);
    }
}

/** * @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�Ҏ��执行 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�个�Ҏ��中都有体玎ͼ�他们分别是：拦截器（Interceptor�Q�、Action、PreResultListener和Result。在�q�个�Ҏ��中，保证了这些层�ơ的有序调用和执行。由此我们也可以看出Struts2在Action层次设计上的众多考虑�Q�每个层�ơ都具备了高度的扩展性和插入点，使得�E�序员可以在��M��喜欢的层�ơ加入自��q��实现机制改变Action的行为�?/span>

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

Java代码

resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);

resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);

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

Java代码

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

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

        return result;
}

public String intercept(ActionInvocation invocation) throws Exception { String result = null; before(invocation); // 调用invocation的invoke()�Ҏ��Q�在�q�里形成了递归调用 result = invocation.invoke(); after(invocation, result); return result; }

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

一个有序链表，通过递归调用�Q�变成了一个堆栈执行过�E�，��一�D�|��序执行的代码变成�?�D�|��行顺序完全相反的代码�q�程�Q�从而��y妙地实现了AOP�?/span>�q�也��成��Z��Struts2的Action层的AOP基础�?

Web 2.0 技术资�?/a> 2009-03-02 15:24 发表评论

Mon, 02 Mar 2009 03:31:00 GMT

转自(http://samyulong.javaeye.com/blog/217092)

一�?span>什么是拦截器？

提到拦截器，使我不得�?惌��v武侠剧中劫匪们常说的一句话�Q?#8220;此山是我开�Q�此树是我栽�Q�要打此路过�Q�留下买路胦�Q?#8221;。难不成�E�序中也�?#8220;打劫”的，说的没错�Q�拦截器��是个打劫的�?在现实生�z�M��Q�劫匪劫的大都是��p��Q�当然也有别的什么，那么�E�序中的“劫匪”劫的又是什么呢�Q�或者说�E�序中�ؓ什么需要它�Q�在我们的日常编�E�中��不了写一�?重复的代码，例如在一个地方中写了一�D�代码，后来发现�q�段代码在其它地方中同样需要，在传�l�的�~�程中我们一定会采取复制、粘贴的办法。如果这�D�代码只在这一两个处需要，我们采取�q�种办法�Q�还说的�q�去�Q�但是如果系�l�对�q�段代码�q�于依赖�Q�也��是�q�段代码在系�l�中出现的过多，如果那一天我们发现这�D�代码中在某�?地方�q�需要完善，我们是不是要着个修改它们呢�Q�我估计没有��Z��q�么做，它严重违反了软�g开发中一条非帔R��要的DRY规则�Q�不写重复代码。说了这么多你一定知道我们�ؓ什么需要在�E�序中弄一�?#8220;劫匪”了吧。这�?#8220;劫匪”��是�q�不是劫取什么东西，只是��Z��在某个程序执行前后，动态的增加一些功能（以前所写通用代码块）或进行一些检查工作。那么这个拦截器到底是怎么实现的呢�Q�实际上它是�?/span>Java中的动态代理来实现的�?/span>

二�?span>拦截器在Struts2中的应用

对于Struts2框架而言�Q�正是大量的内置拦截器完成了大部分操作。像params拦截器将http��h��中参数解析出来赋值给Action中对应的属性�?/span>Servlet-config拦截器负责把��h��?/span>HttpServletRequest实例�?/span>HttpServletResponse实例传递给Action……struts2内置的拦截器�?/span>很多�Q�在此我��׃��一一列�D�?/span>

那么怎么�?/span>struts2中定义自��q��拦截器呢?

    很简�?/span>Struts2为我们提供了一�?/span>Interceptor接口,该接口源代码如下:

publicinterface Interceptor extends Serializable {

    void destroy();

    void init();

    String intercept(ActionInvocation invocation) throws Exception;

}

1)    init():在拦截器执行之前调用�Q�主要用于初始化�pȝ��资源�?/span>

2)    destroty():�?/span>init()对应�Q�用于拦截器执行之后销毁资源�?/span>

3)    intercept():拦截器的核心�Ҏ��Q�实现具体的拦截操作。与action一��P��该方法也�q�回一个字�W�串作�ؓ逻辑视图。如果拦截器成功调用�?/span>action�Q�则�q�回一个真正的�Q�也��是�?/span>action�?/span>execute()�Ҏ��q�回的逻辑视图�Q�反之，则返回一个自定义的逻辑视图�?/span>

通常我们使用拦截器�ƈ不需要申误��源，为此Struts2�q��ؓ我们提供了一�?/span>AbstractInterceptor�c�，该类�?/span>init()�?/span>destroy()都是�I�实现。我们开发自��q��拦截器只需要��承这个类��p��了�?/span>

    下面创徏一个判断用��h��否登录的拦截器。代码如�?/span>:


import java.util.Map;
import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;

@SuppressWarnings("serial")
public class CheckLoginInterceptor extends AbstractInterceptor {

    @SuppressWarnings("unchecked")
    public String intercept(ActionInvocation actionInvocation) throws Exception {
         System.out.println("begin check login interceptor!");

            // ��查Session中是否存在user

            Map session = actionInvocation.getInvocationContext().getSession();

            String username = (String) session.get("user");

            if (username != null && username.length() > 0) {

                // 存在的情况下�q�行后箋操作�?/span>

                System.out.println("already login!");

                return actionInvocation.invoke();

            } else {

                // 否则�l�止后箋操作�Q�返回LOGIN

                System.out.println("no login, forward login page!");

                return Action.LOGIN;

            }

        }

    }

    创徏好拦截器后，�q�不能��用，�q�需要我们在struts.xml中配�|�一下�?/span>

下面看一下怎么配置拦截器�?/span>

<interceptors>

           <interceptor name="checkLogin" class="com.myblog.interceptor.CheckLoginInterceptor" />

interceptors>

   �q�个定义好的拦截器在Action中怎么使用呢？使用�Ҏ��很简单，如下�Q?/span>

<action name=" " class=" " >



           <interceptor-ref name="checkLogin" />

action>

   一旦我们�ؓ某个action引用了自定义的拦截器�Q?/span>struts2默认的拦截器��׃��会再起作用，因此�q�需要引用默认拦截器�?/span>

<action name=" " class=" " >



           <interceptor-ref name="checkLogin" />



action>

   但是我们�q�么做似乎也不太方便�Q�因为如果拦截器checkLogin需要被多个action引用的话�Q�每一个都要配�|�一遍太�ȝ��了。我们可以把它定义成默认的拦截器�?/span>

<interceptors>

           <interceptor name="checkLogin" class="com.myblog.interceptor.CheckLoginInterceptor" />

           定义一个拦截器�?/span>-->

           <interceptor-stack name="mydefault">

              <interceptor-ref name="defaultStack" />

              <interceptor-ref name="checkLogin" />

           interceptor-stack>

interceptors>

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

   另外�Q?/span>struts2�q��ؓ我们提供了一个方法过滤的拦截�?/span>MethodFilterInterceptor�c�，该类�l�承AbstractInterceptor�c�，重写�?/span>intercept(ActionInvocation invocation)�q�提供了一个新的方�?/span>doInterceptor(ActionInvocation invocation)抽象�Ҏ��。该�cȝ��使用�Ҏ��很简单，��׃��举例了。这个拦截器与以往的拦截器配置有所不同。那��是可以指定哪些�Ҏ��需要被拦截�Q�那些不需要。通常在引用该拦截器时指定�?/span>

<interceptor-ref name=" ">

       <param name="exculdeMethods">param>

       <param name="includeMethods">param>

interceptor-ref>

   exculdeMethods�Q�是不被拦截的方法，如果有多个以逗号分隔�?/span>

   includeMethods�Q�需要被拦截的方法，如果有多个以逗号分隔�?/span>

    下面我来实验下。我们写个拦截器�?br />

<interceptors>
   <interceptor name="authorize" class="com.struts2.interceptor.AuthorizeInterceptor" />
   <interceptor-stack name="appStack">

      <interceptor-ref name="authorize"/>

      <interceptor-ref name="defaultStack"/>
   interceptor-stack>
interceptors>
<action name="forward" class="com.struts2.RequestForward">
   <interceptor-ref name="appStack"/>
   <result name="index">index.jspresult>
   <result name="NOT_FOUND">not_found.jspresult>
action>

    恩，�q�是有点很迷茫的位置�Q�比说的拦截器的调用��序是根据xml里面的顺序来的吗�Q�还有可以指定只在action之前或者只在action之后调用吗？说实话我也搞不清楚，在运用的�q�程中，大家慢慢在来体会

拦截器几乎完成了Struts2框架70%的工作，包括解析��h��参数、将��h��参数赋值给Action属性、执行数据校验、文件上�?#8230;…�Q�Struts2设计的灵巧性，更大�E�度地得益于拦截器设计，当需要扩展Struts2功能�Ӟ��只需要提供对应拦截器�Q��ƈ��它配置在Struts2容器中即可；如果不需要该功能�Ӟ��也只需要取消该拦截器的配置卛_��。这�U�可插拔式的设计�Q�正是��Y件设计领域一直孜孜以求的目标�?/p>
实际上，Struts2的精髓就在于拦截器，掌握了Struts2的拦截器机制�Q�你��可以说�_�N��了Struts2�?br /> 从某个角度来看，我们可以把Struts2框架理解成一个空壻I��而这些拦截器像一个一个抽屉，随时可以
插进入，也可以拔出来——这是��Y件��品一直追求的目标�?br /> 如果你喜�Ƣ，你可以把Struts2的全部插件拔出，那么Struts2��成了一个空容器—�?br /> 而这�U�空�Q�正�?Struts2的魅力，你可以把��M��自己惌��的东西填入进去，甚至包括自己完全实现�q�个框架�?/p>
另一斚w��Q�因为Struts2的插件机�?Struts2提供了无限扩展的可能性，你可以把自己惌��的�Q�?br /> 东西做成插�g�Q�然后填入Struts2——这��L��l�果是：一个企业，一个团队，可以把自�׃��务相关的东西
做成插�g�Q�随旉��地地复用�?br /> 也就是说�Q�如果你惌��Q�你可以把Struts2攚w��成属于自己的框架�?/p>
当然�Q�Struts2也内��Z��大量的拦截器�Q�这些拦截器以name-class对的形式配置在struts-default. xml文�g中，其中name是拦截器的名字，��是以后使用该拦截器的唯一标识�Q�class则指定了该拦截器的实现类�Q�如果我们定义的package�l�承了Struts2的默认struts-default包，则可以自�׃��用下面定义的拦截器，否则必须自己定义�q�些拦截器�?br /> 下面是Struts2内徏拦截器的��要介�l�：
alias�Q�实现在不同��h��中相似参数别名的转换�?br /> autowiring�Q�这是个自动装配的拦截器�Q�主要用于当Struts2和Spring整合�Ӟ��Struts2可以使用自动装配的方式来讉K��Spring容器中的Bean�?br /> chain�Q�构��Z��个Action链，使当前Action可以讉K��前一个Action的属性，一般和一起��用�?br /> conversionError�Q�这是一个负责处理类型�{换错误的拦截器，它负责将�c�d��转换错误从ActionContext中取出，�q��{换成Action的FieldError错误�?br /> createSession�Q�该拦截器负责创��Z��个HttpSession对象�Q�主要用于那些需要有HttpSession对象才能正常工作的拦截器中�?br /> debugging�Q�当使用Struts2的开发模式时�Q�这个拦截器会提供更多的调试信息�?br /> execAndWait�Q�后台执行Action�Q�负责将�{�待画面发送给用户�?br /> exception�Q�这个拦截器负责处理异常�Q�它��异常映��ؓ�l�果�?br /> fileUpload�Q�这个拦截器主要用于文�g上传�Q�它负责解析表单中文件域的内宏V�?
i18n�Q�这是支持国际化的拦截器�Q�它负责把所选的语言、区域放入用户Session中�?br /> logger�Q�这是一个负责日志记录的拦截器，主要是输出Action的名字�?br /> model-driven�Q�这是一个用于模型驱动的拦截器，当某个Action�c�d��C��ModelDriven接口�Ӟ��它负责把getModel()�Ҏ��的结果堆入ValueStack中�?
scoped-model-driven�Q�如果一个Action实现了一个ScopedModelDriven接口�Q�该拦截器负责从指定生存范围中找出指定的Modol�Q��ƈ��通过setModel�Ҏ��该Model传给Action实例�?br /> params�Q�这是最基本的一个拦截器�Q�它负责解析HTTP��h��中的参数�Q��ƈ��参数��D��|�成Action对应的属性倹{�?br /> prepare�Q�如果action实现了Preparable接口�Q�将会调用该拦截器的prepare()�Ҏ��?br /> static-params�Q�这个拦截器负责��xml�?lt;action>标签�?lt;param>标签中的参数传入action�?br /> scope�Q�这是范围�{换拦截器�Q�它可以��Action状态信息保存到HttpSession范围�Q�或者保存到ServletContext范围内�?br /> servlet-config�Q�如果某个Action需要直接访问Servlet API�Q�就是通过�q�个拦截器实现的�?br /> 注意�Q�尽量避免在Action中直接访问Servlet API�Q�这样会��D��Action与Servlet的高耦合�?br /> roles�Q�这是一个JAAS�Q�Java Authentication and Authorization Service�Q�Java授权和认证服务）拦截器，只有当浏览者取得合适的授权后，才可以调用被该拦截器拦截的Action�?br /> timer�Q�这个拦截器负责输出Action的执行时��_��q�个拦截器在分析该Action的性能瓉��时比较有用�?br /> token�Q�这个拦截器主要用于��L��重复提交�Q�它��查传到Action中的token�Q�从而防止多�ơ提交�?br /> token-session�Q�这个拦截器的作用与前一个基本类��|��只是它把token保存在HttpSession中�?br /> validation�Q�通过执行在xxxAction-validation.xml中定义的校验器，从而完成数据校验�?br /> workflow�Q�这个拦截器负责调用Action�c�M��的validate�Ҏ��Q�如果校验失败，则返回input的逻辑视图�?br /> 大部分时候，开发者无需手动控制�q�些拦截器，因�ؓstruts-default.xml文�g中已�l�配�|�了�q�些拦截器，只要我们定义的包�l�承了系�l�的struts-default包，��可以直接��用这些拦截器�?/p>
当然�Q�Struts2的拦截器机制�q�不是来自于Struts1�Q�而是来自于WebWork�?/p>

Web 2.0 技术资�?/a> 2009-03-02 11:31 发表评论