Struts1.1 说明

前一段时间好象有人问关于Struts的事情,本人留意了一下.请有兴趣的同志不防研究研究.
(1)
1.　介绍

1.1　Model-View-Controller　(MVC)　设计模式

FIXME　-　需要一个对该模式一般性的介绍。（译注：可以参考机械工业出版社的《设计模式》。）
　
1.2　将MVC概念映射到Struts组件中

Struts　的体系结构实现了Model-View-Controller设计模式的概念，它将这些概念映射到web应用程序的组件和概念中。　
这一体系结构中每个主要的组件都将在下面做详细的讨论。　

1.3　Model:　系统状态和商业逻辑JavaBeans

基于MVC的系统中的　Model　部分可以细分为两个概念　--　系统的内部状态,　能够改变状态的行为。用语法术语来说，我们可以把状态信息当作名词（事物），把行为当作动词（事物状态的改变）。　
通常说来，你的应用程序将系统内部的状态表示为一组一个或多个的JavaBeans，使用属性（properties）来表示状态的细节。依赖于你的应用程序的复杂度，这些beans可以是自包含的（以某种方式知道怎样永久地保存它们的状态信息），或者可以是正面的（facades），知道当被请求时怎样从外部数据源（例如数据库）中取得信息。Entity　EJBs通常也用来表示内部状态。
大型应用程序经常将系统可能的商业逻辑行为表示为可以被维护状态信息的beans调用的方法。举个例子，你有一个为每个当前用户保存在session中的购物车bean，里面是表示当前用户决定购买物品的属性。这个bean有一个checkOut()方法用来验证用户的信用卡，将定单发给库房以选择货品和出货。别的系统分别地表示同样的行为，或许使用Session　EJBs。
在一些小型应用程序中，同样的行为又可能嵌入到作为Controller一部分的　Action　类中。这在逻辑非常简单或者并不想要在其它环境中重用这些商业逻辑时是恰当的。Struts框架支持所有这些方法，但建议将商业逻辑（“做什么”）和　Action　类（“决定做什么”）分离开。　

1.4　View:　JSP页面和表示组件

基于Struts的应用程序中的　View　部分通常使用JSP技术来构建。JSP页面包含称为“模版文本”的静态HTML（或XML）文本，加上插入的基于对特殊行为标记解释的动态内容。JSP环境包括了其用途由JSP规范来描述的一套标准的行为标记，例如　<jsp:useBean>　。另外，还有一个用来定义你自己标记的标准机制，这些自定义的标记组织在“定制标记库”中。　
Struts包括了一个广阔的便于创建用户界面，并且充分国际化的定制标记库，与作为系统　Model　部分一部分的ActionForm　beans美妙地相互配合。这些标记的使用将在后面做详细讨论。
除了JSP页面和其包含的行为及定制标记，商业对象经常需要能够基于它们在被请求时的当前状态将自己处理成HTML（或XML）。从这些对象处理过的输出可以很容易地使用　<jsp:include>　标准行为标记包括在结果的JSP页面中。　

1.5　Controller:　ActionServlet和ActionMapping

应用程序的　Controller　部分集中于从客户端接收请求（典型情况下是一个运行浏览器的用户），决定执行什么商业逻辑功能，然后将产生下一步用户界面的责任委派给一个适当的View组件。在Struts中，controller的基本组件是一个　ActionServlet　类的servlet。这个servlet通过定义一组映射（由Java接口　ActionMapping　描述）来配置。每个映射定义一个与所请求的URI相匹配的路径和一个　Action　类（一个实现　Action　接口的类）完整的类名，这个类负责执行预期的商业逻辑，然后将控制分派给适当的View组件来创建响应。　
Struts也支持使用包含有运行框架所必需的标准属性之外的附加属性的　ActionMapping　类的能力。这允许你保存特定于你的应用程序的附加信息，同时仍可利用框架其余的特性。另外，Struts允许你定义控制将重定向到的逻辑名，这样一个行为方法可以请求“主菜单”页面（举例），而不需要知道相应的JSP页面的实际名字是什么。这个功能极大地帮助你分离控制逻辑（下一步做什么）和显示逻辑（相应的页面的名称是什么）。　

2.　创建Model组件

2.1　概述

你用到的应用程序的需求文档很可能集中于创建用户界面。然而你应该保证每个提交的请求所需要的处理也要被清楚的定义。通常说来，Model　组件的开发者集中于创建支持所有功能需求的JavaBeans类。一个特殊应用要求的beans的精确特性依赖于具体需求变化会非常的大，但是它们通常可以分成下面讨论的几种类型。然而，首先对“范围”概念做一个简短的回顾是有用的，因为它与beans有关。　

2.2　JavaBeans和范围

