深入了解数据校验（Bean Validation）：从深处去掌握@Valid的作用（级联校验）以及常用约束注解的解释说明【享学Java】（上）

@Getter
@Setter
@ToString
public class Person {
    // 错误消息message是可以自定义的
    @NotNull(message = "{message} -> 名字不能为null", groups = Simple.class)
    public String name;
    @Max(value = 10, groups = Simple.class)
    @Positive(groups = Default.class) // 内置的分组：default
    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组
    interface Simple {
    }
    interface Complex {
    }
}

    public static void main(String[] args) {
        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

public enum ConfigurationSource {
  ANNOTATION( 0 ),
  XML( 1 ),
  API( 2 ); //programmatic API
}

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;
  ... // 它自己并不处理什么逻辑，参数都是通过构造器传进来的
}

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 );
  }
}

  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注解
    );
  }