struts中的Validator-rules.xml配置文件详解

validation.xml文件的文档结构是由validator_1_1_3.dtd文件定义，其文件头部内容如下：

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE form-validation PUBLIC

"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1.3//EN"

"http://jakarta.apache.org/commons/dtds/validator_1_1_3.dtd">

1.顶层元素

<form-validation>，它包含<formset>和<global>子元素。一般只需要定义<formset>元素，<formset>元素定义格式如下：

<formset>

       <constant></constant>

       <form></form>

</formset>

其中<constant />为可选子元素，而<form />子元素至少需要出现一次。<form />子元素的定义格式如下：

<form name="">


      <field property=""></field>

      ..............

      <field property=" "    depends=" "    page=" "    indexedListProperty=" "></field>


</form>

其中属性描述如下：

l-- name：指定了表单的名字与配置文件中的form-bean的name相同；

l --field：对应表单中验证的字段；

l --property：对应ActionForm的属性；

l-- depends：指定验证规则，例如：required、maxlength等；

l-- page：ActionForm若是跨页表单，则与表单中的page属性对应。


2. <field>子元素配置举例

2.1 必填（或非空）验证

非空验证的depends属性值为required，配置举例如下：

<form name="UserForm">

<field property="loginName" depends="required">

<arg0 key="UserForm.loginName" />

</field>

<field property="name" depends="required">

<arg0 key="UserForm.name" />

</field>

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

<arg0 key="UserForm.password" />

</field>

</form>

其中<arg0 key="UserForm.password" />中的key跟资源文件中的键对应。

注意：为了使默认的验证产生正确的信息，开发人员还需要在资源文件中添加errors.required等默认的错误信息，具体操作时，开发人员可在简体中文的资源文件：ApplicationResources_zh_CN.properties.bak中添加如下信息：

errors.required = {0}不能为空

errors.maxlength = {0}长度不能大于{1}个字符

errors. minlength = {0}长度不能小于{1}个字符

errors.short = {0}必须是一个整数

errors.integer = {0}必须是一个整数

errors.long={0}必须是一个整数

errors.float={0}必须是一个浮点数

errors.double ={0}必须是一个双精度型

errors.date={0}必须是一个日期

errors.range = {0}必须是 {1} 到 {2}之间的整数

errors.creditcard={0}必须是一个有效的信用卡号码

errors.email = {0}是无效e-mail地址

在英文资源文件ApplicaitonResources.properties中添加如下内容：

errors.required={0} is required.

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

errors.maxlength={0} can not be greater than {1} characters.

errors.invalid={0} is invalid.


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

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

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

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

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

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





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

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

errors.creditcard={0} is an invalid credit card number.

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

2.2 最大长度和最小长度验证

可在<field>元素的depends属性中添加maxlength和minlength来限制对于那个字段的最大长度和最小长度，使用举例如下：

<field property="password" depends = "required, maxlength, minlength">

<arg0 key = "UserForm.password"/>

<var>

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

<var-value>12</var-value>

</var>

<var>

<var-name>minlength</var-name>

<var-value>6</var-value>

</var>

</field>

2.3 Email验证

在Struts中还可以添加email验证，此时depends为email，使用举例如下：

<field property="email" depends="required, email">

<arg0 key="UserForm.email" />

</field>

2.4 日期验证

在Struts中还可以添加日期验证，此时depends为date，使用举例如下：

<field property="begintime" depends="date">

<arg0 key="HistoryForm.begintime" />

</field>

2.5 整数范围验证

在Struts中还提供了验证整数是否在某个范围之间，例如下述的例子验证整数是否在1到9999之间，配置如下：

<field property="score" depends="intRange">

<arg0 key="TestForm.score" />

<arg1 name="intRange" key="${var:min}" resource="false" />

<var>

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

<var-value>1</var-value>

</var>

<arg2 name="intRange" key="${var:max}" resource="false" />

<var>

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

<var-value>99999</var-value>

</var>

