Struts 校验器总结

验证器：

从0.5版，验证器在一些form中就已经实现了，他最初包含在开发人员包中，后来核心代码挪到Jakarta Commons包中和Struts特别扩展中作为 Struts 1.1的一部分。许多开发者为方便一直使用struts验证器，这篇文档首先概述验证器的核心功能性，然后大概介绍在 struts1.1中的变化和新增功能。

如果你配置好验证器插件，你应该扩展ValidatorForm而不是ActionForm，以便它能加载你的Validator资源。他根据struts-config.xml文件中的action的name属性为当前form的调用相应的验证器，因此在validator-rules.xml中的form元素的名称属性应该与action的name属性值相匹配。

另外一种选择是扩展ValidatorActionForm 而不是ValidatorForm，ValidatorActionForm使用struts-config.xml中action的path属性，所以path属性的值相应的应该与validator-rules.xml中的Form的name属性匹配。

一个分离的action可以定义给多页form的每个页面，而且验证规则可以与action关联而不是与页码，就像验证范例中的多页form范例那样。

国际化

在validator-rules.xml 文件中form的验证规则可以组织为FormSet。FormSet 有与java.util.Locale 类相应的属性：如语言, 国家以及变量型属性，如果他们未定义，FormSet 将把它设置为默认值。一个FormSet 也可以有关联的常量。另外还可以定义与FormSet 同一级别的全局global元素，他与FormSet同样也有常量。

注意：你必须在国际化的FormSet前声明一个没有国际化的默认FormSet。这样如果Validator没有找到locale时可以有一个默认版本。

       可插入验证器的默认错误信息值可以被msg元素覆盖。所以为mask验证器生成错误信息的替代方法就是使用msg属性，如果字段的name属性与验证器的name属性匹配，那末将使用字段的msg属性。

       error messages的可以设置arg0-arg3 等参数元素。如果没有设置arg0-arg3的name属性， error messages将使用他们作为默认的构建参数值。如果设置了name属性，你就可以把参数指定给一特定的可插入验证器，然后这些参数将在构造错误信息时被使用。

<field

property="lastName"

depends="required,mask">

<msg

name="mask"

key="registrationForm.lastname.maskmsg"/>

<arg0 key="registrationForm.lastname.displayname"/>

<var>

<var-name>mask</var-name>

<var-value>^[a-zA-Z]*$</var-value>

</var>

</field>

默认的arg0-arg3元素将在消息资源中查找相应的key，如果资源属性设为false，她将把值直接传进去，而不从消息资源中查找。注意1.1版本中，你必须为每个模块中明确地定义在验证中用到的消息资源，否则将使用top-level资源。

<field

property="integer"

depends="required,integer,intRange">

<arg0 key="typeForm.integer.displayname"/>

<arg1

name="range"

key="${var:min}"

resource="false"/>

<arg2

name="range"

key="${var:max}"

resource="false"/>

<var>

<var-name>min</var-name>

<var-value>10</var-value>

</var>

<var>

<var-name>max</var-name>

<var-value>20</var-value>

</var>

</field>

常量/变量

全局的常量可以在全局标签中定义，FormSet/本地常量能在formset 标签中创建。常量当前仅仅是代替字段的property属性，字段的var 元素的 value属性，字段的msg 元素的 key属性，字段的arg0-arg3 元素的 key属性。字段的变量也可以在arg0-arg3 元素中被代替（例如：${var:min}））。替换的顺序是FormSet/Locale常量第一，全局的常量第二，

arg elements 变量最后。

<global>

<constant>

<constant-name>zip</constant-name>

<constant-value>^\d{5}(-\d{4})?$</constant-value>

</constant>

</global>

 

<field

property="zip"

depends="required,mask">

<arg0 key="registrationForm.zippostal.displayname"/>

<var>

<var-name>mask</var-name>

<var-value>${zip}</var-value>

</var>

</field>

验证器可以使用字段下面的变量部分来存储变量，这些变量通过字段的getVar（(String key)方法取得。

<field

property="integer"

depends="required,integer,intRange">

<arg0 key="typeForm.integer.displayname"/>

<arg1

name="range"

key="${var:min}" resource="false"/>

<arg2

name="range"

key="${var:max}" resource="false"/>

<var>

<var-name>min</var-name>

<var-value>10</var-value>

</var>

<var>

<var-name>max</var-name>

<var-value>20</var-value>

</var>

</field>

使用validwhen设计复杂的验证

使用validwhen来设计复杂验证的一个经常的要求就是根据一个字段验证另外一个字段（比如, 如果你要用户两次输入口令来确认值口令一致），另外一个就是表单中的一个字段只有另外一个字段有确定值的时候才是必须输入的。新的validwhen验证规则将很快被包含在1.1后的STRUTS版本中，她就是用来处理这种情况的。

       validwhen 规则处理单个的变量字段，叫测试。这变量的值是一个布尔的表达式，如果验证有效则它必须为真。可以包含这种变量的表达式有：

u       单引号或双引号字符串literals，

u       十进制、十六进制、八进制的Integer literals，

u       null与null和空字符串匹配，

u       其它可以用属性名引用的form字段,例如customerAge，

u       可以在外部因用得索引字段, 例如childLastName[2]，

