How to use SpringBoot for elegant data verification

<dependency>
 <groupId></groupId>
 <artifactId>hibernate-validator</artifactId>
 <version>6.0.</version>
</dependency>

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

 private static Logger logger = ();

 @GetMapping("/getUser")
 @ResponseBody
 // Note: If you want to use @NotNull annotation verification in the parameters, you must add @Validated to the class; public UserDTO getUser(@NotNull(message = "userId cannot be empty") Integer userId){
 ("userId:[{}]",userId);
 UserDTO res = new UserDTO();
 (userId);
 ("The Road to Freedom of Programmers");
 (8);
 return res;
 }
}

@RestControllerAdvice
public class GlobalExceptionHandler {

 private static final Logger logger = ();

 @ExceptionHandler(value = )
 public Response handle1(ConstraintViolationException ex){
  StringBuilder msg = new StringBuilder();
 Set<ConstraintViolation<?>> constraintViolations = ();
 for (ConstraintViolation<?> constraintViolation : constraintViolations) {
  PathImpl pathImpl = (PathImpl) ();
  String paramName = ().getName();
  String message = ();
  ("[").append(message).append("]");
 }
 ((),ex);
 // Note: The Response class must have a get and set method, otherwise an error will be reported. return new Response(RCode.PARAM_INVALID.getCode(),());
 }

 @ExceptionHandler(value = )
 public Response handle1(Exception ex){
 ((),ex);
 return new Response((),());
 }
}

# There is no userId passed hereGET 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 cannot be empty]"
}

import ;
import ;

public class UserDTO {

 private Integer userId;

 @NotEmpty(message = "The name cannot be empty")
 private String name;
 @Range(min = 18,max = 50,message = "Age must be between 18 and 50")
 private Integer age;
 //Omit the get and set methods}

@PostMapping("/saveUser")
@ResponseBody
//Note: If the parameter in the method is an object type, you must add @Validated in front of the parameter object.public Response<UserDTO> getUser(@Validated @RequestBody UserDTO userDTO){
 (100);
 Response response = ();
 (userDTO);
 return response;
}

@ExceptionHandler(value = )
public Response handle2(MethodArgumentNotValidException ex){
 BindingResult bindingResult = ();
 if(bindingResult!=null){
 if(()){
  FieldError fieldError = ();
  String field = ();
  String defaultMessage = ();
  ((),ex);
  return new Response(RCode.PARAM_INVALID.getCode(),field+":"+defaultMessage);
 }else {
  ((),ex);
  return new Response((),());
 }
 }else {
 ((),ex);
 return new Response((),());
 }
}

@Validated
@Service
public class ValidatorService {

	private static final Logger logger = ();

	public String show(@NotNull(message = "Can't be empty") @Min(value = 18, message = "Minimum 18") String age) {
		("age = {}", age);
		return age;
	}

}

public class UserDTO {

 public interface Default {
 }

 public interface Group1 {
 }

 private Integer userId;
 //Note: After adding groups attributes to the @Validated annotation, the verification rule without group attributes in DTO will be invalid @NotEmpty(message = "The name cannot be empty",groups = )
 private String name;

 //Note: After adding the groups attribute, the group attribute must be added to the @Validated annotation before the verification rules can take effect, otherwise the following verification limit will be invalid @Range(min = 18, max = 50, message = "Age must be between 18 and 50",groups = )
 @Range(min = 17, message = "Age must be greater than 17", groups = )
 private Integer age;
}

@PostMapping("/saveUserGroup")
@ResponseBody
//Note: If the parameter in the method is an object type, you must add @Validated in front of the parameter object.//Check group verification, age satisfaction is greater than 17public Response<UserDTO> saveUserGroup(@Validated(value = {UserDTO.}) @RequestBody UserDTO userDTO){
 (100);
 Response response = ();
 (userDTO);
 return response;
}

public class GroupSequenceDemoForm {

 @NotBlank(message = "Contains at least one non-empty character", groups = {})
 @Size(min = 11, max = 11, message = "The length must be 11", groups = {})
 private String demoAttr;

 public interface First {

 }

 public interface Second {

 }

 @GroupSequence(value = {, })
 public interface GroupOrderedOne {
 // First calculate the constraints belonging to the First group, and then calculate the constraints belonging to the Second group }


 @GroupSequence(value = {, })
 public interface GroupOrderedTwo {
 // First calculate the constraints belonging to the Second group, and then calculate the constraints belonging to the First group }

}

// First calculate the constraints belonging to the First group, and then calculate the constraints belonging to the Second group@Validated(value = {}) @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) {
  = userId;
 }

 public String getName() {
 return name;
 }

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

 public Integer getAge() {
 return age;
 }

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

 public Job getJob() {
 return job;
 }

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

 /**
  * This must be set to a static internal class
  */
 static class Job {
 @NotEmpty
 private String jobType;
 @DecimalMax(value = "1000.99")
 private Double salary;

 public String getJobType() {
  return jobType;
 }

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

 public Double getSalary() {
  return salary;
 }

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

}

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

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

 // @Delegate is a lombok annotation // In the implementation of the List interface, a series of methods are required. Using this annotation can be delegated to the ArrayList implementation // @Delegate
 @Valid
 public List list = new ArrayList<>();


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

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

 @Override
 public boolean contains(Object o) {
 return (o);
 }
 //.... The following omits a series of List interface methods, which are actually called ArrayList methods}

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

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

 // Default error message String message() default "Encryption id format error";

 // Grouping Class[] groups() default {};

