Java Bean Validation

╰半橙微兮° 2023-01-08 02:30 120阅读 0赞

> **关键词：**JSR 303    hibernate validator

--------------------

在开发过程中，我们经常要对方法参数进行数据的有效性校验，比如新增一个用户信息时，用户的姓名不能为空且长度要有限制。数据校验涉及的范围有，首先前端用户提交的表单到Controller层，要在Controller层做数据校验。其次，Controller层调用Service层方法，Service层也要做数据校验，等等场景还有很多。数据校验我们可以通过if...else逻辑判断来校验，比如：

if (user.getName()==null) {
       return "用户姓名不能为空";
    }
    if (user.getName().length()>10) {
       return "姓名长度不能超过10";
    }

if...else校验方式存在一定的问题，当需要对参数校验的方法很多时，通过if...else方式来进行数据校验，会产生很多的重复冗余代码。可喜的是，Java为我们提供了一种便捷的数据校验方式，当方法的参数是Java Bean时，仅仅只需要添加几个注解就可以完成数据校验了（具体的使用过程将在下文说明）。但是此种通过注解的方式也是有限制的，即只能对Java Bean进行数据校验，当方法参数是String、Integer等等类型的时候，此种方式便无法达到效果了。

--------------------

# **█ **JSR 303: Bean Validation #

JSR 303定义了用于JavaBean验证的元数据模型和API，默认的元数据源是注释。此协议和JDBC协议一样，只提供了接口规范，并不提供具体的实现。在JDK中并没有提供此协议的相关接口，需要引入相关jar包：

<dependency>
        <groupId>javax.validation</groupId>
        <artifactId>validation-api</artifactId>
        <version>2.0.1.Final</version>
    </dependency>

**@Constraint：**

约束注解，作用于注解上。具体的约束校验注解要标记上此注解。可以将类比成是一个标记接口，具体的子类都实现必须要实现此特定的接口。

