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

青旅半醒 2021-11-26 10:06 345阅读 0赞

#### 每篇一句 ####

> 没有任何技术方案会是一种银弹，任何东西都是有利弊的

#### 前言 ####

关于`Bean Validation`的基本原理篇完结之后，接下来就是小伙伴最为关心的干货：**使用篇**。  
如果说要使用`Bean Validation`数据校验，我十分相信小伙伴们都能够使用，但估计大都是有个前提的：`Spring MVC`环境。我极其简单的调查了一下，近乎`99%`的人都是只把数据校验使用在`Spring MVC`的`Controller`层面的，而且几乎`90%`的人都是让它必须和`@RequestBody`一起来使用去校验`JavaBean`入参~

如果这么去理解`Bean Validation`的使用，那就有点太过于片面了，毕竟被Spring包裹起来，你其实很难去知道它真正做的事。  
**熟悉我文章风格的人知道，每篇文章我都会带你领略一些不一样的风景，本章亦不例外**，会让你知道数据校验在`Spring`框架之外的一些事~

#### 分组校验 ####

在我的前置原理篇文章，分组校验其实是没太大必要说的，因为使用起来确实非常的简单。此处还是给个分组校验的使用案例吧：

@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

可以直观的看到效果，此处的校验只执行`Person.Simple.class`这个`Group`组上的约束~

> 分组约束在Spring MVC中的使用场景还是相对比较多的，但是需要注意的是：`javax.validation.Valid`没有提供指定分组的，但是`org.springframework.validation.annotation.Validated`扩展提供了直接在注解层面指定分组的能力

## @Valid注解 ##

我们知道`JSR`提供了一个`@Valid`注解供以使用，在本文之前，绝大多数小伙伴都是在`Controller`中并且结合`@RequestBody`一起来使用它，但在本文之后，你定会对它有个全新的认识~

该注解用于验证**级联的属性**、**方法参数**或**方法返回**类型。  
当验证属性、方法参数或方法返回类型时，将验证对象及其属性上定义的约束，另外：`此行为是递归应用的。`

：：：为了理解`@Valid`，那就得知道处理它的时机：：：

#### MetaDataProvider ####

元数据提供者：约束相关元数据（如约束、**默认组序列**等）的`Provider`。它的作用和特点如下：

1.  基于不同的元数据：**如xml、注解。（还有个编程映射）** 这三种类型。对应的枚举类为：

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

