如何使用Hibernate创建可引用多种不同类型实体的Entity集合字段

核心思路 #

通过多态实体抽象+中间关联表实现，既保留现有Block分表存储的结构，也支持同类型Block重复存储、自定义排序，最终可直接序列化出要求的JSON格式。

具体实现步骤 #

1. 抽象Block公共父类 #

提取所有Block的公共属性，用JPA继承适配分表结构：

@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
@MappedSuperclass
public abstract class Block implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 可补充所有Block通用字段
    // getter、setter
}

原有BlockA、BlockB修改为继承该父类即可，其余逻辑无需改动：

@Entity
@Table(name = "blockA")
public class BlockA extends Block {
    // 原有字段、getter、setter保留
}

@Entity
@Table(name = "BlockB")
public class BlockB extends Block {
    // 原有字段、getter、setter保留
}

2. 新增Stage和Block的中间关联实体 #

解决不同表Block无法直接关联的问题，同时记录排序：

@Entity
@Table(name = "stage_block")
public class StageBlock {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "stage_id", nullable = false)
    private Stage stage;

    @Column(name = "block_id", nullable = false)
    private Long blockId;

    // 标记Block类型，取值为BLOCK_A、BLOCK_B等
    @Column(name = "block_type", nullable = false)
    private String blockType;

    // 排序字段，控制Block列表的顺序
    @Column(name = "sort", nullable = false)
    private Integer sort;

    // getter、setter
}

3. 改造Stage实体 #

维护关联关系，增加序列化专用的Block列表字段：

@Entity
@Table(name = "stage")
public class Stage {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "stage", cascade = CascadeType.ALL, orphanRemoval = true)
    @OrderBy("sort asc")
    private List<StageBlock> stageBlocks = new ArrayList<>();

    // 不持久化到数据库，仅用于JSON序列化
    @Transient
    private List<Block> blocks = new ArrayList<>();

    // 填充多态Block列表，业务查询后调用即可
    public void assembleBlocks(BlockAService blockAService, BlockBService blockBService) {
        this.blocks = stageBlocks.stream()
                .map(sb -> {
                    if ("BLOCK_A".equals(sb.getBlockType())) {
                        return blockAService.getById(sb.getBlockId());
                    } else if ("BLOCK_B".equals(sb.getBlockType())) {
                        return blockBService.getById(sb.getBlockId());
                    }
                    // 新增Block类型只需扩展对应分支
                    return null;
                })
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
    }

    // getter、setter
}

效果验证 #

调用assembleBlocks方法后序列化Stage实体，即可得到要求的输出格式：

{
    "name": "step1",
    "blocks": [
        {"id":1, "...blockA专属字段": "..."},
        {"id":2, "...blockB专属字段": "..."},
        {"id":3, "...blockA专属字段": "..."},
        ...
    ]
}

可选优化（Hibernate专属） #

如果使用Hibernate作为JPA实现，可以通过@Any注解实现自动多态关联，无需手动编写assembleBlocks逻辑：

1. 在Block父类增加元数据定义：

@AnyMetaDef(
    name = "BlockMetaDef", 
    metaType = "string",
    idType = "long",
    metaValues = {
        @MetaValue(value = "BLOCK_A", targetEntity = BlockA.class),
        @MetaValue(value = "BLOCK_B", targetEntity = BlockB.class)
    }
)
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
@MappedSuperclass
public abstract class Block implements Serializable {
    // 原有逻辑不变
}

2. 改造StageBlock实体的关联字段：

@Entity
@Table(name = "stage_block")
public class StageBlock {
    // 其余字段不变
    @Any(metaDef = "BlockMetaDef", metaColumn = @Column(name = "block_type"), fetch = FetchType.LAZY)
    @JoinColumn(name = "block_id")
    private Block block;
}

直接查询Stage关联的stageBlocks即可自动获取对应类型的Block对象，使用更简洁。

方案优势 #

• 无侵入适配现有Block分表结构，无需修改原有表字段
• 支持同类型Block重复添加，可通过sort字段灵活调整顺序
• 扩展性强，新增Block类型只需继承Block父类、扩展类型判断分支即可
• 符合JPA规范，无黑魔法，后续维护成本低

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