Struts2和Struts1.x的区别

在本系列教程中我们将学习到Struts2的各种技术。在本教程中使用的工具和程序库的版本如下：

开发工具：MyEclipse6

Web服务器：Tomcat6

Struts版本：Struts2.0.11.1

JDK版本：JDK1.5.0_12

J2EE版本：Java EE5.0

在本系列教程中Web工程的上下文路径都是struts2，如果在Web根目录有一个index.jsp文件，则访问路径如下：

http://localhost:8080/struts2/index.jsp

由于MyEclipse6目前并不支持Struts2，所以我们需要到struts.apache.org去下载Struts2安装包。要想正常使用Struts2，至少需要如下五个包（可能会因为Struts2的版本不同，包名略有差异，但包名的前半部是一样的）。

struts2-core-2.0.11.1.jar

xwork-2.0.4.jar

commons-logging-1.0.4.jar

freemarker-2.3.8.jar

ognl-2.6.11.jar

Struts2虽然在大版本号上是第二个版本，但基本上在配置和使用上已经完全颠覆了Struts1.x的方式（当然，Struts2仍然是基于MVC模式的，也是动作驱动的，可能这是唯一没变的东西）。Struts2实际上是在Webwork基础上构建起来的MVC框架。我们从Struts2的源代码中可以看到，有很多都是直接使用的xwork(Webwork的核心技术)的包。既然从技术上来说Struts2是全新的框架，那么就让我们来学习一下这个新的框架的使用方法。

如果大家使用过Struts1.x，应该对建立基于Struts1.x的Web程序的基本步骤非常清楚。让我们先来回顾一下建立基于Struts1.x的Web程序的基本步骤。

1.安装Struts。由于Struts的入口点是ActionServlet，所以得在web.xml中配置一下这个Servlet。

2.编写Action类（一般从org.apache.struts.action.Action类继承）。

3.编写ActionForm类（一般从org.apache.struts.action.ActionForm类继承），这一步不是必须的，如果要接收客户端提交的数据，需要执行这一步。

4.在struts-config.xml文件中配置Action和ActionForm。

5.如果要采集用户录入的数据，一般需要编写若干JSP页面，并通过这些JSP页面中的form将数据提交给Action。

下面我们就按着编写struts1.x程序的这五步和struts2.x程序的编写过程一一对应，看看它们谁更“酷”。下面我们来编写一个基于Struts2的Web程序。这个程序的功能是让用户录入两个整数，并提交给一个Struts Action，并计算这两个数的代数和，如果代码和为非负数，则跳转到positive.jsp页面，否则跳转到negative.jsp页面。

【第1步】安装Struts2

这一步对于Struts1.x和Struts2都是必须的，只是安装的方法不同。Struts1的入口点是一个Servlet，而Struts2的入口点是一个过滤器(Filter)。因此，Struts2要按过滤器的方式配置。下面是在web.xml中配置Struts2的代码：

