正则匹配

1.调用demo

ValidUtil.valid("【设备编码】50内长度数字", body.getDeviceNum(), "{'required':true,'regex':'" + RegexConstants.DEVICE_NUM_PATTERN + "'}");
ValidUtil.valid("【任务状态】", body.getStatus(), "{'required':true,'numeric':{'min':1,'max':5}}");
ValidUtil.valid("【算法类型】1:中心算法 2:边缘算法 3:第三方算法", body.getAlgType(), "{'required':false,'numeric':{'min':1,'max':3}}");
ValidUtil.valid("【任务类型】1:切图任务,2：采集任务", body.getTaskType(), "{'required':true,'numeric':{'min':1,'max':2}}");
ValidUtil.valid("【帧率】,", body.getVideoFps(), "{'required':true,'numeric':{'min':1,'max':1000}}");
ValidUtil.valid("【图片组数】,", body.getPictureNum(), "{'required':true,'numeric':{'min':1,'max':" + body.getVideoFps() + "}}");

2.参数校验类

package com.awifi.capacity.analysis.task.distribute.common.util;

import com.alibaba.fastjson.JSON;
import com.awifi.capacity.analysis.task.distribute.common.constant.RegexConstants;
import com.awifi.capacity.analysis.task.distribute.common.constant.ReturnCode;
import com.awifi.capacity.analysis.task.distribute.common.exception.ValidException;
import org.apache.commons.lang.StringUtils;

import java.text.MessageFormat;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;


/**
 * 版权所有： 爱WiFi无线运营中心
 * 创建日期:2017年1月17日 下午2:05:15
 * 创建作者：hw
 * 文件名称：ValidUtil.java
 * 版本：  v1.0
 * 功能：参数校验
 * 修改记录：
 */
@SuppressWarnings("unchecked")
public class ValidUtil {

    /**
     * 校验
     * @param key 键
     * @param value 值
     * @param rules 规则
     * @author hw  
     * @date 2017年1月17日 下午2:26:47
     */
    public static void valid(String key, Object value, String rules){
        notBlank("rules", rules);//校验规则不允许为空
        if(rules.indexOf("{") == -1){//判断rules是否属于json格式的
            validSingle(key, value, rules);//校验单参数
        }else {
            validMulti(key, value, rules);//校验正则或多个参数
        }
    }
    
    /**
     * 校验单参数
     * @param key 键
     * @param value 值
     * @param rule 规则
     * @author hw  
     * @date 2017年1月17日 下午2:26:47
     */
    private static void validSingle(String key, Object value, String rule){
        if(rule.trim().equals("required")){//必填校验
            notBlank(key, value);//非空字符串校验
        }else if(rule.trim().equals("numeric")){//数字校验
            isNumeric(key, value);//数字校验
        }else if(rule.trim().equals("arrayNotBlank")) {//数组内部不允许存在空值(null|"")的校验
            arrayNotBlank(key, value);//数组内部不允许存在空值(null|"")的校验
        } else if (rule.trim().equals("length")){//长度校验，暂只支持字符串
            length(key, value, CastUtil.toInteger(rule));
        }else{
            throw new ValidException(ReturnCode.RULE_OVER_EX.getCode(), MessageFormat.format(ReturnCode.RULE_OVER_EX.getMsg(), rule));//rule[{0}]超出了范围!
        }
    }
    
