SpringBoot数据验证 怎样使用SpringBoot进行优雅的数据验证

<dependency>
 <groupId>org.hibernate</groupId>
 <artifactId>hibernate-validator</artifactId>
 <version>6.0.1.Final</version>
</dependency>

@Validated
@RestController
@RequestMapping("/user")
public class UserController {

 private static Logger logger = LoggerFactory.getLogger(UserController.class);

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

@RestControllerAdvice
public class GlobalExceptionHandler {

 private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

 @ExceptionHandler(value = ConstraintViolationException.class)
 public Response handle1(ConstraintViolationException ex){
  StringBuilder msg = new StringBuilder();
 Set<ConstraintViolation<?>> constraintViolations = ex.getConstraintViolations();
 for (ConstraintViolation<?> constraintViolation : constraintViolations) {
  PathImpl pathImpl = (PathImpl) constraintViolation.getPropertyPath();
  String paramName = pathImpl.getLeafNode().getName();
  String message = constraintViolation.getMessage();
  msg.append("[").append(message).append("]");
 }
 logger.error(msg.toString(),ex);
 // 注意：Response类必须有get和set方法，不然会报错
 return new Response(RCode.PARAM_INVALID.getCode(),msg.toString());
 }

 @ExceptionHandler(value = Exception.class)
 public Response handle1(Exception ex){
 logger.error(ex.getMessage(),ex);
 return new Response(RCode.ERROR.getCode(),RCode.ERROR.getMsg());
 }
}

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

HTTP/1.1 200 
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 14 Nov 2020 07:35:44 GMT
Keep-Alive: timeout=60
Connection: keep-alive

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

import org.hibernate.validator.constraints.Range;
import javax.validation.constraints.NotEmpty;

public class UserDTO {

 private Integer userId;

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

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

@ExceptionHandler(value = MethodArgumentNotValidException.class)
public Response handle2(MethodArgumentNotValidException ex){
 BindingResult bindingResult = ex.getBindingResult();
 if(bindingResult!=null){
 if(bindingResult.hasErrors()){
  FieldError fieldError = bindingResult.getFieldError();
  String field = fieldError.getField();
  String defaultMessage = fieldError.getDefaultMessage();
  logger.error(ex.getMessage(),ex);
  return new Response(RCode.PARAM_INVALID.getCode(),field+":"+defaultMessage);
 }else {
  logger.error(ex.getMessage(),ex);
  return new Response(RCode.ERROR.getCode(),RCode.ERROR.getMsg());
 }
 }else {
 logger.error(ex.getMessage(),ex);
 return new Response(RCode.ERROR.getCode(),RCode.ERROR.getMsg());
 }
}

@Validated
@Service
public class ValidatorService {

	private static final Logger logger = LoggerFactory.getLogger(ValidatorService.class);

	public String show(@NotNull(message = "不能为空") @Min(value = 18, message = "最小18") String age) {
		logger.info("age = {}", age);
		return age;
	}

}

public class UserDTO {

 public interface Default {
 }

 public interface Group1 {
 }

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

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

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

public class GroupSequenceDemoForm {

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

 public interface First {

 }

 public interface Second {

 }

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


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

}

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

public class UserDTO1 {

 private Integer userId;
 @NotEmpty
 private String name;
 @NotNull
 private Integer age;
 @Valid
 @NotNull
 private Job job;

 public Integer getUserId() {
 return userId;
 }

 public void setUserId(Integer userId) {
 this.userId = userId;
 }

 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }

 public Integer getAge() {
 return age;
 }

 public void setAge(Integer age) {
 this.age = age;
 }

 public Job getJob() {
 return job;
 }

 public void setJob(Job job) {
 this.job = job;
 }

 /**
 * 这边必须设置成静态内部类
 */
 static class Job {
 @NotEmpty
 private String jobType;
 @DecimalMax(value = "1000.99")
 private Double salary;

 public String getJobType() {
  return jobType;
 }

 public void setJobType(String jobType) {
  this.jobType = jobType;
 }

 public Double getSalary() {
  return salary;
 }

 public void setSalary(Double salary) {
  this.salary = salary;
 }
 }

}

@PostMapping("/saveUserWithJob")
@ResponseBody
public Response<UserDTO1> saveUserWithJob(@Validated @RequestBody UserDTO1 userDTO){
 userDTO.setUserId(100);
 Response response = Response.success();
 response.setData(userDTO);
 return response;
}

public class ValidationList<T> implements List<T> {

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


