天地初开

五年前,科技大厦 1 层 B 座。

小明的眼睛直勾勾地盯着屏幕,双手噼里啪啦的敲着键盘。

思考是不存在的,思考只会让小明的速度降下来。

优秀的程序员完全不需要思考,就像不需要写文档和注释一样。

“真是简单的需求啊”,小明觉得有些无聊,“毫无挑战。”

和无数个 web 开发者一样,小明今天做的是用户的注册功能。

首先定义一下对应的用户注册对象:

public class UserRegister {

    /**
     * 名称
     */
    private String name;

    /**
     * 原始密码
     */
    private String password;

    /**
     * 确认密码
     */
    private String password2;

    /**
     * 性别
     */
    private String sex;

    // getter & setter & toString()
}

注册时格式要求文档也做了简单的限制:

(1)name 名称必须介于 1-32 位之间

(2)password 密码必须介于 6-32 位之间

(3)password2 确认密码必须和 password 保持一致

(4)sex 性别必须为 BOY/GIRL 两者中的一个。

“这也不难”,无情的编码机器开始疯狂的敲打着键盘,不一会儿基本的校验方法就写好了:

private void paramCheck(UserRegister userRegister) {
    //1. 名称
    String name = userRegister.getName();
    if(name == null) {
        throw new IllegalArgumentException("名称不可为空");
    }
    if(name.length() < 1 || name.length() > 32) {
        throw new IllegalArgumentException("名称长度必须介于 1-32 之间");
    }

    //2. 密码
    String password = userRegister.getPassword();
    if(password == null) {
        throw new IllegalArgumentException("密码不可为空");
    }
    if(password.length() < 6 || password.length() > 32) {
        throw new IllegalArgumentException("密码长度必须介于 6-32 之间");
    }
    //2.2 确认密码
    String password2 = userRegister.getPassword2();
    if(!password.equals(password2)) {
        throw new IllegalArgumentException("确认密码必须和密码保持一致");
    }

    //3. 性别
    String sex = userRegister.getSex();
    if(!SexEnum.BOY.getCode().equals(sex) && !SexEnum.GIRL.getCode().equals(sex)) {
        throw new IllegalArgumentException("性别必须指定为 GIRL/BOY");
    }
}

打完收工,小明把代码提交完毕,就早早地下班跑路了。

初见 Hibernate-Validator

“小明啊,我今天简单地看了一下你的代码。”,项目经理看似随意地提了一句。

小明停下了手中的工作,看向项目经理,意思是让他继续说下去。

“整体还是比较严谨的,就是写了太多的校验代码。”

“太多的校验代码?不校验数据用户乱填怎么办?”,小明有些不太明白。

“校验代码的话,有时间可以了解一下 hibernate-validator 校验框架。”

“可以,我有时间看下。”

嘴上说着,小明心里一万个不愿意。

什么休眠框架,影响我搬砖的速度。

后来小明还是勉为其难的搜索了一下 hibernate-validator,看了看感觉还不错。

这个框架提供了很多内置的注解,便于日常校验的开发,大大提升了校验方法的可复用性。

于是,小明把自己的校验方法改良了一下:

public class UserRegister {

    /**
     * 名称
     */
    @NotNull(message = "名称不可为空")
    @Length(min = 1, max = 32, message = "名称长度必须介于 1-32 之间")
    private String name;

    /**
     * 原始密码
     */
    @NotNull(message = "密码不可为空不可为空")
    @Length(min = 1, max = 32, message = "密码长度必须介于 6-32 之间")
    private String password;

    /**
     * 确认密码
     */
    @NotNull(message = "确认密码不可为空不可为空")
    @Length(min = 1, max = 32, message = "确认密码必须介于 6-32 之间")
    private String password2;

    /**
     * 性别
     */
    private String sex;

}

校验方法调整如下:

private void paramCheck2(UserRegister userRegister) {
    //1. 名称
    ValidateUtil.validate(userRegister);

    //2.2 确认密码
    String password2 = userRegister.getPassword2();
    if(!userRegister.getPassword().equals(password2)) {
        throw new IllegalArgumentException("确认密码必须和密码保持一致");
    }

    //3. 性别
    String sex = userRegister.getSex();
    if(!SexEnum.BOY.getCode().equals(sex) && !SexEnum.GIRL.getCode().equals(sex)) {
        throw new IllegalArgumentException("性别必须指定为 GIRL/BOY");
    }
}

确实清爽了很多,ValidateUtil 是基于一个简单的工具类:

public class ValidateUtil {

    /**
     * 使用hibernate的注解来进行验证
     */
    private  static Validator validator = Validation
            .byProvider(HibernateValidator.class)
            .configure().failFast(true)
            .buildValidatorFactory()
            .getValidator();

    public static <T> void validate(T t) {
        Set<ConstraintViolation<T>> constraintViolations = validator.validate(t);
        // 抛出检验异常
        if (constraintViolations.size() > 0) {
            final String msg = constraintViolations.iterator().next().getMessage();
            throw new IllegalArgumentException(msg);
        }
    }

}

但是小明依然觉得不满意,sex 的校验可以进一步优化吗?

答案是肯定的,小明发现 hibernate-validator 支持自定义注解。

这是一个很强大的功能,优秀的框架就应该为使用者提供更多的可能性

于是小明实现了一个自定义注解:

