说明：希望本文的读者能有一定的Struts使用基础。

Model 2

Struts是基于Model 2之上的，而Model 2是经典的MVC（模型－视图－控制器）模型的Web应用变体，这个改变主要是由于网络应用的特性--HTTP协议的无状态性引起的。Model 2的目的和MVC一样，也是利用控制器来分离模型和视图，达到一种层间松散耦合的效果，提高系统灵活性、复用性和可维护性。在多数情况下，你可以将Model 2与MVC等同起来。

下图表示一个基于Java技术的典型网络应用，从中可以看出Model 2中的各个部分是如何对应于Java中各种现有技术的。

在利用Model 2之前，我们是把所有的表示逻辑和业务逻辑都集中在一起（比如大杂烩似的JSP），有时也称这种应用模式为Model 1，Model 1的主要缺点就是紧耦合，复用性差以及维护成本高。

Struts 1.1 和Model 2

既然Struts 1.1是基于Model 2之上，那它的底层机制也就是MVC，下面是Struts 1.1中的MVC实现示意图：

首先，控制器（ActionServlet）进行初始化工作，读取配置文件（struts-config.xml），为不同的Struts模块初始化相应的ModuleConfig对象。比如配置文件中的Action映射定义都保存在ActionConfig集合中。相应地有ControlConfig集合、FormBeanConfig集合、ForwardConfig集合和MessageResourcesConfig集合等。

提示：模块是在Struts 1.1中新提出的概念，在稍后的内容中我们将详细介绍，你现在可以简单地把模块看作是一个子系统，它们共同组成整个应用，同时又各自独立。Struts 1.1中所有的处理都是在特定模块环境中进行的。模块的提出主要是为了解决Struts 1.0中单配置文件的问题。

控制器接收HTTP请求，并从ActionConfig中找出对应于该请求的Action子类，如果没有对应的Action，控制器直接将请求转发给JSP或者静态页面。否则控制器将请求分发至具体Action类进行处理。

在控制器调用具体Action的execute方法之前，ActionForm对象将利用HTTP请求中的参数来填充自己（可选步骤，需要在配置文件中指定）。具体的ActionForm对象应该是ActionForm的子类对象，它其实就是一个JavaBean。此外，还可以在ActionForm类中调用validate方法来检查请求参数的合法性，并且可以返回一个包含所有错误信息的ActionErrors对象。如果执行成功，ActionForm自动将这些参数信息以JavaBean（一般称之为form bean）的方式保存在Servlet Context中，这样它们就可以被其它Action对象或者JSP调用。

Struts将这些ActionForm的配置信息都放在FormBeanConfig集合中，通过它们Struts能够知道针对某个客户请求是否需要创建相应的ActionForm实例。

Action很简单，一般只包含一个execute方法，它负责执行相应的业务逻辑，如果需要，它也进行相应的数据检查。执行完成之后，返回一个ActionForward对象，控制器通过该ActionForward对象来进行转发工作。我们主张将获取数据和执行业务逻辑的功能放到具体的JavaBean当中，而Action只负责完成与控制有关的功能。遵循该原则，所以在上图中我将Action对象归为控制器部分。

提示：其实在Struts 1.1中，ActionMapping的作用完全可以由ActionConfig来替代，只不过由于它是公共API的一部分以及兼容性的问题得以保留。ActionMapping通过继承ActionConfig来获得与其一致的功能，你可以等同地看待它们。同理，其它例如ActionForward与ForwardConfig的关系也是如此。

下图给出了客户端从发出请求到获得响应整个过程的图解说明。

下面我们就来详细地讨论一下其中的每个部分，在这之前，先来了解一下模块的概念。

模块

我们知道，在Struts 1.0中，我们只能在web.xml中为ActionServlet指定一个配置文件，这对于我们这些网上的教学例子来说当然没什么问题，但是在实际的应用开发过程中，可能会有些麻烦。因为许多开发人员都可能同时需要修改配置文件，但是配置文件只能同时被一个人修改，这样肯定会造成一定程度上的资源争夺，势必会影响开发效率和引起开发人员的抱怨。

在Struts 1.1中，为了解决这个并行开发的问题，提出了两种解决方案：

1. 多个配置文件的支持
2. 模块的支持

支持多个配置文件，是指你能够为ActionServlet同时指定多个xml配置文件，文件之间以逗号分隔，比如Struts提供的MailReader演示例子中就采用该种方法。

  <!-- Action Servlet Configuration -->
  <servlet>
	<servlet-name>action</servlet-name>
	<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
	<init-param>
		<param-name>config</param-name>
		<param-value>/WEB-INF/struts-config.xml, /WEB-INF/struts-config-registration.xml</param-value>
	</init-param> 
	<load-on-startup>1</load-on-startup>
  </servlet>

这种方法可以很好地解决修改冲突的问题，不同的开发人员可以在不同的配置文件中设置自己的Action、ActionForm等等（当然不是说每个开发人员都需要自己的配置文件，可以按照系统的功能模块进行划分）。但是，这里还是存在一个潜在的问题，就是可能不同的配置文件之间会产生冲突，因为在ActionServlet初始化的时候这几个文件最终还是需要合并到一起的。比如，在struts-config.xml中配置了一个名为success的<forward>，而在struts-config-registration.xml中也配置了一个同样的<forward>，那么执行起来就会产生冲突。

为了彻底解决这种冲突，Struts 1.1中引进了模块（Module）的概念。一个模块就是一个独立的子系统，你可以在其中进行任意所需的配置，同时又不必担心和其它的配置文件产生冲突。因为前面我们讲过，ActionServlet是将不同的模块信息保存在不同的ModuleConfig对象中的。要使用模块的功能，需要进行以下的准备工作：

1、为每个模块准备一个配置文件

2、配置web.xml文件，通知控制器

决定采用多个模块以后，你需要将这些信息告诉控制器，这需要在web.xml文件进行配置。下面是一个典型的多模块配置：

<init-param>
	<param-name>config</param-name>
	<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
<init-param>
	<param-name>config/customer</param-name> 
	<param-value>/WEB-INF/struts-config-customer.xml</param-value>
</init-param>
<init-param> 
	<param-name>config/order</param-name>
	<param-value>/WEB-INF/struts-config-order.xml</param-value>
</init-param>

要配置多个模块，你需要在原有的一个<init-param>（在Struts 1.1中将其对应的模块称为缺省模块）的基础之上，增加模块对应的<init-param>。其中<param-name>表示为config/XXX的形式，其中XXX为对应的模块名，<param-value>中还是指定模块对应的配置文件。上面这个例子说明该应用有三个模块，分别是缺省模块、customer和order，它们分别对应不同的配置文件。

3、准备各个模块所需的ActionForm、Action和JSP等资源

但是要注意的是，模块的出现也同时带来了一个问题，即如何在不同模块间进行转发？有两种方法可以实现模块间的转发，一种就是在<forward>（全局或者本地）中定义，另外一种就是利用org.apache.struts.actions.SwitchAction。

下面就是一个全局的例子：

    ... 
    <struts-config>
	... 
	<global-forwards>
		<forward name="toModuleB"
			contextRelative="true"  
			path="/moduleB/index.do" 
		redirect="true"/>   
	... 
	</global-forwards>  
	...   
    </struts-config>

可以看出，只需要在原有的path属性前加上模块名，同时将contextRelative属性置为true即可。此外，你也可以在<action>中定义一个类似的本地<forward>。

  <action-mappings>
	<!-- Action mapping for profile form -->
	<action path="/login" 
	type="com.ncu.test.LoginAction"  
	name="loginForm"     
	scope="request"      
	input="tile.userLogin"
	validate="true">     
	<forward name="success" contextRelative="true" path="/moduleA/login.do"/> 
	</action> 
  </action-mappings>

如果你已经处在其他模块，需要转回到缺省模块，那应该类似下面这样定义，即模块名为空。

<forward name="success" contextRelative="true" path="/login.do"/>

此外，你也可以使用org.apache.struts.actions.SwitchAction，例如：

    ...
    <action-mappings> 
	<action path="/toModule" 
	type="org.apache.struts.actions.SwitchAction"/>  
	...    
    </action-mappings>  
    ...

ActionServlet

我们首先来了解MVC中的控制器。在Struts 1.1中缺省采用ActionServlet类来充当控制器。当然如果ActionServlet不能满足你的需求，你也可以通过继承它来实现自己的类。这可以在/WEB-INF/web.xml中来具体指定。

要掌握ActionServlet，就必须了解它所扮演的角色。首先，ActionServlet表示MVC结构中的控制器部分，它需要完成控制器所需的前端控制及转发请求等职责。其次，ActionServlet被实现为一个专门处理HTTP请求的Servlet，它同时具有servlet的特点。在Struts 1.1中它主要完成以下功能：

• 接收客户端请求
• 根据客户端的URI将请求映射到一个相应的Action类
• 从请求中获取数据填充Form Bean（如果需要）
• 调用Action类的execute()方法获取数据或者执行业务逻辑
• 选择正确的视图响应客户

此外，ActionServlet还负责初始化和清除应用配置信息的任务。ActionServlet的初始化工作在init方法中完成，它可以分为两个部分：初始化ActionServlet自身的一些信息以及每个模块的配置信息。前者主要通过initInternal、initOther和initServlet三个方法来完成。

我们可以在/WEB-INF/web.xml中指定具体的控制器以及初始参数，由于版本的变化以及Struts 1.1中模块概念的引进，一些初始参数被废弃或者移入到/WEB-INF/struts-config.xml中定义。下面列出所有被废弃的参数，相应地在web.xml文件中也不鼓励再使用。

• application
• bufferSize
• content
• debug
• factory
• formBean
• forward
• locale
• mapping
• maxFileSize
• multipartClass
• nocache
• null
• tempDir

ActionServlet根据不同的模块来初始化ModuleConfig类，并在其中以XXXconfig集合的方式保存该模块的各种配置信息，比如ActionConfig，FormBeanConfig等。

初始化工作完成之后，ActionServlet准备接收客户请求。针对每个请求，方法process(HttpServletRequest request, HttpServletResponse response)将被调用。该方法指定具体的模块，然后调用该模块的RequestProcessor的process方法。

protected void process(HttpServletRequest request, 
		HttpServletResponse response) 
		throws IOException, ServletException {

	RequestUtils.selectModule(request, getServletContext());        
	getRequestProcessor(getModuleConfig(request)).process(request, response);
}

RequestProcessor包含了Struts控制器的所有处理逻辑，它调用不同的processXXX方法来完成不同的处理。下表列出其中几个主要的方法：

方法	功能
processPath	获取客户端的请求路径
processMapping	利用路径来获得相应的ActionMapping
processActionForm	初始化ActionForm（如果需要）并存入正确的scope中
processActionCreate	初始化Action
processActionPerform	调用Action的execute方法
processForwardConfig	处理Action返回的ActionForward

ActionForm

对于ActionForm你可以从以下几个方面来理解它：

1. ActionForm表示HTTP窗体中的数据，可以将其看作是模型和视图的中介，它负责保存视图中的数据供模型或者视图使用。Struts 1.1文档中把它比作HTTP和Action之间的防火墙，这体现了ActionForm具有的过滤保护的作用，只有通过ActionForm验证的数据才能够发送到Action处理。
2. ActionForm是与一个或多个ActionConfig关联的JavaBean，在相应的action的execute方法被调用之前，ActionForm会自动利用请求参数来填充自己（初始化属性）。
3. ActionForm是一个抽象类，你必须通过继承来实现自己的类。

ActionForm首先利用属性的getter和setter方法来实现初始化，初始化完毕后，ActionForm的validate方法被调用，你可以在其中来检查请求参数的正确性和有效性，并且可以将错误信息以ActionErrors的形式返回到输入窗体。否则，ActionForm将被作为参数传给action的execute方法以供使用。

ActionForm bean的生命周期可以设置为session（缺省）和request，当设置为session时，记得在reset方法中将所有的属性重新设置为初始值。

由于ActionForm对应于HTTP窗体，所以随着页面的增多，你的ActionForm将会急速增加。而且可能同一类型页面字段将会在不同的ActionForm中出现，并且在每个ActionForm中都存在相同的验证代码。为了解决这个问题，你可以为整个应用实现一个ActionForm或者至少一个模块对应于一个ActionForm。

但是，聚合的代价就是复用性很差，而且难维护。针对这个问题，在Struts 1.1中提出了DynaActionForm的概念。

DynaActionForm类

DynaActionForm的目的就是减少ActionForm的数目，利用它你不必创建一个个具体的ActionForm类，而是在配置文件中配置出所需的虚拟ActionForm。例如，在下表中通过指定<form-bean>的type为"org.apache.struts.action.DynaActionForm"来创建一个动态的ActionForm--loginForm。

<form-beans>
	<form-bean name="loginForm" type="org.apache.struts.action.DynaActionForm">  
		<form-property name="actionClass" type="java.lang.String"/>
		<form-property name="username" type="java.lang.String"/>
		<form-property name="password" type="java.lang.String"/> 
	</form-bean> 
</form-beans>

动态的ActionForm的使用方法跟普通的ActionForm相同，但是要注意一点。普通的ActionForm对象需要为每个属性提供getter和setter方法，以上面的例子而言，我们需要提供getUsername() 和 setUsername()方法取得和设置username属性，同样地有一对方法用于取得和设置password属性和actionClass属性。

如果使用DynaActionForm，它将属性保存在一个HashMap类对象中，同时提供相应的get(name) 和 set(name)方法，其中参数name是要访问的属性名。例如要访问DynaActionForm中username的值，可以采用类似的代码：

String username = (String)form.get("username")；

由于值存放于一个HashMap对象，所以要记得对get()方法返回的Object对象做强制性类型转换。正是由于这点区别，如果你在Action中非常频繁地使用ActionForm对象，建议还是使用普通的ActionForm对象。

在Struts 1.1中，除了DynaActionForm以外，还提供了表单输入自动验证的功能，在包org.apache.struts.validator中提供了许多有用的类，其中最常见的就是DynaValidatorForm类。

DynaValidatorForm类

DynaValidatorForm是DynaActionForm的子类，它能够提供动态ActionForm和自动表单输入验证的功能。和使用DynaActionForm类似，你必须首先在配置文件中进行配置：

<form-beans>
	<form-bean name="loginForm" type="org.apache.struts.validator.DynaValidatorForm"> 
		<form-property name="actionClass" type="java.lang.String"/>     
		<form-property name="username" type="java.lang.String"/> 
		<form-property name="password" type="java.lang.String"/>  
	</form-bean>
</form-beans>

同时要定义验证的插件：

  <plug-in className="org.apache.struts.validator.ValidatorPlugIn">
	<set-property property="pathnames"  
	value="/WEB-INF/validator-rules.xml,  
	/WEB-INF/validation.xml"/>
  </plug-in>

其中的validator.xml和validator-rules.xml分别表示验证定义和验证规则的内容（可以合并在一起），比如针对上例中的DynaValidatorForm，我们有如下验证定义（validator.xml）：

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE form-validation PUBLIC  
"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.0//EN"  
"http://jakarta.apache.org/commons/dtds/validator_1_0.dtd">
<!--    Validation Rules    $Id: validation.xml-->

<form-validation>  
<!-- ========== Default Language Form Definitions ===================== -->
<formset>  
	<form name="loginForm">     
		<field property="username" depends="required, minlength,maxlength"> 
			<arg0   key="prompt.username"/>          
			<arg1   key="${var:minlength}" name="minlength" resource="false"/>       
			<arg2   key="${var:maxlength}" name="maxlength" resource="false"/>              
			<var>                
				<var-name>maxlength</var-name>    
				<var-value>16</var-value>         
			</var>          
			<var>      
				<var-name>minlength</var-name>     
				<var-value>3</var-value>         
			</var>       
		</field>     
		<field property="password" depends="required, minlength,maxlength" bundle="alternate">          
			<arg0   key="prompt.password"/>   
			<arg1   key="${var:minlength}" name="minlength" resource="false"/>          
			<arg2   key="${var:maxlength}" name="maxlength" resource="false"/>  
			<var>              
				<var-name>maxlength</var-name>     
				<var-value>16</var-value>        
			</var>          
			<var>      
				<var-name>minlength</var-name> 
				<var-value>3</var-value>       
			</var>        
		</field>    
	</form>   
</formset>
</form-validation>

从上述定义中，我们可以看到对于字段username有三项验证：required, minlength, maxlength，意思是该字段不能为空，而且长度在3和16之间。而validator-rules.xml文件则可以采用Struts提供的缺省文件。注意在<form-bean>中定义的form是如何与validation.xml中的form关联起来的。最后，要启动自动验证功能，还需要将Action配置的validate属性设置为true。

<action path="/login"  
type="com.ncu.test.LoginAction"
name="loginForm"          
scope="request"         
input="tile.userLogin"validate="true">

此时，Struts将根据xml配置文件中的定义来检验表单输入，并将不符合要求的错误信息输出到页面。但是你可能会想：这个功能虽然好，可是什么检验都跑到服务器端执行，效率方面和用户易用性方面是不是有些问题？你可能会怀念起那简单的JavaScript客户端验证。

不用担心，在Struts 1.1中也支持JavaScript客户端验证。如果你选择了客户端验证，当某个表单被提交以后，Struts 1.1启动客户端验证，如果浏览器不支持JavaScript验证，则服务器端验证被启动，这种双重验证机制能够最大限度地满足各种开发者的需要。JavaScript验证代码也是在validator-rules.xml文件中定义的。要启动客户端验证，你必须在相应的JSP文件中做如下设置：

1. 为<html:form>增加onsubmit属性
2. 设置Javascript支持

下表中列出了一JSP文件的示例代码，红字部分为Javascript验证所需代码。

<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<table bgcolor="#9AFF9A" cellspacing="0" cellpadding="10" border="1" width="100%">
	<tr>
	<td> 
	<table cellspacing="0" cellpadding="0" border="0" width="100%"> 
	<tr bgcolor="#696969"> 
		<td align="center">     
		<font color="#FFFFFF">Panel 3: Profile</font>  
		</td>
		</tr> 
	<tr>  
		<td><br> 
		<html:errors/>  
		<html:form action="/login.do" focus="username"  onsubmit="return validateLoginForm(this);">  
		<html:hidden property="actionClass"/>   
		<center>      
		<table>      
			<tr>        
			<td>UserName:</td>   
			<td><html:text property="username" size="20"/></td> 
			</tr> 
			<tr>  
			<td>Password:</td>   
			<td><html:password property="password" size="20"/></td>    
			</tr>  
			<tr>  
			<td colspan=2><html:submit property="submitProperty" value="Submit"/></td>     
		</table>   
		</center>  
		</html:form> 
		<html:javascript formName="loginForm" dynamicJavascript="true" staticJavascript="false"/>  
	
	<script language="Javascript1.1" src="staticJavascript.jsp"></script>  
	</td> 
	</tr> 
	</table>
	</td>
	</tr>
</table>

其中onsubmit的值为"return validateLoginForm(this);"，它的语法为：

return validate + struts-config.xml中定义的form-bean名称 + (this);

staticJavascript.jsp的内容为：

