Hibernate 6中PostgreSQL JSONB字段的泛型实体定义与枚举反序列化

你提到的泛型实体SettingEntity<T>在JPA规范中是不被支持的，因为Hibernate需要明确的实体类型元数据来处理持久化。下面提供几种可行的方案，实现基于枚举SettingType动态反序列化JSONB字段到对应Java类的需求。

前置定义：枚举与对应Java类 #

首先定义枚举SettingType，关联每个类型对应的Java类：

public enum SettingType {
    USER_PREFERENCES(UserPreferences.class),
    SYSTEM_CONFIG(SystemConfig.class),
    FEATURE_FLAGS(FeatureFlags.class);

    private final Class<?> valueType;

    SettingType(Class<?> valueType) {
        this.valueType = valueType;
    }

    public Class<?> getValueType() {
        return valueType;
    }
}

// 示例对应Java类
public class UserPreferences {
    private String theme;
    private int timezoneOffset;
    // getter、setter省略
}

public class SystemConfig {
    private boolean maintenanceMode;
    private int maxConcurrentUsers;
    // getter、setter省略
}

方案一：利用实体回调（@PostLoad/@PrePersist） #

通过瞬态字段存储反序列化后的对象，在实体加载/保存时手动处理JSON转换：

@Getter
@Setter
@Entity
@Table(name = "setting")
public class SettingEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Enumerated(EnumType.STRING)
    private SettingType type;

    // 数据库存储的原始JSON字符串
    @Column(name = "values", columnDefinition = "jsonb")
    @JdbcTypeCode(SqlTypes.JSON)
    private String valuesJson;

    // 瞬态字段：不持久化，仅用于业务逻辑
    @Transient
    private Object values;

    // 加载实体后反序列化JSON
    @PostLoad
    public void postLoad() {
        if (valuesJson != null && type != null) {
            try {
                ObjectMapper mapper = new ObjectMapper();
                values = mapper.readValue(valuesJson, type.getValueType());
            } catch (JsonProcessingException e) {
                throw new RuntimeException("反序列化配置值失败", e);
            }
        }
    }

    // 保存/更新前序列化对象为JSON
    @PrePersist
    @PreUpdate
    public void prePersist() {
        if (values != null && type != null) {
            try {
                ObjectMapper mapper = new ObjectMapper();
                valuesJson = mapper.writeValueAsString(values);
            } catch (JsonProcessingException e) {
                throw new RuntimeException("序列化配置值失败", e);
            }
        }
    }
}

优点：实现简单，无需复杂的Hibernate扩展；缺点：需要区分持久化字段和业务字段，代码稍显冗余。

方案二：自定义CompositeUserType（推荐） #

实现Hibernate的CompositeUserType，直接关联实体的type字段完成动态转换：

public class SettingValueType implements CompositeUserType<Object> {
    private final ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public String[] getPropertyNames() {
        return new String[]{"values", "type"};
    }

    @Override
    public Type[] getPropertyTypes() {
        return new Type[]{String.class, SettingType.class};
    }

    @Override
    public Object getPropertyValue(Object component, int property) {
        if (component == null || property != 0) return null;
        try {
            return objectMapper.writeValueAsString(component);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void setPropertyValue(Object component, int property, Object value) {}

    @Override
    public Class<Object> returnedClass() {
        return Object.class;
    }

    @Override
    public boolean equals(Object x, Object y) {
        return Objects.equals(x, y);
    }

    @Override
    public int hashCode(Object x) {
        return x != null ? x.hashCode() : 0;
    }

    // 从数据库加载时，根据实体的type字段反序列化JSON
    @Override
    public Object nullSafeGet(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner) throws SQLException {
        String json = rs.getString(names[0]);
        if (json == null) return null;

        SettingEntity setting = (SettingEntity) owner;
        SettingType type = setting.getType();
        if (type == null) throw new IllegalStateException("配置类型为空，无法反序列化");

        try {
            return objectMapper.readValue(json, type.getValueType());
        } catch (JsonProcessingException e) {
            throw new RuntimeException("反序列化配置值失败", e);
        }
    }

    // 保存到数据库时序列化对象
    @Override
    public void nullSafeSet(PreparedStatement st, Object value, int index, SharedSessionContractImplementor session) throws SQLException {
        if (value == null) {
            st.setNull(index, Types.OTHER);
            return;
        }
        try {
            String json = objectMapper.writeValueAsString(value);
            st.setObject(index, json, SqlTypes.JSON);
        } catch (JsonProcessingException e) {
            throw new RuntimeException("序列化配置值失败", e);
        }
    }

    @Override
    public Object deepCopy(Object value) {
        if (value == null) return null;
        try {
            String json = objectMapper.writeValueAsString(value);
            return objectMapper.readValue(json, value.getClass());
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public boolean isMutable() { return true; }

    @Override
    public Serializable disassemble(Object value) { return (Serializable) deepCopy(value); }

    @Override
    public Object assemble(Serializable cached, Object owner) { return deepCopy(cached); }

    @Override
    public Object replace(Object original, Object target, Object owner) { return deepCopy(original); }
}

然后修改实体类：

@Getter
@Setter
@Entity
@Table(name = "setting")
public class SettingEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Enumerated(EnumType.STRING)
    private SettingType type;

    @Column(name = "values", columnDefinition = "jsonb")
    @Type(SettingValueType.class)
    private Object values;
}

优点：完全贴合Hibernate持久化模型，业务代码无需区分字段；缺点：需要实现自定义类型，代码量较大。

方案三：Jackson多态反序列化 #

利用Jackson的多态注解，通过JSON中的类型标识自动匹配类：

1. 定义所有配置类的父类：

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "@type")
@JsonSubTypes({
        @JsonSubTypes.Type(value = UserPreferences.class, name = "USER_PREFERENCES"),
        @JsonSubTypes.Type(value = SystemConfig.class, name = "SYSTEM_CONFIG"),
        @JsonSubTypes.Type(value = FeatureFlags.class, name = "FEATURE_FLAGS")
})
public abstract class SettingValue {}

2. 修改实体类：

@Getter
@Setter
@Entity
@Table(name = "setting")
public class SettingEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Enumerated(EnumType.STRING)
    private SettingType type;

    @Column(name = "values", columnDefinition = "jsonb")
    @JdbcTypeCode(SqlTypes.JSON)
    private SettingValue values;

    // 同步枚举类型与JSON中的类型标识
    @PrePersist
    @PreUpdate
    public void syncType() {
        if (values != null) {
            // 从Jackson的类型注解中获取对应枚举值
            JsonSubTypes.Type annotation = values.getClass().getAnnotation(JsonSubTypes.Type.class);
            this.type = SettingType.valueOf(annotation.name());
        }
    }
}

优点：代码简洁，利用Jackson原生特性；缺点：JSON中会冗余存储@type字段，需要维护枚举与注解的一致性。

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