< filter >
< filter-name >struts2 </ filter-name >
< filter-class >
org.apache.struts2.dispatcher.FilterDispatcher
</ filter-class >
</ filter >
< filter-mapping >
< filter-name >struts2 </ filter-name >
< url-pattern >/* </ url-pattern >
</ filter-mapping >

【第2步】编写Action类

这一步和Struts1.x也必须进行。只是Struts1.x中的动作类必须从Action类中继承，而Struts2.x的动作类需要从com.opensymphony.xwork2.ActionSupport类继承。下面是计算两个整数代码和的Action类，代码如下：

packageaction;

importcom.opensymphony.xwork2.ActionSupport;

public classFirstAction extendsActionSupport
{
private intoperand1;
private intoperand2;

publicStringexecute() throwsException
{
if(getSum()>=0) // 如果代码数和是非负整数，跳到positive.jsp页面
{
return"positive";
}
else // 如果代码数和是负整数，跳到negative.jsp页面
{
return"negative";
}
}

public intgetOperand1()
{
returnoperand1;
}

public voidsetOperand1( intoperand1)
{
System.out.println(operand1);
this.operand1=operand1;
}

public intgetOperand2()
{
returnoperand2;
}
public voidsetOperand2( intoperand2)
{
System.out.println(operand2);
this.operand2=operand2;
}
public intgetSum()
{
returnoperand1+operand2; // 计算两个整数的代码数和
}
}

从上面的代码可以看出，动作类的一个特征就是要覆盖execute方法，只是Struts2的execute方法没有参数了，而Struts1.x的execute方法有四个参数。而且execute方法的返回值也不同的。Struts2只返回一个String，用于表述执行结果（就是一个标志）。上面代码的其他部分将在下面讲解。

【第3步】编写ActionForm类

在本例中当然需要使用ActionForm了。在Struts1.x中，必须要单独建立一个ActionForm类（或是定义一个动作Form），而在Struts2中ActionForm和Action已经二合一了。从第二步的代码可以看出，后面的部分就是应该写在ActionForm类中的内容。所以在第2步，本例的ActionForm类已经编写完成（就是Action类的后半部分）。

【第4步】配置Action类

这一步 struts1.x 和 struts2.x 都是必须的，只是在 struts1.x 中的配置文件一般叫 struts-config.xml （当然也可以是其他的文件名），而且一般放到 WEB-INF 目录中。而在 struts2.x 中的配置文件一般为 struts.xml ，放到 WEB-INF"classes 目录中。下面是在 struts.xml 中配置动作类的代码：

<? xmlversion="1.0"encoding="UTF-8" ?>
<! DOCTYPEstrutsPUBLIC
"-//ApacheSoftwareFoundation//DTDStrutsConfiguration2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd" >
< struts >
< package name ="struts2" namespace ="/mystruts"
extends ="struts-default" >
< action name ="sum" class ="action.FirstAction" >
< result name ="positive" >/positive.jsp </ result >
< result name ="negative" >/negative.jsp </ result >
</ action >
</ package >
</ struts >

在<struts>标签中可以有多个<package>，第一个<package>可以指定一个Servlet访问路径（不包括动作名），如“/mystruts”。extends属性继承一个默认的配置文件“struts-default”，一般都继承于它，大家可以先不去管它。<action>标签中的name属性表示动作名，class表示动作类名。

<result>标签的name实际上就是execute方法返回的字符串，如果返回的是“positive”，就跳转到positive.jsp页面，如果是“negative”，就跳转到negative.jsp页面。在<struts>中可以有多个<package>，在<package>中可以有多个<action>。我们可以用如下的URL来访问这个动作：

http://localhost:8080/struts2/mystruts/sum.action

注：Struts1.x的动作一般都以.do结尾，而Struts2是以.action结尾。

【第5步】编写用户录入接口（JSP页面）

1.主界面（sum.jsp）

在Web根目录建立一个sum.jsp，代码如下：

<% @pagelanguage = " java " import = " java.util.* " pageEncoding = " GBK " %>
<% @taglibprefix = " s " uri = " /struts-tags " %>

< html >
< head >
< title >输入操作数 </ title >
</ head >

< body >
求代数和
< br />
< s:form action ="mystruts/sum.action" >
< s:textfield name ="operand1" label ="操作数1" />
< s:textfield name ="operand2" label ="操作数2" />
< s:submit value ="代数和" />
</ s:form >
</ body >
</ html >

在sum.jsp中使用了Struts2带的tag。在Struts2中已经将Struts1.x的好几个标签库都统一了，在Struts2中只有一个标签库/struts-tags。这里面包含了所有的Struts2标签。但使用Struts2的标签大家要注意一下。在<s:form>中最好都使用Struts2标签，尽量不要用HTML或普通文本，大家可以将sum.jsp的代码改为如下的形式，看看会出现什么效果：

... ...

求代数和

<br/>

<s:form action="mystruts/sum.action" >

操作数1：<s:textfield name="operand1" /><br/>

操作数2：<s:textfield name="operand1" /><br/>

<s:submit value="代数和" />

</s:form>

... ...

提示一下，在<s:form>中Struts2使用<table>定位。

2.positive.jsp

<% @pagelanguage = " java " import = " java.util.* " pageEncoding = " GBK " %>
<% @taglibprefix = " s " uri = " /struts-tags " %>

< html >
< head >
< title >显示代数和 </ title >
</ head >

< body >
代数和为非负整数 < h1 >< s:property value ="sum" /></ h1 >
</ body >
</ html >

3.negative.jsp

<% @pagelanguage = " java " import = " java.util.* " pageEncoding = " GBK " %>
<% @taglibprefix = " s " uri = " /struts-tags " %>

< html >
< head >
< title >显示代数和 </ title >
</ head >

< body >
代数和为负整数 < h1 >< s:property value ="sum" /></ h1 >

</ body >
</ html >

这两个jsp页面的实现代码基本一样，只使用了一个<s:property>标签来显示Action类中的sum属性值。<s:property>标签是从request对象中获得了一个对象中得到的sum属性，如我们可以使用如下的代码来代替<s:property value=”sum”/>：

<%

com.opensymphony.xwork2.util.OgnlValueStack ovs =

(com.opensymphony.xwork2.util.OgnlValueStack)request.getAttribute("struts.valueStack");

out.println(ovs.findString("sum"));

%>

启动Tomcat后，在IE中输入如下的URL来测试这个例子：

http://localhost:8080/struts2/sum.jsp

========================================================================================

========================================================================================

========================================================================================

大多数人都会熟悉Struts, 无论是从项目实战中获得的经验还是从书中了解到的知识。在这一系列文章里，我们将通过一个由Struts迁移到Struts 2的简单应用例子向大家展现Struts 2的所有特征。

在我们开始介绍这个例子之前，你需要去了解一点Struts 2的背景知识。文章的第一部分将介绍Struts 2与Struts的核心架构的不同点，以助于更好地把所有概念联系起来。第二部分将深入探讨两者在actions上的差别、action相关的框架特征和action的配置。在文章最后一部分将会讲述用户界面。我们会讲到其架构、UI构件、主题和标签，还有如何为我们的应用加上新的外观。

我们并不打算谈及迁移过程的所有细节方面，我们只是从普通的出发点开始介绍Struts 2的概念和现在可用的所有新特征。但拥有这些知识后，无论以后迁移到何等规模的应用到Struts 2中你都可以易如反掌。

导言/历史

Struts的第一个版本是在2001年5月份发布的。它的最初设想是通过结合JSP和Servlet，使Web应用的视图和业务/应用逻辑得以清晰地分离开来。在Struts之前，最常见的做法是在JSP中加入业务和应用逻辑，或者在Servlet中通过println()来生成视图。

自从第一版发布以来，Struts实际上已成为业界公认的Web应用标准。它的炙手可热也为自己带来了改进和变更，所以不但要跟上对Web应用框架不断变化的需求，而且要与日渐增多竞争激烈的众多框架的特性相融合。

到最后，产生了几个下一代Struts的解决方案。其中两个最受瞩目的方案是Shale和Struts Ti。Shale是一个基于构件的框架，并在最近成为Apache的顶级项目。而Struts Ti则是在Struts的成功经验基础上继续坚持对前端控制器（Front Controller）和MVC（model-view-controller）模式进行改进。

WebWork项目是在2002年3月发布的，它对Struts式框架进行了革命性改进，引进了不少新的思想，概念和功能，但和原Struts代码并不兼容。WebWork是一个成熟的框架，经过了好几次重大的改进与发布。

在2005年12月，WebWork与Struts Ti宣布合并。与此同时，Struts Ti改名为Struts Action Framework 2.0，成为Struts真正的继承者。

最后要注意的是，并不是说Struts或WebWork项目已经停止开发了。由于人们对这两个项目的兴趣仍然很高，而且也有很多开发者仍然愿意使用它们，因此这两个项目还在继续开发中，继续修复Bug，改进功能和继续添加新功能。

请求运作过程

在我们开始详细探讨如何把应用由Struts迁移到Struts 2之前，让我们通过体验整个请求流程，看看新架构是如何运作的。

在我们体验了整个请求的生命周期后，你应当注意到很重要的一点——Struts 2仍是以前端控制器框架为主体的。所有的概念还都是你以前所熟悉的。

这意味着：

• Actions仍然是通过URL触发的
• 数据仍然是通过URL请求参数和Form参数传送到服务端的
• 所有Servlet对象（如request、response和session等）仍在Action可用

以下是请求处理过程的高层概览：

整个请求的处理过程可以分为6步：

1. 由框架产生一个请求并进行处理- 框架根据请求匹配相应的配置，得到使用哪些拦截器，Action类和返回结果的信息。
2. 请求通过一系列的拦截器- 拦截器和拦截器组可以按照不同级别进行组合配置来处理请求。它们为请求提供各种预处理和切面处理的应用功能。这和Struts的使用Jakarta Commons Chain构件的RequestProcessor类很相似。
3. 调用Action- 产生一个新的Action对象实例，并提供请求所调用的处理逻辑的方法。我们在第二部文章中将对这步骤进行进一步讨论。Struts 2可以在配置Action时为请求分配其指定的方法。
4. 调用相应的Result- 通过匹配处理Action方法之后的返回值，获取相应Result类，生成并调用它的实例。处理Result可能产生的结果之一就是对UI模板（但并非只有一个）进行渲染，来产生HTML。如果是这种情况的话，模板中的Struts 2 tags可以直接从Action中获取要被要被渲染的值。
5. 请求再次经过一系列拦截器处理后返回- Request以和进入时相反的方向通过拦截器组，当然，你可以在这个过程中进行回收整理或者额外的处理工作。
6. 响应被返回给用户- 最后一步是将控制权交还给Servlet引擎。最常见的结果是把渲染后的HTML返回给用户，但返回的也可能是指定的HTTP头或者进行HTTP重定向。

你应该已经注意到Struts 2和Struts的差别了。最明显的就是Struts 2是一个pull-MVC架构。这是什么意思呢？从开发者角度看，就是说需要显示给用户的数据可以直接从Action中获取，而不像Struts那样必须把相应的Bean存到Page、Request或者Session中才能获取。

配置框架

首先最重要的是，通过配置web.xml文件让框架能在Servlet容器里运行。

下面这个就是大家都熟悉的Struts在web.xml里的配置方法：

    
	action
	org.apache.struts.action.ActionServlet
	
	    config
	    /WEB-INF/struts-config.xml
	
	2
    

    
	action
	*.do
    

在Struts 2中，配置有少许改变，最明显的是分发器（dispatcher）已由Servlet转为Servlet Filter, 其配置和Servlet一样简单，如下：

    
	webwork
	
	    org.apache.struts.action2.dispatcher.FilterDispatcher
	
    

    
	webwork
	/*
    

和Servlet配置一样，Filter配置中定义了Filter的名称（作为引用）和类名。Filter Mapping通过URI和名称匹配来调用相应的Filter。默认情况下，扩展名为“.action”，这是在default.properties文件（在Struts 2 JAR文件里）的“struts.action.extension”属性定义的。

工具箱：“default.properties”是默认配置选项定义文件。你可以通过在classpath中包含一个叫“struts.properties”的文件，设置不同的属性值，来覆盖默认配置的值，实现自己的配置。

对于Struts来说, Servlet配置提供了一个用于定义文件名的init-param tag来配置Struts，而Struts 2没有这样的配置参数，取而代之的是在classpath下的默认配置文件“struts.xml”。

工具箱/提示：因为Struts Actions（扩展名“.do”）和Struts 2 Actions（扩展名“.action”）两者的扩展名命名空间不一样，所以Struts和Struts 2可以在同一个Web应用系统中无碍地共存。所以这就为迁移提供了很好的条件，加入适当的配置，新功能的开发都用Struts 2。保持原有的遗留功能，如果时间和资源允许的情况下再逐步迁移。另一种方法是，只把Struts 2的扩展名改为“.do”，这样就可使得以前的JSP页面可重用。

解剖Actions

在上面介绍的请求运作流程中，我们从高层次上谈及了一些Struts和Struts 2的不同点。现在我们将较深入地探讨这两个框架中Action结构的具体差别。

让我们来回顾一下Struts的Action的主要结构。Struts Action的主要形式如下：

public class MyAction extends Action {
    public ActionForward execute(ActionMapping mapping,
                                 ActionForm form,
                                 HttpServletRequest request,
                                 HttpServletResponse response)
            throws Exception {
        // do the work
        return (mapping.findForward("success"));
    }
}

当你实现一个Struts Action时, 需要注意以下问题：

1. 所有的Action都继承于Action基类。
2. 所有的Action都必须是线程安全的，因为只产生一个Action实例。
3. 因为所有的Action都必须是线程安全的，所有在Action处理过程中所需要的对象都必须以方法参数的形式传入。
4. 处理Action所调用的方法必须命名为“execute”（在Struts中的DispatchAction类可以调用同一个Action的其它方法，但实际上在框架中的入口点仍然是“execute”方法）。
5. ActionForward结果是通过ActionMapping类中的方法来产生的，通常的做法是通过调用“findForward”方法。

相比较之下，Struts 2的Action提供了更简单的实现方式。下面就是个例子：

public class MyAction {
   public String execute() throws Exception {
        // do the work
        return "success";
   }
}

首先你会注意到的是，Struts 2中的Action不再继承于任何类或需要实现任何接口。实际上，它还远不只这些。按照惯例，只有“execute”方法能调用Action,　但在Struts 2中并非必要，任何声明为public String methodName() 方法都能通过配置来调用Action。

另外，你会注意到返回的对象不是ActionForward，而是String。如果你不喜欢以字符串的形式出现在你的代码中，有个Helper接口Action可以以常量方式提供常见结果，如“success”、“none”、“error”、“input”和“login”。

最后，和Struts最大的革命性的不同是，处理Action过程中调用的方法（“execute”方法）是不带参数的。那你如何获取你所需要的对象呢？答案是使用“反转控制（Inversion of Control）”，也叫“依赖注入（Dependency Injection）”的模式（想更多地了解这方面信息请看Martin Fowler的文章http://www.martinfowler.com/articles/injection.html）。Spring框架使得这个模式流行起来，然而Struts 2的前身（WebWork）也在同时应用上了这个模式。

为了更好地了解反转控制，让我们来看看一个例子，如何在Action处理过程中可以访问到当前请求HttpServerRequest对象。

在我们的例子中，我们使用的依赖注入机制是接口注入。就如其名称一样，接口注入需要的是已经被实现了的接口。这个接口包含了相应属性的setter，为Action提供值。例子中我们使用了ServletRequestAware接口，如下：

public interface ServletRequestAware {
    public void setServletRequest(HttpServletRequest request);
}

当我们继承这个接口后，我们原本简单的Action看起来有点复杂了，但是这时我们可以获取HttpServerRequest对象来使用了。

public class MyAction implements ServletRequestAware {
   private HttpServletRequest request;
   public void setServletRequest(HttpServletRequest request) {
        this.request = request;
   }
   public String execute() throws Exception {
        // do the work using the request
        return Action.SUCCESS;
   }
}

看起来现在这些属性是类级别的，并不是线程安全的，会出现问题。其实在Struts 2里并没有问题，因为每个请求过来的时候都会产生一个新的Action对象实例，它并没有和其他请求共享一个对象，所以不需要考虑线程安全问题。

现在我们还有最后一步，就是为这个Action关联上ServletConfigInterceptor拦截器。这个拦截器提供了一系列功能去获取HttpServletRequest，并可以把它注入到实现了ServletRequestAware接口Action中。这时你并不需要担心如何配置这些，我们将在下一篇文章中有具体讲述。最重要的是让我们明白到是拦截器和接口共同合作下为Action提供了反转控制功能的。

这个设计的好处是能让Action和框架完全解耦。Action仅仅是一个与框架无关的简单POJO。这给单元测试带来极大的好处，Struts 2 Action的单元测试远比Struts Action使用StrutsTestCase或MockStrutsTestCase的单元测试简单。

总结/综述

到现在为止，你应该对Struts2的基础有所了解了——包括高层的框架概念和基础的请求流程。你也应该能自己动手在Servlet容器里配置Struts 2，并理解Struts和Struts 2两者之间在Action方面的差别了。

在下篇文章中，我们将会介绍一个详细的迁移的例子，同时我们也在这章学到的知识基础上，演示如何由Struts向Struts 2的Action迁移。在最后讲述如何在应用中使用JSTL、JSP和Struts2。我们会进一步探讨Struts和Struts 2在Action上的区别，Struts 2的配置和其他框架元素，和谈到更多的Action相关的框架特征。

关于作者

Ian Roughley是一位技术演讲人、作家及独立咨询顾问，住在马萨诸塞州的波士顿。他具有十多年提供架构设计、开发、过程改进以及指导等方面服务的经验，客户范围小至创业公司，大到财富500强前10名的公司。他专注于具有实效性且以结果为目标的方法，是开源及以敏捷开发为基础的过程和质量改进的支持者。

============================================================================================

============================================================================================

============================================================================================

struts2 VS struts1

struts2与struts1相比，确实有很多革命性的改进，但它并不是新发布的新框架，实在webWork的基础上发展起来的。

struts2 没有继承struts1的血统，而是继承webwork的血统。webwork衍生出了struts2,因为struts2是webwork的升级
而不是一个全新的框架，因此稳定性、性能等方面都有很好的保证。吸收了struts1和webwork两者的优势。

Apache struts2是一个优雅的，可扩展的JAVAEE web框架。框架设计的目标贯穿整个开发周期，从开发到发布，包括维护整个过程。
经历了几年的各自发展后，webwork和struts社区决定合二为一，即是struts2.

struts1和struts2 的不同

Action 类：

struts1 要求Action类继承一个抽象基类。struts1的一个普遍问题是使用抽象类编程而不是接口 (如：struts1须继承action的
抽象类其中提供的参数HttpServlet，Httprequest... 等等与容器做绑定了必须依赖也容器<tomcat,jobs>服务器，没有服务器不能测试)。
使用抽象类编程了而不是接口编程。
struts2面向接口编程 struts2 的Action可以实现Action的接口也可以不实现，也可以实现其他接口。Action就是一个不同的类。
struts2提供的一个ActionSuppert基类去实现常用的接口。Action接口不是必须的，任何有execute标识的POJO对象都可以用作struts2的Action对象。

线程模式

struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有请求。单例策略限制了struts1 Action
能做的事，并且要在开发时特别小心，Action的资源必须是线程安全的或同步的。
sturts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。

Servlet 依赖：

struts1 Action 依赖于Servlet API，因为当一个Action被调用时HttpServletRequest和HttpServletResponse被传递给execute方法。
struts2 Action 不依赖于容器，允许Action脱离容器单独被测试。如果需要，struts2 Action 仍然可以访问初始化的request和response
但是，其他的元素减少或者消除了直接访问HttpServletRequest和HttpServletResponse的必要性。

可测性：

测试struts1 Action 的一个主要问题是execute方法暴露了servlet API (这使得测试要依赖于容器)。一个第三方扩展 -- struts TestCase
提供了一套struts1的模拟对象(来进行测试)。
struts2 Action 可以通过初始化、设置属性、调用方法来测试，“依赖注入”支持也使得测试更容易。

捕获输入：

struts1 使用ActionFrom 对象捕获输入。
所有的ActionForm必须继承一个基类。因为其他JavaBean不能用作ActionForm,开发者经常创建多余的类捕获输入。
动态Bean(Dynabeans)可以作为创建传统ActionForm的选择，但是，开发者可能是在重新描述(创建)已经存在的JavaBean (仍然会导致有冗余的javabean).
struts2 直接使用Action属性作为输入属性，消除了对第二个输入对象的需求。Action的属性能够通过web页面上的taglibs 访问。
struts2 也支持ActionForm模式。

表达式语言：

struts1 整合了JSTL，因此使用JSTL EL。这种EL有基于对象图遍历。但是对集合和索引属性的支持很弱。
struts2 可以使用JSTL，但是也支持一个更强大和灵活的表达式语言 -- "Object Graph Notation Language" (OGNL对象图导航语言)
绑定值到页面(view)
struts1 使用标准JSP 机制把对象绑定到页面中来访问。
struts2 使用“ValueStack”技术，使taglib能够访问值而不需要把你的页面(view)和对象绑定起来。ValueStack策略允许通过一系列
名称相同但类型不同的属性重用页面(view). (struts2的值栈技术<在jsp页面中直接使用标签获取Action中的值>)。

类型转换：

struts1 ActionForm 属性通常都是String 类型。Struts1使用Commons-Beanutils进行类型转换。每个类一个转换器，对每一个实例
来说是不可配置的。
struts2 使用OGNL进行类型转换。提供基本和常用对象的转换器。

校验：

struts1 支持在ActionForm的validate方法中手动校验，或者通过Commons Validator 的扩展来校验。同一个类可以有不同的校验内容，
但不能校验子对象。
struts2 支持通过validate方法和XWork校验框架来进行校验。XWork校验框架使用为属性类类型定义的校验和内容校验，来支持chain校验
子属性。

Action 执行的控制：

struts1 支持每一个模块有单独的Request Processors (生命周期)，但是模块中的所有Action必须共享相同的生命周期。
struts2 支持通过拦截器堆栈(Interceptor Stacks) 为每一个Action创建不同的生命周期。堆栈能够根据需要和不同的Action一起使用。