这种批量导入越跑越慢的问题我碰到过好多次，尤其是用Hibernate做大量关联表数据插入的时候，核心原因大多是Session缓存膨胀、大事务拖垮数据库IO，加上ORM本身的额外开销。结合你的技术栈（Hibernate4、Spring、PostgreSQL9.6），给你几个实操性强的解决方案：

1. 给Hibernate“减负”：定期清空Session缓存+分批提交事务 #

Hibernate的一级Session缓存会默认保存所有持久化对象，导入几万条数据后，缓存里攒了大量对象，不仅占用内存导致频繁GC，还会让Hibernate在flush时做大量脏检查，速度骤降。

解决办法很直接：每插入N条数据（建议500-1000条，根据你的对象大小调整）就手动flush并清空Session，同时分批提交事务——别把27万条数据塞进一个大事务里，PostgreSQL处理超大事务时WAL日志会疯狂膨胀，IO性能直接崩。

示例代码（Spring环境下用SessionFactory）：

@Autowired
private SessionFactory sessionFactory;

public void batchImport(List<MainEntity> mainEntities) {
    Session session = sessionFactory.openSession();
    Transaction tx = null;
    final int BATCH_SIZE = 500;

    try {
        for (int i = 0; i < mainEntities.size(); i++) {
            MainEntity entity = mainEntities.get(i);
            // 手动处理关联对象（避免级联操作的额外开销）
            for (ChildEntity child : entity.getChildren()) {
                child.setMainEntity(entity);
                session.save(child);
            }
            session.save(entity);

            // 每BATCH_SIZE条执行一次提交+缓存清空
            if ((i + 1) % BATCH_SIZE == 0) {
                if (tx == null) {
                    tx = session.beginTransaction();
                }
                session.flush(); // 把SQL发送到数据库
                session.clear(); // 清空Session缓存，释放内存
                tx.commit();
                tx = null;
            }
        }
        // 处理最后一批剩余数据
        if (tx != null) {
            session.flush();
            session.clear();
            tx.commit();
        }
    } catch (Exception e) {
        if (tx != null) tx.rollback();
        throw new RuntimeException("批量导入失败", e);
    } finally {
        session.close();
    }
}

2. 开启Hibernate批量插入模式 #

默认情况下Hibernate会逐条发送SQL，开启批量模式后，它会把同表的插入SQL打包发送，减少数据库交互次数。需要在hibernate.cfg.xml或Spring配置里加这几个参数：

# 设置批量大小，和你上面的BATCH_SIZE对应
hibernate.jdbc.batch_size=500
# 让Hibernate按表分组插入SQL，提升批量效率
hibernate.order_inserts=true
hibernate.order_updates=true
# 禁用JDBC自动提交，交给Hibernate批量处理
hibernate.connection.autocommit=false

⚠️ 注意：如果你的实体用了IDENTITY主键生成策略，PostgreSQL下建议改用SEQUENCE生成策略，或者直接用PostgreSQL的SERIAL/BIGSERIAL，配合hibernate.jdbc.use_get_generated_keys=true，这样Hibernate可以批量获取主键。

3. 跳过ORM开销：用JDBC或PostgreSQL原生COPY命令 #

Hibernate的ORM方便但有额外开销，批量导入场景下，原生JDBC或PostgreSQL的COPY命令速度会快好几倍。

方案A：Spring JdbcTemplate批量插入 #

用JdbcTemplate的batchUpdate方法，直接操作SQL，避免Hibernate的缓存和脏检查：

@Autowired
private JdbcTemplate jdbcTemplate;

public void batchInsertChildren(List<ChildEntity> children) {
    String sql = "INSERT INTO child_table (col1, col2, main_entity_id) VALUES (?, ?, ?)";
    jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
        @Override
        public void setValues(PreparedStatement ps, int i) throws SQLException {
            ChildEntity child = children.get(i);
            ps.setString(1, child.getCol1());
            ps.setInt(2, child.getCol2());
            ps.setLong(3, child.getMainEntityId());
        }

        @Override
        public int getBatchSize() {
            return children.size();
        }
    });
}

方案B：PostgreSQL COPY命令（最快的方式） #

PostgreSQL的COPY是专门为批量导入设计的，速度比JDBC批量还快一个量级。如果你的数据是CSV格式，直接用SQL：

COPY main_table (col1, col2, col3) FROM '/path/to/your/data.csv' WITH CSV HEADER;

如果是内存中的数据，可以用PostgreSQL的PGCopyManager类（需要引入PostgreSQL JDBC驱动）：

@Autowired
private DataSource dataSource;

public void copyImport(List<MainEntity> entities) throws SQLException, IOException {
    Connection conn = dataSource.getConnection();
    PGConnection pgConn = conn.unwrap(PGConnection.class);
    PGCopyManager copyManager = new PGCopyManager(pgConn);

    // 构造COPY命令
    String copySql = "COPY main_table (col1, col2, col3) FROM STDIN WITH CSV";
    try (StringWriter writer = new StringWriter()) {
        // 把实体数据写成CSV格式
        for (MainEntity entity : entities) {
            writer.write(String.format("%s,%d,%s\n", 
                entity.getCol1(), entity.getCol2(), entity.getCol3()));
        }
        // 执行导入
        copyManager.copyIn(copySql, new StringReader(writer.toString()));
    } finally {
        conn.close();
    }
}

4. 数据库层面的优化（关键！） #

光优化代码不够，PostgreSQL的默认配置不适合超大批量导入，需要临时调整参数：

• 禁用约束和索引：导入前先禁用外键约束和删除索引，导入完成后再恢复——插入时维护索引和外键检查会消耗大量CPU和IO。

  -- 禁用外键触发器（导入子表时用）
  ALTER TABLE child_table DISABLE TRIGGER ALL;
  -- 删除索引
  DROP INDEX idx_main_table_col1;
  

  导入完成后恢复：

  ALTER TABLE child_table ENABLE TRIGGER ALL;
  CREATE INDEX idx_main_table_col1 ON main_table(col1);
  

• 调整WAL日志参数：PostgreSQL9.6里可以增大wal_buffers（比如设为64MB）和checkpoint_segments（比如设为32），减少checkpoint的频率，避免IO瓶颈。修改postgresql.conf后重启数据库（或者用ALTER SYSTEM动态修改）。
• 关闭自动提交：JDBC连接时设置autoCommit=false，避免每条插入都提交一次。

5. 关闭二级缓存（如果开启的话） #

如果你的项目开启了Hibernate二级缓存，批量导入时Hibernate会不断把新插入的对象放进缓存，这完全是没必要的开销——导入过程中根本不需要查询这些数据。临时关闭二级缓存，或者把导入的实体缓存策略设为none。

内容的提问来源于stack exchange，提问作者Amir Hossein Khalouei