<%@ page language="java" %>
<%-- set document type to Javascript (addresses a bug in Netscape according to a web resource --%>
<%@ page contentType="application/x-javascript" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<html:javascript dynamicJavascript="false" staticJavascript="true"/>

如果validator-rules.xml中定义的基本验证功能不能满足你的需求，你可以自己添加所需的验证类型。

Action

我们通过继承Action类来实现具体的执行类。具体Action类的功能一般都在execute（以前是perform方法）方法中完成，其中主要涉及到以下几个方面：

1. 辅助ActionForm进行一些表单数据的检查。
2. 执行必要的业务逻辑，比如存取数据库，调用实体bean等。
3. 更新服务器端的bean数据，后续对象中可能会用到这些数据，比如在JSP中利用bean:write来获得这些数据。
4. 根据处理结果决定程序的去处，并以ActionForward对象的形式返回给ActionServlet。

提示：由于在Action和ActionForm中都可以实现验证方法，那么如何来安排它们之间的分工呢？一般来说，我们秉着MVC分离的原则，也就是视图级的验证工作放在ActionForm来完成，比如输入不能为空，email格式是否正确，利用ValidatorForm可以很轻松地完成这些工作。而与具体业务相关的验证则放入Action中，这样就可以获得最大ActionForm重用性的可能。

前面我们提到过，我们主张将业务逻辑执行分离到单独的JavaBean中，而Action只负责错误处理和流程控制。而且考虑到重用性的原因，在执行业务逻辑的JavaBean中不要引用任何与Web应用相关的对象，比如HttpServletRequest，HttpServletResponse等对象，而应该将其转化为普通的Java对象。关于这一点，可以参考Petstore中WAF框架的实现思路。

此外，你可能还注意到execute与perform的一个区别：execute方法简单地掷出Exception异常，而perform方法则掷出ServletException和IOException异常。这不是说Struts 1.1在异常处理功能方面弱化了，而是为了配合Struts 1.1中一个很好的功能--宣称式异常处理机制。

宣称式异常处理

和EJB中的宣称式事务处理概念类似，宣称式异常处理其实就是可配置的异常处理，你可以在配置文件中指定由谁来处理Action类中掷出的某种异常。你可以按照以下步骤来完成该功能：

1. 实现org.apache.struts.action.ExceptionHandler的子类，覆盖execute方法，在该方法中处理异常并且返回一个ActionForward对象
2. 在配置文件中配置异常处理对象，你可以配置一个全局的处理类或者单独为每个Action配置处理类

下表就定义了一个全局的处理类CustomizedExceptionHandler，它被用来处理所有的异常。

<global-exceptions> 
<exception 
	handler="com.yourcorp.CustomizedExceptionHandler" 
	key="global.error.message" 
	path="/error.jsp"    
	scope="request"    
	type="java.lang.Exception"/>
</global-exceptions>

其中具体的参数含义，可以参考ExceptionHandler.java源文件。

taglib

讲完了模型和控制器，接下来我们要涉及的是视图。视图的角色主要是由JSP来完成，从JSP的规范中可以看出，在视图层可以"折腾"的技术不是很多，主要的就是自定义标记库的应用。Struts 1.1在原有的四个标记库的基础上新增了两个标记库--Tiles和Nested。

其中Tiles除了替代Template的基本模板功能外，还增加了布局定义、虚拟页面定义和动态页面生成等功能。Tiles强大的模板功能能够使页面获得最大的重用性和灵活性，此外可以结合Tiles配置文件中的页面定义和Action的转发逻辑，即你可以将一个Action转发到一个在Tiles配置文件中定义的虚拟页面，从而减少页面的数量。比如，下表中的Action定义了一个转发路径，它的终点是tile.userMain，而后者是你在Tiles配置文件中定义的一个页面。

<!-- ========== Action Mapping Definitions ============================== -->
<action-mappings>  
<!-- Action mapping for profile form --> 
	<action path="/login"   
		type="com.ncu.test.LoginAction"      
		name="loginForm"    
		scope="request"     
		input="tile.userLogin"
		validate="true">     
		<forward name="success" path="tile.userMain"/>   
	</action> 
</action-mappings>

Tiles配置文件：tiles-defs.xml

<!DOCTYPE tiles-definitions PUBLIC 
"-//Apache Software Foundation//DTD Tiles Configuration//EN"       "http://jakarta.apache.org/struts/dtds/tiles-config.dtd">
<tiles-definitions>  
<!-- =======================================================  --> 
<!-- Master definitions                                       -->
<!-- =======================================================  --> 
<!-- Page layout used as root for all pages. --> 

<definition name="rootLayout" path="/tiles-layouts/rootLayout.jsp"> 
	<put name="titleString" value="CHANGE-ME"/>   
	<put name="topMenu" value="/tiles-components/topMenu.jsp"/> 
	<put name="leftMenu" value="/tiles-components/panel1.jsp"/>  
	<put name="body" value="CHANGE-ME"/>   
	<put name="footer" value="/tiles-components/footer.jsp"/> 
</definition> 

<!-- =======================================================  --> 
<!-- Page definitions 					-->  
<!-- =======================================================  --> 

<!-- User Login page --> 
<definition name="tile.userLogin" extends="rootLayout"> 
	<put name="titleString" value="User Login"/>  
	<put name="body" value="/src/userLogin.jsp"/> 
</definition>  
<!-- User Main page --> 
<definition name="tile.userMain" extends="rootLayout"> 
	<put name="titleString" value="User Main"/>  
	<put name="body" value="/src/userMain.jsp"/> 
</definition>
</tiles-definitions>

而Nested标记库的作用是让以上这些基本标记库能够嵌套使用，发挥更大的作用。

Commons Logging 接口

所谓的Commons Logging接口，是指将日志功能的使用与日志具体实现分开，通过配置文件来指定具体使用的日志实现。这样你就可以在Struts 1.1中通过统一的接口来使用日志功能，而不去管具体是利用的哪种日志实现，有点于类似JDBC的功能。Struts 1.1中支持的日志实现包括：Log4J，JDK Logging API， LogKit，NoOpLog和SimpleLog。

你可以按照如下的方式来使用Commons Logging接口（可以参照Struts源文中的许多类实现）：

package com.foo;
// ...
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
//...
	public class Foo {    
	// ...    
	private static Log log = LogFactory.getLog(Foo.class);
	// ...    
	public void setBar(Bar bar) {       
		if (log.isTraceEnabled()) {         
			log.trace("Setting bar to " + bar);   
		}      
	this.bar = bar;   
	}
// ...
}

而开启日志功能最简单的办法就是在WEB-INF/classes目录下添加以下两个文件：

commons-logging.properties文件：

# Note: The Tiles framework now uses the commons-logging package to output different information or debug statements. 
Please refer to this package documentation to enable it. The simplest way to enable logging is to create two files in 
WEB-INF/classes:
# commons-logging.properties
# org.apache.commons.logging.Log=org.apache.commons.logging.impl.SimpleLog
# simplelog.properties
# # Logging detail level,
# # Must be one of ("trace", "debug", "info", "warn", "error", or "fatal").
#org.apache.commons.logging.simplelog.defaultlog=trace
org.apache.commons.logging.Log=org.apache.commons.logging.impl.SimpleLog

simplelog.properties文件：

# Logging detail level,
# Must be one of ("trace", "debug", "info", "warn", "error", or "fatal").
org.apache.commons.logging.simplelog.defaultlog=fatal

这里我们采用的日志实现是SimpleLog，你可以在simplelog.properties文件指定日志明细的级别：trace，debug，info，warn，error和fatal，从trace到fatal错误级别越来越高，同时输出的日志信息也越来越少。而这些级别是和org.apache.commons.logging.log接口中的方法一一对应的。这些级别是向后包含的，也就是前面的级别包含后面级别的信息。

Struts框架的一个主要好处是它提供了对接收到的表单数据进行验证的内置界面。如果有任何验证失败，则应用程序都会重新显示HTML表单，这样就可以改正无效的数据了。如果验证成功，则处理过程会继续进行。Struts框架的简单验证界面会减少与处理数据验证有关的令人头疼的事情，这样你就可以把精力集中到验证代码上，而不是放到捕获数据、重新显示不完整或无效数据的技巧上。

但是，Struts内置的验证界面也有缺点。例如，在整个应用程序中验证代码常常会大量重复，因为许多域需要相同的验证逻辑。对一些相似字段的验证逻辑进行任何修改都要求在几个地方修改代码，还要重新编译受影响的代码。为了解决这个问题并增强Struts验证界面的功能，作为Struts的第三方附加件创建了Validator框架。后来，Validator被集成到核心Struts代码库中，并从Struts中分离出来，现在它是一个独立的Jakarta Commons项目。虽然Validator是一个独立的框架，但它仍能与其他程序封装在一起后提供，并与Struts无缝集成。

Validator概述

没有Validator，你就不得不编写验证表单数据所需的全部代码，并把它放入Form Bean对象的validate( )方法中。对于想在其上进行数据验证的每个Form Bean域来说，都需要编写逻辑代码来实现验证。此外，你还必须编写代码来存储验证失败时的出错消息。

有了Validator，你就不必在Form Bean中编写用于验证或存储错误消息的任何代码。相反，Form Bean提供了Validator的一个ActionForm子类，它提供验证或存储错误消息的功能。

可把Validator框架作为一个可用于Form Bean验证的可插入的验证例行程序系统来进行安装。每个验证例行程序都只是一个Java方法，负责执行特定类型的验证任务，验证可能通过，也可能失败。 默认情况下，Validator与几个有用的验证例行程序封装在一起来提供，这些例行程序能满足大多数情况下的验证要求。但是，如果Validator框架没有提供你需要的验证例行程序，那么你可以自己创建定制的验证例行程序，并将它插入到该框架中。此外，Validator还支持服务器端和客户端（JavaScript）的验证，而Form Bean只提供服务器端验证界面。

Validator使用两个XML配置文件来分别确定安装哪个验证例行程序和如何将它们应用于给定的应用程序。第一个配置文件validator-rules.xml说明应该被插入到框架中的验证例行程序，并提供每个验证的逻辑的名称。validator-rules.xml文件还定义了每个验证例行程序的客户端JavaScript代码。可以配置Validator让它把这个JavaScript代码发送到浏览器上，这样验证就可以在客户端和服务器端进行了。

第二个配置文件validation.xml确定哪个验证例行程序应用到哪个Form Bean。文件中的定义使用struts-config.xml文件给出的Form Bean的逻辑名称以及validator-rules.xml文件给出的验证例行程序的逻辑名称，以便把二者关联起来。

使用Validator框架包括启用Validator插件、配置Validator的两个配置文件，以及创建提供Validator的ActionForm子类的Form Beans。下面详细解释如何配置和使用Validator。

启用Validator插件

虽然Validator框架是与Struts封装在一起提供的，但在默认状况下Validator并不被启用。为了启用Validator，要向你的应用程序的struts-config.xml文件中添加下面的插件定义。

<!-- Validator Configuration -->
<plug-in className="org.apache.struts
.validator.ValidatorPlugIn">
  <set-property property="pathnames"
               value="/WEB-INF/
  validator-rules.xml, /WEB-INF/

  validation.xml"/>
</plug-in>

该定义告诉Struts为你的应用程序加载并初始化Validator插件。在初始化时，该插件装入由路径名属性指定的、用逗号分隔的Validator配置文件清单。每个配置文件的路径应该用与Web应用程序的相关的路径来指定，如前面的例子所示。

请注意，你的应用程序的struts-config.xml文件必须与Struts Configuration Document Type Definition（Struts配置文档类型定义，DTD）一致，后者规定文件中元素出现的顺序。所以，你必须把Validator插件定义放到该文件的适当位置。确保文件中元素适当排列的最简便方法就是使用诸如Struts Console的工具，它自动格式化你的配置文件，以便与DTD保持一致。

配置validator-rules.xml

Validator框架可以设置为可插入系统，其验证例行程序仅仅是插入到该系统中执行具体验证的Java方法。validator-rules.xml文件说明性地插入Validator用于执行验证的验证例行程序中。Struts示例应用程序带有这个文件的预配置拷贝。在大多数情况下，你不必修改这个预配置拷贝，除非你要向该框架中添加自己定制的验证。

清单1 是一个示例validator-rules.xml文件，说明如何将验证例行程序插入到Validator中。validator-rules.xml文件中的每个验证例行程序都有自己的定义，它用validator标记声明，利用name属性为该验证例行程序指定逻辑名，并指定该例行程序的类和方法。该例行程序的逻辑名称供该文件中的其他例行程序以及validation.xml文件中的验证定义用于引用该例行程序。

请注意，validator标记放在javascript的标记中，javascript标记用于定义客户端JavaScript代码，以便在客户端执行与服务器端相同的验证。

提供的验证程序

默认情况下，Validator中包括几个基本验证例行程序，你可以用它们来处理大多数验证问题。这些例行程序具有逻辑名称，如required（用于输入要求的值）、CreditCard（用于输入信用卡号码值）、email（用于输入电子邮件地址值），等等。

创建Form Bean

为了使用Validator，你的应用程序的Form Bean必须归到Validator的ActionForm的某一子类，而不是ActionForm本身。Validator的ActionForm子类提供了ActionForm的validate( )方法（它嵌入到Validator框架中）的实施过程。你不必从头编写验证代码并把它投入validate( )方法中，相反，可以完全忽略该方法，因为Validator为你提供了验证代码。

与Struts提供的核心功能相类似，Validator提供给你两种可供选择的方法来创建Form Bean。 你可以选择的第一种方法就是像下面这样创建一个特定的Form Bean对象：

package com.jamesholmes.minihr;

import org.apache.struts.validator
.ValidatorForm;


public class LogonForm extends ValidatorForm {
  private String username;
  private String password;
  
  public String getUsername() {
    return username;
  }
  
  public void setUsername(String 
username) {
    this.username = username;
  }


  public String getPassword() {
    return password;
  }
public void setPassword(String 
password) {
    this.password = password;
  }
}

这个类与你不是用Validator所创建的类相似，但它提供ValidatorForm而不是ActionForm。这个类也不提供ActionForm的空reset( )和validate( )方法的实施过程，因为ValidatorForm提供了相应过程。

在struts-config.xml文件中配置这个特定Form Bean的方法与配置正则Form Bean的方法相同：

<form-beans>
  <form-bean name="logonForm"
            type="com.jamesholmes
  .minihr.LogonForm"/>
</form-beans>

用表单标记的name属性给特定Form Bean指定的逻辑名是在定义validation.xml文件中的验证时所使用的名称，如下所示：

<!DOCTYPE form-validation 
PUBLIC "-//Apache Software Foundation//
       DTD Commons Validator Rules
       Configuration 1.0//EN"
       "http://jakarta.apache.org/
      commons/dtds/validator_1_0.dtd">


<form-validation>
  <formset>
    <form name="logonForm">
      <field property="username" 
            depends="required">
        <arg0 key="prompt.username"/>
      </field>
    </form>
  </formset>
</form-validation>

Validator使用该表单标记的name属性的值将验证定义与要应用这些定义的Form Bean的名称相匹配。

创建Form Bean时可以选择的第二种方法是在struts-config.xml文件中定义一个动态Form Bean，如下所示：

<form-beans>
  <form-bean name="logonForm"
            type="org.apache
.struts.validator.DynaValidatorForm">
    <form-property name="username"
            type="java.lang.String"/>
    <form-property name="password"
            type="java.lang.String"/>
  </form-bean>
</form-beans>

动态Form Bean不要求创建特定的Form Bean对象；相反，要定义Form Bean应该具有的属性和类型，而Struts为你动态创建Form Bean。 Validator允许你使用这个概念，就像在核心Struts中使用这个概念一样。与使用Validator的惟一区别就是要指定Form Bean是org.apache.struts.validator.DynaValidatorForm类型，而不是org.apache.struts.action.DynaActionForm类型。

分配给动态Form Bean的逻辑名是在定义validation.xml文件中的验证时使用的名称。Validator使用与之相匹配的名称将这些验证与Form Bean联系在一起。

除了创建Form Bean的这两种标准方法之外，Validator还提供了一个高级特性，用于将多个验证定义与一个Form Bean定义联系起来。当你使用基于validatorForm或基于DynaValidatorForm的Form Bean时，Validator使用struts-config.xml文件中的Form Bean的逻辑名称，将Form Bean映射到validation.xml文件中的验证定义。这种机制在大多数情况下非常有用，但在某些时候，Form Bean要在多个操作中共享。 一个操作可能使用Form Bean的所有域（fields），而另一个操作可能只使用这些域的一个子集。因为验证定义被连接到Form Bean，所以只使用域的一个子集的操作就无法绕过对未使用域的验证。当验证Form Bean时，就会对未使用的域生成错误消息，因为Validator无从知道不去验证未使用的域，它只是简单地把它们看作缺失或无效。

为了解决这个问题，Validator提供了两个附加的ActionForm子类，它使你能够将验证与操作相关联，而不是与Form Bean相关联。这样你就可以根据哪个操作正在使用Form Bean来指定把哪些验证用于该Form Bean了。对于特定的Form Bean，你要像下面这样声明org.apache.struts.validator.ValidatorActionForm子类：

public class AddressForm extends ValidatorActionForm {
  ...
}

对于动态Form Bean，在struts-config.xml文件中为Form Bean定义指定org.apache.struts.validator.DynaValidatorActionForm的类型，如下所示：

<form-bean name="addressForm"
          type="org.apache.struts
.validator.DynaValidatorActionForm">
  ...
</form-bean>

在validation.xml文件中，把一组验证映射到一个操作路径，而不是映射到Form Bean名，因为如果你定义了Create Address和Edit Address两个操作（它们使用同一个Form Bean），那么每个操作都会有一个惟一的操作名，如下所示：

<action-mappings>
  <action path="/createAddress"
         type="com.jamesholmes
  .minihr.CreateAddressAction"
         name="addressForm"/>
  <action path="/editAddress"
         type="com.jamesholmes
  .minihr.EditAddressAction"
         name="addressForm"/>

</action-mappings>

下面的validation.xml文件片断显示了两组验证，它们用于同一个Form Bean，但却有不同的操作路径：

<formset>
  <form name="/createAddress">
    <field property="city"
          depends="required">
      <arg0 key="prompt.city"/>
    </field>
  </form>
  <form name="/editAddress">
    <field property="state"
          depends="required">
      <arg0 key="prompt.state"/>
    </field>
  </form>
</formset>

因为Form Bean要么属于ValidatorActionForm子类，要么属于DynaValidatorActionForm子类，所以Validator知道用一个操作路径代替Form Bean的逻辑名称来找出用于Form Bean的验证。

配置validation.xml文件

validation.xml文件用于声明将应用到Form Beans的一组验证。要验证的每个Form Bean在这个文件中都有自己的定义。在这个定义中，指定要应用到该Form Bean的各域的验证。下面是一个validation.xml文件的例子，说明如何定义验证：

<!DOCTYPE form-validation 
PUBLIC "-//Apache Software Foundation//
       DTD Commons Validator Rules
       Configuration 1.0//EN"
       "http://jakarta.apache.org/
      commons/dtds/validator_1_0.dtd">

<form-validation>
  <formset>
    <form name="logonForm">
      <field property="username"
            depends="required">
        <arg0 key="prompt.username"/>

      </field>
      <field property="password"
            depends="required">
        <arg0 key="prompt.password"/>
      </field>
    </form>
  </formset>
</form-validation>

validation.xml文件的第一个元素是form-validation。这个元素是该文件的主元素，而且只定义一次。在form-validation元素内定义form-set元素，它包括多个表单元素。一般来说，在文件中只定义一个form-set元素，但是如果要将验证国际化，那就要在每个地方单独使用一个form-set元素。

每个表单元素使用name属性将名称与其所包含的域验证集关联起来。Validator使用这个逻辑名称将这些验证映射到在struts-config.xml文件中定义的一个Form Bean。根据要验证的Form Bean的类型，Validator力求将该名称与Form Bean的逻辑名称或操作路径相匹配。在表单元素内，field元素定义要应用到Form Bean的特定域的验证。field元素的property属性对应于特定Form Bean中的域名。depends属性利用validator-rules.xml文件指定验证例行程序的逻辑名称，这些例行程序将应用到域验证中。

配置ApplicationResources.properties

Validator使用Struts的资源绑定（Resource Bundle）机制将错误消息具体化。不用在框架中对错误消息进行硬编码，Validator使你能在ApplicationResources.properties文件中为一个消息指定一个键值，如果验证失败则将返回该键值。validator-rules.xml文件中的每个验证例行程序都用validator标记的msg属性指定错误消息的键值，如下所示：

<validator name="required"
          classname="org.apache

.struts.validator.FieldChecks"
          method="validateRequired"
          methodParams="java.lang
.Object, org.apache.commons.validator
.ValidatorAction, org.apache.commons
.validator.Field, org.apache.struts
.action.ActionErrors, javax.servlet
.http.HttpServletRequest"
          msg="errors.required">

如果在验证例行程序运行时验证失败，则返回与msg属性指定的键值对应的消息。

下面的片段显示来自ApplicationResources.properties文件的验证出错时的默认消息集，它们由Struts示例应用程序提供。每个消息的键值对应于每个由validator-rules.xml文件中的验证例行程序所指定的消息，它们由Struts示例应用程序提供。

# Error messages for Validator framework validations
errors.required={0} is required.
errors.minlength={0} cannot be less than {1} characters.
errors.maxlength={0} cannot be greater than {2} characters.
errors.invalid={0} is invalid.
errors.byte={0} must be a byte.
errors.short={0} must be a short.
errors.integer={0} must be an integer.
errors.long={0} must be a long.0.   errors.float={0} must be a float.

errors.double={0} must be a double.
errors.date={0} is not a date.
errors.range={0} is not in the range {1} through {2}.
errors.creditcard={0} is not a valid credit card number.
errors.email={0} is an invalid e-mail address.

请注意，每条消息都有占位符，形式为{0}、{1}或{2}。在运行期间，占位符被另一个值代替，如所验证的域的名称。这一特性特别有用，它使你能够创建可被几个不同的域重复使用的通用验证错误消息。

例如，下面给出required验证的错误消息errors.required：

errors.required={0} is required.

当你使用validation.xml文件中的该required验证时，必须定义用于替换该错误消息中的{0}的值，如下所示：

<form name="auctionForm">
  <field property="bid" depends="required">
    <arg0 key="prompt.bid"/>
  </field>
</form>

错误消息最多可以有4个占位符：{0}和{3}。这些占位符分别称为arg0到arg3，你可以通过使用arg0~arg3标记来指定它们。在上面的例子中，arg0标记指定了用于替换{0}占位符的值。该标记的key属性指定来自ApplicationResources.properties文件的一个消息键值，它的值用于替换占位符，如下所示：

prompt.bid=Auction Bid

使用消息键值代替占位符的值，这一方法使你不必在validation.xml文件中对替换值反复硬编码。但是，如果你不想使用Resource Bundle的键值/值机制来指定占位符的值，则可以使用arg0标记的如下语法显式地指定占位符的值：

<arg0 key="Auction Bid" resource="false"/>

在这个例子中，resource属性的值设为false，以便通知Validator要把该key属性指定的值作为占位符的值，而不要作为ApplicationResources.properties文件中消息的一个键值。

启用客户端验证

Validator除了提供了简化服务器端表单数据验证过程的框架外，它还提供了执行客户端验证时易于使用的方法。在validator-rules.xml文件中定义的每一个验证例行程序都可以随意指定JavaScript代码，这些代码可以在浏览器（客户端上的）中运行，从而执行与服务器端进行的验证相同的验证过程。在客户端进行验证时，除非所有表单都通过验证，否则这些表单不允许被提交。

为了启用客户端验证，必须在每个需要验证的JSP中放上Struts HTML Tag Library（标记库）的javascript标记，如下所示：

<html:javascript formName="logonForm"/>

javascript标记要求使用formName属性来为想要对其执行验证的表单指定validation.xml文件中给出的表单定义名，如下所示：

<form name="logonForm">
  <field property="username"
        depends="required">
    <arg0 key="prompt.username"/>
  </field>
  <field property="password"
        depends="required">
    <arg0 key="prompt.password"/>
  </field>
</form>

为表单定义指定的服务器端的所有验证都将在客户端运行。由于客户端验证用JavaScript执行，所以可以有多种方法不去执行它。要确保验证过程总是能运行，不论你是否选择启用了客户端验证，Validator都在服务器端执行这些验证。

结论

Validator框架针对表单数据的验证提供了可配置的系统，从而为核心Struts框架添加了很多有价值的功能。通过把Validator框架用于你的应用程序，你可以节约时间并简化Struts应用程序的开发过程。

Web应用的发布描述文件:web应用发布描述文件可以在应用开着者,发布者和组装者之间传递配置信息,Web容器在启动的时候从该文件中读取配置信息,根据它来装载和配置web应用.文档类型定义DTD对XML文档的格式做了定义,DTD吧XML文档划分为元素,属性,实体每一种XML文档都有独自的DTD文件.可以从网上下载.元素是web.xml的根元素,其他元素必须嵌入在元素之内.要注意的是子元素也是有顺序的比如必须是首先,然后最后.

为Struts应用配置Web.xml文件:首先最重要的一步是配置ActionServlet,这个用标签的servlet-name属性起一个名字叫action,然后用servlet-class属性指定ActionServlet的类.然后用标签的servlet-name属性指定action,在用url-pattern指定接收范围是*.do的请求.不管应用中包含了多少子应用,都只需要配置一个ActionServlet,类来出来应用中的不同的功能,其实者就是不必要的,因为Servlet本身就是多线程的,而且目前Struts只允许配置一个ActionServlet.声明ActionServlet的初始化参数:的子元素用来配置Servlet的初始化参数.param-name设置config参数名.param-value设置struts-config.xml的路径参数值.

配置欢迎使用清单:如果客户访问Web的时候值是访问了WEB应用的根目录URL.没有具体的指定文件,Web会自动调用Web的欢迎文件.元素来配置的.通过其中的欢迎页面来配置.

配置错误处理:尽管Struts框架功能强大的错误处理机制,但是不能保证处理所有的错误或者异常.当错误发生时,如果框架不能处理这种错误,把错误抛弃给Web容器,在默认的情况下web容器会想客户端返回错误信息.如果想避免让客户看到原始的错误信息,可以在Web应用发布描述文件中配置元素.通过404来定义错误的类型.然后通过要处理错误的JSP页面来对错误进行处理.还可以用来设置异常,然后通过来处理异常的JSP页面来处理异常.

配置Struts标签库:这个就和以前学到的JSP自定义标签类似,配置元素为来配置.这个指定标签库的uri,类似起一个名称.这个是标签库的位置也就是实际所在的路径.通过这样的方法引入一个标签库,然后在前台JSP页面就可以通过自己定义的URI来调用标签.

Struts配置文件:struts-config.xml文件.首先研讨一下org.apache.struts.config包,在struts应用启动的时候会把Struts配置文件信息读取到内存中,并把它们存放在config包中相关的JavaBean类的实例中.包中的每一个类都和struts配置文件中特定的配置元素对应,ModuleConfig在Struts框架中扮演了十分重要的角色,它是整个config包的核心,在Struts运行时来存放整个应用的配置信息.如果有多个子应用都会有一个ModuleConfig对象,它和Struts文件根元素的对应.根元素中包含等元素.

元素:时Struts配置文件的根元素,和它对应的配置类ModuleConfig类,元素有8个子元素.他们的DTD定义是data-sources?form-bean? global-exception?global-forwards?action-mapping?controller?message-resources?plug-in*在Struts配置文件中,必须按照DTD指定的先手顺序来配置元素的各个子元素,如果颠倒了这些子元素的顺序,会产生错误.

元素:用来配置应用所需要的数据源,数据源负责创建和特定的数据库的连接.许多数据源采用连接池的机制实现.以便提高数据库访问的性能.JAVA语言提供了javax.sql.DataSource接口,所有的数据源都必须实现这个接口.许多应用服务器和Web服务器都提供了数据源组件.很多数据库厂商也提供了数据源的实现.元素包含多个子元素永远配置特定的数据源.他们可以包含多个子元素用于设置数据源的各种属性.配置了数据源以后,就可以在Action类中访问数据源,在Action中定义了getDataSource(HttpRequest)方法,用于获取数据源对象的引用.然后可以利用DataSource对象调用getConnection获取一个连接对象对数据库进行操作.在配置文件中声明多个数据源的时候需要为每一个数据源分配唯一的Key值,通过这个来表示特定的数据源.获取特定的数据源的时候可以用dataSource = getDataSource(reqeust,”A”);

元素:用来配置多个ActionForm,包含一个或者N个子元素.每个元素都包含多个属性.className指定和匹配的类.name指定该ActionForm的唯一标识符,这个属性是必须的以后作为引用使用.type指定ActionForm类的完整类名,这个属性也是必须的.注意包名也要加上.是指定动态的Form的元素,以后会深入了解.

元素:用于配置异常处理,元素可以包含一个或者多个元素,用来设置JAVA异常和异常处理类ExceptionHandler之间的映射.className指定和元素对应的配置类,默认的不用动.handler指定异常处理类默认是ExceptionHandler.key指定在本地资源文件中异常的消息Key,path指定当前异常发生的时候转发的路径.scope指定ActionMessages实例存放的范围.type指定需要处理异常类的名字,必须的.bundle指定Resource Bundle.

元素:用来声明全局转发,元素可以有一个或者N个元素组成,用于把一个逻辑名映射到特定的URL,通过这种方法Action类或者JSP页面无需指定URL,只要指定逻辑名称就可以实现请求转发或者重定向.这样可以减少控制组件和视图的聚合.易于维护.className对应的配置类.contextRelative如果为true表示当path属性以/开头的时候,给出的是对应的上下文URL默认是false.name转发路径的逻辑名,必须写.path转发或者重定向的URL,必须写必须是以/开头.redirect设置为true的时候表示执行重定向操作,此项为false的时候,表示执行请求转发操作.重定向与请求转发的区别以后就是重定向是把请求生成应答给客户端然后在重新发送给定向的URL,浏览器地址栏会有显示.而转发就是直接把请求转发给本应用的另一个文件,不生成应答所以客户端IE没显示.

元素:包含一个或者N个元素,描述了从特定的请求路径到响应的Action的映射.在元素中可以包含多个和子元素,他们分别配置局部异常处理和局部转发.attribute设置Action关联的ActionForm在request或者session范围内的key.就是在request或者session共享内的名称.className对应配置元素的类.默认的是ActionMapping.forward指定转发URL路径include指定包含URL路径.input指定包含表单的URL,当表单验证失败的时候发送的URL.name,指定和该Action关联的Form名字.该名字必须是在form-bean中定义过的,可写可不写.path必须/开头的方位Action的路径.parameter指定Action配置参数.在Action的execute()方法中可以调用ActionMapping的getParameter()方法来读取匹配的参数.roles指定允许调用该Action的安全角色,多个角色之间逗号格开.scope指定Form的存在范围.默认是session.tyep指定Action的完整类名.unknown如果是true表示可以处理用户发出的所有的无效的ActionURL默认是false.validate指定是否调用ActionForm的validate方法.

元素:用于配置ActionServlet.buffreSize指定上载文件的输入缓冲大小.该属性为可选默认4096.className指定元素对应的配置类,ControllerConfig.然后是contentType指定响应结果内容类型和字符编码,该属性为可选,默认是text/html如果在Action或者JSP网页也设置了类型内容,会覆盖这个.locale指定是否把Locale对象保存到当前用户的session中默认false.tempDir指定处理文件上载的临时工作目录.nochache如果是true在响应结果中加入特定的头参数.

元素:用来配置Resource Bundle.用于存放本地文本消息文件.className元素对应的配置类.MessageResourcesConfig.factory指定消息的工厂类.key指定文件存放的Servlet对象中采用的属性Key.null指定如何处理未知消息.parameter指定消息的文件名.

元素:用于配置Struts插件.

配置多应用模块:所有的子应用都可以共享同一个ActionServlet实例,但是每个子应用都有单独的配置文件.把应用划分为多个子应用模块.首先为每个应用创建单独的Struts配置文件,在web.xml的ActionServlet配置代码中添加几个子应用信息.采用元素来实现应用之间的切换.

Digester组件:是一个Apache的另一个开源代码项目.当Struts被初始化的时候,首先会读取并解析配置文件,框架采用Digester组件来且西配置文件.然后创建config包中的对象.者对象用于存放配置信息.

其实配置文件不难,只要都理其中的原理就OK了.真正实际的项目开发中,采用的工具例如Eclipse系列,提供了相应的插件,在创建一个Struts工程的时候配置文件的标签都是自动生成的,而我们只需要往里面填写属性就OK了.

1)     HTML文档

