解决多字段联合逻辑校验问题【享学Spring MVC】

每篇一句

前言

本以为洋洋洒洒的把

Java/Spring

Bean Validation

关于

Java/Spring

JavaBean

if else

Bean Validation

热心网友问题描述

为了更真实的还原问题场景，我贴上聊天截图如下：

待校验的请求JavaBean如下：

校需求描述简述如下：

这位网友描述的真实生产场景问题，这也是本文讲解的内容所在。
虽然这是在

Spring MVC

方案和原理

对于单字段的校验、级联属性校验等，通过阅读我的系列文章，我有理由相信小伙伴们都能

驾轻就熟

@Getter
@Setter
@ToString
public class Person {

@NotNull
private String name;
@NotNull
@Range(min = 10, max = 40)
private Integer age;

@NotNull
@Size(min = 3, max = 5)
private List<String> hobbies;

// 级联校验
@Valid
@NotNull
private Child child;
}

测试：

public static void main(String[] args)  {
Person person = new Person();
person.setName("fsx");
person.setAge(5);
person.setHobbies(Arrays.asList("足球","篮球"));
person.setChild(new Child());

Set<ConstraintViolation<Person>> result = Validation.buildDefaultValidatorFactory().getValidator().validate(person);

// 对结果进行遍历输出
result.stream().map(v -> v.getPropertyPath() + " " + v.getMessage() + ": " + v.getInvalidValue()).forEach(System.out::println);
}

运行，打印输出：

child.name 不能为null: null
age 需要在10和40之间: 5
hobbies 个数必须在3和5之间: [足球,篮球]

结果符合预期，（级联）校验生效。

@Valid

List

问题来了，针对上例，现在我有如下需求：

1. 若20 <= age < 30，那么

   hobbies

   的

   size

   需介于1和2之间
2. 若30 <= age < 40，那么

   hobbies

   的

   size

   需介于3和5之间

3. age其余值，

   hobbies

   无校验逻辑

   实现方案

   Hibernate Validator

   提供了非标准的

   @GroupSequenceProvider

   注解。本功能提供根据当前对象实例的状态，动态来决定加载那些校验组进入默认校验组。

为了实现上面的需求达到目的，我们需要借助

Hibernate Validation

DefaultGroupSequenceProvider

// 该接口定义了：动态Group序列的协定
// 要想它生效，需要在T上标注@GroupSequenceProvider注解并且指定此类为处理类
// 如果`Default`组对T进行验证，则实际验证的实例将传递给此类以确定默认组序列（这句话特别重要  下面用例子解释）
public interface DefaultGroupSequenceProvider<T> {
// 合格方法是给T返回默认的组（多个）。因为默认的组是Default嘛~~~通过它可以自定指定
// 入参T object允许在验证值状态的函数中动态组合默认组序列。（非常强大）
// object是待校验的Bean。它可以为null哦~（Validator#validateValue的时候可以为null）

// 返回值表示默认组序列的List。它的效果同@GroupSequence定义组序列，尤其是列表List必须包含类型T
List<Class<?>> getValidationGroups(T object);
}

注意：

1. 此接口Hibernate并没有提供实现
2. 若你实现请必须提供一个空的构造函数以及保证是线程安全的

按步骤解决多字段组合验证的逻辑：
1、自己实现

DefaultGroupSequenceProvider

public class PersonGroupSequenceProvider implements DefaultGroupSequenceProvider<Person> {

@Override
public List<Class<?>> getValidationGroups(Person bean) {
List<Class<?>> defaultGroupSequence = new ArrayList<>();
defaultGroupSequence.add(Person.class); // 这一步不能省,否则Default分组都不会执行了，会抛错的

if (bean != null) { // 这块判空请务必要做
Integer age = bean.getAge();
System.err.println("年龄为：" + age + "，执行对应校验逻辑");
if (age >= 20 && age < 30) {
defaultGroupSequence.add(Person.WhenAge20And30Group.class);
} else if (age >= 30 && age < 40) {
defaultGroupSequence.add(Person.WhenAge30And40Group.class);
}
}
return defaultGroupSequence;
}
}

2、在待校验的javaBean里使用

@GroupSequenceProvider

