《研磨struts2》 第六章 拦截器 之 6.2 预定义的拦截器

6.2  预定义的拦截器

6.2.1  预定义的拦截器

一起来看看Struts2中已经定义好的预定义拦截器。Struts2的预定义拦截器都定义在struts-default.xml文件的struts-default包内，定义如下：

 

java代码：

<interceptors>
            <interceptor name="alias" class="com.opensymphony.xwork2.interceptor.AliasInterceptor"/>
            <interceptor name="autowiring" class="com.opensymphony.xwork2.spring.interceptor.ActionAutowiringInterceptor"/>
            <interceptor name="chain" class="com.opensymphony.xwork2.interceptor.ChainingInterceptor"/>
            <interceptor name="conversionError" class="org.apache.struts2.interceptor.StrutsConversionErrorInterceptor"/>
            <interceptor name="cookie" class="org.apache.struts2.interceptor.CookieInterceptor"/>
            <interceptor name="clearSession" class="org.apache.struts2.interceptor.ClearSessionInterceptor" />
            <interceptor name="createSession" class="org.apache.struts2.interceptor.CreateSessionInterceptor" />
            <interceptor name="debugging" class="org.apache.struts2.interceptor.debugging.DebuggingInterceptor" />
            <interceptor name="externalRef" class="com.opensymphony.xwork2.interceptor.ExternalReferencesInterceptor"/>
            <interceptor name="execAndWait" class="org.apache.struts2.interceptor.ExecuteAndWaitInterceptor"/>
            <interceptor name="exception" class="com.opensymphony.xwork2.interceptor.ExceptionMappingInterceptor"/>
            <interceptor name="fileUpload" class="org.apache.struts2.interceptor.FileUploadInterceptor"/>
            <interceptor name="i18n" class="com.opensymphony.xwork2.interceptor.I18nInterceptor"/>
            <interceptor name="logger" class="com.opensymphony.xwork2.interceptor.LoggingInterceptor"/>
            <interceptor name="modelDriven" class="com.opensymphony.xwork2.interceptor.ModelDrivenInterceptor"/>
            <interceptor name="scopedModelDriven" class="com.opensymphony.xwork2.interceptor.ScopedModelDrivenInterceptor"/>
            <interceptor name="params" class="com.opensymphony.xwork2.interceptor.ParametersInterceptor"/>
            <interceptor name="actionMappingParams" class="org.apache.struts2.interceptor.ActionMappingParametersInteceptor"/>
            <interceptor name="prepare" class="com.opensymphony.xwork2.interceptor.PrepareInterceptor"/>
            <interceptor name="staticParams" class="com.opensymphony.xwork2.interceptor.StaticParametersInterceptor"/>
            <interceptor name="scope" class="org.apache.struts2.interceptor.ScopeInterceptor"/>
            <interceptor name="servletConfig" class="org.apache.struts2.interceptor.ServletConfigInterceptor"/>
            <interceptor name="sessionAutowiring" class="org.apache.struts2.spring.interceptor.SessionContextAutowiringInterceptor"/>
            <interceptor name="timer" class="com.opensymphony.xwork2.interceptor.TimerInterceptor"/>
            <interceptor name="token" class="org.apache.struts2.interceptor.TokenInterceptor"/>
            <interceptor name="tokenSession" class="org.apache.struts2.interceptor.TokenSessionStoreInterceptor"/>
            <interceptor name="validation" class="org.apache.struts2.interceptor.validation.AnnotationValidationInterceptor"/>
            <interceptor name="workflow" class="com.opensymphony.xwork2.interceptor.DefaultWorkflowInterceptor"/>
            <interceptor name="store" class="org.apache.struts2.interceptor.MessageStoreInterceptor" />
            <interceptor name="checkbox" class="org.apache.struts2.interceptor.CheckboxInterceptor" />
            <interceptor name="profiling" class="org.apache.struts2.interceptor.ProfilingActivationInterceptor" />
            <interceptor name="roles" class="org.apache.struts2.interceptor.RolesInterceptor" />
            <interceptor name="jsonValidation" class="org.apache.struts2.interceptor.validation.JSONValidationInterceptor" />
            <interceptor name="annotationWorkflow" class="com.opensymphony.xwork2.interceptor.annotations.AnnotationWorkflowInterceptor" />
            <interceptor name="multiselect" class="org.apache.struts2.interceptor.MultiselectInterceptor" />
