java后端参数校验--Hibernate validator

￡神魔★判官ぃ 2022-05-23 06:08 436阅读 0赞

### 一、前言 ###

在后端开发过程中，对参数的校验成为开发环境不可缺少的一个环节。一般情况下，我们会再前端和后端都对数据进行双重校验，以保证数据的准确性。如果参数较少，且规格简单的情况下，我们是可以还用简单的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值不合法]]