在一个基于web的应用程序中，JavaBeans可以被保存在（并从中访问）一些不同“属性”的集合中。每一个集合都有集合生存期和所保存的beans可见度的不同的规则。总的说来，定义生存期和可见度的这些规则被叫做这些beans的　范围　。JSP规范中使用以下术语定义可选的范围（在圆括号中定义servlet　API中的等价物）：　
page　-　在一个单独的JSP页面中可见的Beans，生存期限于当前请求。（service()方法中的局部变量）　request　-　在一个单独的JSP页面中可见的Beans，也包括所有包含于这个页面或从这个页面重定向到的页面或servlet。（Request属性）　
session　-　参与一个特定的用户session的所有的JSP和servlet都可见的Beans，跨越一个或多个请求。(Session属性）　
application　-　一个web应用程序的所有JSP页面和servlet都可见的Beans。（Servlet　context属性）　
记住同一个web应用程序的JSP页面和servlets共享同样一组bean集合是很重要的。例如，一个bean作为一个request属性保存在一个servlet中，就象这样：　
MyCart　mycart　=　new　MyCart(...);
request.setAttribute("cart",　mycart);
将立即被这个servlet重定向到的一个JSP页面使用一个标准的行为标记看到，就象这样：　
<jsp:useBean　id="cart"　scope="request" class="com.mycompany.MyApp.MyCart"/>

2.3　ActionForm　Beans

Struts框架通常假定你已经为每一个你的应用程序中请求的输入创建了一个　ActionForm　bean（即一个实现了　ActionForm　接口的类）。如果你在你的　ActionMapping　配置文件中定义了这样的beans（见“创建Controller组件”），Struts的controller　servlet在调用适当的　Action　方法前将自动为你执行如下的服务：　
用适当的关键字检查用户的session中是否有适当的类的bean的一个实例。　
如果没有这样的session范围的bean，自动建立一个新的bean并添加到用户的session中。　
对每个名字对应于bean中的一个属性的请求参数，调用相应的set方法。这个操作类似于当你以通配符“*”选择所有属性使用标准的JSP行为标记　<jsp:setProperty>　。　
更新的ActionForm　bean在被调用时将被传递给Acton类的perform()方法，以使这些值能够立即生效。　
当你在写你的ActionForm　beans时，记住以下的原则：　
ActionForm　接口本身不需要特殊的实现方法。它是用来标识这些特定的beans在整个体系结构中的作用。典型情况下，一个ActionForm　bean只包括属性的get方法和set方法，没有商业逻辑。　
通常在一个ActionForm　bean中只有很少的输入验证逻辑。这样的beans存在的主要理由是保存用户为相关的表单所输入的大部分近期值　--　甚至在错误被检测到时　--　这样同样的页面可以被重建，伴随有一组出错信息，这样用户仅仅需要纠正错误的字段。用户输入的验证应该在　Action　类中执行（如果是很简单的话），或者在适当的商业逻辑beans中执行。　
为每个表单中出现的字段定义一个属性（用相关的getXxx()和setXxx()方法）。字段名和属性名必须按照JavaBeans的约定相匹配。例如，一个名为　username　的输入字段将引起　setUsername()　方法被调用。　
你应该注意一个“表单”在这里讨论时的意义并不必须对应于用户界面中的一个单独的JSP页面。在很多应用程序中一个“表单”（从用户的观点）延伸至多个页面也是很平常的。想想看，例如，通常在安装新的应用程序时使用的导航安装程序的用户界面。Struts鼓励你定义一个包含所有字段属性的单独的ActionForm　bean。不管字段实际上是显示在哪个页面上。同样的，同一表单的不同的页面应该提交到相同的Action类。如果你遵照这个建议，在大多数情况下，页面设计者可以重新组织不同页面中的字段而不需要改变处理逻辑。　

2.4　系统状态Beans

系统的实际状态通常表示为一组一个或多个的JavaBeans类，其属性定义当前状态。例如，一个购物车系统包括一个表示购物车的bean，这个bean为每个单独的购物者维护，这个bean中包括（在其它事物之中）一组购物者当前选择购买的项目。分别地，系统也包括保存用户信息（包括他们的信用卡和送货地址）、可获得项目的目录和它们当前库存水平的不同的beans。　
对于小规模的系统，或者对于不需要长时间保存的状态信息，一组系统状态beans可以包含所有系统曾经经历的特定细节的信息。或者经常是，系统状态beans表示永久保存在一些外部数据库中的信息（例如CustomerBean对象对应于表　CUSTOMERS　中的特定的一行），在需要时从服务器的内存中创建或清除。在大规模应用程序中，Entity　EJBs也用于这种用途。　

2.5　商业逻辑Beans

你应该把你的应用程序中的功能逻辑封装成对为此目的设计的JavaBeans的方法调用。这些方法可以是用于系统状态beans的相同的类的一部分，或者可以是在专门执行商业逻辑的独立的类中。在后一种情况下，你通常需要将系统状态beans传递给这些方法作为参数处理。　
为了代码最大的可重用性，商业逻辑beans应该被设计和实现为它们不知道自己被执行于web应用环境中。如果你发现在你的bean中你必须import一个　javax.servlet.*　类，你就把这个商业逻辑捆绑在了web应用环境中。考虑重新组织事物使你的　Action　类（Controller任务的一部分，在下面描述）翻译所有从HTTP请求中请求被处理为对你的商业逻辑beans属性set方法调用的信息，然后可以发出一个对　execute()　的调用。这样的一个商业逻辑类可以被重用在除它们最初被构造的web应用程序以外的环境中。　
依赖于你的应用程序的复杂度和范围，商业逻辑beans可以是与作为参数传递的系统状态beans交互作用的普通的JavaBeans，或者使用JDBC调用访问数据库的普通的JavaBeans。而对于较大的应用程序，这些beans经常是有状态或无状态的EJBs。　

2.6　题外话:　访问关系数据库

很多web应用程序利用一个关系数据库（通过一个JDBC　driver访问）来保存应用程序相关的永久数据。其它应用程序则使用Entity　EJBs来实现这个目的，他们委派EJBs自己来决定怎样维护永久状态。如果你是使用EJBs来实现这个目的，遵照EJB规范中描述的客户端设计模式。　
对于基于直接数据库访问的web应用程序，一个普通的设计问题是当需要访问低层数据库时怎样产生一个适当的JDBC连接对象。解决这个问题有几种方法　--　以下原则描述了推荐的一种方法：　
创建或得到一个允许一组数据库连接被多个用户共享的ConnectionPool类。Struts（当前）没有包括这样的一个类，但是有很多这样的类可以得到。　
当应用程序初始化时，在应用程序展开（deployment）描述符中定义一个有一个“启动时加载”值的servlet。我们将把这个servlet叫做　启动　servlet。在大多数情况下，这个servlet不需要处理任何的请求，所以没有一个　<servlet-mapping>　会指向它。　
在启动servlet的　init()　方法中，配置并初始化一个ConnectionPool类的实例，将其保存为一个servlet　context属性（从JSP的观点看等同于一个application范围的bean）。通常基于传递给启动servlet初始化参数来配置联接缓冲池是很方便的。　
在启动servlet的　destroy()　方法中，包含了释放联接缓冲池所打开的联接的逻辑。这个方法将在servlet容器结束这个应用程序的时候被调用。　
当　Action　类需要调用一个需要数据库联接的商业逻辑bean中的方法（例如“insert　a　new　customer”）时，将执行下面的步骤：　
为这个web应用程序从servelt　context属性中得到一个联接缓冲池对象。　
调用联接缓冲池对象的　open()　方法来得到一个在　Action　类调用中使用的联接。　
调用商业逻辑bean中合适的方法，将数据库联接对象作为一个参数传递给它。　
调用分配的联接中的　close()　方法，这将引起这个联接为了以后其它请求的重用被返回到缓冲池中。　
一个通常的编程错误是忘记了把数据库联接返回给缓冲池，这将最终导致用完所有的联接。一定要确信　Action　类的逻辑总是返回联接，甚至在商业逻辑bean抛出一个违例时。　
遵照上面推荐的设计模式意味着你能够编写你的商业逻辑类而不需要担心它们怎样得到一个JDBC联接来使用--　简单地在任何需要访问数据库的方法中包含一个Connection参数。当你的商业逻辑类在一个web应用程序中被利用时，分配和释放适当的联接是　Action　类的责任。当你使用相同的商业逻辑类时，例如，在一个批处理工作中，提供一个适当的联接是那个应用程序的责任（这不需要从缓冲池中获得，因为大多数批处理工作运行于一个单线程环境中）。　

3.　创建View组件

3.1　概述

这一章集中于创建应用程序中的　View　组件的任务，主要使用JSP技术建立。特别的，Struts除了提供了与输入表单的交互外还提供了建立国际化应用程序的支持。几个其它的与View相关的主题也被简单地讨论。　

3.2　国际化消息

几年之前，应用程序开发者能够考虑到仅仅支持他们本国的只使用一种语言（或者有时候是两种）和通常只有一种数量表现方式（例如日期、数字、货币值）的居民。然而，基于web技术的应用程序的爆炸性增长，以及将这些应用程序展开在Internet或其它被广泛访问的网络之上，已经在很多情况下使得国家的边界淡化到不可见。这种情况转变成为一种对于应用程序支持国际化（经常被称做“i18n”，因为18是字母“i”和字母“n”之间的字母个数）和本地化的需求。　
Struts建立于Java平台之上为建立国际化和本地化的应用程序提供帮助。需要熟悉的关键概念是：　
Locale　-　基础的支持国际化的Java类是　java.util.Locale　。每个　Locale　代表一个特别的国家和语言选择（加上一个可选的语言变量），以及一套格式假定，例如数字和日期等等。　
ResourceBundle　-　java.util.ResourceBundle　类提供支持多种语言消息的基本工具。查看文档中关于ResourceBundle　类以及你的JDK版本的文档包中关于国际化的更多内容。　
PropertyResourceBundle　-　一个　ResourceBundle　类的标准实现允许你使用与初始化properties文件同样的“name=value”语法来定义资源。这对于使用为用于一个web应用程序的消息准备资源包是非常方便的，因为这些消息通常都是面向文本的。　
MessageFormat　-　java.text.MessageFormat　类允许你使用运行时指定的参数替换一个消息字符串中的一部分（在这种情况下，是一个从一个资源包得到的消息）。这在你创建一个句子的场合中是有用的，但是词会以不同的语言按照不同的顺序出现。消息中的占位符字符串{0}用第一个运行时参数替换，{1}用第二个运行时参数替换，以此类推。　
MessageResources　-　Struts的类　org.apache.struts.util.MessageResources　使你能够将一套资源包视做一个数据库，并且允许你为一个特定的Locale（通常是与当前用户相对应）请求一个特定的消息，而不是为服务器运行在其中的缺省的Locale请求消息。　
对于一个国际化的应用程序，遵照JDK文档包中国际化文档所描述的步骤来创建一个包含每种语言的消息的属性文件。下面举一个例子说明。　
假设你的源代码建立在包　com.mycompany.mypackage　中，因此它保存于一个叫做（相对于你的源目录）com/mycompany/mypackage　的目录中。为创建一个叫做　com.mycompany.mypackage.MyResources　的资源包，你应该在目录　com/mycompany/mypackage　中创建下列文件：　
MyResources.properties　-　包含你的服务器的缺省语言的消息。如果你的缺省语言是英语，你可能有一个这样的条目：　
prompt.hello=Hello
MyResources_xx.properties　-　包含ISO语言编程为“xx”（查看ResourceBundle的Java文档页面得到一个当前列表的联接）的同样的消息。对于上面的消息的法语版，你可以有这个条目：　
prompt.hello=Bonjour
你可以有你需要的任意多的语言的资源包文件。
当你在web应用程序展开描述符中配置controller　servlet时，你需要在一个初始化参数中定义的一件事是应用程序的资源包的基础名。在上述的情况中，这应该是　com.mycompany.mypackage.MyResources　。　

3.3　表单和FormBean的交互

大部分web开发者曾经使用HTML的标准性能来建立表单，例如使用　<input>　标记。用户希望交互程序具有一定的行为，这些期待中的一个与错误处理有关　--　如果用户出现一个错误，应用程序应该允许他们仅仅修改需要修改的部分　--　而不需要重新敲入当前页面或表单中的任何其它信息。　
使用标准的HTML和JSP编程来完全实现这个期望是单调而繁重的。举例来说，一个用户名字段的输入元素看起来可以象是这样（在JSP中）　
<input　type="text"　name="username"
value="<%=　loginBean.getUsername()　%>">
这很难敲对，会把没有编程概念的HTML开发者搞糊涂，并且会在HTML编辑器中造成问题。取而代之的是，Struts提供了一种全面的基于JSP　1.1的定制标记库功能的机制来建立表单。上面的情况使用Struts处理后将象是这样：　
<struts:text　name="username"/>
没有必要再显式地涉及到从中获得初始值的JavaBean。这将由框架自动处理。　

3.3.1　使用Struts建立表单

一个完整的注册表单将演示Struts相对于直接使用HTML和标准的JSP功能怎样极大地减轻了处理表单的痛苦。考虑以下称为logon.jsp的页面（来自Struts的例子程序）：　
<%@　page　language="java"　%>
<%@　taglib　uri="/WEB-INF/struts.tld"　prefix="struts"　%>
<html>
<head>
<title><struts:message　key="logon.title"/></title>
<body　bgcolor="white">

<struts:errors/>

<struts:form　action="logon.do"　name="logonForm"
type="org.apache.struts.example.LogonForm"/>
<table　border="0"　width="100%">
<tr>
<th　align="right">
<struts:message　key="prompt.username"/>
</th>
<td　align="left">
<struts:text　name="username"　size="16"/>
</td>
</tr>
<tr>
<th　align="right">
<struts:message　key="prompt.password"/>
</th>
<td　align="left">
<struts:password　name="password"　size="16"/>
</td>
</tr>
<tr>
<td　align="right">
<struts:submit>
<struts:message　key="button.submit"/>
</struts:submit>
</td>
<td　align="right">
<struts:reset>
<struts:message　key="button.reset"/>
</struts:reset>
</td>
</tr>

</struts:form>

</body>
</html>
下面的条目基于这个例子演示在Struts中处理表单的关键的特性：　
taglib指令告诉JSP页面编译器从哪里找到Struts标记库的　标记库描述符　。在这种情况下，我们使用struts作为前缀来标识来自这个库中的标记，但是可以使用任何你想用的前缀。　
这个页面使用了几个　message　标记来从一个包含有这个应用程序所有资源的　MessageResources　对象中查找国际化的消息字符串。为了让这个页面能够工作，以下的消息关键字必须在这些资源中被定义：　
logon.title　-　注册页面的标题　
prompt.username　-　一个　“Username:”　提示字符串　
prompt.password　-　一个　“Password:”　提示字符串　
button.submit　-　“Submit”按钮的标签　
button.reset　-　“Reset”按钮的标签　
当用户注册时，应用程序可以在用户的session中保存一个　Locale　对象。这个　Locale　将用来选择适当语言的消息。这使得给用户一个切换语言的可选项实现起来变的容易了　--　仅仅改变保存的　Locale　对象，所有的消息就会自动切换。　
errors　标记显示由一个商业逻辑组件保存的任何出错消息，或者如果没有出错消息保存就什么都没有。这个标记将在下面做深入的描述。　
form　标记基于指定的属性对一个HTML　<form>　元素进行处理。它也将所有在这个表单中的字段与一个保存在关键字　logonForm　下的session范围的FormBean相关联。这个bean用来为所有的具有与bean中的属性名匹配的名字的输入字段提供初始值。如果适当的bean没有找到，一个新的bean将会被自动建立，使用指定的Java类名。　
text　标记对一个类型为“text”的HTML　<input>　元素进行处理。在这种情况下，占据浏览器屏幕的字符位置的数字也被指定。当页面被执行时，是相对应的bean的　username　属性的当前值（也就是　getUsername()　的返回值）。　
password　标记使用方法类似。不同之处是当用户敲入他们的口令时浏览器将回应星号字符，而不是输入值。　
submit　和　reset　标记在表单低部生成相应的按钮。每个按钮的文本标签使用　message　标记建立，同时带有提示，这样这些值就是国际化的。　

3.3.2　输入字段类型支持

Struts为所有以下类型的输入字段定义了标记，带有与其相应的参考信息的超联接。　
checkboxes　
hidden　字段　
password　输入字段　
radio　按钮　
reset　按钮　
select　列表和嵌入的　
options　
submit　按钮　
text　输入字段　
textareas　
在所有情况下，一个字段标记都必须嵌套在一个　form　标记中，这样字段才知道使用哪个bean来初始化显示的值。　

3.3.3　其它有用的表示标记

在Struts的标记库中有几个其它的标记对于建立用户界面是有帮助的：　
enumerate　为一个指定集合的每个元素重复一次标记体（可以是一个Enumeration，一个Hashtable，一个Vector或一个对象数组）。　
getProperty　从指定的bean中得到指定的属性，并且在本页面的其余部分作为一个page范围的bean存在。这是访问一个被　enumerate　使用的集合的方便的方法。　
ifAttributeExists　只有在一个指定的属性存在于一个指定的范围中时才对标记体求值。　
ifAttributeMissing　只有在一个指定的属性不存在于一个指定的范围中时才对标记体求值。　
ifParameterEquals　只有在一个指定的请求参数具有一个指定的值时才对标记体求值。　
ifParameterNotEquals　只有在一个指定的请求参数不具有一个指定的值或者不存在时才对标记体求值。　
ifParameterNotNull　只有在一个指定的请求参数包含在这个请求中并且长度大于0时才对标记体求值。　
ifParameterNull　只有在一个指定的请求参数不包含在这个请求中或者长度等于0时才对标记体求值。　
iterate　为一个指定集合中的每个元素重复一次标记体（可以是一个Collection，一个Iterator，一个Map，或者一个对象数组）。这个标记在Java2环境中代替了　enumerate　标记。　
link　生成一个超联接，当没有cookie支持时自动应用URL编程来维护session状态。　
parameter　处理指定请求参数的值，适当地过滤HTML中有特殊含义的字符。　
property　显示一个表单中命名的bean属性　--　在属性应该是只读时使用这个标记而不是　text　标记。　

3.3.4　自动表单验证

除了上面描述的表单和bean的交互外，如果你的bean知道怎样验证它接收的输入字段，Struts还提供一种附加的机制。为了利用这个特性，使你的bean类实现　ValidatingActionForm　接口，而不是　ActionForm　接口。一个　ValidatingActionForm　增加了一个附加的方法签名：　
public　String[]　validate()
对于一个被controller　servlet在bean属性已经组装但是在相应的行为类的　perform()　方法被调用之前调用的方法，validate()　方法有以下可选项：　
执行适当的验证发现没有错误　--　返回　null　或者一个非0长度字符串数组，并且controller　servlet将继续调用适当的　Action　类的　perform()　方法。　
执行适当的验证发现有错误　--　返回一个内容为应该被显示的出错消息关键字（进入应用程序的MessageResources　包）的字符串数组。controller　servlet将作为适合于　<struts:errors>　标记使用的请求属性保存这个数组，并且将控制重定向回输入表单（由这个　ActionMapping　的　inputForm　属性标识）。　
正如以前提到的，这个特性完全是可选的。如果你的form　bean　仅仅实现了　ActionForm　接口，controller　servlet将假设任何请求的验证由action类完成。　

3.4　其它的表示技术

尽管你的应用程序的外表和感觉可以完全基于标准的JSP能力和Struts的定制标记库构建，你也应该考虑展开其它改进组件重用、减少管理负担或者减少出错的技术。在下面的部分讨论几个可选的技术。　

3.4.1　特定于应用程序的定制标记

在使用Struts库提供的定制标记之外，很容易建立特定于你创建的应用程序的标记来帮助建立用户界面。Struts包括的例子程序用建立以下仅用于实现这个应用程序的标记演示了这个原则：　
checkLogon　-　检查一个特殊的会话对象的存在，如果不存在将控制重定向到注册页面。这是用来捕捉这样的情况，用户在你的应用程序执行的中间把一个页面做成书签并且试图跳过注册，或者用户的会话超时。　
linkSubscription　-　为一个详细的定单页面生成一个超联接，它将需要的主关键字值作为一个请求属性传递。这在列出与一个用户相关的定单并提供编辑或删除定单的联接时使用。　
linkUser　-　为一个用户的一个具体的页面生成一个超联接，它将它将需要的主关键字值作为一个请求属性传递。　
这些标记的源代码在　src/example　目录中，在包　org.apache.struts.example　里，还带有一些其它的用在这个应用程序中的Java类。　

3.4.2　有包含文件的页面组件

在一个JSP文件（包含定制标记和beans用来访问请求的动态数据）中创建完整的表示是一种非常普通的设计方法，在Struts包括的例子程序中被采用。然而很多应用程序要求在单独一个页面中显示你的应用程序的多个逻辑上独立的部分。　
举例来说，一个入口应用程序可以在入口的主页面上有一些或者全部以下的功能：　
访问这个入口的一个搜索引擎。　
一个或更多的“提供新闻”的显示，含有按照用户的注册信息定制的感兴趣的标题。　
访问与这个入口相关的讨论的主题。　
如果你的入口提供免费邮件帐号，还要有一个“邮件等待”的提示。　
如果你能够将工作划分开，分配不同的开发者去做不同的片段，那么这个站点不同片段的开发就会更加简单。然后，你可以使用JSP技术的　include　能力来将这些片段组合进一个单独的页面。有两种　include　可用，依赖于你希望输出的组合发生在什么时间：　
include　指令　（<%@　include　file="xxxxx"　%>）在JSP页面被编译时处理。它用于包括不需要在请求时改变的HTML代码。它把包括进来的文本当作静态文本，很象C或C++中的　#include　指令。　
include　行为　（<jsp:include　page="xxxxx"　flush="true"　/>）在请求时处理，并且是由服务器透明处理。这意味着你可以通过把它嵌套在一个类似ifParameterEquals的标记中有条件地执行include　。　

3.4.3　图片处理组件

一些应用程序要求动态生成图片，就象一个股市报告站点的价格图一样。通常使用两种不同的方法来实现这个需求：　
处理一个执行一个servlet请求的URL的超联接。这个servlet将使用一个图象库来生成图片，设置适当的content类型（例如　image/gif），并且将图片的字节流发送回浏览器。浏览器就会象从一个静态文件中接收到的一样显示图片。　
处理HTML代码需要下载一个创建请求的图象的Java　applet。你可以通过为在处理的代码中的这个applet设置适当的初始化参数配置这个图象，或者你可以让这个applet与服务器建立自己联接来接收这些参数。　

4.　创建Controller组件

4.1　概述

现在我们理解了怎样构造你的应用程序的Model和View组件，现在是集中到　Controller　组件的时候了。Struts包括一个实现映射一个请求URI到一个行为类的主要功能的servlet。因此你的与Controller有关的主要责任是：　
为每一个可能接收的逻辑请求写一个　Action　类（也就是，一个　Action　接口的实现）　
写一个定义类名和与每个可能的映射相关的其它信息的　ActionMapping　类（也就是，一个　ActionMapping　接口的实现）　
写行为映射配置文件（用XML）用来配置controller　servlet。　
为你的应用程序更新web应用程序展开描述符文件（用XML）用来包括必需的Struts组件。　
给你的应用程序添加适当的Struts组件。　

4.2　Action类

Action　接口定义一个单一的必须由一个　Action　类实现的方法，就象下面这样：　
public　ActionForward　perform(ActionServlet　servlet,
ActionMapping　mapping,
ActionForm　form,
HttpServletRequest　request,
HttpServletResponse　response)
throws　IOException,　ServletException;
一个　Action　类的目标是处理这个请求，然后返回一个标识JSP页面的　ActionForward　对象，控制应该重定向这个JSP页面以生成相应的响应。在　Model　2　设计模式中，一个典型的　Action　类将在它的　perform()　方法中实现下面的逻辑：　
验证用户session的当前状态（例如，检查用户已经成功地注册）。如果　Action　类发现没有注册存在，请求应该重定向到显示用户名和口令用于注册的JSP页面。应该这样做是因为用户可能试图从“中间”（也就是，从一个书签）进入你的应用程序，或者因为session已经超时并且servlet容器创建了一个新的session。　
如果验证还没有发生（由于使用一个实现　ValidatingActionForm　接口的form　bean），验证这个　form　bean　的属性是必须的。如果发现一个问题，当作一个请求属性保存合适的出错信息关键字，然后将控制重定向回输入表单这样错误可以被纠正。　
执行要求的处理来处理这个请求（例如在数据库里保存一行）。这可以用嵌入　Action　类本身的代码来完成，但是通常应该调用一个商业逻辑bean的一个合适的方法来执行。　
更新将用来创建下一个用户界面页面的服务器端对象（典型情况下是request范围或session范围beans，定义你需要在多长时间内保持这些项目可获得）。　
返回一个标识生成响应的JSP页面的适当的　ActionForward　对象，基于新近更新的beans。典型情况下，你将通过在你接收到的　ActionMapping　对象（如果你使用一个局部于与这个映射上的逻辑名）或者在controller　servlet　本身（如果你使用一个全局于应用程序的逻辑名）上调用　findForward()　得到一个对这样一个对象的引用。　
当为　Action　类编程时要记住的设计要点包括以下这些：　
controller　servlet仅仅创建一个你的　Action　类的实例，用于所有的请求。这样你需要编写你的　Action　类使其能够在一个多线程环境中正确运行，就象你必须安全地编写一个servlet的　service()　方法一样。　
帮助线程安全编程的最重要的原则就是在你的　Action　类中仅仅使用局部变量而不是实例变量。局部变量创建于一个分配给（由你的JVM）每个请求线程的栈中，所以没有必要担心会共享它们。　
尽管不应该，代表你的系统中Model部分的的beans仍有可能抛出违例。你应该在你的　perform()　方法的逻辑中捕捉所有这样的违例，并且通过执行以下语句将它们记录在应用程序的日志文件中（包括相应的栈跟踪信息）：　
servlet.log("Error　message　text",　exception);
作为一个通用的规则，分配很少的资源并在来自同一个用户（在用户的session中）的请求间保持它们会导致可伸缩性的问题。你应该在将控制重定向到适当的View组件前努力释放这样的资源（例如数据库联接）　--　甚至在你调用的一个bean抛出了一个违例时。　
另外，你将会想要防止出现非常大的　Action　类。最简单的实现途径是将你的功能逻辑嵌入到　Action　类本身，而不是将其写在独立的商业逻辑beans中。除了使　Action　类难于理解和维护外，这种方法也使得难于重用这些商业逻辑代码，因为代码被嵌入到一个组件（Action　类）中并被捆绑运行于web应用程序环境中。　
包括在Struts中的例子程序某种程度上延伸了这个设计原则，因为商业逻辑本身是嵌入到　Action　类中的。这应该被看作是在这个样本应用程序设计中的一个bug，而不是一个Struts体系结构中的固有特性，或者是一个值得仿效的方法。　

4.3　ActionMapping实现

为了成功地运行，Struts的controller　servlet需要知道关于每个URI该怎样映射到一个适当的　Action　类的几件事。需要了解的知识封装在一个叫做　ActionMapping　的Java接口中，它有以下属性：　
actionClass　-　用于这个映射的　Action　类完整的Java类名。第一次一个特定的映射被使用，一个这个类的实例将被创建并为以后重用而保存。　
formAttribute　-　session范围的bean的名字，当前的这个映射的　ActionForm　被保存在这个bean之下。如果这个属性没有被定义，没有　ActionForm　被使用。　
formClass　-　用于这个映射的　ActionForm　类完整的Java类名。如果你在使用对form　beans的支持，这个类的一个实例将被创建并保存（在当前的用户会话中）　
path　-　匹配选择这个映射的请求的URI路径。看下面如何匹配的例子。　
Struts在一个叫做　ActionMappingBase　的类中包括了一个　ActionMapping　接口的方便的实现。如果你不需要为你自己的映射定义任何附加的属性，尽管把这个类作为你的　ActionMapping　类好了，就向下面部分描述的那样配置。然而，定义一个　ActionMapping　实现（多半是扩展　ActionMappingBase　类）来包含附加的属性也是可能的。controller　servlet知道怎样自动配置这些定制属性，因为它使用Struts的Digester模块来读配置文件。　
包括在Struts的例子程序中，这个特性用来定义两个附加的属性：　
failure　-　如果Action类检测到它接收的输入字段的一些问题，控制应该被重定向到的上下文相关的URI。典型情况下是请求发向的JSP页面名，它将引起表单被重新显示（包含Action类设置的出错消息和大部分最近的来自ActionForm　bean的输入值）。　
success　-　如果Action类成功执行请求的功能，控制应该被重定向到的上下文相关的URI。典型情况下是准备这个应用程序的会话流的下一个页面的JSP页面名。　
使用这两个额外的属性，例子程序中的　Action　类几乎完全独立于页面设计者使用的实际的JSP页面名。这个页面可以在重新设计时被重命名，然而几乎不会影响到　Action　类本身。如果“下一个”JSP页面的名字被硬编码到　Action　类中，所有的这些类也需要被修改。　

4.4　Action映射配置文件

controller　servlet怎样知道你想要得到的映射？写一个简单地初始化新的　ActionMapping　实例并且调用所有适当的set方法的小的Java类是可能的（但是很麻烦）。为了使这个处理简单些，Struts包括一个Digester模块能够处理一个想得到的映射的基于XML的描述，同时创建适当的对象。看　API　文档　以获得关于Digester更多的信息。　
开发者的责任是创建一个叫做　action.xml　的XML文件，并且把它放在你的应用程序的WEB-INF目录中。（注意这个文件并不需要　DTD，因为实际使用的属性对于不同的用户可以是不同的）最外面的XML元素必须是<action-mappings>，在这个元素之中是嵌入的0个或更多的　<action>　元素　--　每一个对应于你希望定义的一个映射。　

来自例子程序的　action.xml　文件包括“注册”功能的以下映射条目，我们用来说明这个需求：　

<action-mappings>

<forward　name="logon"　path="/logon.jsp"/>

<action　path="/logon"
actionClass="org.apache.struts.example.LogonAction"
formAttribute="logonForm"
formClass="org.apache.struts.example.LogonForm"
inputForm="/logon.jsp">
<forward　name="success"　path="/mainMenu.jsp"/>
</action>

</action-mappings>
就象你所看到的，这个映射匹配路径　/logon　（实际上，因为例子程序使用扩展匹配，你在一个JSP页面指定的请求的URI结束于/logon.do）。当接收到一个匹配这个路径的请求时，一个　LogonAction　类的实例将被创建（仅仅在第一次）并被使用。controller　servlet将在关键字　logonForm　下查找一个session范围的bean，如果需要就为指定的类创建并保存一个bean。　
这个　action　元素也定义了一个逻辑名“success”，它在　LogonAction　类中被用来标识当一个用户成功注册时使用的页面。象这样使用一个逻辑名允许将　action　类隔离于任何由于重新设计位置而可能发生的页面名改变。　

这是第二个在任何　action　之外宣告的　forward　元素，这样它就可以被所有的action全局地获得。在这个情况下，它为注册页面定义了一个逻辑名。当你调用　mapping.findForward()　时在你的　action　代码中，Struts首先查找这个action本地定义的逻辑名。如果没有找到，Struts会自动为你查找全局定义的逻辑名。　

4.5　Web应用程序展开描述符

设置应用程序最后的步骤是配置应用程序展开描述符（保存在文件WEB-INF/web.xml中）以包括所有必需的Struts组件。作为一个指南使用例子程序的展开描述符，我们看到下面的条目需要被创建或修改。　

4.5.1　配置Action　Servlet实例

添加一个条目定义action　servlet本身，同时包括适当的初始化参数。这样一个条目看起来象是这样：　
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-p
aram>
<param-name>application</param-name>
<param-value>org.apache.struts.example.ApplicationResources</param-value>
</init-param>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/action.xml</param-value>
</init-param>
<init-param>
<param-name>debug</param-name>
<param-value>2</param-value>
</init-param>
<init-param>
<param-name>mapping</param-name>
<param-value>org.apache.struts.example.ApplicationMapping</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>
controller　servlet支持的初始化参数在下面描述，拷贝自　ActionServlet　类的　Javadocs　。方括号描述如果你没有为那个初始化参数提供一个值时假设的缺省值。　
application　-　应用程序资源包基类的Java类名。[NONE].　
config　-　包含配置信息的XML资源的上下文相关的路径。[/WEB-INF/action.xml]　
debug　-　这个servlet的调试级别，它控制记录多少信息到日志中。[0]　
digester　-　我们在　initMapping()　中利用的Digester的调试级别，它记录到System.out而不是servlet的日志中。[0]　
forward　-　使用的ActionForward实现的Java类名。[org.apache.struts.action.ActionForward]　
mapping　-　使用的ActionMapping实现的Java类名。[org.apache.struts.action.ActionMappingBase]　
nocache　-　如果设置为　true，增加HTTP头信息到所有响应中使浏览器对于生成或重定向到的任何响应不做缓冲。[false]　
null　-　如果设置为　true，设置应用程序资源使得如果未知的消息关键字被使用则返回　null。否则，一个包括不欢迎的消息关键字的出错消息将被返回。[true]　

4.5.2　配置Action　Servlet映射

有两种通常的方法来定义将被controller　servlet处理的URL　--　前缀匹配和扩展匹配。每种方法的一个适当的映射条目将在下面被描述。　
前缀匹配意思是你想让所有以一个特殊值开头（在上下文路径部分之后）的URL传递给这个servlet。这样一个条目看起来可以象是这样：　

<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>/execute/*</url-pattern>
</servlet-mapping>
它意味着一个匹配前面描述的　/logon　路径的请求的URL看起来象是这样：　
http://www.mycompany.com/myapplication/execute/logon
这里　/myapplicationis　是你的应用程序展开所在的上下文路径。　
另一方面，扩展映射基于URL以一个跟着定义的一组字符的句点结束的事实而将URL匹配到action　servlet　。例如，JSP处理servlet映射到　*.jsp　模式这样它在每个JSP页面请求时被调用。为了使用　*.do　扩展（它意味着“做某件事”）映射条目看起来应该象是这样：　

<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
并且一个匹配以前描述的　/logon　路径的请求的URI可以看起来象是这样：　
http://www.mycompany.com/myapplication/logon.do

4.5.3　配置Struts标记库

下一步，你必须添加一个定义Struts标记库的条目。这个条目看起来应该象是这样：　
<taglib>
<taglib-uri>/WEB-INF/struts.tld</taglib-uri>
<taglib-location>/WEB-INF/struts.tld</taglib-location>
</taglib>
它告诉JSP系统到哪里去找这个库的标记库描述符（在你的应用程序的WEB-INF目录，而不是在外部互联网上的某个地方）。　

4.5.4　添加Struts组件到你的应用程序中

为了在你的应用程序运行时使用Struts，你必须将　struts.tld　文件拷贝到你的　WEB-INF　目录，将　struts.jar　文件拷贝到你的　WEB-INF/lib　。　?　



(2)
了解MVC

MVC是Model,View,Controller的缩写,MVC是Application开发的设计模式，也就是大家
所知道的Model2.在MVC的设计模式中,要求在Application开发中你把商业逻辑，界面
显示，数据分离。也就是分别在Model,View,Controller实现：数据，控制（商业逻辑）
显示（页面显示）.
在以前或者说传统的Web Application开发方式当中，如Asp,Php,Jsp(Model 1)开发当中，我们在Asp(Php,Jsp)中实现一切，如：从数据库中取到我们需要的数据，并根据数据之间的关联和实际的需要按照某种方式把他显示在页面中以及从页面提交的表单中提取数据，根据 商业逻辑从数据库查询相关数据，或者把数据写入数据库。也就是说我们在Asp(Php,Jsp) 实现一切包括：界面显示，商业逻辑，数据存取。这样带来的后果就是你所写的Asp(Php,Jsp) 没有层次，并且Html和Script(JavaScript、JScript,Asp、Php、Jsp源代码)相互嵌套.可 维护性差，最要命的是在Web Application通常显示一块是由美工完成的，很多时候也是 你先写好Asp、Php、Jsp然后美工进行美化，很有可能你发现经过美工处理完以后你的代码 已经面目全非了。你不得不把你的代码重新组织。
在MVC模式中这个问题的解决办法是：View中负责显示，View一般从Controller得到已经处理 过的数据，然后显示在页面当中，应该说这样在Html中嵌套很少的Script.基本上美工的修改 不大会废掉你的劳动成果。
在使用Java开发Web Application有几种符合MVC设计模式的开发方式让你选择。
1:Jsp+Servlet+JavaBean(EJB)
2:Jsp+JavaBean(Controller)+JavaBean(EJB)(Model)
3:TDK(Turbine，Velocity...)
4:Xsp
5:Jsp+Struts+JavaBean(EJB)
我个人认为后面两种比较好，其他几种都有可取的地方特别是使用TDK因为有一个比较好的
工具可以自动生成很多代码，至于它的缺点在后面几种开发方式的比较当中我会介绍。

Struts1.1的新功能
Struts1.1与1.0相比加了一些很不错的功能。最主要是表单验证上功能增强。在Struts1.1
数据的验证不象以前在Action中在validator具体实现，而是在validation.xml通过配置实现
这样做的好处就是重用性加强了很多。

Struts1.1实现的主要组成
主要包括:Action,ActionForm,ActionMapping,ActionForward,开发当中最主要写的是Action
ActionForm根据需要可以写或不写。下面我就一一具体介绍。
Action
An Action is an adapter between the contents of an incoming HTTP request
and the corresponding business logic that should be executed to process this
request.
上面是Struts开发小组对Action的描述，说Action实际上是Request和Business Logic
中间的适配器.通俗的说就是从表单中取到数据并穿给商业逻辑操作进行一系列的操作
然后返回相应的操作信息。

ActionForm
An ActionForm is a JavaBean optionally associated with one or more
ActionMappings. Such a bean will have had its properties initialized from
the corresponding request parameters before the corresonding action's execute()
method is called.
ActionForm实际上就是把从Request取到的数据封装并进行校验,然后把合法的数据给
Action进行处理。实际上ActionForm除了进行数据校验之外另外更重要的是在表单回写
的时候作用很大。反而在1.1以后数据校验的大部分工作在validation.xml去实现。

ActionMapping,ActionForward
ActionMapping主要是用与配置和描述相关属性使用的。先看下在struts-config.xml
中的配置文件一段配置描述:
<action-mappings>
<!-- Registration Action -->
<action path="/usereg"
type="com.bingo.finance.action.UseregAction"
name="useregForm"
scope="request"
validate="true"
input="/usereg.jsp">
<forward name="success" path="/msg.jsp"/>
</action>
</action-mappings>
ActionMapping就是用来描述一个Action的URL、具体实现的文件、相对应的ActionForm
数据属性(request or session)、是否需要进行数据校验和回写、以及处理完成后可能
跳转的URL.
而ActionForward你就可以理解为Action 操作完成后的跳转URL,Action在处理完相关操作后
返回的是一个ActionForward也就是告诉Struts我做完这个操作下一步到哪儿去。


构建Struts1.1运行环境
我的配置是居于Tomcat4.0以上版本讨论，其他的AppServer大致相同。
1:得到Struts1.1
http://jakarta.apache.org/builds/jakarta-struts/release/v1.1-b1/jakarta-struts-1.1-b1.zip
2:设置
把Struts.jar Copy到$Tomcat_home/common/lib 或你使用Struts的Appaction下的WEB-INF/lib下
在你使用Struts的Appaction下web.xml中增加下列配置

<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>debug</param-name>
<param-value>3</param-value>
</init-param>
<init-param>
<param-name>detail</param-name>
<param-value>3</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>

<taglib>
<taglib-uri>/WEB-INF/struts-html.tld</taglib-uri>
<taglib-location>/WEB-INF/struts-html.tld</taglib-location>
</taglib>

<taglib>
<taglib-uri>/WEB-INF/struts-logic.tld</taglib-uri>
<taglib-location>/WEB-INF/struts-logic.tld</taglib-location>
</taglib>

<!-- Nested Tag Library Descriptor -->
<taglib>
<taglib-uri>/WEB-INF/struts-nested.tld</taglib-uri>
<taglib-location>/WEB-INF/struts-nested.tld</taglib-location>
</taglib>

<!-- Template Tag Library Descriptor -->
<taglib>
<taglib-uri>/WEB-INF/struts-template.tld</taglib-uri>
<taglib-location>/WEB-INF/struts-template.tld</taglib-location>
</taglib>
Struts1.1中提供了很详细的例子，你可以仔细看看.
接下来你该根据需要配置struts-config.xml,以下是一个简单的例子
<?xml version="1.0" encoding="ISO-8859-1" ?>

<!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 Bean Definitions =================================== -->
<form-beans>

<!-- Registration form bean -->
<form-bean name="useregForm"
type="com.bingo.finance.action.UserForm"/>

</form-beans>

<!-- ========== Global Forward Definitions ============================== -->
<global-forwards>
<forward name="error" path="/error.jsp"/>
</global-forwards>

<!-- ========== Action Mapping Definitions ============================== -->
<action-mappings>

<!-- Registration Action -->
<action path="/usereg"
type="com.bingo.finance.action.UseregAction"
name="useregForm"
scope="request"
validate="true"
input="/usereg.jsp">
<forward name="success" path="/msg.jsp"/>
</action>
</action-mappings>

<!-- ========== Message Resources Definitions =========================== -->

<message-resources
parameter="com.bingo.finance.common.DisplayMsg"/>

<!-- ========== Plug Ins Configuration ================================== -->

<!-- Add multiple validator resource files by setting the pathname property -->
<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
<set-property property="pathname" value="/WEB-INF/validator-rules.xml"/>
<set-property property="pathname" value="/WEB-INF/validation.xml"/>
</plug-in>

</struts-config>
上面的英文我相信你能够看懂。我就不做解释了。你需要继续配置validation.xml了，看如下
简单的例子.
<form-validation>
<formset>
<form name="useregForm">
<field property="username"
depends="required,mask,minlength,maxlength">
<arg0 key="common_username"/>
<arg1 name="minlength" key="${var:minlength}" resource="false"/>
<arg1 name="maxlength" key="${var:maxlength}" resource="false"/>
<var>
<var-name>mask</var-name>
<var-value>^\w+$</var-value>
</var>
<var>
<var-name>minlength</var-name>
<var-value>5</var-value>
</var>
<var>
<var-name>maxlength</var-name>
<var-value>20</var-value>
</var>
</field>
<field property="password"
depends="required,mask,minlength,maxlength">
<arg0 key="common_password"/>
<arg1 name="minlength" key="${var:minlength}" resource="false"/>
<arg1 name="maxlength" key="${var:maxlength}" resource="false"/>
<var>
<var-name>mask</var-name>
<var-value>^\w+$</var-value>
</var>
<var>
<var-name>minlength</var-name>
<var-value>5</var-value>
</var>
<var>
<var-name>maxlength</var-name>
<var-value>20</var-value>
</var>
</field>
<field property="nickname"
depends="required,mask,minlength,maxlength">
<arg0 key="common_nickname"/>
<arg1 name="minlength" key="${var:minlength}" resource="false"/>
<arg1 name="maxlength" key="${var:maxlength}" resource="false"/>
<var>
<var-name>mask</var-name>
<var-value>^\w+$</var-value>
</var>
<var>
<var-name>minlength</var-name>
<var-value>5</var-value>
</var>
<var>
<var-name>maxlength</var-name>
<var-value>20</var-value>
</var>
</field>
<field property="superpass"
depends="required,mask,minlength,maxlength">
<arg0 key="common_superpass"/>
<arg1 name="minlength" key="${var:minlength}" resource="false"/>
<arg1 name="maxlength" key="${var:maxlength}" resource="false"/>
<var>
<var-name>mask</var-name>
<var-value>^\w+$</var-value>
</var>
<var>
<var-name>minlength</var-name>
<var-value>10</var-value>
</var>
<var>
<var-name>maxlength</var-name>
<var-value>20</var-value>
</var>
</field>
</form>
</formset>
</form-validation>
上面validation.xml就是告诉Struts我的useregForm取到的数据应该做下面的验证
username是必须不能为空的并且最小长度为5，最大长度是20.
................
password,nickname,superpass基本一样我就不做更多说明.至次配置基本结束，我们要开始写
第一个Struts 了。

开发Struts1.1

usereg.jsp
为了考虑页面的灵活性，在页面中显示的所有元素我都放在properties文件中并由
com.bingo.finance.common.HtmlMsg这个文件取到.
===================================================================
<%@ page contentType="text/html;charset=GBK" %>
<%@ page import="java.io.*"%>
<%@ page import="com.bingo.finance.common.HtmlMsg"%>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>

<html>
<head>
<title><%=HtmlMsg.TITLE_REGISET%></title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
</head>

<body bgcolor="#FFFFFF" text="#000000">
<form name="usereg" method="post" action="usereg.esp">
<!--在Struts中默认的后缀是.do你可以根据需要自己修改-->
<table width="100%" border="0" cellspacing="1" cellpadding="1">
<tr align="center">
<td colspan="2"><%=HtmlMsg.TITLE_REGISET%></td>
</tr>
<tr>
<td width="49%" align="right"><%=HtmlMsg.COMMON_USERNAME%>：</td>
<td width="51%">
<!--为了实现回写在Struts中建议你使用Tag使用如下写法代替一般的写法
<html:text property="username" size="20" maxlength="30" styleClass="css" styleId="userId"/>
上面的代码你看不懂你需要进一步了解Tag.
-->
<input type="text" name="username" size="20" maxlength="20">
</td>
</tr>
<tr>
<td width="49%" align="right"><%=HtmlMsg.COMMON_PASSWORD%>：</td>
<td width="51%">
<input type="password" name="password" size="20" maxlength="20">
</td>
</tr>
<tr>
<td width="49%" align="right"><%=HtmlMsg.COMMON_NICKNAME%>：</td>
<td width="51%">
<input type="text" name="nickname" size="20" maxlength="20">
</td>
</tr>
<tr>
<td width="49%" align="right"><%=HtmlMsg.COMMON_SUPERPASS%>：</td>
<td width="51%">
<input type="password" name="superpass" size="20" maxlength="20">
</td>
</tr>
<tr>
<td width="49%" align="right">
<input type="submit" name="Submit" value="<%=HtmlMsg.ACTION_REGISET%>">
</td>
<td width="51%">
<input type="reset" name="Submit2" value="<%=HtmlMsg.COMMON_RESET%>">
</td>
</tr>

</form>
</body>
</html>


UseregActiom.java
===========================================================
package com.bingo.finance.action;

//java import
import java.io.IOException;
import java.util.Locale;

//servlet import
import javax.servlet.ServletException;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

//struts import
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.util.MessageResources;

//finance import
import com.bingo.finance.action.UserForm;
import com.bingo.finance.manager.UserManager;
import com.bingo.finance.entity.User;

public class UseregAction extends Action {
//在Struts1.1以前使用perform
//struts1.1使用execute替代perform
public ActionForward execute(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
try{
UserForm userForm=(UserForm)form;
UserManager userManager=new UserManager();
User user=userManager.formToEntity(userForm);
userManager.add(user);
//Insert into DataBase a Userinfo
}catch(Exception ex){
return mapping.findForward("error");
}
return mapping.findForward("success");
//ForWard is "/msg.jsp"
}
}

UserForm.java
=========================================================================
package com.bingo.finance.action;
import java.util.*;
import java.io.Serializable;
//servlet import
import javax.servlet.ServletException;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
//struts import
import org.apache.struts.action.ActionMapping;
import org.apache.struts.validator.ValidatorForm;
public class UserForm extends ValidatorForm implements Serializable{
//在Struts1.1以前通常Form继承ActionForm
//实际上ValidatorForm是继承ActionForm
//为什么要加一层ValidatorForm是为了校验而做的
private String id;
private String username;
private String password;
private String nickname;
private String superpass;


public UserForm(){

}

/****/
public String getId(){
return this.id;
}

/****/
public void setId(String _id){
this.id=_id;
}

/****/
public String getUsername(){
return this.username;
}

/****/
public void setUsername(String _username){
this.username=_username;
}

/****/
public String getPassword(){
return this.password;
}

/****/
public void setPassword(String _password){
this.password=_password;
}

/****/
public String getNickname(){
return this.nickname;
}

/****/
public void setNickname(String _nickname){
this.nickname=_nickname;
}

/****/
public String getSuperpass(){
return this.superpass;
}

/****/
public void setSuperpass(String _superpass){
this.superpass=_superpass;
}

/**show this class info**/
public String toString(){
StringBuffer info=new StringBuffer();
info.append("....id is:"+id);
info.append("....username is:"+username);
info.append("....password is:"+password);
info.append("....nickname is:"+nickname);
info.append("....superpass is:"+superpass);
return info.toString();
}

public void reset(ActionMapping mapping, HttpServletRequest request) {
id=null;
username=null;
password=null;
nickname=null;
superpass=null;
}
}

