java后端参数校验--Hibernate validator

一、前言

        在后端开发过程中，对参数的校验成为开发环境不可缺少的一个环节。一般情况下，我们会再前端和后端都对数据进行双重校验，以保证数据的准确性。如果参数较少，且规格简单的情况下，我们是可以还用简单的if判断即可满足条件。
        比如参数不能为null，email必须符合email的格式，如果手动进行if判断或者写正则表达式判断开发效率太慢，在时间、成本、质量的博弈中必然会落后。所以把校验层抽象出来是必然的。
        这种通用参数校验方式采用的是JSR303规范，Hibernate validator是JSR303规范的一种很好的实现。

二、具体实现

1、引入依赖

<dependency>  
    <groupId>javax.validation</groupId>  
    <artifactId>validation-api</artifactId>  
    <version>1.1.0.Final</version>  
</dependency>  
<dependency>  
    <groupId>org.hibernate</groupId>  
    <artifactId>hibernate-validator</artifactId>  
    <version>5.2.4.Final</version>  
</dependency>  
<dependency>  
    <groupId>javax.el</groupId>  
    <artifactId>javax.el-api</artifactId>  
    <version>2.2.4</version>  
</dependency>  

2、创建ValidateResult类，用于存储校验结果

public class ValidateResult {  
    private boolean result = false; //校验结果  

    private String[] errMsg; //错误信息  

    public ValidateResult(boolean result, String[] errMsg) {  
        this.result = result;  
        this.errMsg = errMsg;  
    }  


    public boolean isSuccess() {  
        return result;  
    }  

    public String[] getErrMsg() {  
        return errMsg;  
    }  


    /** 
     * @see java.lang.Object#toString() 
     */  
    @Override  
    public String toString() {  
        return "ValidateResult [result=" + result +  
                ", errMsg=" + Arrays.toString(errMsg) + "]";  
    }  
} 

3、创建ValidateUtil类，用于进行参数校验

import javax.validation.ConstraintViolation;  
import javax.validation.Validation;  
import javax.validation.Validator;  
import javax.validation.ValidatorFactory;  
import java.util.Set;  

/** 
 * 参数校验类（JSR 303） 
 */  
public class ValidatorUtil {  
    private static Validator validator;  
    static {  
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();  
        validator = factory.getValidator();  
    }  

    public static <T> ValidateResult validator(T object) {  
        if (null == object) {  
            return new ValidateResult(false,  
                    new String[]{"The object to be validated must not be null."});  
        }  

        Set<ConstraintViolation<T>> violations = validator.validate(object);  
        int errSize = violations.size();  

        String[] errMsg = new String[errSize];  
        boolean result = true;  
        if (errSize > 0) {  
            int i = 0;  
            for (ConstraintViolation<T> violation : violations) {  
                errMsg[i] = violation.getMessage();  
                i++;  
            }  
            result = false;  
        }  

        return new ValidateResult(result, errMsg);  
    }  
} 

注意：validator对象是线程安全的，可以进行复用

4、针对特殊的校验方式，进行自定义注解实现（一般情况下适用规范提供的注解即可）

注解类如下：

import javax.validation.Constraint;  
import javax.validation.Payload;  
import java.lang.annotation.*;  

@Documented  
@Target({  
        ElementType.FIELD,  
        ElementType.METHOD,  
        ElementType.ANNOTATION_TYPE,  
        ElementType.CONSTRUCTOR,  
        ElementType.PARAMETER})  
@Retention(RetentionPolicy.RUNTIME)  
@Constraint(validatedBy = {InValidator.class})  
public @interface In {  
    String message() default "值不在给定范围内";  

    String[] values() default {};  

    Class<?>[] groups() default {};  

    Class<? extends Payload>[] payload() default {};  
} 

注解解析类如下：

import javax.validation.ConstraintValidator;  
import javax.validation.ConstraintValidatorContext;  

public class InValidator implements ConstraintValidator<In, String> {  
    private String[] checkedValues;  
    @Override  
    public void initialize(In constraintAnnotation) {  
        checkedValues = constraintAnnotation.values();  
    }  

    @Override  
    public boolean isValid(String value, ConstraintValidatorContext context) {  
        if(value == null || value.length() == 0) {  
            return false;  
        }  
        for(String checkedValue : checkedValues) {  
            if(value.equals(checkedValue)) {  
                return true;  
            }  
        }  
        return false;  
    }  
}