</interceptors>

由于很多拦截器都是与具体的功能相关联的的，因此这里不去介绍所有的预定义拦截器，只介绍几个常用的，其他的在以后的章节里碰到了再说。

1：params拦截器

这个拦截器是必不可少的，因为就是由它偷偷的把请求参数设置到相应的Action的属性去的，并自动进行类型转换。

2：staticParams拦截器

将struts.xml配置文件里定义的Action参数，设置到对应的Action实例中，Action参数使用<param>标签，是<action>标签的子元素。

struts.xml的示例如下：

 

java代码：

<action name="helloworldAction" class="cn.javass.action.action.HelloWorldAction">
            <param name="account">test</param>
</action>

这要求Action中一定要有一个account的属性，并有相应的getter/setter方法。运行的时候，Action的account属性在初始化过后，会接到这里的赋值“test”。

       注意：params拦截器和staticParams拦截器都会为Action的属性赋值，如果碰到了都要赋同一个值呢，比如request里面有account参数，而struts.xml中也有account参数，最终的值是谁？

       其实是Action初始化过后，就会把struts.xml中配置的数据设置到Action实例中相应的属性上去。然后，把用户请求的数据设置到Action实例中相应的属性上去。

       很明显最后的值是用户请求中account的数据。

3：prepare拦截器

在Action执行之前调用Action的prepare()方法，这个方法是用来准备Action执行之前要做的工作。它要求我们的Action必需实现com.opensymphony.xwork2.Preparable接口

4：modelDriven拦截器

如果Action实现ModelDriven接口，它将getModel()取得的模型对象存入OgnlValueStack中。

5：chain拦截器

将前一个执行结束的Action属性设置到当前的Action中。它被用在ResultType为“chain”所指定的结果的Action中，该结果Action对象会从值栈中获得前一个Action对应的属性，它实现Action链之间的数据传递。

6：execption拦截器

顾名思义，在抛出异常的时候，这个拦截器起作用。它是我们第五章讲的Struts2的错误处理机制（<exception-mapping>）的基础，任何应用都应该引用这个拦截器，而且引用的时候，最好把它放在第一位，让它能捕获所有的异常。

7：validation拦截器

调用验证框架读取 *-validation.xml文件，并且应用在这些文件中声明的校验。

8：token拦截器

核对当前Action请求（request）的有效标识，防止重复提交Action请求 。使用标签<s:token>可以生成表单令牌，该标签会在session中设置一个预期的值并且在表单中创建一个隐藏的input字段。Token拦截器会检查这个令牌，如果不合法，将不会执行action，注意这个拦截器需要手工添加，还需要配置一个invalid.token的result。

9：tokenSession拦截器

扩展了token拦截器的功能，当提交无效的Action请求标识时，它会跳转回到第一次成功后的页面。

10：conversionError拦截器

用来处理框架进行类型转化（Type Conversion）时的出错信息。它将存储在ActionContext中的类型转化（Type Conversion）错误信息转化成相应的Action字段的错误信息，保存在堆栈中。根据需要，可以将这些错误信息在视图中显示出来

11：fileUpload拦截器

用来处理文件上传

12：workflow拦截器

Action默认的工作流，如果action实现了Validateable接口，那么interceptor会调用action的validate()方法；如果action实现了ValidationAware接口，那么interceptor将会检查action是否包含错误信息。如果包含任何错误信息，那么interceptor将会返回input，而不让action执行。

