Spring Boot学习笔记（二十一）Spring boot 数据校验 @Validated、@Valid用法详解

后端数据校验（JSR303/JSR-349、javax validation、hibernate validation、spring validation）

后端数据校验如：请求参数不能为null、数值至少为5、email参数符合邮箱地址规则等，通常涉及到上述几种工具，其区别：

• JSR303/JSR-349、javax validation：JSR303是一项标准、JSR-349是其升级版本，添加了一些新特性，他们规定一些校验规范即校验注解，如@Null，@NotNull，@Pattern，他们位于javax.validation.constraints包下，只提供规范不提供实现
• hibernate validation是对该规范的实践（不要将hibernate和数据库orm框架联系在一起），他提供了相应的实现，并增加了一些其他校验注解，如@Email，@Length，@Range等等，他们位于org.hibernate.validator.constraints包下
• spring对hibernate validation进行了二次封装以方便使用，其在springmvc模块中添加了自动校验并将校验信息封装进了特定的类中、还支持指定groups以进行分组校验。以此可见，下面说到的分组是Spring validation提供的功能。
  在使用时最好用规范，这样可以在不改变代码的情况下选用其他具体实现。

maven依赖：

        <dependency>
            <groupId>javax.validationgroupId>
            <artifactId>validation-apiartifactId>
        dependency>


<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-validationartifactId>
    <version>2.2.5.RELEASEversion>
dependency>

约束注解（大多为 javax.validation.constraints 下的注解）

javax Validation v2.0规范中已经定义了22个常用的标记。包括：@NotNull、@NotBlank、@Email、@Pattern、@AssertTrue、@Min、@DecimalMin、@Negative、@Size、@Past、@Future等

启用校验

通常是针对Controller Handler（即Controller中接收http request的方法）启用参数校验，当然也可以对自己创建的对象启用参数校验

启用自动校验可以通过@Validated（ org.springframework.validation.annotation.Validated ）或@Valid（ javax.validation.constraints.Valid ）完成

也可通过 Validation.buildDefaultValidatorFactory().getValidator() 获取一个 Validator 来手动启用校验

使用

1、指定约束：在Bean中的字段上加上@NotNull等约束注解（若方法参数是一个Bean对象如courseEntityDTO，注解可以放在字段声明上，也可以放在字段的get方法上），或直接对方法参数加上约束注解（如 public void test(@NotNull String courseId) {...} ）；

2、启用约束：

若是对请求体的值（@RequestBody 参数）做验证，则在Controller请求方法的Bean参数前加上@Validated即可（也可用@Valid，但多用@Validated）。示例：

@PostMapping("/courses")
public ApiBaseResp importCourses(@Validated @RequestBody ImportCoursesDto importCoursesDto);

若是对非请求体值（如@RequestParam 参数）的验证，则将@Validated放在方法所在的类上，示例：

@Validated
@Data
@Configuration
@ConfigurationProperties(prefix = "sensestudy.security.jwt")
public class JwtSettings {
     

    @NotBlank
    private String tokenIssuer;

    @NotBlank
    private String tokenSigningKey;

    @NotNull
    private Integer tokenExpirationTimeMinutes;

    @NotNull
    private Integer refreshTokenExpireTimeMinutes;

    /** 若 */
    @NotBlank
    private String domainForCookie = "*";

    @Valid
    private Cookie cookie=new Cookie();

}
@Data
class Cookie {
     
    @NotBlank
    private String domain;
}

消息

message参数用于指定出错时的提示信息。如果是{xxxx}的格式，则可用于本地化，如果找不到，就作为一般性描述。如果没有大括号，就是一般性的描述。

缺省的内置的限制标记都有相应的{xxxx}说明，例如 {javax.validation.constraints.NotNull.message}。

未指定则会用注解的默认值，如{javax.validation.constraints.NotNull.message}；若自己指定，则值（可以用EL表达式）：

既可以是字面值，如"name is not present"

也可以包含EL表达式，如 @Size(min=0, max=5, message="value ${validatedValue} should be between [{min},{max}]") ，message中可以引用变量：

对于注解自身有的属性的值可以通过 {属性名} 引用
引用所传的值用 ${validatedValue}

若要进行消息国际化显示，则可通过LocalValidatorFactoryBean指定消息配置源，如：

@Configuration
public class ValidationConfig{
     

    @Value(value = "${spring.messages.basename}")
    private String basename;

    @Bean(name = "messageSource")
    public ResourceBundleMessageSource messageSource() {
     
        ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
        String[] basenames=basename.split(",");
        messageSource.setBasenames(basenames);
        messageSource.setDefaultEncoding("UTF-8");
        return messageSource;
    }


    @Bean
    public LocalValidatorFactoryBean getValidator() {
     
        LocalValidatorFactoryBean bean = new LocalValidatorFactoryBean();
        bean.setValidationMessageSource(messageSource());
            return bean;
    }
}

示例

@AssertTrue：用于修饰方法或属性，要求方法名或属性名必须以 is 开头

//用于修饰方法或属性，要求方法名或属性名必须以 is 开头

//用于方法
@AssertTrue(message = "the value of grant type parameter must be 'clientcredentials'")//校验失败时默认报'grantType只能为true'，可以通过message指定自定义消息    
private boolean isGrantTypeRight() {
        return getGrant_type().equals(GrantTypeEnum.clientcredentials);
    }


//用于属性
@AssertTrue    
private boolean isCourseDisabled;

