SpringBoot parameter verification usage and scenarios of @Valid and @Validated

In actual development, parameter verification is an important means to ensure interface security and data integrity. Spring Boot provides@Validand@ValidatedTwo core annotations are used to implement parameter verification, but many developers have doubts about their differences and usage scenarios. This article will analyze the differences between the two in depth and demonstrate their specific application scenarios through code examples.

1. Comparison of core annotations

2. Usage and scenarios of @Valid

1. Basic use

@ValidIt is mainly used for method parameter verification, especially for verification of DTO objects at the Controller layer. Need to cooperate with JSR-303 annotations (such as@NotNull、@Size)use.

Sample code:

@PostMapping("/users")
public ResponseEntity<?> createUser(@RequestBody @Valid UserDTO userDTO) {
    // Business logic    return ().build();
}
public class UserDTO {
    @NotBlank(message = "Username cannot be empty")
    private String username;
    @Size(min = 6, max = 20, message = "The password length must be between 6-20 digits")
    private String password;
}

2. Nested Verification

If the DTO contains other object fields, you need to add them to the fields.@ValidTrigger recursive check.

public class OrderDTO {
    @Valid  // Trigger nested verification    private UserDTO user;
    @NotNull(message = "The order amount cannot be empty")
    private BigDecimal amount;
}

3. Advanced features of @Validated

1. Group verification

Scenario description: In different business scenarios, different verification rules may be required for the same object. For example, users need to verify the email address when registering, but not when updating information.

Implementation steps:

Define the packet interface:

public interface CreateGroup {}  // Create groupingpublic interface UpdateGroup {}  // Update grouping

Specify the grouping in the DTO:

public class UserDTO {
    @NotBlank(groups = , message = "The email cannot be empty")
    private String email;
    @NotBlank(message = "Username cannot be empty")
    private String username;
}

Use in Controller@ValidatedActivate grouping:

@PostMapping("/users")
public ResponseEntity<?> createUser(
    @RequestBody @Validated() UserDTO userDTO) {
    // Only verify the rules for CreateGroup grouping    return ().build();
}

2. Method parameter verification

@ValidatedCan be used for service layer method parameter verification, need to be added on the class@Validatedannotation.

@Service
@Validated  // Enable method parameter verificationpublic class UserService {
    public void updateUser(@NotBlank String username, @Min(1) Long userId) {
        // Business logic    }
}

4. Combining nested verification and grouped verification

Complex scenario: Trigger verification of nested objects in group verification.

public class OrderDTO {
    @Validated()  // Specify the grouping    @Valid
    private UserDTO user;
    @NotNull(message = "Required amount")
    private BigDecimal amount;
}
// Controller layer@PostMapping("/orders")
public ResponseEntity<?> createOrder(
    @RequestBody @Validated() OrderDTO orderDTO) {
    //Check the rules of CreateGroup grouping in OrderDTO and UserDTO at the same time    return ().build();
}

5. Frequently Asked Questions and Precautions

1. Exception handling

If the verification fails, the following exception will be thrown:

• MethodArgumentNotValidException(@Valid triggered)
• ConstraintViolationException(@Validated triggered)

Unified exception handling example:

@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler()
    public ResponseEntity<?> handleValidationException(MethodArgumentNotValidException ex) {
        Map<String, String> errors = new HashMap<>();
        ().getFieldErrors().forEach(error -> 
            ((), ()));
        return ().body(errors);
    }
}

2. Dependency issues

Ensure introductions in the projectspring-boot-starter-validation：

<dependency>
    <groupId></groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

3. Things to note

• Spring version compatibility: Lower versions of Spring need to be enabled manually@EnableWebMvcor@Validatedsupport.
• Packet interface design: The packet interface is recommended to be defined as an empty interface and is only used as an identifier.

6. Summary and best practices

Best Practices:

• Controller layer: priority@ValidPerform a simple verification.
• Complex business verification: Use@Validatedgrouping function.
• Service layer parameter verification: Add on class@Validated, in conjunction with JSR-303 annotations.

The above is the detailed content of the usage and scenarios of @Valid and @Validated in SpringBoot. For more information about @Valid and @Validated in SpringBoot, please follow my other related articles!