如何使用SpringBoot进行优雅的数据验证

2023-07-10 21:27:04 89

JSR-303规范

在程序进行数据处理之前，对数据进行准确性校验是我们必须要考虑的事情。尽早发现数据错误，不仅可以防止错误向核心业务逻辑蔓延，而且这种错误非常明显，容易发现解决。

JSR303规范（BeanValidation规范）为JavaBean验证定义了相应的元数据模型和API。在应用程序中，通过使用BeanValidation或是你自己定义的constraint，例如@NotNull,@Max,@ZipCode，就可以确保数据模型（JavaBean）的正确性。constraint可以附加到字段，getter方法，类或者接口上面。对于一些特定的需求，用户可以很容易的开发定制化的constraint。BeanValidation是一个运行时的数据验证框架，在验证之后验证的错误信息会被马上返回。

关于JSR303–BeanValidation规范，可以参考官网

对于JSR303规范，HibernateValidator对其进行了参考实现.HibernateValidator提供了JSR303规范中所有内置constraint的实现，除此之外还有一些附加的constraint。如果想了解更多有关HibernateValidator的信息，请查看官网。

Constraint	详细信息
@AssertFalse	被注释的元素必须为false
@AssertTrue	同@AssertFalse
@DecimalMax	被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@DecimalMin	同DecimalMax
@Digits	带批注的元素必须是一个在可接受范围内的数字
@Email	顾名思义
@Future	将来的日期
@FutureOrPresent	现在或将来
@Max	被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@Min	被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@Negative	带注释的元素必须是一个严格的负数（0为无效值）
@NegativeOrZero	带注释的元素必须是一个严格的负数（包含0）
@NotBlank	同StringUtils.isNotBlank
@NotEmpty	同StringUtils.isNotEmpty
@NotNull	不能是Null
@Null	元素是Null
@Past	被注释的元素必须是一个过去的日期
@PastOrPresent	过去和现在
@Pattern	被注释的元素必须符合指定的正则表达式
@Positive	被注释的元素必须严格的正数（0为无效值）
@PositiveOrZero	被注释的元素必须严格的正数（包含0）
@Szie	带注释的元素大小必须介于指定边界（包括）之间

HibernateValidator附加的constraint

Constraint	详细信息
@Email	被注释的元素必须是电子邮箱地址
@Length	被注释的字符串的大小必须在指定的范围内
@NotEmpty	被注释的字符串的必须非空
@Range	被注释的元素必须在合适的范围内
CreditCardNumber	被注释的元素必须符合信用卡格式

HibernateValidator不同版本附加的Constraint可能不太一样，具体还需要你自己查看你使用版本。Hibernate提供的Constraint在org.hibernate.validator.constraints这个包下面。

一个constraint通常由annotation和相应的constraintvalidator组成，它们是一对多的关系。也就是说可以有多个constraintvalidator对应一个annotation。在运行时，BeanValidation框架本身会根据被注释元素的类型来选择合适的constraintvalidator对数据进行验证。

有些时候，在用户的应用中需要一些更复杂的constraint。BeanValidation提供扩展constraint的机制。可以通过两种方法去实现，一种是组合现有的constraint来生成一个更复杂的constraint，另外一种是开发一个全新的constraint。

使用SpringBoot进行数据校验

SpringValidation对hibernatevalidation进行了二次封装，可以让我们更加方便地使用数据校验功能。这边我们通过SpringBoot来引用校验功能。

如果你用的SpringBoot版本小于2.3.x，spring-boot-starter-web会自动引入hibernate-validator的依赖。如果SpringBoot版本大于2.3.x，则需要手动引入依赖：


org.hibernate
hibernate-validator
6.0.1.Final

直接参数校验

有时候接口的参数比较少，只有一个活着两个参数，这时候就没必要定义一个DTO来接收参数，可以直接接收参数。