1.  `MetaDataProvider`只返回**直接为一个类配置的**元数据
2.  它不处理从超类、接口合并的元数据（`简单的说你@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;
    	... // 它自己并不处理什么逻辑，参数都是通过构造器传进来的
    }

它的继承树：  
![在这里插入图片描述][20190724195931220.png]  
三个实现类对应着上面所述的三种元数据类型。本文很显然只需要关注和注解相关的：`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()`这个私有方法上。总结一下调用此方法的两个原始入口（一个构造器，一个接口方法）：

1.  `ValidatorFactory.getValidator()`获取校验器的时候，初始化时会自己`new`一个，调用栈如下图：  
    ![在这里插入图片描述][20190724203252242.png]
2.  调用`Validator.validate()`方法的时候，`beanMetaDataManager.getBeanMetaData( rootBeanClass )`它会遍历初始化时所有的`metaDataProviders`(默认情况下两个，没有xml方式的)，拿出所有的`BeanConfiguration`交给`BeanMetaDataBuilder`，最终构建出一个属于此Bean的`BeanMetaData`。对此有一点注意事项描述如下：  
    1. 处理`MetaDataProvider`时会调用`ClassHierarchyHelper.getHierarchy( beanClass )`方法，不仅仅处理本类。拿到本类自己和所有父类后，统一交给`provider.getBeanConfiguration( clazz )`处理（**也就是说任何一个类都会把Object类处理一遍**）  
    ![在这里插入图片描述][20190724203946765.png]

###### `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`如下：（两个）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70 1]  
这是直观的结论，可以看到仅仅是一个简单的类其实**所包含的项**是挺多的。

> 此处说一句：项是有这么多，但是并不是每一个都需要走验证逻辑的。因为毕竟大多数项上面并没有约束（注解），大多数`ConstrainedElement.getConstraints()`为空嘛~

总得来说，我个人建议不能光只记忆结论，因为那很容易忘记，所以还是得稍微深入一点，让记忆更深刻吧。那就从下面四个方面深入：

##### 检索Field：getFieldMetaData( beanClass ) #####

1.  拿到**本类**所有字段`Field`：`clazz.getDeclaredFields()`
2.  把每个`Field`都包装成`ConstrainedElement`存放起来~~~  
    1. 注意：此步骤完成了对每个`Field`上标注的注解进行了保存

##### 检索Method：getMethodMetaData( beanClass ) #####

1.  拿到本类所有的方法`Method`：`clazz.getDeclaredMethods()`
2.  排除掉静态方法和合成(isSynthetic)方法
3.  把每个Method都转换成一个`ConstrainedExecutable`装着~~(`ConstrainedExecutable`也是个`ConstrainedElement`)。在此期间它完成了如下事（**方法和构造器都复杂点，因为包含入参和返回值**）：  
    1. 找到方法上所有的注解保存起来  
    2. 处理入参、返回值（包括自动判断是作用在入参还是返回值上）

##### 检索Constructor：getConstructorMetaData( beanClass ) #####

完全同处理Method，略

##### 检索Type：getClassLevelConstraints( beanClass ) #####

1.  找打标注在此类上的所有的注解，转换成`ConstraintDescriptor`
2.  对已经找到每个`ConstraintDescriptor`进行处理，最终都转换`Set<MetaConstraint<?>>`这个类型  
    1.
3.  把`Set<MetaConstraint<?>>`用一个`ConstrainedType`包装起来（`ConstrainedType`是个`ConstrainedElement`）

关于级联校验此处补充说明一点，处理Type，都会处理级联校验情况，并且还是递归处理：  
也就是这个方法（课件`@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 ) );
    	}

这里对我们理解级联校验最重要的一句是：`annotatedElement.isAnnotationPresent(Valid.class)`。也就是说：若元素被此注解标注了，那就证明需要对它进行**级联校验**，这就是JSR定位`@Valid`的作用~

> Spring提升了它？？？请关注后文Spring对它的应用吧~

#### `ConstraintValidator.isValid()`调用处 ####

