springboot @Valid注解对嵌套类型的校验功能

Spring Boot @Valid Annotation for Nested Type Validation

The @Valid annotation in Spring Boot is used to enable validation on nested types. It allows you to validate the fields of an object that is a property of another object. This annotation is particularly useful when dealing with complex data structures or when you need to validate multiple levels of nested objects.

To use the @Valid annotation for nested type validation, follow these steps:

1. Define the nested object class with appropriate validation annotations on its fields.
2. In the parent object class, annotate the nested object property with the @Valid annotation.

Here's an example to illustrate the process:

Step 1: Define the Nested Object Class

public class Address {
    @NotBlank(message = \"Street is required\")
    private String street;

    @NotBlank(message = \"City is required\")
    private String city;

    @NotBlank(message = \"State is required\")
    private String state;

    // Getters and setters
}

In this example, the Address class represents a nested object with three fields: street, city, and state. The @NotBlank annotation is used to ensure that these fields are not empty.

Step 2: Annotate the Nested Object Property with @Valid

public class User {
    @NotBlank(message = \"Name is required\")
    private String name;

    @Valid
    private Address address;

    // Getters and setters
}

In this example, the User class has a property called address, which is an instance of the Address class. By annotating the address property with @Valid, Spring Boot will automatically validate the fields of the nested Address object.

Example Usage

Now, let's see how to use the nested type validation with the @Valid annotation.

@RestController
public class UserController {

    @PostMapping(\"/users\")
    public ResponseEntity<String> createUser(@Valid @RequestBody User user) {
        // Process the user object
        return ResponseEntity.ok(\"User created successfully\");
    }
}

In this example, the createUser method is a REST endpoint that receives a User object as the request body. By annotating the user parameter with @Valid, Spring Boot will automatically validate the nested Address object within the User object.

If any validation errors occur during the validation process, Spring Boot will automatically return a response with the appropriate error messages.

Another Example

Let's consider another example to demonstrate the nested type validation with the @Valid annotation.

public class OrderItem {
    @NotNull(message = \"Product ID is required\")
    private Long productId;

    @Positive(message = \"Quantity must be positive\")
    private Integer quantity;

    // Getters and setters
}

public class Order {
    @NotNull(message = \"Customer ID is required\")
    private Long customerId;

    @Valid
    private List<OrderItem> items;

    // Getters and setters
}

In this example, the Order class contains a nested list of OrderItem objects. The OrderItem class has two fields: productId and quantity, which are validated using the @NotNull and @Positive annotations, respectively.

By annotating the items property of the Order class with @Valid, Spring Boot will validate each OrderItem object within the list.

I hope this guide helps you understand how to use the @Valid annotation for nested type validation in Spring Boot.