@Validated
@RestController
@RequestMapping("/user")
publicclassUserController{

privatestaticLoggerlogger=LoggerFactory.getLogger(UserController.class);

@GetMapping("/getUser")
@ResponseBody
//注意：如果想在参数中使用@NotNull这种注解校验，就必须在类上添加@Validated；
publicUserDTOgetUser(@NotNull(message="userId不能为空")IntegeruserId){
logger.info("userId:[{}]",userId);
UserDTOres=newUserDTO();
res.setUserId(userId);
res.setName("程序员自由之路");
res.setAge(8);
returnres;
}
}

下面是统一异常处理类

@RestControllerAdvice
publicclassGlobalExceptionHandler{

privatestaticfinalLoggerlogger=LoggerFactory.getLogger(GlobalExceptionHandler.class);

@ExceptionHandler(value=ConstraintViolationException.class)
publicResponsehandle1(ConstraintViolationExceptionex){
StringBuildermsg=newStringBuilder();
Set>constraintViolations=ex.getConstraintViolations();
for(ConstraintViolationconstraintViolation:constraintViolations){
PathImplpathImpl=(PathImpl)constraintViolation.getPropertyPath();
StringparamName=pathImpl.getLeafNode().getName();
Stringmessage=constraintViolation.getMessage();
msg.append("[").append(message).append("]");
}
logger.error(msg.toString(),ex);
//注意：Response类必须有get和set方法，不然会报错
returnnewResponse(RCode.PARAM_INVALID.getCode(),msg.toString());
}

@ExceptionHandler(value=Exception.class)
publicResponsehandle1(Exceptionex){
logger.error(ex.getMessage(),ex);
returnnewResponse(RCode.ERROR.getCode(),RCode.ERROR.getMsg());
}
}

调用结果

#这里没有传userId
GEThttp://127.0.0.1:9999/user/getUser

HTTP/1.1200
Content-Type:application/json
Transfer-Encoding:chunked
Date:Sat,14Nov202007:35:44GMT
Keep-Alive:timeout=60
Connection:keep-alive

{
"rtnCode":"1000",
"rtnMsg":"[userId不能为空]"
}

实体类DTO校验

定义一个DTO

importorg.hibernate.validator.constraints.Range;
importjavax.validation.constraints.NotEmpty;

publicclassUserDTO{

privateIntegeruserId;

@NotEmpty(message="姓名不能为空")
privateStringname;
@Range(min=18,max=50,message="年龄必须在18和50之间")
privateIntegerage;
//省略get和set方法
}

接收参数时使用@Validated进行校验

@PostMapping("/saveUser")
@ResponseBody
//注意：如果方法中的参数是对象类型，则必须要在参数对象前面添加@Validated
publicResponsegetUser(@Validated@RequestBodyUserDTOuserDTO){
userDTO.setUserId(100);
Responseresponse=Response.success();
response.setData(userDTO);
returnresponse;
}

统一异常处理

@ExceptionHandler(value=MethodArgumentNotValidException.class)
publicResponsehandle2(MethodArgumentNotValidExceptionex){
BindingResultbindingResult=ex.getBindingResult();
if(bindingResult!=null){
if(bindingResult.hasErrors()){
FieldErrorfieldError=bindingResult.getFieldError();
Stringfield=fieldError.getField();
StringdefaultMessage=fieldError.getDefaultMessage();
logger.error(ex.getMessage(),ex);
returnnewResponse(RCode.PARAM_INVALID.getCode(),field+":"+defaultMessage);
}else{
logger.error(ex.getMessage(),ex);
returnnewResponse(RCode.ERROR.getCode(),RCode.ERROR.getMsg());
}
}else{
logger.error(ex.getMessage(),ex);
returnnewResponse(RCode.ERROR.getCode(),RCode.ERROR.getMsg());
}
}

调用结果

###创建用户
POSThttp://127.0.0.1:9999/user/saveUser
Content-Type:application/json

{
"name1":"程序员自由之路",
"age":"18"
}

#下面是返回结果
{
"rtnCode":"1000",
"rtnMsg":"姓名不能为空"
}

对Service层方法参数校验

个人不太喜欢这种校验方式，一半情况下调用service层方法的参数都需要在controller层校验好，不需要再校验一次。这边列举这个功能，只是想说Spring也支持这个。

