Spring Validation：为单个字段多约束获取唯一关联校验消息

Hey there! The issue you're facing is that Bean Validation (like Hibernate Validator) runs all constraints on a field by default and collects all failure messages, even if some constraints are actually satisfied by the input. For your example with "af3", the @NotNull, @Min(3), and @Max(40) constraints are all passing—only the @Pattern check fails, so you should only see that one message.

To fix this and get only the relevant error message for each input scenario, you can use validation group sequences to enforce an order of checks. This way, the validator stops checking subsequent constraints once a failure is found, returning only the first (and only relevant) error.

Step 1: Define Validation Groups #

First, create empty marker interfaces to represent each check group. These groups let you organize constraints into sequential stages:

public interface ValidationGroups {
    // Group for null check
    interface NotNullCheck {}
    // Group for minimum length check
    interface MinLengthCheck {}
    // Group for maximum length check
    interface MaxLengthCheck {}
    // Group for pattern check
    interface PatternCheck {}
}

Step 2: Assign Constraints to Groups & Define Sequence #

Update your bean class to assign each constraint to its corresponding group, then use @GroupSequence to specify the order of validation. The validator will run checks in this order, and stop at the first failed group:

import jakarta.validation.constraints.*;
import jakarta.validation.GroupSequence;

@GroupSequence({
    ValidationGroups.NotNullCheck.class,
    ValidationGroups.MinLengthCheck.class,
    ValidationGroups.MaxLengthCheck.class,
    ValidationGroups.PatternCheck.class
})
public class YourBean {

    @NotNull(
        message = "Name can not be null",
        groups = ValidationGroups.NotNullCheck.class
    )
    @Min(
        value = 3,
        message = "Name should be at least 3 chars long",
        groups = ValidationGroups.MinLengthCheck.class
    )
    @Max(
        value = 40,
        message = "Name can not be longer than 40 chars",
        groups = ValidationGroups.MaxLengthCheck.class
    )
    @Pattern(
        regexp = "[a-zA-Z]+",
        message = "Name can only contain letters",
        groups = ValidationGroups.PatternCheck.class
    )
    private String name;

    // Add getters and setters here
}

Step 3: Validate Using the Group Sequence #

When validating your bean, use the top-level ValidationGroups interface to trigger the sequence. Here's how to do it with raw Bean Validation:

import jakarta.validation.Validation;
import jakarta.validation.Validator;
import jakarta.validation.ValidatorFactory;
import java.util.Set;

public class ValidationExample {
    public static void main(String[] args) {
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();

        YourBean bean = new YourBean();
        bean.setName("af3"); // Your test input

        Set<ConstraintViolation<YourBean>> violations = validator.validate(bean, ValidationGroups.class);

        for (ConstraintViolation<YourBean> violation : violations) {
            System.out.println(violation.getMessage());
            // Will only print: "Name can only contain letters"
        }
    }
}

If You're Using Spring Boot #

In Spring MVC/Spring Boot, use @Validated with the group sequence to enforce this behavior in your controller:

import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class YourController {

    @PostMapping("/submit")
    public ResponseEntity<?> submitBean(@Validated(ValidationGroups.class) @RequestBody YourBean bean) {
        // Process the bean
        return ResponseEntity.ok("Success");
    }
}

How This Works #

• The group sequence tells the validator to run checks in a specific order: first check if the field is not null, then check minimum length, then maximum length, finally the pattern.
• If any check in the sequence fails, the validator stops processing subsequent groups. This ensures you only get the error message relevant to the first failed constraint (which is the most critical issue for the input).

For your test case "af3":

1. @NotNull passes (field is not null)
2. @Min(3) passes (length is 3)
3. @Max(40) passes (length is under 40)
4. @Pattern fails → validator returns only this error message.

Other scenarios:

• Input null → only @NotNull error is returned
• Input "a" → only @Min(3) error is returned
• Input a 50-letter string → only @Max(40) error is returned

内容的提问来源于stack exchange，提问作者Deb