2)     JSP客户化标签

3)     JavaScripet和stylesheet

4)     多媒体文件

5)     消息资源(Resource Bundle)

6)     ActionForm Bean

ActionForm属于一种Bean,什么是Bean呢?是可重用的平台独立的JAVA组件,JavaBean

支持属性,事件,方法和持久化.Struts框架仅仅利用了JavaBean的一小部分特性.Bean和普通的JAVA类很相似,不过它应该遵守以下的规范:

1)     必须提供不带参数的构造方法

2)     为Bean的所有属性提供公共的get/set方法

3)     对于boolean类型的属性要提供isXXX()方法,那么该方法返回Boolean类型的属性

4)     对于数组类型的属性,应该提供getXXX(int index)和setXXX(index,value)方法来读取和设置数组元素.

Struts利用JavaBean来创建数据传输对象,Data Transfer Object简称DTO,用于不同的层之间传递数据.

ActionForm是Struts框架提供的DTO,用于在视图层和控制器之间传递HTML表单数据,控制层可以从ActionForm中读取用于输入的表单数据,也可以把来自模型的数据保存到ActionForm中,然后返回给视图.ActionForm具有表单验证的功能.由于ActionForm类使用了ServletAPI,因此不提倡直接把ActionForm传递给模型,而是应该在控制层把它的数据重新组装到自定义的DTO中,在把它传递给模型层.在配置文件中元素的scope属性设置ActionForm的范围默认是session.Action的生命周期如下:

1)     控制器接收到请求

2)     从request或者session范围内取出ActionForm的实例,没有就新建一个

3)     调用Form的reset()方法

4)     把ActionForm实例保存到request或者session范围中

5)     把用户输入的表单数据装到ActionForm中

6)     如果validate属性是true则调用validate方法

7)     验证成功就把ActionForm实例以参数传递给Action的execute方法,如果失败把请求转发给的input属性指定的Web组件(大多JSP),ActionForm依然保存在request或者session范围内.

Struts框架的ActionForm类是抽象类,必须在应用中创建它的子类,来捕获具体的HTML表单数据.其中的属性和表单的属性一一对应.如果配置文件中元素的name属性和元素的name属性匹配,元素中的的validate属性为true.的时候.validate方法会被调用,基类的返回值是null,如果扩展了ActionForm类,那么应该覆盖validate方法,这个方法主要负责检验格式和语法,而不负责检查数据是否符合业务逻辑.对于一个请求控制器首先调用的是ActionForm的reset()方法,然后在把用户输入的表单数据组装到ActionFrom中.这个方法负责恢复属性的默认值,例如把boolean类型的属性设置成true或者false,把字符串设置为null或者某个初始值.感觉如果ActionForm在request范围内,那么对于每个新的请求都会创建新的ActionForm实例,当新的实例创建后,它的属性就是默认值,所以在写reset()方法就没什么意义了.如果是在session范围内,一个实例可以接收多次请求,那么reset()方法就非常有用了!如果是从request或者session范围中取出Form的值,可以用例如Form f=(Form)session.getAttribute(“Form”)的方法取出.这时Form的名字就是共享对象中的一个key不过如果是在Action的execute()方法中就很简单了,可以Form f=(Form)Form这样来获取一个Form也可以通过其中的具体的get方法来获取具体的属性,注意一定要转换类型.有的时候,由于表单的数量太多,无法在同一个页面显示,可以把他们拆分成多个表单,分多个页面显示.在这种情况下,即可以为每一个表单创建一个单独的ActionForm,也可以只创建一个,和多个表单对应.

下面研讨以下如何使用动态的ActionForm,在Struts框架中,ActionForm对象用来包装HTML表单数据,并能够动态返回用于显示给用户的数据.自己写的Form必须符合JavaBean的规范,继承ActionForm同时可以选择的重写reset()和validate()方法.虽然ActionForm简化了Web开发,但是对于大型的项目如果HTML表单改变对应的ActionForm也一定要修改,所以Strust1.1对此做出了修改引入了动态的DynaActionForm类.它支持载配置文件中完成ActionForm的全部配置,没必要写额外的程序来创建具体的ActionForm类,配置动态的方法是在配置文件中一个元素.如下:

type=”org.apache.struts.action.DynaActionForm”

//上面是指定DynaActionForm类,名字是loginForm

元素的子元素来设置动态的ActionForm属性.name指定属性的名称,type指定属性的类型.ActionForm的类型表单的类型.如果要设置JAVA的基本类型,在配置的时候应该用相应的包装类型来替换,例如int的包装类型就是Integer.动态的Form类DynaActionForm提供了initialize()方法,它把调但所有的属性都恢复为默认值.表单属性默认值由元素的子元素的initial属性来决定.如果没设置,则表单的默认属性由其JAVA类型来自动决定.例如对象类型的默认就是null.整型是0.Boolean是false.如果希望Struts每次把表单数据组装到动态的ActionForm之前,先把所有的属性恢复为默认值,可以定义一个DynaActionForm的子类,然后覆盖reset()方法,在其中调用initalize()方法就OK了.

Action类和JSP都可以访问动态的ActionForm类,使用方法与标准的Form大致相同.有一点区别就是如果使用标准的Form类,用get和set方法就可以,而DynaActionForm是把所有的属性保存在一个Map类对象中.访问的方法如下:

public Object get(String name)

public void set(Strig name,Object value)

DynaActionForm基类的validate()方法没有提供任何默认的验证行为,可以定义扩展它的子类,然后覆盖validate()方法,但是以编程的方法来验证动态的ActionForm违背了Struts框架提供的机制.幸运的是,可以采用另一种机制.Validator框架来完成验证,如果想了解Validator验证框架,不要急继续关注我的Blog,我还会漫漫道来.

今天侧重研讨了构成Struts视图组件的ActionForm,因为它非常重要,必须彻底的了解它算能真正的学会Struts,它可以存放在session和request范围内.下面说一些开发技巧希望能对关注我的Blog的朋友们,在如后的开发中有所帮助.

1)     在HTML表单中定义隐藏字段来标示当前页面

2)     在ActionForm中定义page属性,它和表单中的隐藏字段page对应

3)     在ActionForm的reset()方法中,只能把当前表单相关的属性值恢复默认值.

4)     在ActionFomr的validate()方法中,只能对当前表单的相关属性进行验证.

5)     在配置ActionForm和Actin的映射的时候,应该把ActionForm的范围设为session

Struts框架还引入了DynaActionForm类,是动态创建ActionForm的类,要注意的如下:

1)

模型是应用中重要的一部分,它包含了业务实体和业务规则,负责访问和更新持久化数据.应该把所有的模型组件放在系统中的同一个位置,这样利于维护数据和完整性,提高可重用性.模型和视图以及控制器之间保持独立,在分层框架结构中.位于上层的视图和控制器依赖于下层的模型的实现,而下层的模型不应该依赖于上层的视图在控制器的实现.如果在模型组件中通过JAVA的import语句引入了视图和控制器组件,这样的程序就垃圾了.

在科学和工程技术领域,模型是一个很有用途的概念,它可以用来模拟一个真是的系统.在软件开发领域,模型用来表示真是世界的实体.在软件开发的不同阶段,需要为目标系统创建不同的模型.可以采用面向对象的建模语言UML来描述.

在建模之前首先要对问题域进行详细的分析,确定用例,接下来可以根据用例来创建概念模型.概念模型用来模拟问题域中的真实实体.概念模型描述了每个实体的概念和属性,以及实体之间的关系.这个阶段并不描述实体的行为.比如说商品和商品目录之间存在多对多的关系,这是因为一个商品目录包含多个商品,而一个商品也可以属于多个商品目录.

设计模型需要在概念模型的基础上设计.可以用UML类框图,活动图以及状态图来描述设计模型.根据UML语言,类之间存在四种关系:

1)     关联(Association):就是类之间的引用关系,

2)      依赖(Dependency):是指类之间的访问关系.

3)      累积(Aggregation)就是说整体与个体之间的关系,可以把累积看作一种强关联关系.

4)      一般化(Generalization):是类之间的继承关系.

如果想了解如何为应用创建合理的面向对象的设计模型,可以浏览www.uml.org深入了解UML语言.

业务对象BO(Business Object),是对真是世界的实体的软件抽象.它可以代表业务领域中的人,地点,事务或者概念.业务对象包括状态和行为.如果一个类可以作为业务对象它应该具有以下特征:

1)     包含状态和行为.

2)      代表业务领域的人,地点,事务或概念.

3)      可以重用.

业务对象客分为三种类型:

1)     实体业务对象.

2)      过程业务对象.

3)      事件业务对象.

实体对象就是具体的对象,比如人,地点,商品,订单.过程对象就是业务过程或者流程,

他们通常依赖于实体对象.可以把业务领域的动词,比如登陆,发货等作为过程对象.事件对象代表一些时间如比异常,警告,超时,错误.这些事件通常由系统中的行为触发器激活.在应用使用业务对象好处很多,最重要的一点就是业务对象提供了通用的技术术语和概念,不管技术人员还是非技术人员都可以共享理解它们.此外业务对象可以隐藏实现的细节,对外只暴露接口,提高了安全性.

通常,持久化意味着通过手工或者其他方法输入到应用中的数据,能够在应用结束运行后依然存在.即使应用运行结束或者计算机关闭,这些信息依然存在.当应用中的业务对象在内存中创建后,他们不可能永远存在.最后,他们要么消失,要么就要被持久化到数据库中.内存无法永久保留数据,因此必须对业务对象进行持久化.关系型数据库被广泛用来存储数据.关系型数据库中存放的是关系型数据.它是非面向对象的.把业务对象映射到非面向对象的数据库中,因为对象由状态和行为组成,而关系数据库则由表组成.对象之间的各种关系和关系型数据库中表之间的关系并不一一对应.例如对象之间继承关系就不能直接映射到关系型数据库中了.而对于JAVA应用,可以直接通过JDBC编程来访问数据库.JDBC可以说是访问持久化数据层的最原始最直接的方法,如果数据模型非常复杂,这里我推荐用Hibernate架构来进行持久化层的处理.

因为Struts中本身不包含处理模型的架构,所以在这里只是简单的对模型进行了介绍.至于具体的知识可以研究Ejb,JavaBean等技术.至于持久化层的hibernate架构,这里我推荐阅读孙卫琴的:<<精通Hibernate>>.

ActionServlet类:是Struts框架的核心控制器组件,所有的用户请求都先由它来处理,然后再由它把请求转发给其他组件.容器启动的时候或者用户首次请求ActionServlet的时候加载ActionServlet类在这两种情况下,容器都会在ActionServlet被加载后立即执行它的init()方法,这可以保证当ActionServlet处理用户请求的时候已经被初始化.至于具体的初始化方法我们不用去管,下面研究一下ActinServlet的process()方法.当主控制器实例接收到Http请求后,在doGet()或者doPost()方法中都会调用process()方法来处理请求.在这个方法中首先调用selectModule()方法,这个方法选择负责处理用于请求的子应用模块.然后把子应用模块相关的ModuleConfig和MessageResources对象存储到request范围内,这使得框架的其余组件可以方便地从request范围内读取这些对象.从而获取应用配置信息和消息资源.ActionServlet是可以派生子类的但是感觉没什么意义了,多数的功能都被移动到了RequestProcessor类中,以便减轻ActionServlet的负担.

RequestProcessor类:对于应用模块,每个子应用模块都由各自的RequestProcessor实例.在ActionServlet的process()方法中一旦选择了正确的子应用模块,就会调用子应用的模块的RequestProcessor类,每个子应用模块都可以拥有单纯的RequestProcessor类.开发人员可以很方便的创建客户化的RequestProcessor类.

Action类:是用户请求和业务逻辑之间的桥梁,每个Action充当客户的一项业务代理.在RequestProcessor类预处理请求的时候.在创建了Action的实例后,就调用自身的processActionPerForm()方法,该方法调用Action的execute()方法.为了确保线程安全thread-safe,在一个应用的生命周期中.Struts框架只会为每个Action类创建一个Action实例.所有的客户请求共享同一个Action实例.并且所有的请求线程可以执行它的execute方法.Action类的execute()方法返回一个ActionForward对象,代表了Web资源的逻辑对象,这里的Web资源可以是JSP页面,JAVA servlet或者Action.从execute()方法返回的对象有两种方法:创建一个动态的ActionForward实例和在配置文件的action元素里的子元素元素.在execute()方法只需要调用mapping实例参数的findForward()方法,来获得特定的ActionForward对象.元素的roles属性是指定这个Action的用户必须具备的安全角色.多个角色之间以逗号隔开.

利用Token解决重复提交:在某些情况下,如果用户对同一个HTML表单多次提交,Web应用必须能够判断用户的重复提交的行为,以做出相应的处理.可以利用同步令牌Token机制来解决Web应用重复提交的问题.Struts给出了一个参考实例.Action类中提供了一系列和Token相关的方法判断存储在当前用户会话中的令牌值和请求参数中的令牌是否匹配,如果匹配返回true.否则返回false.方法是protected boolean isTokenValid(request).

实用类:RequestUtils类:org.apache.struts.util.RequestUtlis为Struts框架提供了一些处理请求的通用的方法.ModuleUtils类:org.apache.strtus.taglib.ModuleUtils类提供了处理子应用应用模块的实用方法.Globals类:org.apache.struts.Globals类提供了一组公共类型的静态常量.

控制器组件的核心技术可以说就是Servlet,控制器也是Struts的灵魂也是MVC模式的核心,所以如果想学好Struts就必须彻底的了解控制器的运行原理.

      Struts framework主要包括三部分的配置描述，一个是指定有关Struts Controller及其相关的的配置描述（Initialization Parameters），一个是对struts tag lib的描述，一个是Struts组件（ActionMapping，Action，ActionForm）之间相互映射协调的关系

      因为Struts Controller的主要类ActionServlet是继承自HttpServlet，所以必须像配置一个Servlet那样在部署描述符（Web.xml ）中配置ActionServlet类及其访问映射。

   当第一次创建基于Struts的Web应用程序时，将为您创建一个部署描述符，这通常就足够了。该文件包括下列条目：

l、<servlet>条目定义用于Web应用程序的servlet (在本例中，这是唯一的servlet)：

— <servlet-name> 和<servlet-class>指示ActionServlet (标识为“操作”)接收HTTP请求并确定如何响应。

— <init-param>表示servlet初始化参数.

— “config”指示ActionServlet的行为由指定的配置文件来指导，该配置文件通常具有以下名称：

\WEB-INF\struts-config.xml

— “debug”具有整数值，它指示将有关处理的详细信息写至控制台的程度。“0”表示不生成任何Debug信息。

— “detail”具有整数值，它指示将“映射”详细信息(如后面所述)写至控制台的程度。

―  <load-on-startup>导致在启动应用程序时装入servlet。

—  <servlet-mapping>元素标识这样的命名模式：当命名模式由URL进行匹配时，Web服务器就将控制权移交给ActionServlet。考虑下面各种情况：

―  访问了ActionServlet，原因是“操作”(<servlet-mapping>中的<servlet-name>元素的内容)与“操作”(<servlet>中的<servlet-name>元素的内容)相匹配。

— <servlet-mapping>元素指定URL的结尾的命名模式。每个URL的开头都是应用程序上下文路径。按照惯例，ActionServlet调用对象以响应与命名模式“*.do”(其中“*”是通配符)一致的URL。

— <welcome-file-list>元素指示获得初始控制权的特定于应用程序的代码；在本例中，Web服务器直接从Web Content目录中调用index.jsp。

— <error-page>元素指示显示哪个JSP来响应错误;在本例中，错误为如下所示：

―  404  (找不到资源)

―  500  (Web服务器内部发生错误)

      每个<taglib>元素都使相对URL(相对于Web.xml)与标记库描述符(相对于Web应用程序根目录)相关联。每个JSP都可以使用同一个URL来表示给定的标记库，而Web.xml确定引用了哪个文件。

有关struts tag lib的配置描述
    如果你的web application打算使用Struts的taglib，那么你有必要在web.xml中对struts taglib进行配置描述。

有关Struts Action Mapping的配置描述
      作为先前描述的web.xml设置的结果，Web应用程序服务器将请求的一个子集按路径发送至ActionServlet，它通常调用一系列操作和JSP。ActionServlet的响应是基于配置文件struts-config.xml的内容的。有关其DTD文档的描述，请参考这里。

    一般struts-config（version1.1）包含了如下几个部分：

   （1）form-bean

   （2）global-forwards

   （3）action-mappings

   （4）data-sources

      对于这样的一个请求（例如，表示为“/login.do”），Struts框架将会执行下列步骤：

1、    寻找操作类对象（继承org. apache.struts.action.Action的类）
2、    ActionServlet调用操作类对象的执行方法
操作类中的执行方法的特征符为如下所示：
public ActionForward  execute(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response)
    映射对象（ActionMapping），它包含指示如何响应方法的每个可能结果的规则（“映射”）
    Struts表单bean（ActionForm），它保存发送至HTML表单或接收自HTML表单的数据
    请求和响应对象（HttpServletReques/ HttpServletResponse）

3、    从执行方法返回ActionForward对象，用于指导ActionServlet接着访问哪个操作类或JSP
返回的ActionForward对象中的信息取决于两个值：
    方法的结果（如在“成功”或“故障”等字符串中所述）
    映射对象，它包含从Struts配置文件中读取的信息


要弄明白某些运行时关系，要明白struts-config.xml该文件包括下面的一组条目：
    ＜form-beans＞标记标识每个表单bean
    ＜action-mappings＞标记包括用于指导应用程序流的信息，每个＜action＞子标记都使相对URL与操作类和潜在的后续操作相关。
Form-bean元素
Struts配置文件中的一个示例＜form-bean＞子元素为如下所示：
　<form-bean name=“registerForm”  type=“strutscommon.RegisterForm”/>
每个<form-bean>子元素都包括下列属性：
name
表单bean的名称，稍后在配置文件中会用到。ActionServlet举例说明了该bean（如果需要的话）并在将对bean的引用存储在请求或会话对象中时将该名称用作键。
type
　　　　　类的全限定名称，它继承org.apache.struts.action.ActionForm该类必须在类路径中。接受“Struts贸易样本”中的注册的表单bean包括HTML注册表单中每个字段的getter 和setter方法。该bean还包括验证方法，如下节“验证”中所述。
Action元素
   Struts配置文件中的一个示例＜action＞元素为如下所示：
　　<action path=“/register”
        type=“strutsEGL.RegisterAction”
       name=“registerForm”
       input=“/register.jsp”
       scope=“request”
       <forward name=“success”path=“/home.do”/>
       < forward name=“failure”path=“/register.jsp”/>
     </action>
每个＜action＞元素都包括下列属性中的某些属性或所有属性：
 path
     将请求指定为非限定URL，不带文件扩展名（例如，“/register”）请求是根据＜action＞元素中的其它属性来处理的，并且是用户输入的结果或者是在different＜action＞元素中标识的转发的结果。
type
     指定在发出请求时调用其执行方法的操作类的全限定名。该类必须在类路径中。
　　　注：不指定要实例化的类，可以通过使用forward属性来转发请求，该属性在“Struts贸易样本”中未使用，并且与后面描述的＜forward＞子元素不相同。
name
     用于保存发送至HTML表单或接收自HTML表单的数据表单bean的名称。
　　 input
     指定相对URL（例如，“/register.do”或“/index.jsp”）必须包括后缀，
如果表单bean的验证方法指示发生了输入错误，则会调用URL；有关详细信息，参见下节的“验证”。
　　 scope
         指定将对表单 bean的引用存储在哪个作用域中。其值为“会话”（缺省值）或“请求”。
　　　　 Struts配置文件中的每个＜action＞元素还包括子元素＜forward＞，它指定从方法结果至后续调用的映射。每个＜forward＞子元素都包括下列属性
　　name 
指定导致在运行时使用当前映射的字符串（例如，“success”），但是
只限于以下情况：在 type 中引用的操作类的执行方法使用完全相同
的字符串来配置返回至ActionServlet的 ActionForward对象。下面
的执行方法不是很重要，但是会导致使用“success”映射：
  
 public ActionForward exectue(
   ActionMapping mapping,
   ActoinForm form,
   HttpServletRequest request,
   HttpServletResponse response)
   Throws IOException,ServletException
｛
   ActionForward forward=new ActionForward();
   Forward=mapping,findForward(“success”);
   return(forward)；
｝
     path
          指定非限定URL（例如，“/home.do” 或“/index.jsp”）必须包括文件扩展名，仅当使用当前映射时才会调用该URL，转发操作类是根据different<action>元素中的属性来处理的，尤其是，在其path属性标识相同URL的<action>元素中。

    有必要提一下的是，在struts1.1中，提出了对Multiple Application Support。在struts的早先版本中，只有一个struts配置文件，一般叫struts-config.xml。但是，对于越来越复杂的应用系统的发展，只有一个地方存放这个一个文件，对大型项目来说，使用和修改这个配置文件，使其成为了一个应用的瓶颈问题。在struts1.1中，你可以定义多了配置文件协同工作。

