自己动手实现Java Validation 和JSR 303

参数检查用得最多的是JSR 303，用法示例：
http://blog.csdn.net/caihaijiang/article/details/7463514
但JSR 303有个缺点，那就是当参数的限制发生变化时，例如某String类型的最大长度由10改为20，就需要改代码重新编译。
那有没有办法只改配置文件重启程序就达到目的呢？
网上还没有类似的解决方案，那就自己实现Java Validation。

思路：
参数检查时，从配置文件中取得参数的限制条件，通过反射取得对应的字段值，并进行验证。

用法：

Java代码  收藏代码
//利用反射和注解自行实现的参数检查 
 
           Order order = newOrder(); 
           Map<String, String> configMap = ConfigMap.INSTANCE.getMap(); 
         
        //需要两个参数：一是需要参数检查的对象，二是参数的限制条件 
           List<String> list = Checker.INSTANCE.check(order, configMap); 
           for (String str : list) { 
         
            /*输出示例：
            cardNo不符合正则表达式\d+
            name长度最小不能小于2
            address长度最小不能小于2
            intVal最大不能超过9
            integerVal最小不能小于4
            longVal最小不能小于4
            longGVal最小不能小于4
            */ 
               System.out.println(str); 
           } 
 
       } 
 
     

Java代码  收藏代码
     
package com.ljn.validation; 
 
import java.util.HashMap; 
import java.util.Map; 
 
/**
* 
* 模拟从配置文件中读取配置值
* 用点号分隔，最后是字段名
*/ 
public enum ConfigMap { 
    INSTANCE; 
     
    private Map<String, String> map; 
     
    ConfigMap() { 
        map = new HashMap<String, String>(); 
         
        //在配置文件中这样写：check.com.ljn.validation.MyOrder.userId.max=3 
        //表示MyOrder这个类的userId字段，长度最大为3 
        map.put("check.com.ljn.validation.MyOrder.userId.max", "3"); 
        map.put("check.com.ljn.validation.MyOrder.name.max",  "3"); 
        map.put("check.com.ljn.validation.MyOrder.address.max", "3"); 
         
        map.put("check.com.ljn.validation.MyOrder.cardNo.reg", "\\d+"); 
         
        map.put("check.com.ljn.validation.MyOrder.intVal.max",  "9"); 
        map.put("check.com.ljn.validation.MyOrder.integerVal.max",  "9"); 
        map.put("check.com.ljn.validation.MyOrder.longVal.max",  "9"); 
        map.put("check.com.ljn.validation.MyOrder.longGVal.max",  "9"); 
         
        map.put("check.com.ljn.validation.MyOrder.userId.min", "2"); 
        map.put("check.com.ljn.validation.MyOrder.name.min",  "2"); 
        map.put("check.com.ljn.validation.MyOrder.address.min", "2"); 
                       
        map.put("check.com.ljn.validation.MyOrder.intVal.min",  "4"); 
        map.put("check.com.ljn.validation.MyOrder.integerVal.min",  "4"); 
        map.put("check.com.ljn.validation.MyOrder.longVal.min",  "4"); 
        map.put("check.com.ljn.validation.MyOrder.longGVal.min",  "4"); 
         
        map.put("check.com.ljn.validation.MyOrder.bigDecimalVal.maxBigDecimalIntegerSize",  "5"); 
        map.put("check.com.ljn.validation.MyOrder.bigDecimalVal.maxBigDecimalFractionSize",  "2"); 
    } 
 
} 

Java代码  收藏代码
package com.ljn.validation; 
 
import java.math.BigDecimal; 
import java.util.List; 
 
import javax.validation.constraints.Digits; 
import javax.validation.constraints.Max; 
import javax.validation.constraints.Min; 
import javax.validation.constraints.NotNull; 
import javax.validation.constraints.Size; 
 
public class Order { 
     
    @Check(NotNull=true) 
    @NotNull 
    private List nullVal; 
     
    @Size(min =2, max = 3) 
    @Check(Min=true,Max=true) 
    private String name; 
     
    @Size(min =2, max = 3) 
    @Check(Min=true, Max=true) 
    private String address; 
 
    private String userId; 
 
    @Min(4) 
    @Max(9) 
    @Check(Min=true, Max=true) 
    private int intVal; 
     
    @Min(4) 
    @Max(9) 
    @Check(Min=true, Max=true) 
    private Integer integerVal; 
     
    @Min(4) 
    @Max(9) 
    @Check(Min=true, Max=true) 
    private long longVal; 
     
    @Min(4) 
    @Max(9) 
    @Check(Min=true, Max=true) 
    private Long longGVal; 
     
    @Digits(integer=5, fraction=2) 
    @Check(MaxBigDecimalFractionSize=true, MaxBigDecimalIntegerSize=true) 
    private BigDecimal bigDecimalVal; 
     
//...setter and getter 
    } 

测试表明，Checker比JSR 303速度更快。Checker没有JSR 303那么全面，但也基本够用。