13：servletConfig拦截器

这个拦截器提供Action直接对Servlet API的访问，把Servlet API的对象注入到Action中。包括：ServletRequestAware、ServletResponseAware、ParameterAware、SessionAware、ApplicationAware。

14：timer拦截器

记录ActionInvocation余下部分执行的时间，并做为日志信息记录下来，便于寻找性能瓶颈。

15：logger拦截器

在日志信息中输出要执行的Action信息 ，这样，在调试的时候，就能很快的定位到这个对应的Action了。

先看这么多，其他的预定义拦截器，随着后面的学习再慢慢的展开。

6.2.2  预定义的拦截器栈

在了解了Struts2中预定义的拦截器之后，来看看拦截器栈。

       先回顾一下在前面的所有示例，在struts.xml中进行配置的时候，是否有看到任何关于拦截器（interceptor）的身影呢？

       答案很明显，是没有看到。也就是说，前面做了这么多示例，既没有声明拦截器，也没有引用拦截器，但是前面又说我们已经使用拦截器了，这到底是怎么回事呢？

       其实是因为Struts2有默认的拦截器配置，也就是说，虽然我们没有主动去配置任何关于拦截器的东西，但是Struts2会使用默认引用的拦截器。

由于Struts2的默认拦截器声明和引用都在这个Struts-default.xml里面，因此我们需要到这个文件的struts-default包里去看一下。找到struts-default.xml这个文件中的struts-default包，只留下其中关于拦截器的部分，定义如下：

 

java代码：

<package name="struts-default" abstract="true">
       <interceptors>
            ……就是前面看到的预定义的拦截器部分，这里就省略了
            ……接下来有很多拦截器栈的定义，这里就省略了，看看下面缺省的拦截器栈的定义
            <!--接下来是defaultStack拦截器栈的定义-->
            <interceptor-stack name="defaultStack">
                <interceptor-ref name="exception"/>
                <interceptor-ref name="alias"/>
                <interceptor-ref name="servletConfig"/>
                <interceptor-ref name="i18n"/>
                <interceptor-ref name="prepare"/>
                <interceptor-ref name="chain"/>
                <interceptor-ref name="debugging"/>
                <interceptor-ref name="scopedModelDriven"/>
                <interceptor-ref name="modelDriven"/>
                <interceptor-ref name="fileUpload"/>
                <interceptor-ref name="checkbox"/>
                <interceptor-ref name="multiselect"/>
                <interceptor-ref name="staticParams"/>
                <interceptor-ref name="actionMappingParams"/>
                <interceptor-ref name="params">
                  <param name="excludeParams">dojo\..*,^struts\..*</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>
       </interceptors>

        <default-interceptor-ref name="defaultStack"/>
    </package>

由于篇幅问题，并没有罗列出所有的拦截器栈。但是上面的部分就已经把要观察的问题都列举出来了。

       仔细观察，上面的配置可以分为三个部分。

• <interceptor>
• <interceptor-stack>
• <default-interceptor-ref>

         那么，到底谁是声明，谁是引用呢？

1：首先，<interceptor>元素用来定义一个拦截器，这里仅仅是一个定义，还没有任何一个Action来引用它。里面的name属性作为唯一标志，而class属性就是这个拦截器的实现类。拦截器的实现类都应该是com.opensymphony.xwork2.interceptor.Interceptor这个接口的实现类。

    2：其次，<interceptor-stack>定义了一个拦截器栈，这个栈中可以引用其他已经定义好的拦截器。拦截器栈简化了动作类Action在引用拦截器时的操作。

因为大多数动作类Action在引用拦截器的时候都不会仅仅引用一个拦截器，而是引用一组拦截器，而多个动作类Action大概又会引用同一组拦截器，这时候，为了引用的方便，可以把多个拦截器组合成一个拦截器栈。Action在引用的时候，只需要引用这个拦截器栈就可以了，而不是引用每一个拦截器。如下图所示：

