spring-boot-starter-validation 参照文档

最新推荐文章于 2024-03-01 17:35:20 发布
最新推荐文章于 2024-03-01 17:35:20 发布
阅读量444 收藏
点赞数 11
分类专栏： spring boot 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41939901/article/details/134187516
版权

spring-boot-starter-validation 参照文档

引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

常用注解

  • NotNull
  • NotBlank
  • Max
  • Min
  • Size

大部分注解

NotNull

带注解的字段不能为null

NotEmpty

带注解的字段不能为null也不能为空

支持Map、CharSequence、Collection、Array

AssertFalse

带注解的字段必须为false

AssertTrue

带注解的字段必须为true

DecimalMax

带注解的元素必须是一个数字，其值必须小于或等于指定的最大值

支持BigDecimal、BigInteger、CharSequence，

byte、short、int、long和它们各自的包装类型

DecimalMin

带注解的元素必须是一个数字，其值必须大于或等于指定的最小值

支持BigDecimal、BigInteger、CharSequence，

byte、 short 、 int 、 long和它们各自的包装类型`

Digits

带注解的元素必须是可接受范围内的数字

支持BigDecimal、BigInteger、CharSequence，

byte、 short 、 int 、 long和它们各自的包装类型`

Email

带注解的字符串必须是格式正确的电子邮件地址
null元素被认为是有效的

Future

带注解的元素必须是未来的瞬间、日期或时间

支持的类型有：

  • java.util.Date
  • java.util.Calendar
  • java.time.Instant
  • java.time.LocalDate
  • java.time.LocalDateTime
  • java.time.LocalTime
  • java.time.MonthDay
  • java.time.OffsetDateTime
  • java.time.OffsetTime
  • java.time.Year
  • java.time.YearMonth
  • java.time.ZonedDateTime
  • java.time.chrono.HijrahDate
  • java.time.chrono.JapaneseDate
  • java.time.chrono.MinguoDate
  • java.time.chrono.ThaiBuddhistDate

Max

带注解的元素必须是一个数字，其值必须小于或等于指定的最大值。
支持的类型有：
BigDecimal
BigInteger
byte、 short、 int、 long和它们各自的包装器
请注意，由于舍入错误，不支持double和float（某些提供程序可能会提供一些近似支持）。
null元素被认为是有效的。

Min

带注解的元素必须是一个数字，其值必须大于或等于指定的最小值。

支持类型以及注意事项见第10条：Max

Negative

带注解的元素必须是严格的负数（即，0 被视为无效值）

支持的类型有：BigDecimal
BigInteger
byte、 short、 int、 long ， float， double和它们各自的包装器
null元素被认为是有效的。

NegativeOrZero

带注解的元素必须是负数或 0

支持类型见第12条：Negative

NotBlank

带注解的元素不能为null并且必须至少包含一个非空白字符。 仅支持CharSequence

Null

带注解的元素必须为null 。 接受任何类型

Past

带注解的元素必须是过去的瞬间、日期或时间

支持的类型见第9条：Future

Pattern

带注解的CharSequence必须匹配指定的正则表达式。 正则表达式遵循 Java 正则表达式约定
null元素被认为是有效的。

Positive

带注解的元素必须是严格的正数（即 0 被视为无效值）。
支持的类型见第12条：Negative

null元素被认为是有效的。

PositiveOrZero

带注解的元素必须是正数或 0。
支持的类型见第12条：Negative

null元素被认为是有效的。

Size

带注解的元素大小必须在指定边界（包括）之间。
支持的类型有：
CharSequence（评估字符序列的长度）
Collection（评估集合大小）
Map（评估Map大小）
Array（评估数组长度）
null元素被认为是有效的。

ScriptAssert

一个类级别的约束，它根据带注释的元素评估脚本表达式。 此约束可用于实现依赖于带注释元素的多个属性的验证例程。
脚本表达式可以用任何脚本或表达式语言编写，在类路径中可以找到与JSR 223 （“Java TM平台脚本”）兼容的引擎。 以下清单显示了一个使用 JDK附带的 JavaScript引擎的示例：