我们知道，每个约束注解都是交给`约束校验器ConstraintValidator.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) { 
    		...
    		V validatedValue = (V) valueContext.getCurrentValidatedValue();
    		isValid = validator.isValid( validatedValue, constraintValidatorContext );
    		...
    		// 显然校验不通过就返回错误消息 否则返回空集合
    		if ( !isValid ) { 
    			return executionContext.createConstraintViolations(valueContext, constraintValidatorContext);
    		}
    		return Collections.emptySet();
    	}
    	...
    }

这个方法的调用，会在执行每个`Group`的时候

success = metaConstraint.validateConstraint( validationContext, valueContext );

`MetaConstraint`在上面检索的时候就已经准备好了，最后通过`ConstrainedElement.getConstraints`就拿到了每个元素的校验器们，继续调用

// ConstraintTree<A>
    boolean validationResult = constraintTree.validateConstraints( executionContext, valueContext );

so，最终就调用到了`isValid`这个**真正做事**的方法上了。

说了这么多，你可能还云里雾里，那么就`show`一把吧：

## Demo Show ##

上面用一个示例校验`Person`这个`JavaBean`了，但是你会发现示例中我们全都是校验的`Field`属性。从理论里我们知道了`Bean Validation`它是有校验**方法、构造器、入参甚至递归校验级联属性的能力的**：

#### 校验属性Field ####

略

#### 校验Method入参、返回值 ####

#### 校验Constructor入参、返回值 ####

#### 既校验入参，同时也校验返回值 ####

这些是不能直接使用的，需要在运行时进行校验。具体使用可参考：[【小家Spring】让Controller支持对平铺参数执行数据校验（默认Spring MVC使用@Valid只能对JavaBean进行校验）][Spring_Controller_Spring MVC_Valid_JavaBean]

#### 级联校验 ####

什么叫级联校验，其实就是带校验的成员里存在级联对象时，也要对它完成校验。这个在实际应用场景中是比较常见的，比如入参`Person`对象中，还持有`Child`对象，我们不仅仅要完成`Person`的校验，也依旧还要对**Child内的属性**校验：

@Getter
    @Setter
    @ToString
    public class Person { 
    
        @NotNull
        private String name;
        @NotNull
        @Positive
        private Integer age;
        @Valid
        @NotNull
        private InnerChild child;
    
        @Getter
        @Setter
        @ToString
        public static class InnerChild { 
            @NotNull
            private String name;
            @NotNull
            @Positive
            private Integer age;
        }
    
    }

校验逻辑如下：

public static void main(String[] args) { 
            Person person = new Person();
            person.setName("fsx");
            Person.InnerChild child = new Person.InnerChild();
            child.setName("fsx-son");
            child.setAge(-1);
            person.setChild(child); // 放进去
    
            Validator validator = Validation.byProvider(HibernateValidator.class).configure().failFast(false)
                    .buildValidatorFactory().getValidator();
            Set<ConstraintViolation<Person>> result = validator.validate(person);
    
            // 输出错误消息
            result.stream().map(v -> v.getPropertyPath() + " " + v.getMessage() + ": " + v.getInvalidValue())
                    .forEach(System.out::println);
        }

运行：

child.age 必须是正数: -1
    age 不能为null: null

对`child.age`这个级联属性校验成功~

## 常用约束注解解释 ##

本来这个不用写的，但是为了保证系列文章的完整性，还是总结如下

> 说明：我的总结比绝大多数文章都会详细点，因此看此一篇就够了

所有的约束注解都是**可以重复标记**的，因为它身上都有如下重复标记的标注：

@Repeatable(List.class)

###### JSR标准注解 ######

<table> 
 <thead> 
  <tr> 
   <th>约束注解</th> 
   <th>支持的类型</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@AssertFalse</td> 
   <td>Boolean,boolean</td> 
   <td>元素值必须是false</td> 
  </tr> 
  <tr> 
   <td>@AssertTrue</td> 
   <td>Boolean,boolean</td> 
   <td>元素值必须是true</td> 
  </tr> 
  <tr> 
   <td>@DecimalMax</td> 
   <td>BigDecimal，BigInteger, byte,short, int, long，等任何Number或CharSequence（存储的是数字）</td> 
   <td>value：数值上限 inclusive：是否包含此上限，默认true是包含的</td> 
  </tr> 
  <tr> 
   <td>@DecimalMin</td> 
   <td>同上</td> 
   <td>不解释</td> 
  </tr> 
  <tr> 
   <td>@Max</td> 
   <td>同上</td> 
   <td><strong>值=max</strong>，也是校验通过的</td> 
  </tr> 
  <tr> 
   <td>@Min</td> 
   <td>同上</td> 
   <td>不解释</td> 
  </tr> 
  <tr> 
   <td>@Digits</td> 
   <td>同上</td> 
   <td>integer：整数位数<strong>上限</strong> fraction：小数位数<strong>上限</strong></td> 
  </tr> 
  <tr> 
   <td>@Positive</td> 
   <td>同上</td> 
   <td>2.0。必须是严格的正数。0都不行~</td> 
  </tr> 
  <tr> 
   <td>@PositiveOrZero</td> 
   <td>同上</td> 
   <td>2.0。 0是被允许的</td> 
  </tr> 
  <tr> 
   <td>@Negative</td> 
   <td>同上</td> 
   <td>2.0。 必须是严格的负数。0都不行</td> 
  </tr> 
  <tr> 
   <td>@NegativeOrZero</td> 
   <td>同上</td> 
   <td>2.0。 0是被允许的</td> 
  </tr> 
  <tr> 
   <td>@Email</td> 
   <td>CharSequence子类型（如String）</td> 
   <td>2.0。值是否是Email，也可以通过<code>regexp</code>和<code>flag</code>指定<strong>自定义的email格式</strong></td> 
  </tr> 
  <tr> 
   <td>@Future</td> 
   <td>Date、Calendar及所有JSR 310时间类</td> 
   <td>是否是<strong>将来时间</strong>(若是这种<code>LocalTime.now()</code>取当前的，都会是false哦~)</td> 
  </tr> 
  <tr> 
   <td>@FutureOrPresent</td> 
   <td>同上</td> 
   <td>2.0。和上面的区别是now也行~</td> 
  </tr> 
  <tr> 
   <td>@Past</td> 
   <td>同上</td> 
   <td>不解释</td> 
  </tr> 
  <tr> 
   <td>@PastOrPresent</td> 
   <td>同上</td> 
   <td>2.0。不解释</td> 
  </tr> 
  <tr> 
   <td>@NotBlank</td> 
   <td>CharSequence子类型（如String）</td> 
   <td>2.0。规则为<code>.trim().length() &gt; 0</code>（注意：<code>null is not valid</code>）</td> 
  </tr> 
  <tr> 
   <td>@NotEmpty</td> 
   <td>CharSequence子类型、Collection、Map、数组</td> 
   <td>2.0。长度/size大小&gt;0（注意：<code>null is not valid</code>）</td> 
  </tr> 
  <tr> 
   <td>@Size</td> 
   <td>CharSequence子类型、Collection、Map、数组</td> 
   <td>2.0。min：最小值 max：最大值。（注意：边界值是包含的。<strong>null is valid哦</strong>~~）</td> 
  </tr> 
  <tr> 
   <td>@NotNull</td> 
   <td>所有类型</td> 
   <td>不解释</td> 
  </tr> 
  <tr> 
   <td>@Null</td> 
   <td>所有类型</td> 
   <td>不解释</td> 
  </tr> 
  <tr> 
   <td>@Pattern</td> 
   <td>CharSequence子类型（如String）</td> 
   <td>是否满足此正则表达式。regexp：正则。flags：模式</td> 
  </tr> 
  <tr> 
   <td><code>@Valid</code></td> 
   <td>非原子类型</td> 
   <td>级联属性校验</td> 
  </tr> 
 </tbody> 
</table>

说明：

1.  `@DecimalMax`和`@Max`的区别：  
    1. `@DecimalMax`支持类型：Number、BidDecimal、Float、Double、BigInteger、Long  
    2. `@Max`支持的类型：同上  
    3. 它俩都还能标注在String上，比如“6”这种字符串。（若你不是数字字符串，永远校验不通过）
2.  所有没有特殊说明的：`null is valid`
3.  若在不支持的类型上使用约束注解，运行时抛出异常：`javax.validation.UnexpectedTypeException`:No validator could be found for constraint ‘javax.validation.constraints.Future’ validating type ‘java.lang.String’
4.  `@FutureOrPresent`和`@PastOrPresent`这块注意：对于`Present`的匹配，要注意程序是有执行时间的。so如果是匹配时间戳`Instant`，若是`Instant.now()`的话，`@FutureOrPresent`就是非法的，而`@PastOrPresent`就成合法的了。但是若是日期的话比如`LocalDate.now()`就不会有这问题，毕竟你的程序不可能执行一天嘛~~~~
5.  `@NotNull`：有的人问用在基本类型（非包装类型报错吗？），很显然不会报错。因为基本类型都有默认值，不可能为null的
6.  所有的注解都能标注在：字段、方法、构造器、入参、**以及注解上**

`JSR`的注解都申明都非常的简单，没有Hibernate提供的复杂，比如没有用到`@ReportAsSingleViolation`等注解内容~为了方面，下面列出各个注解的**默认**提示消息（中文）：

javax.validation.constraints.AssertFalse.message     = 只能为false
    javax.validation.constraints.AssertTrue.message      = 只能为true
    javax.validation.constraints.DecimalMax.message      = 必须小于或等于{ value}
    javax.validation.constraints.DecimalMin.message      = 必须大于或等于{ value}
    javax.validation.constraints.Digits.message          = 数字的值超出了允许范围(只允许在{ integer}位整数和{ fraction}位小数范围内)
    javax.validation.constraints.Email.message           = 不是一个合法的电子邮件地址
    javax.validation.constraints.Future.message          = 需要是一个将来的时间
    javax.validation.constraints.FutureOrPresent.message = 需要是一个将来或现在的时间
    javax.validation.constraints.Max.message             = 最大不能超过{ value}
    javax.validation.constraints.Min.message             = 最小不能小于{ value}
    javax.validation.constraints.Negative.message        = 必须是负数
    javax.validation.constraints.NegativeOrZero.message  = 必须是负数或零
    javax.validation.constraints.NotBlank.message        = 不能为空
    javax.validation.constraints.NotEmpty.message        = 不能为空
    javax.validation.constraints.NotNull.message         = 不能为null
    javax.validation.constraints.Null.message            = 必须为null
    javax.validation.constraints.Past.message            = 需要是一个过去的时间
    javax.validation.constraints.PastOrPresent.message   = 需要是一个过去或现在的时间
    javax.validation.constraints.Pattern.message         = 需要匹配正则表达式"{regexp}"
    javax.validation.constraints.Positive.message        = 必须是正数
    javax.validation.constraints.PositiveOrZero.message  = 必须是正数或零
    javax.validation.constraints.Size.message            = 个数必须在{ min}和{ max}之间

参考文件`ValidationMessages_zh_CN.properties`，若消息不适合你，可自行定制~

###### Hibernate Validation扩展的注解 ######

<table> 
 <thead> 
  <tr> 
   <th>约束注解</th> 
   <th>支持的类型</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@URL</td> 
   <td>CharSequence</td> 
   <td>校验URL。protocol="",host="", port="", regexp=".*", flags={}</td> 
  </tr> 
  <tr> 
   <td>@UniqueElements</td> 
   <td>Collection</td> 
   <td>集合内不允许有重复元素。</td> 
  </tr> 
  <tr> 
   <td>@SafeHtml</td> 
   <td>CharSequence</td> 
   <td>传入的文本中不能含有<code>script</code>等敏感标签。（注意：需要<code>org.jsoup</code>包的支持）</td> 
  </tr> 
  <tr> 
   <td>@Range</td> 
   <td>同<code>@Min</code></td> 
   <td>是对<code>@Min</code>和<code>@Max</code>的结合补充</td> 
  </tr> 
  <tr> 
   <td>@Length</td> 
   <td>CharSequence</td> 
   <td><code>value.length() &gt;= min &amp;&amp; value.length() &lt;= max</code>（null is valid）</td> 
  </tr> 
  <tr> 
   <td>@ISBN</td> 
   <td>CharSequence</td> 
   <td>校验图书的ISBN。<code>type：Type.ISBN_13</code>（还有个取值：ISBN_10）</td> 
  </tr> 
  <tr> 
   <td>@EAN</td> 
   <td>CharSequence</td> 
   <td>校验商用条形码<code>EAN</code></td> 
  </tr> 
  <tr> 
   <td>@Currency</td> 
   <td>MonetaryAmount</td> 
   <td>校验货币。value：只允许的货币种类，如<code>USD, EUR</code>等</td> 
  </tr> 
  <tr> 
   <td>@CodePointLength</td> 
   <td>CharSequence</td> 
   <td>校验代码点<code>codePoint</code>。关于String的length和代码点，可<a href="https://bbs.csdn.net/topics/340195349" rel="nofollow">参考这里</a> 一般不使用，使用<code>@Length</code>即可~</td> 
  </tr> 
  <tr> 
   <td>@ConstraintComposition</td> 
   <td>all</td> 
   <td>所有约束是AND/OR/ALL_FALSE关系。它只能标注在注解上，运用于组合注解上</td> 
  </tr> 
  <tr> 
   <td><code>@DurationMax</code></td> 
   <td>Duration</td> 
   <td><code>maxDuration.compareTo( value )</code>这么比较的，相等也是valid的</td> 
  </tr> 
  <tr> 
   <td><code>@DurationMin</code></td> 
   <td>Duration</td> 
   <td>`minDuration.compareTo( value )这么比较的，相等也是valid的</td> 
  </tr> 
  <tr> 
   <td>@CNPJ</td> 
   <td>CharSequence</td> 
   <td>法人国家登记号</td> 
  </tr> 
 </tbody> 
