Java 简单校验框架

╰+攻爆jí腚メ 2022-08-05 00:52 187阅读 0赞

### 数据校验框架现状 ###

在我们的方法入口后面，难免会有如下样子的代码：

result.setSuccess(false);
            if (StringUtils.isBlank(bizOrder.getThirdOrder())) {
                result.setResultMessage("thirdOrder不能为空");
     return result;
            }
    
            if(bizOrder.getThirdOrder().length() > 100){
                result.setResultMessage("thirdOrder长多过长，必须在100以内");
     return result;
            }
    
            if (StringUtils.isBlank(bizOrder.getSku())) {
                result.setResultMessage("sku不能为空");
     return result;
            }
            if (StringUtils.isBlank(bizOrder.getName())) {
                result.setResultMessage("name不能为空");
     return result;
            }       
    
            if(bizOrder.getName().length() > 20){
                result.setResultMessage("name字数过长");
     return result;
            }
    
            if (bizOrder.getProvince() == 0 || bizOrder.getCity() == 0
                    || bizOrder.getCounty() == 0) {
                result.setResultMessage("地址信息不正确");
     return result;
            }
            if (StringUtils.isBlank(bizOrder.getAddress())) {
                result.setResultMessage("address不能为空");
     return result;
            }

对于一名有洁癖的程序员，这显然是不行的，我们要更加的优雅。  
好吧，马后炮了，其实早就有这样的规范了：JSR 303 - Bean Validation  
对于其实现，目前用的最广泛的是：[**Hibernate Validator**][Hibernate Validator]  
Hiberante Validator, 小巧，规范，易扩展，易整合。  
但是本文不是说它。。。

对于Web应用，可能更多的我们还是使用Spring MVC的校验，叫做：spring mvc validator  
一百度一大堆，可以跟页面的error标签很好的结合做页面输入的校验。  
但是本文也不是说它。。。

本文主要是说，来写一个适合自己的校验框架

### 数据框架设计目的 ###

1.  要简单  
    只是作为一个小的工具包，代码最多几K，无依赖也是必须的吧
2.  要优雅  
    if.else的调用方式太难看了。看看如下的这种怎么样：

new Validator().notNull(name, "姓名").notNull(mail, "邮箱");

1.  要易用  
    注解是易用的一个好办法，就像JSR303那样
2.  要可扩展  
    要方便客户端程序方便的创建自定义校验器

### 总体设计 ###

![这里写图片描述][20150527182444694]

首先得起个名字吧，叫MiniValidator  
主要分了两个部分：  
1. 用来给对象进行注解的Annotation及其解析器和校验器  
Annotation ,一组注解  
Parser, 注解解析器，主要处理注解的行为  
AnnotationValidator 使用注解和解析器对传入的对象的字段进行校验  
2. 可扩展的校验器  
AnnotationRule 注解校验rule,作为内置的rule使用  
Rule 用于扩展，可以自定义Rule  
Validator 使用Rule对数据进行校验，或者使用内置的校验器

### 实现 ###

#### 注解校验部分 ####

首先写一个***注解***, 例如不能为空白：

@Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface NotBlank { 
        public String fieldName();
    }

然后是对应该注解的***解析器***：

/** * 不能为空白校验器 * @author cdwangzijian * */
    public class NotBlankParser implements IAnnotationParser { 
    
        /** * 校验字段f的值不能为null或者是空字符串，校验结果保存在result中 */
        @Override
        public ValidateResult validate(Field f, Object value) {
            ValidateResult result = new ValidateResult();
            if(f.isAnnotationPresent(NotBlank.class)){
                NotBlank notBlank = f.getAnnotation(NotBlank.class);
                if(value == null || value.toString().length() == 0){
                    result.setMessage(notBlank.fieldName() + "不能为空");
                }
            }
            return result;
        }
    
    }

下面是使用上面内容的***注解校验器***：

/** * 注解校验器 * @author cdwangzijian * */
    public class AnnotationValidator { 
        private static final Logger log = Logger.getLogger(AnnotationValidator.class.getName());
    
        private final static List<IAnnotationParser> vList = new ArrayList<IAnnotationParser>();
        static {
            vList.add(new NotNullParser());
            vList.add(new NotBlankParser());
        }
    
        /** * 遍历所有字段，用所有解析器进行校验，如果校验失败，则终止校验返回结果，如果校验成功，同样返回校验结果 * @param t * @return */
        public static <T> ValidateResult validate(T t){
            ValidateResult result = null;
            for (Field f : t.getClass().getDeclaredFields()) {
                f.setAccessible(true);
                Object value = null;
                try {
                    value = f.get(t);
                } catch (IllegalArgumentException e) {
                    log.log(Level.SEVERE, "Exception", e);
                } catch (IllegalAccessException e) {
                    log.log(Level.SEVERE, "Exception", e);
                }
    
                for (IAnnotationParser va : vList) {
                    result = va.validate(f, value);
                    if(!result.isValid()){
                        return result;
                    }
                }
            }
            return result;
        }
    
        /** * 注册解析器 * @param parser */
        public static void register(IAnnotationParser parser){
            vList.add(parser);
        }
    }

可以看到该校验器已经注册了多个解析器。然后对于传入的对象，会对每一个字段的值进行所有解析器的校验，得到校验结果。

写一个测试程序吧：

class User{
        private Long id;
        @NotBlank(fieldName="姓名")
        private String name;
        @Less(fieldName="年龄", value=100)
        private int age;
    