u       可以默认implicit因用得索引字段, 例如childLastName[], 她将作为被索引的字段使用同样的索引到数组中，

The literal *这里指它包含当前测试字段的值，

作为例子，考虑一个包含通讯地址和邮箱字段的form。如果通讯地址不为空则邮箱字段是必须的required。你能这样定义validwhen 规则：

<field property="emailAddress" depends="validwhen">

<arg0 key="userinfo.emailAddress.label"/>

<var>

<var-name>test</var-name>

<var-value>((sendNewsletter == null) or (*this* != null))</var-value>

</var>

</field>

上面定义的意思是：如果通讯地址是空或不空时这个字段时有效的。

这里有个稍微复杂的例子，它使用了索引字段。假定有一个表单，允许用户输入他们希望定购的部件号和数量。类orderLine 的bean的一数组被用来在称为orderLines 的一属性保持输入项。

If you wished to verify that every line with part number also had a quantity entered, you could do it with:

如果你希望校验订单中有数量输入得每一行，你可以这样：

<field

property="quantity"

indexedListProperty="orderLines"

depends="validwhen">

<arg0 key="orderform.quantity.label"/>

<var>

<var-name>test</var-name>

<var-value>((orderLines[].partNumber == null) or (*this* != null))</var-value>

</var>

</field>

这里的意思是：如果相应的partNumber 字段是空, 或这字段是不空的，则这字段是有效的。

最后一个例子，想象一表单，用户必须输入他们的以英寸为单位的高度，如果他们在高度在60英寸以下，则出一错误。（it is an error to have checked off nbaPointGuard as a career.）

<field property="nbaPointGuard" depends="validwhen">

<arg0 key="careers.nbaPointGuard.label"/>

<var>

<var-name>test</var-name>

<var-value>((heightInInches >= 60) or (*this* == null))</var-value>

</var>

</field>

 

给程序员的简单说明：

所有的比较关系必须在parens 封装。All comparisons must be enclosed in parens.

只有两个itme时可以and或or链接。

如果比较的两item都可以转为整数，则使用numeric比较，否则使用字符串比较。

可插入验证器

验证是从validation.xml 文件中加载的，默认的验证规则定义在validation.xml 文件中，默认定义了required, mask ,byte, short, int, long, float, double, date (没有本地支持), and a numeric range。

" mask "方式依赖于默认值安装要求，那意味着"required "可以完成，在"'mask "将运行以前"required "和" mask "方式被默认包含进框架中了。任何字段如果不是"required "而且是空或有零长度将跳过其他验证。

如果使用了Javascript 标签，客户端javascript在validator's javascript 属性中查找值而且产生一个有验证form方法的对象，要得到更多的关于Javascript Validator 标签工作细节的详细的解释,参阅html标签API参考。

"'mask' "方式让你用一正则表达式掩码验证字段，它使用jakarta的正规表达式包，所有的有效性规则存储在validator-rules.xml 文件，使用的主类是org.apache.regexp.RE。

validation.xml文件中的验证器配置范例：

<validator name="required"

classname="org.apache.struts.validator.FieldChecks"

method="validateRequired"

methodParams="java.lang.Object,

org.apache.commons.validator.ValidatorAction,

org.apache.commons.validator.Field,

org.apache.struts.action.ActionErrors,

javax.servlet.http.HttpServletRequest"

msg="errors.required">

<validator name="mask"

classname="org.apache.struts.validator.FieldChecks"

method="validateMask"

methodParams="java.lang.Object,

org.apache.commons.validator.ValidatorAction,

org.apache.commons.validator.Field,

org.apache.struts.action.ActionErrors,

javax.servlet.http.HttpServletRequest"

msg="errors.invalid">

 

定义可插入验证器

方法的参数是用逗号分隔的一些类名称列表，方法属性需要有一个符合上面的列表的签名。列表由以下组合而成：

java.lang.Object - 要验证的Bean。

org.apache.commons.validator.ValidatorAction - 当前ValidatorAction。

org.apache.commons.validator.Field - 要验证的字段

org.apache.struts.action.ActionErrors - 如果验证错误将加入ActionError的错误对象javax.servlet.http.HttpServletRequest -当前request 对象。

javax.servlet.ServletContext - 应用的ServletContext。

org.apache.commons.validator.Validator-当前的org.apache.commons.validator.Validator实例。

java.util.Locale - 当前用户的Locale。

多页面form

字段部分有一可选的页面属性，它可以被设为整数，页上字段的所有验证小于或等于服务器端验证的当前页，页上字段的所有验证小于或等于客户端页上所有字段的验证小于或等于服务器端验证的当前页验证的当前页。一个mutli-part表单需要定义页面属性：

<html:hidden property="page" value="1"/>。

比较两个字段

这是一个展示你怎样才能比较两个字段是否有一样的值的例子。比如"用户改变他们的口令"一般会有口令字段和一确认字段。

<validator name="twofields"

classname="com.mysite.StrutsValidator"

method="validateTwoFields"

msg="errors.twofields"/>

<field property="password" depends="required,twofields">

<arg0 key="typeForm.password.displayname"/>

<var>

<var-name>secondProperty</var-name>

