数据校验框架现状
在我们的方法入口后面，难免会有如下样子的代码：
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
Hiberante Validator, 小巧，规范，易扩展，易整合。
但是本文不是说它。。。
对于Web应用，可能更多的我们还是使用Spring MVC的校验，叫做：spring mvc validator
一百度一大堆，可以跟页面的error标签很好的结合做页面输入的校验。
但是本文也不是说它。。。
本文主要是说，来写一个适合自己的校验框架
数据框架设计目的
- 要简单
只是作为一个小的工具包，代码最多几K，无依赖也是必须的吧 - 要优雅
if.else的调用方式太难看了。看看如下的这种怎么样：
new Validator().notNull(name, "姓名").notNull(mail, "邮箱");- 1
- 要易用
注解是易用的一个好办法，就像JSR303那样 - 要可扩展
要方便客户端程序方便的创建自定义校验器
总体设计
首先得起个名字吧，叫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());
}
}
}输出的结果：
姓名不能为空- 1
扩展注解校验器
基于这个框架，还是可以比较方便的进行扩展的。
要写一个新的注解，新的解析器，然后注册一下新的解析器就能给新的字段进行校验了。如下：
新的注解：
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DateFormat {
public String fieldName();
public String format();
}- 1
- 2
- 3
- 4
- 5
- 6
新的解析器
/**
* 日期格式注解解析器
*
* @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()));
}
}- 1
- 2
- 3
- 4
- 5
总结
到此，这个简单的校验框架就完成了。
主要的技术上使用了注解，
然后通过反射再利用注解解析器来进行解析进行校验
校验器每个方法返回this，可以使用更优雅的代码来完成校验
并且还可以比较方便的扩展。
完整的代码，可以从这里获取