UserManager.java ,User.java文件我就不提供了,这一部分在实际的开发当中根据需要自己去
处理，也就是为了把数据插入数据库。
现在一个简单的注册用户你就开发完成了。很简单吧。呵呵，继续努力...但其中还有很多
细节你需要进一步了解，我只把你领到门了，你必须自己去研究一些东西，比如说，我希望
我的用户多一个Email字段和一个年龄字段我应该如何做，而且我希望validation.xml的验证
有Email合法验证，年龄必须大于0而且一定是整数。那我应该如何做？
我只能告诉你加两个字段你需要修改Form 增加字段,同时相应文件也要修改。在struts中
Email的验证非常简单。好好看例子吧，好好研究validator-rules.xml，这个我认为struts1.1
最好的功能增加(Struts1.0没有这个文件)。Struts中提供了一个非常灵活而且重用极高的验证机制。

Struts和其他开发方式的比较
使用Struts开发至少带来如下好处：
1：层次结构非常清晰，也使得分工很明确。
2：重用度很高，连数据验证都可以重用，还有一个更好的重用就是Form,Action是可以很好的重用的。
3：可维护性好。这是居于第一点的。
.................
下面我说一个Struts的不足之处，如果你使用或者了解TDK你就会觉得，TDK中可以自动生成很多
java源代码的确可以节省不少工作量，Struts中也可以做的很好。我自己开发了一个工具，功能
还不够强大。在我的计划当中，我希望Form,JavaBean(封装数据相当于EJB中的Entity Bean),
甚至包括操作数据库的Method都自动生成，还有validation.xml也可以动态的生成。然而因为
下一个原因：Struts到目前为止还不是一个比较成熟的项目。他的改动实在是太大了。1.0和0.5
就有很大的改动。所以我的计划有变。我希望在1.1完全推出来再做开发(1.1现在是Beta版)。
同时我也给Craig R. McClanahan(Struts开发的Team leader)写过信听取他的建议.
-完-

……