<var-value>password2</var-value>

</var>

</field>

 

public static boolean validateTwoFields(

Object bean, ValidatorAction va, 

Field field, ActionErrors errors, HttpServletRequest request, 

ServletContext application) {

String value = ValidatorUtils.getValueAsString( bean,  field.getProperty());

String sProperty2 = field.getVarValue("secondProperty");

String value2 = ValidatorUtils.getValueAsString( bean,  sProperty2);

 

       if (!GenericValidator.isBlankOrNull(value)) {

try {

if (!value.equals(value2)) {

errors.add(field.getKey(),

Resources.getActionError( application, request, va, field));

                            return false;

}

} catch (Exception e) {

errors.add(field.getKey(), Resources.getActionError( application, request, va, field));

return false;

}

}

}

已知的bug

Struts Validator依赖于Commons Validator包，所以问题报告和增强需求可能在两个产品中列出。

·   Struts Validator Bugzilla Reports

·   Commons Validator Bugzilla Reports

变更和deprecations

新建的标记属性。

<html:javascript>标记有新的属性定义.

使用commons-validator.jar中的DTD验证。

当前使用的验证XML文件是根据commons-validator.jar中的DTD。Struts不在为validator-rules.xml and validator.xml.单独维护一个分离的DTD，另外,commons-validator 现在维护一个统一的validator.dtd。修改所有validator.xml文件的DTD引用为

<!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">

空字段。

当前默认在所有得基础验证类型中忽略空白的字段，如果你要求一个字段必须输入，那末在你的应用的validator.xml 文件相应的字段定义的depends属性中添加 " required "。

新建的范围RANGE方法.

JavaScript 和JAVA中都添加了intRange & floatRange 方法。

有条件地REQUIRED字段.

最大的修改是添加了基于其她字段的值的有条件地require验证的能力。它允许你定义逻辑如："只有X字段非空的时候Y字段为'male'才有效"，这是实现上述逻辑的推荐方法，这种方法在1.1版后的第一版将实现。在1.1版中添加的Requiredif验证规则，将在新版中去掉。不过，如果你正准备使用requiredif，这里有一个简短的教程。

       让我们假定你有一个有3个字段的医药的信息表单，性别sex，怀孕测试pregnancyTest，测试结果testResult，如果性别为'f' or 'F'，则怀孕测试pregnancyTest是required，如果pregnancyTest不是空，测试结果testResult是required。

你的validation.xml 文件的输入项应该是这样的：

<form name="medicalStatusForm">

<field property="pregnancyTest" depends="requiredif">

<arg0 key="medicalStatusForm.pregnancyTest.label"/>

<var>

<var-name>field[0]</var-name>

<var-value>sex</var-value>

</var>

<var>

<var-name>fieldTest[0]</var-name>

<var-value>EQUAL</var-value>

</var>

<var>

<var-name>fieldValue[0]</var-name>

<var-value>F</var-value>

</var>

<var>

<var-name>field[1]</var-name>

<var-value>sex</var-value>

</var>

<var>

<var-name>fieldTest[1]</var-name>

<var-value>EQUAL</var-value>

</var>

<var>

<var-name>fieldValue[1]</var-name>

<var-value>f</var-value>

</var>

<var>

<var-name>fieldJoin</var-name>

<var-value>OR</var-value>

</var>

</field>

<field property="testResult" depends="requiredif">

<arg0 key="medicalStatusForm.testResult.label"/>

<var>

<var-name>field[0]</var-name>

<var-value>pregnancyTest</var-value>

</var>

<var>

<var-name>fieldTest[0]</var-name>

<var-value>NOTNULL</var-value>

</var>

</field>

</form>

 

这里有一个使用索引的属性更复杂的例子，如果你的struts-config.xml 有这下面：

<form-bean name="dependentlistForm"

type="org.apache.struts.webapp.validator.forms.ValidatorForm">

<form-property

name="dependents"

type="org.apache.struts.webapp.validator.Dependent[]" size="10"/>

<form-property name="insureDependents" type="java.lang.Boolean" initial="false"/>

</form-bean>

这里dependentlistForm bean有lastName，firstName，dob，coverageType四个属性，你可以这样定义一验证规则：

<form name="dependentlistForm">

<field

property="firstName" indexedListProperty="dependents" depends="requiredif">

<arg0 key="dependentlistForm.firstName.label"/>

<var>

<var-name>field[0]</var-name>

<var-value>lastName</var-value>

</var>

<var>

<var-name>fieldIndexed[0]</var-name>

<var-value>true</var-value>

</var>

<var>

<var-name>fieldTest[0]</var-name>

<var-value>NOTNULL</var-value>

</var>

</field>

 

<field

property="dob" indexedListProperty="dependents" depends="requiredif,date">

<arg0 key="dependentlistForm.dob.label"/>

<var>

<var-name>field[0]</var-name>

<var-value>lastName</var-value>

</var>

<var>

<var-name>fieldIndexed[0]</var-name>

<var-value>true</var-value>

</var>

<var>

<var-name>fieldTest[0]</var-name>

<var-value>NOTNULL</var-value>

</var>

</field>

 

<field

property="coverageType" indexedListProperty="dependents" depends="requiredif">

