Struts提供了非常多的标签，依据功能和使用习惯的不同被分到了五个标签库中:

• Bean Tags:该标签库包含的标签可以用来创建bean、访问bean和访问bean的属性。同时提供了依据cookies、headers和parameters的值创建相关bean的能力。
• HTML Tags:该标签库包含的标签可以用来创建Struts输入表单。
• Logic Tags:该标签库包含的标签可以用来进行逻辑判断、集合迭代和流程控制。
• Nested Tags:该标签库建立在前三个标签库的基础上，具有前三个标签库的所有功能，只是允许标签间的嵌套。
• Tiles Tags:该标签库包含的标签可以用来创建tiles样式的页面。

这篇指南主要介绍前三个标签库中的标签。如果您对后两类标签也感兴趣可以查阅参考资料中的Struts的用户指南。

bean:cookie

cookie最早是由Netscape公司提出来的，用来存储客户的少量状态信息。如果您对cookie的具体细节感兴趣可以查阅参考资料中的cookie spec。

bean:cookie标签取回请求中名称为name的cookie的值。如果没有指定multiple属性则依据刚取回的值创建一个Cookie类型的bean。如果指定了multiple属性则依据刚取回的值创建一个Cookie[]类型的数组。然后用id属性值将Cookie或Cookie[]绑定到page作用域中(这种绑定是为了其它标签能够使用该值)，并创建对应的scripting变量(这种变量是为了JSP脚本能够使用该值)。

下面的代码片段示例了如何使用bean:cookie标签读取名为JSESSIONID的cookie的值，并且使用了两种方式进行了输出：

