验证、数据绑定、类型转换 - Java Bean 验证 - 《文档月度笔记》

Bean Validation 概述
配置 Bean Validation Provider
- 注入 Validator
- 配置自定义约束
Spring 驱动的方法验证
配置 DataBinder
Spring MVC 3 Validation

Spring 框架提供了对 Java Bean Validation API 的支持。

Bean Validation 概述

Bean Validation 为 Java 应用程序提供了一种通过约束声明和元数据进行验证的通用方法。为了使用它，你用声明性的验证约束来注解领域模型属性，然后由运行时强制执行。有一些内置的约束，你也可以定义你自己的自定义约束。

考虑下面的例子，它显示了一个有两个属性的简单 PersonForm 模型：

public class PersonForm {
    private String name;
    private int age;
}

Bean Validation 可以让你声明约束条件，如下例所示：

public class PersonForm {
    @NotNull
    @Size(max=64)
    private String name;
    @Min(0)
    private int age;
}

然后，Bean Validation 验证器根据声明的约束条件来验证该类的实例。关于 API 的一般信息，请参见 Bean Validation 。关于具体的约束条件，见 Hibernate Validator 文档。要了解如何将 Bean 验证提供者设置为 Spring Bean，请继续阅读。

配置 Bean Validation Provider

Spring 提供了对 Bean Validation API 的全面支持，包括将 Bean Validation 提供者作为 Spring Bean 的引导。这让你可以在应用中需要验证的地方注入一个 javax.validation.ValidatorFactory或javax.validator 。

你可以使用 LocalValidatorFactoryBean 来配置一个默认的 Validator 作为 Spring Bean，如下例所示：

import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
@Configuration
public class AppConfig {
    @Bean
    public LocalValidatorFactoryBean validator() {
        return new LocalValidatorFactoryBean();
    }
}

前面例子中的基本配置通过使用其默认的引导机制来触发 Bean Validation 的初始化。一个 Bean Validation 提供者，例如 Hibernate Validator，应该存在于 classpath 中并被自动检测（意思就是说要添加 Hibernate Validator 的依赖）。

比如：添加 Hibernate Validator 的依赖，上面的 @Size 注解才可以使用

    // LocalValidatorFactoryBean 中有说明，支持 hibernate-validator 5.2 和 6.0 版本
    implementation 'org.hibernate.validator:hibernate-validator:6.0.0.Final'
    // 该依赖在 org.hibernate.validator.messageinterpolation.ResourceBundleMessageInterpolator 中有用到，所以需要添加
    // 可以在
    implementation group: 'org.glassfish', name: 'javax.el', version: '3.0.0'

再注入使用

可以看到上图有一个 defaultMessage 的错误信息，这个就是在国际化里面的消息文件中来的

这个在内容应该是在将 errorCode 转换为错误消息的问题章节里面提到过的，但是这一章内容不怎么详细，如果要深入了解可能还是需要再去展开研究研究

注入 Validator

LocalValidatorFactoryBean 同时实现了 javax.validatorFactory和 javax.validator，以及Spring 的 org.springframework.validation.Validator。你可以将这些接口的引用注入到需要调用验证逻辑的 Bean 中。

如果你喜欢直接使用 Bean Validation API，你可以注入对 javax.validation.Validator的引用，如下例所示：

import javax.validation.Validator;
@Service
public class MyService {
    @Autowired
    private Validator validator;
}

如果你的 Bean 需要 Spring Validation API，你可以注入对 org.springframework.validation.Validator的引用，如下例所示：

import org.springframework.validation.Validator;
@Service
public class MyService {
    @Autowired
    private Validator validator;
}

配置自定义约束

每个 bean 验证约束由两部分组成：

一个 @Constraint注解，声明了约束及其可配置的属性。（比如前面用到的 @Size 注解上就有这个元注解）
javax.validation.ConstraintValidator接口的一个实现，实现约束的行为。

为了将声明与实现联系起来，每个 @Constraint 注解都引用了一个相应的 ConstraintValidator 实现类。在运行时，当你的领域模型中遇到约束注解时，ConstraintValidatorFactory 会实例化所引用的实现。

默认情况下，LocalValidatorFactoryBean 配置了一个 SpringConstraintValidatorFactory，使用 Spring 来创建 ConstraintValidator 实例。这让你的自定义约束验证器像其他 Spring Bean 一样受益于依赖性注入。

下面的例子显示了一个自定义的 @Constraint声明和一个相关的 ConstraintValidator 实现，它使用 Spring 进行依赖注入。

package cn.mrcode.study.springdocsread.data;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
/**
 * @author mrcode
 */
@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = MyConstraintValidator.class)
public @interface MyConstraint {
    String message() default "{cn.mrcode.constraints.MyConstraint.message}";
    Class<?>[] groups() default { };
    Class<? extends Payload>[] payload() default { };
}

这个注解如果要用在 Hibernate Validator 里面的话，就需要写上面的 message、groups、payload 属性

package cn.mrcode.study.springdocsread.data;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
/**
 * @author mrcode
 */
// 这里要写泛型：这个验证器绑定的注解类，要验证的对象类型
public class MyConstraintValidator implements ConstraintValidator<MyConstraint, Object> {
    /**
     * 实现验证逻辑；
     *
     * @param value
     * @param context
     * @return
     */
    @Override
    public boolean isValid(Object value, ConstraintValidatorContext context) {
        // 这里写你的验证逻辑，这里假设就判断下是否为空
        if (value == null) {
            return false;
        }
        return true;
    }
}

