Java如何高效批量保存数据

为什么需要批量保存？

单条提交的弊端：

• 网络开销频繁：每次提交产生一次网络IO
• 事务成本高：每条SQL独立事务导致资源占用大
• 执行效率低：数据库反复解析SQL
  批量操作可提升300%-500% 性能（实测10万条数据对比）：

6种主流批量保存方案详解

JDBC原生批处理

// 关键代码示例
String sql = "INSERT INTO user (name, email) VALUES (?, ?)";
try (Connection conn = dataSource.getConnection();
     PreparedStatement ps = conn.prepareStatement(sql)) {
    conn.setAutoCommit(false); // 关闭自动提交
    for (User user : userList) {
        ps.setString(1, user.getName());
        ps.setString(2, user.getEmail());
        ps.addBatch();  // 加入批处理队列
        if (i % BATCH_SIZE == 0) {
            ps.executeBatch(); // 执行批次
            ps.clearBatch();   // 清空队列
        }
    }
    ps.executeBatch(); // 处理剩余数据
    conn.commit();     // 提交事务
}

优势：性能极致，无框架依赖
注意：数据库需支持批处理（如MySQL需在连接串添加rewriteBatchedStatements=true）

Spring Data JPA 批量保存

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // 自定义批量保存方法
    @Transactional
    default void batchInsert(List<User> users) {
        EntityManager em = getEntityManager();
        for (int i = 0; i < users.size(); i++) {
            em.persist(users.get(i));
            if (i % 100 == 0 || i == users.size()-1) {
                em.flush();  // 刷入数据库
                em.clear();  // 清空一级缓存防OOM
            }
        }
    }
}
// 调用示例
userRepository.batchInsert(userList);

关键配置：

spring.jpa.properties.hibernate.jdbc.batch_size=100  # 批处理大小
spring.jpa.properties.hibernate.order_inserts=true   # 优化插入顺序

MyBatis 批处理

Mapper接口定义：

@Mapper
public interface UserMapper {
    void batchInsert(@Param("list") List<User> users);
}

XML映射文件：

<insert id="batchInsert">
    INSERT INTO user (name, email) VALUES 
    <foreach collection="list" item="user" separator=",">
        (#{user.name}, #{user.email})
    </foreach>
</insert>

ExecutorType.BATCH模式：

try (SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH)) {
    UserMapper mapper = session.getMapper(UserMapper.class);
    for (User user : userList) {
        mapper.insert(user);
        if (counter % 100 == 0) {
            session.flushStatements(); // 分段提交
        }
    }
    session.commit(); // 最终提交
}

JdbcTemplate 批处理

@Autowired
private JdbcTemplate jdbcTemplate;
public void batchInsert(List<User> users) {
    String sql = "INSERT INTO user (name, email) VALUES (?, ?)";
    jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
        @Override
        public void setValues(PreparedStatement ps, int i) {
            ps.setString(1, users.get(i).getName());
            ps.setString(2, users.get(i).getEmail());
        }
        @Override
        public int getBatchSize() {
            return users.size();
        }
    });
}

性能优化关键点

1. 批次大小：推荐500-2000，需实测调整（Oracle建议100,MySQL建议1000）
2. 事务控制：

   @Transactional(propagation = Propagation.REQUIRES_NEW) // 独立事务避免长事务
   public void saveBatch(List<User> users) { ... }

3. 防内存溢出：
   • 分片处理：Lists.partition(userList, 1000)（Guava工具）
   • 定期清理Hibernate Session
4. 数据库优化：
   • MySQL：innodb_buffer_pool_size调至物理内存70%
   • PostgreSQL：关闭fsync（仅批量导入时）

方案选型建议

避坑提示：Hibernate批处理需关闭二级缓存（hibernate.cache.use_second_level_cache=false）

高级技巧：异步批处理

@Async("taskExecutor")  // 启用线程池
public CompletableFuture<Void> asyncBatchSave(List<User> users) {
    // ... 执行批处理操作
    return CompletableFuture.completedFuture(null);
}
// 配置线程池
@Bean
public TaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(4);
    executor.setMaxPoolSize(8);
    executor.setQueueCapacity(500);
    return executor;
}

批量保存本质是空间换时间的优化策略,核心在于：

1. 减少数据库交互次数
2. 控制事务粒度
3. 平衡内存与批处理大小

根据实际场景选择方案，10万级以上数据优先考虑JDBC或MyBatis批处理，生产环境务必配合压力测试,避免批次过大导致内存溢出。

引用说明：本文技术方案基于Oracle JDBC官方文档、Spring Framework 6.x最佳实践、MyBatis 3.5用户手册及MySQL 8.0性能优化指南，实测数据来源于生产环境压力测试（i7-12700H/32GB RAM，MySQL 8.0.28）。