    /**
     * 校验正则或多个参数
     * @param key 键
     * @param value 值
     * @param rules 规则
     * @author hw  
     * @date 2017年1月17日 下午2:26:47
     */
    private static void validMulti(String key, Object value, String rules) {
        Map<String, Object> ruleMap = JSON.parseObject(rules, LinkedHashMap.class);
        for (Map.Entry<String, Object> entry : ruleMap.entrySet()) {
            String ruleKey = entry.getKey();//规则 键
            Object ruleValue = entry.getValue();//规则 值
            notBlank("ruleKey", ruleKey);//规则 键 不允许为空
            notNull("ruleValue", ruleValue);//规则 值 不允许为空
            //没有配必填参数默认为不必填。不必填在值为空的情况下不校验
            if(!ruleKey.trim().equals("required") ){
                if(value==null || (value instanceof String && "".equals(value))){
                    return;
                }
            }
            if (ruleKey.trim().equals("required")) {//必填校验
                isBoolean("ruleValue", ruleValue);//规则 值 必须为boolean
                if ((Boolean) ruleValue) {
                    //非空字符串校验required情况为true下
                    notBlank(key, value);
                }else {
                    //非空字符串校验required情况为false下
                    if(value==null || (value instanceof String && "".equals(value))){
                        return;
                    }else {
                        notBlank(key, value);
                    }
                }
            } else if (ruleKey.trim().equals("numeric")) {//数字校验
                if (ruleValue instanceof Boolean && !((Boolean) ruleValue)) {//当为false时，不校验
                    return;
                }
                isNumeric(key, value);//数字校验
                isNumericRange(key, value, ruleValue);//数字最大/最小校验
            } else if (ruleKey.trim().equals("arrayNotBlank")) {//数组内部不允许存在空值(null|"")的校验
                isBoolean("ruleValue", ruleValue);//规则 值 必须为boolean
                if ((Boolean) ruleValue) {
                    arrayNotBlank(key, value);//数组内部不允许存在空值(null|"")的校验
                }
            } else if (ruleKey.trim().equals("length")) {//长度校验，暂只支持字符串
                length(key, value, (Integer) ruleValue);
            } else if (ruleKey.trim().equals("regex")) {//正则匹配
                isString("ruleValue", ruleValue);//规则 值 必须为字符串
                regex(key, value, (String) ruleValue);
            }
        }
    }

    /**
     * 字符串判断
     * @param key 键
     * @param value 值
     * @author hw  
     * @date 2017年1月17日 下午2:37:26
     */
    private static void isString(String key, Object value){
        if(!(value instanceof String)){
            throw new ValidException(ReturnCode.MUST_STRING_TYPE_EX.getCode(), MessageFormat.format(ReturnCode.MUST_STRING_TYPE_EX.getMsg(), key));
        }
    }
    
    /**
     * 字符串判断
     * @param key 键
     * @param value 值
     * @author hw  
     * @date 2017年1月17日 下午2:37:26
     */
    private static void isBoolean(String key, Object value){
        if(!(value instanceof Boolean)){
            throw new ValidException(ReturnCode.MUST_BOOLEAN_TYPE_EX.getCode(), MessageFormat.format(ReturnCode.MUST_BOOLEAN_TYPE_EX.getMsg(), key));
        }
    }
    
    /**
     * 数字判断
     * @param key 键
     * @param value 值
     * @author hw  
     * @date 2017年1月22日 上午10:14:54
     */
    private static void isNumeric(String key, Object value){
        if(value == null){
            return;
        }
        if(value instanceof Integer || value instanceof Long){
            return;
        }
        isString(key, value);
        String valueStr = (String)value;
        if(!RegexUtil.match(valueStr, RegexConstants.NUMBER_PATTERN)){
            throw new ValidException(ReturnCode.MUST_NUMBER_TYPE_EX.getCode(), MessageFormat.format(ReturnCode.MUST_NUMBER_TYPE_EX.getMsg(), key));
        }
    }
    
    /**
     * 数字最大/最小校验
     * @param key 
     * @param value 
     * @param ruleValue 
     * @author 亢燕翔  
     * @date 2017年1月22日 下午2:23:16
     */
    private static void isNumericRange(String key, Object value, Object ruleValue) {
        if(value == null){//当值为空时，流程结束
            return;
        }
        if(ruleValue instanceof Boolean){//ruleValue 为boolean时，流程结束
            return;
        }
        /* 规则  不允许为为空，防止出现  rlueValue=="" 的情况 */
        if(ruleValue instanceof String){
            String ruleValueStr = (String)ruleValue;//校验规则 转化为字符串
            if(ruleValueStr == null || ruleValueStr.trim().length() <= 0){//非空校验
                throw new ValidException(ReturnCode.NOT_ALLOW_NULL_EX.getCode(), MessageFormat.format(ReturnCode.NOT_ALLOW_NULL_EX.getMsg(), "规则"));
            }
        }
        /* value 处理，转换为int */
        isNumeric("numeric.value", value);//判断value是否为数字
        Integer valueInt = CastUtil.toInteger(value);
        
        Map<String, Integer> numMap = JsonUtil.fromJson(ruleValue.toString(), HashMap.class);
        /* numeric.min 处理，转换为int */
        Object minObj = numMap.get("min");
        isNumeric("numeric.min", minObj);//判断规则中的最小值[min]是否为数字
        Integer min =CastUtil.toInteger(minObj);
        if(min != null && min > valueInt){
            throw new ValidException(ReturnCode.LOW_NUMBER_EX.getCode(), MessageFormat.format(ReturnCode.LOW_NUMBER_EX.getMsg(), new Object[]{key,min}));
        }
        /* numeric.max 处理，转换为int */
        Object maxObj = numMap.get("max");
        isNumeric("numeric.max", maxObj);//判断规则中的最小值[min]是否为数字
        Integer max =CastUtil.toInteger(maxObj);
        if(max == null){
            return;
        }
        if(max < valueInt){
            throw new ValidException(ReturnCode.UP_NUMBER_EX.getCode(), MessageFormat.format(ReturnCode.UP_NUMBER_EX.getMsg(), new Object[]{key,min}));
        }
    }
    