图6.2 拦截器栈原理图

上图的左半部分，描述了没有拦截器栈的情况，每个Action都需要配置自己要的拦截器，这里面有很多是重复的劳动，比如Action1需要拦截器1和2，Action2也需要拦截器1和2，在没有拦截器栈的情况下，他们必须分别配置，重复劳动。

       上图的右半部分，描述了有拦截器栈的情况，可以把Action1和Action2公共需要的拦截器组合成一个拦截器栈，在Action配置的时候，只需要引用这个拦截器栈就可以了，而不需要一个一个罗列里面的拦截器。

注意：<interceptor-ref>里面的name 属性，不仅仅可以写一个已经定义好的拦截器，还可以写一个已经定义好的拦截器栈。

6.2.3  预定义拦截器的配置使用

在了解到Struts2里面有那么多的预定义拦截器之后，究竟如何来使用这些拦截器呢？有两种方式：

1：在struts.xml的Action配置里面，引用需要使用的拦截器。

先看一下struts-2.1.dtd对于<action>元素的定义：

 

java代码：

<!ELEMENT action (param|result|interceptor-ref|exception-mapping)*>

action元素后面出现的interceptor-ref子元素后面用*来修饰，这说明一个action元素可以有不限个数的interceptor-ref子元素。

那么在<action>元素中，如何使用<interceptor-ref>子元素呢？其实很简单，只需要在<action>元素中，配置需要的<interceptor-ref>子元素就可以了，<interceptor-ref>子元素里面配置需要使用的拦截器的名称，比如：

 

java代码：

<action name="helloworldAction" class="cn.javass.action.action.HelloWorldAction">
            <param name="account">test</param>
         <result>/s2impl/welcome.jsp</result>
         <interceptor-ref name="staticParams"/>
         <interceptor-ref name="basicStack"/>
</action>

<interceptor-ref>子元素中的name，不仅仅可以是一个已经定义好的拦截器的名称，还可以是一个已经定义好的拦截器栈的名称。上面的示例，就引用了一个拦截器和一个拦截器栈。

2：在包上声明包内所有的Action都使用的拦截器

先看一下struts-2.1.dtd对于<package>元素的定义：

 

java代码：

<!ELEMENT package (result-types?, interceptors?, default-interceptor-ref?, default-action-ref?, default-class-ref?, global-results?, global-exception-mappings?, action*)>

package元素后面出现的default-interceptor-ref子元素后面用“?”来修饰，这说明一个package元素只能有0个或1个default-interceptor-ref子元素。

其实，在配置自己的package的时候所扩展的struts-default包里面，就已经定义了一个<default-interceptor-ref>，在Struts-default.xml中定义的struts-default包内，有如下定义：

 

java代码：

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

正是因为有这个定义，前面的示例中，我们都没有主动去配置拦截器，但实际上，是有拦截器在运行并执行很重要的工作，只不过是使用的默认的拦截器，我们不知道罢了。

当然现在就知道了，如果我们没有去配置拦截器，默认就会运行名称为“defaultStack”的拦截器栈里面定义的那些拦截器。可能有朋友会问，到底有哪些拦截器，看看上面的预定义拦截器，或者到Struts-default.xml中定义的struts-default包内去查看，里面都有。

6.2.4  拦截器的调用顺序

在学习了预定义拦截器的配置使用之后，接下来看看<action>元素引用拦截器的调用顺序。在拿到一个动作类的声明<action>元素后，如何找到它引用的拦截器呢？

       1：首先，要找它自己有没有声明拦截器的引用，即<action>元素有没有<interceptor-ref>子元素，如果有，则不用继续再找，直接使用这些拦截器，如果没有，下一步。