</field>

2.6 自定义验证

在Struts中的验证机制提供了扩展，开发人员可以添加自定义的验证规则，例如可添加文件类型的验证。此时需要编写的Java类、在validator-rules.xml添加该验证规则以及添加验证的js。

自定义验证的Java类CustomValidator的代码如下所示：

package com.amigo.struts.validation;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.validator.Field;

import org.apache.commons.validator.GenericValidator;

import org.apache.commons.validator.Validator;

import org.apache.commons.validator.ValidatorAction;

import org.apache.commons.validator.util.ValidatorUtils;

import org.apache.struts.action.ActionMessages;

import org.apache.struts.validator.Resources;

/**

 * Struts自定义验证类.

 */

public class CustomValidator {



         /**

          * 判断文件类型

          */

         public static boolean validateFileType(Object bean, ValidatorAction va,

                            Field field, ActionMessages errors, Validator validator,

                            HttpServletRequest request) {

                   String value = ValidatorUtils.getValueAsString(bean, field

                                     .getProperty());

                   String inputType = value.substring(value.lastIndexOf('.'));

                   String type[] = field.getVarValue("fileTypeProperty").split(";");

                   if (!GenericValidator.isBlankOrNull(value)) {

                            try {

                                     boolean judge = false;

                                     for (int i = 0; i < type.length; i++) {

                                               Pattern p = Pattern.compile(type[i],

                                                                 Pattern.CASE_INSENSITIVE);

                                               Matcher m = p.matcher(inputType);

                                               judge = m.matches();

                                               if (judge) {

                                                        break;

                                               }

                                     }



                                     if (!judge) {

                                               errors.add(field.getKey(), Resources.getActionMessage(

                                                                 validator, request, va, field));

                                               return false;

                                     }

                            } catch (Exception e) {

                                     errors.add(field.getKey(), Resources.getActionMessage(

                                                        validator, request, va, field));

                                     return false;

                            }

                   }

                   return true;

         }

}

接着还需要在validator-rules.xml这个验证规则文件中添加如下内容：

<!-- 判断文件类型-->

<validator name="fileType" classname="com.cotel.comm.EarlyValidator" method="validateFileType"

                            methodParams="java.lang.Object,

                       org.apache.commons.validator.ValidatorAction,

                       org.apache.commons.validator.Field,

                       org.apache.struts.action.ActionMessages,

                       org.apache.commons.validator.Validator,

                       javax.servlet.http.HttpServletRequest"

                            msg="errors.fileType">

                            <javascript>

                                     <![CDATA[

 function validateFileType(form) {

        var isValid = true;

        var focusField = null;

        var i = 0;

        var fields = new Array();

        var formName = form.getAttributeNode("name"); 



       oFileType = eval('new ' + formName.value + '_fileType()'); 







        for (x in oFileType) {

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





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

                field.type == 'text' ||

                field.type == 'file' ||

                field.type == 'textarea') &&

                field.disabled == false) {



             var iMax =oFileType[x][2]("fileTypeProperty").split(";");

             var index = field.value.lastIndexOf(".");

          var length = field.value.length;

                  var fileType= field.value.substring(index, length);

                  var judege=false;



                 if(length>0 && fileType!=""){

         for (var j = 0; j < iMax.length; j++) {

            if (iMax[j].toLowerCase() == fileType.toLowerCase()) {

                judege = true;

                break;

            }

                  }



            if (!judege) {

            if (i == 0) {

                        focusField = field;

                    }



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

                    isValid = false;

                }

                }

            }

        }

        if (fields.length > 0) {

           focusField.focus();

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

        }

        return isValid;

    }

    ]]>

                            </javascript>

                   </validator>

利用上面这个自定义的验证可以验证文件的类型，在下面的例子中验证文件的类型是否为jpg的，举例如下：

<field property="picPath" depends="required,fileType">

         <arg0 key="TestForm.picPath" />

         <var>

                   <var-name>fileTypeProperty</var-name>

                   <var-value>.jpg</var-value>

         </var>

