专栏首页BAT的乌托邦深入了解数据校验(Bean Validation):从深处去掌握@Valid的作用(级联校验)以及常用约束注解的解释说明【享学Java】

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

前言

关于Bean Validation的基本原理篇完结之后,接下来就是小伙伴最为关心的干货:使用篇。 如果说要使用Bean Validation数据校验,我十分相信小伙伴们都能够使用,但估计大都是有个前提的:Spring MVC环境。我极其简单的调查了一下,近乎99%的人都是只把数据校验使用在Spring MVCController层面的,而且几乎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;
	... // 它自己并不处理什么逻辑,参数都是通过构造器传进来的
}

它的继承树:

三个实现类对应着上面所述的三种元数据类型。本文很显然只需要关注和注解相关的: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一个,调用栈如下图:
  1. 调用Validator.validate()方法的时候,beanMetaDataManager.getBeanMetaData( rootBeanClass )它会遍历初始化时所有的metaDataProviders(默认情况下两个,没有xml方式的),拿出所有的BeanConfiguration交给BeanMetaDataBuilder,最终构建出一个属于此Bean的BeanMetaData。对此有一点注意事项描述如下: 1. 处理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 )
  1. 拿到本类所有字段Fieldclazz.getDeclaredFields()
  2. 把每个Field都包装成ConstrainedElement存放起来~~~ 1. 注意:此步骤完成了对每个Field上标注的注解进行了保存
检索Method:getMethodMetaData( beanClass )
  1. 拿到本类所有的方法Methodclazz.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进行校验)

级联校验

什么叫级联校验,其实就是带校验的成员里存在级联对象时,也要对它完成校验。这个在实际应用场景中是比较常见的,比如入参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标准注解

约束注解

支持的类型

说明

@AssertFalse

Boolean,boolean

元素值必须是false

@AssertTrue

Boolean,boolean

元素值必须是true

@DecimalMax

BigDecimal,BigInteger, byte,short, int, long,等任何Number或CharSequence(存储的是数字)

value:数值上限 inclusive:是否包含此上限,默认true是包含的

@DecimalMin

同上

不解释

@Max

同上

值=max,也是校验通过的

@Min

同上

不解释

@Digits

同上

integer:整数位数上限 fraction:小数位数上限

@Positive

同上

2.0。必须是严格的正数。0都不行~

@PositiveOrZero

同上

2.0。 0是被允许的

@Negative

同上

2.0。 必须是严格的负数。0都不行

@NegativeOrZero

同上

2.0。 0是被允许的

@Email

CharSequence子类型(如String)

2.0。值是否是Email,也可以通过regexp和flag指定自定义的email格式

@Future

Date、Calendar及所有JSR 310时间类

是否是将来时间(若是这种LocalTime.now()取当前的,都会是false哦~)

@FutureOrPresent

同上

2.0。和上面的区别是now也行~

@Past

同上

不解释

@PastOrPresent

同上

2.0。不解释

@NotBlank

CharSequence子类型(如String)

2.0。规则为.trim().length() > 0(注意:null is not valid)

@NotEmpty

CharSequence子类型、Collection、Map、数组

2.0。长度/size大小>0(注意:null is not valid)

@Size

CharSequence子类型、Collection、Map、数组

2.0。min:最小值 max:最大值。(注意:边界值是包含的。null is valid哦~~)

@NotNull

所有类型

不解释

@Null

所有类型

不解释

@Pattern

CharSequence子类型(如String)

是否满足此正则表达式。regexp:正则。flags:模式

@Valid

非原子类型

级联属性校验

说明:

  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扩展的注解

约束注解

支持的类型

说明

@URL

CharSequence

校验URL。protocol="",host="", port="", regexp=".*", flags={}

@UniqueElements

Collection

集合内不允许有重复元素。

@SafeHtml

CharSequence

传入的文本中不能含有script等敏感标签。(注意:需要org.jsoup包的支持)

@Range

同@Min

是对@Min和@Max的结合补充

@Length

CharSequence

value.length() >= min && value.length() <= max(null is valid)

@ISBN

CharSequence

校验图书的ISBN。type:Type.ISBN_13(还有个取值:ISBN_10)

@EAN

CharSequence

校验商用条形码EAN

@Currency

MonetaryAmount

校验货币。value:只允许的货币种类,如USD, EUR等

@CodePointLength

CharSequence

校验代码点codePoint。关于String的length和代码点,可参考这里 一般不使用,使用@Length即可~

@ConstraintComposition

all

所有约束是AND/OR/ALL_FALSE关系。它只能标注在注解上,运用于组合注解上

@DurationMax

Duration

maxDuration.compareTo( value )这么比较的,相等也是valid的

@DurationMin

Duration

`minDuration.compareTo( value )这么比较的,相等也是valid的

@CNPJ

CharSequence

法人国家登记号

说明:

  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环境下使用就更简单了~

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • SpringMVC学习

    Spring MVC是一个基于MVC架构的用来简化web应用程序开发的应用开发框架,它是Spring的一部分,它和Struts2一样都属于表现层的框架。

    杨肆月
  • 不管你是开发还是运维,微服务这些你得知道!

    这几年在Java工程师招聘时,会看到很多人的简历都写着使用了Spring Cloud做微服务实现,使用Docker做自动化部署,并且也会把这些做为自己的亮点。而...

    kubernetes中文社区
  • Spring与后端模板引擎的故事

    现在很多开发,都采用了前后端完全分离的模式,随着近几年前端工程化工具和MVC框架的完善,使得这种模式的维护成本逐渐降低。但是这种模式目前并不利于SEO(前后端分...

    全菜工程师小辉
  • Java描述设计模式(07):适配器模式

    缺省(接口)适配(Default Adapter)模式为一个接口提供缺省实现,这样子类型可以从这个缺省实现进行扩展,而不必从原有接口进行扩展。

    知了一笑
  • SSH架构/spring-security安全认证/LDAP账号打通

    参考:https://blog.csdn.net/shan9liang/article/details/8803989

    杨肆月
  • 快速理解Java的三种代理模式

    代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式,即通过代理对象访问目标对象。这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即...

    全菜工程师小辉
  • SpringIoC和SpringMVC的快速入门

    IoC和AOP是Spring框架的两大特性,IoC和MVC的流程密不可分,可以看作是面向对象编程的实现;而AOP特性则是面向切面编程的体现,也是前者的补充,所以...

    全菜工程师小辉
  • 那些年,我们见过的 Java 服务端乱象

    移动互联网的快速发展,出现了许多新机遇,很多创业者伺机而动;随着行业竞争加剧,互联网红利逐渐消失,很多创业公司九死一生。笔者在初创公司摸爬滚打数年,接触了各式各...

    JAVA葵花宝典
  • Spring Boot 自定义事件

    系统启动时,执行顺序为:application starting > application prepared > application ready

    吟风者
  • 快速了解Java线程池

    还有很多其他的方法:比如:getQueue() 、getPoolSize() 、getActiveCount()、getCompletedTaskCount()...

    全菜工程师小辉

扫码关注云+社区

领取腾讯云代金券