@Validated
@Service
publicclassValidatorService{

	privatestaticfinalLoggerlogger=LoggerFactory.getLogger(ValidatorService.class);

	publicStringshow(@NotNull(message="不能为空")@Min(value=18,message="最小18")Stringage){
		logger.info("age={}",age);
		returnage;
	}

}

分组校验

有时候对于不同的接口，需要对DTO进行不同的校验规则。还是以上面的UserDTO为列，另外一个接口可能不需要将age限制在18～50之间，只需要大于18就可以了。

这样上面的校验规则就不适用了。分组校验就是来解决这个问题的，同一个DTO，不同的分组采用不同的校验策略。

publicclassUserDTO{

publicinterfaceDefault{
}

publicinterfaceGroup1{
}

privateIntegeruserId;
//注意：@Validated注解中加上groups属性后,DTO中没有加group属性的校验规则将失效
@NotEmpty(message="姓名不能为空",groups=Default.class)
privateStringname;

//注意：加了groups属性之后，必须在@Validated注解中也加上groups属性后，校验规则才能生效，不然下面的校验限制就失效了
@Range(min=18,max=50,message="年龄必须在18和50之间",groups=Default.class)
@Range(min=17,message="年龄必须大于17",groups=Group1.class)
privateIntegerage;
}

使用方式

@PostMapping("/saveUserGroup")
@ResponseBody
//注意：如果方法中的参数是对象类型，则必须要在参数对象前面添加@Validated
//进行分组校验，年龄满足大于17
publicResponsesaveUserGroup(@Validated(value={UserDTO.Group1.class})@RequestBodyUserDTOuserDTO){
userDTO.setUserId(100);
Responseresponse=Response.success();
response.setData(userDTO);
returnresponse;
}

使用Group1分组进行校验，因为DTO中，Group1分组对name属性没有校验，所以这个校验将不会生效。

分组校验的好处是可以对同一个DTO设置不同的校验规则，缺点就是对于每一个新的校验分组，都需要重新设置下这个分组下面每个属性的校验规则。

分组校验还有一个按顺序校验功能。

考虑一种场景：一个bean有1个属性（假如说是attrA），这个属性上添加了3个约束（假如说是@NotNull、@NotEmpty、@NotBlank）。默认情况下，validation-api对这3个约束的校验顺序是随机的。也就是说，可能先校验@NotNull，再校验@NotEmpty，最后校验@NotBlank，也有可能先校验@NotBlank，再校验@NotEmpty，最后校验@NotNull。

那么，如果我们的需求是先校验@NotNull，再校验@NotBlank，最后校验@NotEmpty。@GroupSequence注解可以实现这个功能。

publicclassGroupSequenceDemoForm{

@NotBlank(message="至少包含一个非空字符",groups={First.class})
@Size(min=11,max=11,message="长度必须是11",groups={Second.class})
privateStringdemoAttr;

publicinterfaceFirst{

}

publicinterfaceSecond{

}

@GroupSequence(value={First.class,Second.class})
publicinterfaceGroupOrderedOne{
//先计算属于First组的约束，再计算属于Second组的约束
}


@GroupSequence(value={Second.class,First.class})
publicinterfaceGroupOrderedTwo{
//先计算属于Second组的约束，再计算属于First组的约束
}

}

使用方式

//先计算属于First组的约束，再计算属于Second组的约束
@Validated(value={GroupOrderedOne.class})@RequestBodyGroupSequenceDemoFormform

嵌套校验

前面的示例中，DTO类里面的字段都是基本数据类型和String等类型。

但是实际场景中，有可能某个字段也是一个对象，如果我们需要对这个对象里面的数据也进行校验，可以使用嵌套校验。

假如UserDTO中还用一个Job对象,比如下面的结构。需要注意的是，在job类的校验上面一定要加上@Valid注解。

