在Hibernate中对@Embeddable组合字段进行加载后验证

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

@Target({ElementType.TYPE}) // 作用于类级别
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = ValidMyEmbeddableCombinationValidator.class) // 指定验证器
@Documented
public @interface ValidMyEmbeddableCombination {

    String message() default "Type and value combination is invalid."; // 默认错误消息

    Class<?>[] groups() default {}; // 验证组

    Class<? extends Payload>[] payload() default {}; // 负载信息
}

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

// 假设MyType是一个枚举，MyValue是一个接口
enum MyType {
    TYPE_A, TYPE_B, TYPE_C
}

interface MyValue {
    // 示例方法
    String getValueData();
}

// 示例实现
class MyStringValue implements MyValue {
    private String data;
    public MyStringValue(String data) { this.data = data; }
    @Override public String getValueData() { return data; }
}

class MyIntegerValue implements MyValue {
    private Integer data;
    public MyIntegerValue(Integer data) { this.data = data; }
    @Override public String getValueData() { return String.valueOf(data); }
}


public class ValidMyEmbeddableCombinationValidator implements ConstraintValidator<ValidMyEmbeddableCombination, MyEmbeddable> {

    @Override
    public void initialize(ValidMyEmbeddableCombination constraintAnnotation) {
        // 可以在此处初始化验证器，例如获取注解中的参数
    }

    @Override
    public boolean isValid(MyEmbeddable embeddable, ConstraintValidatorContext context) {
        if (embeddable == null) {
            return true; // null embeddable 可以通过，如果需要非空验证，应使用 @NotNull
        }

        MyType type = embeddable.getType();
        MyValue value = embeddable.getValue();

        // 示例验证逻辑：
        // 1. 如果 type 是 TYPE_A，那么 value 必须是 MyStringValue
        // 2. 如果 type 是 TYPE_B，那么 value 必须是 MyIntegerValue
        // 3. 如果 type 是 TYPE_C，则不做额外限制

        boolean isValid = true;
        String errorMessage = null;

        if (type == MyType.TYPE_A) {
            if (!(value instanceof MyStringValue)) {
                isValid = false;
                errorMessage = "For TYPE_A, value must be a MyStringValue.";
            }
        } else if (type == MyType.TYPE_B) {
            if (!(value instanceof MyIntegerValue)) {
                isValid = false;
                errorMessage = "For TYPE_B, value must be a MyIntegerValue.";
            }
        }
        // 可以添加更多复杂的组合验证逻辑

        if (!isValid) {
            // 禁用默认的错误消息
            context.disableDefaultConstraintViolation();
            // 添加自定义的错误消息到特定字段或整个对象
            context.buildConstraintViolationWithTemplate(errorMessage)
                   .addConstraintViolation();
        }

        return isValid;
    }
}

import javax.persistence.Embeddable;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.Transient; // 假设MyValue不直接映射到数据库，而是通过其他方式处理或计算

@Embeddable
@ValidMyEmbeddableCombination // 应用自定义类级别约束
public class MyEmbeddable {

    @Enumerated(EnumType.STRING)
    private MyType type;

    // 假设MyValue的持久化逻辑在其他地方处理，或者它是一个复合对象
    // 这里为了演示，我们假设它是一个瞬态字段，或者通过一个转换器来持久化
    @Transient // 或者使用 @Convert 等
    private MyValue value;

    // 无参构造函数是Hibernate所必需的
    public MyEmbeddable() {
    }

    public MyEmbeddable(MyType type, MyValue value) {
        this.type = type;
        this.value = value;
    }

    public MyType getType() {
        return type;
    }

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

    public MyValue getValue() {
        return value;
    }

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

    // toString, equals, hashCode...
}

import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.validation.Valid; // 导入 @Valid

@Entity
public class MyEntity {

    @Id
    @GeneratedValue
    private Long id;

    private String name;

    @Valid // 确保MyEmbeddable在验证MyEntity时也被验证
    @Embedded
    private MyEmbeddable embeddableData;

    public MyEntity() {
    }

    public MyEntity(String name, MyEmbeddable embeddableData) {
        this.name = name;
        this.embeddableData = embeddableData;
    }

    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 getEmbeddableData() {
        return embeddableData;
    }

    public void setEmbeddableData(MyEmbeddable embeddableData) {
        this.embeddableData = embeddableData;
    }
}

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

public class ValidationExample {

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

        // 1. 验证通过的场景
        MyEmbeddable validEmbeddable = new MyEmbeddable(MyType.TYPE_A, new MyStringValue("test_string"));
        MyEntity validEntity = new MyEntity("Valid Entry", validEmbeddable);
        Set<ConstraintViolation<MyEntity>> violations = validator.validate(validEntity);
        System.out.println("Valid Entity Violations: " + violations.isEmpty()); // 应该为 true

        // 2. 验证失败的场景
        MyEmbeddable invalidEmbeddable = new MyEmbeddable(MyType.TYPE_A, new MyIntegerValue(123)); // TYPE_A 期望 MyStringValue
        MyEntity invalidEntity = new MyEntity("Invalid Entry", invalidEmbeddable);
        violations = validator.validate(invalidEntity);
        System.out.println("Invalid Entity Violations: " + violations.isEmpty()); // 应该为 false
        if (!violations.isEmpty()) {
            violations.forEach(v -> System.out.println("Error: " + v.getMessage() + " (Path: " + v.getPropertyPath() + ")"));
        }

        // 3. 加载后显式验证 (模拟从数据库加载)
        // 假设从数据库加载了一个实体，我们希望立即验证它
        MyEntity loadedEntity = new MyEntity("Loaded Entity", new MyEmbeddable(MyType.TYPE_B, new MyStringValue("wrong type")));
        Set<ConstraintViolation<MyEntity>> postLoadViolations = validator.validate(loadedEntity);
        System.out.println("Post-load Validation Violations: " + postLoadViolations.isEmpty()); // 应该为 false
        if (!postLoadViolations.isEmpty()) {
            postLoadViolations.forEach(v -> System.out.println("Post-load Error: " + v.getMessage() + " (Path: " + v.getPropertyPath() + ")"));
        }
    }
}