@GroupSequenceProvider(PersonGroupSequenceProvider.class)
@Getter
@Setter
@ToString
public class Person {

@NotNull
private String name;
@NotNull
@Range(min = 10, max = 40)
private Integer age;

@NotNull(groups = {WhenAge20And30Group.class, WhenAge30And40Group.class})
@Size(min = 1, max = 2, groups = WhenAge20And30Group.class)
@Size(min = 3, max = 5, groups = WhenAge30And40Group.class)
private List<String> hobbies;

/**
* 定义专属的业务逻辑分组
*/
public interface WhenAge20And30Group {
}
public interface WhenAge30And40Group {
}
}

测试用例同上，做出简单修改：

person.setAge(25)

年龄为：25，执行对应校验逻辑
年龄为：25，执行对应校验逻辑

没有校验失败的消息（就是好消息），符合预期。
再修改为

person.setAge(35)

年龄为：35，执行对应校验逻辑
年龄为：35，执行对应校验逻辑
hobbies 个数必须在3和5之间: [足球, 篮球]

校验成功，结果符合预期。
从此案例可以看到，通过

@GroupSequenceProvider

使用JSR提供的

@GroupSequence

注解控制校验顺序

上面的实现方式是最佳实践，使用起来不难，灵活度也非常高。但是我们必须要明白它是

Hibernate Validation

JSR

@GroupSequence

JSR

// Defines group sequence.  定义组序列（序列：顺序执行的）
@Target({ TYPE })
@Retention(RUNTIME)
@Documented
public @interface GroupSequence {
Class<?>[] value();
}

顾名思义，它表示

Group组序列

1. 第二个组的约束验证依赖于第一个约束执行完成的结果（必须第一个约束正确了，第二个约束执行才有意义）
2. 某个Group组的校验非常耗时，并且会消耗比较大的CPU/内存。那么我们的做法应该是把这种校验放到最后，所以对顺序提出了要求

一个组可以定义为其他组的序列，使用它进行验证的时候必须符合该序列规定的顺序。

在使用组序列验证的时候

给个栗子：

public class User {

@NotEmpty(message = "firstname may be empty")
private String firstname;
@NotEmpty(message = "middlename may be empty", groups = Default.class)
private String middlename;
@NotEmpty(message = "lastname may be empty", groups = GroupA.class)
private String lastname;
@NotEmpty(message = "country may be empty", groups = GroupB.class)
private String country;

public interface GroupA {
}
public interface GroupB {
}
// 组序列
@GroupSequence({Default.class, GroupA.class, GroupB.class})
public interface Group {
}
}

测试：

public static void main(String[] args)  {
User user = new User();
// 此处指定了校验组是：User.Group.class
Set<ConstraintViolation<User>> result = Validation.buildDefaultValidatorFactory().getValidator().validate(user, User.Group.class);

// 对结果进行遍历输出
result.stream().map(v -> v.getPropertyPath() + " " + v.getMessage() + ": " + v.getInvalidValue()).forEach(System.out::println);
}

运行，控制台打印：

middlename middlename may be empty: null
firstname firstname may be empty: null

现象：只有

Default

User user = new User();
user.setFirstname("f");
user.setMiddlename("s");

运行，控制台打印：

lastname lastname may be empty: null

现象：

Default

@GroupSequence

短路

针对本例的多字段组合逻辑校验，若想借助

@GroupSequence

1. 多字段之间的逻辑、“通信”通过类级别的自定义校验注解来实现（至于为何必须是类级别的，不用解释吧~）

2. @GroupSequence

   用来控制组执行顺序（让类级别的自定义注解先执行）
3. 增加Bean级别的第三属性来辅助校验~

当然喽，在实际应用中不可能使用它来解决如题的问题，所以我此处就不费篇幅了。我个人建议有兴趣者可以自己动手试试，有助于加深你对数据校验这块的理解。

这篇文章里有说过：数据校验注解是可以标注在Field属性、方法、构造器以及

Class

Set<MetaConstraint<?>> metaConstraints

所以网上有说：校验顺序是先校验字段属性，在进行类级别校验不实，请注意辨别。

原理解析

本文中，我借助