将真正的表达式语言与较短的对象别名结合使用可以实现非常紧凑的表达式：

注：javascript就是java

可直接调用类中方法：

公共方法：_this.methodName(params)

静态方法：com.demo.utils.ValidUtils.LocalDateTimeValid(params)

方法返回值需要布尔类型，错误消息需要指定message属性

@ScriptAssert(lang = "javascript", script = "_this.startDate.before(_this.endDate)")
 public class CalendarEvent {
 	private Date startDate;
 	private Date endDate;
 	//...
 }

@ScriptAssert(lang = "jexl", script = "_.startDate > _.endDate", alias = "_")
 public class CalendarEvent {
 	private Date startDate;
 	private Date endDate;
 	//...
 }

Length

验证字符串是否介于 min和 max之间

Range

带注解的元素必须在适当的范围内。 应用于数值或数值的字符串表示

URL

验证带注解的字符串是 URL

参数protocol 、 host和port与 URL 的相应部分匹配。 并且可以使用regexp和flags指定额外的正则表达式以进一步限制匹配条件。
注意：默认情况下，此约束的约束验证器使用java.net.URL构造函数来验证字符串。 这意味着匹配的协议处理程序需要可用

CreditCardNumber

带注解的元素必须代表一个有效的信用卡号。 这是 Luhn算法实现，旨在检查用户错误，而不是信用卡有效性

错误消息模板示例：

例如Max、Min、Range

@Max(value = 100, message = "最大不超过{value}")
@Min(value = 0, message = "最小不低于{value}")
@Range(min = 0, max = 100, message = "数值介于{min}~{max}之间")

方法参数校验使用示例：

@Validated
public class Test {
    public void test(@Min(value = 0, message = "最小不低于{value}") Integer age){}
}
public class Test {
    public void test(@RequestBody @Valid User user){}
}

嵌套校验示例：

@Valid
private User user;

分组校验示例：

public interface CreateGroup {}
public interface UpdateGroup {}
public class TestDto {
    @Max(value = 100, groups = {CreateGroup.class}, message = "最大不超过{value}")
    @Min(value = 0, groups = {UpdateGroup.class}, message = "最小不低于{value}")
    private Integer age;
}
public class Test {
    public void test1(@RequestBody @Validated({CreateGroup.class}) TestDto dto){}
    public void test2(@RequestBody @Validated({UpdateGroup.class}) TestDto dto){}
}
// 注解Valid与Validated可以混用
// Validated是Valid的变体
// Valid不支持分组校验

手动触发校验

//注入javax.validation.Validator
@Autowired
private Validator validator;

public void valid(TestDto dto, Class<?> groupClass) {
    Set<ConstraintViolation<TestDto>> validateSet = validator.validate(dto, groupClass);
    if(validateSet.isEmpty()) {
        // 校验通过
        return;
    }
    // 校验失败
    for(ConstraintViolation<TestDto> validate: validateSet) {
        System.out.println(validate);
    }
}

Spring boot配置校验快速失败模式

// 快速失败即校验到一个不符合条件就结束了
@Bean
public Validator validator() {
    ValidatorFactory validatorFactory = Validation.byProvider(HibernateValidator.class)
            .configure()
            // 快速失败模式
            .failFast(true)
            .buildValidatorFactory();
    return validatorFactory.getValidator();
}

RequestBody校验实现原理

可以看看org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor。

其中方法resolveArgument

@Override
	public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
         // 将数据封装到参数对象中
		parameter = parameter.nestedIfOptional();
		Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
		String name = Conventions.getVariableNameForParameter(parameter);

		if (binderFactory != null) {
			WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
			if (arg != null) {
                 // 参数校验
				validateIfApplicable(binder, parameter);
				if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
					throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
				}
			}
			if (mavContainer != null) {
				mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
			}
		}

		return adaptArgumentIfNecessary(arg, parameter);
	}
