SpringBoot利用@Validated和@Valid进行校验参数

什么是Validator

Spring Validation验证框架对参数的验证机制提供了@Validated（Spring's JSR-303规范，是标准JSR-303的一个变种），javax提供了@Valid（标准JSR-303规范），配合BindingResult可以直接提供参数验证结果。

@Validated是@Valid的一次封装，不是规范。

在检验Controller的入参是否符合规范时，使用@Validated或者@Valid在基本验证功能上没有太多区别。但是在分组、注解地方、嵌套验证等功能上两个有所不同：

分组：
@Validated：提供了一个分组功能，可以在入参验证时，根据不同的分组采用不同的验证机制

@Valid：作为标准JSR-303规范，还没有吸收分组的功能。

注解地方：

• @Validated：可以用在类、方法和方法参数上。
• @Valid：可以用在方法、构造函数、方法参数和成员属性（字段）上
• 嵌套验证：
• 嵌套验证就是类嵌套类的验证，比如我要在集合上加一个@notnull的注解，要求该集合中的每一个对象都被验证，如果只用@Validated与@Valid是不会验证的。我们要用@Validated配合@Valid来进行验证。

使用示例：

方法参数校验：

@GetMapping("/validtest")
@ResponseBody
public String validtest(
        @Size(min = 1,max = 10,message = "姓名长度必须为1到10")@RequestParam("name") String name,
        @Min(value = 10,message = "年龄最小为10")@Max(value = 100,message = "年龄最大为100") @RequestParam("age") Integer age) {
    return "validtest";
}

 

对象/DTO对象校验

//如果你有一个学生类，其结构如下
//在新增时需要验证其名字和年龄是否为空，那么只需要如下操作即可

public class StudentDTO{
    @NotBlank(message = "学生名称不能为空")
    private String name;
    @NotNull(message = "年龄不能为空")
    private Integer age;
    ...
    getter
    setter省略
}

//在web接口处

@RestController
@RequestMapping("/api/v1/student")
public class StudentController{
    
    /**
     *
     * BindingResult result 一定要跟在 @Validated 注解对象的后面,且当有多个@Validated
     * 注解时,每个注解对象后面都需要添加一个
     */
    @PostMapping("add")
    public ResponseEntity addStudent(@RequestBody @Validated StudentDTO student , BindingResult result){
    
        if(result.hasErrors()){
            return new ResponseEntity(result.getFieldError().getDefaultMessage());
            //result.getFieldError().getDefaultMessage() 这个方法的内容就是刚刚在DTO处定义的message内容
        }
    }
}

然后需要在controller方法体添加@Validated或@Valid  不加校验会不起作用

嵌套校验：

示例：

public class Item {

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

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

Item带有很多属性，属性里面有属性id，属性值id，属性名和属性值，如下所示：

public class Prop {

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

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

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

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

分组校验

import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;

public class Resume {
    public interface Default {
    }

    public interface Update {
    }

    @NotNull(message = "id不能为空", groups = Update.class)
    private Long id;

    @NotNull(message = "名字不能为空", groups = Default.class)
    @Length(min = 4, max = 10, message = "name 长度必须在 {min} - {max} 之间", groups = Default.class)
    private String name;

    @NotNull(message = "年龄不能为空", groups = Default.class)
    @Min(value = 18, message = "年龄不能小于18岁", groups = Default.class)
    private Integer age;
    
}

使用分组：

/**
     * 使用Defaul分组进行验证
     * @param resume
     * @return
     */
    @PostMapping("/validate5")
    public String addUser(@Validated(value = Resume.Default.class) @RequestBody Resume resume) {
        return "validate5";
    }

    /**
     * 使用Default、Update分组进行验证
     * @param resume
     * @return
     */
    @PutMapping("/validate6")
    public String updateUser(@Validated(value = {Resume.Update.class, Resume.Default.class}) @RequestBody Resume resume) {
        return "validate6";
    }

建立了两个分组，名称分别为Default、Update。POST方法提交时使用Defaut分组的校验规则，PUT方法提交时同时使用两个分组规则。

自定义校验规则

自定义注解校验

需要自定义一个注解类和一个校验类。

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.*;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.PARAMETER,ElementType.FIELD})
@Constraint(validatedBy = FlagValidatorClass.class)
public @interface FlagValidator {
    // flag的有效值，多个使用,隔开
    String values();

    // flag无效时的提示内容
    String message() default "flag必须是预定义的那几个值，不能随便写";

    Class[] groups() default {};

    Class[] payload() default {};
}

 

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

public class FlagValidatorClass implements ConstraintValidator {
    /**
     * FlagValidator注解规定的那些有效值
     */
    private String values;

    @Override
    public void initialize(FlagValidator flagValidator) {
        this.values = flagValidator.values();
    }

    /**
     * 用户输入的值，必须是FlagValidator注解规定的那些值其中之一。
     * 否则，校验不通过。
     * @param value 用户输入的值，如从前端传入的某个值
     */
    @Override
    public boolean isValid(Object value, ConstraintValidatorContext constraintValidatorContext) {
        // 切割获取值
        String[] value_array = values.split(",");
        Boolean isFlag = false;

        for (int i = 0; i < value_array.length; i++){
            // 存在一致就跳出循环
            if (value_array[i] .equals(value)){
                isFlag = true; break;
            }
        }

        return isFlag;
    }
}

使用我们自定义的注解：

public class User {
    // 前端传入的flag值必须是1或2或3，否则校验失败
    @FlagValidator(values = "1,2,3")
    private String flag ;
}

添加全局异常

创建一个GlobalExceptionHandler类，在类上方添加@RestControllerAdvice注解然后添加以下代码：

 /**
     * 对方法参数校验异常处理方法(仅对于表单提交有效，对于以json格式提交将会失效)
     * 如果是表单类型的提交，则spring会采用表单数据的处理类进行处理（进行参数校验错误时会抛出BindException异常）
     */
    @ExceptionHandler(BindException.class)
    public ResponseEntity> handlerBindException(BindException exception) {
        return handlerNotValidException(exception);
    }
 
    /**
     * 对方法参数校验异常处理方法(前端提交的方式为json格式出现异常时会被该异常类处理)
     * json格式提交时，spring会采用json数据的数据转换器进行处理（进行参数校验时错误是抛出MethodArgumentNotValidException异常）
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity> handlerArgumentNotValidException(MethodArgumentNotValidException exception) {
        return handlerNotValidException(exception);
    }
 
    public ResponseEntity> handlerNotValidException(Exception e) {
        log.debug("begin resolve argument exception");
        BindingResult result;
        if (e instanceof BindException) {
            BindException exception = (BindException) e;
            result = exception.getBindingResult();
        } else {
            MethodArgumentNotValidException exception = (MethodArgumentNotValidException) e;
            result = exception.getBindingResult();
        }
 
        Map maps;
        if (result.hasErrors()) {
            List fieldErrors = result.getFieldErrors();
            maps = new HashMap<>(fieldErrors.size());
            fieldErrors.forEach(error -> {
                maps.put(error.getField(), error.getDefaultMessage());
            });
        } else {
            maps = Collections.EMPTY_MAP;
        }
 
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(maps);
 
    }

在这里我仅仅是针对参数校验的异常进行了统一处理，也就是返回给前端的响应码是400（参数格式错误）,对于自定义异常或者其他的异常都可以采用这种方式来对异常进行统一处理