<arg0 key="dependentlistForm.coverageType.label"/>

<var>

<var-name>field[0]</var-name>

<var-value>lastName</var-value>

</var>

<var>

<var-name>fieldIndexed[0]</var-name>

<var-value>true</var-value>

</var>

<var>

<var-name>fieldTest[0]</var-name>

<var-value>NOTNULL</var-value>

</var>

<var>

<var-name>field[1]</var-name>

<var-value>insureDependents</var-value>

</var>

<var>

<var-name>fieldTest[1]</var-name>

<var-value>EQUAL</var-value>

</var>

<var>

<var-name>fieldValue[1]</var-name>

<var-value>true</var-value>

</var>

<var>

<var-name>fieldJoin</var-name>

<var-value>AND</var-value>

</var>

</field>

</form>

这里的意思是：

如果lastName 字段是非空的，firstName 字段required。因为字段Indexed 为真，这它意味着lastName的indexed 必须与firstName 的索引的一样，dob同理，除非date不为空。

如果lastName 用样索引时的值不空, 而且非索引字段insureDependents为真，则coverageType 是only require。

你可以对字段在[n]中使用任意数字，唯一的限制是他们必须都是AND或OR,你无法混合使用。

Deprecation：

u       JavaScript 和Java的range方法.

u       StrutsValidator &StrutsValidatorUtil 类中的Deprecation方法

验证器api指南

一个简明的Struts验证器API指南 可以帮助你开始。

验证器资源

Struts Validator: Validating Two Fields Match 作者Matt Raible。（两个字段匹配验证）关于使用方法的文章。（范例部分为翻译此文内容）

DynaForms and the Validator 作者James Turner and Kevin Bedell。Struts Kickstart的其中一章（动态form和验证器），可以自由下载PDF).

Validating user input 作者 David Winterfeldt and Ted Husted。Struts in Action的其中一章，可以自由下载(PDF)。

使用方法

作者：

丑陋 && Snowtears：经过2周的不懈努力，阅读了大量的资料，终于对Validator有了个初步的认识，整理了一下，浅浅的谈了谈写法，希望能有一定的帮助，其中肯定有许多说的不对不准确的地方，还请多指教 [e-mail]

       王艺：

       根据以上两位的文章正理而成

配置ruts-config.xml：

1、            添加ApplicationResources配置文件。

如：

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

<message-resources parameter="com.dc.sibss.om.struts.ApplicationResources" />

其中com.sibss.om.struts.ApplicationResources"的部分是资源文件的路径，此文件的作用是提供错误信息的非编程定制化和多语言支持。如果我们使用中文平台操作系统，则默认情况下将首先查找ApplicationResource_zh_CN.properties文件，然后是ApplicationResources_zh.properties，如果前两个文件没有被找到则将查找ApplicationResources.properties文件。

为了能够在页面上显示错误提示信息，我们还需要将以下内容添加到ApplicationResources.properties文件的末尾：

              errors.required={0} is required.

errors.minlength={0} cannot be less than {1} characters.

errors.maxlength={0} cannot be greater than {2} characters.

errors.invalid={0} is invalid.

errors.byte={0} must be an byte.

errors.short={0} must be an short.

errors.integer={0} must be an integer.

errors.long={0} must be an long.

errors.float={0} must be an float.

errors.double={0} must be an double.

errors.date={0} is not a date.

errors.range={0} is not in the range {1} through {2}.

errors.creditcard={0} is not a valid credit card number.

errors.email={0} is an invalid e-mail address.

以上仅是struts现在支持的错误类型的错误提示信息，如果你自定义了新类型的错误验证，则还需要在此加上你自己的内容。

以上内容中的{0}指的是错误提交的参数。比如：当你需要页面上的"用户名"不能为空时（也就是上面的errors.required），这个{0}就代表"用户名"，所以如果你没有填写用户名将抛出如下错误：

       用户名 is required.（你可以根据需要修改称中文）

我们可能已经注意到了，既然错误提示信息需要配置，那么上例中"用户名"系统是如何得到的呢？没错！也是通过修改此配置文件，内容如下：

       visitCust.error.name.required=<br>用户名

这样当"用户名"为空时，struts后台程序将联合以上两处定义显示错误信息。

另外，上面的"visitCust.error.name.required"是在Validation.xml配置验证内容时指定的。具体见以下介绍。

注意：一般情况下，你的系统只需要一个ApplicationResources文件，所以开发组的成员不要添加自己的resource文件。只有在你的项目分组开发时才需要使用多个ApplicationResources文件，但是，同时你的struts-config.xml文件也会有相同的数量对应。

2、            在struts-config.xml文件中加入validator插件：

加入这个插件后你的应用就具备使用Validator的环境，如：

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

</plug-in>

这里如果是想使用多个***.xml文件的话，value部分写法如下value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml, /WEB-INF/validation1.xml , /WEB-INF/validation2.xml "

在<action-mappings>里，定义需要验证的画面对应的Action的时候要加上validate="true"

四种使用方法

1、            用Javascript在客户端进行验证

配置：在需要验证的JSP文件中写入

<html:form action="/XXX" onsubmit="return validateXXXX(this);">