预备知识
在开始学习Struts以前，以下的知识点，需要有所了解： 模型-视图-控制的软件构架模式，JSP/Servlet的web层应用，J2EE体系结构。如果对客户标签类（Customer TagLib）有所了解也许更容易理解Struts本身的TagLib。

概述
本文主要从概念上讲解什么是struts framework，它的框架结构，组件结构，以及简单的配置讲解。对于其应用请参考后面的“struts安装及应用”和“struts实用案例分析”。
文章的包括了如下四大部分：
一、 Framework的概念和体系简介 （Framework Conception and Architecture）
二、 Struts的概念和体系结构（Struts Conception and Architecture）
三、 Struts的工作原理和组件（Struts Componennts）
四、 Struts配置文件简介（Struts Deployment Description）

一、 Framework概念
一直以来我们都说struts是一个web framework。那么让我么先来看看什么是Framework。（我想用“框架”一词来翻译framework，可是后来越来越发现不太理想和完备，所以就直接用Framework一词）
Framework概念并不是很新了，伴随着软件开发的发展，在多层的软件开发项目中，可重用、易扩展的，而且是经过良好测试的软件组件，越来越为人们所青睐。这意味着人们可以将充裕的时间用来分析、构建业务逻辑的应用上，而非繁杂的代码工程。于是人们将相同类型问题的解决途径进行抽象，抽取成一个应用框架。这也就是我们所说的Framework。
Framework的体系提供了一套明确机制，从而让开发人员很容易的扩展和控制整个framework开发上的结构。 通常，framework的结构中都有一个“命令和控制”组件（"command and control" component）??Framework Factory and Manager。

图片（2）：Framework体系


通过基于请求响应（Request-Response）模式的应用framework，基本上有如下几个表现逻辑结构组成。
（1）控制器（Controller）??控制整个framework中各个组件的协调工作。
（2）业务逻辑层（Business Logic）??这是framework所希望解决问题的关键。当然对framwork本身来说，这里仅仅只是概念和几个提够服务的基础组件，真正的实现与客户的业务逻辑接轨，还需要开发人员在framework上再次扩展。
（3）数据逻辑层（Data Logic）??绝大应用系统都需要涉及到数据交互，这一层次主要包括了数据逻辑和数据访问接口。对于数据逻辑来说，如果你了解数据建模（Data Modeling）可能就很容易理解。

下面就进入我们的正题??Struts的结构

二、 Struts的概念和体系结构
Struts有一组相互协作的类（组件）、Serlvet以及jsp tag lib组成。基于struts构架的web应用程序基本上符合JSP Model2的设计标准，可以说是MVC设计模式的一种变化类型。根据上面对framework的描述，我们很容易理解为什么说Struts是一个web framwork，而不仅仅是一些标记库的组合。但 Struts 也包含了丰富的标记库和独立于该框架工作的实用程序类。
Struts有其自己的控制器（Controller），同时整合了其他的一些技术去实现模型层（Model）和视图层（View）。在模型层，Struts可以很容易的与数据访问技术相结合，包括EJB,JDBC和Object Relation Bridge。在视图层，Struts能够与JSP, Velocity Templates,XSL等等这些表示层组件想结合。

2.1 Struts的与Web App的关系

既然struts叫做web framework，那么其肯定主要基于web层的应用系统开发。按照J2EE Architecture的标准，struts应当和jsp/servlet一样，存在于web container一层。如图片(3)所显示
图片（3）： Struts与WebApp的关系

2.2 Struts的体系结构
我们说struts framework是MVC 模式的体现，下面我们就从分别从模型、视图、控制来看看struts的体系结构（Architecture）。图片（4）显示了struts framework的体系结构响应客户请求时候，各个部分工作的原理。
图片（4）：Struts体系结构

2.2.1从视图角度（View）
主要由JSP建立，struts自身包含了一组可扩展的自定义标签库（TagLib），可以简化创建用户界面的过程。目前包括：Bean Tags，HTML Tags，Logic Tags，Nested Tags，Template Tags　这几个Taglib。有关它们的详细资料请参考struts用户手册
2.2.2从模型角度（Model）
模型主要是表示一个系统的状态（有时候，改变系统状态的业务逻辑操作也也划分到模型中）。在Struts中，系统的状态主要有ActiomForm Bean体现，一般情况下，这些状态是非持久性的。如果需要将这些状态转化为持久性数据存储，Struts本身也提供了Utitle包，可以方便的与数据库操作
2.2.3 从控制器角度（Controller）
在Struts framework中， Controller主要是ActionServlet，但是对于业务逻辑的操作则主要由Action、ActionMapping、ActionForward这几个组件协调完成（也许这几个组件，应该划分到模型中的业务逻辑一块）。其中，Action扮演了真正的业务逻辑的实现者，而ActionMapping和ActionForward则指定了不同业务逻辑或流程的运行方向。

2.3 Struts的基本组件包
整个struts大约有15包，近200个类所组成，而且数量还在不断的扩展。在此我们不能一一介绍，只能列举几个主要的简要的介绍一下。下表说明了目前struts api中基本的几个组件包，包括action,actions,config,util,taglib,validator。图片（5）则显现了这几个组件包之间的关系。其中action是整个struts framework的核心
org.apache.struts.action
基本上，控制整个struts framework的运行的核心类、组件都在这个包中，比如我们上面提到的控制器ActionServlet。已经Action,ActionForm,ActionMapping等等。struts1.1比1.0多了 DynaActionForm 类。增加了动态扩展生成FormBean功能
org.apache.struts.actions
这个包是主要作用是提供客户的http请求和业务逻辑处理之间的特定适配器转换功能，而1.0版本中的部分动态增删FromBean的类，也在struts1.1中被Action包的DynaActionForm组件所取代
org.apache.struts.config
提供对配置文件struts-config.xml元素的映射。这也是sturts1.1中新增的功能
org.apache.struts.util
Strtuts为了更好支持web application的应用，体统了一个些常用服务的支持，比如Connection Pool和Message Source。详细信息请参考http://jakarta.apache.org/struts/api/org/apache/struts/util/package-summary.html
org.apache.struts.taglib
这不是一个包，而是是一个客户标签类的集合。下面包括Bean Tags，HTML Tags，Logic Tags，Nested Tags，Template Tags这几个用于构建用户界面的标签类。
org.apache.struts.validator
Struts1.1 framework中增加了validator framework，用于动态的配置from表单的验证。详细信息请参阅 http://home.earthlink.net/~dwinterfeldt/








三、 Struts framework的工作原理和组件
对于Struts 如何控制、处理客户请求，让我们通过对struts的四个核心组件介绍来具体说明。这几个组件就是：ActionServlet。Action Classes，Action Mapping（此处包括ActionForward），ActionFrom Bean。
3.1 Struts ActionServlet
ActionServlet继承自javax.servlet.http.HttpServlet类，其在Struts framework中扮演的角色失控制器，参看上面的“Struts体系图”。控制器ActionServlet主要负责将HTTP的客户请求信息组装后，根据配置文件的指定描述，转发到适当的处理器。（在Struts1.1中新增了org.apache.struts.action.Action.RequestProcessor类，将处理请求的功能从控制器功能中分离。
按照Servelt的标准，所有得Servlet必须在web配置文件（web.xml）声明。同样，ActoinServlet必须在Web Application配置文件（web.xml）中描述，有关配置信息，后面将会介绍。

当用户向服务器端提交请求的时候，实际上信息是首先发送到控制器ActionServlet，一旦控制器获得了请求，其就会将请求信息传交给一些辅助类（help classes）处理。这些辅助类知道如何去处理与请求信息所对应的业务操作。在Struts中，这个辅助类就是org.apache.struts.action.Action。通常开发者需要自己继承Aciton类，从而实现自己的Action实例。

3.2 Struts Action Classes
一个Action 类的角色，就像客户请求动作和业务逻辑处理之间的一个适配器（Adaptor），其功能就是将请求与业务逻辑分开。这样的分离，使得客户请求和Action类之间可以有多个点对点的映射。而且Action类通常还提供了其它的辅助功能，比如：认证（authorization）、日志（logging）和数据验证（validation）。
Action最为常用的是execute（）方法。（注意，以前的perform方法在struts1.1中已经不再支持），还有一个execute（）方法，请参考apidoc，在此不在说明。
当Controller收到客户的请求的时候，在将请求转移到一个Action实例时，如果这个实例不存在，控制器会首先创建，然后会调用这个Action实例的execute（）方法。Struts Framework为应用系统中的每一个Action类只创建一个实例。因为所有的用户都使用这一个实例，所以你必须确定你的Action 类运行在一个多线程的环境中。下图显示了一个execute（）方法如何被访问：

图片（6）： Action实例的execute()方法

注意，客户自己继承的Action子类，必须重写execute（）方法，因为Action类在默认情况下是返回null的。


3.3 Struts Action Mapping
上面讲到了一个客户请求是如何被控制器转发和处理的，但是，控制器如何知道什么样的信息转发到什么样的Action类呢？这就需要一些与动作和请求信息相对应的映射配置说明。在struts 中，这些配置映射信息是存储在特定的XML文件（比如struts-config.xml）。
这些配置信息在系统启动的时候被读入内存，供struts framework在运行期间使用。在内存中，每一个<action>元素都与org.apache.struts.action.ActionMapping类的一个实例对应。下表就显示了一个登陆的配置映射。

上面的配置表示：当可以通过/logonAction.do（此处假设配置的控制器映射为*.do）提交请求信息的时候，控制器将信息委托com.test.LogonAction处理。调用LogonAction实例的execute()方法。同时将Mapping实例和所对应的LogonForm Bean信息传入。其中name=LogonForm，使用的form-bean元素所声明的ActionForm Bean。有关form-bean的申明如下显示。

元素<forward>则表示了当Action实例的execute()方法运行完毕或，控制器根据Mapping可将响应信息转到适当的地方。如上面现实，如果客户登陆成功，则调用welcome forward，将成功信息返回到/welcome.jsp页面。在你的execute()方法的结尾可以使用下面的实例代码而返回welcome forward。当然你的welcome forward必须在action元素属性中定义，正如上面所声明的那样。

在此稍稍说一下有关global-forwards的概念。其在配置文件中描述了整个应用系统可以使用的ActionForward，而不是仅仅是一个特定的Action。


3.4 Struts ActionForm Bean
在上面讲解ActionServlet，Action Classes和Action Mapping的时候，我们都提到了ActionForm Bean的概念。一个应用系统的消息转移（或者说状态转移）的非持久性数据存储，是由ActionForm Bean的负责保持的。
ActionForm的主要功能就是为Action的操作提供与客户表单相映射的数据（如果在客户指定的情况下，还包括对数据进行校验）。Action负责对系统数据状态的保持，而Action则负责根据业务逻辑的需要，对数据状态进行修改，在改变系统状态后，ActionForm则自动的回写新的数据状态并保持。
注意：在struts1.1中，ActionForm的校验功能，逐渐被剥离出来（当然依然可以使用）。使用了validator framework对整个应用系统的表单数据验证进行统一管理。相信信息请参考：http://home.earthlink.net/~dwinterfeldt
在ActionForm的使用中，Struts提倡使用到值对象（Value Object）。这样将客户或开发人员，对数据状态与对象状态能够更加清晰的理解和使用。
对于每一个客户请求，Struts framework在处理ActionForm的时候，一般需要经历如下几个步骤：
（１）检查Action的映射，确定Action中已经配置了对ActionForm的映射
（２）根据name属性，查找form bean的配置信息
（３）检查Action的formbean的使用范围，确定在此范围下，是否已经有此form bean的实例。
（４）假如当前范围下，已经存在了此form bean的实例，而是对当前请求来说，是同一种类型的话，那么就重用。
（５）否则，就重新构建一个form bean的实例
（６）form bean的reset()方法备调用
（７）调用对应的setter方法，对状态属性赋值
（８）如果validatede的属性北设置为true，那么就调用form bean的validate()方法。
注意：直接从ActionFrom类继承的reset()和validate()方法，并不能实现什么处理功能，所以有必要自己重新覆盖。
如果validate（）方法没有返回任何错误，控制器将ActionForm作为参数，传给Action实例的execute（）方法并执行。


有必要提一下有关org.apache.struts.action.DynaActionForm。这是struts1.1新增的特性。其继承自ActionForm，在struts早先版本中，我们必须人为的构造特定的ActionFrom子类，但是利用DynaActionForm，可以依据属性集而动态的创建from bean。有关其详细资料，请参考???


四、Struts的其他组件
Struts framework本身提供了很多可扩展的组件或sub framework，方便的开发人员在其构架上构建web层的应用系统。比如upload,collections ,logging等等。让我们来看看两个比较重要的组件：validationg framework和struts taglib。有关其他组件请参考Struts用户手册（http://jakarta.apache.org/struts/userGuide）。
在stuts1.0中有些很不错的概念和组件，比如benaUtils,Collections等等，后来被Jakarta Commons项目组吸收而独立处struts framework。但是struts依然需要依赖这些组件才能正常的工作。
4.1 Validation Framework for Struts
在struts1.1中，新增了validation framework。增加了对form数据提交的验证。将原本需要在ActionFrom Bean的validate（）进行的验证通过配置文件的描述进行验证。
有关其详细信息，请参考http://home.earthlink.net/~dwinterfeldt 。个人建议对于小型应用系统可以采用这种配置方式，但是对于应用系统中有大量web层表单应用的系统，并且业务需求变动比较大的，使用validation framework 可能会加重开发难度、系统维护难度。可以借鉴validation framework的Javascript Validator Tag。

4.2 Struts TagLib
struts提供了一组可扩展的自定义标签库（TagLib），可以简化创建用户界面的过程。目前包括：Bean Tags，HTML Tags，Logic Tags，Nested Tags，Template Tags　这几个Taglib。有关Struts Taglib的结构和使用，可以参考前面有关Cutomer Tag Lib的介绍，有关起详细资料，请参考

4.3 BeanUtils
这个组件的全称是Bean Introspection Utilites。是属于Jakarta Commons项目组的。主要是帮助构建javabean的属性操作的（getter,setter），已经提供一种动态定义和访问bean的属性。有关详细信息，请参考。
http://jakarta.apache.org/commons/beanutils.html
如果各位对这方面有很兴趣，可以参考一些有关java反射（Reflectio）方面的资料。

4．4 Collections
这个组件主要是提供了一些集合或列表对象，在原有的java collections framework的基础上进行了扩展。详细资料请参考：
http://jakarta.apache.org/commons/collections.html 以及
http://cvs.apache.org/viewcvs/~checkout~/jakarta-commons/collections/STATUS.html?rev=1.13

4．5 Digester
这个组件翻译成中文的意思是“汇编”。其主要功能是根据xml配置文件，初始化系统的一些java类对象。Digester帮助你指定XML与java对象之间映射模型，而且允许客户话定制映射规则（rules）。详细资料请参考
http://jakarta.apache.org/commons/digester.html

4．6 其他相关组件
由于篇幅问题，还有一些组件就不一一介绍了，包括Database Connection Pool，Upload，Logging，Pool，Services。基在struts用户手册都有详细介绍，请参考。



五、 Struts配置文件简介（Deployment Description）
struts framework根据配置文件指定（更确切的说，是控制器），才使得ServletAction，ＡctionMapping,Action　,　ActionForm这几个不同层次的组件相互交互，协调的工作。前面也提到了，这些配置文件是在系统启动的时候，读入导内存中，供控制器使用的。
Struts framework主要包括三部分的配置描述，一个是指定有关Struts Controller及其相关的的配置描述（Initialization Parameters），一个时对struts tag lib的描述，一个是struts组件（ＡctionMapping,Action，ActionForm）之间相互映射协调的关系

5.1有关Struts Controller及其相关的的配置描述
因为Struts Controller的主要类ActionServlet是继承自HttpServlet，所以必须像配置一个Servlet那样配置ActionServlet类及其访问映射。详细信息请参考：
http://jakarta.apache.org/struts/userGuide/building_controller.html#dd_config

5.2 有关struts tag lib的配置描述
如果你的web application打算使用Struts的taglib，那么你有必要在web.xml中对struts taglib进行配置描述。有关详细的描述和说明请参考
http://jakarta.apache.org/struts/userGuide/building_controller.html#dd_config_taglib

5.3 有关Struts Action Mapping的配置描述
Struts本身有一个配置文件，通常情况为struts-config.xml。有关其DTD文档的描述，请参考http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd
（或struts-config_1_0.dtd）
一般struts-config（version1.1）包含了如下几个部分：
（1）form-bean
（2）global-forwards
（3）action-mappings
（4）data-sources
有关详细信息请参阅
http://jakarta.apache.org/struts/userGuide/building_controller.html#config

有必要提一下的是，在struts1.1中，提出了对Multiple Application Support。在struts的早先版本中，只有一个struts配置文件，一般叫struts-config.xml。但是，对于越来越复杂的应用系统的发展，只有一个地方存放这个一个文件，对大型项目来说，使用和修改这个配置文件，使其成为了一个应用的瓶颈问题。在struts1.1中，你可以定义多了配置文件协同工作。

总结
希望通过以上的对Struts Framework的讲解，读者可以对Struts的整体结构有个比较清晰的认识，对其如何处理客户请求，如何进行业务逻辑的处理和自动流转能够有个概念上的认识。

Resource
① Struts的官方网站：
http://jakarta.apache.org/struts/
② Struts用户手册（User Guide）
http://jakarta.apache.org/struts/userGuide
③ ARTICLE --- Framework save the day
http://www.javaworld.com/jw-09-2000/jw-0929-ejbframe.html
④ ARTICLE --- Building a Java servlet framework using reflection
http://www.javaworld.com/javaworld/jw-11-1999/jw-11-servlet.html
⑤ Validation Framework
http://home.earthlink.net/~dwinterfeldt/
http://cvs.apache.org/viewcvs/jakarta-commons/validator/
⑥ ARTICLE --- Struts1.1,Should I upgrade?
http://www.theserverside.com/resources/article.jsp?l=Struts1_1 　

本文讨论了Struts框架中Action以及Form Bean之间的不同组合方式以及这些组合的使用。

Full action（一个完整的Action）

This is arguably the most popular form of Struts action. It contains an action class and a form bean. The action mapping for this operation looks like this:

首先这里要讨论的是Struts框架中最常用的组合，即一个Action对应一个Form Bean。这样的对应关系可以用下图来解释：                        

Full action call sequence

• Struts controller component receives a request.
• Struts identifies the action mapping which is responsible for request processing.
• Struts creates a new instance of the form bean, if it was not found in the scope or if the scope has "request" type. If the bean exists in the scope, it is reused.
• If form bean defines reset() method, it is called (1)
• Struts populates the fields with request arguments, using mutators (2)
• Struts calls validate() method if "validate" attribute of action mapping is not set to "false" (3)
• If validate() returns non-empty ActionErrors object, control is forwarded to an URI identified by "input" attribute of the action mapping (4a)
• if validate() returns empty ActionErrors object or null, Struts calls execute() method of the action class (4b)
• execute() method returns an ActionForward object, which is used by Struts to select the destination URI (5)
  
• Struts框架的控制器组件接收到一个Request请求；
• Struts框架通过Action Mapping配置来确定处理这个请求的Action；
• 如果在可见域（scope）内不存在该Action对应的Form Bean或者可见域为Request时，Struts框架创建一个新的（该Action对应的）Form Bean的实例。如果在可见域内存在此Form Bean，则可以重用；
• 如果在Form Bean中定义了reset（）方法，则调用该方法；（１）
• Struts框架以Request域中的变量自动填充Form Bean中的变量，使用mutators；（２）
• 如果配置文件（struts-config.xml）Action-Mapping对应的validate属性被设置为True，那么Struts框架将自动调用validate（）方法；（３）
• 如果Validate（）方法返回一个非空的ActionErrors对象，Struts控制器会将页面导向至配置文件中定义个某个处理错误的页面；
• 如果Validate（）方法返回的ActionErrors对象为空，Struts框架将会自动调用Action的Execute（）方法；（４b）
• Execute（）方法将会返回一个ActionForward的对象，Struts框架会通过这个对象决定页面的转向地址。（５）

Consequences and usage tips

• execute() method of an action class is not called if ActionForm.validate() returns non-empty ActionErrors object. Instead, control is directly routed to the URI defined in "input" attribute of action mapping.
• "input" attribute of action mapping allows forwarding to an URI only. If you need to redirect, use Controller.inputForward property. This property was introduced in Struts 1.1. When it set to "true" it indicates that Action.input is not a URI, but a name of an Action.forward element.
  

• 如果Action对应Form Bean的validate（）方法返回的是一个非空的ActionErrors对象，那么Action的Execute（）方法将不会被调用。此时，Struts框架将直接把页面导向Action Mapping中input属性定义的错误处理页面；
• Action Mapping中“Input”属性指定的仅为一个Form Bean的URL路径。如果需要重定向页面，应当使用Controller.inputForward属性（该属性在Struts1.1版本中引入）。当该属性被设为“True”时，表明Input属性设置的不是URL而是一个Action.forward元素名。

Form-only action

This action combines a custom form bean and the standard ForwardAction class. This type of action can be used when an action has only two outcomes, one of which is an error.

Form-only call sequence

• Struts creates a new instance of the form bean, if it was not found in the scope or if the scope has "request" type. If the bean exists in the scope, it is reused.
• If the form bean defines reset() method, it is called (1)
• Struts populates the fields with request arguments, using mutators (2)
• Struts calls validate() method if "validate" attribute of action mapping is not set to "false" (3)
• If validate() returns non-empty ActionErrors object, control is forwarded to an URI identified by "input" attribute of the action mapping (4a)
• if validate() returns empty ActionErrors object or null, control is forwarded to an URI identified by "parameter" attribute of the action mapping (4b)

Consequences and usage tips

• There is no action class to put business code in, so all custom code must be called from either reset() or validate() methods of the form bean.
• validate() performs two functions: validating request arguments, and accessing the business layer.
• Because action mapping does not contain "forward" elements, control can be only forwarded, but cannot be redirected.
• One of the possible usages of a form-only action is response rendering. A form bean can receive a business object id with a request, then look up the business object in the business/persistence layer, fill in the form fields and forward to a JSP which would display the result.
• It may be convenient to use "session" scope for form-only actions, thus implementing caching of output data.

Action class-only action

Struts does not require to declare a form bean for an action mapping. Hence the seemingly tautological action-only action.

Action-class only call sequence

• execute() is called on the action class (1)
• execute() returns ActionForward object; target URI must be defined in a "forward" element of action mapping (2)

Consequences and usage tips

• This action does not declare a form bean, thus Struts passes null to execute() method instead of a form bean.
• If the action receives request parameters, they must be retrieved from the request object manually. Action class-only action may be used if just a few or no parameters are passed with request, otherwise it is easier to use a form bean.
• Control may be either forwarded or redirected to another action or JSP page. If you are forwarding control to a JSP, make sure that necessary form beans with output data exist in the scope.
• Action-class only action cannot be called from HTML FORM, because Struts expects to find the form bean definition in an action mapping which serves the FORM. As a workaround, you can call an action-class only action from a link.

JSP-only action

This is the most compact, most error-prone and the least useful type of action. It can be used if it is forwarded to from another action, or if there are other means to obtain needed data.

The call chain

• request is received by Struts controller component
• Struts calls ForwardAction.execute()
• ForwardAction.execute() forwards control to an action defined in "parameter" attribute of the action mapping.

Consequences and usage tips

• This action does not use a form bean, thus it is not created, not initialized, not populated and not passed to an action class.
• Though I called it JSP-only operation, it can forward to any URI including other action if needed.
• Because a form bean is not instantiated during the course of this operation, JSP relies on a form bean which was created earlier and is in the scope of the action. Form bean could be created in another action which forwards control to this action, or it could be created with "session" or higher scope during processing of another request.
• Usage of this action is very limited. For example, it can be used as a switching yard to forward to another action. After application is compiled and deployed, the course of operation can be switched in the config file using this action.

Two actions, one form

Struts allows to call one action from another, thus it is possible to implement a simple Chain of Responsibility.

Two-action call sequence and usage tips

The call sequence does not differ from the full-action case. The problem is, that Struts calls reset() and validate() methods again for the target action, and it populates form bean fields as well. To use form bean as a transport/command object we must prevent overwriting of form bean fields.

