Solve the problem that the @NotEmpty annotation fails when the List collection contains null elements

When a List collection contains null elements, the standard @NotEmpty annotation cannot recognize it as an invalid state because it only checks whether the collection itself is null or empty. To solve this problem, you need to create custom validation annotations and corresponding validators to implement null value checking on the internal elements of the List collection, thereby ensuring data integrity and returning the expected 400 Bad Request response.

Understand the validation behavior of @NotEmpty and List collections

In Java Bean Validation, the @NotEmpty annotation is mainly used to verify whether a collection, array or string is empty. For collection types, it checks if the collection is null and contains any elements. However, when a List collection contains null elements, the @NotEmpty annotation does not treat it as "empty" or invalid.

Consider the following data model and request body example:

 class Data {
    @NotEmpty // This annotation only checks whether the List itself is empty, and does not check its internal elements private List values;

    // Getter, Setter, Constructors
}

• Request body 1 (expected 200 OK):

   { "values": ["randomValue"] }

  This request body is as expected, the List is not empty and contains valid elements.

• Request body 2 (expected 400 BAD_REQUEST):

   { }

  The values ​​field in this request body is missing. @NotEmpty will capture this situation and return 400.

• Request body 3 (expected 400 BAD_REQUEST):

   { "values": [] }

  The values ​​field in this request body is an empty List. @NotEmpty will capture this situation and return 400.

• Request body 4 (actual 200 OK, expected 400 BAD_REQUEST):

   { "values": [null] }

  This is the core of the problem. Although the List contains null elements, since the List itself is not empty (it contains one element), the @NotEmpty annotation does not recognize this as an invalid state, causing the request to succeed (200 OK) instead of the expected validation error (400 BAD_REQUEST).

To solve this problem, we need to implement a custom validation logic that can deeply check each element in the List collection.

Implement custom List element validation

Custom validation usually involves two core components: a custom annotation (Annotation) and a validator (ConstraintValidator).

Step 1: Define the custom validation annotation @ValidList

First, create a new annotation, such as @ValidList. This annotation will be used to mark List fields that require custom validation.

 import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE})
@Constraint(validatedBy = ListValidator.class) //Specify the actual validator class public @interface ValidList {
    String message() default "The list field cannot be null or contain null elements"; // Default error message Class>[] groups() default {}; // Validation group Class extends Payload>[] payload() default {}; // Payload information}

• @Constraint(validatedBy = ListValidator.class): This is the key part, which associates the @ValidList annotation with the ListValidator class we are about to create, indicating that ListValidator will be responsible for handling the validation logic of this annotation.
• message(): Defines the default error message returned when validation fails.
• groups() and payload(): attributes of standard Bean Validation annotations, used for group verification and passing additional information.

Step 2: Implement custom validator ListValidator

Next, create the ListValidator class, which will implement the ConstraintValidator interface and contain the actual validation logic.

 import java.util.List;
import java.util.Objects;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

public class ListValidator implements ConstraintValidator<validlist list>&gt; {

    @Override
    public void initialize(ValidList constraintAnnotation) {
        // You can get the properties of the annotation here, such as customized error messages, etc.}

    @Override
    public boolean isValid(List&gt; list, ConstraintValidatorContext context) {
        // If the List itself is null, empty, or contains any null elements, it is considered invalid // Note: The logic here is that as long as the List itself is null, empty List, or there is any null element in the List, it is considered invalid.
        // You can adjust this logic according to actual business needs.
        if (list == null || list.isEmpty()) {
            return false; // List is null or empty, considered invalid}
        // Check if there is a null element in the List return list.stream().noneMatch(Objects::isNull);
    }
}</validlist>

• ConstraintValidator>: The first generic parameter is the custom annotation type, and the second generic parameter is the field type to which the annotation will be applied (here List>, representing any type of List).
• initialize() method: called when the validator is initialized, and can be used to obtain the properties defined in the annotations.
• isValid() method: This is where the core validation logic lies.
  • First check whether the incoming list is null or isEmpty(). If so, return false directly.
  • Next, use list.stream().noneMatch(Objects::isNull) to check if there are any null elements in the List. If there are any null elements, noneMatch will return false, causing isValid to return false, indicating that validation failed.
  • The logic here can be adapted to specific needs. For example, if you allow a List to be empty but not contain null elements, you can remove the list.isEmpty() check.

Step 3: Apply custom annotations to the data model

Finally, in your data model, replace or supplement the original @NotEmpty annotation with @ValidList.

 import javax.validation.Valid;
import java.util.List;

public class Data {
    @ValidList // Use our custom validation annotation private List values;

    public List<string> getValues() {
        return values;
    }

    public void setValues(List<string> values) {
        this.values ​​= values;
    }

    public Data() {
    }

    public Data(List values) {
        this.values ​​= values;
    }
}</string></string>

With the above modification, when request body 4 { "values": [null] } is sent, ListValidator's isValid method will detect that the List contains null elements, thus returning false, triggering validation failure, and returning the expected 400 BAD REQUEST response.

Notes and Summary

1. Annotations for combined use: If you hope that the List itself cannot be null, cannot be empty, and cannot contain null elements, you can use @NotNull (used to check whether the List itself is null), @NotEmpty (used to check whether the List is empty) and @ValidList (used to check whether the internal elements of the List are null). But usually, the isValid method of @ValidList already contains checks for null and empty, so @ValidList can be used directly.

2. Error message internationalization: You can use placeholders (such as {my.custom.validation.message}) in the message attribute, and then define the corresponding internationalized message in the ValidationMessages.properties file.

3. Spring Boot integration: In a Spring Boot application, make sure you use the @Valid or @Validated annotation on your controller method parameters to activate Bean Validation.

    @RestController
   @RequestMapping("/api/data")
   public class DataController {
   
       @PostMapping
       public ResponseEntity<string> createData(@Valid @RequestBody Data data) {
           // Process business logic return ResponseEntity.ok("Data created successfully");
       }
   }</string>

4. Flexibility: The isValid method of a custom validator provides great flexibility. You can implement more complex validation logic according to business needs, such as checking the uniqueness of elements in a List, meeting specific format requirements, etc.

By customizing validation annotations and validators, we can effectively extend the functionality of Bean Validation and handle complex validation scenarios that cannot be met by standard annotations, thereby improving the data integrity and robustness of the application.

The above is the detailed content of Solve the problem that the @NotEmpty annotation fails when the List collection contains null elements. For more information, please follow other related articles on the PHP Chinese website!