    /**
     * 非空判断
     * @param key 键
     * @param value 值
     * @author hw  
     * @date 2017年1月17日 下午2:08:08
     */
    private static void notNull(String key, Object value){
        if(value == null){
            throw new ValidException(ReturnCode.NOT_ALLOW_NULL_EX.getCode(), MessageFormat.format(ReturnCode.NOT_ALLOW_NULL_EX.getMsg(),key));//{0}不允许为空!
        }
    }
    
    /**
     * 非空字符串判断
     * @param key 键
     * @param value 值
     * @author hw  
     * @date 2017年1月17日 下午2:08:08
     */
    private static void notBlank(String key, Object value){
        notNull(key, value);//非空判断
        //isString(key, value);//字符串判断
        if(!(value instanceof String)){
            return;
        }
        String valueStr = (String)value;
        if(valueStr.trim().length() <= 0){
            throw new ValidException(ReturnCode.NOT_ALLOW_NULL_EX.getCode(), MessageFormat.format(ReturnCode.NOT_ALLOW_NULL_EX.getMsg(),key));//{0}不允许为空!
        }
    }
    
    /**
     * 数组内部不允许存在空值(null|"")的校验
     * @param key 键
     * @param value 值
     * @author hw  
     * @date 2017年2月9日 上午9:29:17
     */
    private static void arrayNotBlank(String key, Object value){
        notNull(key, value);//非空判断
        if(!(value instanceof Object[])){
            return;
        }
        Object[] objArray= (Object[])value;
        int maxLength = objArray.length;
        if(maxLength <= 0){
            throw new ValidException(ReturnCode.NOT_ALLOW_NULL_EX.getCode(), MessageFormat.format(ReturnCode.NOT_ALLOW_NULL_EX.getMsg(),"数组内容"));//{0}不允许为空!
        }
        Object obj = null;
        for(int i=0; i<maxLength; i++){
            obj = objArray[i];
            if(obj == null){//对象不允许为空
                throw new ValidException(ReturnCode.NOT_ALLOW_NULL_EX.getCode(), MessageFormat.format(ReturnCode.NOT_ALLOW_NULL_EX.getMsg(),key));//{0}不允许为空!
            }
            if(obj instanceof String){//字符串不允许为""
                String str = (String)obj;
                if(str.trim().length() <= 0){
                    throw new ValidException(ReturnCode.NOT_ALLOW_NULL_EX.getCode(), MessageFormat.format(ReturnCode.NOT_ALLOW_NULL_EX.getMsg(),key));//{0}不允许为空!
                }
            }
        }
        
    }

    /**
     * 长度校验，暂只支持字符串
     * @param key 键
     * @param value 值
     * @param length 长度
     * @author hw
     * @date 2017年11月7日 下午2:20:40
     */
    private static void length(String key, Object value, int length){
        if(!(value instanceof String)){//不是字符串，自动跳过
            return;
        }
        String valueStr = (String)value;
        if(StringUtils.isBlank(valueStr)){//空串，自动跳过
            return;
        }
        if(valueStr.length() > length){
            throw new ValidException(ReturnCode.UP_PARAM_LENGTH_EX.getCode(), MessageFormat.format(ReturnCode.UP_PARAM_LENGTH_EX.getMsg(), new Object[]{key, value, length}));//{0}不允许为空!
        }
    }

    /**
     * 正则匹配
     * @param key 键
     * @param value 值
     * @param pattern 正则公式
     * @author hw  
     * @date 2017年1月17日 下午2:19:39
     */
    private static void regex(String key, Object value, String pattern){
        //notNull(key, value);//非空判断
        if(value == null){
            return;
        }
        isString(key, value);//字符串判断
        String valueStr = (String)value;
        if(!RegexUtil.match(valueStr, pattern)){
            throw new ValidException(ReturnCode.NOT_FIT_REGULAR_EX.getCode(), MessageFormat.format(ReturnCode.NOT_FIT_REGULAR_EX.getMsg(), key));//{0}不符合正则规范!
        }
    }

}

 