protected void validateIfApplicable(WebDataBinder binder, MethodParameter parameter) {
		Annotation[] annotations = parameter.getParameterAnnotations();
		for (Annotation ann : annotations) {
			Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class);
             // 如果有Validated注解或者Valid开头的注解则开始校验
			if (validatedAnn != null || ann.annotationType().getSimpleName().startsWith("Valid")) {
				Object hints = (validatedAnn != null ? validatedAnn.value() : AnnotationUtils.getValue(ann));
				Object[] validationHints = (hints instanceof Object[] ? (Object[]) hints : new Object[] {hints});
				binder.validate(validationHints);
				break;
			}
		}
	}
// WebDataBinder.validate实现
public void validate(Object target, Errors errors, Object... validationHints) {
		if (this.targetValidator != null) {
			processConstraintViolations(
                      // 调用Hibernate Validator执行真正的校验
					this.targetValidator.validate(target, asValidationGroups(validationHints)), errors);
		}
	}

方法参数校验实现原理

实现原理其实就是AOP，这种方式实际上可以作用与任何spring bean

可以看看org.springframework.validation.beanvalidation.MethodValidationPostProcessor

public class MethodValidationPostProcessor extends AbstractBeanFactoryAwareAdvisingPostProcessor
		implements InitializingBean {
    private Class<? extends Annotation> validatedAnnotationType = Validated.class;
	@Override
	public void afterPropertiesSet() {
         // 为所有`@Validated`标注的Bean创建切面
		Pointcut pointcut = new AnnotationMatchingPointcut(this.validatedAnnotationType, true);
         // 创建Advisor进行增强
		this.advisor = new DefaultPointcutAdvisor(pointcut, createMethodValidationAdvice(this.validator));
	}
	/**
	 * Create AOP advice for method validation purposes, to be applied
	 * with a pointcut for the specified 'validated' annotation.
	 * @param validator the JSR-303 Validator to delegate to
	 * @return the interceptor to use (typically, but not necessarily,
	 * a {@link MethodValidationInterceptor} or subclass thereof)
	 * @since 4.2
	 */
	protected Advice createMethodValidationAdvice(@Nullable Validator validator) {
		return (validator != null ? new MethodValidationInterceptor(validator) : new MethodValidationInterceptor());
	}

}

public class MethodValidationInterceptor implements MethodInterceptor {
	@Override
	@Nullable
	public Object invoke(MethodInvocation invocation) throws Throwable {
		// Avoid Validator invocation on FactoryBean.getObjectType/isSingleton
		if (isFactoryBeanMetadataMethod(invocation.getMethod())) {
			return invocation.proceed();
		}
        // 分组
		Class<?>[] groups = determineValidationGroups(invocation);

		// Standard Bean Validation 1.1 API
		ExecutableValidator execVal = this.validator.forExecutables();
		Method methodToValidate = invocation.getMethod();
		Set<ConstraintViolation<Object>> result;

		Object target = invocation.getThis();
		Assert.state(target != null, "Target must not be null");

		try {
            // 方法入参校验
			result = execVal.validateParameters(target, methodToValidate, invocation.getArguments(), groups);
		}
		catch (IllegalArgumentException ex) {
			// Probably a generic type mismatch between interface and impl as reported in SPR-12237 / HV-1011
			// Let's try to find the bridged method on the implementation class...
			methodToValidate = BridgeMethodResolver.findBridgedMethod(
					ClassUtils.getMostSpecificMethod(invocation.getMethod(), target.getClass()));
			result = execVal.validateParameters(target, methodToValidate, invocation.getArguments(), groups);
		}
        // 校验不通过抛出异常
		if (!result.isEmpty()) {
			throw new ConstraintViolationException(result);
		}

		Object returnValue = invocation.proceed();

        // 返回值的校验
		result = execVal.validateReturnValue(target, methodToValidate, returnValue, groups);
        // 校验不通过抛出异常
		if (!result.isEmpty()) {
			throw new ConstraintViolationException(result);
		}

		return returnValue;
	}