</table>

说明：

1.  `@ReportAsSingleViolation`：如果`@NotEmpty`、`@Pattern`都校验失败，不添加此注解，则会生成**两个**校验失败的结果。若添加了此注解，那错误消息以它标注的本注解的`message`为准
2.  所有没有特殊说明的：`null is valid`。
3.  所有约束注解都可重复标注

各个注解的**默认**提示消息（中文）：

org.hibernate.validator.constraints.CreditCardNumber.message        = 不合法的信用卡号码
    org.hibernate.validator.constraints.Currency.message                = 不合法的货币 (必须是{ value}其中之一)
    org.hibernate.validator.constraints.EAN.message                     = 不合法的{ type}条形码
    org.hibernate.validator.constraints.Email.message                   = 不是一个合法的电子邮件地址
    org.hibernate.validator.constraints.Length.message                  = 长度需要在{ min}和{ max}之间
    org.hibernate.validator.constraints.CodePointLength.message         = 长度需要在{ min}和{ max}之间
    org.hibernate.validator.constraints.LuhnCheck.message               = ${ validatedValue}的校验码不合法, Luhn模10校验和不匹配
    org.hibernate.validator.constraints.Mod10Check.message              = ${ validatedValue}的校验码不合法, 模10校验和不匹配
    org.hibernate.validator.constraints.Mod11Check.message              = ${ validatedValue}的校验码不合法, 模11校验和不匹配
    org.hibernate.validator.constraints.ModCheck.message                = ${ validatedValue}的校验码不合法, ${ modType}校验和不匹配
    org.hibernate.validator.constraints.NotBlank.message                = 不能为空
    org.hibernate.validator.constraints.NotEmpty.message                = 不能为空
    org.hibernate.validator.constraints.ParametersScriptAssert.message  = 执行脚本表达式"{script}"没有返回期望结果
    org.hibernate.validator.constraints.Range.message                   = 需要在{ min}和{ max}之间
    org.hibernate.validator.constraints.SafeHtml.message                = 可能有不安全的HTML内容
    org.hibernate.validator.constraints.ScriptAssert.message            = 执行脚本表达式"{script}"没有返回期望结果
    org.hibernate.validator.constraints.URL.message                     = 需要是一个合法的URL

