Chinaunix首页 | 论坛 | 博客

ZJU2011_shark的ChinaUnix博客

首页　| 　博文目录　| 　关于我

ZJU2011_shark

  • 博客访问： 342558
  • 博文数量： 329
  • 博客积分： 2633
  • 博客等级： 少校
  • 技术积分： 3633
  • 用 户 组： 普通用户
  • 注册时间： 2011-04-22 15:43
文章分类

全部博文（329）

文章存档

2013年（244）

2012年（46）

2011年（39）

我的朋友
最近访客
推荐博文
相关博文
strut结合validator框架的简单示例（适合初学者）

分类： 系统运维

2012-03-21 12:29:58

摘自精通struts
validator.xml:

点击(此处)折叠或打开

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE form-validation PUBLIC "-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.0//EN" "validator_1_0.dtd" >
  3. <form-validation>
  4.     <global>
  5.         <constant>
  6.             <constant-name>numericchar</constant-name>
  7.             <constant-value>^\w+$</constant-value>
  8.         </constant>
  9.     </global>

  11.     <formset>
  12.         <form name="CheckForm">
  13.             <field property="userName" depends="required,mask">
  14.                 <arg0 key="userName" />
  15.                 <var>
  16.                     <var-name>mask</var-name>
  17.                     <var-value>${numericchar}</var-value>
  18.                 </var>
  19.             </field>
  20.             
  21.             <!-- <field property="passWord" depends="minlength,maxlength,required,mask">-->
  22.             <field property="passWord" depends="required,mask,minmaxlength">
  23.                 <arg0 key="passWord" ></arg0>
  24.                 <arg1 key="6" resource="false"></arg1>
  25.                 <arg2 key="12" resource="false"></arg2>
  26.                 <var>
  27.                     <var-name>mask</var-name>
  28.                     <var-value>${numericchar}</var-value>
  29.                 </var>
  30.                 <var>
  31.                     <var-name>maxlength</var-name>
  32.                     <var-value>12</var-value>
  33.                 </var>
  34.                 <var>
  35.                     <var-name>minlength</var-name>
  36.                     <var-value>6</var-value>
  37.                 </var>
  38.             </field>
  39.             <field property="age" depends="range">
  40.                 <arg0 key="age" />
  41.                 <arg1 key="18" resource="false" />
  42.                 <arg2 key="30" resource="false" />
  43.                 <var>
  44.                     <var-name>min</var-name>
  45.                     <var-value>18</var-value>
  46.                 </var>
  47.                 <var>
  48.                     <var-name>max</var-name>
  49.                     <var-value>30</var-value>
  50.                 </var>
  51.             </field>
  52.             <field property="email" depends="email">
  53.                 <arg0 key="email"></arg0>
  54.             </field>
  55.         </form>
  56.     </formset>
  57. </form-validation>
 
NewValidator.java:(自定义校验类)
 

点击(此处)折叠或打开

  1. package struts.sample.cap5.sample1.validator;
  2. import java.io.Serializable;

  4. import javax.servlet.http.HttpServletRequest;

  6. import org.apache.commons.validator.Field;
  7. import org.apache.commons.validator.ValidatorAction;
  8. import org.apache.commons.validator.ValidatorUtil;
  9. import org.apache.struts.action.ActionErrors;
  10. import org.apache.struts.util.StrutsValidatorUtil;

  12. public class NewValidator implements Serializable {

  14.     public static boolean validateMinMaxLength(Object bean, ValidatorAction va,
  15.             Field field, ActionErrors errors, HttpServletRequest request) {

  17.         String value = null;
  18.         // 将检验的字段转为String

  20.         if (field.getProperty() != null && field.getProperty().length() > 0) {
  21.             value = ValidatorUtil.getValueAsString(bean, field.getProperty());
  22.         }
  23.         //从var元素得到校验参数

  25.         String sMaxLength = field.getVarValue("maxlength");
  26.         String sMinLength = field.getVarValue("minlength");

  28.         //当校验的字段不为空时进行校验

  30.         if (value != null) {
  31.             try {
  32.                 int valueLength = value.length();
  33.                 int maxLength = Integer.parseInt(sMaxLength);
  34.                 int minLength = Integer.parseInt(sMinLength);

  36.                 //若字段的字符数大于校验参数maxlength或小于校验参数minLength时将返回报错信息

  38.                 if (valueLength > maxLength || valueLength < minLength) {
  39.                     errors.add(field.getKey(), StrutsValidatorUtil
  40.                             .getActionError(request, va, field));
  41.                     return false;
  42.                 }
  43.             } catch (Exception e) {
  44.                 //当捕捉到任何异常时将返回报错信息

  46.                 errors.add(field.getKey(), StrutsValidatorUtil.getActionError(
  47.                         request, va, field));
  48.                 return false;
  49.             }
  50.         }
  51.         return errors.empty();
  52.     }
  53. }

validator-rules.xml:

点击(此处)折叠或打开

  1. <!DOCTYPE form-validation PUBLIC
  2.           "-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.0//EN"
  3.           "">
  4. <!--

  6.    This file contains the default Struts Validator pluggable validator
  7.    definitions. It should be placed somewhere under /WEB-INF and
  8.    referenced in the struts-config.xml under the plug-in element
  9.    for the ValidatorPlugIn.

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

  16.    These are the default error messages associated with
  17.    each validator defined in this file. They should be
  18.    added to your projects ApplicationResources.properties
  19.    file or you can associate new ones by modifying the
  20.    pluggable validators msg attributes in this file.

  22.    # Struts Validator Error Messages
  23.    errors.required={0} is required.
  24.    errors.minlength={0} can not be less than {1} characters.
  25.    errors.maxlength={0} can not be greater than {1} characters.
  26.    errors.invalid={0} is invalid.

  28.    errors.byte={0} must be a byte.
  29.    errors.short={0} must be a short.
  30.    errors.integer={0} must be an integer.
  31.    errors.long={0} must be a long.
  32.    errors.float={0} must be a float.
  33.    errors.double={0} must be a double.

  35.    errors.date={0} is not a date.
  36.    errors.range={0} is not in the range {1} through {2}.
  37.    errors.creditcard={0} is an invalid credit card number.
  38.    errors.email={0} is an invalid e-mail address.

  40. -->

  42. <form-validation>

  44.    <global>

  46.       <validator name="required"
  47.             classname="org.apache.struts.validator.FieldChecks"
  48.                method="validateRequired"
  49.          methodParams="java.lang.Object,
  50.                        org.apache.commons.validator.ValidatorAction,
  51.                        org.apache.commons.validator.Field,
  52.                        org.apache.struts.action.ActionErrors,
  53.                        javax.servlet.http.HttpServletRequest"
  54.                   msg="errors.required">

  56.          <javascript><![CDATA[
  57.             function validateRequired(form) {
  58.                 var isValid = true;
  59.                 var focusField = null;
  60.                 var i = 0;
  61.                 var fields = new Array();
  62.                 oRequired = new required();
  63.                 for (x in oRequired) {
  64.                     var field = form[oRequired[x][0]];
  65.                     
  66.                     if (field.type == 'text' ||
  67.                         field.type == 'textarea' ||
  68.                         field.type == 'file' ||
  69.                         field.type == 'select-one' ||
  70.                         field.type == 'radio' ||
  71.                         field.type == 'password') {
  72.                         
  73.                         var value = '';
  74.                         // get field's value
  75.                         if (field.type == "select-one") {
  76.                             var si = field.selectedIndex;
  77.                             if (si >= 0) {
  78.                                 value = field.options[si].value;
  79.                             }
  80.                         } else {
  81.                             value = field.value;
  82.                         }
  83.                         
  84.                         if (trim(value).length == 0) {
  85.                         
  86.      if (i == 0) {
  87.      focusField = field;
  88.      }
  89.      fields[i++] = oRequired[x][1];
  90.      isValid = false;
  91.                         }
  92.                     }
  93.                 }
  94.                 if (fields.length > 0) {
  95.                    focusField.focus();
  96.                    alert(fields.join('\n'));
  97.                 }
  98.                 return isValid;
  99.             }
  100.             
  101.             // Trim whitespace from left and right sides of s.
  102.             function trim(s) {
  103.                 return s.replace( /^\s*/, "" ).replace( /\s*$/, "" );
  104.             }
  105.             
  106.             ]]>
  107.          

  109.       

  111.       
  112.                  classname="org.apache.struts.validator.FieldChecks"
  113.                  method="validateRequiredIf"
  114.                  methodParams="java.lang.Object,
  115.                                org.apache.commons.validator.ValidatorAction,
  116.                                org.apache.commons.validator.Field,
  117.                                org.apache.struts.action.ActionErrors,
  118.                                org.apache.commons.validator.Validator,
  119.                                javax.servlet.http.HttpServletRequest"
  120.                  msg="errors.required">
  121.       

  123.       
  124.             classname="org.apache.struts.validator.FieldChecks"
  125.                method="validateMinLength"
  126.          methodParams="java.lang.Object,
  127.                        org.apache.commons.validator.ValidatorAction,
  128.                        org.apache.commons.validator.Field,
  129.                        org.apache.struts.action.ActionErrors,
  130.                        javax.servlet.http.HttpServletRequest"
  131.               depends=""
  132.                   msg="errors.minlength">

  134.          
  135.             function validateMinLength(form) {
  136.                 var isValid = true;
  137.                 var focusField = null;
  138.                 var i = 0;
  139.                 var fields = new Array();
  140.                 oMinLength = new minlength();
  141.                 for (x in oMinLength) {
  142.                     var field = form[oMinLength[x][0]];
  143.                     
  144.                     if (field.type == 'text' ||
  145.                         field.type == 'textarea') {
  146.                         
  147.                         var iMin = parseInt(oMinLength[x][2]("minlength"));
  148.                         if ((trim(field.value).length > 0) && (field.value.length < iMin)) {
  149.                             if (i == 0) {
  150.                                 focusField = field;
  151.                             }
  152.                             fields[i++] = oMinLength[x][1];
  153.                             isValid = false;
  154.                         }
  155.                     }
  156.                 }
  157.                 if (fields.length > 0) {
  158.                    focusField.focus();
  159.                    alert(fields.join('\n'));
  160.                 }
  161.                 return isValid;
  162.             }]]>
  163.          

  165.       


  168.       
  169.             classname="org.apache.struts.validator.FieldChecks"
  170.                method="validateMaxLength"
  171.          methodParams="java.lang.Object,
  172.                        org.apache.commons.validator.ValidatorAction,
  173.                        org.apache.commons.validator.Field,
  174.                        org.apache.struts.action.ActionErrors,
  175.                        javax.servlet.http.HttpServletRequest"
  176.               depends=""
  177.                   msg="errors.maxlength">

  179.          
  180.             function validateMaxLength(form) {
  181.                 var isValid = true;
  182.                 var focusField = null;
  183.                 var i = 0;
  184.                 var fields = new Array();
  185.                 oMaxLength = new maxlength();
  186.                 for (x in oMaxLength) {
  187.                     var field = form[oMaxLength[x][0]];
  188.                     
  189.                     if (field.type == 'text' ||
  190.                         field.type == 'textarea') {
  191.                         
  192.                         var iMax = parseInt(oMaxLength[x][2]("maxlength"));
  193.                         if (field.value.length > iMax) {
  194.                             if (i == 0) {
  195.                                 focusField = field;
  196.                             }
  197.                             fields[i++] = oMaxLength[x][1];
  198.                             isValid = false;
  199.                         }
  200.                     }
  201.                 }
  202.                 if (fields.length > 0) {
  203.                    focusField.focus();
  204.                    alert(fields.join('\n'));
  205.                 }
  206.                 return isValid;
  207.             }]]>
  208.          

  210.       


  213.       
  214.             classname="org.apache.struts.validator.FieldChecks"
  215.                method="validateMask"
  216.          methodParams="java.lang.Object,
  217.                        org.apache.commons.validator.ValidatorAction,
  218.                        org.apache.commons.validator.Field,
  219.                        org.apache.struts.action.ActionErrors,
  220.                        javax.servlet.http.HttpServletRequest"
  221.               depends=""
  222.                   msg="errors.invalid">

  224.          
  225.             function validateMask(form) {
  226.                 var isValid = true;
  227.                 var focusField = null;
  228.                 var i = 0;
  229.                 var fields = new Array();
  230.                 oMasked = new mask();
  231.                 for (x in oMasked) {
  232.                     var field = form[oMasked[x][0]];
  233.                     
  234.                     if ((field.type == 'text' ||
  235.                          field.type == 'textarea') &&
  236.                          (field.value.length > 0)) {
  237.                         
  238.                         if (!matchPattern(field.value, oMasked[x][2]("mask"))) {
  239.                             if (i == 0) {
  240.                                 focusField = field;
  241.                             }
  242.                             fields[i++] = oMasked[x][1];
  243.                             isValid = false;
  244.                         }
  245.                     }
  246.                 }
  247.                 
  248.                 if (fields.length > 0) {
  249.                    focusField.focus();
  250.                    alert(fields.join('\n'));
  251.                 }
  252.                 return isValid;
  253.             }

  255.             function matchPattern(value, mask) {
  256.                return mask.exec(value);
  257.             }]]>
  258.          

  260.       


  263.       
  264.             classname="org.apache.struts.validator.FieldChecks"
  265.                method="validateByte"
  266.          methodParams="java.lang.Object,
  267.                        org.apache.commons.validator.ValidatorAction,
  268.                        org.apache.commons.validator.Field,
  269.                        org.apache.struts.action.ActionErrors,
  270.                        javax.servlet.http.HttpServletRequest"
  271.               depends=""
  272.                   msg="errors.byte"
  273.        jsFunctionName="ByteValidations">

  275.          
  276.             function validateByte(form) {
  277.                 var bValid = true;
  278.                 var focusField = null;
  279.                 var i = 0;
  280.                 var fields = new Array();
  281.                 oByte = new ByteValidations();
  282.                 for (x in oByte) {
  283.                     var field = form[oByte[x][0]];
  284.                     
  285.                     if (field.type == 'text' ||
  286.                         field.type == 'textarea' ||
  287.                         field.type == 'select-one' ||
  288.                         field.type == 'radio') {

  290.                         var value = '';
  291.                         // get field's value
  292.                         if (field.type == "select-one") {
  293.                             var si = field.selectedIndex;
  294.                             if (si >= 0) {
  295.                                 value = field.options[si].value;
  296.                             }
  297.                         } else {
  298.                             value = field.value;
  299.                         }
  300.                         
  301.                         if (value.length > 0) {
  302.                             if (!isAllDigits(value)) {
  303.                                 bValid = false;
  304.                                 if (i == 0) {
  305.                                     focusField = field;
  306.                                 }
  307.                                 fields[i++] = oByte[x][1];

  309.                             } else {

  311.      var iValue = parseInt(value);
  312.      if (isNaN(iValue) || !(iValue >= -128 && iValue <= 127)) {
  313.      if (i == 0) {
  314.      focusField = field;
  315.      }
  316.      fields[i++] = oByte[x][1];
  317.      bValid = false;
  318.      }
  319.                             }
  320.                         }
  321.                         
  322.                     }
  323.                 }
  324.                 if (fields.length > 0) {
  325.                    focusField.focus();
  326.                    alert(fields.join('\n'));
  327.                 }
  328.                 return bValid;
  329.             }]]>
  330.          </javascript>

  332.       </validator>


  335.       <validator name="short"
  336.             classname="org.apache.struts.validator.FieldChecks"
  337.                method="validateShort"
  338.          methodParams="java.lang.Object,
  339.                        org.apache.commons.validator.ValidatorAction,
  340.                        org.apache.commons.validator.Field,
  341.                        org.apache.struts.action.ActionErrors,
  342.                        javax.servlet.http.HttpServletRequest"
  343.               depends=""
  344.                   msg="errors.short"
  345.        jsFunctionName="ShortValidations">

  347.          <javascript><![CDATA[
  348.             function validateShort(form) {
  349.                 var bValid = true;
  350.                 var focusField = null;
  351.                 var i = 0;
  352.                 var fields = new Array();
  353.                 oShort = new ShortValidations();
  354.                 for (x in oShort) {
  355.                     var field = form[oShort[x][0]];
  356.                     
  357.                     if (field.type == 'text' ||
  358.                         field.type == 'textarea' ||
  359.                         field.type == 'select-one' ||
  360.                         field.type == 'radio') {
  361.                         
  362.                         var value = '';
  363.                         // get field's value
  364.                         if (field.type == "select-one") {
  365.                             var si = field.selectedIndex;
  366.                             if (si >= 0) {
  367.                                 value = field.options[si].value;
  368.                             }
  369.                         } else {
  370.                             value = field.value;
  371.                         }
  372.                         
  373.                         if (value.length > 0) {
  374.                             if (!isAllDigits(value)) {
  375.                                 bValid = false;
  376.                                 if (i == 0) {
  377.                                     focusField = field;
  378.                                 }
  379.                                 fields[i++] = oShort[x][1];

  381.                             } else {
  382.                         
  383.      var iValue = parseInt(value);
  384.      if (isNaN(iValue) || !(iValue >= -32768 && iValue <= 32767)) {
  385.      if (i == 0) {
  386.      focusField = field;
  387.      }
  388.      fields[i++] = oShort[x][1];
  389.      bValid = false;
  390.      }
  391.      }
  392.                        }
  393.                     }
  394.                 }
  395.                 if (fields.length > 0) {
  396.                    focusField.focus();
  397.                    alert(fields.join('\n'));
  398.                 }
  399.                 return bValid;
  400.             }]]>
  401.          

  403.       


  406.       
  407.             classname="org.apache.struts.validator.FieldChecks"
  408.                method="validateInteger"
  409.          methodParams="java.lang.Object,
  410.                        org.apache.commons.validator.ValidatorAction,
  411.                        org.apache.commons.validator.Field,
  412.                        org.apache.struts.action.ActionErrors,
  413.                        javax.servlet.http.HttpServletRequest"
  414.               depends=""
  415.                   msg="errors.integer"
  416.        jsFunctionName="IntegerValidations">

  418.          
  419.             function validateInteger(form) {
  420.                 var bValid = true;
  421.                 var focusField = null;
  422.                 var i = 0;
  423.                 var fields = new Array();
  424.                 oInteger = new IntegerValidations();
  425.                 for (x in oInteger) {
  426.                     var field = form[oInteger[x][0]];

  428.                     if (field.type == 'text' ||
  429.                         field.type == 'textarea' ||
  430.                         field.type == 'select-one' ||
  431.                         field.type == 'radio') {
  432.                         
  433.                         var value = '';
  434.                         // get field's value
  435.                         if (field.type == "select-one") {
  436.                             var si = field.selectedIndex;
  437.                          if (si >= 0) {
  438.                              value = field.options[si].value;
  439.                          }
  440.                         } else {
  441.                             value = field.value;
  442.                         }
  443.                         
  444.                         if (value.length > 0) {
  445.                         
  446.                             if (!isAllDigits(value)) {
  447.                                 bValid = false;
  448.                                 if (i == 0) {
  449.      focusField = field;
  450.      }
  451.                          fields[i++] = oInteger[x][1];
  452.                         
  453.                             } else {
  454.      var iValue = parseInt(value);
  455.      if (isNaN(iValue) || !(iValue >= -2147483648 && iValue <= 2147483647)) {
  456.      if (i == 0) {
  457.      focusField = field;
  458.      }
  459.      fields[i++] = oInteger[x][1];
  460.      bValid = false;
  461.      }
  462.                            }
  463.                        }
  464.                     }
  465.                 }
  466.                 if (fields.length > 0) {
  467.                    focusField.focus();
  468.                    alert(fields.join('\n'));
  469.                 }
  470.                 return bValid;
  471.             }

  473.             function isAllDigits(argvalue) {
  474.                 argvalue = argvalue.toString();
  475.                 var validChars = "0123456789";
  476.                 var startFrom = 0;
  477.                 if (argvalue.substring(0, 2) == "0x") {
  478.                    validChars = "0123456789abcdefABCDEF";
  479.                    startFrom = 2;
  480.                 } else if (argvalue.charAt(0) == "0") {
  481.                    validChars = "01234567";
  482.                    startFrom = 1;
  483.                 } else if (argvalue.charAt(0) == "-") {
  484.                     startFrom = 1;
  485.                 }
  486.                 
  487.                 for (var n = startFrom; n < argvalue.length; n++) {
  488.                     if (validChars.indexOf(argvalue.substring(n, n+1)) == -1) return false;
  489.                 }
  490.                 return true;
  491.             }]]>
  492.          </javascript>

  494.       </validator>


  497.       <validator name="long"
  498.             classname="org.apache.struts.validator.FieldChecks"
  499.                method="validateLong"
  500.          methodParams="java.lang.Object,
  501.                        org.apache.commons.validator.ValidatorAction,
  502.                        org.apache.commons.validator.Field,
  503.                        org.apache.struts.action.ActionErrors,
  504.                        javax.servlet.http.HttpServletRequest"
  505.               depends=""
  506.                   msg="errors.long"/>


  509.       <validator name="float"
  510.             classname="org.apache.struts.validator.FieldChecks"
  511.                method="validateFloat"
  512.          methodParams="java.lang.Object,
  513.                        org.apache.commons.validator.ValidatorAction,
  514.                        org.apache.commons.validator.Field,
  515.                        org.apache.struts.action.ActionErrors,
  516.                        javax.servlet.http.HttpServletRequest"
  517.               depends=""
  518.                   msg="errors.float"
  519.        jsFunctionName="FloatValidations">

  521.          <javascript><![CDATA[
  522.             function validateFloat(form) {
  523.                 var bValid = true;
  524.                 var focusField = null;
  525.                 var i = 0;
  526.                 var fields = new Array();
  527.                 oFloat = new FloatValidations();
  528.                 for (x in oFloat) {
  529.                     var field = form[oFloat[x][0]];
  530.                     
  531.                     if (field.type == 'text' ||
  532.                         field.type == 'textarea' ||
  533.                         field.type == 'select-one' ||
  534.                         field.type == 'radio') {
  535.                         
  536.                         var value = '';
  537.                         // get field's value
  538.                         if (field.type == "select-one") {
  539.                             var si = field.selectedIndex;
  540.                             if (si >= 0) {
  541.                              value = field.options[si].value;
  542.                             }
  543.                         } else {
  544.                             value = field.value;
  545.                         }
  546.                         
  547.                         if (value.length > 0) {
  548.                             // remove '.' before checking digits
  549.                             var tempArray = value.split('.');
  550.                             var joinedString= tempArray.join('');

  552.                             if (!isAllDigits(joinedString)) {
  553.                                 bValid = false;
  554.                                 if (i == 0) {
  555.                                     focusField = field;
  556.                                 }
  557.                                 fields[i++] = oFloat[x][1];

  559.                             } else {
  560.      var iValue = parseFloat(value);
  561.      if (isNaN(iValue)) {
  562.      if (i == 0) {
  563.      focusField = field;
  564.      }
  565.      fields[i++] = oFloat[x][1];
  566.      bValid = false;
  567.      }
  568.                             }
  569.                         }
  570.                     }
  571.                 }
  572.                 if (fields.length > 0) {
  573.                    focusField.focus();
  574.                    alert(fields.join('\n'));
  575.                 }
  576.                 return bValid;
  577.             }]]>
  578.          

  580.       


  583.       
  584.             classname="org.apache.struts.validator.FieldChecks"
  585.                method="validateDouble"
  586.          methodParams="java.lang.Object,
  587.                        org.apache.commons.validator.ValidatorAction,
  588.                        org.apache.commons.validator.Field,
  589.                        org.apache.struts.action.ActionErrors,
  590.                        javax.servlet.http.HttpServletRequest"
  591.               depends=""
  592.                   msg="errors.double"/>


  595.       
  596.             classname="org.apache.struts.validator.FieldChecks"
  597.                method="validateDate"
  598.          methodParams="java.lang.Object,
  599.                        org.apache.commons.validator.ValidatorAction,
  600.                        org.apache.commons.validator.Field,
  601.                        org.apache.struts.action.ActionErrors,
  602.                        javax.servlet.http.HttpServletRequest"
  603.               depends=""
  604.                   msg="errors.date"
  605.        jsFunctionName="DateValidations">

  607.          
  608.             function validateDate(form) {
  609.                var bValid = true;
  610.                var focusField = null;
  611.                var i = 0;
  612.                var fields = new Array();
  613.                oDate = new DateValidations();
  614.                for (x in oDate) {
  615.                    var value = form[oDate[x][0]].value;
  616.                    var datePattern = oDate[x][2]("datePatternStrict");
  617.                    if ((form[oDate[x][0]].type == 'text' ||
  618.                         form[oDate[x][0]].type == 'textarea') &&
  619.                        (value.length > 0) &&
  620.                        (datePattern.length > 0)) {
  621.                      var MONTH = "MM";
  622.                      var DAY = "dd";
  623.                      var YEAR = "yyyy";
  624.                      var orderMonth = datePattern.indexOf(MONTH);
  625.                      var orderDay = datePattern.indexOf(DAY);
  626.                      var orderYear = datePattern.indexOf(YEAR);
  627.                      if ((orderDay < orderYear && orderDay > orderMonth)) {
  628.                          var iDelim1 = orderMonth + MONTH.length;
  629.                          var iDelim2 = orderDay + DAY.length;
  630.                          var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
  631.                          var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
  632.                          if (iDelim1 == orderDay && iDelim2 == orderYear) {
  633.                             dateRegexp = new RegExp("^(\\d{2})(\\d{2})(\\d{4})$");
  634.                          } else if (iDelim1 == orderDay) {
  635.                             dateRegexp = new RegExp("^(\\d{2})(\\d{2})[" + delim2 + "](\\d{4})$");
  636.                          } else if (iDelim2 == orderYear) {
  637.                             dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})(\\d{4})$");
  638.                          } else {
  639.                             dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{4})$");
  640.                          }
  641.                          var matched = dateRegexp.exec(value);
  642.                          if(matched != null) {
  643.                             if (!isValidDate(matched[2], matched[1], matched[3])) {
  644.                                if (i == 0) {
  645.                                    focusField = form[oDate[x][0]];
  646.                                }
  647.                                fields[i++] = oDate[x][1];
  648.                                bValid = false;
  649.                             }
  650.                          } else {
  651.                             if (i == 0) {
  652.                                 focusField = form[oDate[x][0]];
  653.                             }
  654.                             fields[i++] = oDate[x][1];
  655.                             bValid = false;
  656.                          }
  657.                      } else if ((orderMonth < orderYear && orderMonth > orderDay)) {
  658.                          var iDelim1 = orderDay + DAY.length;
  659.                          var iDelim2 = orderMonth + MONTH.length;
  660.                          var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
  661.                          var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
  662.                          if (iDelim1 == orderMonth && iDelim2 == orderYear) {
  663.                              dateRegexp = new RegExp("^(\\d{2})(\\d{2})(\\d{4})$");
  664.                          } else if (iDelim1 == orderMonth) {
  665.                              dateRegexp = new RegExp("^(\\d{2})(\\d{2})[" + delim2 + "](\\d{4})$");
  666.                          } else if (iDelim2 == orderYear) {
  667.                              dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})(\\d{4})$");
  668.                          } else {
  669.                              dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{4})$");
  670.                          }
  671.                          var matched = dateRegexp.exec(value);
  672.                          if(matched != null) {
  673.                              if (!isValidDate(matched[1], matched[2], matched[3])) {
  674.                                  if (i == 0) {
  675.                                      focusField = form[oDate[x][0]];
  676.                                  }
  677.                                  fields[i++] = oDate[x][1];
  678.                                  bValid = false;
  679.                               }
  680.                          } else {
  681.                              if (i == 0) {
  682.                                  focusField = form[oDate[x][0]];
  683.                              }
  684.                              fields[i++] = oDate[x][1];
  685.                              bValid = false;
  686.                          }
  687.                      } else if ((orderMonth > orderYear && orderMonth < orderDay)) {
  688.                          var iDelim1 = orderYear + YEAR.length;
  689.                          var iDelim2 = orderMonth + MONTH.length;
  690.                          var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
  691.                          var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
  692.                          if (iDelim1 == orderMonth && iDelim2 == orderDay) {
  693.                              dateRegexp = new RegExp("^(\\d{4})(\\d{2})(\\d{2})$");
  694.                          } else if (iDelim1 == orderMonth) {
  695.                              dateRegexp = new RegExp("^(\\d{4})(\\d{2})[" + delim2 + "](\\d{2})$");
  696.                          } else if (iDelim2 == orderDay) {
  697.                              dateRegexp = new RegExp("^(\\d{4})[" + delim1 + "](\\d{2})(\\d{2})$");
  698.                          } else {
  699.                              dateRegexp = new RegExp("^(\\d{4})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{2})$");
  700.                          }
  701.                          var matched = dateRegexp.exec(value);
  702.                          if(matched != null) {
  703.                              if (!isValidDate(matched[3], matched[2], matched[1])) {
  704.                                  if (i == 0) {
  705.                                      focusField = form[oDate[x][0]];
  706.                                   }
  707.                                   fields[i++] = oDate[x][1];
  708.                                   bValid = false;
  709.                               }
  710.                           } else {
  711.                               if (i == 0) {
  712.                                   focusField = form[oDate[x][0]];
  713.                               }
  714.                               fields[i++] = oDate[x][1];
  715.                               bValid = false;
  716.                           }
  717.                      } else {
  718.                          if (i == 0) {
  719.                              focusField = form[oDate[x][0]];
  720.                          }
  721.                          fields[i++] = oDate[x][1];
  722.                          bValid = false;
  723.                      }
  724.                   }
  725.                }
  726.                if (fields.length > 0) {
  727.                   focusField.focus();
  728.                   alert(fields.join('\n'));
  729.                }
  730.                return bValid;
  731.             }

  733.      function isValidDate(day, month, year) {
  734.      if (month < 1 || month > 12) {
  735.                     return false;
  736.                 }
  737.                 if (day < 1 || day > 31) {
  738.                     return false;
  739.                 }
  740.                 if ((month == 4 || month == 6 || month == 9 || month == 11) &&
  741.                     (day == 31)) {
  742.                     return false;
  743.                 }
  744.                 if (month == 2) {
  745.                     var leap = (year % 4 == 0 &&
  746.                                (year % 100 != 0 || year % 400 == 0));
  747.                     if (day>29 || (day == 29 && !leap)) {
  748.                         return false;
  749.                     }
  750.                 }
  751.                 return true;
  752.             }]]>
  753.          

  755.       


  758.       
  759.             classname="org.apache.struts.validator.FieldChecks"
  760.                method="validateIntRange"
  761.          methodParams="java.lang.Object,
  762.                        org.apache.commons.validator.ValidatorAction,
  763.                        org.apache.commons.validator.Field,
  764.                        org.apache.struts.action.ActionErrors,
  765.                        javax.servlet.http.HttpServletRequest"
  766.               depends="integer"
  767.                   msg="errors.range">

  769.          
  770.             function validateRange(form) {
  771.                 return validateIntRange(form);
  772.             }]]>
  773.          

  775.       

  777.       
  778.             classname="org.apache.struts.validator.FieldChecks"
  779.                method="validateIntRange"
  780.          methodParams="java.lang.Object,
  781.                        org.apache.commons.validator.ValidatorAction,
  782.                        org.apache.commons.validator.Field,
  783.                        org.apache.struts.action.ActionErrors,
  784.                        javax.servlet.http.HttpServletRequest"
  785.               depends="integer"
  786.                   msg="errors.range">

  788.          
  789.             function validateIntRange(form) {
  790.                 var isValid = true;
  791.                 var focusField = null;
  792.                 var i = 0;
  793.                 var fields = new Array();
  794.                 oRange = new intRange();
  795.                 for (x in oRange) {
  796.                     var field = form[oRange[x][0]];
  797.                     
  798.                     if ((field.type == 'text' ||
  799.                          field.type == 'textarea') &&
  800.                         (field.value.length > 0)) {
  801.                         
  802.                         var iMin = parseInt(oRange[x][2]("min"));
  803.                         var iMax = parseInt(oRange[x][2]("max"));
  804.                         var iValue = parseInt(field.value);
  805.                         if (!(iValue >= iMin && iValue <= iMax)) {
  806.                             if (i == 0) {
  807.                                 focusField = field;
  808.                             }
  809.                             fields[i++] = oRange[x][1];
  810.                             isValid = false;
  811.                         }
  812.                     }
  813.                 }
  814.                 if (fields.length > 0) {
  815.                     focusField.focus();
  816.                     alert(fields.join('\n'));
  817.                 }
  818.                 return isValid;
  819.             }]]>
  820.          

  822.       

  824.       
  825.             classname="org.apache.struts.validator.FieldChecks"
  826.                method="validateFloatRange"
  827.          methodParams="java.lang.Object,
  828.                        org.apache.commons.validator.ValidatorAction,
  829.                        org.apache.commons.validator.Field,
  830.                        org.apache.struts.action.ActionErrors,
  831.                        javax.servlet.http.HttpServletRequest"
  832.               depends="float"
  833.                   msg="errors.range">

  835.          
  836.             function validateFloatRange(form) {
  837.                 var isValid = true;
  838.                 var focusField = null;
  839.                 var i = 0;
  840.                 var fields = new Array();
  841.                 oRange = new floatRange();
  842.                 for (x in oRange) {
  843.                     var field = form[oRange[x][0]];
  844.                     
  845.                     if ((field.type == 'text' ||
  846.                          field.type == 'textarea') &&
  847.                         (field.value.length > 0)) {
  848.                         
  849.                         var fMin = parseFloat(oRange[x][2]("min"));
  850.                         var fMax = parseFloat(oRange[x][2]("max"));
  851.                         var fValue = parseFloat(field.value);
  852.                         if (!(fValue >= fMin && fValue <= fMax)) {
  853.                             if (i == 0) {
  854.                                 focusField = field;
  855.                             }
  856.                             fields[i++] = oRange[x][1];
  857.                             isValid = false;
  858.                         }
  859.                     }
  860.                 }
  861.                 if (fields.length > 0) {
  862.                     focusField.focus();
  863.                     alert(fields.join('\n'));
  864.                 }
  865.                 return isValid;
  866.             }]]>
  867.          

  869.       

  871.       
  872.             classname="org.apache.struts.validator.FieldChecks"
  873.                method="validateCreditCard"
  874.          methodParams="java.lang.Object,
  875.                        org.apache.commons.validator.ValidatorAction,
  876.                        org.apache.commons.validator.Field,
  877.                        org.apache.struts.action.ActionErrors,
  878.                        javax.servlet.http.HttpServletRequest"
  879.               depends=""
  880.                   msg="errors.creditcard">

  882.          
  883.             function validateCreditCard(form) {
  884.                 var bValid = true;
  885.                 var focusField = null;
  886.                 var i = 0;
  887.                 var fields = new Array();
  888.                 oCreditCard = new creditCard();
  889.                 for (x in oCreditCard) {
  890.                     if ((form[oCreditCard[x][0]].type == 'text' ||
  891.                          form[oCreditCard[x][0]].type == 'textarea') &&
  892.                         (form[oCreditCard[x][0]].value.length > 0)) {
  893.                         if (!luhnCheck(form[oCreditCard[x][0]].value)) {
  894.                             if (i == 0) {
  895.                                 focusField = form[oCreditCard[x][0]];
  896.                             }
  897.                             fields[i++] = oCreditCard[x][1];
  898.                             bValid = false;
  899.                         }
  900.                     }
  901.                 }
  902.                 if (fields.length > 0) {
  903.                     focusField.focus();
  904.                     alert(fields.join('\n'));
  905.                 }
  906.                 return bValid;
  907.             }

  909.             /**
  910.              * Reference: ~sburke/pub/luhn_lib.pl
  911.              */
  912.             function luhnCheck(cardNumber) {
  913.                 if (isLuhnNum(cardNumber)) {
  914.                     var no_digit = cardNumber.length;
  915.                     var oddoeven = no_digit & 1;
  916.                     var sum = 0;
  917.                     for (var count = 0; count < no_digit; count++) {
  918.                         var digit = parseInt(cardNumber.charAt(count));
  919.                         if (!((count & 1) ^ oddoeven)) {
  920.                             digit *= 2;
  921.                             if (digit > 9) digit -= 9;
  922.                         };
  923.                         sum += digit;
  924.                     };
  925.                     if (sum == 0) return false;
  926.                     if (sum % 10 == 0) return true;
  927.                 };
  928.                 return false;
  929.             }

  931.             function isLuhnNum(argvalue) {
  932.                 argvalue = argvalue.toString();
  933.                 if (argvalue.length == 0) {
  934.                     return false;
  935.                 }
  936.                 for (var n = 0; n < argvalue.length; n++) {
  937.                     if ((argvalue.substring(n, n+1) < "0") ||
  938.                         (argvalue.substring(n,n+1) > "9")) {
  939.                         return false;
  940.                     }
  941.                 }
  942.                 return true;
  943.             }]]>
  944.          

  946.       


  949.       
  950.             classname="org.apache.struts.validator.FieldChecks"
  951.                method="validateEmail"
  952.          methodParams="java.lang.Object,
  953.                        org.apache.commons.validator.ValidatorAction,
  954.                        org.apache.commons.validator.Field,
  955.                        org.apache.struts.action.ActionErrors,
  956.                        javax.servlet.http.HttpServletRequest"
  957.               depends=""
  958.                   msg="errors.email">

  960.          
  961.             function validateEmail(form) {
  962.                 var bValid = true;
  963.                 var focusField = null;
  964.                 var i = 0;
  965.                 var fields = new Array();
  966.                 oEmail = new email();
  967.                 for (x in oEmail) {
  968.                     if ((form[oEmail[x][0]].type == 'text' ||
  969.                          form[oEmail[x][0]].type == 'textarea') &&
  970.                         (form[oEmail[x][0]].value.length > 0)) {
  971.                         if (!checkEmail(form[oEmail[x][0]].value)) {
  972.                             if (i == 0) {
  973.                                 focusField = form[oEmail[x][0]];
  974.                             }
  975.                             fields[i++] = oEmail[x][1];
  976.                             bValid = false;
  977.                         }
  978.                     }
  979.                 }
  980.                 if (fields.length > 0) {
  981.                     focusField.focus();
  982.                     alert(fields.join('\n'));
  983.                 }
  984.                 return bValid;
  985.             }

  987.             /**
  988.              * Reference: Sandeep V. Tamhankar (stamhankar@hotmail.com),
  989.              *
  990.              */
  991.             function checkEmail(emailStr) {
  992.                if (emailStr.length == 0) {
  993.                    return true;
  994.                }
  995.                var emailPat=/^(.+)@(.+)$/;
  996.                var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]";
  997.                var validChars="\[^\\s" + specialChars + "\]";
  998.                var quotedUser="(\"[^\"]*\")";
  999.                var ipDomainPat=/^(\d{1,3})[.](\d{1,3})[.](\d{1,3})[.](\d{1,3})$/;
  1000.                var atom=validChars + '+
struts-config.xml中加入：

点击(此处)折叠或打开

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

最后附加代码： validatesample.rar   
阅读(2135) | 评论(0) | 转发(0) |
0

上一篇：struts的logic标签库详解

下一篇：初识正则表达式

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6