@Target({ ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = MyEnumRangesValidator.class)
public @interface MyEnumRanges {

    Class<? extends Enum> value();

    String message() default "";

}

MyEnumRangesValidator 的实现如下:

public class MyEnumRangesValidator implements
        ConstraintValidator<MyEnumRanges, String> {

    private MyEnumRanges myEnumRanges;

    @Override
    public void initialize(MyEnumRanges constraintAnnotation) {
        this.myEnumRanges = constraintAnnotation;
    }

    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        return getEnumValues(myEnumRanges.value()).contains(value);
    }

    /**
     * 获取枚举值对应的信息
     *
     * @param enumClass 枚举类
     * @return 枚举说明
     * @since 0.0.9
     */
    private List<String> getEnumValues(Class<? extends Enum> enumClass) {
        Enum[] enums = enumClass.getEnumConstants();

        return ArrayUtil.toList(enums, new IHandler<Enum, String>() {
            @Override
            public String handle(Enum anEnum) {
                return anEnum.toString();
            }
        });
    }

}

限制当前的字段值必须在指定的枚举范围内,以后所有涉及到枚举范围的,使用这个注解即可搞定。

然后把 @MyEnumRanges 加在 sex 字段上:

@NotNull(message = "性别不可为空")
@MyEnumRanges(message = "性别必须在 BOY/GIRL 范围内", value = SexEnum.class)
private String sex;

这样校验方法可以简化如下:

private void paramCheck3(UserRegister userRegister) {
    //1. 名称
    ValidateUtil.validate(userRegister);
    //2.2 确认密码
    String password2 = userRegister.getPassword2();
    if(!userRegister.getPassword().equals(password2)) {
        throw new IllegalArgumentException("确认密码必须和密码保持一致");
    }
}

小明满意的笑了笑。

但是他的笑容只是持续了一会儿,因为他发现了一个不令人满意的地方。

确认密码这一段代码可以去掉吗?

好像直接使用 hibernate-validator 框架是做不到的。

框架不足之处

这一切令小明很痛苦,他发现框架本身确实有很多不足之处。

hibernate-validator 无法满足的场景

如今 java 最流行的 hibernate-validator 框架,但是有些场景是无法满足的。

比如:

  1. 验证新密码和确认密码是否相同。(同一对象下的不同属性之间关系)

  2. 当一个属性值满足某个条件时,才进行其他值的参数校验。

  3. 多个属性值,至少有一个不能为 null

其实,在对于多个字段的关联关系处理时,hibernate-validator 就会比较弱。

本项目结合原有的优点,进行这一点的功能强化。

validation-api 过于复杂

validation-api 提供了丰富的特性定义,也同时带来了一个问题。

实现起来,特别复杂。

然而我们实际使用中,常常不需要这么复杂的实现。

valid-api 提供了一套简化很多的 api,便于用户自行实现。

自定义缺乏灵活性

hibernate-validator 在使用中,自定义约束实现是基于注解的,针对单个属性校验不够灵活。

本项目中,将属性校验约束和注解约束区分开,便于复用和拓展。

过程式编程 vs 注解式编程

hibernate-validator 核心支持的是注解式编程,基于 bean 的校验。

一个问题是针对属性校验不灵活,有时候针对 bean 的校验,还是要自己写判断。

本项目支持 fluent-api 进行过程式编程,同时支持注解式编程。

尽可能兼顾灵活性与便利性。

valid 工具的诞生

于是小明花了很长时间,写了一个校验工具,希望可以弥补上述工具的不足。

开源地址:https://github.com/houbb/valid

特性

  • 支持 fluent-validation

  • 支持 jsr-303 注解,支持所有 hibenrate-validator 常用注解

  • 支持 i18n

  • 支持用户自定义策略

  • 支持用户自定义注解

  • 支持针对属性的校验

  • 支持过程式编程与注解式编程

  • 支持指定校验生效的条件

快速开始

maven 引入

<dependency>
    <groupId>com.github.houbb</groupId>
    <artifactId>valid-jsr</artifactId>
    <version>0.2.2</version>
</dependency>

编码

工具类使用:

User user = new User();
user.sex("what").password("old").password2("new");

ValidHelper.failOverThrow(user);

报错如下:

会抛出 ValidRuntimeException 异常,异常的信息如下:

name: 值 <null> 不是预期值,password: 值 <old> 不是预期值,sex: 值 <what> 不是预期值

其中 User 的定义如下:

public class User {

    /**
     * 名称
     */
    @HasNotNull({"nickName"})
    private String name;

    /**
     * 昵称
     */
    private String nickName;

    /**
     * 原始密码
     */
    @AllEquals("password2")
    private String password;

    /**
     * 新密码
     */
    private String password2;

    /**
     * 性别
     */
    @Ranges({"boy", "girl"})
    private String sex;

    /**
     * 失败类型枚举
     */
    @EnumRanges(FailTypeEnum.class)
    private String failType;

    //Getter and Setter
}

内置注解简介如下:

注解 说明
@AllEquals 当前字段及指定字段值必须全部相等
@HasNotNull 当前字段及指定字段值至少有一个不为 null
@EnumRanges 当前字段值必须在枚举属性范围内
@Ranges 当前字段值必须在指定属性范围内

小明在设计验证工具的时候,针对 hibernater 的不足都做了一点小小的改进。

可以让字段之间产生联系,以提供更加强大的功能。

每一个注解都有对应的过程式方法,让你可以在注解式和过程式中切换自如。

内置了 @Condition 的注解生效条件,让注解生效更加灵活。

小明抬头看了看墙上的钟,夜已经太深了,百闻不如一见,感兴趣的小伙伴可以自己去感受一下:

开源地址:https://github.com/houbb/valid

小结

这个开源工具是日常工作中不想写太多校验方法的产物,还处于初期阶段,还有很多需要改进的地方。

不过,希望你能喜欢。

我是老马,期待与你的下次重逢。

在这里插入图片描述

posted on 2021-08-10 20:07  老马啸西风  阅读(662)  评论(2编辑  收藏  举报