</field>

3. 完整配置实例
本小节举一个validation.xml配置的完整例子，本例汇总，对两个表单添加了验证规则。内容如下：

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE form-validation PUBLIC

          "-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1.3//EN"

          "http://jakarta.apache.org/commons/dtds/validator_1_1_3.dtd">

<form-validation>

         <formset>

                   <form name="UserinfoForm">

                            <field property="email" depends="email">

                                     <arg0 key="UserinfoForm.email" />

                            </field>

                            <field property="mobile" depends="required">

                                     <arg0 key="UserinfoForm.mobile" />

                            </field>

                            <field property="description" depends="maxlength">

                                     <arg0 key="UserinfoForm.description" />

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

                                     <var>

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

                                               <var-value>200</var-value>

                                     </var>

                            </field>

                   </form>

                   <form name="PasswordForm">

                            <field property="newPass" depends="required">

                                     <arg0 key="PasswordForm.newPass" />

                            </field>

                            <field property="oldPass" depends="required">

                                     <arg0 key="PasswordForm.oldPass" />

                            </field>

                            <field property="conPass" depends="required">

                                     <arg0 key="PasswordForm.conPass" />

                            </field>

                   </form>

         </formset>

</form-validation>

===========================分割线=======================

关于validation.xml

在validator.xml中使用了validation-rules.xml的验证规则
注意一定要加其已经定义好的出错消息考到你的资源包里去,否则出错的时候，显示错误对话框
里面却什么错误消息都没有，不允许发生这样的错误
---------------------------------------------------------------------------------
<arg>：一共可定义4个（arg0..arg3）,作用是向资源文件提供参数的值。属性同<msg>

<arg1 key="${var:min}" resource="false"/>
        <var>
          <var-name>min</var-name>
          <var-value>10</var-value>
        </var>

既是代替资源包中{1}的参数值
又是在验证规则中传进了参数
记住将resource="false"(当设为false时，key值可自定义)

---------------------------------------------------------------------------------
Validator验证框架
validator.xml
在validator.xml 文件中定义formset 元素时，需要使用校验器和消息关键字，如清单12.3formset 元素

<formset>
     <form name="logonForm">
        <field   property="username"    depends="required,mask">
            <msg name="mask" key="logon.username.maskmsg"/>
            <arg0 key="logon.userName.displayName"/>
                 <var>
                       <var-name>mask</var-name>
                       <var-value>^[a-zA-Z0-9]*$</var-value>
                 </var>
       </field>


      <field property="password"   depends="required,minlength">
            <arg0 key="logon.password.displayName"/>
                <var>
                     <var-name>minlength</var-name> 
                     <var-value>5</var-value>
                </var>
     </field>
    </form>
</formset>

○1 formset 是一个或者多个form的包装器.
○2 每个form 元素都要给定其自身的名称。这应该对应于Struts 配置中的form bean 名称或
者 action 的路径。
○3 每个form 元素有一些field 元素组成
○4 field 元素通过depends 属性指出要使用哪个校验器。
○5 可选的msg 元素允许你指定针对一个校验器的定制消息和用于替换参数的消息关键字
○6 arg0 元素指定了那些需要它们的消息所用的第一个替换参数
○7 var 元素用于传递变量属性到校验器中。
○8 这里传递了一个正则表达式到mask 校验器。表达式意思是用户名称只可以包含字母和
数字。.
○9 这里我们设置password 是必须的，并且至少有5个字符的长度。password 长度是一个业
务需求，帮助使用户账户更加安全。
password 校验消息使用了缺省 minlength or required 消息，该消息定义于
validation-rules.xml (errors.minlength and errors.required)。


<form>：指定要校验的ActionForm
属性 描述 name 指定要校验的ActionForm的名字 <field>：指定要校验ActionForm的哪一个属性
属性 描述 property 指定要校验的ActionForm中的属性名 depends 所用的校验规则，在validation-rules中定义 page ?当此属性的值小于或等于与此form相关的javabean的page值时，此field才会被处理 indexedListProperty ?The method name that will return an array or a Collection used to retrieve the list and then loop through the list, performing the validations for this field.