<logic:present cookie="JSESSIONID">
<bean:cookie id="jSession" name="JSESSIONID"/>
<!-- 其它标签通过绑定到page作用域中的属性使用该值 -->
这个cookie的名称是<bean:write name="jSession" property="name"/>，
值为<bean:write name="jSession" property="value"/>。<br/>
<!-- JSP脚本通过scripting变量使用该值 -->
<%
String name = jSession.getName();
String value = jSession.getValue();
out.println("这个cookie的名称是"+name+"，值为"+value+"。
<br/>");
%>
</logic:present>

bean:define

bean:define标签在toScope(如果没有指定值就使用page作用域)指定的作用域中创建一个新属性，同时创建一个scripting变量。我们可以通过id值使用它们。新创建的属性可以由其它标签使用，而新创建的scripting变量可以由JSP脚本使用。

我们可以使用三种方式为新创建的属性和scripting变量赋值：

• 通过该标签的name、property和scope取回值，并且保持类型的一致性，除非取回的值为Java的原始类型，这时会使用适合的包装器类对这些值进行包装。
• 通过该标签的value指定值，这时新创建的属性和scripting变量的类型为java.lang.String。
• 通过在该标签的体中嵌入值，这时新创建的属性和scripting变量的类型为java.lang.String。

下面的代码片段示例了如何使用bean:define标签创建新属性values和新scripting变量values，它将listForm中persons的值取出来赋给values:

<bean:define id="values" name="listForm" property = "persons"
type="java.util.List"/>

下面给出ListForm的代码片段以帮助您更好的理解，其中Person是一个只有id和name两个属性的简单bean：

public class ListForm extends ActionForm {
private List<Person> persons = null;
public List<Person> getPersons() {
return persons;
}
public void setPersons(List<Person> persons) {
this.persons = persons;
}
public void reset(ActionMapping mapping,
HttpServletRequest request) {
persons = null;
}
}

下面的代码片段示例了logic:iterate标签如何使用bean:define标签创建的新属性values:

<logic:iterate id="person" name="values">
<bean:write name="person" property="id"/><br/>
</logic:iterate>

下面的代码片段示例了JSP脚本如何使用bean:define标签创建的新scripting变量values:

<%
Person p = new Person();
for(int i=0;i<values.size();i++){
p = (Person)values.get(i);
out.println(p.getId());
out.println("<br/>");
}
%>

bean:header

bean:header标签取回请求中名称为name的header的值。如果没有指定multiple属性则依据刚取回的值创建一个String类型的bean。如果指定了multiple属性则依据刚取回的值创建一个String[]类型的数组。然后用id属性值将String或String[]绑定到page作用域中(这种绑定是为了其它标签能够使用该值)，并创建对应的scripting变量(这种变量是为了JSP脚本能够使用该值)。

下面是我的浏览器发送的header的内容，这些内容和浏览器有关，因此您的浏览器发送的内容可能和下面列出的不同。不过这没有关系，因为要理解bean:header标签您只要对这些内容有一个大概的认识就足够了。

accept: */*
accept-language: zh-cn
accept-encoding: gzip, deflate
user-agent: Mozilla/4.0 (compatible; MSIE 6.0; //应该在同一行
Windows NT 5.1; SV1; .NET CLR 1.1.4322)
host: localhost:8080
connection: Keep-Alive

下面的代码片段示例了如何使用bean:header标签读取名为User-Agent的header的值，并且使用了两种方式进行了输出：

<logic:present header="User-Agent">
<!-- 其它标签通过绑定到page作用域中的属性使用该值 -->
您的浏览器是<bean:header id="userAgent" name="User-Agent"/>
<bean:write name="userAgent"/>。<br/>
<!-- JSP脚本通过scripting变量使用该值 -->
<%
out.println("您的浏览器是"+userAgent+"。<br/>");
%>
</logic:present>

bean:include

bean:include标签对指定url(由forward、href或page确定)处的资源做一个请求，将响应数据作为一个String类型的bean绑定到page作用域，同时创建一个scripting变量。我们可以通过id值访问它们。

下面的代码片段示例了bean:include标签的用法，其中include.txt文件包含要include的内容，然后将这些内容输出:

<bean:include id="value" page="/include.txt"/>
<!-- 其它标签通过绑定到page作用域中的属性使用该值 -->
<bean:write name="value"/><br/>
<!-- JSP脚本通过scripting变量使用该值 -->
<%
out.println(value);
%>

bean:message

bean:message标签用来从指定的locale中取回国际化的消息并输出，在这个过程中我们还可以传递五个以内的参数。message key可以通过key直接指定，也可以通过name和property间接的指定。

bean:message标签有两种指定message key的方式，一是通过key属性直接指定；二是通过name和property属性间接的指定，其中message key是在message resources文件中定义的。

我们可以在struts-config.xml文件中使用<message-resources>来设置message resources文件。

为了介绍该标签我使用了三个message resources文件，三个文件的名字分别为Resources.properties、Resources_en.properties和Resources_zh.properties。在struts-config.xml文件中的设置(这里不用设置三个，struts会依据locale自动找到对应的文件)如下：

<message-resources parameter="Resources" />

三个message resources文件中定义的message key为：

<!-- Resources.properties -->
resource=Resources.properties.
from=Resources.properties.
<!-- Resources_en.properties -->
from=Resources_en.properties.
<!-- Resources_zh.properties
因为文件的编码被限制为ISO8859所以要有汉字必须用jdk的native2ascii提前转换
-->
from=Resources_zh.properties.

下面的代码片段示例了bean:message标签的用法:

<bean:message key="from"/><br/>
<bean:message key="resource"/><br/>
<html:link action="/locale?language=en">English</html:link>
<html:link action="/locale?language=zh">Chinese</html:link>

上面的代码中含有改变locale的两个html:link标签，要使它们工作您的struts-config.xml文件中必须含有下面定义的form和action:

<form-bean name="localeForm"
type="org.apache.struts.action.DynaActionForm">
<form-property name="language" type="java.lang.String" />
<form-property name="country" type="java.lang.String" />
<!--action成功后要跳到那里-->
<form-property name="page"  type="java.lang.String"
initial="/message.jsp"/>
</form-bean>
<action path="/locale" type="org.apache.struts.actions.LocaleAction"
name="localeForm" scope="request">
</action>

在不同的locale下我们得到了如下的两个结果：

在locale为zh时的结果：
Resources_zh.properties.
Resources.properties.
在locale为en时的结果：
Resources_en.properties.
Resources.properties.

让我们来看一下在locale为zh时如何得到的是上面的结果。因为locale为zh所以<bean:message key="from"/><br/>先找Resources_zh.properties这个文件从中得到form键的值。而<bean:message key="resource"/><br/>也会先找Resources_zh.properties这个文件但这次没有找到resource键，这时Struts会到Resources.properties这个文件中找，很幸运这里找到了。如果还没有找到，或message resource文件不存在就会抛出异常。当locale为en时类似，您可以自己试试。

bean:page

bean:page标签将页上下文中的application、config、request、response 或 session取出，然后用id属性值将它们绑定到page作用域中(这种绑定是为了其它标签能够使用该值)，并创建对应的scripting变量(这种变量是为了JSP脚本能够使用该值)。

下面的代码片段示例了bean:page标签取出response，然后使用bean:write标签将response的characterEncoding和contentType属性输出：

<bean:page id="res" property="response"/>
<!-- 其它标签通过绑定到page作用域中的属性使用该值 -->
<bean:write name="res" property="characterEncoding"/><br/>
<bean:write name="res" property="contentType"/><br/>
<!-- JSP脚本通过scripting变量使用该值 -->
<%
String characterEncoding = res.getCharacterEncoding();
String contentType = res.getContentType();
out.println(characterEncoding+"<br/>");
out.println(contentType+"<br/>");
%>

您可以用和上面类似的代码访问application、config、request 或 session中的任何一个对象。

bean:parameter

bean:parameter标签取回请求中的参数值。如果没有指定multiple属性则依据刚取回的值创建一个String类型的bean。如果指定了multiple属性则依据刚取回的值创建一个String[]类型的数组。然后用id属性值将String或String[]绑定到page作用域中(这种绑定是为了其它标签能够使用该值)，并创建对应的scripting变量(这种变量是为了JSP脚本能够使用该值)。

下面的两个代码片段使用相同的url传递参数，url的形式为http://127.0.0.1:8080/struts-demo/parameter.jsp?param=1&param=2&param=3。前面的代码片段中没有指定multiple属性，因此p是String类型而且仅仅读取了参数的第一个值。后面的代码片段中指定了multiple属性的值，因此ps是String[]类型的包含所有参数的值。

<bean:parameter id="p" name="param"/>
<bean:write name="p"/>

<bean:parameter id="ps" multiple="true" name="param"/>
<logic:iterate id="p" name="ps">
<bean:write name="p"/><br/>
</logic:iterate>

bean:resource

bean:resource标签取回指定的web应用程序的资源，以InputStream或String的形式保存到page作用域中并且创建scripting变量。采用什么形式取决于标签的input属性，如果指定input则以InputStream的形式保存，如果没有指定input则以String的形式保存。

下面的两个代码片段示例了bean:resource标签，其中resource.txt是要使用的资源文件。前面的代码片段中没有指定input属性，因此以String的形式处理资源文件，bean:write标签输出资源文件的内容。后面的代码片段中指定了input属性的值，因此以InputStream的形式使用资源文件，两个bean:write标签分别输出InputStream对象的实例名(如java.io.ByteArrayInputStream@16dadf9)和类名(如class java.io.ByteArrayInputStream)。

<bean:resource id="str" name="/resource.txt"/>
<!-- 其它标签通过绑定到page作用域中的属性使用该值 -->
<bean:write name="str"/><br/>
<!-- JSP脚本通过scripting变量使用该值 -->
<%
out.println(str+"<br/>");
%>

<bean:resource id="is" input="true" name="/resource.txt"/>
<!-- 其它标签通过绑定到page作用域中的属性使用该值 -->
<bean:write name="is"/><br/>
<bean:write name="is" property="class"/>
<!-- JSP脚本通过scripting变量使用该值 -->
<%
out.println(is+"<br/>");
out.println(is.getClass()+"<br/>");
%>

bean:size

bean:size标签创建一个java.lang.Integer类型的bean，这个bean的值为该标签指定的Collection或Map中所含元素的个数。 这可以和logic:iterate标签配合使用，因为logic:iterate标签不能得到所叠代的集合的元素的个数，这有时候很不方便。

下面的代码片段示例了bean:size标签取出persons中还有元素的个数，其中listForm和persons的定义参见bean:define标签部分：

<logic:notEmpty name="listForm" property = "persons">
<bean:size id="size" name="listForm" property = "persons"/>
<bean:write name="size"/>
</logic:notEmpty>

bean:struts

bean:struts标签取回Struts的内部对象formBean、forward或mapping的值，然后用id绑定到page作用域中(这种绑定是为了其它标签能够使用该值)，并创建对应的scripting变量(这种变量是为了JSP脚本能够使用该值)。

下面的代码片段示例了bean:struts标签取出listForm对象，让我们先来看一下listForm的定义在读代码：

<!-- listForm的定义<form-bean name="listForm"
type="org.solo.struts.form.ListForm" /> -->
<bean:struts id="listFormBean" formBean="listForm"/>
name:<bean:write name="listFormBean" property="name"/><br/>
type:<bean:write name="listFormBean" property="type"/><br/>
dynamic:<bean:write name="listFormBean" property="dynamic"/><br/>

上面代码运行的结果为：

name:listForm
type:org.solo.struts.form.ListForm
dynamic:false

bean:write

bean:write标签将指定的bean的属性值写到当前的JspWriter中，并且可以对输出进行格式化。

下面的代码片段示例了bean:write标签输出User-Agent：

<logic:present header="User-Agent">
<bean:header id="header" name="User-Agent"/>
<bean:write name="header"/>
</logic:present>

下面的代码片段示例了bean:write标签格式化输出当前日期，其中now是在DataForm中定义的一个java.util.Date类型的域(值为new Date())，format.date.standard是在资源文件中的一个键(format.date.standard=yyyy-MM-dd)：

<bean:define id="date" name="dataForm" property="now"/>
<br/><bean:write name="date"/>
<br/><bean:write name="date" format="MM/dd/yyyy"/>
<br/><bean:write name="date" formatKey="format.date.standard"/>

上面代码运行的结果为：

Sun Jun 04 17:04:05 CST 2006
06/04/2006
2006-06-04

html:base

虽然这里的标题是html:base标签，但是这里也是这篇指南要介绍的第一个Struts html标签。因此我想在这里从整体上简单的介绍一下，最后给出一个对照表。其中的绝大多数标签就不一一介绍了，要介绍的也不会在这里介绍，而是将其独立出来以显重要性。

从用户处收集数据是动态web应用非常重要的一个方面，因此构建输入表单也就自然而然的成为struts框架的一个重要内容。Struts html标签库含有创建Struts输入表单的标签，和其它标签库(bean、logic、nested和tiles)中的标签一起协作就可以产生基于html的用户界面。

下面的对照表会使您对Struts html标签库有一个整体的印象：

html:cancel

html:cancel标签生成一个取消按钮。当点击该按钮后action servlet会绕过相应的form bean的validate()方法，同时将控制权交给相应的action。在该action中可以使用Action.isCancelled(HttpServletRequest)方法判断是否被取消了。如果返回true表示这个action被取消了，否则表示这个action没有被取消。

请注意，如果您修改了html:cancel标签的property属性值，那么struts提供的cancel探测机制就失效了，您自己必须提供类似的机制。

下面是可取消的action的配置文件，注意<set-property property="cancellable" value="true"/>这一行，如果不添加Struts会抛出org.apache.struts.action.InvalidCancelException异常。这是我在完成本指南的过程中发现的唯一向下不兼容的地方。

<action path="/cancel"
type="org.solo.struts.action.CancelAction" name="cancelForm"
scope="request">
<set-property property="cancellable" value="true"/>
<forward name="success" path="/cancel.jsp" />
</action>

下面是html:cancel标签的代码：

<html:cancel>取消</html:cancel>

下面是对应的action中的代码：

if(isCancelled(request)){
//action被取消时要做的事情写在这里
return mapping.findForward("cancel");
}else{
//action没有被取消时要做的事情写在这里
return mapping.findForward("success");
}

html:select

html:select标签生成一个select元素。是单选还是多选取决于该标签的multiple属性。如果指定了multiple="true"则为多选，此时对应的属性应该是一个数组。如果没有指定multiple="true"则为单选，此时对应的属性应该是标量。

注意：为了正确的处理没有做任何的选择的情况，在ActionForm中的reset()方法中必须将标量属性设置为默认值而将数组的长度置为0。

另外的一个重要问题就是struts如何生成option元素了，这个任务struts交给了html:option、html:options和html:optionsCollection三个标签。

html:option标签

html:option标签生成一个HTML的option元素。该标签必须嵌在html:select标签中。它的显示文本来自其标签体，也可以来自于资源文件。它的value属性用来指定什么值将要被提交。

<html:option value="one">one</html:option>
<html:option value="two">two</html:option>

html:options标签

html:options标签生成多个HTML的option元素。该标签必须嵌在html:select标签中。而且工作方式有些特殊，它的name与property属性和其它标签的name与property属性意义不一致，让我们具体看一下它的工作方式。

• 指定collection属性
• 没有指定collection属性

指定collection属性

让我通过示例来介绍在指定collection属性时该标签的工作方式，首先要说明selectForm中的persons和listForm中的persons完全一致。请参见bean:define标签。

下面的代码先利用bean:define标签将selectForm中的persons取到page作用域中，然后html:options标签再依据collection="personCollection"选中这个persons并将其中的每一个对象(Person类型)生成一个option元素。该标签的property="id"表示persons中的对象(Person类型)的id属性将作为option元素的value值。该标签的labelProperty="name"表示persons中的对象(Person类型)的name属性将作为option元素的label值。

当这个select提交时所选择的值将被提交到selectForm(name="selectForm")中的person对象(这是在SelectForm中声明的一个Person类型的域专门用来接收提交的值)的id属性中(property="person.id")。

<bean:define id="personCollection" name="selectForm"
property="persons"/>
<html:select name="selectForm" property="person.id" size="1">
<html:options collection="personCollection" property="id"
labelProperty="name"/>
</html:select>

没有指定collection属性

让我通过示例来介绍没有指定collection属性时该标签的工作方式，先来看看ids和names的定义：

  private List<String> ids = null;
private List<String> names = null;

上面的代码来自SelectForm，其中ids是一个String的列表，names也是一个String的列表。我们暂时假定这两个列表含有相同数目的元素。有了这些让我们开始介绍下面的代码。html:options标签用ids中的第i个值作为option元素的value值同时使用names中相同位置的值(第i个值)作为option元素的label值。如果ids比names长那么多出的ids中的值将即作为option的value又作为option的label。如果ids比names短那么多出的names的值会被丢掉。

当这个select提交时所选择的值将被提交到selectForm(name="selectForm")中的person对象(这是在SelectForm中声明的一个Person类型的域专门用来接收提交的值)的id属性中(property="person.id")。

<html:select name="selectForm" property="person.id" size="1">
<html:options property="ids" labelProperty="names"/>
</html:select>

html:optionsCollection标签

html:optionsCollection标签生成多个HTML的option元素。该标签必须嵌在html:select标签中。它的功能和html:options标签的相同，但是它的name与property属性和其它标签的name与property属性意义一致，理解起来比较自然。

让我通过示例来介绍html:optionsCollection标签的用法。首先依据name="selectForm"和property="persons"取到selectForm中的persons列表，然后将列表中的对象(Person类型)的id属性作为option元素的value值(value="id")，将列表中的对象(Person类型)的name属性作为option元素的label值(label="name")。

<html:select name="selectForm" property="person.id" size="1">
<html:optionsCollection name="selectForm" property="persons"
label="name" value="id"/>
</html:select>

下面是一个多选的示例，虽然示例中使用了html:options标签，但是html:option和html:optionsCollection也能够用来多选。而且您还必须意识到html:option、html:options和html:optionsCollection这三个标签可以同时使用。代码中的personIds是SelectForm中声明的一个String[]类型的数组用来接收提交的多个值。

<html:select name="selectForm" property="personIds"
multiple="true" size="2">
<html:options property="ids" labelProperty="names"/>
</html:select>

html:checkbox

html:check标签生成一个checkbox。这里的value值可以是true，yes或on。如果您要提交其它的值(如某种形式的标识)应该考虑使用html:multibox标签。

注意:为了正确的处理没有选中的checkbox您必须在reset()中设置对应的属性为false。

下面的代码示例了html:checkbox标签的用法，其中CheckboxForm中声明了三个boolean类型的域，如下：

				
private boolean one = false;
private boolean two = false;
private boolean three = false;

<html:checkbox name="checkboxForm" property="one">
One
</html:checkbox>
<html:checkbox name="checkboxForm" property="two">
Two
</html:checkbox>
<html:checkbox name="checkboxForm" property="three">
Three
</html:checkbox>

如果选中后被提交则相应的属性的值为true。

html:radio

html:radio标签生成一个radio。主要的用法有两种，下面我们通过代码来示例。

下面的代码示例了html:radio标签的一般用法，如果被提交则选中的radio的value值将被提交到radioForm中的id中。

<html:radio name="radioForm" property="id" value="00001">
One
</html:radio>
<html:radio name="radioForm" property="id" value="00002">
Two
</html:radio>

下面的代码示例了html:radio标签的典型用法，其中的persons和bean:define标签中的一致，您可以参考bean:define标签。我只介绍这个<html:radio idName="person" property="id" value="id">，idName指定html:radio要使用的bean(这里为person)，value="id"表示person的id属性将作为radio元素的value值而property="id"表示提交时选中的radio的值将被提交给radioForm中的id属性。

<logic:notEmpty name="radioForm" property="persons">
<logic:iterate id="person" name="radioForm" property="persons">
<html:radio idName="person" property="id" value="id">
<bean:write name="person" property="name"/>
</html:radio>
</logic:iterate>
</logic:notEmpty>

html:multibox

html:multibox标签生成多个checkbox。当您要使用大量的checkbox时使用这个标签非常方便，可以使您避免在ActionForm中声明大量的boolean类型的变量，带之以一个数组就行了。

注意:为了正确的处理没有选中的checkbox您必须在reset()中设置数组的长度为0。

下面的代码示例了html:multibox标签的一般用法，如果被提交则选中的所有checkbox的value值将被提交到multiboxForm中的selectedItems中，这是一个String[]数组。

<html:multibox name="multiboxForm" property="selectedItems"
value="00001"/>
<html:multibox name="multiboxForm" property="selectedItems"
value="00002"/>

下面的代码示例了html:multibox标签的典型用法：

<logic:iterate id="person" name="multiboxForm" property="persons">
<html:multibox property="selectedItems">
<bean:write name="person" property="id"/>
</html:multibox>
<bean:write name="person" property="name"/>
</logic:iterate>

html:link

html:link标签生成一个锚点(<a>)元素。我从html:link标签如何构造基本url和如何构造query参数两个方面来介绍这个标签。

构造基本url是依据该标签的如下四个属性进行的，这四个属性一次只能出现一个。让我们看看它们：

• forward，指定一个全局ActionForward的名称。另外如果forward是module相关的则该forward必须指向一个action而不能是一个页面。
• action，指定一个Action的名称。
• href，struts会直接使用这个值而不会对其进行任何处理。
• page，指定一个页面的路径，必须以/开始。

构造query参数，下面列举了可能的形式，其中baseurl只是一个占位符：

• baseurl?p=00001(单参单值)
• baseurl?p1=00001&p2=00002&p3=00003(多参单值)
• baseurl?p=00001&p=00002&p=00003(单参多值)
• baseurl?p1=00001&p2=00002&p=00001&p=00002&p=00003(混合)

下面我们以代码示例来说明每一种html:link的用法，首先让我们花点时间看看相关action中的代码：

<!-- 下面所有代码的数据都是在这里构造的 -->
public ActionForward execute(ActionMapping mapping,ActionForm form,
HttpServletRequest request,HttpServletResponse response) {
DataForm dataForm = (DataForm) form;
dataForm.setParam("00001");
HashMap paramSingleMap = new HashMap();
paramSingleMap.put("p1","00001");
paramSingleMap.put("p2","00002");
paramSingleMap.put("p3","00003");
dataForm.setParamSingleMap(paramSingleMap);
HashMap paramMultiMap = new HashMap();
paramMultiMap.put("p",new String[]{"00001","00002","00003"});
dataForm.setParamMultiMap(paramMultiMap);
HashMap paramSMMap = new HashMap();
paramSMMap.put("p1","00001");
paramSMMap.put("p2","00002");
paramSMMap.put("p",new String[]{"00001","00002","00003"});
dataForm.setParamSMMap(paramSMMap);
List<Person> persons = new ArrayList<Person>();
Person person1 = new Person();
person1.setId("00001");
person1.setName("赵辰");
Person person2 = new Person();
person2.setId("00002");
person2.setName("李为芳");
Person person3 = new Person();
person3.setId("00003");
person3.setName("王微");
persons.add(person1);
persons.add(person2);
persons.add(person3);
dataForm.setPersons(persons);
return mapping.findForward("success");
}

<!-- 这用来设置一个位置 -->
<html:link linkName="top"/>
<!-- 这用来定位到上面的那个位置 -->
<html:link page="/link.do" anchor="top">Go Top</html:link>

<html:link page="/link.do" paramId="p" paramName="dataForm"
paramProperty="param">
单参单值
</html:link><br/>
<html:link page="/link.do" name="dataForm" property="paramSingleMap">
多参单值
</html:link><br/>
<html:link page="/link.do" name="dataForm" property="paramMultiMap">
单参多值
</html:link><br/>
<html:link page="/link.do" name="dataForm" property="paramSMMap">
混合
</html:link>

下面的代码示例了html:link标签的indexed属性和indexId属性的用法，这两个属性只有html:link标签嵌套在logic:iterate标签中时才可用。

<logic:iterate id="person" name="dataForm" property="persons">
<html:link action="/link.do" paramId="person" paramName="person"
paramProperty="id" indexed="true" indexId="number">
person
</html:link>
<br/>
</logic:iterate>
<!-- 下面是上面代码的运行结果(产生的html)
<a href="/struts-demo/link.do?person=00001&number=0">赵辰</a><br/>
<a href="/struts-demo/link.do?person=00002&number=1">李为芳</a><br/>
<a href="/struts-demo/link.do?person=00003&number=2">王微</a><br/>
其中的number是由indexId="number"确定的，而该参数的值为元素在集合中的位置。
-->

html:rewrite标签和html:link标签类似只是不生成锚点(<a>)，而是简单的输出字符串。

html:errors

html:errors标签和html:messages标签的功能相似，所以我们放到一起来介绍。

html:errors标签将由name属性指定的ActionMessages、ActionErrors、String和String[]直接输出到页面中。

html:messages标签将用由name属性(注意message属性值对它的影响)指定的ActionMessages、ActionErrors、String和String[]创建一个新的属性和scripting变量，使用id属性值作为名称。

html:errors标签和html:messages标签的property属性是用来为errors和messages分类的。我们可以给这两个标签指定property属性，以便只显示某一类的错误或消息。

在资源文件增加了如下的内容：

# -- standard errors --
errors.header=<ul>
errors.prefix=<li>
errors.suffix=</li>
errors.footer=</ul>
error=error with none value .
error1=error1 with one value is {0} .
error2=error2 with two values are {0} , {1} .
error3=error3 with three values are {0} , {1} , {2} .
error4=error4 with four values are {0} , {1} , {2} ,{3} .

下面的代码示例了actionErrors的构造：

public ActionErrors validate(ActionMapping mapping,
HttpServletRequest request) {
ActionErrors actionErrors = new ActionErrors();
actionErrors.add("property1",
new ActionMessage("error"));
actionErrors.add("property2",
new ActionMessage("error1","value0"));
actionErrors.add("property2",
new ActionMessage("error2","value0","value1"));
actionErrors.add("property3",
new ActionMessage("error3","value0","value1","value2"));
actionErrors.add("property3",
new ActionMessage("error4","value0","value1","value2","value3"));
actionErrors.add("property4",
new ActionMessage("error1",new Object[]{"value0"}));
actionErrors.add("property4",
new ActionMessage("error2",new Object[]{"value0","value1"}));
actionErrors.add("property4",
new ActionMessage("error3",new Object[]{"value0","value1",
"value2"}));
actionErrors.add("property5",
new ActionMessage("error4",new Object[]{"value0","value1",
"value2","value3"}));
actionErrors.add("notBundle",
new ActionMessage("not a bundle key",false));
return actionErrors;
}

errors标签代码示例：

<html:errors/>
<br/>
<html:errors property="property4"/>

messages标签代码示例：

<logic:messagesPresent>
<ul>
<html:messages id="message">
<li><bean:write name="message"/></li>
</html:messages>
</ul>
</logic:messagesPresent>
<br/>
<logic:messagesPresent>
<ul>
<html:messages id="message" property="property4">
<li><bean:write name="message"/></li>
</html:messages>
</ul>
</logic:messagesPresent>

html:javascript

html:javascript标签生成用于校验的javascript脚本代码。

下面的代码片段示例了html:javascript标签的基本用法，其中formName属性的值是在validation.xml文件的<formset>中定义的form的名称。有一点值得注意的是在确定<formset>时要使用合适的language属性值。

<html:javascript formName="dataForm"/>

html:xhtml

html:xhtml标签在页面中一出现就是告诉该页的所有其它的Struts html标签以XHTML1.0兼容的形式输出。这和将html:html标签的xhtml属性值指定为true有些类似。如果上述情况都没有出现，Struts html标签将以html4.01兼容的形式输出。

logic:iterate

logic:iterate标签用来迭代集合，您可以使用如下方式来为这个标签指定其要叠代的集合：

• 使用一个运行时表达式，这个表达式的值是一个集合。
• 用name属性引用一个JSP Bean，这个JSP Bean本身就是一个集合。
• 用name属性引用一个JSP Bean，这个JSP Bean的一个属性是一个集合，这时可以联合使用property来指定这个集合。

上面所提到的集合可以是：

• 对象类型或原子类型的数组(Array)。
• java.util.Collection的实现，包括ArrayList，Vector。
• java.util.Enumeration的实现。
• java.util.Iterator的实现。
• java.util.Map的实现，包括HashMap，Hashtable和TreeMap。

如果您叠代的集合中含有null的值，这时需要采取一定的措施，因为这时logic:iterate不会在page作用域中创建对象。一般是使用<logic:present>标签或<logic:notPresent>标签来判断一下。

下面是logic:iterate叠代ArrayList的示例的对象引用关系和部分代码：

图中的persons列表是在ListAction中填充的，在这里只是简单的加入了三个Person对象，在实际的应用中这些数据应该取自数据库。具体的代码如下：

public ActionForward execute(ActionMapping mapping,ActionForm form,
HttpServletRequest request,	HttpServletResponse response) {
ListForm listForm = (ListForm) form;
List<Person> persons = new ArrayList<Person>();
Person person1 = new Person();
person1.setId("00001");
person1.setName("赵辰");
Person person2 = new Person();
person2.setId("00002");
person2.setName("李为芳");
Person person3 = new Person();
person3.setId("00003");
person3.setName("王微");
persons.add(person1);
persons.add(person2);
persons.add(person3);
listForm.setPersons(persons);
return mapping.findForward("success");
}

标签输出的结果为：

00001-->赵辰
00002-->李为芳
00003-->王微

logic:present

如果指定的值出现该标签就会创建其标签体内的内容。该标签用于以下情况：

• 检查具有指定名称的cookie是否出现。
• 检查具有指定名称的header是否出现。
• 检查具有指定名称的JSP Bean是否出现 或 检查具有指定名称的JSP Bean中的property属性是否出现。
• 检查request中指定名称的参数是否出现。
• 检查当前的认证用户是否与指定的安全角色相关联。
• 检查当前认证的主体是否具有指定的名字。

下面的代码示例了logic:present标签检查具有指定名称User-Agent的header是否出现：

<logic:present header="User-Agent">
您的浏览器是<bean:header id="userAgent" name="User-Agent"/>
<bean:write name="userAgent"/>。<br/>
</logic:present>

logic:notPresent标签的应用正好和logic:present标签相反。

logic:messagesPresent

logic:messagesPresent标签用于以下情况：

• 在request作用域中存在一个ActionMessages对象，标签的property属性和ActionMessages中的property对应。
• 在request作用域中存在一个ActionErrors对象，标签的property属性和ActionErrors中的property对应。
• 存在一个String对象，将其转换(构造)成ActionMessage然后在添加到ActionMessages中。
• 存在一个String Array对象，将数组中的每一个String转换成一个ActionMessage，在将其添加到ActionMessages中。

标签的message属性值为true时将以Globals.MESSAGE_KEY为key在request作用域中查找Message，其它情况下，将name的值作为key查找，如果name 没有出现，默认值为Globals.ERROR_KEY。

下面的代码示例了logic:messagesPresent标签的典型用法：

<logic:messagesPresent>
<ul>
<html:messages id="message">
<li><bean:write name="message"/></li>
</html:messages>
</ul>
</logic:messagesPresent>

标签logic:messagesNotPresent的应用正好和logic:messagesPresent的应用相反。

logic:empty

logic:empty标签是用来判断是否为空的。如果为空，该标签体中嵌入的内容就会被处理。该标签用于以下情况：

• 当Java对象为null时
• 当String对象为""时
• 当java.util.Collection对象中的isEmpty()返回true时
• 当java.util.Map对象中的isEmpty()返回true时

下面的代码示例了logic:empty标签判断集合persons是否为空：

<logic:empty name="listForm" property = "persons">
<div>集合persons为空!</div>
</logic:empty>

logic:notEmpty标签的应用正好和logic:empty标签相反。

logic:match

logic:match标签用来处理子串匹配问题。

如果指定的值匹配该标签就会创建其标签体内的内容。该标签用于以下情况：

• 检查具有指定名称的cookie是否与该标签的value匹配。
• 检查具有指定名称的header是否与该标签的value匹配。
• 检查具有指定名称的JSP Bean是否与该标签的value匹配 或 检查具有指定名称的JSP Bean中的property属性值是否与该标签的value匹配。
• 检查request中指定名称的参数值是否与该标签的value匹配。

下面的代码示例了logic:match标签的典型用法：

<logic:present header="User-Agent">
<logic:match header="User-Agent" value="MSIE 6.0">
MS IE 6.0
</logic:match>
</logic:present>

logic:notMatch标签的应用正好和logic:match标签相反。

logic:equal

这里要介绍的不只是logic:equal(=)标签，而是要介绍一类标签，这类标签完成比较运算，包括：

• logic:equal(=)
• logic:notEqual(!=)
• logic:greaterEqual(>=)
• logic:lessEqual(<=)
• logic:graterThan(>)
• logic:lessThan(<)

该类标签的用法类似，我们只介绍logic:equal标签，其它的留给您自己去完成。

logic:equal是用来判断是否相等的。如果相等，该标签体中嵌入的内容就会被处理。该标签用于以下情况：

• 比较由该标签的cookie属性指定的cookie的值是否与该标签的value属性值相等。
• 比较由该标签的header属性指定的header的值是否与该标签的value属性值相等。
• 比较由该标签的name属性指定的JSP Bean是否与该标签的value属性值相等(property属性不出现)或比较由该标签的name属性指定的JSP Bean中的property属性值是否与该标签的value属性值相等。
• 比较由该标签的parameter属性指定的参数值(request中)是否与该标签的value属性值相等。

logic:forward

我觉得将forward和redirect这两个动作放到一起对比着介绍更加有利于理解，基于此原因也就将logic:forward和logic:redirect这两个标签也拿到这里一起介绍了。

让我们看看这两个动作的区别：

• forward是在servlet内部执行，浏览器完全不会感知到这个动作，原始的url也不会改变，浏览器重新装载的话也只是对原始的请求进行简单的重复。
• redirect则分成两个步骤：第一步是web应用程序告诉浏览器第二个url，然后浏览器向第二个url发送请求。

redirect比forward慢，因为浏览器要做二次请求。还有就是要注意，在第一次的请求作用域(request作用域)内的bean对于第二次请求是不可见的。

理解了上面描述的区别也就知道了什么时候该选用logic:forward标签什么时候该选用logic:redirect标签了。logic:forward标签完成PageContext.forward()或HttpServletResponse.sendRedirect()，如何选择由控制器决定。logic:redirect标签完成HttpServletResponse.sendRedirect()。

在使用logic:redirect标签时我们可以向使用html:link一样构造baseurl和query参数。如果您感兴趣可以参考html:link标签。

总结

这篇指南的背景是Struts-1.2.9，其中的所有的代码示例也都是在这个版本下调试通过的。目前Struts仍然在快速的发展中，但是从开发者应用的角度来讲还是比较稳定的。因此我有理由相信其中的代码示例也可以很好的运行在其它的版本之上。最后希望这篇指南能够让您心情愉快！

<logic:equal>变量等于指定的常量

<logic:notEqual>变量不等于指定的常量

<logic:lessThan>变量小于指定的常量

<logic:lessEqual>变量小于或者等于指定的常量

<logic:geraterThan>变量大于指定的常量

<logic:geraterEqual>变量大于或等于指定的常量

以上这些标签都很类似,有共同的属性,cookie属性指定cookie属性的值,然后用value设置的常量进行比较.header属性设置header请求头的值,也是通过value属性设置的值进行比较.parameter属性设置一个请求参数,然后也是通过value属性设置的值进行比较.name属性设置一个变量,然后用value比较.如果同时设置了name和property属性,此时name属性指定已经存在的JavaBean,property属性指定Bean的属性.这个标签感觉十分简单,用法也十分单一,下面研究一下进行字符串匹配的标签和判断特定内容的标签.

<logic:match>标签是判断变量种是否包含常量字符串的,<logic:netMatch>也判断是否不包含字符串的,用name属性定义一个字符串变量,然后用value属性的值去判断变量是否包含这个字符串或者是不包含这个字符串,判断成功返回true.

<logic:empty>和<logic:netEmpty>标签可以判断指定的变量是否为空的字符串,可以通过name属性来判断一个字符串是否为null.例如是请求参数的字符串.

<logic:present>和<logic:notPresent>标签可以判断指定的对象是否为空,这个标签的属性很多.cookie属性判断Cookie是否存在.Header属性判断HTPP请求头是否存在.role属性是判断当前的权限的用户是否是指定的安全角色.user属性是判断当前通过权限验证的用户是否拥有指定的用户名.parameter属性是判断请求的参数是否存在.name属性是用来判断指定的Bean是否存在.同时设置name和property属性就是判断Bean种的具体属性是否存在了.

<logic:messagesPresent>和<logic:messagesNotPresent>标签是用来判断是否在request范围内的特定的ActionMessages或者是子类ActionErrors对象.name属性是用来检索ActionMessages对象的key,property指定从ActionMessages集合对象中检索某条消息key也就是具体的ActionMessage对象.

进行循环遍历Logic标签是Logic标签库中最复杂的标签,也是用途最广泛的标签,它能够在一个循环中遍历数组,Collection,Enumeration,Irerator或者Map中的所有元素

1)              遍历集合的标签<logic:iterate>的name属性指定需要进行遍历的集合对象,它每次从集合中检索出一个元素,然后存放在page范围内,并以id属性指定这个字符串来命名这个元素,最好是在里面嵌套一个<bean:write>标签,把刚刚遍历的第一个id指定的字符串输出,然后在循环在输出.length属性需要遍历的元素的数目,如果没有设置length属性,就遍历集合中的所有元素.offset属性指定开始遍历的其实位置,默认值是0.indexId属性定义一个代表当前被遍历元素的系列号,这个变量存放在page范围内,可以被<bean:write>标签访问输出输出的是int的数字.例如1.2.3.4等.可以用户输出输出的元素的系列号.

2)              遍历Map是通过<logic:iterate>标签,name属性指定一个HashMap,存放在request范围,然后赋给id指定的变量,indexId可以指定索引编号,然后通过<bean:write>标签输出出来.在HashMap的每一个元素都是一个集合对象,所以可以嵌套使用.就是说<logic:inerate>这个标签既可以把Collection的元素弄出来负给一个变量也可以弄Map的.所以说它的功能强大.还有一个collection属性可以设置一个表达式,这个表达式返回的结果可以作为,<logic:inerate>标签输出的集合或者Map.这个属性类似name属性.

最后研究一下进行请求转发和重定向的Logic标签,<logic:forward>标签用于请求转发,它的name属性指定转发的目标,与Struts配置文件中的<global-forwards>元素和的子元素<forward>元素匹配.简单的说就是<logic:forward>标签的name属性定义的值,要去找到<golbal-forwards>子元素<forward>元素的匹配的name属性,然后通过path指定的路径进行转发.重定向用<logic:redierct>标签它的forward,href和page属性指定重定向的目标,这几个属性和<html:link>标签的属性用法十分相似.

关于标签的部分我就说到这里,因为我个人觉得在Struts中最常用的无非也就是这三个标签库了.我以前还写过一个Struts的分页应用,过些天继续发布到我的Blog上. (网友们的支持,是我继续写技术文章的动力!)

< plug - in className = " org.apache.struts.validator.ValidatorPlugIn " >
     < set - property property = " pathnames "  value = " /WEB-INF/validator-rules.xml,/WEB-INF/validator/validation.xml "   />
     < set - property property = " stopOnFirstError "  value = " true "   />
   </ plug - in >
其中 < set - property property = " stopOnFirstError "  value = " true "   /> 是什么意思？？？

再比如：

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

转贴来自：http://www.xdfbc.net/program/2007/3/22/5411908.htm

创建一个实现了org.apache.struts.action.PlugIn接口的类文件并在struts - config.xml中设置plug - in元素。以下代码片段显示了一个plug - in生命声明和一个自定义的set - property子元素：

< plug - in className = " com.oreilly.strutsckbk.CustomPlugin "   >

   < set - property property = " customData "

                   value = " Hello from the plugin " />

</ plug - in >

n   细节讨论：

Struts提供一个 PlugIn接口能使你在启动应用程序时为你提供自定义的操作。其源代码如下：

package  org.apache.struts.action;

 

import  javax.servlet.ServletException;

import  org.apache.struts.config.ModuleConfig;

 

public   interface  PlugIn  {

     void  destroy();

     void  init(ActionServlet servlet, ModuleConfig config)

         throws  ServletException;

}

要实现一个plug - in，你只需要实现这个接口并在struts - config.xml文件的中声明plug - in元素。子类必须实现方法destroy()和init()。init()在ActionServlet启动时实例化plug - in过程中执行，当ActionServlet结束时执行destroy(),一般情况下是应用程序关闭。通过在plug - in元素中设置set - property元素，可以向PlugIn类传递参数。

所有set - property元素都在init()方法执行之前被执行，这样就可以在init()方法中使用这些由set - property设置的参数了。

Struts将ActionServlet的引用和ModuleConfig参数传递给init()方法。ActionServlet使的init()方法中可以将数据保存到ServletContext中。ActionServlet还可以使你能够访问更多的J2EE组件如java sources、message队列等。ModuleConfig可以让你访问当前的模块配置信息。

n   举例说明：

你需要定义一个plug - in记录应用程序何时运行的及运行了多久。

TimeTracker.java:

package  com.yourcompany.struts.plugin;

 

import  java.util.Date;

 

public   class  TimeTracker  {

 

   private   long  startUpTimeMillis;

   private  Date startedOn;

 

   public  TimeTracker( )  {

     startUpTimeMillis  =  System.currentTimeMillis( );

     startedOn  =   new  Date( );

   }

 

   public   long  getUptime( )  {

     return  System.currentTimeMillis( )  -  startUpTimeMillis;

  }

 

   public  Date getStartedOn( )  {

     return  startedOn;

  }

}

创建一个PlugIn子类TimeTrackerPlugin。TimeTrackerPlugi将TimeTracker保存在ServletContext中，键名由由plug - in元素的set - propery子元素指定：

TimeTrackerPlugin.java:

package  com.yourcompany.struts.plugin;

 

import  javax.servlet.ServletException;

import  org.apache.struts.action.ActionServlet;

import  org.apache.struts.action.PlugIn;

import  org.apache.struts.config.ModuleConfig;

 

public   class  TimeTrackerPlugin  implements  PlugIn  {

 

     private  String contextKey;

   

    public   void  setContextKey(String key)  {

        this .contextKey  =  key;

   }

   

    public   void  init(ActionServlet servlet, ModuleConfig conf)

          throws  ServletException  {

      servlet.getServletContext( ).setAttribute(contextKey,  new  TimeTracker( ));

   }

 

    public   void  destroy( )  {

    }

}

struts - config.xml:

   < plug - in className = " com.yourcompany.struts.plugin.TimeTrackerPlugin " >

     < set - property property = " contextKey "  value = " timeTracker " />

   </ plug - in >

 

你可以使用如下的JSP片段访问TimTracker，并显示关于应用程序运行时间的信息。

 

n   你也可以在web.xml中配置一个Servlet实现plug - in的功能将load - on - startup值设置为一个较低的值如1。他将在应用程序启动是自动加载并执行。容器在实例化Servlet后将调用此Servlet的init()方法。比较而言，使用plug - in有更多的优势：

1 .  一般情况下Struts应用程序设置好web.xml后，在开发过程中不许要改动他的内容。在web.xml中增加servlet意味着增加了一个维护对象。

2 .  plug - in接口提供了访问struts应用程序特有的信息的能力。

plug - in的声明周期跟ActionSerlvet的生命周期一致。他可以保证你的struts应用程序需要的信息可用。

王和全 ,

转自：http://www-128.ibm.com/developerworks/cn/java/l-struts1-1/

作为基于MVC模式的Web应用最经典框架，Struts已经正式推出了1.1版本，该版本在以往版本的基础上，提供了许多激动人心的新功能。本文就将带你走进Struts 1.1去深入地了解这些功能。

说明：希望本文的读者能有一定的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方法来完成不同的处理。下表列出其中几个主要的方法：

回页首

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启动时，controller会读入一个配置文件struts-config.xml，其中定义了前端请求的url与相应的Action类及使用的Form类的映射关系，下面是一个struts-config.xml中的片断：

从中可以看出，这个action会响应url类似于/logon的请求（在后面我们会看到，这儿的实际的url要根据在web.xml中配置，比如可能为/logon.do或/logon.other之类的带后缀的url），负责处理这个请求的action类是org.apache.struts.webapp.example.LogonAction，使用的FormBean是logonForm，scope界定了这个FormBean存在的范围是只在当前request中存在。
struts会读入这些设置，生成相应的org.apache.action.ActionMapping对象。controller正是使用这些mapping来把HTTP请求转发到应用的actions。一个ActionMapping指定了

• 一个请求URI
• 对应的类（Action的子类）
• 需要的属性

对于一个DB应用，

• 一个商业逻辑Bean用于连接、查询数据库
• 这个Bean返回结果到Action
• Action将这些结果存储到request的form bean中
• Jsp显示

 转自：http://www.javaresearch.org/article/showarticle.jsp?column=23&thread=256

一直以来我们都说Struts是一个Web Framework。那么让我么先来看看什么是Framework。

Framework概念并不是很新了，伴随着软件开发的发展，在多层的软件开发项目中，可重用、易扩展的，而且是经过良好测试的软件组件，越来越为人们所青睐。这意味着人们可以将充裕的时间用来分析、构建业务逻辑的应用上，而非繁杂的代码工程。于是人们将相同类型问题的解决途径进行抽象，抽取成一个应用框架。这也就是我们所说的Framework。

   Framework的体系提供了一套明确机制，从而让开发人员很容易的扩展和控制整个Framework开发上的结构。   通常，Framework的结构中都有一个“命令和控制”组件（"command and control" component）——Framework Factory and Manager。

用Struts建立MVC应用的介绍

文档选项 将此页作为电子邮件发送 未显示需要 JavaScript 的文档选项 对此页的评价 帮助我们改进这些内容 级别: 初级 赵晨希, 2002 年 12 月 11 日 本文讲述了如何用Struts建立MVC应用。 Model 1 和Model 2简介 我们在开发Web应用时经常提到的一个概念是Model 1/Model 2，那么到底它是什么意思呢？其实它是对采用JSP技术构成Web应用的不同模型的描述。下面对这个概念做一个简单的介绍。 Model 1 在使用JAVA技术建立Web应用的实例中，由于JSP技术的发展，很快这种便于掌握和可实现快速开发的技术就成了创建Web应用的主要技术。JSP页面中可以非常容易地结合业务逻辑(jsp:useBean)、服务端处理过程（jsp:scriplet）和HTML(<html>)，在JSP页面中同时实现显示，业务逻辑和流程控制，从而可以快速地完成应用开发。现在很多的Web应用就是由一组JSP页面构成的。这种以JSP为中心的开发模型我们可以称之为Model 1。 当然这种开发模式在进行快速和小规模的应用开发时，是有非常大的优势，但是从工程化的角度考虑，它也有一些不足之处： 应用的实现一般是基于过程的,一组JSP页面实现一个业务流程，如果要进行改动，必须在多个地方进行修改。这样非常不利于应用扩展和更新。 由于应用不是建立在模块上的, 业务逻辑和表示逻辑混合在JSP页面中没有进行抽象和分离。所以非常不利于应用系统业务的重用和改动。 考虑到这些问题在开发大型的Web应用时必须采用不同的设计模式--这就是Model2 Model 2 Model 2 表示的是基于MVC模式的框架。MVC是Model－View－Controller的简写。"Model" 代表的是应用的业务逻辑（通过JavaBean，EJB组件实现）， "View" 是应用的表示面（由JSP页面产生），"Controller" 是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。从而弥补了Model 1的不足。 Model 2具有组件化的优点从而更易于实现对大规模系统的开发和管理，但是开发MVC系统比简单的JSP开发要复杂许多，它需要更多的时间学习和掌握。同时新东西的引入会带来新的问题（这让我想起来关于"自动计算"的一篇文章，中间提到为了降低系统的复杂度，却导致更高的复杂度）。 必须基于MVC组件的方式重新思考和设计应用结构。原来通过建立一个简单的JSP页面就能实现的应用现在变成了多个步骤的设计和实现过程。 所有的页面和组件必须在MVC框架中实现，所以必须进行附加地开发工作。 MVC本身就是一个非常复杂的系统，所以采用MVC实现Web应用时，最好选一个现成的MVC框架，在此之下进行开发，从而取得事半功倍的效果。现在有很多可供使用的MVC框架，由于Struts有完整的文档并且相对来讲比较简单，所以用它开发MVC系统还是比较方便地。 回页首 Struts的结构和处理流程简介 Struts是Apache组织的一个项目，像其他的Apache组织的项目一样，它也是开放源码项目。Struts是一个比较好的MVC框架提供了对开发MVC系统的底层支持，它采用的主要技术是Servlet，JSP和custom tag library。获取它的使用版本和具体信息可以查阅 http://jakarta.apache.org网站。 Struts框架的基本构成由下图所示： 图 1 struts uml图 作为一个MVC的框架，Struts对Model、View和Controller都提供了对应的实现组件，对应上面的UML图，分别进行介绍，并且看看它们是如何结合在一起的。 Controller：控制器的作用是从客户端接受请求，并且选择执行相应的业务逻辑，然后把响应结果送回到客户端。在Struts中Controller功能由图中ActionServlet和ActionMapping对象构成：核心是一个Servlet类型的对象ActionServlet，它用来接受客户端的请求。ActionServlet包括一组基于配置的ActionMapping对象，每个ActionMapping对象实现了一个请求到一个具体的Model部分中Action处理器对象之间的映射。 Model： MVC系统中的Model部分从概念上可以分为两类--系统的内部状态，和改变系统状态的动作。Struts为Model部分提供了Action和ActionForm对象：所有的Action处理器对象都是开发者从Struts的Action类派生的子类。Action处理器对象封装了具体的处理逻辑，调用业务逻辑模块，并且把响应提交到合适的View组件以产生响应。Struts提供的ActionForm组件对象，它可以通过定义属性描述客户端表单数据。开发者可以从它派生子类对象，利用它和Struts提供的自定义标记库结合可以实现对客户端的表单数据的良好封装和支持，Action处理器对象可以直接对它进行读写，而不再需要和request、response对象进行数据交互。通过ActionForm组件对象实现了对View和Model之间交互的支持。Struts通常建议使用一组JavaBean表示系统的内部状态，根据系统的复杂度也可以使用像Entity EJB 和 Session EJB等组件来实现系统状态。Struts建议在实现时把"做什么"（Action）和"如何做"（业务逻辑）分离。这样可以实现业务逻辑的重用。 View：Struts应用中的View部分是通过JSP技术实现的。Struts提供了自定义的标记库可以使用，通过这些自定义标记可以非常好地和系统的Model部分交互，通过使用这些自定义标记创建的JSP表单，可以实现和Model部分中的ActionForm的映射，完成对用户数据的封装，同时这些自定义标记还提供了像模板定制等多种显示功能。 Struts框架的处理流程清楚的体现了MVC系统的特点，简单的Struts组件结构如图2所示。Struts Controller ActionServlet处理客户请求，利用配置的ActionMapping对象把请求映射到Action处理器对象进行处理。Action处理对象访问ActionForm中的数据，处理和响应客户请求，它还调用后台的Bean组件，这些组件封装了具体的业务逻辑。Action处理器对象根据处理结果通知Controller，Controller进行下一步的处理。 图2 Struts框架的组件结构图 回页首 利用Struts框架开发MVC系统要做的工作 由于Struts已经为我们提供了一个非常好的MVC框架，我们利用Struts开发MVC系统时可以大大加快开发的速度。在开发时可以采用的一个开发流程如下（引自资料3）： 收集和定义应用需求。 基于数据采集和显示的原则定义和开发"屏幕显示"需求 。 为每一个"屏幕显示"定义访问路径。 定义ActionMappings建立到应用业务逻辑之间的联系。 开发满足"屏幕显示"需求的所有支持对象。 基于每一个"屏幕显示"需求提供的数据属性来创建对应的ActionForm对象 开发被ActionMapping调用的Action对象。 开发应用业务逻辑对象 (Bean，EJB，等等)。 对应ActionMapping设计的流程创建JSP页面。 建立合适的配置文件struts-config.xml ， web.xml。 开发/测试/部署 具体在使用Struts框架时，对应各个部分的开发工作主要包括： Model部分：采用JavaBean和EJB组件，设计和实现系统的业务逻辑。根据不同的请求从Action派生具体Action处理对象。完成"做什么"的任务来调用由Bean构成的业务组件。创建由ActionForm 的派生类实现对客户端表单数据的封装。 Controller部分：Struts为我们提供了核心控制部分的实现。我们只需要配置ActionMapping对象 View部分：为了使用Model中的ActionForm 对象，我们必须用Struts提供的自定义标记创建HTML 表单。利用Struts提供的自定义标记库编写用户界面把应用逻辑和显示逻辑分离。Struts框架通过这些自定义标记建立了View和Model之间的联系。Struts的自定义标记还提供了很多定制页面的功能。 同时需要编辑两个配置文件：web.xml和struts-config.xml。通过它们配置Struts系统中的各个模块之间的交互。下面对这两个配置文件做一些介绍： web.xml文件的配置： web应用中的web.xml是第一个要配置的地方，它描述了系统的Controller对象。在web.xml中增加如下标记 <servlet> <servlet-name>action</servlet-name> <servlet-class>org.apache.struts.action.ActionServlet</servlet-class> <init-param> <param-name>application</param-name> ・・・・・・ </servlet> 说明：这个servlet对象就是Struts提供的Controller，还可以为它指定初始化参数，比如对系统应用属性的支持。 <servlet-mapping> <servlet-name>action</servlet-name> <url-pattern>*.do</url-pattern> </servelt-mapping> 说明：实现客户请求的url信息和服务器端具体处理的映射关系。 <taglib> <taglib-url>/WEB-INF/struts-bean.tld</taglib-url> <taglib-location>/WEB-INF/struts-bean.tld</taglib-location> </taglib> ・・・・・・・ 说明：添加对Struts提供的应用所使用的自定义标记库的引用。 struts-config.xml文件的配置： struts-config.xml是用于建立Controller和Model之间的关系的。它描述了Controller所使用的把请求对应到具体处理的法则，同时它还描述了客户提供的数据与ActionForm组件的对应映射关系。 在struts-config.xml中增加如下标记 <form-beans> <form-bean name="loginForm" type="loginForm" /> </form-beans> 说明：<form-bean>标记描述一个具体的ActionForm子类对象，通过它和JSP页面中的自定标记的结合使用可以实现ActionForm和View之间的数据映射。 <action-mappings> <action path="/login" type="loginAction" name="loginForm" input="/login.jsp" ・・・ /> </action-mappings> 说明：<action-mappings>标记描述了请求和处理的一对一映射关系。input和path属性唯一的标记了客户端的一个请求，name属性描述封装客户端的数据的ActionForm子类对象。Type属性描述处理这个请求的Action子类对象。 通过对两个配置文件的配置，把Struts框架中MVC的各个部分联系起来，实现一个真正的MVC系统。 回页首 可供参考的例子 编写一个好的例子演示是比较占篇幅的，可以从 http://jakarta.apache.org/下载Struts最新的发表包，在这个包中有详细的用户帮助和API文档，还有非常好的演示程序可供参考。具体的安装步骤可以参考附带的文档。参考这些例子可以很快地理解如何利用struts框架开发MVC系统。 回页首 参考资料 The Struts User's Guide http://Jakarta.apache.org "Struts Tutorial" 作者：Stephan Wiesner 主页 www.stephanwiesner.de Struts系列文章 http://www.onjava.com/onjava/open_source/ 《设计模式》Gamma 等四人 回页首 关于作者 赵晨希，一直集中在服务器端的程序开发上，喜欢用C++和Java编程，对新技术有极大的兴趣，目前个人兴趣在J2EE上和Open Source的项目上。希望和更多的爱好者交流。 Email： zhaochenxi@vip.sina.com