@GroupSequenceProvider

1. 为何必须有这一句：

   defaultGroupSequence.add(Person.class)

2. 为何

   if (bean != null)

   必须判空
3. 为何

   年龄为：35，执行对应校验逻辑

   被输出了两次（在判空里面还出现了两次哦~），但校验的失败信息却只有符合预期的一次

带着问题，我从

validate

ValidatorImpl.validate(T object, Class<?>... groups)

ValidatorImpl：
@Override
public final <T> Set<ConstraintViolation<T>> validate(T object, Class<?>... groups) {
Class<T> rootBeanClass = (Class<T>) object.getClass();
// 获取BeanMetaData，类上的各种信息：包括类上的Group序列、针对此类的默认分组List们等等
BeanMetaData<T> rootBeanMetaData = beanMetaDataManager.getBeanMetaData( rootBeanClass );
...
}

2、

beanMetaDataManager.getBeanMetaData(rootBeanClass)

!= null

BeanMetaDataManager:
public <T> BeanMetaData<T> getBeanMetaData(Class<T> beanClass) {
...
// 会调用AnnotationMetaDataProvider来解析约束注解元数据信息（当然还有基于xml/Programmatic的，本文略）
// 注意：它会递归处理父类、父接口等拿到所有类的元数据

// BeanMetaDataImpl.build()方法，会new BeanMetaDataImpl(...) 这个构造函数里面做了N多事
// 其中就有和我本例有关的defaultGroupSequenceProvider
beanMetaData = createBeanMetaData( beanClass );
}

3、

new BeanMetaDataImpl( ... )

Person.class

BeanMetaDataImpl：
public BeanMetaDataImpl(Class<T> beanClass,
List<Class<?>> defaultGroupSequence, // 如果没有配置，此时候defaultGroupSequence一般都为null
DefaultGroupSequenceProvider<? super T> defaultGroupSequenceProvider, // 我们自定义的处理此Bean的provider
Set<ConstraintMetaData> constraintMetaDataSet, // 包含父类的所有属性、构造器、方法等等。在此处会分类：按照属性、方法等分类处理
ValidationOrderGenerator validationOrderGenerator) {
... //对constraintMetaDataSet进行分类
// 这个方法就是筛选出了：所有的约束注解（比如6个约束注解，此处长度就是6  当然包括了字段、方法等上的各种。。。）
this.directMetaConstraints = getDirectConstraints();

// 因为我们Person类有defaultGroupSequenceProvider，所以此处返回true
// 除了定义在类上外，还可以定义全局的：给本类List<Class<?>> defaultGroupSequence此字段赋值
boolean defaultGroupSequenceIsRedefined = defaultGroupSequenceIsRedefined();

// 这是为何我们要判空的核心：看看它传的啥：null。所以不判空的就NPE了。这是第一次调用defaultGroupSequenceProvider.getValidationGroups()方法
List<Class<?>> resolvedDefaultGroupSequence = getDefaultGroupSequence( null );
... // 上面拿到resolvedDefaultGroupSequence 分组信息后，会放到所有的校验器里去（包括属性、方法、构造器、类等等）
// so，默认组序列还是灰常重要的（注意：默认组可以有多个哦~~~）
}

@Override
public List<Class<?>> getDefaultGroupSequence(T beanState) {
if (hasDefaultGroupSequenceProvider()) {
// so，getValidationGroups方法里请记得判空~
List<Class<?>> providerDefaultGroupSequence = defaultGroupSequenceProvider.getValidationGroups( beanState );
// 最重要的是这个方法：getValidDefaultGroupSequence对默认值进行分析~~~
return getValidDefaultGroupSequence( beanClass, providerDefaultGroupSequence );
}
return defaultGroupSequence;
}