publicclassUserDTO1{

privateIntegeruserId;
@NotEmpty
privateStringname;
@NotNull
privateIntegerage;
@Valid
@NotNull
privateJobjob;

publicIntegergetUserId(){
returnuserId;
}

publicvoidsetUserId(IntegeruserId){
this.userId=userId;
}

publicStringgetName(){
returnname;
}

publicvoidsetName(Stringname){
this.name=name;
}

publicIntegergetAge(){
returnage;
}

publicvoidsetAge(Integerage){
this.age=age;
}

publicJobgetJob(){
returnjob;
}

publicvoidsetJob(Jobjob){
this.job=job;
}

/**
*这边必须设置成静态内部类
*/
staticclassJob{
@NotEmpty
privateStringjobType;
@DecimalMax(value="1000.99")
privateDoublesalary;

publicStringgetJobType(){
returnjobType;
}

publicvoidsetJobType(StringjobType){
this.jobType=jobType;
}

publicDoublegetSalary(){
returnsalary;
}

publicvoidsetSalary(Doublesalary){
this.salary=salary;
}
}

}

使用方式

@PostMapping("/saveUserWithJob")
@ResponseBody
publicResponsesaveUserWithJob(@Validated@RequestBodyUserDTO1userDTO){
userDTO.setUserId(100);
Responseresponse=Response.success();
response.setData(userDTO);
returnresponse;
}

测试结果

POSThttp://127.0.0.1:9999/user/saveUserWithJob
Content-Type:application/json

{
"name":"程序员自由之路",
"age":"16",
"job":{
"jobType":"1",
"salary":"9999.99"
}
}

{
"rtnCode":"1000",
"rtnMsg":"job.salary:必须小于或等于1000.99"
}

嵌套校验可以结合分组校验一起使用。还有就是嵌套集合校验会对集合里面的每一项都进行校验，例如List字段会对这个list里面的每一个Job对象都进行校验。这个点
在下面的@Valid和@Validated的区别章节有详细讲到。

集合校验

如果请求体直接传递了json数组给后台，并希望对数组中的每一项都进行参数校验。此时，如果我们直接使用java.util.Collection下的list或者set来接收数据，参数校验并不会生效！我们可以使用自定义list集合来接收参数：

包装List类型，并声明@Valid注解

publicclassValidationListimplementsList{

//@Delegate是lombok注解
//本来实现List接口需要实现一系列方法，使用这个注解可以委托给ArrayList实现
//@Delegate
@Valid
publicListlist=newArrayList<>();


@Override
publicintsize(){
returnlist.size();
}

@Override
publicbooleanisEmpty(){
returnlist.isEmpty();
}

@Override
publicbooleancontains(Objecto){
returnlist.contains(o);
}
//....下面省略一系列List接口方法，其实都是调用了ArrayList的方法
}

调用方法

@PostMapping("/batchSaveUser")
@ResponseBody
publicResponsebatchSaveUser(@Validated(value=UserDTO.Default.class)@RequestBodyValidationListuserDTOs){
returnResponse.success();
}

调用结果

Causedby:org.springframework.beans.NotReadablePropertyException:Invalidproperty'list[1]'ofbeanclass[com.csx.demo.spring.boot.dto.ValidationList]:Beanproperty'list[1]'isnotreadableorhasaninvalidgettermethod:Doesthereturntypeofthegettermatchtheparametertypeofthesetter?
atorg.springframework.beans.AbstractNestablePropertyAccessor.getPropertyValue(AbstractNestablePropertyAccessor.java:622)~[spring-beans-5.2.6.RELEASE.jar:5.2.6.RELEASE]
atorg.springframework.beans.AbstractNestablePropertyAccessor.getNestedPropertyAccessor(AbstractNestablePropertyAccessor.java:839)~[spring-beans-5.2.6.RELEASE.jar:5.2.6.RELEASE]
atorg.springframework.beans.AbstractNestablePropertyAccessor.getPropertyAccessorForPropertyPath(AbstractNestablePropertyAccessor.java:816)~[spring-beans-5.2.6.RELEASE.jar:5.2.6.RELEASE]
atorg.springframework.beans.AbstractNestablePropertyAccessor.getPropertyValue(AbstractNestablePropertyAccessor.java:610)~[spring-beans-5.2.6.RELEASE.jar:5.2.6.RELEASE]

会抛出NotReadablePropertyException异常，需要对这个异常做统一处理。这边代码就不贴了。

自定义校验器

在Spring中自定义校验器非常简单，分两步走。

自定义约束注解