2：其次，找这个<action>所在的包有没有声明默认的拦截器引用，即<package>元素的<default-interceptor-ref>子元素, 如果有，则不用继续再找，直接使用这些拦截器，如果没有，下一步。

       3：最后，递归地寻找这个包的父包有没有声明默认的拦截器引用，直到找到有拦截器引用就为止。

       特别注意：这三个地方的定义是覆盖的关系，什么意思呢？就是如果<action>里面声明了拦截器引用，那么就以它的为准，其他的定义就无效了。也即是<action>里面的拦截器引用声明会覆盖<package>里面的缺省拦截器声明，而<package>里面的缺省拦截器声明又会覆盖父包的<package>里面的缺省拦截器声明，以此类推。

举个例子来说，如果你先有一个Action的配置如下：

 

java代码：

<package name="helloworld"  extends="struts-default">
        <action name="helloworldAction" class="cn.javass.action.action.HelloWorldAction">
            <param name="account">test</param>
            <result>/s2impl/welcome.jsp</result>
        </action>
</package>

这个配置下，helloworldAction是有拦截器的，它自己没有声明拦截器引用，它所在的包也没有声明默认的拦截器引用，但是它的父包，也就是struts-default包里面声明了默认的拦截器引用，也就是前面看到的“defaultStack”，因此helloworldAction是有拦截器的，就是在“defaultStack”引用的所有拦截器。

如果这个时候，你在Action的配置里面添加了一个拦截器的引用，配置如下：

 

java代码：

<package name="helloworld"  extends="struts-default">
        <action name="helloworldAction" class="cn.javass.action.action.HelloWorldAction">
            <param name="account">test</param>
            <result>/s2impl/welcome.jsp</result>
            <interceptor-ref name="staticParams"/>
        </action>
    </package>

这个配置下，helloworldAction也是有拦截器的，但是它只有一个拦截器，那就是“staticParams”。也就是说，helloworldAction配置里面有拦截器的引用，那么它将覆盖掉包或者父包里面定义的缺省引用。

也正是因为拦截器的配置是这种“覆盖”的关系，所以在<action>中配置拦截器的引用的时候，为了具有缺省的拦截器的引用，通常的做法是在后面加上对“defaultStack”的引用，示例如下：

 

java代码：

<package name="helloworld"  extends="struts-default">
        <action name="helloworldAction" class="cn.javass.action.action.HelloWorldAction">
            <param name="account">test</param>
            <result>/s2impl/welcome.jsp</result>
            <interceptor-ref name="staticParams"/>
            <interceptor-ref name="defaultStack"/>
        </action>
    </package>

6.2.5  实践一下

       已经学了不少预定义拦截器的知识了，来小小地综合运用一下。假如有如下的struts.xml，示例如下：

 

java代码：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
    <constant name="struts.devMode" value="true" />
    <constant name="struts.locale" value="zh_CN"/>
    <constant name="struts.i18n.encoding" value="gb2312"/>

    <package name="helloworld"  extends="struts-default">
        <action name="helloworldAction" class="cn.javass.action.action.HelloWorldAction">
            <result name="toWelcome">/s2impl/welcome.jsp</result>
        </action>
    </package>
</struts>

因为需要使用到struts-default.xml，因此简单的回顾一下，struts-default.xml配置示意如下：

 

java代码：

<package name="struts-default" abstract="true">
    ...
<interceptors>
<interceptor name="alias" class="com.opensymphony.xwork2.interceptor.AliasInterceptor"/>
<interceptor name="chain" class="com.opensymphony.xwork2.interceptor.ChainingInterceptor"/>
<interceptor name="cookie" class="org.apache.struts2.interceptor.CookieInterceptor"/>
<interceptor name="clearSession" class="org.apache.struts2.interceptor.ClearSessionInterceptor" />
<interceptor name="fileUpload" class="org.apache.struts2.interceptor.FileUploadInterceptor"/>
<interceptor name="i18n" class="com.opensymphony.xwork2.interceptor.I18nInterceptor"/>
<interceptor name="logger" class="com.opensymphony.xwork2.interceptor.LoggingInterceptor"/>
<interceptor name="timer" class="com.opensymphony.xwork2.interceptor.TimerInterceptor"/>
<interceptor name="token" class="org.apache.struts2.interceptor.TokenInterceptor"/>
        …