> 此处用到了`${validatedValue}`、`${modType}`是EL表达式的语法。  
> `@DurationMax`和`@DurationMin`的message消息此处未贴出，有大量的EL计算，太长了~~~

#### 总结 ####

本文值得说是深入了解数据校验（Bean Validation）了，对于数据校验的基本使用一直都不是难事，特别是在`Spring`环境下使用就更简单了~

#### 相关阅读 ####

[深入了解数据校验：Java Bean Validation 2.0（JSR303、JSR349、JSR380）Hibernate-Validation 6.x使用案例【享学Java】][Java Bean Validation 2.0_JSR303_JSR349_JSR380_Hibernate-Validation 6.x_Java]  
[让Controller支持对平铺参数执行数据校验（默认Spring MVC使用@Valid只能对JavaBean进行校验）【享学Spring】][Spring_Controller_Spring MVC_Valid_JavaBean]  
[Spring方法级别数据校验：@Validated + MethodValidationPostProcessor优雅的完成数据校验动作【享学Spring】][Spring_Validated _ MethodValidationPostProcessor_Spring]  
[Bean Validation完结篇：你必须关注的边边角角（约束级联、自定义约束、自定义校验器、国际化失败消息…）【享学Spring】][Bean Validation_Spring]

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

# 关注A哥 #