这里的XXX 是与要进行验证的 forward name，validateXXXX (this);里面的XXXX是需要进行验证的ActionForm名。

<html:javascript formName="mytestForm"/>

在validation.xml文件中写入验证代码就可以进行基本的验证了。这种方法是在客户端进行验证，客户端可以看到JAVASCRIPT部分的全代码。安全性不高

2、            ValidatorForm的validate方法

1、validate（）方法：使自己的ActionForm继承ValidatorForm类，在里面编写自己的方法：

public ActionErrors validate (ActionMapping mapping,HttpServletRequest request) {

ActionErrors errors = new ActionErrors();

。。。。。。

if ( mytext.equals("aaa") ) {

//my exampleerrors.add("mytext",new ActionError("mytext.error"));

}

。。。。。。

return errors;

}

此时，如果写了这个方法，就会屏蔽掉在Validation.xml中定义的验证部分，换句话说就是系统运行时，Validation.xml里对应此ActionForm的定义的错误验证部分不实行，如果不写这个方法的话，系统运行时会进行Validation.xml里对应此ActionForm的定义的错误验证部分的操作。此类方法是在服务器端进行验证，验证部分代码客户端不可见。

2、创建你的ActionForm并让它继承org.apache.struts.validator.ValidatorForm类。创建你的Action实现，并和上面定义的ActionForm关联。这里需要注意的是，在定义此Action时一定将validate属性设置为true，并且在你定义的ActionForm中不要实现它的validate方法――这就意味着你将使用ValidatorForm的validate方法，这样才能保证你的错误验证正常进行。配置validation.xml文件。基本内容如下：

<form-validation>

<!-- ========== Default Language Form Definitions ===================== -->

    <formset>

              <form name="custGNewForm">需要验证页面上form的名字

                     <field property="certifiCode"需要校验的属性

                                   depends="required,maxlength">校验内容

                            <arg0 key="prompt.certifiCode"/>ApplicationResource文件中对应

                            <arg1 key="${var:maxlength}" name="maxlength" resouce="false"/>

                            <var>确定最长限制的长度

                                   <var-name>maxlength</var-name>

                                   <var-value>20</var-value>

                            </var>

                     </field>

注意：此处的arg0和arg1就代表了ApplicationResources文件中使用"{}"括起来的参数。比如：
errors.range={0} is not in the range {1} through {2}.
定义了三个参数，所以你这里也要定义<arg0>、<arg1>、<arg2>三个参数才能完整的显示错误信息。
errors.maxlength={0} cannot be greater than {2} characters.
定义了0、2两个参数，所以你就需要定义<arg0>和<arg2>两个参数。

                     <field        property="userName"

                                   depends="required,maxlength">

                            <arg0 key="prompt.userName"/>

                            <arg2 key="${var:maxlength}" name="maxlength" resouce="false"/>

                            <var>

                                   <var-name>maxlength</var-name>

                                   <var-value>80</var-value>

                            </var>

                     </field>

                     <field property="email"

                    depends="email">

                <arg0 key="prompt.email"/>

            </field>

              </form>

              <form name="custGNewCheckForm">

                     <field       property="certifiCode"

                                   depends="required">

                            <arg0 key="prompt.certifiCode"/>

                     </field>

              </form>

    </formset>

</form-validation>

在校验页面的<body>前添加如下内容：<html:errors/>

3、            DynaValidatorForm

不需要再写对应的ActionForm，只需在struts-config.xml里把自己的ActionForm进行配置：

<form-bean name="testForm" type="org.apache.struts.validator. DynaValidatorForm">

       <form-property name="mytext" type="java.lang.String"/>

<form-property name="mytextarea" type="java.lang.String"/>

       <form-property name="mydatetext" type="java.lang.String"/>

</form-bean>

在form-property里设置相应的项目，比如说mytext，mytextarea什么的，执行的时候会动态生成ActionForm，再在validation.xml里写入所希望的验证代码，就可以了。JSP文件里不需要写入任何东西，验证也是在服务器端进行，验证部分代码在JSP中不可见。

4、            组合验证

如果使用动态验证DynaValidatorForm的话，不许编写自己的对应的ActionForm，相应的特殊验证会受到相当程度的限制。这个时候，需要将特殊验证部分写入对应的Action，

if(mytext.equals("aaa")){//My Example

ActionErrors errors = new ActionErrors();

errors.add("***",new ActionError("***.error"));      

saveErrors(request,errors);

return (mapping.findForward("false"));

}

就可以实现特殊验证了。

 

       实际上你的FORM还可以继承ValidatorActionForm和DynaValidatorActionForm，这两种与他们对应的ValidatorForm和DynaValidatorForm的唯一区别正如开篇就讲到的：在struts-config.xml中查找对应的FORM类时，前者根据ACTION的PATH值，而后者使用NAME值。

范例：

Struts 验证器：验证两个字段匹配
在使用指南中，有一节讲述怎样创建验证器来验证两个字段匹配，我用这个服务器端验证器（象例子中显示的那样）做口令，确定口令验证。这个已经可以正常工作了；但我还想用客户端的javascript验证器来试一试。我写了自己的程序来比较两个字段，但他们和推荐给你的那个不同（from validator-rules.xml）。所以昨天，我补充了怎样添加JavaScript方法到validator-rules.xml。 这里就是怎样配置的的整个过程（大部分在使用指南中已经包含了，保存JavaScript）。
怎样添加两个字段的验证器