The solution depends on how the target action is called. If the target action is forwarded to, we can use a token in the HttpRequest object to distinguish if an action is the first action in the chain.

• Check for the token in the reset() method of the form. If token not found, then this action is the first in the chain. If token is found, do not reset form fields, because this is a chained action.
• Plant a token into the request object. This must be done in reset() method, because it is always called unlike validate(). validate() may be not called if "validate" property is set to "false" in struts-config.xml file.
• Verify in each mutator, that the action is first in chain. If not, do not allow changing the field value. This prevents Struts from modifying the form fields. •
• check for token in validate() method. If not present, validate form fields, because this is the first action in chain.

You do not need to remove the token from the request object, the request will be disposed automatically.

If you use redirection to call the target action, you cannot use request token, because request object is recreated after redirection. The following solutions are possible:

• Read action mapping name. This works only if you have strict rules defining when each action is called. If struts-config.xml is changed, the code would have to be updated.
• Store a token on the server in the object with session or higher scope. The token should be promptly removed when the last action in chain finishes.
• Stick a token into the target URI of the response object, it would be passed to a target action as an HTTP request parameter after redirect completes. This solution takes some additional effort, but the result worth it.

Important: use the same form scope in both actions for predictable behavior.

Two actions, two forms

As long as we already have two actions, why not to have two different forms.

Two-action, two form usage tips

The call sequence does not differ from the previous case. But because now we have two different form types and different instances, we can make the code much cleaner.

This design can be used to handle input and output of web applications. The source action receives the request, the source form validates the input data. If input is valid, the control is redirected to output action. Struts would want to populate form bean fields again, but here is the trick: you can either define fields with different names, or even better, you can define only accessors for the output form bean. Struts uses accessors and mutators to operate on form bean fields, so without mutators it would not be able to modify the fields of the output form.

The control flow looks like this:

• Struts calls reset() on the input form bean (1)
• Struts populates the fields of input form bean using mutators (2). Input form bean does not even have to define the accessors.
• truts calls validate() on input form bean, which validates request data (3)
• If validate() returns non-empty ActionErrors object, control is forwarded to an error page identified by "input" attribute of the action mapping (4a)
• if validate() returns empty ActionErrors object or null, Struts calls execute() method of the input action class (4b)
• execute() updates business and persistent objects.
• execute() creates new ActionForward instance with modified URI of the target action, adding to it the ID of an object which must be displayed.
• if execute() returns "OK", Struts redirects to the output action (5)
• Struts calls reset() on the output form bean (6)
• Struts tries to populate the fields of the output form bean, but because there are no mutators defined, they are not changed (7)
• validate() has nothing to validate in the output form, so it returns null (8)
• execute() method of the action class locates business object using ID passed with the request, fills out the fields of the output form with business data and returns "OK" (9b)
• Struts displays the result page (10)

Because I fill out the output form manually with the persistent data, I do not need to preserve values of the input form bean. Thus, I do not need to use forwarding, and I can employ redirection instead. This way, input action and output action become less tied to each other.

A very nice side effect of this solution is that output page can be easily reloaded without processing the request in input action again. This helps to prevent double submission of input data.

More on double submit problem and how it can be defeated see in my other article: Redirect After Post

About the Author

Michael holds an MS in Computer Science from Moscow Aviation Institute (technical university), Moscow, Russia. He has more than 10 years of experience developing applications for MS-DOS, Windows and Java platform. he has devoted the last 5 years to server-side Java applications. Curently he is employed as a software engineer at International Lottery and Totalizator, Inc.

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="/WEB-INF/Struts-bean.tld" prefix="bean" %>
<%@ taglib uri="/WEB-INF/Struts-html.tld" prefix="html" %>
<html:html locale="true">
<head>
<title>RegUser</title>
<html:base/>
</head>
<body bgcolor="white">
<html:errors/>
<html:form action="/regUserAction" focus="logname">
<table border="0" width="100%">
  <tr>
    <th align="right">
      Logname:
    </th>
    <td align="left">
      <html:text property="logname" size="20" maxlength="20"/>
    </td>
  </tr>
  <tr>
    <th align="right">
      Password:
    </th>
    <td align="left">
      <html:password property="password" size="20" maxlength="20"/>
    </td>
  </tr> 
  <tr>
    <th align="right">
      E-mail:
    </th>
    <td align="left">
      <html:password property="email" size="30" maxlength="50"/>
    </td>
  </tr>
  <tr>
    <td align="right">
      <html:submit property="submit" value="Submit"/>
    </td>
    <td align="left">
      <html:reset/>
    </td>
  </tr>
</table>
</html:form>
</body>
</html:html>

上一篇Struts入门经验，我们主要讲述了如何安装Struts以及注册页面：reguser.jsp，本文将主要介绍Struts应用实例、优缺点和实施经验。

Struts-config.xml：

<Struts-config> <form-beans> <form-bean name="regUserForm" type="org.cjea.Struts.example. RegUserForm "/> </form-beans> <action-mappings> <action path="/regUserAction" type=" org.cjea.Struts.example.RegUserAction " attribute=" regUserForm " scope="request" validate="false"> <forward name="failure" path="/ messageFailure.jsp"/> <forward name="success" path="/ messageSuccess.jsp"/> </action> </action-mappings> </Struts-config>

Struts的核心是Controller，即ActionServlet，而ActionServlet的核心就是Struts-config.xml，Struts-config.xml集中了所有页面的导航定义。对于大型的WEB项目，通过此配置文件即可迅速把握其脉络，这不管是对于前期的开发，还是后期的维护或升级都是大有裨益的。掌握Struts-config.xml是掌握Struts的关键所在。

FormBean：RegUserForm

package org.cjea.Struts.example; import javax.Servlet.http.HttpServletRequest; import org.apache.Struts.action.ActionForm; import org.apache.Struts.action.ActionMapping; public final class RegUserForm extends ActionForm{ private String logname; private String password; private String email; public RegUserForm(){ logname = null; password = null; email = null; } public String getLogName() { return this.logname; } public void setLogName(String logname) { this.logname = logname; } public void setPassWord(String password) { this.password = password; } public String getPassWord() { return this.password; } public void setEmail(String email) { this.email = email; } public String getEmail() { return this.email; } public void reset(ActionMapping mapping, HttpServletRequest request) { logname = null; password = null; email = null; } }

每一个FormBean 都必须继承ActionForm类，FormBean是对页面请求的封装。即把HTTP request 封装在一个对象中，需要说明的一点就是多个HTTP request可以共用一个FormBean，便于维护和重用。

ActionBean：RegUserAction package org.cjea.Struts.example; import javax.Servlet.http.*; import org.apache.Struts.action.*; public final class RegUserAction extends Action { public ActionForward perform(ActionMapping mapping, ActionForm form, HttpServletRequest req, HttpServletResponse res) { String title = req.getParameter("title"); String password = req.getParameter("password"); String email = req.getParameter("email"); /* 取得用户请求,做相应数据库操作，略 */ } }

FormBean的产生是为了提供数据给ActionBean，在ActionBean中可以取得FormBean中封装的数据，经相应的逻辑处理后，调用业务方法完成相应业务要求。

Servlet的演变：在常规的 JSP，Servlet，JavaBean三层结构中，JSP实现View的功能，Servlet实现Controller的功能，JavaBean实现Model的实现。

在Struts中，将常规情况下的Servlet拆分与ActionServlet、FormBean、ActionBean三个部分。ActionServlet配合Struts-config.xml，专职完成页面导航，而不再负责具体的数据获取与相应逻辑，这两部分功能由FormBean和ActionBean来完成。

Struts优缺点

优点：

Struts跟Tomcat、Turbine等诸多Apache项目一样，是开源软件，这是它的一大优点。使开发者能更深入的了解其内部实现机制。

除此之外，Struts的优点主要集中体现在两个方面：Taglib和页面导航。Taglib是Struts的标记库，灵活动用，能大大提高开发效率。另外，就目前国内的JSP开发者而言，除了使用JSP自带的常用标记外，很少开发自己的标记，或许Struts是一个很好的起点。

关于页面导航，我认为那将是今后的一个发展方向，事实上，这样做，使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。

缺点：

Taglib是Struts的一大优势，但对于初学者而言，却需要一个持续学习的过程，甚至还会打乱你网页编写的习惯，但是，当你习惯了它时，你会觉得它真的很棒。

Struts将MVC的Controller一分为三，在获得结构更加清晰的同时，也增加了系统的复杂度。

Struts从产生到现在还不到半年，但已逐步越来越多运用于商业软件。虽然它现在还有不少缺点，但它是一种非常优秀的J2EE MVC实现方式，如果你的系统准备采用J2EE MVC架构，那么，不妨考虑一下Struts。

Struts实施经验：

1、基于Struts架构的项目开发，首先需要有一个很好的整体规划，整个系统中包括哪几个模块，每个模块各需要多少FormBean和ActionBean等，而且最好有专人负责Struts-config.xml的管理。开发基于Struts的项目的难点在于配置管理，尤其是对Struts-config.xml的管理

2、如果你的项目非常紧，并且项目组中又没有富有经验的Struts开发人员，建议不要冒然采用Struts。Struts的掌握需要一个过程，对于一个熟练的JSP程序员，自学大概需要半个月左右的时间。如果结合titls，则需要更长的时间

3、如果你在网页中大量运用taglib，那么你的美工将做出部分牺牲。当你结合Tiles，功能增强的同时，这种牺牲尤为明显。当然，你对功能和美观的取舍由你自己决定

4、Taglib是一个好东西，但灵活运用它却需要一个过程，如果你不想在Taglib上花太多的时间，那么只需理解与FORM有关的几个标记，其它的标记就放着吧，以后再看，先去研究ActionServlet和Struts-config.xml，你会觉得很有成就感

5、Struts是否只适合于大型项目呢？No！Struts适合于各种大小的项目，当然，对于大型项目，它所体现出来的优势更加明显

Figure 1. StrutsGUI model. Click on thumbnail to view full-size image.

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!-- Struts Config XML - Sample Struts App -->
<!-- ===================================== -->

<!-- AutoGenerated from : c:\dev\javaworld\app\sample.vsd -->
<!-- AutoGenerated on   : 02-18-2003 23:05:47 -->
<!-- AutoGenerated by   : Struts GUI v2.11   (c)2002 Alien-Factory -->
<!--                    : See 'http://www.alien-factory.co.uk' for details -->

<!-- GET YOUR STICKY FINGERS OFF! i.e. Do not edit. -->

<!DOCTYPE struts-config PUBLIC
      "-//Apache Software Foundation//DTD Struts Configuration 1.0//EN"
      "http://jakarta.apache.org/struts/dtds/struts-config_1_0.dtd">

<struts-config>

  <!-- ====================== Form Bean Definitions =================== -->
  <form-beans>
  </form-beans>

  <!-- ================= Global Forward Definitions =================== -->
  <global-forwards>
  </global-forwards>

  <!-- ======================= Action Definitions ===================== -->
  <action-mappings>
    <action  path="/Login"
             type="com.agilquest.onboard.presentation.actions.LoginAction">
      <description>Authenticates and authorizes a user.</description>
    </action>
  </action-mappings>
  
</struts-config>

public class MenuAction {

  public ActionForward perform(ActionMapping       _mapping,
                               ActionForm          _form,
                               HttpServletRequest  _request,
                               HttpServletResponse _response)
                                  throws IOException, ServletException {

    // Check end-user permissions whether allowed into the requested     
    // functionality 
    checkIfUserAllowedToProceed(_mapping, _form, _request, _response); 

    // Clean up the session object (this logic is in its own method)
    String formName = null; 

    HttpSession session = _request.getSession();
    Enumeration e = session.getAttributeNames();  

    while(e.hasMoreElements()) {
     
      formName = (String)e.nextElement();

      if (formName.endsWith("Form")){
        session.removeAttribute(formName);
      }    
    }

    // Now find out which functionality the end-user wants to go to
    String forwardStr = _request.getParameter("nextFunctionality");

    if (forwardStr != null && forwardStr.trim().length() > 0){
      return _mapping.findForward(forwardStr);
    }
    else {
      return _mapping.findForward("index");
    }
  }  
}

<!-- A generic menu action that forwards the user from one 
     functionality to another functionality (after checking permissions)
-->
<action path="/menuAction"
        type="x.y.z.MenuAction"
        input="/menu.jsp">      
  <forward name="create_reservation" path="/actionResv.do"/> 
  <forward name="index"              path="/menu.jsp"/> 
  <forward name="add_person"         path="/actionPerson.do"/> 
  <forward name="logout"             path="/actionLogout.do"/> 
</action>

<!-- A generic action that forwards request from one JSP page to another JSP page -->
<action path="/forwardAction"
        type="x.y.z.One2OneAction"
        input="/test1.jsp">      
  <forward name="continue"  path="/test2.jsp"/> 
</action>

<!-- A generic action that forwards request from one JSP page to different 
     branches depending on the selected hyperlink, by the end-user
-->
<action path="/branchAction"
         type="x.y.z.One2NAction"
         input="/test1.jsp">      
  <forward name="target1"   path="/test2.jps"/> 
  <forward name="target2"   path="/test3.jsp"/> 
  <forward name="target3"   path="/someAction.do"/> 
</action>

public class N2NAction {

  public ActionForward perform(ActionMapping      _mapping,
                               ActionForm         _form,
                               HttpServletRequest _request,
                               HttpServletResponse _response)
                                  throws IOException, ServletException {

    N2NInterface if = (N2NInterface)_form;

    //Execute some business functionality here
    try{
      //Business logic successful?
               
    }
    catch(Exception e){

      //Indicates failure
      return _mapping.findForward(if.getSource()); 
    }

    //Indicates success
    return _mapping.findForward(if.getDestination());            

  } 

}

<!-- A generic action that forwards request from one JSP page to another JSP page -->
<action  path="/sourceAndDestinationAction"
         type="x.y.z.N2NAction"
         input="/test1.JSP">      
  <forward name="source1"          path="/source1.JSP"/> 
  <forward name="source2"          path="/source2.JSP"/> 
  <forward name="source3"          path="/someAction.do"/> 
  <forward name="destination1"     path="/destination1.JSP"/> 
  <forward name="destination2"     path="/destination1.JSP"/> 
  <forward name="destination3"     path="/destination2.JSP"/>
</action>

   A hyerplink can be something like
   <a href="sourceAndDestinationAction.do?
    source=source1&destination=destination1">click me</a>
   <a href="sourceAndDestinationAction.do?
    source=source2&destination=destination2">click me too</a>

所有的ActionForms 默认地都必须所有这三种关系（通常通过界面）。使用普通的Action 类，你可以自由地在用户界面流程中移动.

目录：
五、Back之痛!
六、你是谁，在这做什么？
七、我们去往何处？
八、犯错乃人之常情...我们不是圣贤
九、测试，就是用户想要的！
十、简化Struts 开发

五、Back之痛!

设计演示层，有一个好方法就是按照功能设计。例如：在一个预订系统中预订的时候，将所有的相关动作类封装到一个包装内如

com.companyname.productname.presentation. reservation.mak

就是一个不错的方法。深度封装也可以应用到ActionForm类中。表格应该处在功能周期的会话期内。这就保证了该完整功能所需的数据放在表格对象本身之内。这样用户就能够前进到功能的任何页面并且找到该页上显示的正确数据。接着用户还能够在最终保存该数据之前更新数值。因此，就会产生一个有趣的两难局面：当用户确认数据、按下浏览器中的Back 按钮、修改并再次提交的话会发生什么事情？例如，在创建了数据库中的预定后，用户返回并试图再次提交同样的数据。演示层必须在应用层有机会抱怨之前先捕捉到这个错误。处理这种情况的方法之一就是在提交之前创建一个令牌，提交之后检查令牌的有效性，并立即修改令牌值——这样用户就不能够再次使用Back 按钮来提交同样的值。

这个方法的弊病之一就是需要管理令牌：例如，如果用户试图保存数据失败了，但是令牌值却已经修改了。如果这样的话，用户就不能够修改数据，和在不重新设置令牌的情况下重新提交。相应的Action 类也不会允许提交。那么到底什么时候才应该重置令牌呢？用户可以遍历六个页面，那么在确认它的修改时就会收到错误，然后定向到六个页面中的任何一个页面。

要管理这个问题，就需要在用户请求一个特别功能时创建一个表格并在会话期内存储一个默认的令牌值。在保存之前，用户可以多次使用Back按钮进行修改。一旦用户提交了这些修改，只有在保存成功之后才能重新设置令牌。如果确认失败，用户可以使用Back 按钮或者前进到产生失败的页面，修改数据然后重新提交数据。一旦确认成功的话，令牌值就会修改。ActionForm 对象本身也可以包含令牌值（令牌值可以通过程序设置）。还有一个方法就是，在第一次提交之后，Submit 按钮就变得无效、不允许用户再次提交直到有事情发生。我们建议每个ActionForm 处理他自己的令牌，应用至多是使用不止一个不同的ActionForm对象来处理一个特殊功能。

要了解另外一个复制表格提交的方法，请参考Romain Guay的 "Java Tip 136: Protect Web Application Control Flow" (JavaWorld, March 2003).

六、你是谁，在这做什么？

企业应用必须设计成能够同时支持多个认证模式。这对于来自ISVs（独立的软件开发商）的软件更为重要。例如，假设一个应用的认证要求是单一登录、询问用户密码、条形码认证或者指纹认证，甚至是将来有可能出现的声音认证。JAAS (Java 认证和授权服务)，这个可插入的认证机制，证明可用于这个方面。默认的， Struts 1.1 支持JAAS。JAAS也可用在具有极好结果的Struts 1.0中。对于认证，一个很好的继承性设计将会推动使用不同的认证动作类，每个动作类都有他自己唯一的Action 映射。这种设计方法将会推动对不同认证的同时支持。如果需要添加新的认证机制，只要用一个支持该认证的Action类在struts-config.xml内创建一个新的动作映射即可。

七、我们去往何处？

流程控制器的设计目的是限制和引导用户通过应用程序，它在保证用户遵循特殊流程方面很实用。让流程控制器以系统的地位为基础证明是有用的。无论用户什么时候试图访问系统中的功能，流程控制器都可以确保用户有权进入到特殊流程中。而且，就算出现了意外情况，用户也能够被引导到恰当的页面。放置流程控制器最好的地方是在超类中。只有在流程控制器满意之后用户才允许执行特定动作。

图 2 给出了一个简单的继承性模型，它可用来使用合并到用户认证中的流程控制器。

Figure 2. Simple authentication class model

article1.CustomerForm
package article1;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionError;
import javax.servlet.http.HttpServletRequest;

public class CustomerForm extends ActionForm {

    protected boolean nullOrBlank (String str) {
        return ((str == null) || (str.length() == 0));
    }
    public  ActionErrors validate(ActionMapping mapping,
            HttpServletRequest request) {
        ActionErrors errors = new ActionErrors();
        if (nullOrBlank(lastName)) {
            errors.add("lastName",
                   new ActionError("article1.lastName.missing"));
        }
        if (nullOrBlank(firstName)) {
            errors.add("firstName",
                   new ActionError("article1.firstName.missing"));
        }
        if (nullOrBlank(street)) {
            errors.add("street",
                   new ActionError("article1.street.missing"));
        }
        if (nullOrBlank(city)) {
            errors.add("city",
                   new ActionError("article1.city.missing"));
        }
        if (nullOrBlank(state)) {
            errors.add("state",
                   new ActionError("article1.state.missing"));
        }
        if (nullOrBlank(postalCode)) {
            errors.add("postalCode",
                   new ActionError("article1.postalCode.missing"));
        }
        if (nullOrBlank(phone)) {
            errors.add("phone",
                   new ActionError("article1.phone.missing"));
        }
        return errors;
    }

    private String lastName;
    private String firstName;
    private String street;
    private String city;
    private String state;
    private String postalCode;
    private String phone;

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getPostalCode() {
        return postalCode;
    }

    public void setPostalCode(String postalCode) {
        this.postalCode = postalCode;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }
}

customer.jsp
<%@ taglib uri="/WEB-INF/c.tld" prefix="c" %>
<%@ taglib prefix="fmt" uri="/WEB-INF/fmt.tld" %>
<%@ taglib uri="/WEB-INF/struts-tiles.tld" prefix="tiles" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>

<head>
<title>Example of a standard Customer form</title>
</head>
<h1>Example of a standard Customer form</h1>
<html:form action="/addCustomer">
Last Name: <html:text property="lastName"/>
<html:errors property="lastName" /><br>
First Name: <html:text property="firstName"/>
<html:errors property="firstName" /><br>
Street Addr: <html:text property="street"/>
<html:errors property="street" /><br>
City: <html:text property="city"/>
<html:errors property="city" /><br>
State: <html:text property="state" maxlength="2" size="2" />
<html:errors property="state" /><br>
Postal Code: <html:text property="postalCode" maxlength="5"
                                              size="5" />
<html:errors property="postalCode" /><br>
Telephone: <html:text property="phone" maxlength="11" size="11" />
<html:errors property="phone" /><br>
<html:submit/>
</html:form>

article1.AddCustomerAction
package article1;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionForm;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletException;
import java.io.IOException;

public class AddCustomerAction extends Action {
    public ActionForward execute(ActionMapping mapping,
                                 ActionForm form,
                                 HttpServletRequest request,
                                 HttpServletResponse response)
    throws ServletException, IOException{
        CustomerForm custForm = (CustomerForm) form;
        System.out.println("lastName   = "
                            + custForm.getLastName());
        System.out.println("firstName  = "
                            + custForm.getFirstName());
        System.out.println("street     = " + custForm.getStreet());
        System.out.println("city       = " + custForm.getCity());
        System.out.println("state      = " + custForm.getState());
        System.out.println("postalCode = "
                            + custForm.getPostalCode());
        System.out.println("phone      = " + custForm.getPhone());

        return mapping.findForward("success");
    }
}

这就是一起绑定的所有东西，他们总是与Struts一起，放在struts-config.xml 文件内:

<struts-config> <form-beans> <form-bean name="customerForm" type="jdj.article1.Customer" /> </form-beans> <action-mappings> <action path="/addCustomer" type="article1.AddCustomerAction" name="customerForm" scope="request" input="/addCustomer.jsp"> <forward name="success" path="/addCustomerSucceeded.jsp" redirect="false" /> </action> </action-mappings> <message-resources parameter="ApplicationResources" /> <plug-in className="org.apache.struts.validator.ValidatorPlugIn"> <set-property value="/WEB-INF/validator-rules.xml" property="pathnames" /> struts-config.xml</plug-in></struts-config> <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd"> <struts-config> <form-beans> <form-bean name="customerForm" type="article1.CustomerForm" /> </form-beans> <action-mappings> <action path="/addCustomer" type="article1.AddCustomerAction" name="customerForm" scope="request" input="/customer.jsp"> <forward name="success" path="/addCustomerSucceeded.jsp" redirect="false" /> </action> </action-mappings> <message-resources parameter="ApplicationResources" /> <plug-in className="org.apache.struts.validator.ValidatorPlugIn"> <set-property value="/WEB-INF/validator-rules.xml" property="pathnames" /> </plug-in> </struts-config>

customerForm链接到刚刚定义的CustomerForm 类上， /addCustomer动作也是定义用来使用该表格和使用article1.AddCustomerAction类来处理请求。

当你将表格放在了你的浏览器上，你需要填写下列空白表格:



如果你提交了无任何实际内容的表格，就会出现下列内容：



当你认真填写了表格并提交后，在你的Web容器日志文件内（在Tomcat 下为catalina.out ）就会出现下列内容：

lastName = Bush firstName = George street = 1600 Pennsylvania Avenue NW city = Washington state = DC postalCode = 20500 phone = 2024561414

至此，这都是人人熟知的Struts。但是，通过使用Struts 1.1的某些新特征，你可以彻底的删除原本需要编写的大量代码。例如: 我们使用Dynaform扩展，就不需要ActionForm类。如果这样的话，我们需要修改struts-config.xml 中的customerForm 的定义，以便使用org.apache.struts.action.DynaActionForm类(为了这篇指南，我们实际上将创建一个新的类和JSP页，这样你就能够比较他们两个)