3.正则匹配工具类

package com.awifi.capacity.analysis.task.distribute.common.util;


import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 版权所有： 爱WiFi无线运营中心
 * 创建日期:2017年1月17日 下午2:17:45
 * 创建作者：hw
 * 文件名称：RegexUtil1.java
 * 版本：  v1.0
 * 功能：正则匹配工具类
 * 修改记录：
 */
public class RegexUtil {

    /**
     * 正则匹配
     * @param str 待匹配字符串
     * @param pattern 正则表达式
     * @return true 成功、false 失败
     * @author hw  
     * @date 2017年1月17日 下午2:17:25
     */
    public static boolean match(String str, String pattern){
        return match(str, pattern, null);
    }
    
    /**
     * 正则匹配
     * @param str 待匹配字符串
     * @param pattern 正则表达式
     * @param flags flags
     * @return true 成功、false 失败
     * @author hw  
     * @date 2016年7月25日 下午12:13:16
     */
    public static boolean match(String str, String pattern, Integer flags){
        if(str == null){
            return false;
        }
        Pattern p = null;
        if(flags == null){
            p = Pattern.compile(pattern);
        }else {
            p = Pattern.compile(pattern, flags);
        }
        Matcher m = p.matcher(str);
        return m.matches();
    }

}

 

4.正则定义类

package com.awifi.capacity.analysis.task.distribute.common.constant;

/**
 * @ClassName RegexConstants
 * @Description 正则常量
 * @Author hw
 * @Date 2019/7/16 19:53
 * @Version 1.0
 **/
public class RegexConstants {
    /** 数字 */
    public static final String NUMBER_PATTERN = "^-?\\\\d+$";
    /**50以内字符 非空*/
    public static final String DEVICE_NUM_PATTERN = "^[0-9]{5,50}$";
    /**50以内字符 非空*/
    public static final String STRING_1_50_PATTERN = "^.{1,50}$";
    /**50以内字符 非空*/
    public static final String STRING_1_250_PATTERN = "^.{1,250}$";
    /** xx_xx_xx */
    public static final String ALG_CODE_PATTERN = "^([1-9]{0,5})_([1-9]{0,5})_([1-9]{0,5})$";
}

 

5.返回标识类

package com.awifi.capacity.analysis.task.distribute.common.constant;

/**
 * @ClassName ReturnCode
 * @Description 返回标识类
 * @Author hw
 * @Date 2019/6/25 8:22 PM
 * @Version 1.0
 **/
public enum ReturnCode {
    SUCCESS("0", "成功"),
    FAIL("1", "失败"),
    JSON_EX("2","JSON转换异常"),
    PARAMS_EMPTY("5","{0}参数不能为空"),
    SQL_EX("5014","数据库异常"),
    UNKNOW_EX("5015","未知异常"),
    DATA_IS_EXIST("5027","{0}数据已存在"),
    DATA_IS_NO_EXIST("5028","{0}数据不存在"),


    /**参数校验异常码8101~8150*/
    RULE_OVER_EX("8101","rule[{0}]超出了范围!"),
    NOT_ALLOW_NULL_EX("8102","{0}不允许为空!"),
    NOT_FIT_REGULAR_EX("8103","{0}不符合正则规范!"),
    LOW_NUMBER_EX("8104","{0}超出范围，不能小于{1}!"),
    UP_NUMBER_EX("8105","{0}超出范围，不能大于{1}!"),
    MUST_STRING_TYPE_EX("8106","{0}的数据类型必须为必须为字符串!"),
    MUST_BOOLEAN_TYPE_EX("8107","{0}的数据类型必须为必须为Boolean!"),
    MUST_NUMBER_TYPE_EX("8108","{0}的数据类型必须为必须为数字!"),
    UP_PARAM_LENGTH_EX("8109","'{0}'的'{1}'数据长度超过了{2}！"),
    INSTANCE_NOT_EXIST("8110","切图实例不存在！"),
    TASK_IS_EXIST("8111","切图任务已存在,请不要重复创建!"),
    TASK_IS_NOT_EXIST("8113","切图任务不存在!"),
    TASK_CANT_CHANGE_STATUS("8112","任务状态无法执行当前操作!");


    private String code;

    private String msg;

    private ReturnCode(String value, String msg){
        this.code = value;
        this.msg = msg;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}