<interceptor-stack name="defaultStack">
<interceptor-ref name="exception"/>
<interceptor-ref name="alias"/>
<interceptor-ref name="servletConfig"/>
<interceptor-ref name="i18n"/>
<interceptor-ref name="prepare"/>
<interceptor-ref name="chain"/>
<interceptor-ref name="debugging"/>
<interceptor-ref name="scopedModelDriven"/>
<interceptor-ref name="modelDriven"/>
<interceptor-ref name="fileUpload"/>
<interceptor-ref name="checkbox"/>
<interceptor-ref name="multiselect"/>
<interceptor-ref name="staticParams"/>
<interceptor-ref name="actionMappingParams"/>
<interceptor-ref name="params">
<param name="excludeParams">dojo\..*,^struts\..*</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>
</interceptors>

<default-interceptor-ref name="defaultStack"/>
    ...
</package>

1：请问：helloworldAction引用了timer这个拦截器了吗?

       可以在struts-default.xml里面看到，在<interceptor>的声明中，有一个名为timer的拦截器：<interceptor name="timer" class="com.opensymphony.xwork2.interceptor.TimerInterceptor"/>

       但是怎么判断helloworldAction是否引用了timer呢？很简单，按照前面讲述的拦截器的调用顺序：

（1）先来看看这个<action>里面有没有声明拦截器引用？

       很明显没有，这个<action>元素没有<interceptor-ref>子元素，那就下一步。

（2）再看看这个包有没有声明默认的拦截器引用？

答案也很明显，是没有，这个<package>元素没有<defult-interceptor-ref>元素。

（3）接着看这个包的父包有没有声明默认的拦截器引用？

这个包的父包是struts-default，前面已经讲过，struts-default包里面有缺省的拦截器引用，它引用了“defaultStack”这个拦截器栈。

好了，找到一个了，那就停止寻找，helloworldAction会使用这个“defaultStack”拦截器栈里面所引用的所有拦截器。

（4）接下来，就来看看“defaultStack”拦截器栈里面是否引用了“timer”拦截器？

       仔细查看上面给出的struts-default.xml的定义，很明显，在“defaultStack”拦截器栈里面并没有引用名称为“timer”的拦截器。

（5）注意，这个时候还没完，因为< interceptor-ref>元素中的name属性不仅仅可以写一个拦截器的名字，还可以出现一个更小的拦截器栈的名字，还需要一一检查，出现的各个<interceptor-ref >是否引用了一个更小的拦截器栈，而这个更小的拦截器栈又是否引用了timer拦截器？

经过仔细排查，最终也没有发现有引用timer拦截器的拦截器栈。

（6）结论：折腾了这么一大圈，终于可以说helloworldAction没有引用timer拦截器了。

2：如何让helloworldAction引用timer拦截器呢？

timer拦截器是struts2的预定义拦截器之一，可以用来记录Action运行的时间。根据前面的示例，可以看到，默认的情况下是没有引用timer的。

如果现在想要引用timer拦截起来输出Action运行的时间，简单的使用示例如下。

（1）修改<action>元素的定义，添加上对timer拦截器的引用，别忘了同时添加上对缺省拦截器栈的引用，示例配置如下：

 

java代码：

<package name="helloworld"  extends="struts-default">
        <action name="helloworldAction" class="cn.javass.action.action.HelloWorldAction">
            <result name="toWelcome">/s2impl/welcome.jsp</result>
            <interceptor-ref name="timer"/>
            <interceptor-ref name="defaultStack"/>
        </action>
</package>

（2）Action就用最简单的写法，示例如下：

 

java代码：

public class HelloWorldAction extends ActionSupport {
    private String account;
    private String password;
    private String submitFlag;