通过使用DynaActionForm，你获得到form-property XML标记的访问，这个标记允许你直接定义struts-config.xml内表格的属性。它看起来如下：

<form-bean name="dynaCustomerForm" type="org.apache.struts.action.DynaActionForm"> <form-property name="lastName" type="java.lang.String"/> <form-property name="firstName" type="java.lang.String"/> <form-property type="java.lang.String" name="street"/> <form-property name="city" type="java.lang.String"/> <form-property name="state" type="java.lang.String"/> <form-property name="postalCode" type="java.lang.String"/> </form-bean>

这就不需要对JSP页做任何修改；DynaForms的使用对Struts HTML标记库是透明的。你确实需要对Action稍微修改一下，但是，因为你不能够再将传递到execute()方法内的表格直接传递给拥有存取器（用于你的数据的GET和SET方法）的类中。相反，你需要将表格传递给DynaActionForm，并且需要使用普通的get(fieldname)存取器。所以Action的新版本看起来如下：

article1.AddDynaCustomerAction package article1; import org.apache.struts.action.*; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.ServletException; import java.io.IOException; public class AddDynaCustomerAction extends Action { public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{ DynaActionForm custForm = (DynaActionForm) form; System.out.println("lastName = " + custForm.get("lastName")); System.out.println("firstName = " + custForm.get("firstName")); System.out.println("street = " + custForm.get("street")); System.out.println("city = " + custForm.get("city")); System.out.println("state = " + custForm.get("state")); System.out.println("postalCode = " + custForm.get("postalCode")); System.out.println("phone = " + custForm.get("phone")); return mapping.findForward("success"); } }

如你所见，它完全删除了整个类(ActionForm)。但是，我们丧失了其他的功能:校验表格数据的能力。有两个方法可以重新获得这个功能。一个方法就是创建一个类，它产生子类DynaActionForm并且实现validate()方法。在我们的范例中，它看起来如下：

article1.DynaCustomerForm package article1; import org.apache.struts.action.*; import javax.servlet.http.HttpServletRequest; public class DynaCustomerForm extends DynaActionForm { protected boolean nullOrBlank (String str) { return ((str == null) || (str.length() == 0)); } public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) { ActionErrors errors = new ActionErrors(); if (nullOrBlank((String)this.get("lastName"))) { errors.add("lastName", new ActionError("article1.lastName.missing")); } if (nullOrBlank((String)this.get("firstName"))) { errors.add("firstName", new ActionError("article1.firstName.missing")); } if (nullOrBlank((String)this.get("street"))) { errors.add("street", new ActionError("article1.street.missing")); } if (nullOrBlank((String)this.get("city"))) { errors.add("city", new ActionError("article1.city.missing")); } if (nullOrBlank((String)this.get("state"))) { errors.add("state", new ActionError("article1.state.missing")); } if (nullOrBlank((String)this.get("postalCode"))) { errors.add("postalCode", new ActionError("article1.postalCode.missing")); } if (nullOrBlank((String)this.get("phone"))) { errors.add("phone", new ActionError("article1.phone.missing")); } return errors; } }

请再次注意：我们需要使用get()存取器，而不是直接访问实际变量。我们也需要修改struts-config.xml 中表格的定义，以便用这个新类来取代一般的DynaActionForm 类。如果这样的话，就会重新获得校验功能。但是，我们得重新为每个表格定义明确的类。在Struts 1.1下进行校验，我推荐的方法是使用Struts Validator 框架，它将在后续文章中进行说明。

在本系列的下一篇文章中，我们将看到DynaForms 的更高级的用途。特别是，我们将教你如何使用编入索引的属性和beans排列来实现复杂的细节繁琐的表格。

1、前言

STRUTS是标准的"模型2"的WEB应用框架，其中的ActionServlet代表了"模型2"MVC设计模式中的"控制器" 。STRUTS应用程序一般使用JSP代码生成用户界面，这些代码不包括任何商业逻辑，代表了MVC中的”VIEW”部分。需要执行商业逻辑的用户界面中的表单或超链将会由"控制器" ActionServlet接收和处理。在STRUTS中，只有一个ActionServlet实例，这个实例将接收和处理应用中的相关用户交互请求。ActionServlet实例将选择和调用相应的ACTION类来处理商业逻辑。在设计模式上，ACTION类被称为“控制辅助者”，它将修改JavaBeans，这些JavaBeans就是MVC中的” model”部分。本文将分析在STRUTS中进行模块化编程的具体细节。

2、样例描述

我们将作一个模块编程的例子，这个例子包括三个模块，缺省模块、registration模块和approval模块。缺省模块下有资源index.html，我们使用它来连接其它两个模块。registration模块和approval模块的编程类似，都包含一个index.jsp和一个结果jsp：result.jsp。下面是目录结构：



目录结构表明，struts的模块由配置文件、java类(这里者action和form类)和资源文件构成，另外各模块可以共享web.xml，message （这里是applicatonResources.properties）文件。

我们的例子的界面交互图可以表示如下：

缺省模块的index.html包括两个链接，分别连接两个模块的index.jsp资源，registration模块的index.jsp提交后，如果验证失败会重新返回到该模块的index.jsp，否则用资源resultok.jsp显示注册成功的结果。模块approval的index.jsp提交后进入到resultok.jsp的界面，显示批准与否的结果。

我们从应用程序的文件组成和交互两方面的模块情况对我们要实现的例子进行了比较清晰的组织，下面我们讲解如何在struts中实现模块化编程。

3、STRUTS的模块化机制

我们将讲解STRUTS的相关配置，这些配置大部分与模块化编程有关系，有些没关系但对理解STRUTS程序有利。

3.1 ActionServlet参数

ActionServlet有好多参数可供设置，STRUTS在WEB应用部署描述符中定义这些参数：

·Config——逗号相隔的应用上下文相对的配置文件的路径，这些配置文件包含了STRUTS WEB应用的缺省模块的设置。缺省值为 /WEB-INF/struts-config.xml；
·config/${module} -逗号相隔的应用上下文相对的配置文件的路径，这些配置文件包含了STRUTS WEB应用的${module}模块的设置。这个模块的前缀是/${module}，多个config/${module}参数定义了多个STRUTS WEB应用模块；
·convertNull - 如果这个参数的值为 true, 数值型Java 包装类（比如java.lang.Integer）的初始值将会是null，而不是0。缺省值[false]
·rulesets-逗号相隔的附加的org.apache.commons.digester.RuleSet列表，Digester在分析配置文件时，除了针对标准的配置元素的RuleSet之外，还会利用这些对象来分析配置文件，这样提供了一个配置扩展机制。
·validatin - 指示我们是否使用验证型的XML分析器来处理配置文件，缺省值为 [true]

3.2 配置文件

我们说STRUTS针对每个模块可以有一个或多个配置文件，这些配置文件使用XML来书写，下面是标准的配置文件XML的元素解释。

3.2.1 元素 action

这个元素描述了一个ActionMapping 对象，这个对象将用来处理用户针对某个模块相对应的URI 的请求。





3.2.2元素 action-mappings

这个元素描述了一个ActionMapping 对象集，类型是org.apache.struts.action.ActionMapping。与STRUTS的ActionServlet 注册的URL模式匹配的用户请求将具体地被这些ActionMapping 对象处理。子元素定义了各个ActionMapping对象。



3.2.3元素 controller

这个元素描述了一个struts模块运行环境的配置——ControllerConfig bean









3.2.4 元素 data-source

这个元素描述了一个DataSource 对象——JDBC 2.0 标准扩展。这个对象将被保存在应用上下文中，而且可以象JavaBean 一样被设置。



3.2.5 元素 exception

这个元素向struts系统为一个exception类型注册了一个ExceptionHandler。.



3.2.6 元素 form-bean

