Hibernate Embeddable加载后验证：合法组合校验实现方案

针对你的需求，这里提供几种优雅的实现方案，核心是在Hibernate加载实体并完成Embeddable属性注入后，自动触发type与value的组合合法性校验：

方案一：直接在@Embeddable类上使用@PostLoad（推荐，Hibernate 5.3+） #

Hibernate从5.3版本开始支持在@Embeddable类上直接使用生命周期注解，包括@PostLoad。这个注解标注的方法会在Hibernate完成该Embeddable实例的属性注入后自动调用，完美适配你的校验场景。

示例代码：

@Embeddable
public class MyEmbeddable {
    @Enumerated(EnumType.STRING)
    private MyType type;
    
    @Column(name = "value_data")
    @Convert(converter = ValueConverter.class) // 适配多实现接口类型的字段转换器
    private MyValueInterface value;

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

    // 业务构造器、getter/setter省略

    @PostLoad
    public void validateCombination() {
        // 基础非空校验
        if (type == null || value == null) {
            throw new IllegalArgumentException("type和value不能为空");
        }
        // 特定组合校验逻辑
        switch (type) {
            case TYPE_A:
                if (!(value instanceof ValueAImpl)) {
                    throw new IllegalArgumentException("type为TYPE_A时，value必须是ValueAImpl类型");
                }
                break;
            case TYPE_B:
                if (!(value instanceof ValueBImpl)) {
                    throw new IllegalArgumentException("type为TYPE_B时，value必须是ValueBImpl类型");
                }
                break;
            default:
                throw new IllegalArgumentException("不支持的type类型：" + type);
        }
    }
}

这种方式的优势是校验逻辑完全内聚在@Embeddable类中，不需要修改任何实体类，代码简洁且符合单一职责原则。

方案二：自定义Hibernate Interceptor（兼容旧版本Hibernate） #

如果你的项目使用的Hibernate版本低于5.3，无法直接在Embeddable上使用@PostLoad，可以通过自定义Interceptor来实现全局校验：

1. 实现Interceptor #

public class EmbeddableValidationInterceptor extends EmptyInterceptor {
    @Override
    public boolean onLoad(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types) {
        // 遍历实体的所有字段，找到MyEmbeddable类型的属性
        Field[] fields = entity.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (MyEmbeddable.class.isAssignableFrom(field.getType())) {
                try {
                    field.setAccessible(true);
                    MyEmbeddable embeddable = (MyEmbeddable) field.get(entity);
                    if (embeddable != null) {
                        embeddable.validateCombination(); // 调用Embeddable中定义的校验方法
                    }
                } catch (IllegalAccessException e) {
                    throw new RuntimeException("校验Embeddable组合合法性失败", e);
                }
            }
        }
        return super.onLoad(entity, id, state, propertyNames, types);
    }
}

2. 配置Interceptor到Hibernate #

如果使用persistence.xml：

<persistence-unit name="yourPersistenceUnit">
    <!-- 其他配置 -->
    <properties>
        <property name="hibernate.ejb.interceptor" value="com.yourpackage.EmbeddableValidationInterceptor"/>
    </properties>
</persistence-unit>

如果使用Java配置：

SessionFactory sessionFactory = new Configuration()
        .setInterceptor(new EmbeddableValidationInterceptor())
        // 其他配置（如映射文件、数据库连接等）
        .buildSessionFactory();

这种方式的好处是无需修改实体类，校验逻辑依然集中在Embeddable内部，适配低版本Hibernate。

方案三：结合Bean Validation（适合已用校验框架的项目） #

如果你的项目已经引入了Jakarta Bean Validation（原JSR-380），可以通过@AssertTrue注解定义组合校验规则，再通过Interceptor触发加载时的校验：

1. 在Embeddable中定义校验规则 #

@Embeddable
public class MyEmbeddable {
    // 字段定义省略

    @AssertTrue(message = "type与value的组合不合法")
    public boolean isCombinationValid() {
        if (type == null || value == null) return false;
        switch (type) {
            case TYPE_A:
                return value instanceof ValueAImpl;
            case TYPE_B:
                return value instanceof ValueBImpl;
            default:
                return false;
        }
    }
}

2. 自定义Interceptor触发校验 #

public class ValidationInterceptor extends EmptyInterceptor {
    private final Validator validator;

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

    @Override
    public boolean onLoad(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types) {
        // 校验实体及其包含的Embeddable属性
        Set<ConstraintViolation<Object>> violations = validator.validate(entity);
        if (!violations.isEmpty()) {
            throw new ConstraintViolationException("实体属性校验失败", violations);
        }
        return super.onLoad(entity, id, state, propertyNames, types);
    }
}

这种方式可以复用已有的校验框架，适合需要统一校验规则的项目。

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