package javax.validation;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Documented
    // 作用与注解上
    @Target({ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Constraint {
        Class<? extends ConstraintValidator<?, ?>>[] validatedBy();
    }

**约束注解：**

@Constraint标记的约束校验注解，必须满足以下几个条件：

①要使用@Constraint标记

②要具有一个String类型的message属性，默认值是类的全限定名.message。

此属性用于指定当数据校验没有通过时的错误信息。

String message() default "{com.acme.constraint.MyConstraint.message}";

③必须要有一个groups属性，默认值是空数组。

Class[] groups() default {};

④必须要有一个payload属性，默认值是空数组。

Class[] payload() default {};

比如：@NotBlank

package javax.validation.constraints;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Repeatable;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    import javax.validation.Constraint;
    import javax.validation.Payload;
    
    @Documented
    @Constraint(validatedBy = {})
    @Target({ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.TYPE_USE})
    @Retention(RetentionPolicy.RUNTIME)
    @Repeatable(NotBlank.List.class)
    public @interface NotBlank {
        String message() default "{javax.validation.constraints.NotBlank.message}";
    
        Class<?>[] groups() default {};
    
        Class<? extends Payload>[] payload() default {};
    
        @Target({ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.TYPE_USE})
        @Retention(RetentionPolicy.RUNTIME)
        @Documented
        public @interface List {
            NotBlank[] value();
        }
    }

协议提供的约束注解：

![20210118192003502.png][]

--------------------

# █ hibernate validator #

hibernate validator提供了JSR 303: Bean Validation协议的一种实现。hibernate validator并没有直接使用javax.validation下提供的相关注解，而是使用的jakarta.validation下提供的注解。jakarta.validation和javax.validation提供的类几乎一样，可以说两种就是包名不一样罢了。

package javax.validation;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Documented
    @Target({ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Constraint {
        Class<? extends ConstraintValidator<?, ?>>[] validatedBy();
    }

package jakarta.validation;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Documented
    @Target({ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Constraint {
        Class<? extends ConstraintValidator<?, ?>>[] validatedBy();
    }

### 简单使用： ###

①引入相关Maven依赖：

<dependency>
        <groupId>org.hibernate.validator</groupId>
        <artifactId>hibernate-validator</artifactId>
        <version>7.0.0.Final</version>
    </dependency>
    
    <dependency>
        <groupId>org.glassfish</groupId>
        <artifactId>jakarta.el</artifactId>
        <version>4.0.0</version>
    </dependency>

②创建一个Java Bean，并使用注解标记校验规则。

@NotBlank表示属性name不能为null或空字符串，当name不满足条件时，则会返回message中的信息。注意，@NotBlank是jakarta.validation.constraints.NotBlank。

public class User {
    
        @NotBlank(message = "name不能为空")
        private String name;
    
        public String getName() {
            return name;
        }
        
        public void setName(String name) {
            this.name = name;
        }
        
    }

③使用hibernate validator提供的api实现校验：

// 创建User对象，此时name为null
    User user = new User();
    // 获取校验器Validator
    Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
    // 对User对象进行属性校验
    Set<ConstraintViolation<User>> violationResults = validator.validate(user);
    if (violationResults!=null && violationResults.size()>0) {
        violationResults.forEach(userConstraintViolation -> {
            // 获取message值
            System.out.println(userConstraintViolation.getMessage());
        });
    }

④执行上述代码，运行结果：

![20210118192230543.png][]

**改造：实现在方法调用时，对方法参数进行校验：**

①编写类，在类中提供一个参数类型为User类型的方法。

参数User需要使用@Valid开启数据校验功能。不标记@Valid则不会对该参数进行校验。注意，@Valid是jakarta.validation.Valid。

public class UserService {
    
        public void insertUser(@Valid User user) {
            System.out.println(user.getName());
        }
    
    }

②编写通用的方法参数校验功能类：

public class MethodInvoker {
        
        public static Object invoke(Method method, Object object, Object[] params) throws Exception{
    
            // 参数注解二维数组，第一维数组是参数数组（一个方法可以有多个参数），第二维数组，是响应参数对应的注解数组（一个参数可以有多个注解）
            Annotation[][] parameterAnnotations = method.getParameterAnnotations();
            // 变量i记录第几个参数
            int i = 0;
            for (Annotation[] annotationArray : parameterAnnotations) {
                for (Annotation annotation : annotationArray) {
                    if (annotation.annotationType() == Valid.class) {
                        Object param = params[i];
                        List<String> validate = validate(param);
                        if (validate.size()>0) {
                            throw new IllegalArgumentException(validate.toString());
                        }
                    }
                }
                i++;
            }
            // 反射调用方法
            return method.invoke(object, params);
        }
    
        public static List<String> validate(Object param) {
            List<String> result = new LinkedList<>();
            Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
            Set<ConstraintViolation<Object>> validateResults = validator.validate(param);
            if (validateResults!=null) {
                validateResults.forEach(objectConstraintViolation -> {
                    result.add(objectConstraintViolation.getMessage());
                });
            }
            return result;
        }
    
    }

③方法调用：

UserService userService = new UserService();
    Method method = userService.getClass().getMethod("insertUser", User.class);
    MethodInvoker.invoke(method, userService, new Object[]{new User()});

通过上面使用反射和代理方式，可以类比一下Spring Validation的实现方式。

### 更多介绍： ###

①使用在字段上：

public class User {
    
        @NotBlank(message = "name不能为空")
        private String name;
        
    }

②作用在方法上，根据方法返回值判断：

public class User {
        
        private String name;
    
        @NotBlank(message = "name不能为空")
        public String getName() {
            return name;
        }
    
    }

会根据方法getName的返回值来判断是否满足NotBlank条件。如果返回值不满足条件，就返回message内容。如果将方法的返回值永远返回固定的有内容的字符串，校验会永远通过，比如：

@NotBlank(message = "name不能为空")
    public String getName() {
        return "notBlank";
    }

③约束继承：

父类中标记了约束注解，则约束注解会被子类继承。如下SonUser继承User，当参数类型是SonUser类型，校验功能同样可用。

public class User {
    
        @NotBlank(message = "name不能为空")
        private String name;
    
        public String getName() {
            return name;
        }
    
    }

public class SonUser extends User{
        
    }

④对象类型的属性：

当一个对象A中有个属性是对象类型B时，在校验A的时候，也可以对B的属性进行校验。

如下，User中持有Car类型的字段，在字段上加上@Valid注解即可。前提是car不能为空，当car为空时，不会校验Car中的driver字段。

public class User {
    
        @Valid
        private Car car;
    
        public void setCar(Car car) {
            this.car = car;
        }
    
    }

public class Car {
    
        @NotBlank(message = "司机名称不能为空")
        private String driver;
    
    }

⑤对方法参数进行校验：

使用**ExecutableValidator** 对方法参数标注约束注解，实现对参数进行校验，此处不是使用@Valid注解，而是直接使用@Constraint相关注解。

public class User {
        
        private Car car;
        
        public void setCar(@NotNull(message = "参数car不能为空") Car car) {
            this.car = car;
        }
    
    }

User user = new User();
    ExecutableValidator executableValidator = Validation.buildDefaultValidatorFactory().getValidator().forExecutables();
    Set<ConstraintViolation<User>> constraintViolations = executableValidator.validateParameters(user, user.getClass().getMethod("setCar", Car.class), new Object[]{null});
    constraintViolations.forEach(userConstraintViolation -> {
        System.out.println(userConstraintViolation.getMessage());
    });

[20210118192003502.png]: /images/20221119/49ddacb2d39545fa8e1304e49f71c2b3.png
[20210118192230543.png]: /images/20221119/a3b7fd7fe521436a8fc18b1a54ce8b15.png