这个元素定义了一个ActionForm[org.apache.struts.action.ActionForm子类，这个定义被"action"元素所引用。



3.2.7 元素 form-property

这个元素描述了一个配置DynaActionForm 或其子类的JavaBean属性。当这个元素的父元素"form-bean" 的"type" 是 [org.apache.struts.action.DynaActionForm] 或其子类时有效。如果使用了一个定制的DynaActionForm 子类，父元素"form-bean" 的"dynamic"属性必须设为 "true"。



3.2.8 元素 forward

这个元素描述了一个ActionForward 对象，这个对象将被Action的doPerform返回。在代码中一般用一个逻辑名字来引用ActionForward 对象。一个"forward" 可以用来描述全局或局部ActionForwards. 全局的 forwards对模块内所有的Action 对象有效，局部forwards 嵌套在 元素内，只能被相应的ActionMapping 中的Action访问。



3.2.9元素 message-resources



3.2.10元素 plug-in



3.2.11 元素 set-property

 

目录：

4、模块定义
5、模块选择
6、总结



4、模块定义

通过上面对STRUTS的模块化机制的讲解，我们现在可以开始实现我们的模块化例子程序了。

4.1 Actionservlet参数

我们在struts的web.xml中定义模块。下面的代码定义了三个模块：缺省模块，approval和registration模块，前缀分别是””,/approval和/registration。

<web-app> <servlet> <servlet-name>action</servlet-name> <servlet-class>org.apache.struts.action.ActionServlet</servlet-class> <init-param> <param-name>config</param-name> <param-value>/WEB-INF/struts-config.xml</param-value> </init-param> <init-param> <param-name>config/approval</param-name> <param-value>/WEB-INF/struts-config-approval.xml</param-value> </init-param> <init-param> <param-name>config/registration</param-name> <param-value>/WEB-INF/struts-config-registration.xml</param-value> </init-param> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>action</servlet-name> <url-pattern>*.do</url-pattern> </servlet-mapping> </web-app>

这样在初始化actionservlet的过程中，servletcontext的属性中就会有这样的属性键/值关系：

4.2 approval模块配置文件

下面是approval模块的配置文件，定义了form和action，以及相应的forward。

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation// DTD Struts Configuration 1.1//EN" "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd"> <struts-config> <form-beans> <form-bean name="approvalForm" type="com.i505.struts.approval.form.ApprovalForm"> </form-bean> </form-beans> <action-mappings> <action attribute="approvalForm" name="approvalForm" input="/index.jsp" path="/approval" scope="request" type="com.i505.struts.approval.action.ApprovalAction"> <forward name="success" contextRelative="false" path="/resultok.jsp" /> </action> </action-mappings> </struts-config>

4.3 registration模块配置文件

下面是registration模块的配置文件，定义了form和action，以及相应的message-resources和forward。

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation// DTD Struts Configuration 1.1//EN" "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd"> <struts-config> <form-beans> <form-bean name="registrationForm" type="com.i505.struts.registration.form.RegistrationForm" /> </form-beans> <action-mappings> <action attribute="registrationForm" input="/index.jsp" name="registrationForm" path="/registration" type="com.i505.struts.registration.action.RegistrationAction"> <forward name="success" path="/resultok.jsp" /> </action> </action-mappings> <message-resources parameter="com.i505.struts.ApplicationResources"/> </struts-config>

5、模块选择

本节主要讲述struts中如何选择模块，实现模块的真正运作的。

5.1 action的模块选择

当我们在浏览器中使用http://hostaddress/contextpath/module/action.do式样的的url时,actionservlet会根据module选择模块对象，下面是actionservlet处理http请求的代码：

protected void process(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { RequestUtils.selectModule(request, getServletContext());        getRequestProcessor(getModuleConfig(request)).process (request, response); }

RequestUtils.selectModule函数将使用下面的代码把url中的模块前缀（下面代码的prefix将代表上面url式样中的/module）指定的模块对象保存在request属性中，这个模块对象就成了处理这个请求的当前模块对象：

// Expose the resources for this module ModuleConfig config = (ModuleConfig) context.getAttribute(Globals.MODULE_KEY + prefix); if (config != null) { request.setAttribute(Globals.MODULE_KEY, config); } else { request.removeAttribute(Globals.MODULE_KEY); }

5.2 资源的模块化

资源（比如jsp）的模块化是指资源可以按照模块一样来组织，比如approval模块的资源可以放在approval目录下，而registration模块的资源则放在registration目录下，缺省模块的资源放在webroot下。

url访问这些资源很简单,url式样是 http://hostaddress/contextpath/module/xxx.jsp。对于input和forward访问这些资源，我们只需直接写相对于模块路径下的路径，注意它们必须以”/”开头。如果forward是相对servletcontext的，则要加上模块路径。

<action-mappings> <action attribute="registrationForm" input="/index.jsp" name="registrationForm" path="/registration" type="com.i505.struts.registration.action.RegistrationAction"> <forward name="success" path="/resultok.jsp" /> </action> </action-mappings>

5.3 Formtag中表单action url的生成

对于模块编程，struts在formtag的action属性好像有些问题，这些问题出现在struts没有考虑直接访问jsp时的情况。应为forward和直接访问这两种环境是不同的，主要是直接访问这些JSP，request属性中没有模块对象，而forward访问这些jsp时request属性中有模块对象。我们需要修改代码，使得在产生action属性时不受jsp所在环境的影响，也就是我们将在formtag的action属性中指定模块，而不是request中得到模块。下面是registration模块的index.jsp的代码，它的formtag的action属性包括了模块的前缀/registration：

<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean"%> <%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html"%> <head> <title>申请注册</title> <%@ page contentType="text/html;charset=GB2312" %> </head> <body> <html:form action="/registration/registration.do" >       姓名：<html:text property="name" /><html:errors property="name"/><br /><br />       年龄：<html:text property="age" /><html:errors property="age"/><br /><br />       <html:submit /> </html:form> </body> </html>

下面我们来修改struts的相关代码达到这个效果。

5.3.1 Formtag

Formtag的setAction将识别form tag的acton属性的module前缀，并分离出真正的模块相对的action路径，lookup将直接从ServletContext中获取模块配置对象。

private String getActionPath(String action) {             String temp = action.trim();             String x;              int pos=0;             if(!temp.startsWith("/")) temp = "/"+ temp;             pos = temp.indexOf("/", 1);             if(pos<=0) return action;                          return temp.substring(pos);      } private String getModulePrefix(String action) {             String result;             int pos;             String temp=action.trim();             if(!temp.startsWith("/")) {                   temp= "/"+temp;             }             pos = temp.indexOf("/", 1);             if(pos<=1) return "";             else              return temp.substring(0, pos);                   } public void setAction(String action) {this.modulePrefix = this.getModulePrefix(action);             this.action = this.getActionPath(action); } protected void lookup() throws JspException {             //我们直接从ServletContext中获取模块配置对象                   moduleConfig = (ModuleConfig) pageContext.getServletContext().getAttribute(Globals.MODULE_KEY + modulePrefix);       …} rotected String renderFormStartElement() { HttpServletResponse response = (HttpServletResponse) this.pageContext.getResponse(); StringBuffer results = new StringBuffer("<form"); results.append(" name=\""); results.append(beanName); results.append("\""); results.append(" method=\""); results.append(method == null ? "post" : method); results.append("\" action=\""); //我们的action已经去掉了modulePrefix，所以我们得重新加上 results.append( response.encodeURL( RequestUtils.getActionMappingURL(this.modulePrefix+ this.action, this.pageContext))); … }

5.3.2 Requestutils

Requestutils的getActionMappingURL主要用作附加servletcontext 路径，因为我们现在在action参数附加了modulePrefix路径，所以没必要再追加模块前缀。

public static String getActionMappingURL(String action, PageContext pageContext) { HttpServletRequest request = (HttpServletRequest) pageContext.getRequest(); StringBuffer value = new StringBuffer(request.getContextPath()); ModuleConfig config = (ModuleConfig) pageContext.getRequest().getAttribute(Globals.MODULE_KEY); //我们jsp中的formtag的action属性已经表示了模块，所以我们不能再追加模块名// if (config != null) { // value.append(config.getPrefix()); // } // Use our servlet mapping, if one is specified String servletMapping = (String) pageContext.getAttribute(Globals.SERVLET_KEY, PageContext.APPLICATION_SCOPE); if (servletMapping != null) { String queryString = null; int question = action.indexOf("?"); if (question >= 0) { queryString = action.substring(question); } String actionMapping = getActionMappingName(action); if (servletMapping.startsWith("*.")) { value.append(actionMapping); value.append(servletMapping.substring(1)); } else if (servletMapping.endsWith("/*")) { value.append(servletMapping.substring(0, servletMapping.length() - 2)); value.append(actionMapping); } else if (servletMapping.equals("/")) { value.append(actionMapping); } if (queryString != null) { value.append(queryString); } } else { if (!action.startsWith("/")) { value.append("/"); } value.append(action); } // Return the completed value return (value.toString()); }

6、总结

模块化编程有利于提高编程效率，但是struts中的模块化支持有些小问题，本文详细分析了struts支持模块化编程的机制，并作了些修改，希望对大家有帮助。另外如果我们可以把其改进为模块化的相关的东西可以打成一个包进行动态部署（比如approval.mar）的话，那将会更加有用。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" 
                               "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">
<struts-config>
    <form-beans>
        <form-bean name="dynamicArrayForm" type="org.apache.struts.validator.DynaValidatorForm">
            <form-property name="people" type="demo.Person[]"/>
        </form-bean>
    </form-beans>


<action-mappings>
    <action path="/setupForm" type="demo.SetupFormAction" name="dynamicArrayForm" scope="session"
 
     validate="false">
        <forward name="success" path="/displayForm.jsp"/>
    </action>
    
<action path="/processActorComments"
type="demo.ProcessFormAction"
        name="dynamicArrayForm" scope="session" 
validate="false">
        <forward name="success" path="/displayForm.jsp"/>
    </action>
</action-mappings>
</struts-config>

package demo;

/**
 *  Copyright 2004, James M. Turner.
 * All Rights Reserved
 *
 * A Struts action that sets up a DynaForm which is globally scoped
 */

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.*;

import org.apache.struts.action.*;
import org.apache.struts.validator.DynaValidatorForm;

public class SetupFormAction extends Action {
    public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                                 HttpServletResponse response)
            throws ServletException, IOException {

        DynaValidatorForm df = (DynaValidatorForm) form;
        Person[] p = new Person[3];
        p[0] = new Person();
        p[0].setDateOfBirth("07/13/1942");
        p[0].setLastName("Ford");
        p[0].setFirstName("Harrison");
        p[0].setGender("M");
        p[1] = new Person();
        p[1].setDateOfBirth("10/21/1956");
        p[1].setLastName("Fisher");
        p[1].setFirstName("Carrie");
        p[1].setGender("F");
        p[2] = new Person();
        p[2].setDateOfBirth("09/25/1951");
        p[2].setLastName("Hamill");
        p[2].setFirstName("Mark");
        p[2].setGender("M");

        df.set("people", p);

        return mapping.findForward("success");
    }
}

<!--
    Copyright 2004, James M Turner.
    All Rights Reserved
    
    -->

<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/c.tld" prefix="c" %>

<head>
<title>Star Wars Actor Fact Page</title>
</head>
<H1><center>Start Wars Actor Fact Page</title>
<html:form action="/processActorComments" >
    <table border="1" width="80%">
        <tr><th>Last Name</th><th>First Name</th><th>Date of Birth</th><th>Comment</th></tr>
        <c:forEach var="people" items="${dynamicArrayForm.map.people}">
            <tr><td><c:out value="${people.lastName}"/></td>
                <td><c:out value="${people.firstName}"/></td>
                <td><c:out value="${people.dateOfBirth}"/></td>
                <td><html:text name="people" indexed="true" property="comment"/></td>
            </tr>
        </c:forEach>
    </table>
    <P/>
    <html:submit value="Update Comments"/> 
</html:form>

package demo;

/**
 *  Copyright 2004, James M. Turner.
 * All Rights Reserved
 *
 * A Struts action that sends the new comments to the console
 */

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.*;

import org.apache.struts.action.*;
import org.apache.struts.validator.DynaValidatorForm;

public class ProcessFormAction extends Action {
    public ActionForward execute(ActionMapping mapping, 
ActionForm form, 
HttpServletRequest request,
                                 HttpServletResponse response)
            throws ServletException, IOException {

        DynaValidatorForm df = (DynaValidatorForm) form;
        Person[] p = (Person[]) df.get("people");

        for (int i = 0; i < p.length; i++) {
            System.out.println(p[i].getFirstName() + " " + p[i].
getLastName() + ":" + p[i].getComment());
        }

        return mapping.findForward("success");
    }
}

Harrison Ford:Indiana Jones
Carrie Fisher:Postcards from the Edge
Mark Hamill:Wing Commander

<form-bean name="dynamicHashmapForm" type="org.apache.struts.validator.DynaValidatorForm">
            <form-property name="people" type="java.util.HashMap"/>
            <form-property name="comments" type="java.util.HashMap"/>
        </form-bean>

package demo;

/**
 *  Copyright 2004, James M. Turner.
 * All Rights Reserved
 *
 * A Struts action that sets up a DynaForm which is globally scoped
 */

import java.io.IOException;
import java.util.HashMap;
import javax.servlet.ServletException;
import javax.servlet.http.*;

import org.apache.struts.action.*;
import org.apache.struts.validator.DynaValidatorForm;

public class SetupHashFormAction extends Action {
    public ActionForward execute(ActionMapping mapping, 
ActionForm form, HttpServletRequest request,
                                 HttpServletResponse response)
            throws ServletException, IOException {

        DynaValidatorForm df = (DynaValidatorForm) form;
        HashMap hm = (HashMap) df.get("people");
        Person p = new Person();
        p = new Person();
        p.setDateOfBirth("07/13/1942");
        p.setLastName("Ford");
        p.setFirstName("Harrison");
        p.setGender("M");
        hm.put("1", p);
        p = new Person();
        p.setDateOfBirth("10/21/1956");
        p.setLastName("Fisher");
        p.setFirstName("Carrie");
        p.setGender("F");
        hm.put("2", p);
        p = new Person();
        p.setDateOfBirth("09/25/1951");
        p.setLastName("Hamill");
        p.setFirstName("Mark");
        p.setGender("M");
        hm.put("3", p);
        return mapping.findForward("success");
    }
}

<!--
    Copyright 2004, James M Turner.
    All Rights Reserved
    
    -->

<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-html-el.tld" prefix="html-el" %>
<%@ taglib uri="/WEB-INF/struts-tiles.tld" prefix="tiles" %>
<%@ taglib uri="/WEB-INF/c.tld" prefix="c" %>
<%@ taglib prefix="fmt" uri="/WEB-INF/fmt.tld" %>

<head>
<title>Star Wars Actor Fact Page</title>
</head>
<H1><center>Start Wars Actor Fact Page</title>
<html:form action="/processHashActorComments" >
    <table border="1" width="80%">
        <tr><th>Last Name</th><th>First Name</th>
<th>Date of Birth</th><th>Comment</th></tr>
        <c:forEach var="people" items="${dynamicHashmapForm.map.people}">
            <tr><td><c:out value="${people.value.lastName}"/></td>
                <td><c:out value="${people.value.firstName}"/></td>
                <td><c:out value="${people.value.dateOfBirth}"/></td>
                <td><html-el:text property="comments(${people.value.lastName},
${people.value.firstName})" /></td>
            </tr>
        </c:forEach>
    </table>
    <P/>
    <html:submit value="Update Comments"/> 
</html:form>

package demo;

/**
 *  Copyright 2004, James M. Turner.
 * All Rights Reserved
 *
 * A Struts action that sends the new comments to the console
 */

import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import javax.servlet.ServletException;
import javax.servlet.http.*;

import org.apache.struts.action.*;
import org.apache.struts.validator.DynaValidatorForm;

public class ProcessHashFormAction extends Action {
    public ActionForward execute(ActionMapping mapping, 
ActionForm form, HttpServletRequest request,
                                 HttpServletResponse response)
            throws ServletException, IOException {

        DynaValidatorForm df = (DynaValidatorForm) form;
        HashMap hm = (HashMap) df.get("comments");

        Iterator it = hm.keySet().iterator();
        while (it.hasNext()) {
            String key = (String) it.next();
            String comment = (String) hm.get(key);
            System.out.println(key + ":" + comment);
        }

        return mapping.findForward("success");
    }
}

同样，这里最大的差别是数据都是作为HashMaps 来存储的。代码获取关键字(lastname,firstname)，然后显示关键字和在控制台注释:

Fisher,Carrie:Leia
Ford,Harrison:Han
Hamill,Mark:Luke

请注意，当控制返回到JSP页时，打印一个空白表格。这是因为我们在初始化操作中创建的HashMap 已经没有了，在处理结果时我们不能重新创建它。你可以将该数据保存在会话期变量中，但是接着你要返回到你使用第一个方案的地方。最好是选择一个关键字，在表格提交时它可以允许你在后台对象上获得，并且能够总是重新创建需要的任何其他的表格数据。
哪种方式更好？基于排列的方案允许你将所有的数据都保存在一个bean 内，而基于堆栈的方法避免了任何会话期范围的数据。你觉得哪种方案最好就采用哪种。
注意：包含运行这些例子所需的所有代码和库的WAR 文件在http://www.blackbear.com/struts.war.上可以找到。

Connection conn=DriverManager.getConnection("JDBC URL ");
      sql=" select *  from some tables ";
PreparedStatement stmt = conn.prepareStatement(sql);
      ResultSet rs = stmt.executeQuery();
ArrayList array=new ArrayList();
while (rs.next()) {
   AActionForm actionForm =new AActionForm ();
   actionForm.setId(rs.getString("Id"));
   actionForm.setName(rs.getString("Name"));           
   array.add(actionForm);
}

<logic:present name=" array " scope="request">
<logic:iterate name=" array " id=" array " 
type="com.bhsky.webis.Goods">
       <tr align="center"> 
          <td class="table2">
<bean:write name=" array " property="goodsid"/>
</td>
            <td class="table2">
<bean:write name=" array " property="goodsname"/>
</td>
        </tr>
  </logic:iterate> 
</logic:present>

三、如何应用类反射机制简化Struts应用程序的开发:





1、 先定义Action FormBean:

package com.bhsky.webis.system; import org.apache.struts.action.*; import javax.servlet.http.*; public class UsersActionForm extends ActionForm { private String usr_id; private String usr_name; public void setUsr_id(String usr_id) { this.usr_id = usr_id; } public String getUsr_id() { return usr_id; } public String getUsr_memo() { return usr_memo; } public void setUsr_name(String usr_name) { this.usr_name = usr_name; } }

2、 编写通用的为ActionFormBean赋值的方法：

///////////////////////////////////////////////////////////////////////////// //Function: 完成ResultSet对象向ArrayList对象为集合的对象的转化 //Para:sql,指定的查询Sql //Para:className,Sql相对应得JavaBean/FormBean类的名字 //Return:以类className为一条记录的结果集，完成ResultSet对象向ArrayList对象为集 //合的className对象的转化 ////////////////////////////////////////////////////////////////////////////// public ArrayList Select(String sql,String className){ ArrayList paraList=new ArrayList(); try{ if (conn == null){ Connection(); } PreparedStatement stmt = conn.prepareStatement(sql); ResultSet rs = stmt.executeQuery(); String recordValue=""; Object c1=null; paraList=new ArrayList(); ResultSetMetaData rsmd = rs.getMetaData(); int columnCount = rsmd.getColumnCount(); while (rs.next()){ c1=Class.forName(className).newInstance(); for (int i=1; i<=columnCount; i++) { if(rs.getString(rsmd.getColumnName(i))!=null){ recordValue=rs.getString(rsmd.getColumnName(i)); }else{ recordValue=""; } Method m=c1.getClass().getMethod(getSetMethodName(rsmd.getColumnName(i)), new Class[]{recordValue.getClass()}); m.invoke (c1, new Object[]{recordValue}); } paraList.add(c1); } }catch(SQLException ex){ }catch(ClassNotFoundException e){ }catch(NoSuchMethodException e) { }catch(InvocationTargetException e){ }catch (IllegalAccessException e){ }catch(InstantiationException e){ } finaly{ closeConnection(); return paraList; } }

3、 在JavaBean封装的商业逻辑中调用Select 方法，然后在JSP页面上显示出来：

//Function:取得用户列表 //Para: //Return:返回用户列表 ///////////////////////////////////////////////////////////////////////////// public ArrayList getUsers(){ ArrayList ret=null; DatabaseManage db=new DatabaseManage(); String sql=" select usr_id,usr_name " +" from users " ; ret=db.Select(sql," com.bhsky. webis.system.UsersActionForm"); return ret; }

4、 在Action的execute方法中调用getUsers()方法：

public ActionForward execute( ActionMapping actionMapping, ActionForm actionForm, HttpServletRequest request, HttpServletResponse httpServletResponse) { /**@todo: complete the business logic here, this is just a skeleton.*/ UsersActionForm uaf=(UsersActionForm)actionForm; SystemService ubb=new SystemService(); ArrayList userList=ubb.getUsers(); request.setAttribute("userList",userList); ActionForward actionForward=actionMapping.findForward(url); return actionForward; }

5、 在JSP中显示：

<table width="700" class="1" border="1" cellspacing="1" align="center"> <tr> <td class="list" >用户ID</td> <td class="list" >姓 名</td> </tr> <logic:present name="userList" scope="request"> <logic:iterate name="userList" id="userList" type="com.bhsky.webis.system.UsersActionForm"> <tr> <td class="cell1" height="22"><bean:write name="userList" property="usr_id"/></td> <td class="cell1" height="22"><bean:write name="userList" property="usr_name"/></td> </tr> </logic:iterate> </logic:present> </table>

四、结语：

我们通过运用类反射机制，在一个Struts应用开发中，完成了一个通用查询方法的实现。它使得程序员摆脱了在每个应用程序中都要编写枯燥的set、get等方法来访问ActionForm Bean,从而简化了Struts应用程序的开发。

理论上，商务罗基层应该包含数据链接的描述，包括数据库链接。但是一些早期的程序员习惯于在调用(caller)中包含数据库链接或者数据源实例。当你需要使用继承的设计时，struts数据源管理器可以在你使你的action类能够在你需要的时候生成这样的数据源。

注意：默认情况下数据库链接是直接由商务逻辑的类来控制的，一般通过JNDI。struts数据源管理器应当仅由那些没有独立数据链接的业务逻辑的类继承得到。如果可能，极力推荐使用标准的DAO模式，这样业务逻辑层不需要知道任何数据库的细节。数据源管理器在struts1.x中仍然保留并向下兼容，但是在后续版本中可能不再被支持。

这还不是问题的关键，如果要用数据库管理器，需要手动下载dbcp's BasicDataSource Commons DBCP.

并且1.2版本之后为了更好的配合BasicDataSource插件和别的数据库的执行，先前版本的struts通用数据源被移除了，这就是为什么1.2的lib里面没有struts-legacy.jar这个文件的原因了。

以下是我成功的配置信息：

          property="driverClassName"
      value="com.mysql.jdbc.Driver" />
          property="url"
      value="jdbc:mysql://localhost:3306/mysql?useUnicode=true&characterEncoding=UTF-8" />
          property="username"
      value="root" />
          property="password"
      value="yourpass" />
          property="maxActive"
      value="10" />
          property="maxWait"
      value="5000" />
          property="defaultAutoCommit"
      value="false" />
          property="defaultReadOnly"
      value="false" />
          property="validationQuery"
      value="SELECT COUNT(*) FROM db" />


最后面那一行不是必需的，但是如果写上的话返回的结果及至少要有一条记录！

mysql的jdbc也可以写成org.gjt.mm.mysql.Driver这样子。

理论上，商务罗基层应该包含数据链接的描述，包括数据库链接。但是一些早期的程序员习惯于在调用(caller)中包含数据库链接或者数据源实例。当你需要使用继承的设计时，struts数据源管理器可以在你使你的action类能够在你需要的时候生成这样的数据源。

注意：默认情况下数据库链接是直接由商务逻辑的类来控制的，一般通过JNDI。struts数据源管理器应当仅由那些没有独立数据链接的业务逻辑的类继承得到。如果可能，极力推荐使用标准的DAO模式，这样业务逻辑层不需要知道任何数据库的细节。数据源管理器在struts1.x中仍然保留并向下兼容，但是在后续版本中可能不再被支持。

这还不是问题的关键，如果要用数据库管理器，需要手动下载dbcp's BasicDataSource Commons DBCP.

并且1.2版本之后为了更好的配合BasicDataSource插件和别的数据库的执行，先前版本的struts通用数据源被移除了，这就是为什么1.2的lib里面没有struts-legacy.jar这个文件的原因了。

以下是我成功的配置信息：

          property="driverClassName"
      value="com.mysql.jdbc.Driver" />
          property="url"
      value="jdbc:mysql://localhost:3306/mysql?useUnicode=true&characterEncoding=UTF-8" />
          property="username"
      value="root" />
          property="password"
      value="yourpass" />
          property="maxActive"
      value="10" />
          property="maxWait"
      value="5000" />
          property="defaultAutoCommit"
      value="false" />
          property="defaultReadOnly"
      value="false" />
          property="validationQuery"
      value="SELECT COUNT(*) FROM db" />


最后面那一行不是必需的，但是如果写上的话返回的结果及至少要有一条记录！

mysql的jdbc也可以写成org.gjt.mm.mysql.Driver这样子。

1. 只在必要的时候才考虑扩展Struts框架

　　一个好的framework有很多优点，首先，它必须能够满足用户的可预见的需求。为此 Struts为Web 应用提供了一个通用的架构，这样开发人员可以把精力集中在如何解决实际业务问题上。其次，一个好的framework还必须能够在适当的地方提供扩展接口，以便应用程序能扩展该框架来更好的适应使用者的实际需要。

　　如果Struts framework在任何场合，任何项目中都能很好的满足需求，那真是太棒了。但是实际上，没有一个框架声称能做到这一点。一定会有一些特定的应用需求是框架的开发者们无法预见到的。因此，最好的办法就是提供足够的扩展接口，使得开发工程师能够调整struts来更好的符合他们的特殊要求。

　　在Struts framework中有很多地方可供扩展和定制。几乎所有的配置类都能被替换为某个用户定制的版本，这只要简单的修改一下Struts的配置文件就可以做到。

　　其他组件如ActionServlet和 RequestProcessor 也能用自定义的版本代替. 甚至连Struts 1.1里才有的新特性也是按照扩展的原则来设计的。例如，在异常处理机制中就允许用户定制异常处理的句柄，以便更好的对应用系统发生的错误做出响应。

　　作为框架的这种可调整特性在它更适合你的应用的同时也在很大的程度上影响了项目开发的效果。首先，由于您的应用是基于一个现有的成熟的、稳定的framework如Struts，测试过程中发现的错误数量将会大大减少，同时也能缩短开发时间和减少资源的投入。因为你不再需要投入开发力量用于编写基础框架的代码了。

　　然而, 实现更多的功能是要花费更大的代价的。我们必须小心避免不必要的滥用扩展性能， Struts是由核心包加上很多工具包构成的，它们已经提供了很多已经实现的功能。因此不要盲目的扩展Struts框架，要先确定能不能采用其他方法使用现有的功能来实现。 在决定编写扩展代码前务必要确认Struts的确没有实现你要的功能。否则重复的功能会导致混乱将来还得花费额外的精力清除它。

2. 使用异常处理声明

　　要定义应用程序的逻辑流程，成熟的经验是推荐在代码之外，用配置的方法来实现，而不是写死在程序代码中的。在J2EE中，这样的例子比比皆是。从实现EJB的安全性和事务性行为到描述JMS消息和目的地之间的关系，很多运行时的处理流程都是可以在程序之外定义的。

　　Struts 创建者从一开始就采用这种方法，通过配置Struts的配置文件来定制应用系统运行时的各个方面。这一点在版本1.1的新特性上得到延续，包括新的异常处理功能。在Struts framework以前的版本中，开发人员不得不自己处理Struts应用中发生的错误情况。在最新的版本中，情况大大的改观了，Struts Framework提供了内置的一个称为 ExceptionHandler 的类， 用于系统缺省处理action类运行中产生的错误。这也是在上一个技巧中我们提到的framework许多可扩展接口之一。

　　Struts缺省的 ExceptionHandler类会生成一个ActionError对象并保存在适当的范围（scope）对象中。这样就允许JSP页面使用错误类来提醒用户出现什么问题。如果你认为这不能满足你的需求，那么可以很方便的实现你自己的ExcepionHandler类。

具体定制异常处理的方法和机制

　　要定制自己的异常处理机制，第一步是继承org.apache.struts.action.ExceptionHandler类。这个类有2个方法可以覆盖，一个是excute()另外一个是storeException(). 在多数情况下，只需要覆盖其中的excute()方法。下面是ExceptionHandler类的excute()方法声明：

public ActionForward execute( Exception ex,
                              ExceptionConfig exConfig,
                              ActionMapping mapping,
                              ActionForm formInstance,
                              HttpServletRequest request,
                              HttpServletResponse response
  ) throws ServletException;

　　正如你看到的，该方法有好几个参数，其中包括原始的异常。方法返回一个ActionForward对象，用于异常处理结束后将controller类带到请求必须转发的地方去。

　　当然您可以实现任何处理，但一般而言，我们必须检查抛出的异常,并针对该类型的异常进行特定的处理。缺省的，系统的异常处理功能是创建一个出错信息，同时把请求转发到配置文件中指定的地方去。 定制异常处理的一个常见的例子是处理嵌套异常。假设该异常包含有嵌套异常，这些嵌套异常又包含了其他异常，因此我们必须覆盖原来的execute()方法，对每个异常编写出错信息。

　　一旦你创建了自己的ExceptionHandler 类，就应该在Struts配置文件中的部分声明这个类，以便让Struts知道改用你自定义的异常处理取代缺省的异常处理.

　　可以配置你自己的ExceptionHandler 类是用于Action Mapping特定的部分还是所有的Action对象。如果是用于Action Mapping特定的部分就在元素中配置。如果想让这个类可用于所有的Action对象,可以在 元素中指定。例如，假设我们创建了异常处理类CustomizedExceptionHandler用于所有的Action类, 元素定义如下所示：

      handler="com.cavaness.storefront.CustomizedExceptionHandler"
    key="global.error.message"
    path="/error.jsp"
    scope="request"
    type="java.lang.Exception"/>

　　在元素中可以对很多属性进行设置。在本文中，最重要的属性莫过于handler属性, handler属性的值就是自定义的继承了ExceptionHandler类的子类的全名。 假如该属性没有定义，Struts会采用自己的缺省值。当然，其他的属性也很重要，但如果想覆盖缺省的异常处理的话，handler无疑是最重要的属性。

　　最后必须指出的一点是，你可以有不同的异常处理类来处理不同的异常。在上面的例子中，CustomizedExceptionHandler用来处理任何java.lang.Exception的子类. 其实，你也可以定义多个异常处理类，每一个专门处理不同的异常树。下面的XML片断解释了如何配置以实现这一点。

      handler="com.cavaness.storefront.CustomizedExceptionHandler"
    key="global.error.message"
    path="/error.jsp"
    scope="request"
    type="java.lang.Exception"/>

      handler="com.cavaness.storefront.SecurityExceptionHandler"
    key="security.error.message"
    path="/login.jsp"
    scope="request"
    type="com.cavaness.storefront.SecurityException"/>

　　在这里，一旦有异常抛出，struts framework将试图在配置文件中找到ExceptionHandler，如果没有找到，那么struts将沿着该异常的父类链一层层往上找直到发现匹配的为止。因此，我们可以定义一个层次型的异常处理关系结构，在配置文件中已经体现了这一点。

3. 使用应用模块（Application Modules）

　　Struts 1.1的一个新特性是应用模块的概念。应用模块允许将单个Struts应用划分成几个模块，每个模块有自己的Struts配置文件，JSP页面，Action等等。这个新特性是为了解决大中型的开发队伍抱怨最多的一个问题，即为了更好的支持并行开发允许多个配置文件而不是单个配置文件。

　　注：在早期的beta版本中，该特性被称为子应用（sub-applications），最近的改名目的是为了更多地反映它们在逻辑上的分工。

　　显然，当很多开发人员一起参加一个项目时，单个的Struts配置文件很容易引起资源冲突。应用模块允许Struts按照功能要求进行划分，许多情况已经证明这样更贴近实际。例如，假设我们要开发一个典型的商店应用程序。可以将组成部分划分成模块比如catalog（商品目录）, customer（顾客）, customer service（顾客服务）, order（订单）等。每个模块可以分布到不同的目录下，这样各部分的资源很容易定位，有助于开发和部署。图1 显示了该应用的目录结构。

图 1. 一个典型的商店应用程序的目录结构



　　注：如果你无需将项目划分成多个模块，Struts框架支持一个缺省的应用模块。这就使得应用程序也可以在1.0版本下创建，具有可移植性，因为应用程序会自动作为缺省的应用模块。

　　为了使用多应用模块功能，必须执行以下几个准备步骤：

　　• 为每个应用模块创建独立的Struts配置文件。

　　• 配置Web 部署描述符 Web.xml文件。

　　• 使用org.apache.struts.actions.SwitchAction 来实现程序在模块之间的跳转.

创建独立的Struts配置文件

　　每个Struts应用模块必须拥有自己的配置文件。允许创建自己的独立于其他模块的Action，ActionForm，异常处理甚至更多。

　　继续以上面的商店应用程序为例，我们可以创建以下的配置文件：一个文件名为struts-config-catalog.xml，包含catalog（商品目录）、items(商品清单)、和其它与库存相关的功能的配置信息；另一个文件名为struts- config-order.xml, 包含对order（订单）和order tracking（订单跟踪）的设置。第三个配置文件是struts-config.xml,其中含有属于缺省的应用模块中的一般性的功能。

配置Web部署描述符

　　在Struts的早期版本中，我们在Web.xml中指定Struts配置文件的路径。好在这点没变，有助于向后兼容。但对于多个应用模块，我们需要在Web部署描述符中增加新的配置文件的设定。

　　对于缺省的应用（包括Struts的早期版本），Struts framework 在Web.xml文件中查找带有config的元素，用于载入Action mapping 和其它的应用程序设定。作为例子，以下的XML片断展现一个典型的元素：

   config>/param-name>
   /WEB-INF/struts-config.xml

　　注：如果在现有的元素中找不到"config"关键字，Struts framework将缺省地使用/WEB/struts-config.xml

　　为了支持多个应用模块(Struts 1.1的新特性)，必须增加附加的元素。与缺省的元素不同的是，附加的元素与每个应用模块对应，必须以config/xxx的形式命名，其中字符串xxx代表该模块唯一的名字。例如，在商店应用程序的例子中，元素可定义如下（注意粗体字部分）：

   config
   /WEB-INF/struts-config.xml


   config/catalog
   /WEB-INF/struts-config.xml


   config/order
   /WEB-INF/struts-config.xml

　　第一个 元素对应缺省的应用模块。第二和第三个元素分别代表非缺省应用模块catalog 和 order。

　　当Struts载入应用程序时，它首先载入缺省应用模块的配置文件。然后查找带有字符串config/xxx 形式的附加的初始化参数。对每个附加的配置文件也进行解析并载入内存。这一步完成后，用户就可以很随意地用config/后面的字符串也就是名字来调用相应的应用模块。

多个应用模块之间调用Action类

　　在为每个应用模块创建独立的配置文件之后，我们就有可能需要调用不同的模块中Action。为此必须使用Struts框架提供的SwitchAction类。Struts 会自动将应用模块的名字添加到URL,就如Struts 自动添加应用程序的名字加到URL一样。应用模块是对框架的一个新的扩充，有助于进行并行的团队开发。如果你的团队很小那就没必要用到这个特性，不必进行模块化。当然，就算是只有一个模块，系统还是一样的运作。

4. 把JSP放到WEB-INF后以保护JSP源代码

　　为了更好地保护你的JSP避免未经授权的访问和窥视， 一个好办法是将页面文件存放在Web应用的WEB-INF目录下。

　　通常JSP开发人员会把他们的页面文件存放在Web应用相应的子目录下。一个典型的商店应用程序的目录结构如图2所示。跟catalog （商品目录）相关的JSP被保存在catalog子目录下。跟customer相关的JSP，跟订单相关的JSP等都按照这种方法存放。

图 2.基于不同的功能 JSP 被放置在不同的目录下



　　这种方法的问题是这些页面文件容易被偷看到源代码，或被直接调用。某些场合下这可能不是个大问题，可是在特定情形中却可能构成安全隐患。用户可以绕过Struts的controller直接调用JSP同样也是个问题。

　　为了减少风险，可以把这些页面文件移到WEB-INF 目录下。基于Servlet的声明，WEB-INF不作为Web应用的公共文档树的一部分。因此，WEB-INF 目录下的资源不是为客户直接服务的。我们仍然可以使用WEB-INF目录下的JSP页面来提供视图给客户，客户却不能直接请求访问JSP。


　　采用前面的例子，图3显示将JSP页面移到WEB-INF 目录下后的目录结构

图 3. JSP存放在 WEB-INF 目录下更为安全


　　如果把这些JSP页面文件移到WEB-INF 目录下，在调用页面的时候就必须把"WEB-INF"添加到URL中。例如，在一个Struts配置文件中为一个logoff action写一个Action mapping。其中JSP的路径必须以"WEB-INF"开头。如下所示：

  path="/logoff"
  type="org.apache.struts.webapp.example.LogoffAction">
 

　　这个方法在任何情况下都不失为Struts实践中的一个好方法。是唯一要注意的技巧是你必须把JSP和一个Struts action联系起来。即使该Action只是一个很基本的很简单JSP，也总是要调用一个Action，再由它调用JSP。

　　最后要说明的是，并不是所有的容器都能支持这个特性。WebLogic早期的版本不能解释Servlet声明，因此无法提供支持，据报道在新版本中已经改进了。总之使用之前先检查一下你的Servlet容器。

5. 使用 Prebuilt Action类提升开发效率

　　Struts framework带有好几个prebuilt Action类，使用它们可以大大节省开发时间。其中最有用的是org.apache.struts.actions.ForwardAction 和 org.apache.struts.actions.DispatchAction.

使用 ForwardAction

　　在应用程序中，可能会经常出现只要将Action对象转发到某个JSP的情况。在上一点中曾提到总是由Action调用JSP是个好习惯。如果我们不必在Action中执行任何业务逻辑，却又想遵循从Action访问页面的话，就可以使用ForwardAction，它可以使你免去创建许多空的Action类。运用ForwardAction的好处是不必创建自己的Action类，你需要做的仅仅是在Struts配置文件中配置一个Action mapping。

　　举个例子，假定你有一个JSP文件index.jsp ，而且不能直接调用该页面，必须让程序通过一个Action类调用，那么，你可以建立以下的Action mapping来实现这一点：

　　正如你看到的，当 /home 被调用时, 就会调用ForwardAction 并把请求转发到 index.jsp 页面.

　　再讨论一下不通过一个Action类直接转发到某个页面的情况，必须注意我们仍然使用元素中的forward属性来实现转发的目标。这时元素定义如下：

   path="/home"
   forward="/index.jsp">

　　以上两种方法都可以节省你的时间，并有助于减少一个应用所需的文件数。

使用 DispatchAction

　　DispatchAction是Struts包含的另一个能大量节省开发时间的Action类。与其它Action类仅提供单个execute()方法实现单个业务不同，DispatchAction允许你在单个Action类中编写多个与业务相关的方法。这样可以减少Action类的数量，并且把相关的业务方法集合在一起使得维护起来更容易。

　　要使用DispatchAction的功能，需要自己创建一个类，通过继承抽象的DispatchAction得到。对每个要提供的业务方法必须有特定的方法signature。例如，我们想要提供一个方法来实现对购物车添加商品清单，创建了一个类ShoppingCartDispatchAction提供以下的方法：

public ActionForward addItem( ActionMapping mapping,
                              ActionForm form,
                              HttpServletRequest request,
                              HttpServletResponse response)
  throws Exception;

　　那么，这个类很可能还需要一个deleteItem()方法从客户的购物车中删除商品清单，还有clearCart()方法清除购物车等等。这时我们就可以把这些方法集合在单个Action类，不用为每个方法都提供一个Action类。

　　在调用ShoppingCartDispatchAction里的某个方法时，只需在URL中提供方法名作为参数值。就是说，调用addItem()方法的 URL看起来可能类似于：

http://myhost/storefront/action/cart?method=addItem

　　其中method参数指定ShoppingCartDispatchAction中要调用的方法。参数的名称可以任意配置，这里使用的"method"只是一个例子。参数的名称可以在Struts配置文件中自行设定。

6.使用动态ActionForm

　　在Struts framework中，ActionForm对象用来包装HTML表格数据（包括请求），并返回返回动态显示给用户的数据。它们必须是完全的JavaBean，并继承.Struts　里面的ActionForm类，同时，用户可以有选择地覆盖两个缺省方法。

　　该特性能节省很多时间，因为它可以协助进行自动的表现层的验证。ActionForm的唯一缺点是必须为不同的HTML表格生成多个ActionForm 类以保存数据。例如，如果有一个页面含有用户的注册信息，另一个页面则含有用户的介绍人的信息，那么就需要有两个不同的ActionForm类。这在大的应用系统中就会导致过多的ActionForm类。Struts 1.1对此做出了很好的改进，引入了动态ActionForm类概念

　　通过Struts framework中的DynaActionForm类及其子类可以实现动态的ActionForm ，动态的ActionForm允许你通过Struts的配置文件完成ActionForm的全部配置；再也没有必要在应用程序中创建具体的ActionForm类。具体配置方法是：在Struts的配置文件通过增加一个元素，将type属性设定成DynaActionForm或它的某个子类的全名。下面的例子创建了一个动态的ActionForm名为logonForm，它包含两个实例变量：username 和 password.

  name="logonForm"
  type="org.apache.struts.action.DynaActionForm">
 
 

　　动态的ActionForm可以用于Action类和JSP，使用方法跟普通的ActionForm相同，只有一个小差别。如果使用普通的ActionForm对象则需要提供get 和 set方法取得和设置数据。以上面的例子而言，我们需要提供getUsername() 和 setUsername()方法取得和设置username变量，同样地有一对方法用于取得和设置password变量.

　　这里我们使用的是DynaActionForm，它将变量保存在一个Map类对象中，所以必须使用DynaActionForm 类中的get(name) 和 set(name)方法，其中参数name是要访问的实例变量名。例如要访问DynaActionForm中username的值，可以采用类似的代码：

　　String username = (String)form.get("username");

　　由于值存放在一个Map对象，所以要记得对get()方法返回的Object对象做强制性类型转换。

　　DynaActionForm有好几个很有用的子类。其中最重要的是DynaValidatorForm ，这个动态的ActionForm和Validator 一起利用公共的Validator包来提供自动验证。这个特性使你得以在程序代码之外指定验证规则。将两个特性结合使用对开发人员来说将非常有吸引力。

7. 使用可视化工具

　　自从Struts 1.0 分布以来，就出现了不少可视化工具用于协助创建，修改和维护Struts的配置文件。配置文件本身是基于XML格式，在大中型的开发应用中会增大变得很笨拙。为了更方便的管理这些文件，一旦文件大到你无法一目了然的时候，建议试着采用其中的一种GUI 工具协助开发。商业性的和开放源代码的工具都有不少，表1列出了可用的工具和其相关链接，从那里可以获取更多信息。

表 1. Struts GUI 工具

应用程序	性质	网址
Adalon	商业软件	http://www.synthis.com/products/adalon
Easy Struts	开放源码	http://easystruts.sourceforge.net/
Struts Console	免费	http://www.jamesholmes.com/struts/console
JForms	商业软件	http://www.solanasoft.com/
Camino	商业软件	http://www.scioworks.com/scioworks_camino.html
Struts Builder	开放源码	http://sourceforge.net/projects/rivernorth/
StrutsGUI	免费	http://www.alien-factory.co.uk/struts/struts-index.html

相关资源

　　要获取更为全面的Struts GUI 工具列表 (包括免费的和商业性的), 请访问 Struts resource page.

　　Struts是在Jakarta项目下开发的源代码开放软件，由一系列的框架类、辅助类和定制的JSP标记库构成，定位在基于Model 2设计模式的J2EE应用开发。Model 2体系是MVC（Model-View-Controller）体系的一种应用。在MVC体系中，数据模型（Model）、表现逻辑（View）和控制逻辑（Controller）是分离的组件，但它们可以互相通信。Struts力图从整体上减轻构造企业级Web应用的负担，并提供国际化和数据库连接池支持。

　　Struts体系可以看成两个相对独立的部分：第一个部分是Struts API，用于编写支持Struts的应用组件；第二部分是Struts的JSP标记库，由html、bean、logic和template四个标记组成。Struts的两个部分有着各自不同的用户。对于规模较小的项目，同一个用户可能同时使用这两个部分；但对于规模较大的项目，通常开发者使用API组件，而负责HTML页面布局的人使用标记库。

　　Struts的设计目标是为Model 2 Web应用开发提供一个强大的框架。同时，Struts还包含了一些实用组件，例如Digest，但这些组件并不从属于上面提到的两个部分。

Struts应用的体系结构

　　对于从传统编程环境转入Web开发的人来说，Web编程中令人很不习惯的一个特点是缺乏“程序”。传统的应用总是有主入口点、流程控制和出口点。但在Web网站上，用户可能从任何地方进入，按照一种完全随机的次序访问各个页面，甚至可能跳过多个页面，也可能在一、两个小时内毫无动静。这是HTTP访问的基本特征，无论是Struts还是其他Web编程框架，都无法改变这一点。然而，Struts能够隐藏Web访问固有的“混乱”，帮助开发者建立起清晰和明确的秩序和规则。

　　在Struts应用中，有一个称为ActionServlet的主调度程序（或称为分配器），如图1所示。不过，并非所有的请求都必须通过ActionServlet。用户的请求目标可以是非Struts的页面，也可以是那些使用了Struts标记库但不使用Struts请求分配服务的页面。这正是Struts体系的优点之一：按需使用。许多编程框架要求你要么不用，要么全部使用，而且一旦你决定使用，以后要悔改从前的错误就会付出高昂的代价。Struts按需使用的优点与这类系统形成了强烈对比。

　　图1 Struts框架中的请求处理

　　Struts应用由下面这些基本模块构成：

　　1.配置信息;

　　2.Servlet，主要是Struts的ActionServlet;

　　3.动作类（Action），执行逻辑和控制（请求分配）功能，它们由ActionServlet调用；

　　4.JSP页面（属于View），常常通过动作类分派；

　　5.JSP标记库，根据需要使用；

　　6.各种形式的JavaBean，包括用户定义的JavaBean。

　　典型的Struts应用要用到三种配置文件：web.xml、struts-config.xml和可选的应用资源文件。

　　web.xml是Web应用的标准配置文件，是所有J2EE Web应用必需的组成部分。应用服务器通过该配置文件把URL映射到Servlet和JSP，通过该配置文件为Servlet和JSP指定启动参数。为Struts应用提供的基本web.xml文件很简单，真正必需的只有一个主ActionServlet定义，以及一个确保Struts请求传递到ActionServlet的映射。按照惯例，以“.do”结尾的URL都是Struts请求，例如/login.do。应用服务器利用web.xml文件中的映射，把该请求传递给ActionServlet。接着，ActionServlet决定如何分配该请求。ActionServlet的决定依据是struts-config.xml中定义的规则，和/或是通过ActionServlet派生类额外定义的分配逻辑。

　　struts-config.xml称为Struts配置文件。Struts应用是一个依靠struts-config.xml文件把组件连接起来的网络。struts-config.xml文件为Web应用的组件定义了逻辑名称，也定义了它们在Struts框架下的属性和关系，就像web.xml文件在Web应用框架之内定义组件一样。struts-config.xml文件包含了与Struts框架有关的应用信息，这些信息分四个类：

　　1.数据源信息，它是可选的。在这里可以指定一个或者多个JDBC数据源，使得数据库定义信息集中化。对于数据库访问，Struts还有一个额外的优点，即支持基本的数据库连接池功能。

　　2. Form Bean是JavaBean的一种特殊类型，它简化了Web表单的处理。

　　3. Global Forwards是全局性的转发定义信息。Struts动作按照一种“请求—转发”机制运行。为了最大限度地分　　离动作模块与转发目标，这里使用了一种映射机制，允许通过同义词引用转发目标。一些目标页面可能被多个动作类引用，例如登录页面，因此可以在全局转发定义部分把逻辑目标页面映射到物理目标页面，避免把这部分信息加入到动作定义部分。

　　4. Actions定义了Struts应用体系的请求分配信息，它们是核心分配器的补充定义，负责处理各种具体的请求类型。

一个简单的应用

　　基于Struts的Web应用和普通Web应用有着许多同样的要求，但Struts应用也有自己特殊的需求。一个可部署的Web应用应该可组织和构成一个WAR文件。WAR文件是带有图2所示目录结构的JAR包。对于Struts Web应用来说，Web-INF目录下还要加上一些额外的文件，例如struts-confg.xml文件和标记库描述器（TLD）文件。注意：应用的资源应该放入应用的类路径下，也就是Web-INF/lib目录或Web-INF/class目录下的JAR包内。对于大多数简单的Struts页面，我们只用到Struts标记库，而按照MVC的术语就不需要涉及Model和Controller部分，只涉及View。请看图3所示的主页例子。虽然这个页面没有表单，但Struts仍能够在设计这类页面时提供帮助。

　　图2 Struts应用的目录结构

　　图3 一个简单的View

　　要管理会话，最简单的途径是使用Cookie。会话标识符被传递到客户端之后，客户端把它保存到Cookie，以后的每次请求就把Cookie发送到服务器。然而，和其他的许多Web解决方案一样，Cookie方案也不是万能的，因为一些用户可能不信任Cookie，关闭浏览器的Cookie支持。由于这种情况，URL改写技术就出现了。使用URL改写技术时，整个网站的所有URL后面都将加上会话标识符。虽然这个方案不像采用Cookie方案那样简单、稳固，但它确实行得通。URL改写技术的不稳固是有两方面的原因。首先，和Cookie不同，URL没有过期时间，如果一个带有会话标识的URL被截取后又重新在以后的访问中使用，那么这种URL不会很有用，因为会话一般在一定的时间后会被作废。其次，如果有一个URL链接的后面没有带上会话标识符，整个链都会中断，客户程序无法再次获取会话标识符，除非它备份了带有会话标识符的URL访问历史。

　　Servlet能够只通过一次方法调用完成URL改写。从技术上讲，JSP也一样能够办到这一点，但一个好的JSP页面应该不包含Java代码，或包含尽量少的Java代码。为此，Struts提供了一个链接标记。本例使用了该标记来维持客户端和服务器之间的会话状态信息。

绑定View、Model和Controller

　　前面的简单页面不需要Struts分配器，因为它只有简单的链接。图4显示了一个比较复杂的“类别”页面。它列举出了数据库中的类别条目，并将这些条目分别链接到对应的编辑页面。为显示这个页面，我们就要用到Struts的ActionServlet分配机制。

　　图4 类别页面

　　在web.xml文件中，放入一项表示所有以“.do”结尾的URL请求必须发送给Struts分配器的声明。这里的分配器可以是org.apache.struts.action.ActionServlet或其扩展类。Struts分配器在启动时读取struts-config.xml文件，并构造出一个动作映射图。本例指定了一个名为ShowCategories的动作类，来处理“ShowCategories”动作。可以看出，Struts应用的基本工作模式是：主分配器调用一个动作分配器，动作分配器确定或构造出Model部分（一个JavaBean或其它Java对象），并把它提供给View（通常是一个JSP页面）。

　　本例使用Bean的情况稍微有点复杂，它有多个数据项，因此我们不是使用单个提供数据的Bean，而是要生成一组Bean。遗憾的是，JSP页面以HTML为基础，HTML没有提供循环或其他控制逻辑。不过，Struts的logic:iterate允许对数组进行迭代操作，如下面的代码片断所示：

<table>
<logic:iterate id="category"
type="com.strutsdemo.Category"
name="<%= Constants.CATALOG_CATEGORIES %>"
scope="application">
<tr>
<td>
<html:link page="/editCategory.do"
name="category"
property="mapping">
编辑
</html:link>
<html:link page="/removeCategory.do"
name="category"
property="mapping">
删除
</html:link>
<bean:write name="category"
property="category"/>
</td>
</tr>
</logic:iterate>
</table>

　　上面讨论了Model 2体系的Model和View部分，下面来看看Controller部分。Struts体系有一个主控制器，即ActionServlet。ActionServlet负责选择和调用合适的动作控制器—即org.apache.struts.action.Action的扩展类。动作控制器实现了process()方法。process()方法分析从URL请求传入的每一个参数，执行必要的业务逻辑，并返回一个指定了调用链中下一个链接的动作（通常是View）。在本例中，我们想要从数据库提取数据，创建管理这些数据的JavaBean，把多个JavaBean整理成一个数组，再把数组保存到请求的上下文，从而使得作为View的JSP页面能够方便地进行页面布局。

为保证上述操作顺利进行，在struts-config.xml文件中加入声明，指定由哪一个动作处理器来处理指定的动作：

<action path="/showCategories"
scope="request"
type="com.strutsdemo.ShowCategoriesAction"
unknown="false"
validate="false">
<forward name="viewCategories" path="/
ShowCategories.jsp"/>
</action>

表单处理

　　表单处理过程充分体现出Struts的优势。在Web应用中，大部分复杂的HTML处理任务都涉及到表单。表单编辑过程具有类似图5所示的请求或应答结构。更新操作的过程与创建操作的过程相似，但对于更新操作来说，“创建Model”这一步骤变成“装入Model”，而“保存Model”变成了“更新Model”。请注意Web应用的特点：操作过程随时可能中止，这既可能是因为用户通过显式的动作取消了当前的操作，也可能是因为用户没有提交表单，例如用户跳转到了一个不是用来处理当前表单的URL。

　　图5 表单处理流程

　　表单编辑过程分三个阶段：这里分别称之为准备（Preparation）、表现（Presentation）和存储（Preservation）。准备和存储阶段都属于Struts动作，而表现阶段主要是客户端的活动。表1显示了该过程中涉及的各种部件：

　　表单Bean（Form Bean）是一种特殊的JavaBean类型，它简化了表单处理。Form Bean从org.apache.struts. action.ActionForm类扩展而来。Form Bean有几个有用的特点，例如，通过reset()方法可以把Bean的属性设置成默认值，通过validate()方法让Bean验证属性的合法性。更重要的是，ActionServlet确保Form Bean被创建且可供它的动作方法调用。HTML标记库还能够确保Form Bean被正确地初始化并从Form View获取数据。

　　Form Bean应当属于Model部分，然而，由于它有validate()方法，因此从某些特征来看它更接近分配器。不过，不必太在乎这些概念上的问题。Model 2并不完全等同于MVC，而且一些人已经在责难MVC不外乎是几种简单设计模式的混合物。不管怎样，从应用实践的角度来讲，系统的稳定性远比概念的严格性更重要。在本例中，这个问题更加富有代表性，因为我们把持久化机制也包装到Form Bean里面。从技术上看，Bean数据的持久化副本就是一个View，因此，从这个意义上来讲，我们现在有了一个结合了分配器和View特点的Model。这种设计方式看起来似乎否定了引入Struts之类框架的理由，但实际上，这种设计方式两方面的特点弥补了许多遗憾。

　　首先，由于验证代码和SQL代码在很大程度上依赖于Form Bean拥有的属性，所以把它们作为一个单元管理会带来很大的方便。由于这里只对Form Bean的属性感兴趣，“重量级”的分配器和View部件都得到了有效的隔离。其次，Form Bean与HTML标记库一起使用时，Form Bean可以包含其他对象。这些对象可以通过“.”符号应用。使用预定义的Java对象时，“.”引用方式能够带来很大的方便，因为Java不支持多重继承。“.”引用方式避免了手工编写大量get/set代码的繁杂工作。

　　当内部对象是EJB时，“.”引用方式带来的方便更加突出，因为在JSP页面中引用EJB时，EJB往往显得很“笨重”。如果EJB嵌入到了Form Bean里面，许多这方面的遗憾就不再存在。更重要的是，它分离了Controller和Model，而且View持久化也简缩到了最简单的程度，因为EJB容器可以处理所有持久化方面的细节。这样，Form Bean就几乎成了一个纯粹的分配器，一切都变得整洁和清晰。

　　如果EJB有大量的属性，而且按照ActionServlet通常对Form Bean所做的那样，按照每个属性分别更新的方式进行更新，就会出现大量的RMI调用开销。对于要求较高的应用，更好的选择是利用EJB 2.0本地接口，或者在EJB之前加上一个传统的JavaBean（通常是会话EJB），并把该Bean传递给实体Bean的UpdateAllProperties()业务方法。后面这种方案允许在单个RMI调用中完成所有的更新操作。

准备阶段

　　一次典型的编辑会话要求有一个动作处理器准备View，即一个作为View的JSP页面，还要求有第二个动作处理器存储更新后的View。当然，存储操作之后会有第二个属于View的页面被显示，例如一个“数据已经更新，点击此处继续”的页面（参见表1）。

　　 表1：基于Form Bean的编辑过程要用到的部件

部件 　　　　　　　　　　　　说明
CatalogForm 　　　　　　　Form Bean
EditCategoryAction 　　　准备阶段
EditCategory.jsp 　　　　编辑
SaveCategoryAction 　　　存储阶段
EditDone.jsp 　　　　　　确认数据已经保存
EditFailed.jsp 　　　　　“数据没有保存”错误

　　下面的代码片断显示了如何在struts-config.xml文件中配置准备阶段：

<action path="/editCategory"
scope="request"
name="catForm"
type="com.strutsdemo.EditCategoryAction"
unknown="false"
validate="false">
<forward name="success"
path="/EditCategory.jsp"/>
</action>

　　在准备阶段，容器尝试从Session或Request找出指定的Form Bean，这是因为在动作中指定了“name=...”。ActionServlet在struts-config.xml文件的区域寻找Form Bean的别名，利用Form Bean的别名寻找对应的Java类。如果用户的请求带有参数，其名字匹配Form Bean属性名字的参数将被设置为属性值。Struts扩展了“属性名字”的含义，使得访问Form Bean内嵌对象的属性成为可能。本文的例子也用到了Struts的这一优点。

　　准备好Form Bean之后，ActionServlet接着调用动作的process()方法，Form Bean作为参数之一传入process()方法。在这里，我们对Form Bean的属性作最后的调整，调用业务方法，委派作为View的EditCategory，从而生成一个以Form Bean中合适数据为基础的HTML页面。这个页面被传递给客户端，接下来就进入了“表现”阶段。

表现阶段

　　这一阶段用户编辑表单并提交。如果服务器端的应用认为用户提交的内容存在问题，它把表单再次显示给用户，加上适当的提示信息；重复该过程，直至用户提交了合法的表单，或取消了表单处理过程。编辑过程的中止可能是由于用户跳转到了其他页面，或者启动了一个取消动作（例如点击了一个由html:cancel标记定义的按钮）。虽然在理论上，View的验证和再次显示操作应该属于表现阶段，但在Struts应用中，这部分功能在存储阶段实现最方便。

存储阶段

　　准备阶段创建了一个带有“name=”属性定义的动作CatForm，存储阶段要加入另外两个属性，即：“validate=‘true’”和“input=”属性。

<action path="/saveCategory"
scope="request"
name="catForm"
type="com.strutsdemo.SaveCategoryAction"
unknown="false"
input="/EditCategory1.jsp"
validate="true">
<forward name="success"
path="/CategoryUpdated.jsp"/>
</action>

　　设置了“validate=‘true’”属性选项之后，服务器端就会增加一个处理步骤。重新用来自View的数据构造出Form Bean，或更新From Bean的时候，Form Bean的validate()方法会被调用。validate()方法执行必要的合法性验证操作。如果用户的输入数据中存在错误，validate()方法就创建一个或多个ActionError对象。这些ActionError对象包含了错误信息源ID和表单输入域的名称。这些ActionError对象被收集和整理到一个ActionErrors对象，随后ActionErrors对象由validate()方法返回。如果用户输入的数据不包含错误，validate()返回null。

　　由于指定了“input=”属性，一旦出现了错误，动作会被忽略，而“input=”指定的View被显示。这个View既包含Form Bean，也包含当前出现的错误对象集合。一般地，这个输入页面就是原来执行编辑功能的JSP页面。

　　大多数Struts的html标记有对应的HTML标记，但Struts有一个HTML没有的标记，即标记。要中止表单编辑过程，用户既可以手工输入URL，也可以点击不指向存储动作处理器的链接。因此，用标记定义的“取消”按钮，不是取消编辑操作的唯一方法。

　　假设validate()方法没有发现任何错误，且用户没有点击“取消”按钮，存储动作的process()方法将被调用。在本例的process()方法中，我们调用了Form Bean的save()方法把数据写入持久性存储设备，然后根据写入操作是否成功，显示“存储操作成功”或“存储操作失败”的View。

构造和运行Struts应用

　　要构造和运行本文的示例应用，你必须了解如何使用Jakarta的Ant工具。如果你还不了解Ant，现在该是学习它的时候了！赶紧到网站下载Ant，通常要解开压缩，设置一下ANT_HOME环境变量，然后把Ant加入到执行路径就可以了。

本文示例的build.xml需要稍微定制一下，修改指示本地Tomcat位置的配置，使它能够找到在Tomcat下编译所必需的类。另外，你还要有一份Struts的JAR。你可以去下载最新的版本。

　　struts-config.xml文件是粘合Struts应用各个部分的配置文件。在部署完成后的Web应用中，struts-config.xml在Web-INF目录下。你应该修改一下数据源配置，使之符合你当前使用的DBMS环境。数据模型和SQL模式文件在下载包的DBMS目录下，SQL文件针对PostgreSQL DBMS编写。

　　示例中src/com/strutsdemo/ShowCategoriesAction. java是一个简单的分配器。ActionForward()是请求分配方法，从ActionServlet调用。该方法可以完成主要的工作，例如分析请求参数、执行计算，以及构造出View使用的JavaBean。另外，该方法还要根据处理结果，确定下一个要显示的是什么页面：可能是预设的多个页面之一，也可能是一个错误信息页面。

ActionForward()的请求分配过程

　　当然，最复杂的处理过程与表单有关。ActionForward方法的请求分配过程是：

　　1. ActionServlet，对请求进行解码。由于为动作指定了Form Bean，ActionServlet处理Form Bean（参见下面有关“ActionServlet如何使用Form Bean”的说明）。然后，请求传递给了EditCategoryAction。

　　2. EditCategoryAction；准备处理View，或者从数据库装入现有数据，或者创建新的数据项。动作处理器利用Mapping.findForward把控制传递给EditCategory.jsp。

　　3. DitCategory.jsp，显示出Form Bean，允许用户编辑数据。用户提交数据后，控制转到ActionServlet。

　　4. ActionServlet，对请求进行解码。这一次，Form Bean将从View的数据初始化，因为它是一个Struts的JSP表单页面。由于有Form Bean，且struts-config.xml中指定了“validate=‘true’”，名为“catForm”的Form Bean的validate()方法被调用。如果用户提交的数据未能通过合法性验证，则控制转到EditCategory1.jsp。

　　5. EditCategory1.jsp，它只是EditCategory.jsp略加修改后的一个版本。如果有必要，原始编辑页面和带有错误提示的编辑页面可以使用同一个View。Struts的JSP标记能够帮助我们轻松地办到这一点。该页面提交给/saveCategory.do。这样，用户就在这几个页面之间绕圈子，直到他跳转到一个与编辑操作无关的页面，或者他提交的数据通过了合法性验证。

　　6. 如果Form Bean合法性验证通过，ActionServlet把请求（包括Form Bean）传递给SaveCategoryAction。在这个例子中，“save”可能意味着创建操作，也可能意味着更新操作，具体由URL提供的选项决定。写入数据的操作通过调用Form Bean的store()方法完成。注意：实际的应用应当使用某种类型的事务管理机制（或使用EJB，因为EJB有内建的事务管理机制），以避免并发访问带来的问题。

ActionServlet如何使用Form Bean

　　涉及Form Bean的ActionServlet处理过程包含六个步骤：

　　1. 找到或创建Form Bean；

　　2. 据从HTTP请求传入的相应数据，更新Form Bean的各个属性；

　　3. 检查用户是否点击了“取消”按钮。如是，跳过步骤4和步骤5；

　　4. 验证Form Bean数据的合法性；

　　5. 如数据未能通过合法性验证，发送“input=”参数中指定的View；

　　6. 否则，把Form Bean传递给动作处理器。