由于注解绑定了具体的验证器处理程序，所以这里不用注册之类的，就可以将 MyConstraint 注解使用了。

另外，验证器里面也可以注入其他 bean，如下所示

import javax.validation.ConstraintValidator;
public class MyConstraintValidator implements ConstraintValidator {
    @Autowired;
    private Foo aDependency;
    // ...
}

Spring 驱动的方法验证

你可以通过 MethodValidationPostProcessor Bean 定义将 Bean Validation 1.1 支持的方法验证功能（作为自定义扩展，Hibernate Validator 4.3 也支持）集成到 Spring 上下文中。

import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;
@Configuration
public class AppConfig {
    @Bean
    public MethodValidationPostProcessor validationPostProcessor() {
        return new MethodValidationPostProcessor();
    }
}

为了符合 Spring 驱动的方法验证的条件，所有目标类都需要用 Spring 的 @Validated 注解来注解，也可以选择声明使用的验证组。参见 MethodValidationPostProcessor，了解与 Hibernate Validator 和 Bean Validation 1.1 提供者的设置细节。

下面是一个例子：

package cn.mrcode.study.springdocsread.web;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import javax.validation.constraints.NotNull;
/**
 * @author mrcode
 */
@Component
@Validated
public class DemoService {
    public void insert(@NotNull Integer id) {
        System.out.println(id);
    }
}

你引用 DemoService 然后调用 insert 方法的时候，如果传递 null 进来，这个验证器就会工作了，报错信息如下

Exception in thread "main" javax.validation.ConstraintViolationException: insert.id: 不能为null
    at org.springframework.validation.beanvalidation.MethodValidationInterceptor.invoke(MethodValidationInterceptor.java:120)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
    at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:753)
    at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:698)
    at cn.mrcode.study.springdocsread.web.DemoService$$EnhancerBySpringCGLIB$$232cf10c.insert(<generated>)
    at cn.mrcode.study.springdocsread.TestDemo.main(TestDemo.java:17)

:::tips 方法验证依赖于目标类周围的 AOP 代理，无论是 JDK 动态代理还是 CGLIB 代理的接口上的方法。使用代理有一些限制，其中一些在《理解 AOP 代理》中有所描述。此外，请记住一定要在代理的类上使用方法和访问器；直接的字段访问是不行的（也就是说，自己在类中的方法里面使用 this 调用方法是不会触发 AOP 的）。 :::

配置 DataBinder

从 Spring 3 开始，你可以给 DataBinder 实例配置一个验证器。一旦配置好，你可以通过调用 binder.validate() 来调用验证器。任何验证错误都会自动添加到绑定器的 BindingResult 中。

下面的例子显示了如何以编程方式使用 DataBinder，在绑定到目标对象后调用验证逻辑：

这个是实体类

package cn.mrcode.study.springdocsread.data;
/**
 * @author mrcode
 */
public class PersonForm {
    private String name;
    private int age;
    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;
    }
}

这是一个验证器

package cn.mrcode.study.springdocsread.data;
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;
/**
 * @author mrcode
 */
public class PersonFormValidator implements Validator {
    @Override
    public boolean supports(Class<?> clazz) {
        return PersonForm.class.equals(clazz);
    }
    @Override
    public void validate(Object target, Errors errors) {
        ValidationUtils.rejectIfEmpty(errors, "name", "name.empty");
    }
}

这是 DataBinder 的使用方式

package cn.mrcode.study.springdocsread.data;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.validation.BindingResult;
import org.springframework.validation.DataBinder;
/**
 * @author mrcode
 */
public class DemoTest {
    public static void main(String[] args) {
        // 你想要的实例对象
        final PersonForm target = new PersonForm();
        DataBinder binder = new DataBinder(target);
        binder.setValidator(new PersonFormValidator());
        // 这个是从其他地方获取到的数据，比如前端提交的数据，现在要把这些属性设置到你的 target 对上上去
        // PropertyValues 接口的默认实现。允许对属性进行简单操作，并提供构造函数以支持从 Map 进行深度复制和构造。
        MutablePropertyValues propertyValues = new MutablePropertyValues();
        propertyValues.add("age", "15");
        // 绑定到目标对象
        binder.bind(propertyValues);
        // 验证目标对象
        binder.validate();
        // 获得包括任何验证错误的 BindingResult
        final BindingResult bindingResult = binder.getBindingResult();
        System.out.println(bindingResult);
    }
}

执行后输出的信息如下： name 字段为空错误

org.springframework.validation.BeanPropertyBindingResult: 1 errors
Field error in object 'target' on field 'name': rejected value [null]; codes [name.empty.target.name,name.empty.name,name.empty.java.lang.String,name.empty]; arguments []; default message [null]

你也可以通过 dataBinder.addValidators 和 dataBinder.replaceValidators将一个 DataBinder 配置成多个验证器实例。当把全局配置的 bean 验证与 DataBinder 实例上本地配置的 Spring 验证器结合起来时，这很有用。参见 Spring MVC 验证配置。

Spring MVC 3 Validation

请参阅 Spring MVC 章节中的验证。