	private boolean isFactoryBeanMetadataMethod(Method method) {
		Class<?> clazz = method.getDeclaringClass();

		// Call from interface-based proxy handle, allowing for an efficient check?
		if (clazz.isInterface()) {
			return ((clazz == FactoryBean.class || clazz == SmartFactoryBean.class) &&
					!method.getName().equals("getObject"));
		}

		// Call from CGLIB proxy handle, potentially implementing a FactoryBean method?
		Class<?> factoryBeanType = null;
		if (SmartFactoryBean.class.isAssignableFrom(clazz)) {
			factoryBeanType = SmartFactoryBean.class;
		}
		else if (FactoryBean.class.isAssignableFrom(clazz)) {
			factoryBeanType = FactoryBean.class;
		}
		return (factoryBeanType != null && !method.getName().equals("getObject") &&
				ClassUtils.hasMethod(factoryBeanType, method));
	}

	/**
	 * Determine the validation groups to validate against for the given method invocation.
	 * <p>Default are the validation groups as specified in the {@link Validated} annotation
	 * on the containing target class of the method.
	 * @param invocation the current MethodInvocation
	 * @return the applicable validation groups as a Class array
	 */
	protected Class<?>[] determineValidationGroups(MethodInvocation invocation) {
		Validated validatedAnn = AnnotationUtils.findAnnotation(invocation.getMethod(), Validated.class);
		if (validatedAnn == null) {
			Object target = invocation.getThis();
			Assert.state(target != null, "Target must not be null");
			validatedAnn = AnnotationUtils.findAnnotation(target.getClass(), Validated.class);
		}
		return (validatedAnn != null ? validatedAnn.value() : new Class<?>[0]);
	}

}

不管是requestBody参数校验还是方法参数校验，最终都是调用的Hibernate Validator。

闲谈

上述都是以注解的形式对入参进行校验，我们也可以自己书写校验的方法然同样的可以达到目的。
对于一些业务逻辑本文章介绍的校验可能并不太适用。
个人建议是使用注解的形式来校验空参即可，其余的校验我们自己书写校验的方法在业务方法开始之前调用即可。