 // Load Class[] payload() default {};
}

public class EncryptIdValidator implements ConstraintValidator<EncryptId, String> {

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

 @Override
 public boolean isValid(String value, ConstraintValidatorContext context) {
 // Verification is performed only if it is not null if (value != null) {
  Matcher matcher = (value);
  return ();
 }
 return true;
 }
}

@Autowired
private  globalValidator;

// Programming verification@PostMapping("/saveWithCodingValidate")
public Result saveWithCodingValidate(@RequestBody UserDTO userDTO) {
 Set<constraintviolation> validate = (userDTO, );
 // If the verification is passed, validate is empty; otherwise, validate contains items that are not validated. if (()) {
 // Only after the verification is passed will the business logic process be performed
 } else {
 for (ConstraintViolation userDTOConstraintViolation : validate) {
  // Check failed, do other logic  (userDTOConstraintViolation);
 }
 }
 return ();
}

@Bean
public Validator validator() {
 ValidatorFactory validatorFactory = ()
  .configure()
  // Fast failure mode  .failFast(true)
  .buildValidatorFactory();
 return ();
}

public class Item {

 @NotNull(message = "id cannot be empty")
 @Min(value = 1, message = "id must be a positive integer")
 private Long id;

 @NotNull(message = "props cannot be empty")
 @Size(min = 1, message = "At least one attribute")
 private List<Prop> props;
}

public class Prop {

 @NotNull(message = "pid cannot be empty")
 @Min(value = 1, message = "pid must be a positive integer")
 private Long pid;

 @NotNull(message = "vid cannot be empty")
 @Min(value = 1, message = "vid must be a positive integer")
 private Long vid;

 @NotBlank(message = "pidName cannot be empty")
 private String pidName;

 @NotBlank(message = "vidName cannot be empty")
 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 cannot be empty")
 @Min(value = 1, message = "id must be a positive integer")
 private Long id;

 @Valid // Nested verification must be @Valid @NotNull(message = "props cannot be empty")
 @Size(min = 1, message = "Props must have at least one custom property")
 private List<Prop> props;
}

@GetMapping("/getUser")
@ResponseBody
public R getUser(@NotNull(message = "userId cannot be empty") Integer userId){
 //
}

@Validated
@Service
public class ValidatorService {

	private static final Logger logger = ();

	public String show(@NotNull(message = "Can't be empty") @Min(value = 18, message = "Minimum 18") String age) {
		("age = {}", age);
		return age;
	}

}

public class MethodValidationPostProcessor extends AbstractBeanFactoryAwareAdvisingPostProcessorimplements InitializingBean {
 @Override
 public void afterPropertiesSet() {
 //Create facets for all beans marked with `@Validated` Pointcut pointcut = new AnnotationMatchingPointcut(, true);
 //Create Advisor for enhancement  = new DefaultPointcutAdvisor(pointcut, createMethodValidationAdvice());
 }

 //Creating Advice is essentially a method interceptor 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 {
 //Skip directly without enhancing methods if (isFactoryBeanMetadataMethod(())) {
  return ();
 }
 //Get grouping information Class[] groups = determineValidationGroups(invocation);
 ExecutableValidator execVal = ();
 Method methodToValidate = ();
 Set<constraintviolation> result;
 try {
  //The method is used to verify the parameters, and it is ultimately entrusted to the Hibernate Validator for verification.  result = (
  (), methodToValidate, (), groups);
 }
 catch (IllegalArgumentException ex) {
  ...
 }
 // Throw it directly if there is an exception if (!()) {
  throw new ConstraintViolationException(result);
 }
 //Real method call Object returnValue = ();
 //Check the return value, and ultimately, it is entrusted to Hibernate Validator for verification result = ((), methodToValidate, returnValue, groups);
 // Throw it directly if there is an exception if (!()) {
  throw new ConstraintViolationException(result);
 }
 return returnValue;
 }
}

@PostMapping("/saveUser")
@ResponseBody
//Note: If the parameter in the method is an object type, you must add @Validated in front of the parameter object.public R saveUser(@Validated @RequestBody UserDTO userDTO){
 (100);
 return (userDTO);
}

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

 parameter = ();
 //Embroidery the requested data into the DTO object Object arg = readWithMessageConverters(webRequest, parameter, ());
 String name = (parameter);

 if (binderFactory != null) {
  WebDataBinder binder = (webRequest, arg, name);
  if (arg != null) {
  // Perform data verification  validateIfApplicable(binder, parameter);
  if (().hasErrors() && isBindExceptionRequired(binder, parameter)) {
   throw new MethodArgumentNotValidException(parameter, ());
  }
  }
  if (mavContainer != null) {
  (BindingResult.MODEL_KEY_PREFIX + name, ());
  }
 }
 return adaptArgumentIfNecessary(arg, parameter);
 }
}

protected void validateIfApplicable(WebDataBinder binder, MethodParameter parameter) {
 // Get parameter annotations, such as @RequestBody, @Valid, @Validated Annotation[] annotations = ();
 for (Annotation ann : annotations) {
 // Try to get the @Validated annotation first Validated validatedAnn = (ann, );
 //If @Validated is marked directly, then check directly. //If not, then determine whether there is annotation starting with Valid before the parameter. if (validatedAnn != null || ().getSimpleName().startsWith("Valid")) {
  Object hints = (validatedAnn != null ? () : (ann));
  Object[] validationHints = (hints instanceof Object[] ? (Object[]) hints : new Object[] {hints});
  //Perform verification  (validationHints);
  break;
 }
 }
}