Hibernate @Embeddable 组合字段的后加载验证策略

<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>6.2.0.Final</version> <!-- 或更高版本 -->
</dependency>
<dependency>
    <groupId>jakarta.validation</groupId>
    <artifactId>jakarta.validation-api</artifactId>
    <version>2.0.2</version> <!-- 或更高版本 -->
</dependency>

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

@Target({ElementType.TYPE}) // 作用于类/接口/枚举
@Retention(RetentionPolicy.RUNTIME) // 运行时可用
@Constraint(validatedBy = ValidCombinationValidator.class) // 指定对应的验证器
@Documented
public @interface ValidCombination {
    String message() default "Invalid combination of fields."; // 默认错误信息
    Class<?>[] groups() default {}; // 验证组
    Class<? extends Payload>[] payload() default {}; // 负载信息
}

import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;

public class ValidCombinationValidator implements ConstraintValidator<ValidCombination, MyEmbeddable> {

    @Override
    public void initialize(ValidCombination constraintAnnotation) {
        // 可以在这里获取注解的参数，例如message
    }

    @Override
    public boolean isValid(MyEmbeddable embeddable, ConstraintValidatorContext context) {
        if (embeddable == null) {
            return true; // 如果embeddable对象为null，则认为有效（或者根据业务需求返回false）
        }

        // 假设MyEmbeddable有type和value字段
        MyEmbeddable.Type type = embeddable.getType();
        Object value = embeddable.getValue();

        // 示例验证逻辑：
        // 只有当type是ENUM_A时，value不能为null
        if (type == MyEmbeddable.Type.ENUM_A) {
            if (value == null) {
                // 自定义错误信息和路径
                context.disableDefaultConstraintViolation(); // 禁用默认错误信息
                context.buildConstraintViolationWithTemplate("Value cannot be null when type is ENUM_A.")
                       .addPropertyNode("value") // 指明哪个字段出错
                       .addConstraintViolation();
                return false;
            }
            // 更多针对ENUM_A的value验证...
        }
        // 只有当type是ENUM_B时，value必须是String类型且长度大于5
        else if (type == MyEmbeddable.Type.ENUM_B) {
            if (!(value instanceof String) || ((String) value).length() <= 5) {
                context.disableDefaultConstraintViolation();
                context.buildConstraintViolationWithTemplate("Value must be a string longer than 5 when type is ENUM_B.")
                       .addPropertyNode("value")
                       .addConstraintViolation();
                return false;
            }
        }
        // ... 其他组合验证规则

        return true; // 所有验证通过
    }
}

import jakarta.persistence.Embeddable;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.Column;

@Embeddable
@ValidCombination // 应用自定义的类级别验证注解
public class MyEmbeddable {

    public enum Type {
        ENUM_A, ENUM_B, ENUM_C
    }

    @Enumerated(EnumType.STRING)
    @Column(name = "embeddable_type")
    private Type type;

    @Column(name = "embeddable_value")
    private String value; // 假设value是String类型，实际可能是Object或接口

    // 无参构造器是JPA/Hibernate的要求
    public MyEmbeddable() {
    }

    public MyEmbeddable(Type type, String value) {
        this.type = type;
        this.value = value;
    }

    // Getters and Setters
    public Type getType() {
        return type;
    }

    public void setType(Type type) {
        this.type = type;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}

import jakarta.persistence.*;
import jakarta.validation.Valid; // 用于级联验证

@Entity
public class MyEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @Embedded
    @Valid // 确保嵌入式对象也被验证
    private MyEmbeddable data;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public MyEmbeddable getData() {
        return data;
    }

    public void setData(MyEmbeddable data) {
        this.data = data;
    }

    // ... 构造器等
}

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

public class ValidationService {

    private final Validator validator;

    public ValidationService() {
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        this.validator = factory.getValidator();
    }

    public <T> Set<ConstraintViolation<T>> validate(T object) {
        return validator.validate(object);
    }

    public static void main(String[] args) {
        ValidationService service = new ValidationService();

        // 示例：创建一个无效的MyEmbeddable实例
        MyEmbeddable invalidEmbeddable = new MyEmbeddable(MyEmbeddable.Type.ENUM_A, null);
        MyEntity entity = new MyEntity();
        entity.setName("Test Entity");
        entity.setData(invalidEmbeddable);

        Set<ConstraintViolation<MyEntity>> violations = service.validate(entity);

        if (!violations.isEmpty()) {
            System.out.println("Validation errors found:");
            for (ConstraintViolation<MyEntity> violation : violations) {
                System.out.println("  - " + violation.getPropertyPath() + ": " + violation.getMessage());
            }
        } else {
            System.out.println("Entity is valid.");
        }
    }
}