源码：
Java代码  收藏代码
import java.lang.annotation.ElementType; 
import java.lang.annotation.Retention; 
import java.lang.annotation.RetentionPolicy; 
import java.lang.annotation.Target; 
 
/**
* 1.NotNull/NotBlank默认值为false，其他为true
* 2.即使Min/Max/MaxBigDecimalIntegerSize/MaxBigDecimalFractionSize/RegExp这些选项配置为true，
*   也需要在配置文件中配置了具体值才会进行检查
* 3.对于String类型，不要同时配置NotNull和NotBlank，建议只配置NotBlank
* @author ljn
*
*/ 
@Retention(RetentionPolicy.RUNTIME) 
@Target(ElementType.FIELD) 
public @interface Check { 
  
    /**
     * 检查是否为null，适用所有数据类型
     */ 
    public boolean NotNull() default false; 
     
    /**
     * 检查字符串是否为空字符串（包括null），相当于StringUtils.isBlank
     */ 
    public boolean NotBlank() default false; 
     
    /**
     * 对于String类型，检查字符串长度是否小于最小长度
     * 对于short/Short/int/Integer/long/Long类型，检查是否小于最小值
     */ 
    public boolean Min() default true; 
     
    /**
     * 对于String类型，检查字符串长度是否超过最大长度
     * 对于short/Short/int/Integer/long/Long类型，检查是否超过最大值
     */ 
    public boolean Max() default true; 
     
    /**
     * 检查BigDecimal类型的整数部分的长度是否超过最大长度
     */ 
    public boolean MaxBigDecimalIntegerSize() default true; 
     
    /**
     * 检查BigDecimal类型的小数部分的长度是否超过最大长度
     */ 
    public boolean MaxBigDecimalFractionSize() default true; 
     
    /**
     * 检查字符串类型的值是否符合正则表达式指定的格式
     */ 
    public boolean RegExp() default true; 
  
} 
 
public enum Checker { 
     
    INSTANCE; 
     
     
    public static final String KEY_SEPARATOR = "."; 
    public static final String PREFIX = "check"; 
    public static final String SUFFIX_MAX = "max"; 
    public static final String SUFFIX_MIN = "min"; 
    public static final String SUFFIX_MAX_BIGDECIMAL_INTEGER_SIZE = "maxBigDecimalIntegerSize"; 
    public static final String SUFFIX_MAX_BIGDECIMAL_FRACTION_SIZE = "maxBigDecimalFractionSize"; 
    public static final String SUFFIX_REG_EXP = "regExp"; 
     
    private Map<Class<?>, List<Field>> classFields = new HashMap<Class<?>, List<Field>>(); 
     
