Build from zero development scaffolding Spring Boot input parameter verification in a variety of ways

The article directories

• • • background
    • Common scenarios
    • • 1. The bean validation
      • 2. Verify plane parameters
      • 3. Manually verify the authentication
      • 4. The List
    • extension
    • • Similarities and differences between 1.@Validated and @valid
      • 2. Quick failure mode
      • 3. Verify relevant notes and instructions
      • 4. Customize validation annotations

Prepare a “Build scaffolding from Scratch series” to share the problems encountered and the process of building.

background

When it comes to user input, you need to verify the input content, for example: the name cannot be blank, the age range is 0-150, and so on. We use Spring Boot’s built-in validation to do this.

Starting with Spring Boot 2.3, we need to explicitly add spring-boot-starter-validation dependencies:

<dependency> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-validation</artifactId> 
</dependency>
Copy the code

Common scenarios

1. The bean validation

Entities to be verified:

@Data
@Builder
public class LakerUser {
    /** * name */
    @notblank (message = "name cannot be blank ")
    private String name;

    /** * age */
    @min (value = 0, message = "age should be greater than or equal to 0")
    @min (value = 150, message = "age should be less than or equal to 150")
    private int age;

    /** * Mobile phone number */
    @notblank (message = "Phone number cannot be blank ")
    ^ @ the Pattern (regexp = "[1] [3,4,5,6,7,8,9] [0-9] {9} $", message =" phone number format is wrong ")
    private String mobile;

}
Copy the code

Controller:

Method entry: add @ “Validated”

    @RequestMapping("/lakeruser")
    public Response validatorBean(@RequestBody @Validated LakerUser lakerUser) {
        return Response.ok();
    }
Copy the code

Global exception handling:

@RestControllerAdvice("com.laker.notes")
@Slf4j
public class GlobalExceptionHandler {  
    /** * Verify the bean type */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Response handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {
        log.error(e.getMessage(), e);
        List<Map> result = new ArrayList<>();
        e.getBindingResult().getFieldErrors().forEach((fieldError) -> {
            result.add(Dict.create().set("field", fieldError.getField()).set("msg", fieldError.getDefaultMessage()));
        });
        returnResponse.error(result); }...Copy the code

Validation:

2. Verify plane parameters

@RestController
@Slf4j
@Validated
public class ValidatorController {    
	@RequestMapping("/validator")
    public Response validatorParam(@notblank (message = "name cannot be blank ") String name, @min (value = 0, message = "age should be greater than or equal to 0")
    @max (value = 150, message = "age should be less than or equal to 150") String age) {
        return Response.ok();
    }
Copy the code

3. Manually verify the authentication

Tools:

public class ValidatorUtils {
    private static Validator validator;
    static {
        // Normal mode
        validator = Validation.byProvider(HibernateValidator.class)
                .configure()
                // Fast failure mode. When fast fails to be enabled, validation stops when the first constraint violation is detected
                .failFast(false)
                .buildValidatorFactory()
                .getValidator();
    }
    /** * Check object */
    public static <T> void validate(T object, Class
       ... groups) {
        Set<ConstraintViolation<T>> constraintViolationSet = validator.validate(object, groups);

        if(! constraintViolationSet.isEmpty()) {throw newConstraintViolationException(constraintViolationSet); }}}Copy the code

Controller:

    @RequestMapping("/util")
    public Response validatorUtil(@RequestBody LakerUser lakerUser) {
        ValidatorUtils.validate(lakerUser);// Call before and after any business logic
        return Response.ok();
    }
Copy the code

Validation:

4. The List

@RestController
@Slf4j
@Validated
public class ValidatorController { 
	@RequestMapping("/lakerusers")
    public Response validatorListBean(@RequestBody @Valid List<LakerUser> lakerUser) {
        return Response.ok();
    }
Copy the code

extension

Similarities and differences between 1.@Validated and @valid

public class ClassRoom{
    @NotNull
    String name;
    @Valid  // Nested checksum validates the attributes inside the parameter
    @NotNull
    Student student;
}
    @GetMapping("/room")   // You can use @valid or @validated to perform nested verification
    public String validator(@Validated ClassRoom classRoom, BindingResult result) {
        if (result.hasErrors()) {
            return result.getFieldError().getDefaultMessage();
        }
        return "ok";
    }
Copy the code

2. Quick failure mode

Fast failure mode: When fast failure is enabled, validation stops when the first constraint violation is detected and defaults to non-fast failure mode.

   // Normal mode
        validator = Validation.byProvider(HibernateValidator.class)
                .configure()
                // Fast failure mode. When fast fails to be enabled, validation stops when the first constraint violation is detected
                .failFast(true)
                .buildValidatorFactory()
                .getValidator();
Copy the code

3. Verify relevant notes and instructions

4. Customize validation annotations

1. Create custom annotations

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD,ElementType.PARAMETER})
@Constraint(validatedBy = FlagValidatorClass.class) // Bind the corresponding validator
public @interface FlagValidator {
    String[] value() default {};
 
    String message(a) default "flag is not found"; Class<? >[] groups()default {};
 
    Class<? extends Payload>[] payload() default {};
}
Copy the code

2. Write a validator

/** ** flag bit validator */
public class FlagValidatorClass implements ConstraintValidator<FlagValidator.Integer> {
    private String[] values;
 
    /** * initializes **@paramThe value set in the flagValidator annotation */
    @Override
    public void initialize(FlagValidator flagValidator) {
        this.values = flagValidator.value();
    }
 
    /** * check **@paramValue Specifies the verified value, that is, *@param* constraintValidatorContext check context@returnReturns true to verify that the verification passed, false to verify that the verification failed */
    @Override
    public boolean isValid(Integer value, ConstraintValidatorContext constraintValidatorContext) {
        boolean isValid = false;
        // If value is null, verification fails
        if (value == null) {
            return false;
        }
        // traversal verification
        for (int i = 0; i < values.length; i++) {
            if (values[i].equals(String.valueOf(value))) {
                isValid = true;
                break; }}returnisValid; }}Copy the code

3. Attribute annotations

    @notnull (message = "Flag bit cannot be empty ")
    @flagvalidator (value = {"0", "1"}, message = "error ")
    private Integer flag;
Copy the code

Reference:

• Blog.csdn.net/weixin_4223…
• www.cnblogs.com/sueyyyy/p/1…