 @Override
 public int size() {
 return list.size();
 }

 @Override
 public boolean isEmpty() {
 return list.isEmpty();
 }

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

@PostMapping("/batchSaveUser")
@ResponseBody
public Response batchSaveUser(@Validated(value = UserDTO.Default.class) @RequestBody ValidationList<UserDTO> userDTOs){
 return Response.success();
}

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

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

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

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

public class EncryptIdValidator implements ConstraintValidator<EncryptId, String> {

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

 @Override
 public boolean isValid(String value, ConstraintValidatorContext context) {
 // 不为null才进行校验
 if (value != null) {
  Matcher matcher = PATTERN.matcher(value);
  return matcher.find();
 }
 return true;
 }
}

@Autowired
private javax.validation.Validator globalValidator;

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

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

@Bean
public Validator validator() {
 ValidatorFactory validatorFactory = Validation.byProvider(HibernateValidator.class)
  .configure()
  // 快速失败模式
  .failFast(true)
  .buildValidatorFactory();
 return validatorFactory.getValidator();
}

public class Item {

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

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

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;
}

@RestController
public class ItemController {

 @RequestMapping("/item/add")
 public void addItem(@Validated Item item, BindingResult bindingResult) {
 doSomething();
 }
}

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<Prop> props;
}

@GetMapping("/getUser")
@ResponseBody
public R getUser(@NotNull(message = "userId不能为空") Integer userId){
 //
}

@Validated
@Service
public class ValidatorService {

	private static final Logger logger = LoggerFactory.getLogger(ValidatorService.class);

	public String show(@NotNull(message = "不能为空") @Min(value = 18, message = "最小18") String age) {
		logger.info("age = {}", age);
		return age;
	}

}

public class MethodValidationPostProcessor extends AbstractBeanFactoryAwareAdvisingPostProcessorimplements InitializingBean {
 @Override
 public void afterPropertiesSet() {
 //为所有`@Validated`标注的Bean创建切面
 Pointcut pointcut = new AnnotationMatchingPointcut(this.validatedAnnotationType, true);
 //创建Advisor进行增强
 this.advisor = new DefaultPointcutAdvisor(pointcut, createMethodValidationAdvice(this.validator));
 }

 //创建Advice，本质就是一个方法拦截器
 protected Advice createMethodValidationAdvice(@Nullable Validator validator) {
 return (validator != null ? new MethodValidationInterceptor(validator) : new MethodValidationInterceptor());
 }
}

public class MethodValidationInterceptor implements MethodInterceptor {
 @Override
 public Object invoke(MethodInvocation invocation) throws Throwable {
 //无需增强的方法，直接跳过
 if (isFactoryBeanMetadataMethod(invocation.getMethod())) {
  return invocation.proceed();
 }
 //获取分组信息
 Class[] groups = determineValidationGroups(invocation);
 ExecutableValidator execVal = this.validator.forExecutables();
 Method methodToValidate = invocation.getMethod();
 Set<constraintviolation> result;
 try {
  //方法入参校验，最终还是委托给Hibernate Validator来校验
  result = execVal.validateParameters(
  invocation.getThis(), methodToValidate, invocation.getArguments(), groups);
 }
 catch (IllegalArgumentException ex) {
  ...
 }
 //有异常直接抛出
 if (!result.isEmpty()) {
  throw new ConstraintViolationException(result);
 }
 //真正的方法调用
 Object returnValue = invocation.proceed();
 //对返回值做校验，最终还是委托给Hibernate Validator来校验
 result = execVal.validateReturnValue(invocation.getThis(), methodToValidate, returnValue, groups);
 //有异常直接抛出
 if (!result.isEmpty()) {
  throw new ConstraintViolationException(result);
 }
 return returnValue;
 }
}

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

public class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMethodProcessor {
 @Override
 public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
     NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

 parameter = parameter.nestedIfOptional();
 //将请求数据封装到DTO对象中
 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) {
 // 获取参数注解，比如@RequestBody、@Valid、@Validated
 Annotation[] annotations = parameter.getParameterAnnotations();
 for (Annotation ann : annotations) {
 // 先尝试获取@Validated注解
 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;
 }
 }
}