<msg>：校验失败时加到Action Errors中的信息，用来替代validator-rules中默认的错误信息
属性 描述 name 使用校验的规则名 key 资源文件中的key或自定义的值 Resource 当设为false时，key值可自定义

<arg>：一共可定义4个（arg0..arg3）,作用是向资源文件提供参数的值。属性同<msg>




---------<msg>的重要作用---------------------------------------------------------
在某些情况下，您可能想提供一个更具体的错误消息而不是在资源束文件中定义的缺省错误消息。
例如，如果您有一个 Mask 验证器，缺省错误消息是，该值是无效的，而没有关于无效性的详细情况。
您可以用另一个消息覆盖 Mask 验证器的错误消息，
方式是将如下一行代码添加到 validator.xml 中：
<msg name="mask" key="some.other.error.msg"/>。

将如下一行代码添加到文件 ApplicationResources.properties 中并保存：
some.other.error.msg = {0} is not a 5-digit number

如下编辑 validation.xml 并保存：

<form-validation>
   <formset>
    <form name="submitForm">
     <field property="name" depends="required,mask">
     <msg name="mask" key="some.other.error.msg"/> !!!!!在这里加上这么一句,替换mask的消息,
     !!!这里可以用多个<msg>来替换所有的原始消息,比如再加一个<msg>替换required
     <msg>的name属性必需来自上面的depends,因为它要替换其中验证规则的错误消息
     <arg0 key="submitForm.name"/>
         <var>
           <var-name>mask</var-name>
           <var-value>^\\d{5}\\d*$</var-value>
         </var>
     </field>
    </form>
   </formset>
</form-validation>

------一些验证规则的用法------------------------------------------------------------
你depends引用任何一个validator-rules.xml中的规则,它都对应一个默认的错误信息
如:xxx{0}xxxxx
如果你引用了很多个规则,则有以下错误信息
xxx{0}xxx
xxx{0}xxx{1}xxx{2}xxx...
则你需要<arg0 <arg1 <arg2
因为你验证的是一个页面的组件,则<arg0 一定是此组件的名字
为了实现国际化,此组件的名字可能在资源包中,如xx.xx
则从xx.xx中获得键的值,然后又赋给资源包中的{0}参数(就是<arg0>)

记住不论引用几种验证规则,{0}可以重复,它代表组件名,它以上的不能重复
xxx{0}xxx
xxx{0}xxx{1}xxx 第二个验证规则
xxx{0}xxx{1}xxx{2}xxx... 第三个验证规则
这样的情况应该是不存在的
因为如果写了第二个验证规则的<arg1
<arg1 key="${var:minlength}" resource="false"/>
<var>
<var-name>minlength</var-name>
<var-value>8</var-value>
</var>
又写第三个验证规则的<arg1
同时出现两个<arg1
这怎么说也非常不适合逻辑

检查是不是字母的正则表达式:^[a-zA-Z]*$

验证minlength(输入的最小长度)
      <field property="userName" depends="required,minlength">
        <arg0 key="label.username"/>
        <arg1 key="${var:minlength}" resource="false"/>
        <var>
          <var-name>minlength</var-name>
          <var-value>8</var-value>
        </var>
      </field>
验证intRange(取值范围)
      <field property="age" depends="required,intRange">
        <arg0 key="label.age"/>
        <arg1 key="${var:min}" resource="false"/>
        <arg2 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>70</var-value>
        </var>
      </field>
验证信用卡号
      <field property="idCard" depends="required,creditCard">
        <arg0 key="label.idcard"/>
      </field>
验证日期格式(比如出生日期)
      <field property="birthday" depends="required,date">
        <arg0 key="label.birthday"/>
        <var>
          <var-name>datePatternStrict</var-name>
          <var-value>yyyy-MM-dd</var-value>
        </var>
      </field>