private static List<Class<?>> getValidDefaultGroupSequence(Class<?> beanClass, List<Class<?>> groupSequence) {
List<Class<?>> validDefaultGroupSequence = new ArrayList<>();
boolean groupSequenceContainsDefault = false; // 标志位：如果解析不到Default这个组  就抛出异常

// 重要
if (groupSequence != null) {
for ( Class<?> group : groupSequence ) {
// 这就是为何我们要`defaultGroupSequence.add(Person.class)`这一句的原因所在~~~ 因为需要Default生效~~~
if ( group.getName().equals( beanClass.getName() ) ) {
validDefaultGroupSequence.add( Default.class );
groupSequenceContainsDefault = true;
}
// 意思是：你要添加Default组，用本类的Class即可，而不能显示的添加Default.class哦~
else if ( group.getName().equals( Default.class.getName() ) ) {
throw LOG.getNoDefaultGroupInGroupSequenceException();
} else { // 正常添加进默认组
validDefaultGroupSequence.add( group );
}
}
}
// 若找不到Default组，就抛出异常了~
if ( !groupSequenceContainsDefault ) {
throw LOG.getBeanClassMustBePartOfRedefinedDefaultGroupSequenceException( beanClass );
}
return validDefaultGroupSequence;
}

到这一步，还仅仅在初始化

BeanMetaData

defaultGroupSequenceProvider.getValidationGroups(null)

BeanMetaData<T> rootBeanMetaData

validate()

4、

determineGroupValidationOrder(groups)

ValidatorImpl：
@Override
public final <T> Set<ConstraintViolation<T>> validate(T object, Class<?>... groups) {
...
BeanMetaData<T> rootBeanMetaData = beanMetaDataManager.getBeanMetaData( rootBeanClass );
...
... // 准备好ValidationContext(持有rootBeanMetaData和object实例)

// groups是调用者传进来的分组数组（对应Spring MVC中指定的Group信息~）
ValidationOrder validationOrder = determineGroupValidationOrder(groups);
... // 准备好ValueContext(持有rootBeanMetaData和object实例)

// 此时还是Bean级别的，开始对此bean执行校验
return validateInContext( validationContext, valueContext, validationOrder );
}

private ValidationOrder determineGroupValidationOrder(Class<?>[] groups) {
Collection<Class<?>> resultGroups;
// if no groups is specified use the default
if ( groups.length == 0 ) {
resultGroups = DEFAULT_GROUPS;
} else {
resultGroups = Arrays.asList( groups );
}
// getValidationOrder()主要逻辑描述。此时候resultGroups 至少也是个[Default.class]
// 1、如果仅仅只是一个Default.class，那就直接return
// 2、遍历所有的groups。（指定的Group必须必须是接口）
// 3、若遍历出来的group标注有`@GroupSequence`注解，特殊处理此序列（把序列里的分组们添加进来）
// 4、普通的Group，那就new Group( clazz )添加进`validationOrder`里。并且递归插入（因为可能存在父接口的情况）
return validationOrderGenerator.getValidationOrder( resultGroups );
}

到这

ValidationOrder

DefaultValidationOrder

validate()

Groups

@GroupSequence

validateInContext( ... )

5、

validateInContext( ... )