进阶

• 嵌套的内部对象的验证：在Person p有个字段List cars，若在验证p时同时要验证Car的price等字段，可以在cars前加上 @Valid 即可
• 分组：在Bean中可以指定字段验证所属的groups、在请求参数中可以指定应用哪种groups进行验证，只会触发相应的groups进行验证；若未指定groups则默认属于组javax.validation.groups.Default，更多可参阅（分组）示例：

//Bean中的定义
    @Min(value = 18, groups = {
      Adult.class ,Default.class}) // groups限制触发此约束的条件，groups中无元素则默认为Default.class
    private Integer age;


//Controller中的验证
    @PostMapping("/foo1")
    public String foo1(@RequestBody @Validated({
      Adult.class }) Foo foo1) {
     
        System.out.println("------- res1 -------");
        return "foo1 done.";
    }

• 分组顺序验证：通过@GroupSequence定义一个组SeqGroup，里面包含若干其他组，则SeqGroup可起顺序验证若干组的作用。示例：

public interface GroupA {
     }
 
public interface GroupB {
     }
 
@GroupSequence( {
      Default.class, GroupA.class, GroupB.class })
public interface SeqGroup {
     }

• 可以不用在方法中与每个请求参数都对应一个BindingResult，而是拦截Controller异常进行处理：违背约束时会抛MethodArgumentNotValidException异常。示例：

@Slf4j
@ControllerAdvice
class GlobalControllerExceptionHandler {
     

    @ResponseBody
    @ExceptionHandler(Throwable.class)
    public String handleApiBindException(Throwable e) {
     
        String msg = e.getLocalizedMessage();

        log.error("param validation error", e);

        if (e instanceof BindException) {
     
//            return handleApiBindException((BindException) e);
        }
        if (e instanceof MethodArgumentNotValidException) {
     
            BindingResult bindingResult2 = ((MethodArgumentNotValidException) e).getBindingResult();
            if (bindingResult2.hasErrors()) {
     
                for (FieldError fieldError : bindingResult2.getFieldErrors()) {
     
                    System.out.println(String.format("%s %s %s %s", fieldError.getCode(), fieldError.getField(),
                            fieldError.getDefaultMessage(), fieldError.getRejectedValue()));
                }

            }
            msg = ((MethodArgumentNotValidException) e).getBindingResult().getFieldErrors().stream()
                    .map(fe -> String.format("'%s'%s", fe.getField(), fe.getDefaultMessage()))
                    .collect(Collectors.joining(","));
        }
        if (e instanceof ConstraintViolationException) {
     
//            return handleApiConstraintViolationException((ConstraintViolationException) e);
        }

        return msg;
    }
}

手动启用验证：通过javax.validation.ValidatorFactory获取一个Validator然后进行验证。此法支持分组但对部分约束（如@Email）不生效。该Validator可针对整个类或指定部分字段进行验证，还支持指定分组等。

Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
validator.validate(new Foo(), Default.class).forEach(e -> {
     
	System.err.println(e.getPropertyPath() + " " + e.getMessage());//+ " " + e.getInvalidValue() 
});

• 自定义注解：
  • 定义自定义注解，该注解须被@Constraint修饰以指定该自定义注解对应的注解处理器

package com.marchon.learning.validation.custom_annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import javax.validation.Constraint;
import javax.validation.Payload;

@Target({ ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = CheckCaseValidator.class)
@Documented
public @interface CheckCase {

    // @Constraint要求必须有以下三个方法
    String message() default "'${validatedValue}' not {caseMode} case";// "com.marchon.learning.validation.constraintts.checkcase";

    Class[] groups() default {};

    Class[] payload() default {};

    // 以下方法为其他自定义方法
    CaseMode caseMode();

    public enum CaseMode {
        UPPER, LOWER
    }
}

• 定义自定义注解的处理器，该处理器须实现ConstraintValidator接口

package com.marchon.learning.validation.custom_annotation;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

import com.marchon.learning.validation.custom_annotation.CheckCase.CaseMode;

public class CheckCaseValidator implements ConstraintValidator<CheckCase, String> {
     //两参数分别为注解类型、注解作用目标的属性类型

    private CaseMode caseMode;

    @Override
    public void initialize(CheckCase constraintAnnotation) {
     
        this.caseMode = constraintAnnotation.caseMode();
    }

    @Override
    public boolean isValid(String value, ConstraintValidatorContext constraintContext) {
     

        if (null == value)
            return true;

        if (caseMode == CaseMode.UPPER)
            return value.equals(value.toUpperCase());
        else
            return value.equals(value.toLowerCase());
    }

}

使用示例

    @CheckCase(caseMode = CaseMode.UPPER)
    @NotBlank
    private String name;

总结

可见用的最多的是spring的 @Validated 、其次是javax的 @Valid ，其多数基本功能相似，但在注解适用位置、分组、嵌套验证支持上有区别。

注解适用位置：前者可用于修饰类型、方法、方法参数上，不能修饰成员变量；后者可用于方法、方法参数、成员变量、构造函数上。能否用于成员属性决定了是否支持嵌套验证。

分组：@Validated 支持，@Valid 不支持。

嵌套验证：@Validated 不支持，@Valid 支持。

更多详情参阅：

https://www.cnkirito.moe/spring-validation/

https://blog.csdn.net/qq_27680317/article/details/79970590

https://blog.csdn.net/flowingflying/article/details/78150015