        private String phone;
        private String birthday;
        public Long getId() {
            return id;
        }
        public void setId(Long id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getPhone() {
            return phone;
        }
        public void setPhone(String phone) {
            this.phone = phone;
        }
        public String getBirthday() {
            return birthday;
        }
        public void setBirthday(String birthday) {
            this.birthday = birthday;
        }
    }
    
    public class TestAnnotationValidator {
        public static void main(String[] args) {
            User user = new User();
            ValidateResult result = AnnotationValidator.validate(user);
            if(result.isValid()){
                System.out.println("校验通过");
            }else{
                System.out.println(result.getMessage());
            }
        }
    }

输出的结果：

姓名不能为空

#### 扩展注解校验器 ####

基于这个框架，还是可以比较方便的进行扩展的。  
要写一个新的注解，新的解析器，然后注册一下新的解析器就能给新的字段进行校验了。如下：  
新的注解：

@Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface DateFormat { 
        public String fieldName();
        public String format();
    }

新的解析器

/** * 日期格式注解解析器 * * @author cdwangzijian * */
    public class DateFormatParser implements IAnnotationParser{ 
    
        /** * 校验f字段的值是否符合value的日期格式 * @see DateFormat */
        @Override
        public ValidateResult validate(Field f, Object value) {
            ValidateResult result = new ValidateResult();
            if(f.isAnnotationPresent(DateFormat.class)){
                DateFormat dateFormat = f.getAnnotation(DateFormat.class);
                try {
                    if(value != null){
                        SimpleDateFormat format = new SimpleDateFormat(dateFormat.format());
                        format.parse(value.toString());
                    }
                } catch (ParseException e) {
                    result.setMessage(dateFormat.fieldName() + "不满足格式：" + dateFormat.format());
                }   
            }
            return result;
        }
    }

使用扩展注解的测试程序：

public class TestAnnotationValidator {
        public static void main(String[] args) {
            User user = new User();
            user.setName("wzj");
            user.setAge(21);
            user.setBirthday("20150525");
            AnnotationValidator.register(new DateFormatParser());
            ValidateResult result = AnnotationValidator.validate(user);
            if(result.isValid()){
                System.out.println("校验通过");
            }else{
                System.out.println(result.getMessage());
            }
        }
    }

结果：

生日不满足格式：yyyy-MM-dd

好了，注解的部分就这么多了。

#### 通用校验部分 ####

通用校验部分首先是一个接口Rule, 供给校验器调用：

/** * 校验规则，用于扩展校验规则 * @author cdwangzijian * */
    public interface Rule { 
        public String getMessage();
        public boolean isValid();
    }

使用Rule的校验器：

/** * 通用校验器 * @author cdwangzijian * */
    public class Validator { 
        public Validator validate(Rule rule) {
            if(this.isValid){
                this.isValid = rule.isValid();
                this.message = rule.getMessage();
            }
            return this;
        }
    
        public Validator validateAnnotation(Object o){
            return validate(new AnnotationRule(o));
        }
    
        public Validator notNull(Object fieldValue, String fieldName) {
            if(this.isValid){
                if(fieldValue == null){
                    this.isValid = false;
                    this.message = fieldName + "不能为空";
                }
            }
            return this;
        }
    
        /** * 是否有效 * @return * true 校验通过，值有效 * message 校验未通过的错误信息 */
        public boolean isValid() {
            return isValid;
        }
        public String getMessage() {
            return message;
        }
    
        private boolean isValid = false;        // 是否有效
        private String message;                 // 错误信息
    }

该类除了使用Rule以外，还内置了一些notXX的方法，返回this，这样可以用.notXX().notXX().notXX()的结构来进行校验。  
来测试一下：

public class TestValidator {
        public static void main(String[] args) {
            testMethod("name", null, null, null);
        }
    
        public static void testMethod(String name, String mail, String thirdOrderId, String address){
            Validator v = new Validator().notNull(name, "姓名").notNull(mail, "邮箱").notNull(address, "地址");
            if(v.isValid()){
                System.out.println("校验通过");
            }else{
                System.out.println(v.getMessage());
            }
        }
    }

结果：

邮箱不能为空

#### 扩展通用校验器 ####

扩展就需要实现Rule接口，如下我们实现一个基于AnnotationValidator的Rule:

/** * 使用AnnotationValidator的校验规则 * * @see AnnotationValidator * @author cdwangzijian * */
    public class AnnotationRule implements Rule{ 
        private String message;
        private Object o;
    
        public AnnotationRule(Object o) {
            this.o = o;
        }
        @Override
        public String getMessage() {
            return message;
        }
    
        @Override
        public boolean isValid() {
            ValidateResult result = AnnotationValidator.validate(this.o);
            this.message = result.getMessage();
            return result.isValid();
        }
    
    }

然后在测试中使用中rule:

public class TestValidator {
        public static void main(String[] args) {
            new Validator().validate(new AnnotationRule(new User()));
        }
    }

### 总结 ###

到此，这个简单的校验框架就完成了。  
主要的技术上使用了注解，  
然后通过反射再利用注解解析器来进行解析进行校验  
校验器每个方法返回this，可以使用更优雅的代码来完成校验  
并且还可以比较方便的扩展。  
完整的代码，可以[从这里获取][Link 1]

[Hibernate Validator]: http://docs.jboss.org/hibernate/validator/4.2/reference/zh-CN/html_single/
[20150527182444694]: /images/20220805/05f7bf70db324685931717466c1947c5.png
[Link 1]: http://download.csdn.net/detail/three_man/8745575