<table> 
 <thead> 
  <tr> 
   <th>Author</th> 
   <th><a href="https://www.yourbatman.cn/about" rel="nofollow">A哥(YourBatman)</a></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>个人站点</td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow">www.yourbatman.cn</a></td> 
  </tr> 
  <tr> 
   <td>E-mail</td> 
   <td>yourbatman@qq.com</td> 
  </tr> 
  <tr> 
   <td><strong>微 信</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat.png" rel="nofollow">fsx641385712</a></td> 
  </tr> 
  <tr> 
   <td><strong><code>活跃平台</code></strong></td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow"><img src="https://img-blog.csdnimg.cn/2020071015182276.png" alt=""></a> <a href="https://fangshixiang.blog.csdn.net/" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151913394.png" alt=""></a><a href="https://yourbatman.cnblogs.com" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151929355.png" alt=""></a><a href="https://juejin.im/user/5b44d178f265da0fa1220efe/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151938937.png" alt=""></a><a href="https://www.zhihu.com/people/fangshixiang/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151950629.png" alt=""></a><a href="https://www.jianshu.com/u/8740f1fdd684" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152000530.png" alt=""></a><a href="https://segmentfault.com/u/yourbatman/articles" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152008726.png" alt=""></a><a href="https://github.com/yourbatman" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152015895.png" alt=""></a></td> 
  </tr> 
  <tr> 
   <td><strong>公众号</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat_channel.jpg" rel="nofollow">BAT的乌托邦（ID：BAT-utopia）</a></td> 
  </tr> 
  <tr> 
   <td>知识星球</td> 
   <td><a href="https://t.zsxq.com/nQBi66I" rel="nofollow">BAT的乌托邦</a></td> 
  </tr> 
  <tr> 
   <td>每日文章推荐</td> 
   <td><a href="https://github.com/yourbatman/reading/issues" rel="nofollow">每日文章推荐</a></td> 
  </tr> 
 </tbody> 
</table>

![BAT的乌托邦][BAT]

[20190724195931220.png]: /images/20211126/71cd725dc40048f0a2c80d13a27674fe.png
[20190724203252242.png]: /images/20211126/8270896a98d44a9c814ae122028f0c2c.png
[20190724203946765.png]: /images/20211126/d5c9e8d1b6ae482fb08f32363b83b887.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70]: /images/20211126/79c9468644c64e3bbf4b031b3a017a0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70 1]: /images/20211126/5aac1ac6919f4c1b9415dc4540839700.png
[Spring_Controller_Spring MVC_Valid_JavaBean]: https://blog.csdn.net/f641385712/article/details/97621755
[Java Bean Validation 2.0_JSR303_JSR349_JSR380_Hibernate-Validation 6.x_Java]: https://blog.csdn.net/f641385712/article/details/96638596
[Spring_Validated _ MethodValidationPostProcessor_Spring]: https://blog.csdn.net/f641385712/article/details/97402946
[Bean Validation_Spring]: https://blog.csdn.net/f641385712/article/details/97968775
[BAT]: /images/20211126/116d1f78c483449f897afe6bc0cb7c29.png