验证email和url
    depends="email">
  <arg0 key="prompt.email" />
</field>
<field property="url"
    depends="url">
  <arg0 key="prompt.url" />
</field>

使用mask验证(可以使用各种正则表达式)
    depends="required,mask">
  <arg0 key="prompt.phone" />
  <var>
    <var-name>mask</var-name>
    <var-value>^\(?(\d{3})\)?[-| ]?(\d{3})[-| ]?(\d{4})$</var-value>
  </var>
</field>

但是，可以容易地在多个地方使用同一个掩码。每次使用时不必重新定义，只要把掩码定义移动到 global constant 即可。
请把下面的内容添加到 validation.xml 文件中的 global 元素内（靠近文件顶部）：

<global>
  <constant>
    <constant-name>phone</constant-name>
    <constant-value>^\(?(\d{3})\)?[-| ]?(\d{3})[-| ]?(\d{4})$</constant-value>
  </constant>
</global>
然后在下面使用${phone} <field property="phone"
    depends="required,mask">
  <arg0 key="prompt.phone" />
  <var>
     <var-name>mask</var-name>
     <var-value>${phone}</var-value>
  </var>
</field>

-------------------------------------------------

关于 validator-rules.xml

分析一下validator-rules.xml中已经配置好的验证规则

<form-validation>

   <global>

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

         <javascript><![CDATA[
            function validateRequired(form) {
                var isValid = true;
                var focusF......

属性
描述

name
指定一个规则名，用来被其它规则引用

ClassName
包含校验规则的类

method
此校验规则在类中实际对应的方法

methodParams
Method方法的参数

depends
引用其它的规则（在当前规则之前被调用）

msg
资源文件中的关键字，当校验不通过时，此关键字中的信息将加入到errors集合中。

jsFunctionName
指定一个JavaScript函数名

----------------------------------------------------------

validator验证

1.1 组成与配置
配置文件： validator-rules.xml、validation.xml
由于validation.xml是要自定义的,所以里面的元素希望都能够记下来
并且能够将validation.xml手写出来
当然validator-rules.xml不要求你会手写,但是请记住里面有哪些元素与属性

验证需要用到的库
commons-beanutils.jar: Commons BeanUtils 
commons-collections.jar: Commons Collections 
commons-digester.jar: Commons Digester 
commons-logging.jar: Commons Logging 
commons-validator.jar: Commons Validator 
jakarta-oro.jar: Jakarta ORO

validator验证分服务器端验证和客户端验证
用了哪一种验证很好区别
如果是在注册页面上出文字(使用了<html:errors/>),则是服务器端验证
如果是弹出了一个对话框,则是使用了客户端验证

---------------------------------------------------------------------------------
服务器端的验证

为了使用服务器端验证，Action Form 实现类应该扩展 ValidatorForm 而不是 ActionForm。当提交表单时，会执行 ValidatorForm 中的 validate() 方法，它将根据 validation-rules.xml 和 validation.xml 文件进行验证。


1.扩展ValidatorForm类构造ActionForm
public class SubmitForm extends org.apache.struts.validator.ValidatorForm{...
2.修改ActionForm的validate()方法如下
public ActionErrors validate(ActionMapping mapping,HttpServletRequest request)
{
return super.validate(mapping, request);
}
3.需要在JSP注册文件中的某一个地方添加 <html:errors/> 行以使错误显示出来。

---------------------------------------------------------------------------------
客户端的验证

为了使用客户端验证，Action Form 应该扩展 ValidatorActionForm 而不是 ActionForm。
如前所述，对于服务器端验证，Action Form 扩展的是 ValidatorForm 类。


1.扩展ValidatorActionForm类构造ActionForm
public class SubmitForm extends org.apache.struts.validator.ValidatorActionForm {
2.服务器端验证时必需的<html:errors /> 在客户端验证时不再需要,删除。
去掉validate()方法
// public ActionErrors validate(ActionMapping mapping,HttpServletRequest request)
// {
// return super.validate(mapping, request);
// }

3.将<html:javascript formName="checkoutForm"/>加在jsp文件末尾，即</html:html>前。

它的作用是将validation-rules.xml中与”checkoutForm”相关的校验规则的javascript插入此页面中。

4.在<html:form>中加onsubmit属性。
例如：<html:form action="/saveArticleType" οnsubmit="return validateCheckoutForm(this);">
说明：validateCheckoutForm()方法是在步骤3中自动生成的。
<html:javascript>将根据formName的属性值（例如：xxx）,生成validatexxx()方法。
---------------------------------------------------------------------------------
扩展对象选择
在为Form选择扩展对象时，要注意：Struts框架提供了两种选择。
第一种选择是使用ValidatorForm或者DynaValidatorForm；
第二种选择是使用ValidatorActionForm或者DynaValidatorActionForm。

使用第一种方式时，Validator.xml中的form元素的name属性必须和struts-config.xml中的action元素的name属性相匹配。

使用第二种方式时，Validator.xml中的form元素的name属性则是与struts-config.xml中的action元素的path属性相匹配。


---------------------------------------------------------------------------------


在 JSP 中支持验证

这些规则都不错，但是仍然有一个显著的问题：JSP 页面没有办法报告错误！例如，如果这里重新部署应用程序，将会发现用错误的值 提交验证表单不会 转向 success.jsp。这是对的，也是朝着正确方向的一步。但是，它也特别令人郁闷；表单只是在浏览器中重新出现，至于出了什么错误却没有任何指示。

请打开 pages/test-validation.jsp 来处理这个问题。首先，需要提供了一个地方，供发生错误时显示。这可以由 html:errors 元素很好地处理。请把以下内容插在 html:form 元素前：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="/tags/struts-bean" prefix="bean" %>
<%@ taglib uri="/tags/struts-html" prefix="html" %>

<html:html />

<html>
 <head>
  <title><bean:message key="valid.title" /></title>
 </head>              <html:errors />            
<html:form action="/SubmitValid" focus="username">

如果现在重新部署，并试着输入错误数据，将开始看到错误消息出现在<html:errors/>处


现在朝着真正坚固的验证又进了一步。但是，仍然在服务器端；在提交表单时会得到讨厌的闪烁，然后不得不等待服务器响应。这里的目标是用 JavaScript 编码的验证（或者更好一些，不必为了每个表单手工编写 JavaScript）。高兴的是，只要几个额外标记，Validator 就允许把它的服务器端代码转换成客户端 JavaScript 脚本：

</html:form>

<html:javascript formName="ValidationForm" cdata="false" />

</body>


不是很多哦！只有一行代码，但是它告诉 Struts 插入所有支持表单客户端验证的 JavaScript。还请注意非常重要的 cdata 属性。必须 把它设置成 false，否则客户端验证不会工作。如果把它设置成 true（默认设置），那么 Struts 生成的 HTML 会把 JavaScript 放在 <![CDATA[ 和 ]]> 标记内。由于一些我不太清楚的原因，多数现代浏览器（Mozilla Firefox 和 Safari 在其中最出名）会忽略这样包含的 JavaScript，所以客户端验证不会执行。

在这一阶段，我要指出，即使忘记了 cdata=false 这一部分，仍然可以得到验证，只不过是在服务器端而已。在任何情况下，Validator 在服务器端都会验证数据，所以如果忘记了这个属性、甚至关闭 JavaScript 或跳过它，也都会得到一个备份。使用 Validator 有一个很好的副作用 —— 它会尝试并捕获每个可能的错误。

(说明：如果按照作者的说法，得不到下面的测试结果，还需要修改一个地方)
修改文件test-validation.jsp，增加οnsubmit="validateValidationForm(this)
<html:form action="/SubmitValid" οnsubmit="validateValidationForm(this)" focus="username">