Step 1: 生成一个包含validateTwoFields方法的类。在我的代码重，我的类定义为ValidationUtil，他有下列方法：

 

public static boolean validateTwoFields(

Object bean,

ValidatorAction va,                                       

Field field,

ActionErrors errors,

HttpServletRequest request) {

 

    String value = ValidatorUtil.getValueAsString(bean, field.getProperty());

    String sProperty2 = field.getVarValue("secondProperty");

String value2 = ValidatorUtil.getValueAsString(bean, sProperty2);

 

    if (!GenericValidator.isBlankOrNull(value)) {

        try {

            if (!value.equals(value2)) {

                errors.add(field.getKey(),

                           Resources.getActionError(request, va, field));

 

                return false;

            }

        } catch (Exception e) {

            errors.add(field.getKey(),

                       Resources.getActionError(request, va, field));

 

            return false;

        }

    }

 

    return true;

}

Step 2: 编辑 validator-rules.xml ，加入"twofields" 规则。

<validator name="twofields" classname="org.appfuse.webapp.util.ValidationUtil"

method="validateTwoFields"

    methodParams="java.lang.Object,

                  org.apache.commons.validator.ValidatorAction,

                  org.apache.commons.validator.Field,

                  org.apache.struts.action.ActionErrors,

                  javax.servlet.http.HttpServletRequest"

   depends="required" msg="errors.twofields">

    <javascript><![CDATA[

        function validateTwoFields(form) {

            var bValid = true;

            var focusField = null;

            var i = 0;

            var fields = new Array();

            oTwoFields = new twofields();

            for (x in oTwoFields) {

                var field = form[oTwoFields[x][0]];

                var secondField = form[oTwoFields[x][2]("secondProperty")];

           

                if (field.type == 'text' ||

                    field.type == 'textarea' ||

                    field.type == 'select-one' ||

                    field.type == 'radio' ||

                    field.type == 'password') {

           

                    var value;

                    var secondValue;

                    // get field's value

                    if (field.type == "select-one") {

                        var si = field.selectedIndex;

                        value = field.options[si].value;

                        secondValue = secondField.options[si].value;

                    } else {

                        value = field.value;

                        secondValue = secondField.value;

                    }

               

                    if (value != secondValue) {

                   

                        if (i == 0) {

                            focusField = field;

                        }

                        fields[i++] = oTwoFields[x][1];

                        bValid = false;

                    }

                }

            }

           

            if (fields.length > 0) {

                focusField.focus();

                alert(fields.join('\n'));

            }

           

            return bValid;

        }]]></javascript>

</validator>

Step 3: 在validation.xml中为你的表单配置验证：

<field property="password" depends="required,twofields">

  <msg name="required" key="errors.required"/>

  <msg name="twofields" key="errors.twofields"/>

  <arg0 key="userForm.password"/>

  <arg1 key="userForm.confirmPassword"/>

  <var>

    <var-name>secondProperty</var-name>

    <var-value>confirmPassword</var-value>

  </var>

</field>

这里errors.twofields的字段 '{0}'必须与字段'{1}' 的值相同。第三步的一个可选的工作就时使用 XDoclet 来生成validation.xml。requires (1) 配置XDoclet (当然)和(2) 在你的表单中添加添加一些@struts 标签setPassword方法。

/**

 * Returns the password.

 * @return String

 *

 * @struts.validator type="required" msgkey="errors.required"

 * @struts.validator type="twofields" msgkey="errors.twofields"

 * @struts.validator-args arg1resource="userForm.password"

 * @struts.validator-args arg1resource="userForm.confirmPassword"

 * @struts.validator-var name="secondProperty" value="confirmPassword"

 */

public String setPassword() {

       return password;

}

 

Struts提供的和Form相关的标签

一些Struts的表单标签总结。
 

与form相关的标签包括<form>标签本身以及所有必须包含在其中的标签。比如，<text>和<password>标签就是和form相关的标签，因为如果不把它们放到一个form中它们就没有意义。

<form>标签
<form>标签用于生成一个HTML form。使用该标签时必须遵循许多规则。

首先，<form>标签中必须包含一个action属性，它是这个标签中唯一必需的属性。如果不具备该属性则JSP页面会抛出一个异常。之后你必须给这个action属性指定一个有效值。一个有效值是指应用程序的Struts配置文件中<action-mappings>元素里的任何一个<action>子元素的访问路径。而且相应的<action>元素中必须有一个name属性，它的值是form bean的名称。

例如，如果你有这样一个<form>标签：   <html:form action="/login" >

那么你的Struts配置文件的<action-mappings>元素中必须有一个如下显示为粗体的<action>元素：
  <action-mappings>
     <action path="/login"
      type="com.javapro.struts.LoginAction" 
      name="loginForm"
      scope="request"
      input="/login.jsp">
      <forward name="success" path="/mainMenu.jsp"/>
    </action>
    .
    .
    .
  </action-mappings>
这就是说一个form标签是和form bean相关联的。