逆水行舟x
关注
  • 11
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot 使用validation数据校验-超级详细 - 第406篇
悟纤学院
12-13 7434
相关历史文章（阅读本文前，您可能需要先看下之前的系列????） 国内最全的SpringBoot系列之四 享元模式：共享女友-第355篇 SpringBoot有没有学明白，就看你这些面试题是否懂？- 第389篇 Spring Boot CLI你知多少？- 第394篇 创建一个 Spring Boot 项目的4种方法，你会几种？- 第396篇 Spring Boot 项目中的 parent原来还有这么多的讲究 - 第398篇 Spring Boot条件注解 - 第400篇 SpringBoo..
spring-boot-starter-validation常用注解
m0_51390969的博客
01-26 676
通过使用分组校验，你可以为同一个对象的不同操作设置不同的验证规则，这在复杂应用中非常有用。这种方法提高了代码的灵活性和可维护性。
Springboot - 14.spring-boot-starter-validation集成
yueerba126的博客
09-04 468
作用：当内置的验证注解不满足特定需求时，可以创建自定义的验证注解和验证器。使用场景：例如，验证密码复杂性或验证字符串是否符合特定的业务规则。示例：创建一个注解来验证密码的复杂性。创建注解：Class
【SpringBoot框架篇】26.集成spring-boot-starter-validation对接口参数校验
皓亮君的博客
05-15 1628
文章目录1.常规验证2.使用validation验证2.1.添加依赖2.2.常用注解2.3.在pojo类中添加需要使用的注解2.4.在接口入参处添加@Valid2.5.添加全局异常处理类返回校验错位提示信息 1.常规验证 以下面的登录接口为例,需要手动去验证参数是否存在,这种写法繁琐且不太优雅。 @RestController public class LoginController { @RequestMapping("/login") public String test(@Reque
spring boot validation使用
ityqing的博客
11-13 1311
是 Spring Boot 中用于支持数据验证的模块。它建立在 Java Validation API（JSR-380）之上，提供了一种方便的方式来验证应用程序中的数据。以下是使用。
Java：SpringBoot整合spring-boot-starter-validation实现自定义入参数据校验
彭世瑜的博客
06-18 495
本文通过简单的代码，实现validation自定义数据校验器。validation依赖。测试用例及其结果如下。
spring-boot 整合 spring-boot-starter-validation 参数校验（文末有彩蛋）
最新发布
qq_37220802的博客
03-01 962
Spring Validation 验证框架对参数的验证机制提供了 @Validated（Spring’s JSR-303 规范，是标准 JSR-303 的一个变种），javax 提供了 @Valid（标准 JSR-303 规范），配合 BindingResult 可以直接提供参数验证结果。其中对于字段的特定验证注解比如 @NotNull 等网上到处都有，这里不详述校验 Controller 的入参是否符合规范时，使用 @Validated 或者 @Valid 在基本验证功能上没有太多区别。
spring-boot-starter-validation-1.3.0.RELEASE.jar
02-27
java运行依赖jar包
spring-boot-starter-validation-2.2.2.RELEASE.jar
02-27
java运行依赖jar包
spring-boot-starter-validation-1.3.5.RELEASE.zip
09-25
odelay.zip,提供延迟执行操作的灵长类动物延迟反应
2020最新-Spring Boot Validation 看这篇就够了.pdf
08-22
2020年最新Spring Boot Validation讲透讲全，别找其他的了。包括了平时用到的所有用法以及代码实例。
Bean Validation 规范文档
03-31
Bean Validation 规范文档
spring-boot-starter-validation-1.3.3.RELEASE.jar
02-27
java运行依赖jar包
spring-boot-starter-validation-2.2.4.RELEASE.jar
02-27
java运行依赖jar包
SpringBoot 使用 Validation 数据校验，自定义校验
qq_35850889的博客
09-21 2267
SpringBoot 使用 Validation 数据校验，自定义校验，异常捕获
Spring官方文档（中文版！！！）
热门推荐
li1376417539的博客
03-18 8万+
本文档是对spring官方文档的解读，原文档参见Spring官方文档 ，本人只是翻译和整理，由于水平有限，部分解读可能不正确，欢迎提出更好的意见和建议或者与我一起完成本次挑战！网页版移步我的临时网页 Git传送门 1 Spring综述 1.1 jdk环境依赖 从Spring Framework 5.1开始，Spring需要JDK 8+ (Java SE 8+)，并提供对JDK 11 LTS的开箱...
Spring Boot 参数校验 Validation 入门
茅坤宝骏氹的博客
05-10 5986
转载自芋道 Spring Boot 参数校验 Validation 入门 本文在提供完整代码示例，可见 https://github.com/YunaiV/SpringBoot-Labs 的 lab-22 目录。 原创不易，给点个 Star 嘿，一起冲鸭！ 1. 概述 在想标题的时候，到底应该叫数据校验，还是参数校验时，我纠结了，而且非常。 最后，考虑参数校验更贴近我们的理解，就选择了它。实际更合适的叫法，还是数据校验。 文头艿艿瞎哔哔了一些碎碎念，嫌弃的胖友，可以跳往 「3. 快速入门.
使用spring-boot-starter-validation做参数校验
日有寸进
06-26 1万+
使用spring-boot-starter-validation做参数校验添加依赖新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图...
各Spring-Boot-Starters介绍
SolidCocoi的博客
12-14 1万+
Spring-Boot-Starters 最通俗的理解— jar 包，引用了什么 starter，就获得了什么的依赖。用游戏类比： SpringBoot—&amp;gt;WeGame spring-boot-starter-web—&amp;gt;英雄联盟及其小工具的合集 SpringMVC—&amp;gt;包含在spring-boot-starter-web 的小工具，类比可理解为 英雄联盟 里的录屏助手 (...
spring-boot-starter-validation版本
09-03
根据提供的引用内容，无法确定Spring Boot Starter Validation的版本号。引用提到了校验包被独立成了一个starter组件，但没有提到具体的版本号。引用提到了Spring Boot 2.0及以上版本最低支持Java 8，但没有提及...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值