5、实体对象类使用注解校验

import com.demo.lizhy.model.validator.In;  

import javax.validation.constraints.Digits;  
import javax.validation.constraints.Max;  
import javax.validation.constraints.Min;  
import javax.validation.constraints.NotNull;  

public class ValidateModel {  
    @NotNull(message="userName不能为空")  
    private String userName;  
    @Min(value=18, message = "age必须大于等于18")  
    @Max(value=50, message = "age必须小于等于50")  
    private int age;  
    @NotNull(message="address不能为空")  
    private String address;  
    @In(values = {"Male","Female"}, message = "sex值不合法")  

    private String sex;  

    public String getSex() {  
        return sex;  
    }  

    public void setSex(String sex) {  
        this.sex = sex;  
    }  

    public String getUserName() {  
        return userName;  
    }  

    public void setUserName(String userName) {  
        this.userName = userName;  
    }  

    public int getAge() {  
        return age;  
    }  

    public void setAge(int age) {  
        this.age = age;  
    }  

    public String getAddress() {  
        return address;  
    }  

    public void setAddress(String address) {  
        this.address = address;  
    }  
}  

6、使用工具类进行参数校验

ValidateModel model = new ValidateModel();  
model.setUserName(null);  
model.setAddress(null);  
model.setAge(10);  
model.setSex("");  

ValidateResult result = ValidatorUtil.validator(model);  
System.out.println(result); 

输出结果如下：

ValidateResult [result=false, errMsg=[age必须大于等于18, userName不能为空, address不能为空, sex值不合法]]  

        以上说明只是针对普通属性进行校验，如果对象中存在对象属性，则扔需要通过自定义校验规则方式进行校验。针对不同的对象，使用同一个自定义规则进行校验，原理就是针对该对象再次调用ValidatorUtil.validate()方法，并将校验结果放回即可。(其实通过@Valid注解也可以实现。只需要在需要校验的对象属性上添加这个注解，就会自动对该对象属性里的各个子属性进行校验)

通用对象校验注解类：

import javax.validation.Constraint;  
import javax.validation.Payload;  
import java.lang.annotation.*;  

/** 
 * 对象校验 
 */  
@Documented  
@Target({  
        ElementType.FIELD,  
        ElementType.METHOD,  
        ElementType.ANNOTATION_TYPE,  
        ElementType.CONSTRUCTOR,  
        ElementType.PARAMETER})  
@Retention(RetentionPolicy.RUNTIME)  
@Constraint(validatedBy = {ObjectCheckValidator.class})  
public @interface ObjectCheck {  
    String message() default "值不合法";  
    String propertyName() default "";//用于标识校验的属性名称  

    Class<?>[] groups() default {};  

    Class<? extends Payload>[] payload() default {};  
}  

通用对象校验规则：

import com.alibaba.fastjson.JSON;  

import javax.validation.ConstraintValidator;  
import javax.validation.ConstraintValidatorContext;  

/** 
 * 通用对象校验规则类 
 */  
public class ObjectCheckValidator implements ConstraintValidator<ObjectCheck, Object> {  
    private String propertyName = "";  
    @Override  
    public void initialize(ObjectCheck constraintAnnotation) {  
        propertyName = constraintAnnotation.propertyName();  
    }  

    @Override  
    public boolean isValid(Object value, ConstraintValidatorContext context) {  
        if(value == null) {  
            //通过以下两句话修改默认message的值  
            context.disableDefaultConstraintViolation();  
            context.buildConstraintViolationWithTemplate(propertyName+"不能为空").addConstraintViolation();  
            return false;  
        }  
        ValidateResult result = ValidatorUtil.validator(value);  
        if(result != null && result.isSuccess()) {  
            return true;  
        }  
        context.disableDefaultConstraintViolation();  
        context.buildConstraintViolationWithTemplate(propertyName+"校验出错:"+JSON.toJSONString(result.getErrMsg())).addConstraintViolation();  
        return false;  
    }  
}  

使用示例：

@ObjectCheck(propertyName = "userModel")  
private UserModel userModel;  

返回结果：

ValidateResult [result=false, errMsg=[<strong>userModel校验出错:["userName不能为空"]</strong>, address不能为空, sex值不合法]]