    /**
     * 
     * @param obj 对obj进行参数检查
     * @param configMap 配置值，配置了各字段的限制值，例如最小长度，最大长度
     * @return 参数不合法的信息列表
     */ 
    public List<String> check(Object obj, Map<String, String> configMap){ 
        List<String> list = new ArrayList<String>(); 
         
        if (obj == null || configMap == null || configMap.isEmpty()) { 
            return list; 
        } 
         
        Class<? extends Object> clazz = obj.getClass(); 
        List<Field> fields = classFields.get(clazz); 
        if (fields == null) { 
            fields = getFieldsUpTo(clazz, Object.class); 
            if (fields == null || fields.isEmpty()) { 
                return list; 
            } 
            classFields.put(clazz, fields); 
        } 
         
        for (Field field : fields) { 
            field.setAccessible(true); 
            Check check = field.getAnnotation(Check.class); 
            if (check == null) { 
                continue; 
            } 
             
            Class<?> fieldType = field.getType(); 
            String fieldName = field.getName(); 
            Object value = null; 
            try { 
                value = field.get(obj); 
            } catch (Exception e) { 
                throw new RuntimeException(e); 
            } 
             
            if (value == null) { 
                if (check.NotNull()) { 
                    list.add(fieldName + "不能为null"); 
                } else if ( check.NotBlank() && fieldType.equals(String.class)) { 
                    list.add(fieldName + "不能为空"); 
                } 
            } else { 
                 
                //check_className_fieldName_suffix 
                String minKey = StringUtils.join(new String[]{PREFIX, clazz.getName(), fieldName, SUFFIX_MIN}, KEY_SEPARATOR);                 
                String maxKey = StringUtils.join(new String[]{PREFIX, clazz.getName(), fieldName, SUFFIX_MAX}, KEY_SEPARATOR);                 
                String maxBigDecimalIntegerSizeKey = StringUtils.join(new String[]{PREFIX, clazz.getName(), fieldName, SUFFIX_MAX_BIGDECIMAL_INTEGER_SIZE}, KEY_SEPARATOR); 
                String maxBigDecimalFractionSizeKey = StringUtils.join(new String[]{PREFIX, clazz.getName(), fieldName, SUFFIX_MAX_BIGDECIMAL_FRACTION_SIZE}, KEY_SEPARATOR); 
                String regExpKey = StringUtils.join(new String[]{PREFIX, clazz.getName(), fieldName, SUFFIX_REG_EXP}, KEY_SEPARATOR); 
                 
                if (fieldType.equals(String.class)) { 
                    String val = (String)value; 
                    if (check.NotBlank() && StringUtils.isBlank(val)) { 
                        list.add(fieldName + "不能为空"); 
                    } 
                    if (check.Min()) { 
                        int min = getInt(configMap, minKey); 
                        if (min != -1 && val.length() < min) { 
                            list.add(fieldName + "长度最小不能小于" + min);  
                        } 
                    } 
                    if (check.Max()) { 
                        int max = getInt(configMap, maxKey); 
                        if (max != -1 && val.length() > max) { 
                            list.add(fieldName + "长度最大不能超过" + max);  
                        } 
                    } 
                    if (check.RegExp()) { 
                        String exp = configMap.get(regExpKey); 
                        if (StringUtils.isNotBlank(exp) && StringUtils.isNotBlank(val) && !val.matches(exp)) { 
                            list.add(fieldName + "不符合正则表达式" + exp); 
                        } 
                    } 
                } 
                 
                if (fieldType.equals(Integer.class) || fieldType.equals(int.class)) { 
                    Integer val = (Integer)value; 
                    if (check.Min()) { 
                        int min = getInt(configMap, minKey); 
                        if (min != -1 && val < min) { 
                            list.add(fieldName + "最小不能小于" + min);  
                        } 
                    } 
                    if (check.Max()) { 
                        int max = getInt(configMap, maxKey); 
                        if (max != -1 && val > max) { 
                            list.add(fieldName + "最大不能超过" + max);  
                        } 
                    } 
                } 
                 
                if (fieldType.equals(Short.class) || fieldType.equals(short.class)) { 
                    Short val = (Short)value; 
                    if (check.Min()) { 
                        int min = getInt(configMap, minKey); 
                        if (min != -1 && val < min) { 
                            list.add(fieldName + "最小不能小于" + min);  
                        } 
                    } 
                    if (check.Max()) { 
                        int max = getInt(configMap, maxKey); 
                        if (max != -1 && val > max) { 
                            list.add(fieldName + "最大不能超过" + max);  
                        } 
                    } 
                } 
                 
                if (fieldType.equals(Long.class) || fieldType.equals(long.class)) { 
                    Long val = (Long)value; 
                    if (check.Min()) { 
                        long min = getLong(configMap, minKey); 
                        if (min != -1 && val < min) { 
                            list.add(fieldName + "最小不能小于" + min);  
                        } 
                    } 
                    if (check.Max()) { 
                        long max = getLong(configMap, maxKey); 
                        if (max != -1 && val > max) { 
                            list.add(fieldName + "最大不能超过" + max);  
                        } 
                    } 
                } 
                 
                if (fieldType.equals(BigDecimal.class)) { 
                    BigDecimal val = (BigDecimal)value; 
                    String str = val.toPlainString(); 
                    String[] parts = str.split("\\."); 
                    if (parts == null || parts.length == 0) { 
                        continue; 
                    } 
                    int integerSize = parts[0].length(); 
                    int fractionSize = parts.length == 2 ? parts[1].length() : 0; 
                    if (check.MaxBigDecimalIntegerSize()) { 
                        int max = getInt(configMap, maxBigDecimalIntegerSizeKey); 
                        if (max != -1 && integerSize > max) { 
                            list.add(fieldName + "整数部分长度最大不能超过" + max); 
                        } 
                    } 
                    if (check.MaxBigDecimalFractionSize()) { 
                        int max = getInt(configMap, maxBigDecimalFractionSizeKey); 
                        if (max != -1 && fractionSize > max) { 
                            list.add(fieldName + "小数部分长度最大不能超过" + max); 
                        } 
                    } 
                } 
                 
                 
            } 
             
 
        } 
        return list; 
    } 
     
    /**
     * 获取所有的Field
     * @param startClass
     * @param exclusiveParent
     * @return
     */ 
    public List<Field> getFieldsUpTo(Class<?> startClass, Class<?> exclusiveParent) { 
 
        List<Field> currentClassFields = new ArrayList<Field>(); 
        Field[] declaredFields = startClass.getDeclaredFields(); 
        for (Field field : declaredFields) { 
            currentClassFields.add(field); 
        } 
        Class<?> parentClass = startClass.getSuperclass(); 
 
        if (parentClass != null && (exclusiveParent == null || !(parentClass.equals(exclusiveParent)))) { 
            List<Field> parentClassFields = (List<Field>) getFieldsUpTo(parentClass, exclusiveParent); 
            currentClassFields.addAll(parentClassFields); 
        } 
 
        return currentClassFields; 
    } 
     
    private static int getInt(Map<String, String> map, String key) { 
        String val = map.get(key); 
        if (val != null) { 
            return Integer.parseInt(val); 
        } 
        return -1; 
    } 
     
    private static long getLong(Map<String, String> map, String key) { 
        String val = map.get(key); 
        if (val != null) { 
            return Long.parseLong(val); 
        } 
        return -1; 
    } 
     
 
}