@Target({METHOD,FIELD,ANNOTATION_TYPE,CONSTRUCTOR,PARAMETER})
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy={EncryptIdValidator.class})
public@interfaceEncryptId{

//默认错误消息
Stringmessage()default"加密id格式错误";

//分组
Class[]groups()default{};

//负载
Class[]payload()default{};
}

实现ConstraintValidator接口编写约束校验器

publicclassEncryptIdValidatorimplementsConstraintValidator{

privatestaticfinalPatternPATTERN=Pattern.compile("^[a-f\\d]{32,256}$");

@Override
publicbooleanisValid(Stringvalue,ConstraintValidatorContextcontext){
//不为null才进行校验
if(value!=null){
Matchermatcher=PATTERN.matcher(value);
returnmatcher.find();
}
returntrue;
}
}

编程式校验

上面的示例都是基于注解来实现自动校验的，在某些情况下，我们可能希望以编程方式调用验证。这个时候可以注入
javax.validation.Validator对象，然后再调用其api。

@Autowired
privatejavax.validation.ValidatorglobalValidator;

//编程式校验
@PostMapping("/saveWithCodingValidate")
publicResultsaveWithCodingValidate(@RequestBodyUserDTOuserDTO){
Setvalidate=globalValidator.validate(userDTO,UserDTO.Save.class);
//如果校验通过，validate为空；否则，validate包含未校验通过项
if(validate.isEmpty()){
//校验通过，才会执行业务逻辑处理

}else{
for(ConstraintViolationuserDTOConstraintViolation:validate){
//校验失败，做其它逻辑
System.out.println(userDTOConstraintViolation);
}
}
returnResult.ok();
}

快速失败(FailFast)配置

SpringValidation默认会校验完所有字段，然后才抛出异常。可以通过一些简单的配置，开启FaliFast模式，一旦校验失败就立即返回。

@Bean
publicValidatorvalidator(){
ValidatorFactoryvalidatorFactory=Validation.byProvider(HibernateValidator.class)
.configure()
//快速失败模式
.failFast(true)
.buildValidatorFactory();
returnvalidatorFactory.getValidator();
}

校验信息的国际化

Spring的校验功能可以返回很友好的校验信息提示，而且这个信息支持国际化。

这块功能暂时暂时不常用，具体可以参考这篇文章

@Validated和@Valid的区别联系

首先，@Validated和@Valid都能实现基本的验证功能，也就是如果你是想验证一个参数是否为空，长度是否满足要求这些简单功能，使用哪个注解都可以。

但是这两个注解在分组、注解作用的地方、嵌套验证等功能上两个有所不同。下面列下这两个注解主要的不同点。

@Valid注解是JSR303规范的注解，@Validated注解是Spring框架自带的注解；
@Valid不具有分组校验功能，@Validate具有分组校验功能；
@Valid可以用在方法、构造函数、方法参数和成员属性（字段）上,@Validated可以用在类型、方法和方法参数上。但是不能用在成员属性（字段）上,两者是否能用于成员属性（字段）上直接影响能否提供嵌套验证的功能;
@Valid加在成员属性上可以对成员属性进行嵌套验证，而@Validate不能加在成员属性上，所以不具备这个功能。

这边说明下，什么叫嵌套验证。

我们现在有个实体叫做Item：

publicclassItem{

@NotNull(message="id不能为空")
@Min(value=1,message="id必须为正整数")
privateLongid;

@NotNull(message="props不能为空")
@Size(min=1,message="至少要有一个属性")
privateListprops;
}

Item带有很多属性，属性里面有：pid、vid、pidName和vidName，如下所示：

publicclassProp{

@NotNull(message="pid不能为空")
@Min(value=1,message="pid必须为正整数")
privateLongpid;

@NotNull(message="vid不能为空")
@Min(value=1,message="vid必须为正整数")
privateLongvid;

@NotBlank(message="pidName不能为空")
privateStringpidName;

@NotBlank(message="vidName不能为空")
privateStringvidName;
}

属性这个实体也有自己的验证机制，比如pid和vid不能为空，pidName和vidName不能为空等。
现在我们有个ItemController接受一个Item的入参，想要对Item进行验证，如下所示：

