Hibernate实现带额外信息的双向自关联图批量插入（避免rowversion递增）

针对你的需求——用Hibernate实现类似原生SQL CTE的一次性节点(Node)和边(Edge)插入，自动关联节点ID且不触发rowversion递增——我整理了几个实用方案，按贴合你需求的优先级排序：

方案1：原生SQL CTE + Hibernate Native Query（最贴近原生CTE思路） #

这个方案直接复用你熟悉的PostgreSQL CTE逻辑，通过Hibernate执行原生SQL，全程单个数据库语句完成，完美匹配你的需求。

实现代码 #

import jakarta.persistence.EntityManager;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Service;

@Service
public class GraphService {

    private final EntityManager entityManager;

    public GraphService(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    @Transactional
    public void batchInsertGraph() {
        String cteInsertSql = """
            WITH inserted_nodes AS (
                INSERT INTO node (name, rowversion)
                VALUES ('A', 0), ('B', 0), ('C', 0)
                RETURNING id, name
            )
            INSERT INTO edge (from_node_id, to_node_id, relation_type)
            -- 插入A到B、A到C的parent关系
            SELECT a.id, b.id, 'parent'
            FROM inserted_nodes a
            JOIN inserted_nodes b ON b.name IN ('B', 'C') AND a.name = 'A'
            UNION ALL
            -- 插入B到A、C到A的child关系
            SELECT b.id, a.id, 'child'
            FROM inserted_nodes a
            JOIN inserted_nodes b ON b.name IN ('B', 'C') AND a.name = 'A'
        """;
        // 执行原生SQL，一次性完成所有插入
        entityManager.createNativeQuery(cteInsertSql).executeUpdate();
    }
}

方案说明 #

• 整个操作是单个数据库语句，由PostgreSQL的CTE保证原子性，要么全成功要么全回滚。
• rowversion在插入时直接设为初始值0，没有后续更新操作，所以不会触发递增。
• 利用CTE的RETURNING子句自动关联节点ID，无需手动插入后再查询ID，完全由数据库层面完成关联。

方案2：Session.doWork() 执行JDBC批量操作（更安全的参数化查询） #

如果需要避免硬编码值（比如动态添加节点），可以用Hibernate的Session.doWork()直接操作JDBC，执行参数化的CTE语句，同样是单个语句完成。

实现代码 #

import org.hibernate.Session;
import jakarta.persistence.EntityManager;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Service;
import java.sql.PreparedStatement;
import java.sql.SQLException;

@Service
public class GraphService {

    private final EntityManager entityManager;

    public GraphService(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    @Transactional
    public void batchInsertWithParams() {
        Session session = entityManager.unwrap(Session.class);
        session.doWork(connection -> {
            String parameterizedCteSql = """
                WITH inserted_nodes AS (
                    INSERT INTO node (name, rowversion)
                    VALUES (?, ?), (?, ?), (?, ?)
                    RETURNING id, name
                )
                INSERT INTO edge (from_node_id, to_node_id, relation_type)
                SELECT a.id, b.id, 'parent'
                FROM inserted_nodes a
                JOIN inserted_nodes b ON b.name IN ('B', 'C') AND a.name = 'A'
                UNION ALL
                SELECT b.id, a.id, 'child'
                FROM inserted_nodes a
                JOIN inserted_nodes b ON b.name IN ('B', 'C') AND a.name = 'A'
            """;
            try (PreparedStatement stmt = connection.prepareStatement(parameterizedCteSql)) {
                // 设置节点参数
                stmt.setString(1, "A");
                stmt.setLong(2, 0);
                stmt.setString(3, "B");
                stmt.setLong(4, 0);
                stmt.setString(5, "C");
                stmt.setLong(6, 0);
                // 执行插入
                stmt.executeUpdate();
            } catch (SQLException e) {
                throw new RuntimeException("批量插入失败", e);
            }
        });
    }
}

方案说明 #

• 用参数化查询避免SQL注入风险，适合动态生成节点数据的场景。
• 依然是单个数据库语句，原子性和rowversion的行为和方案1完全一致。

方案3：纯Hibernate ORM级联保存（多语句但原子性） #

如果更倾向于纯ORM操作，不想写原生SQL，可以通过@OneToMany级联保存实现。不过这个方案会生成多个INSERT语句（先插节点，再插边），但在同一个事务中保证原子性，rowversion同样不会递增。

调整实体类 #

// Node实体
import jakarta.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
public class Node {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 对应PostgreSQL的serial主键
    private Long id;
    private String name;
    @Version // 乐观锁字段，Hibernate自动管理，但这里我们手动设初始值
    private Long rowversion;
    @OneToMany(mappedBy = "fromNode", cascade = CascadeType.PERSIST)
    private List<Edge> outgoingEdges = new ArrayList<>();

    // 添加边的便捷方法
    public void addOutgoingEdge(Node toNode, String relationType) {
        Edge edge = new Edge();
        edge.setFromNode(this);
        edge.setToNode(toNode);
        edge.setRelationType(relationType);
        outgoingEdges.add(edge);
    }

    // Getters & 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 Long getRowversion() { return rowversion; }
    public void setRowversion(Long rowversion) { this.rowversion = rowversion; }
    public List<Edge> getOutgoingEdges() { return outgoingEdges; }
}

// Edge实体
import jakarta.persistence.*;

@Entity
public class Edge {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "from_node_id")
    private Node fromNode;
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "to_node_id")
    private Node toNode;
    private String relationType;

    // Getters & Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public Node getFromNode() { return fromNode; }
    public void setFromNode(Node fromNode) { this.fromNode = fromNode; }
    public Node getToNode() { return toNode; }
    public void setToNode(Node toNode) { this.toNode = toNode; }
    public String getRelationType() { return relationType; }
    public void setRelationType(String relationType) { this.relationType = relationType; }
}

插入代码 #

import jakarta.persistence.EntityManager;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Service;

@Service
public class GraphService {

    private final EntityManager entityManager;

    public GraphService(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    @Transactional
    public void saveGraphViaOrm() {
        Node nodeA = new Node();
        nodeA.setName("A");
        nodeA.setRowversion(0L);

        Node nodeB = new Node();
        nodeB.setName("B");
        nodeB.setRowversion(0L);

        Node nodeC = new Node();
        nodeC.setName("C");
        nodeC.setRowversion(0L);

        // 建立关联关系
        nodeA.addOutgoingEdge(nodeB, "parent");
        nodeA.addOutgoingEdge(nodeC, "parent");
        nodeB.addOutgoingEdge(nodeA, "child");
        nodeC.addOutgoingEdge(nodeA, "child");

        // 持久化节点，级联保存边
        entityManager.persist(nodeA);
        entityManager.persist(nodeB);
        entityManager.persist(nodeC);
    }
}

方案说明 #

• Hibernate会先执行3个Node的INSERT语句，再执行4个Edge的INSERT语句，总共7个语句，但在同一个事务中，原子性有保障。
• rowversion仅在插入时设置初始值，没有更新操作，所以不会递增。
• 完全用ORM操作，无需写SQL，但无法做到单个语句执行。

总结 #

• 如果必须单个语句完成插入，优先选方案1或方案2，利用PostgreSQL的CTE特性，完美匹配你的原生SQL思路。
• 如果可以接受多语句但原子性，方案3的纯ORM方式更符合Hibernate的使用习惯。

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