Spring Validator基于条件的验证实现需求指导

针对你提出的「当isPrimary为true时仅验证primaryDTO，忽略secendoryDTO」的需求，我整理了两种实用的实现方案，你可以根据项目情况选择：

方案一：自定义类级别Validator（灵活可控） #

这种方式完全自定义验证逻辑，适合复杂的条件判断场景。

步骤1：创建自定义验证注解 #

先定义一个类级别的注解，用来标记需要条件验证的UserDTO：

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.*;

@Documented
@Constraint(validatedBy = UserDTOValidator.class)
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ConditionalValidateUser {
    String message() default "Validation failed based on primary flag";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

步骤2：实现Validator逻辑 #

编写验证器，根据isPrimary的值决定要验证的DTO：

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import javax.validation.Validator;
import org.springframework.beans.factory.annotation.Autowired;

public class UserDTOValidator implements ConstraintValidator<ConditionalValidateUser, UserDTO> {

    @Autowired
    private Validator validator;

    @Override
    public void initialize(ConditionalValidateUser constraintAnnotation) {
        // 初始化逻辑（可选）
    }

    @Override
    public boolean isValid(UserDTO userDTO, ConstraintValidatorContext context) {
        // 关闭默认的约束违规提示，我们自己处理
        context.disableDefaultConstraintViolation();
        boolean isValid = true;

        if (userDTO.isPrimary()) {
            // 仅验证PrimaryDTO，将验证错误关联到对应的字段
            validator.validate(userDTO.getPrimaryDTO()).forEach(violation -> {
                context.buildConstraintViolationWithTemplate(violation.getMessage())
                        .addPropertyNode("primaryDTO." + violation.getPropertyPath())
                        .addConstraintViolation();
                isValid = false;
            });
        } else {
            // 这里可以根据需求调整：如果isPrimary为false时需要验证secendoryDTO，保留这段；如果不需要则删除
            validator.validate(userDTO.getSecendoryDTO()).forEach(violation -> {
                context.buildConstraintViolationWithTemplate(violation.getMessage())
                        .addPropertyNode("secendoryDTO." + violation.getPropertyPath())
                        .addConstraintViolation();
                isValid = false;
            });
        }

        return isValid;
    }
}

步骤3：修改UserDTO类 #

去掉原来的@Valid注解，替换成我们自定义的注解：

@ConditionalValidateUser
public class UserDTO {
    private PrimaryDTO primaryDTO;
    private SecendoryDTO secendoryDTO;
    private boolean isPrimary;

    // 别忘了添加getter和setter方法
}

步骤4：在Controller中使用 #

直接用@Valid标记请求体即可：

@PostMapping("/users")
public ResponseEntity<String> createUser(@Valid @RequestBody UserDTO userDTO) {
    // 业务逻辑处理
    return ResponseEntity.ok("User created successfully");
}

方案二：利用验证分组+GroupSequenceProvider（原生机制） #

这种方式基于Spring/Hibernate Validator的原生分组功能，代码更简洁，适合规则清晰的场景。

步骤1：定义验证分组 #

创建两个空接口作为分组标记：

// 验证PrimaryDTO的分组
public interface PrimaryGroup {}

// 验证SecendoryDTO的分组
public interface SecendoryGroup {}

步骤2：给DTO字段指定分组 #

修改PrimaryDTO和SecendoryDTO，将验证注解绑定到对应分组：

public class PrimaryDTO {
    @NotEmpty(message = "Please enter email.", groups = PrimaryGroup.class)
    @Email(message = "Please enter a valid email.", groups = PrimaryGroup.class)
    private String email;

    // getter和setter
}

public class SecendoryDTO {
    @NotEmpty(message = "Please enter phone.", groups = SecendoryGroup.class)
    private String phone;

    // getter和setter
}

步骤3：给UserDTO配置分组序列提供者 #

通过@GroupSequenceProvider动态决定要启用的验证分组：

import org.hibernate.validator.grouping.GroupSequenceProvider;

@GroupSequenceProvider(UserDTOGroupSequenceProvider.class)
public class UserDTO {
    @Valid private PrimaryDTO primaryDTO;
    @Valid private SecendoryDTO secendoryDTO;
    private boolean isPrimary;

    // getter和setter
}

步骤4：实现GroupSequenceProvider #

编写逻辑，根据isPrimary的值选择要验证的分组：

import org.hibernate.validator.spi.group.DefaultGroupSequenceProvider;
import java.util.ArrayList;
import java.util.List;

public class UserDTOGroupSequenceProvider implements DefaultGroupSequenceProvider<UserDTO> {

    @Override
    public List<Class<?>> getValidationGroups(UserDTO userDTO) {
        List<Class<?>> groups = new ArrayList<>();
        groups.add(UserDTO.class); // 先验证默认分组

        if (userDTO != null) {
            if (userDTO.isPrimary()) {
                groups.add(PrimaryGroup.class); // 仅启用Primary分组验证
            } else {
                groups.add(SecendoryGroup.class); // 启用Secendory分组验证
            }
        }

        return groups;
    }
}

步骤5：在Controller中使用 #

注意这里要用@Validated而不是@Valid：

@PostMapping("/users")
public ResponseEntity<String> createUser(@Validated @RequestBody UserDTO userDTO) {
    // 业务逻辑处理
    return ResponseEntity.ok("User created successfully");
}

方案选择建议 #

• 如果你的条件验证逻辑后续可能变得复杂（比如新增更多判断条件），优先选方案一，灵活性更高；
• 如果只是简单的二选一验证，方案二更贴合原生验证机制，代码更简洁易维护。

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