@RestController
publicclassItemController{

@RequestMapping("/item/add")
publicvoidaddItem(@ValidatedItemitem,BindingResultbindingResult){
doSomething();
}
}

在上图中，如果Item实体的props属性不额外加注释，只有@NotNull和@Size，无论入参采用@Validated还是@Valid验证，SpringValidation框架只会对Item的id和props做非空和数量验证，不会对props字段里的Prop实体进行字段验证，也就是@Validated和@Valid加在方法参数前，都不会自动对参数进行嵌套验证。也就是说如果传的List中有Prop的pid为空或者是负数，入参验证不会检测出来。

为了能够进行嵌套验证，必须手动在Item实体的props字段上明确指出这个字段里面的实体也要进行验证。由于@Validated不能用在成员属性（字段）上，但是@Valid能加在成员属性（字段）上，而且@Valid类注解上也说明了它支持嵌套验证功能，那么我们能够推断出：@Valid加在方法参数时并不能够自动进行嵌套验证，而是用在需要嵌套验证类的相应字段上，来配合方法参数上@Validated或@Valid来进行嵌套验证。

我们修改Item类如下所示：

publicclassItem{

@NotNull(message="id不能为空")
@Min(value=1,message="id必须为正整数")
privateLongid;

@Valid//嵌套验证必须用@Valid
@NotNull(message="props不能为空")
@Size(min=1,message="props至少要有一个自定义属性")
privateListprops;
}

然后我们在ItemController的addItem函数上再使用@Validated或者@Valid，就能对Item的入参进行嵌套验证。此时Item里面的props如果含有Prop的相应字段为空的情况，SpringValidation框架就会检测出来，bindingResult就会记录相应的错误。

SpringValidation原理简析

现在我们来简单分析下Spring校验功能的原理。

方法级别的参数校验实现原理

所谓的方法级别的校验就是指将@NotNull和@NotEmpty这些约束直接加在方法的参数上的。

比如

@GetMapping("/getUser")
@ResponseBody
publicRgetUser(@NotNull(message="userId不能为空")IntegeruserId){
//
}

或者

@Validated
@Service
publicclassValidatorService{

	privatestaticfinalLoggerlogger=LoggerFactory.getLogger(ValidatorService.class);

	publicStringshow(@NotNull(message="不能为空")@Min(value=18,message="最小18")Stringage){
		logger.info("age={}",age);
		returnage;
	}

}

都属于方法级别的校验。这种方式可用于任何SpringBean的方法上，比如Controller/Service等。

其底层实现原理就是AOP，具体来说是通过MethodValidationPostProcessor动态注册AOP切面，然后使用MethodValidationInterceptor对切点方法织入增强。

publicclassMethodValidationPostProcessorextendsAbstractBeanFactoryAwareAdvisingPostProcessorimplementsInitializingBean{
@Override
publicvoidafterPropertiesSet(){
//为所有`@Validated`标注的Bean创建切面
Pointcutpointcut=newAnnotationMatchingPointcut(this.validatedAnnotationType,true);
//创建Advisor进行增强
this.advisor=newDefaultPointcutAdvisor(pointcut,createMethodValidationAdvice(this.validator));
}

//创建Advice，本质就是一个方法拦截器
protectedAdvicecreateMethodValidationAdvice(@NullableValidatorvalidator){
return(validator!=null?newMethodValidationInterceptor(validator):newMethodValidationInterceptor());
}
}

接着看一下MethodValidationInterceptor：