另一个要遵循的规则是：任何包含在<form>中用来接收用户输入的标签（<text>、<password>、<hidden>、<textarea>、<radio>、<checkbox>、<select>）必须在相关的form bean中有一个指定的属性值。比如，如果你有一个属性值被指定为"username"的<text>标签，那么相关的form bean中也必须有一个名为"username"的属性。输入<text>标签中的值会被用于生成form bean的userName属性。

除了上面所讲的属性之外，<form>标签还有一些不是必须但加上更好的"次要"的属性。比如，你可以用focus属性来生成JavaScript，它会"定焦"（focus）到该form所包含的一个元素上。使用focus属性时你需要给它指定元素的名称。比如，以下代码是定焦在第二个Text元素上的： <body>
<html:form action="/login" focus="password">
User Name: <html:text property="userName"/>
<br>Password: <html:text property="password"/>
<br><html:submit/>
</html:form>
</body>
该段代码会被转换成：
<body>
<form name="loginForm" method="post"
   action="/myStrutsApp6/login.do">
User Name: <input type="text" name="userName"
   value="">
<br>Password: <input type="text"
   name="password" value="">
<br><input type="submit"
   value="Submit">
</form>
<script language="JavaScript"
   type="text/javascript">
  <!--
 if (document.forms["loginForm"].elements[
      "password"].type != "hidden")
    document.forms["loginForm"].elements[
      "password"].focus()
  // -->
</script>

</body>
注意，<form>标签中method属性的缺省值是POST。另外，有没有看到这个标签库是如何建立JavaScript来定焦到password元素上的? 这也是该库让人着迷的地方之一。你不用担心如何在客户端进行编程，它会帮你自动生成。

在运行前面的例子时还要注意，你必须有一个包含userName和password属性的相关form。你可以参考本文第三部分中的Login程序。

<text>标签
<text>标签用于生成一个文本的输入区域。它必须包含和相关form bean中的相同属性对应的"property"属性。该标签只有在嵌入到一个<form>标签中时才有效。
例如： <html:text property="userName"/>
会被转换成： <input type="text" name="userName" value="">

<password>标签
<password>标签用于生成一个口令字（type password）的输入区域。它必须包含和相关form bean中的相同属性对应的"property"属性。该标签只有在嵌入到一个<form>标签中时才有效。该标签中的一个很重要的属性是"redisplay"，它用于重新显示以前输入到这个区域中的值。该属性的缺省值为true。然而，为了使password不能被重新显示，你或许希望将该属性的值设为false。
例如： <html:password property="password" redisplay="false"/>
会被转换成: <input type="password" name="password" value="">

<hidden>标签
<hidden>标签用于生成一个隐藏文本的输入区域。它必须包含和相关form bean中的相同属性对应的"property"属性。该标签只有在嵌入到一个<form>标签中时才有效：
例如： <html:hidden property="userName"/>
会被转换成: <input type="hidden" name="userName" value="">

<textarea>标签
<textarea>标签用于生成一个文本区元素（text area element）。它必须包含和相关form bean中的相同属性对应的"property"属性。

比如：
<html:textarea property="details" cols="80" rows="20" value="Enter details here"/>
会被转换成：
<textarea name="details" cols="80" rows="20">Enter details here</textarea>

<radio>标签
<radio>标签用于显示一个单选按钮（radio button）。它必须包含"value"属性。比如这段代码： <html:radio property="title" value="1"/>Mr.
<html:radio property="title" value="2"/>Ms.
<html:radio property="title" value="3"/>Dr.
会被转换成这样的HTML：
<input type="radio" name="title" value="1">Mr.
<input type="radio" name="title" value="2">Ms.
<input type="radio" name="title" value="3">Dr.

<checkbox>标签
<checkbox>标签用于显示checkbox类型的输入区域。比如：
<html:checkbox property="notify"/>Please send me notification
会被转换成：
<input type="checkbox" name="notify" value="on">Please send me notification

<submit>标签
<submit>标签用于生成提交类型（type submit）的输入区域。
比如： <html:submit value="Login"/>
会被转换成： <input type="submit" value="Login">
 

<reset>标签
<reset>标签用于生成重置类型（type reset）的输入区域。比如：
<html:reset/>
会被转换成： <input type="reset" value="Reset">

<option>标签
<option>标签用于显示select box中的一个选项。参照下面的<select>标签。

<select>标签
<select>标签用于显示一个包含零个或更多选项的HTML选择元素。它必须被嵌入一个<form>标签中才有效。下面这个例子将说明如何使用该标签： <html:select property="color" size="3">
  <html:option value=
      "r">red</html:option>
  <html:option value=
      "g">green</html:option>
  <html:option value=
      "b">blue</html:option>
</html:select>

会被转换成：
<select name="color" size="3"><option
      value="r">red</option>
  <option value="g">green</option>
  <option value="b">blue</option>
</select>

- 作者： mazhe 2005年01月10日, 星期一 12:40　 回复（1） |　 引用（0） 加入博采

转帖：Struts Action and ActionForm

刚刚在CSDN上看到一篇讲述Struts Action和ActionForm的文章，觉得还可以，所以转帖过来。
[1] 完整的action

