@Valid的作用（级联校验）以及常用约束注解的解释说明
Posted 大忽悠爱忽悠
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了@Valid的作用（级联校验）以及常用约束注解的解释说明相关的知识，希望对你有一定的参考价值。
@Valid的作用（级联校验）以及常用约束注解的解释说明
分组校验
@Getter
@Setter
@ToString
public class Person
@NotNull(message = "名字不能为空", groups = Simple.class)
public String name;
/**
* 内置的分组：default
*/
@Max(value = 10, groups = Simple.class)
@Positive(groups = Default.class)
public Integer age;
@NotNull(groups = Complex.class)
@NotEmpty(groups = Complex.class)
private List<@Email String> emails;
@Future(groups = Complex.class)
private Date start;
// 定义两个组 Simple组和Complex组
public interface Simple
public interface Complex
public class ValidationTest
@Test
public void testValidation()
Person person = new Person();
//person.setName("fsx");
person.setAge(18);
// email校验：虽然是List都可以校验哦
person.setEmails(Arrays.asList("fsx@gmail.com", "baidu@baidu.com", "aaa.com"));
//person.setStart(new Date()); //start 需要是一个将来的时间: Sun Jul 21 10:45:03 CST 2019
//person.setStart(new Date(System.currentTimeMillis() + 10000)); //校验通过
HibernateValidatorConfiguration configure = Validation.byProvider(HibernateValidator.class).configure();
ValidatorFactory validatorFactory = configure.failFast(false).buildValidatorFactory();
// 根据validatorFactory拿到一个Validator
Validator validator = validatorFactory.getValidator();
// 分组校验（可以区分对待Default组、Simple组、Complex组）
Set<ConstraintViolation<Person>> result = validator.validate(person, Person.Simple.class);
//Set<ConstraintViolation<Person>> result = validator.validate(person, Person.Complex.class);
// 对结果进行遍历输出
result.stream().map(v -> v.getPropertyPath() + " " + v.getMessage() + ": " + v.getInvalidValue())
.forEach(System.out::println);
运行打印：
age 最大不能超过10: 18
name message -> 名字不能为null -> 名字不能为null: null
可以直观的看到效果，此处的校验只执行Person.Simple.class这个Group组上的约束~
分组约束在Spring MVC中的使用场景还是相对比较多的，但是需要注意的是：javax.validation.Valid没有提供指定分组的，但是org.springframework.validation.annotation.Validated扩展提供了直接在注解层面指定分组的能力
@Valid注解
我们知道JSR提供了一个@Valid注解供以使用，在本文之前，绝大多数小伙伴都是在Controller中并且结合@RequestBody一起来使用它，但在本文之后，你定会对它有个全新的认识.
该注解用于验证级联的属性、方法参数或方法返回类型。
当验证属性、方法参数或方法返回类型时，将验证对象及其属性上定义的约束，另外：此行为是递归应用的。
为了理解@Valid，那就得知道处理它的时机：
MetaDataProvider
元数据提供者：约束相关元数据（如约束、默认组序列等）的Provider。它的作用和特点如下：
- 基于不同的元数据：如xml、注解。（还有个编程映射） 这三种类型。对应的枚举类为：
public enum ConfigurationSource
ANNOTATION( 0 ),
XML( 1 ),
API( 2 ); //programmatic API
- MetaDataProvider只返回直接为一个类配置的元数据
- 它不处理从超类、接口合并的元数据（简单的说你@Valid放在接口处是无效的）
public interface MetaDataProvider
// 将 注解处理选项 归还给此Provider配置。 它的唯一实现类为：AnnotationProcessingOptionsImpl
// 它可以配置比如：areMemberConstraintsIgnoredFor areReturnValueConstraintsIgnoredFor
// 也就说可以配置：让免于被校验~~~~~~(开绿灯用的)
AnnotationProcessingOptions getAnnotationProcessingOptions();
// 返回作用在此Bean上面的`BeanConfiguration` 若没有就返回null了
// BeanConfiguration持有ConfigurationSource的引用~
<T> BeanConfiguration<? super T> getBeanConfiguration(Class<T> beanClass);
// 表示源于一个ConfigurationSource的一个Java类型的完整约束相关配置。 包含字段、方法、类级别上的元数据
// 当然还包含有默认组序列上的元数据（使用较少）
public class BeanConfiguration<T>
// 三种来源的枚举
private final ConfigurationSource source;
private final Class<T> beanClass;
// ConstrainedElement表示待校验的元素，可以知道它会如下四个子类：
// ConstrainedField/ConstrainedType/ConstrainedParameter/ConstrainedExecutable
// 注意：ConstrainedExecutable持有的是java.lang.reflect.Executable对象
//它的两个子类是java.lang.reflect.Method和Constructor
private final Set<ConstrainedElement> constrainedElements;
private final List<Class<?>> defaultGroupSequence;
private final DefaultGroupSequenceProvider<? super T> defaultGroupSequenceProvider;
... // 它自己并不处理什么逻辑，参数都是通过构造器传进来的
它的继承树：
三个实现类对应着上面所述的三种元数据类型。本文很显然只需要关注和注解相关的：AnnotationMetaDataProvider
AnnotationMetaDataProvider
这个元数据均来自于注解的标注，然后它是Hibernate Validation的默认configuration source。它这里会处理标注有@Valid的元素~
public class AnnotationMetaDataProvider implements MetaDataProvider
private final ConstraintHelper constraintHelper;
private final TypeResolutionHelper typeResolutionHelper;
private final AnnotationProcessingOptions annotationProcessingOptions;
private final ValueExtractorManager valueExtractorManager;
// 这是一个非常重要的属性，它会记录着当前Bean 所有的待校验的Bean信息~~~
private final BeanConfiguration<Object> objectBeanConfiguration;
// 唯一构造函数
public AnnotationMetaDataProvider(ConstraintHelper constraintHelper,
TypeResolutionHelper typeResolutionHelper,
ValueExtractorManager valueExtractorManager,
AnnotationProcessingOptions annotationProcessingOptions)
this.constraintHelper = constraintHelper;
this.typeResolutionHelper = typeResolutionHelper;
this.valueExtractorManager = valueExtractorManager;
this.annotationProcessingOptions = annotationProcessingOptions;
// 默认情况下，它去把Object相关的所有的方法都retrieve:检索出来放着 我比较费解这件事~~~
// 后面才发现：一切为了效率
this.objectBeanConfiguration = retrieveBeanConfiguration( Object.class );
// 实现接口方法
@Override
public AnnotationProcessingOptions getAnnotationProcessingOptions()
return new AnnotationProcessingOptionsImpl();
// 如果你的Bean是Object 就直接返回了~~~（大多数情况下 都是Object）
@Override
@SuppressWarnings("unchecked")
public <T> BeanConfiguration<T> getBeanConfiguration(Class<T> beanClass)
if ( Object.class.equals( beanClass ) )
return (BeanConfiguration<T>) objectBeanConfiguration;
return retrieveBeanConfiguration( beanClass );
如上可知，核心解析逻辑在retrieveBeanConfiguration()这个私有方法上。总结一下调用此方法的两个原始入口（一个构造器，一个接口方法）：
- ValidatorFactory.getValidator()获取校验器的时候，初始化时会自己new一个BeanMetaDataManager:
- 调用Validator.validate()方法的时候，beanMetaDataManager.getBeanMetaData( rootBeanClass )它会遍历初始化时所有的metaDataProviders(默认情况下两个，没有xml方式的)，拿出所有的BeanConfiguration交给BeanMetaDataBuilder，最终构建出一个属于此Bean的BeanMetaData。对此有一点注意事项描述如下：
处理MetaDataProvider时会调用ClassHierarchyHelper.getHierarchy( beanClass )方法，不仅仅处理本类。拿到本类自己和所有父类后，统一交给provider.getBeanConfiguration( clazz )处理（也就是说任何一个类都会把Object类处理一遍）
retrieveBeanConfiguration()详情
这个方法说白了，就是从Bean里面去检索属性、方法、构造器等需要校验的ConstrainedElement项。
private <T> BeanConfiguration<T> retrieveBeanConfiguration(Class<T> beanClass)
// 它检索的范围是：clazz.getDeclaredFields() 什么意思：就是搜集到本类所有的字段 包括private等等 但是不包括父类的所有字段
Set<ConstrainedElement> constrainedElements = getFieldMetaData( beanClass );
constrainedElements.addAll( getMethodMetaData( beanClass ) );
constrainedElements.addAll( getConstructorMetaData( beanClass ) );
//TODO GM: currently class level constraints are represented by a PropertyMetaData. This
//works but seems somewhat unnatural
// 这个TODO很有意思：当前，类级约束由PropertyMetadata表示。这是可行的，但似乎有点不自然
// ReturnValueMetaData、ExecutableMetaData、ParameterMetaData、PropertyMetaData
// 总之吧：此处就是把类级别的校验器放进来了（这个set大部分时候都是空的）
Set<MetaConstraint<?>> classLevelConstraints = getClassLevelConstraints( beanClass );
if (!classLevelConstraints.isEmpty())
ConstrainedType classLevelMetaData = new ConstrainedType(ConfigurationSource.ANNOTATION, beanClass, classLevelConstraints);
constrainedElements.add(classLevelMetaData);
// 组装成一个BeanConfiguration返回
return new BeanConfiguration<>(ConfigurationSource.ANNOTATION, beanClass,
constrainedElements,
getDefaultGroupSequence( beanClass ), //此类上标注的所有@GroupSequence注解
getDefaultGroupSequenceProvider( beanClass ) // 此类上标注的所有@GroupSequenceProvider注解
);
这一步骤把该Bean上的字段、方法等等需要校验的项都提取出来。就拿上例中的Demo校验Person类来说，最终得出的BeanConfiguration如下：（两个）
这是直观的结论，可以看到仅仅是一个简单的类其实所包含的项是挺多的。
此处说一句：项是有这么多，但是并不是每一个都需要走验证逻辑的。因为毕竟大多数项上面并没有约束（注解），大多数ConstrainedElement.getConstraints()为空嘛
总得来说，我个人建议不能光只记忆结论，因为那很容易忘记，所以还是得稍微深入一点，让记忆更深刻吧。那就从下面四个方面深入：
检索Field：getFieldMetaData( beanClass )
- 拿到本类所有字段Field：clazz.getDeclaredFields()
- 把每个Field都包装成ConstrainedElement存放起来
- 注意：此步骤完成了对每个Field上标注的注解进行了保存
检索Method：getMethodMetaData( beanClass )：
- 拿到本类所有的方法Method：clazz.getDeclaredMethods()
- 排除掉静态方法和合成(isSynthetic)方法
- 把每个Method都转换成一个ConstrainedExecutable装着~~(ConstrainedExecutable也是个ConstrainedElement)。在此期间它完成了如下事（方法和构造器都复杂点，因为包含入参和返回值）：
- 1. 找到方法上所有的注解保存起来
- 2. 处理入参、返回值（包括自动判断是作用在入参还是返回值上）
检索Constructor：getConstructorMetaData( beanClass ):
完全同处理Method，略
检索Type：getClassLevelConstraints( beanClass ):
- 找打标注在此类上的所有的注解，转换成ConstraintDescriptor
- 对已经找到每个ConstraintDescriptor进行处理，最终都转换Set<MetaConstraint<?>>这个类型
- 把Set<MetaConstraint<?>>用一个ConstrainedType包装起来（ConstrainedType是个ConstrainedElement）
关于级联校验元数据提取是由findCascadingMetaData方法完成（@Valid信息在这里被提取出来），我们这里更关心的是该方法在哪些场景下会被调用，也就说明了级联校验在哪些场景下会生效了:
// type解释：分如下N中情况
// Field为：.getGenericType() // 字段的类型
// Method为：.getGenericReturnType() // 返回值类型
// Constructor：.getDeclaringClass() // 构造器所在类
// annotatedElement：可不一定说一定要有注解才能进来（每个字段、方法、构造器等都能传进来）
private CascadingMetaDataBuilder getCascadingMetaData(Type type, AnnotatedElement annotatedElement, Map<TypeVariable<?>, CascadingMetaDataBuilder> containerElementTypesCascadingMetaData)
return CascadingMetaDataBuilder.annotatedObject( type, annotatedElement.isAnnotationPresent( Valid.class ), containerElementTypesCascadingMetaData, getGroupConversions( annotatedElement ) );
findCascadingMetaData方法在提取对象属性元数据和方法,构造方法元数据提取中都会进行调用。
validator.validate方法源码流程简析
获取元数据信息,准备上下文环境
- 解析当前对象拿到对象的元数据信息
@Override
public final <T> Set<ConstraintViolation<T>> validate(T object, Class<?>... groups)
...
Class<T> rootBeanClass = (Class<T>) object.getClass();
BeanMetaData<T> rootBeanMetaData = beanMetaDataManager.getBeanMetaData( rootBeanClass );
//如果当前对象没有相关约束,按摩直接返回空
if ( !rootBeanMetaData.hasConstraints() )
return Collections.emptySet();
//准备好validationContext和valueContext
BaseBeanValidationContext<T> validationContext = getValidationContextBuilder().forValidate( rootBeanClass, rootBeanMetaData, object );
ValidationOrder validationOrder = determineGroupValidationOrder( groups );
BeanValueContext<?, Object> valueContext = ValueContexts.getLocalExecutionContextForBean(
validatorScopedContext.getParameterNameProvider(),
object,
validationContext.getRootBeanMetaData(),
PathImpl.createRootPath()
);
//利用validationContext和valueContext完成对bean对象的校验
return validateInContext( validationContext, valueContext, validationOrder );
validationContext最重要的部分就是其内部管理的BeanMetaData，也就是对象的元数据信息。
valueContext更加侧重于对对象属性值获取和验证的相关操作
BeanMetaData是完成数据校验的核心，他的结构如下:
BeanMetaData内部记录了当前对象相关约束信息，并且内部的allMetaConstraints数组内记录了约束信息，该数组内每一个MetaConstraint内部提供的ConstraintTree负责完成具体的验证逻辑:
validationOrder保存的就是用户需要同时校验几个分组:
Set<ConstraintViolation<Person>> result = validator.validate(person, Person.Simple.class,Person.Complex.class);
按照分组挨个进行校验
- validateInContext利用validationContext和valueContext 提供的上下文信息完成数据校验
private <T, U> Set<ConstraintViolation<T>> validateInContext(BaseBeanValidationContext<T> validationContext, BeanValueContext<U, Object> valueContext,
ValidationOrder validationOrder)
...
BeanMetaData<U> beanMetaData = valueContext.getCurrentBeanMetaData();
...
//将用户需要进行校验的分组挨个进行校验
Iterator<Group> groupIterator = validationOrder.getGroupIterator();
while ( groupIterator.hasNext() )
Group group = groupIterator.next();
//可以猜到valueContext负责完成对属于当前分组的约束的校验
valueContext.setCurrentGroup( group.getDefiningClass() );
//进行具体校验
validateConstraintsForCurrentGroup( validationContext, valueContext );
//如果设置了failFast标记为真,并且当前分组校验产生了错误,那么直接短路返回
//默认为false
if ( shouldFailFast( validationContext ) )
return validationContext.getFailingConstraints();
//再对每个分组的级联属性进行校验
groupIterator = validationOrder.getGroupIterator();
while ( groupIterator.hasNext() )
Group group = groupIterator.next();
valueContext.setCurrentGroup( group.getDefiningClass() );
validateCascadedConstraints( validationContext, valueContext );
if ( shouldFailFast( validationContext ) )
return validationContext.getFailingConstraints();
//这块暂时忽略---问题不大
// now we process sequences. For sequences I have to traverse the object graph since I have to stop processing when an error occurs.
Iterator<Sequence> sequenceIterator = validationOrder.getSequenceIterator();
while ( sequenceIterator.hasNext() )
...
//返回上面校验完后的错误结果
return validationContext.getFailingConstraints();
设置快速失败的作用上面也体现出来了:
HibernateValidatorConfiguration configure = Validation.byProvider(HibernateValidator.class).configure();
ValidatorFactory validatorFactory = configure.failFast(false).buildValidatorFactory();
对当前分组的非级联属性完成校验
- validateConstraintsForCurrentGroup： 对当前分组的非级联属性完成校验
private void validateConstraintsForCurrentGroup(BaseBeanValidationContext<?> validationContext, BeanValueContext<?, Object> valueContext)
// we are not validating the default group there is nothing special to consider. If we are validating the default
// group sequence we have to consider that a class in the hierarchy could redefine the default group sequence.
//判断是对默认分组进行校验还是用户自定义分组
if ( !valueContext.validatingDefault() Java中的参数校验