ValidatorImpl：
private <T, U> Set<ConstraintViolation<T>> validateInContext(ValidationContext<T> validationContext, ValueContext<U, Object> valueContext, ValidationOrder validationOrder) {
if ( valueContext.getCurrentBean() == null ) { // 兼容整个Bean为null值
return Collections.emptySet();
}
// 如果该Bean头上标注了（需要defaultGroupSequence处理），那就特殊处理一下
// 本例中我们的Person肯定为true，可以进来的
BeanMetaData<U> beanMetaData = valueContext.getCurrentBeanMetaData();
if ( beanMetaData.defaultGroupSequenceIsRedefined() ) {

// 注意此处又调用了beanMetaData.getDefaultGroupSequence()这个方法，这算是二次调用了
// 此处传入的Object哟~这就解释了为何在判空里面的 `年龄为：xxx`被打印了两次的原因
// assertDefaultGroupSequenceIsExpandable方法是个空方法（默认情况下），可忽略
validationOrder.assertDefaultGroupSequenceIsExpandable( beanMetaData.getDefaultGroupSequence( valueContext.getCurrentBean() ) );
}

// ==============下面对于执行顺序，就很重要了===============
// validationOrder装着的是调用者指定的分组（解析分组序列来保证顺序~~~）
// 需要特别注意：光靠指定分组，是无序的（不能保证校验顺序的） 所以若指定多个分组需要小心求证
Iterator<Group> groupIterator = validationOrder.getGroupIterator();
// 按照调用者指定的分组（顺序），一个一个的执行分组校验。
while ( groupIterator.hasNext() ) {
Group group = groupIterator.next();
valueContext.setCurrentGroup(group.getDefiningClass()); // 设置当前正在执行的分组

// 这个步骤就稍显复杂了，也是核心的逻辑之一。大致过程如下：
// 1、拿到该Bean的BeanMetaData
// 2、若defaultGroupSequenceIsRedefined()=true  本例Person标注了provder注解，所以有指定的分组序列的
// 3、根据分组序列的顺序，挨个执行分组们（对所有的约束MetaConstraint都顺序执行分组们）
// 4、最终完成所有的MetaConstraint的校验，进而完成此部分所有的字段、方法等的校验
validateConstraintsForCurrentGroup( validationContext, valueContext );
if ( shouldFailFast( validationContext ) ) {
return validationContext.getFailingConstraints();
}
}

... // 和上面一样的代码，校验validateCascadedConstraints

// 继续遍历序列：和@GroupSequence相关了
Iterator<Sequence> sequenceIterator = validationOrder.getSequenceIterator();
...

// 校验上下文的错误消息：它会把本校验下，所有的验证器上下文ConstraintValidatorContext都放一起的
// 注意：所有的校验注解之间的上下文ConstraintValidatorContext是完全独立的，无法互相访问通信
return validationContext.getFailingConstraints();
}

that is all. 到这一步整个校验就完成了，若不快速失败，默认会拿到所有校验失败的消息。

真正执行

isValid

public abstract class ConstraintTree<A extends Annotation> {
...
protected final <T, V> Set<ConstraintViolation<T>> validateSingleConstraint(
ValidationContext<T> executionContext, // 它能知道所属类
ValueContext<?, ?> valueContext,
ConstraintValidatorContextImpl constraintValidatorContext,
ConstraintValidator<A, V> validator) {

boolean isValid;
// 解析出value值
V validatedValue = (V) valueContext.getCurrentValidatedValue();
// 把value值交给校验器的isValid方法去校验~~~
isValid = validator.isValid(validatedValue,constraintValidatorContext);
...
if (!isValid) {
// 校验没通过就使用constraintValidatorContext校验上下文来生成错误消息
// 使用上下文是因为：毕竟错误消息可不止一个啊~~~
// 当然此处借助了executionContext的方法~~~内部其实调用的是constraintValidatorContext.getConstraintViolationCreationContexts()这个方法而已
return executionContext.createConstraintViolations(valueContext, constraintValidatorContext);
}
}
}

至于上下文

ConstraintValidatorContext

new ConstraintValidatorContextImpl( ... )

ValidationContext<T> validationContext

ValueContext<?, Object> valueContext

ValidatorImpl.validateMetaConstraints

ConstraintValidatorContext

validationContext

valueContext

dependOn

解决网友的问题

我把这部分看似是本文最重要的引线放到最后，是因为我觉得我的描述已经解决这一类问题，而不是只解决了这一个问题。

回到文首截图中热心网友反应的问题，只要你阅读了本文，我十分坚信你已经有办法去使用

Bean Validation

总结

本文讲述了使用

@GroupSequenceProvider

Bean Validation

相关阅读

【小家Spring】@Validated和@Valid的区别？教你使用它完成Controller参数校验（含级联属性校验）以及原理分析
【小家Spring】Bean Validation完结篇：你必须关注的边边角角（约束级联、自定义约束、自定义校验器、国际化失败消息...）
【小家Java】深入了解数据校验：Java Bean Validation 2.0（JSR303、JSR349、JSR380）Hibernate-Validation 6.x使用案例

知识交流

==The last：如果觉得本文对你有帮助，不妨点个赞呗。当然分享到你的朋友圈让更多小伙伴看到也是被

作者本人许可的~

若对技术内容感兴趣可以加入wx群交流：

Java高工、架构师3群

fsx641385712

"java入群"

==若对Spring、SpringBoot、MyBatis等源码分析感兴趣，可加我wx：fsx641385712，手动邀请你入群一起飞==