java 数据格式验证类

作为一个前端，懂一点java,php之类的，甚好。

我所在的项目前端采用的就是java的spring mvc框架，所以我们也写java，掐指一算，也快一年了。

前端而言，验证是一个坎，绕不过去的，前面的页面得验证，提交到java这边也是需要验证的，接口那边也会进行验证，三层验证，按需来分配。

最常见的验证的一种就是数据格式的验证，比如为空，手机号，邮箱，中文等等。

前端的验证好办，引入jquery.validator，额外的配置一下，就ok了。

当然jquery正逐渐的离我们远去，新兴的vue,react,angular都有自己的验证类或者包。

项目刚开始是从php改版过来的，虽说不了解php，但不得不说，php的全局方法异常强大。验证这块采取了基于laravel自带的，相对比较方便。

java这边自己搜索了，没有搜索到比较好而精简的验证辅助类，参考Laravel思想，自己写一个相对比较简单的验证类吧。

思想：

1. 把前台传输的数据，变为JSONObject，这种简单的键值对。

2. 配置验证，如下面的格式，

key是需要验证的键，

value是要进行的验证

{
     'bankId'：'required',
     'cardNumber'：'required|is_bank_card',
     'provinceValue'：'required',
     'cityValue'：'required',        
     'description': 'required|max:250'
  }  

3. 配置消息提示

           {
            'bankId.required'：'开户行是必填项',
            'cardNumber.required'：'银行卡号是必填项',
            'cardNumber.is_bank_card'：'请输入正确的银行卡号',
            'provinceValue.required'：'请选择开户省',
            'cityValue.required'：'请选择开户市',
            'branchOffice.required'：'支行名称是必填项',    
　　　　　　　'description.max':'做多输入250个字符'
           }  

4. 进行验证，最简单的键值遍历，引用反射执行验证方法

直接上代码了，约160行

import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang.StringUtils;
import net.sf.json.JSONObject;

public class Validators {
    /**
     * 数据格式
     *
     * {
     *         bankId:4545454,
     *         cardNumber : 454545
     *         provinceValue:哈哈
     * }
     *
     *
     * 需要匹配的配置
     * {
     *      'bankId'：'required',
            'cardNumber'：'required|is_bank_card',
            'provinceValue'：'required',
            'cityValue'：'required',
            'description': 'required|max:250'

         }
           匹配失败的信息格式
           {
               'bankId.required'：'开户行是必填项',
            'cardNumber.required'：'银行卡号是必填项',
            'cardNumber.is_bank_card'：'请输入正确的银行卡号',
            'provinceValue.required'：'请选择开户省',
            'cityValue.required'：'请选择开户市',
            'description.max':'做多输入250个字符'
           }
     * @return
     */

    public static JSONObject make(JSONObject data,JSONObject rules , JSONObject messages){
        JSONObject retObj = new JSONObject();
        String retMessages  = "";
        //如果为空直接返回
        if(data == null || rules == null ||messages == null){
            retObj.put("passes", false);
            return retObj;
        }

        Iterator it = data.keys();
        String key, value,message,methodNames,realMethodName;
        Method method;
        String[] methods;
        boolean success = false;
        Validators vu = new Validators();
        while(it.hasNext()){
            try{
                //当前的key
                key = (String)it.next();
                //当前的值
                value = data.getString(key);
                //当前key对应的检验方法,
                if(rules.has(key)){
                    methodNames = rules.getString(key);
                    methods = methodNames.split("\\|");
                    for(String methodName:methods ){
                        realMethodName = methodName;
                        if(methodName.split(":").length >=2){
                            //处理函数名称 min:6, maxLength:250
                            //真正的名字应该是：前面部分，后面部分属于参数
                            realMethodName =  methodName.split(":")[0];
                            method = vu.getClass().getMethod(realMethodName, String.class,String.class);
                            //第一个参数是值，第二个参数是对比参考的参数
                            success =(Boolean) method.invoke(vu, value,methodName.split(":")[1]);
                        }else{
                            //处理只有一个参数的验证
                            method = vu.getClass().getMethod(realMethodName, String.class);
                            success =(Boolean) method.invoke(vu, value);
                        }
                        if(!success){
                            //获得当前key对应验证失败对应的消息,如果未配置错误信息，不添加错误信息
                            if(messages.has(key + "." + realMethodName)){
                                message =messages.getString(key + "." + realMethodName );
                                retMessages += StringUtils.isBlank(retMessages)? message:";#" + message;
                            }
                        }
                    }
                }else{//如果未定义规则，继续
                    continue;
                }
            }catch(Exception ex){
                String em = ex.getMessage();
                ex.printStackTrace();
                //retObj.put("passes", false);
                //return retObj;
            }
        }

        //TODO::不能依据retMessages来识别
        retObj.put("messages", retMessages);
        retObj.put("passes", StringUtils.isBlank(retMessages)?true:false);
        return retObj;
    }    

    /**
     * 必须填写
     * @param value
     * @return
     */
    public static boolean required (String value){
        if(value == null || "".equals(value.trim())){
            return false;
        }
        return true;
    }

    /**
     * 手机号码
     * @param value
     * @return
     */
    public static boolean mobile_phone(String value){
        return match("^1(3\\d|4(7)|5(0|1|2|3|5|6|7|8|9)|7(0|3|6|7|8)|8\\d)\\d{8}$" ,value);
    }    

    /**
    * @param regex 正则表达式字符串
    * @param str 要匹配的字符串
    * @return 如果str 符合 regex的正则表达式格式,返回true, 否则返回 false;
    */
    public static boolean match(String regex, String str) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        return matcher.matches();
    }

    public static void main(String[] args){
        JSONObject data = new JSONObject();
        data.put("name", "dsds");

        JSONObject rules = new JSONObject();
        rules.put("name", "required|mobile_phone");

        JSONObject messages = new JSONObject();
        messages.put("name.required", "必须有值");
        messages.put("name.mobile_phone", "非法手机号码");

        JSONObject result  = make(data,rules,messages);
    } 

}