publicclassMethodValidationInterceptorimplementsMethodInterceptor{
@Override
publicObjectinvoke(MethodInvocationinvocation)throwsThrowable{
//无需增强的方法，直接跳过
if(isFactoryBeanMetadataMethod(invocation.getMethod())){
returninvocation.proceed();
}
//获取分组信息
Class[]groups=determineValidationGroups(invocation);
ExecutableValidatorexecVal=this.validator.forExecutables();
MethodmethodToValidate=invocation.getMethod();
Setresult;
try{
//方法入参校验，最终还是委托给HibernateValidator来校验
result=execVal.validateParameters(
invocation.getThis(),methodToValidate,invocation.getArguments(),groups);
}
catch(IllegalArgumentExceptionex){
...
}
//有异常直接抛出
if(!result.isEmpty()){
thrownewConstraintViolationException(result);
}
//真正的方法调用
ObjectreturnValue=invocation.proceed();
//对返回值做校验，最终还是委托给HibernateValidator来校验
result=execVal.validateReturnValue(invocation.getThis(),methodToValidate,returnValue,groups);
//有异常直接抛出
if(!result.isEmpty()){
thrownewConstraintViolationException(result);
}
returnreturnValue;
}
}

DTO级别的校验

@PostMapping("/saveUser")
@ResponseBody
//注意：如果方法中的参数是对象类型，则必须要在参数对象前面添加@Validated
publicRsaveUser(@Validated@RequestBodyUserDTOuserDTO){
userDTO.setUserId(100);
returnR.SUCCESS.setData(userDTO);
}

这种属于DTO级别的校验。在spring-mvc中，RequestResponseBodyMethodProcessor是用于解析@RequestBody标注的参数以及处理@ResponseBody标注方法的返回值的。显然，执行参数校验的逻辑肯定就在解析参数的方法resolveArgument()中。

publicclassRequestResponseBodyMethodProcessorextendsAbstractMessageConverterMethodProcessor{
@Override
publicObjectresolveArgument(MethodParameterparameter,@NullableModelAndViewContainermavContainer,
NativeWebRequestwebRequest,@NullableWebDataBinderFactorybinderFactory)throwsException{

parameter=parameter.nestedIfOptional();
//将请求数据封装到DTO对象中
Objectarg=readWithMessageConverters(webRequest,parameter,parameter.getNestedGenericParameterType());
Stringname=Conventions.getVariableNameForParameter(parameter);

if(binderFactory!=null){
WebDataBinderbinder=binderFactory.createBinder(webRequest,arg,name);
if(arg!=null){
//执行数据校验
validateIfApplicable(binder,parameter);
if(binder.getBindingResult().hasErrors()&&isBindExceptionRequired(binder,parameter)){
thrownewMethodArgumentNotValidException(parameter,binder.getBindingResult());
}
}
if(mavContainer!=null){
mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX+name,binder.getBindingResult());
}
}
returnadaptArgumentIfNecessary(arg,parameter);
}
}

可以看到，resolveArgument()调用了validateIfApplicable()进行参数校验。

protectedvoidvalidateIfApplicable(WebDataBinderbinder,MethodParameterparameter){
//获取参数注解，比如@RequestBody、@Valid、@Validated
Annotation[]annotations=parameter.getParameterAnnotations();
for(Annotationann:annotations){
//先尝试获取@Validated注解
ValidatedvalidatedAnn=AnnotationUtils.getAnnotation(ann,Validated.class);
//如果直接标注了@Validated，那么直接开启校验。
//如果没有，那么判断参数前是否有Valid起头的注解。
if(validatedAnn!=null||ann.annotationType().getSimpleName().startsWith("Valid")){
Objecthints=(validatedAnn!=null?validatedAnn.value():AnnotationUtils.getValue(ann));
Object[]validationHints=(hintsinstanceofObject[]?(Object[])hints:newObject[]{hints});
//执行校验
binder.validate(validationHints);
break;
}
}
}

看到这里，大家应该能明白为什么这种场景下@Validated、@Valid两个注解可以混用。我们接下来继续看WebDataBinder.validate()实现。

最终发现底层最终还是调用了HibernateValidator进行真正的校验处理。

404等错误的统一处理

参考博客

参考

SpringValidation实现原理及如何运用

SpringBoot参数校验和国际化使用

@Valid和@Validated区别S

pringValidation最佳实践及其实现原理，参数校验没那么简单！

到此这篇关于如何使用SpringBoot进行优雅的数据验证的文章就介绍到这了,更多相关SpringBoot数据验证内容请搜索毛票票以前的文章或继续浏览下面的相关文章希望大家以后多多支持毛票票！

如何使用SpringBoot进行优雅的数据验证

热门推荐

随机推荐