<action path="/aFullAction"
    type="somePackage.someActionClass">
    name="someForm"
    input="someJSP.jsp"
    <forward name="successful" path="someJSP.jsp"/>
    <forward name="failed" path="someOtherJSP.jsp"/>
</action>

首先，Struts的ActionServlet接收到一个请求，然后根据struts-config.xml的配置定位到相应的mapping（映射）；接下来如果form的范围是request或者在定义的范围中找不到这个form，创建一个新的form实例；取得form实例以后，调用其reset()方法，然后将表单中的参数放入form，如果validate属性不为false，调用validate()方法；如果validate()返回非空的ActionErrors，将会被转到input属性指定的URI，如果返回空的ActionErrors，那么执行Action的execute()方法，根据返回的ActionForward确定目标URI。

这样做的效果是：execute()仅当validate()成功以后才执行；input属性指定的是一个URI。

[2] 仅有Form的action

<action path="/aFormOnlyAction"
    type="org.apache.struts.actions.ForwardAction"
    name="someForm"
    input="someJSP.jsp"
    parameter="someOtherJSP.jsp"
/>

首先，Struts会在定义的scope搜寻someForm，如果找到则重用，如果找不到则新建一个实例；取得form实例以后，调用其reset()方法，然后将表单中的参数放入form，如果validate属性不为false，调用validate()方法；如果validate()返回非空的ActionErrors，将会被转到input属性指定的URI，如果返回空的ActionErrors，那么转到parameter属性指定的目标URI。

这样做的效果是：没有action类可以存放我们的业务逻辑，所以所有需要写入的逻辑都只能写到form的reset()或者validate()方法中。validate()的作用是验证和访问业务层。因为这里的action映射不包括forward（也没有意义），所以不能重定向，只能用默认的那个forward。这种仅有form的action可以用来处理数据获取并forward到另一个JSP来显示。

[3] 仅有Action的action

<action path="/anActionOnlyAction"
    type="somePackage.someActionClass">
    input="someJSP.jsp"
    <forward name="successful" path="someJSP.jsp"/>
    <forward name="failed" path="someOtherJSP.jsp"/>
</action>

首先，ActionServlet接收到请求后，取得action类实例，调用execute()方法；然后根据返回的ActionForward在配置中找forward，forward到指定的URI或action。

这样做的效果是：没有form实例被传入execute()方法，于是execute()必须自己从请求中获取参数。Action可以被forward或者重定向。这种action不能处理通过HTML FORM提交的请求，只能处理链接式的请求。

[4] 仅有JSP的action

<action path="/aJSPOnlyAction"
    type="org.apache.struts.actions.ForwardAction"
    parameter="someOtherJSP.jsp"
/>

首先，ActionServlet接到请求后调用ForwardAction的execute()方法，execute()根据配置的parameter属性值来forward到那个URI。

这样做的效果是：没有任何form被实例化，比较现实的情形可能是form在request更高级别的范围中定义；或者这个action被用作在应用程序编译好后充当系统参数，只需要更改这个配置文件而不需要重新编译系统。

[5] 两个action对应一个form

<action path="/anAction"
    type="somePackage.someActionClass">
    name="someForm"
    input="someJSP.jsp"
    <forward name="successful" path="/anotherAction.do"/>
</action>
<action path="/anotherAction"
    type="somePackage.someOtherActionClass">
    name="someForm"
    input="someOtherJSP.jsp"
    <forward name="successful" path="someResultJSP.jsp"/>
</action>

就每个单独的action来讲，处理上并没有和完整的action有什么实质的区别。这个组合模式可以被用来传递命令对象（form）。需要注意的是在后一个action中同样会调用form的reset()和validate()方法，因此我们必须确保form中的信息不被重写。

处理的方式大致分为两种：a) 在request中放入一个指示器表明前一个action有意向后一个action传递form，从而在后一个action可以保留那个form中的值，这一方式只能在使用forward时使用。b) 当使用redirect而不是forward时，可以把指示器放在session或更高的级别，在命令链的最后一环将这个指示器清除。

[6] 两个action对应两个form

<action path="/anAction"
    type="somePackage.someActionClass">
    name="someForm"
    input="someJSP.jsp"
    <forward name="successful" path="/anotherAction.do" redirect="true"/>
</action>
<action path="/anotherAction"
    type="somePackage.someOtherActionClass">"
    name="someOtherForm"
    input="someOtherJSP.jsp"
    <forward name="successful" path="someResultJSP.jsp"/>
</action>

这个组合方式跟前一种在流程上没有太大区别，只是我们现在对于两个action分别提供了form，于是代码看上去更加清晰。于是我们可以分别处理WEB应用程序的输入和输出。值得注意的是，后一个action同样会尝试往form中写入那些参数，不过我们可以这样处理：a) 在后一个form中使用另一套属性名；b) 只提供getter而不提供setter。

大致的处理是这样：
前一个action接收输入、验证、然后将数据写入业务层或持久层，重定向到后一个action，后一个action手动的从业务层/持久层取出数据，写入form（通过其他方式），交给前台JSP显示。

这样做的好处是不必保留输入form中的值，因此可以使用redirect而不是forward。这样就降低了两个action之间的耦合度，同时也避免了不必要的重复提交。