    public String execute() throws Exception {
        this.businessExecute();
        return "toWelcome";
    }
    public void businessExecute(){
        System.out.println("用户输入的参数为==="+"account="+account+",password="+password+",submitFlag="+submitFlag);
    }
    //属性对应的getter/setter方法，省略了
}

（3）登录页面没有改变，去访问登录页面，填入用户名和密码，然后点击登录按钮，观察后台，可以看到其输出结果，示例如下：

 

java代码：

用户输入的参数为===account=test,password=test,submitFlag=login
2010-10-25 22:11:20 com.opensymphony.xwork2.util.logging.jdk.JdkLogger info
信息: Executed action [//helloworldAction!execute] took 151 ms.

其中，加粗的部分就是添加上timer拦截器之后，所输出的结果。通过这个结果可以看出执行helloworldAction的execute方法，共耗费151毫秒。

       注意：不同的机器运行的结果可能是不同的。

（4）这个示例的意义，通过示例实际使用timer拦截器，来学习如何使用预定义的拦截器，也就是说其他的预定义拦截器的使用方式，和这个示例使用timer拦截器的方式大同小异。

3：同包的其他Action也想要引用timer拦截器，该怎么办呢？

       现在需求变化了，不仅仅是helloworldAction需要引用timer拦截器了，同一个包内的其他Action也要引用timer拦截器。

       一个办法就是沿用老办法，让其他Action也跟helloworldAction一样，同时引用timer拦截器和defaultStack拦截器栈。

但是，这种做法不够好，有些重复劳动。简便的做法是，我们自行定义一个拦截器栈，在这个拦截器栈里面引用timer和缺省的拦截器栈，然后在包上指定默认的拦截器引用，而包下所有的Action都直接使用这个默认的引用就好了。接下来示例一下。

（1）先增加一个Action，示例代码如下：

 

java代码：

package cn.javass.action.action;
import com.opensymphony.xwork2.ActionContext;
public class SecondAction extends ActionSupport {
    public String execute() throws Exception {
        System.out.println("现在SecondAction进行处理");
        return "toWelcome";
    }
}

（2）然后修改struts.xml，添加一个自定义的拦截器栈，并指定包默认的拦截器引用就是这个拦截器栈，然后单独的Action就不用再引用拦截器了，示例配置如下：

 

java代码：

<package name="helloworld"  extends="struts-default">
        <interceptors>
            <interceptor-stack name="myStack">
                <interceptor-ref name="timer"/>
                <interceptor-ref name="defaultStack"/>
            </interceptor-stack>
        </interceptors>
        <default-interceptor-ref name="myStack"/>

        <action name="helloworldAction" class="cn.javass.action.action.HelloWorldAction">
            <result name="toWelcome">/s2impl/welcome.jsp</result>
        </action>
        <action name="secondAction" class="cn.javass.action.action.SecondAction">
            <result name="toWelcome">/s2impl/welcome.jsp</result>
        </action>
    </package>

上面的配置做了三件事：

• 定义了一个新的拦截器栈，在这个拦截器栈中，先引用timer拦截器，再引用defaultStack拦截器栈，如下：
  
  java代码：

  <interceptors>
  <interceptor-stack name="myStack">
  <interceptor-ref name="timer"/>
  <interceptor-ref name="defaultStack"/>
  </interceptor-stack>
  </interceptors>

• 
  
  java代码：

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

  在包上定义默认的拦截器引用为这个新定义的拦截器栈，如下：

• 
  
  java代码：

  helloworldAction和secondAction都不再配置拦截器引用

       自己去运行测试一下，看看效果。

私塾在线网站原创《研磨struts2》系列

转自请注明出处：【http://sishuok.com/forum/blogPost/list/0/4058.html】

欢迎访问http://sishuok.com获取更多内容

评论

1 楼 jidu01 2013-10-15  

配置timer的控制台信息输出，需要配置log4j