MyBatis与JDBC批量插入30万条数据优化实战

1. 项目概述

最近在开发一个用户数据迁移功能时，遇到了需要快速插入大量数据的需求。经过反复测试和优化，最终实现了13秒插入30万条数据的性能表现。本文将详细分享从最初4小时的单条插入，到最终批量插入优化的完整过程，包含MyBatis和JDBC两种实现方式的具体代码和调优经验。

2. 核心需求解析

2.1 业务场景分析

在实际项目中，我们经常会遇到需要批量导入数据的场景：

• 历史数据迁移
• 大数据量初始化
• 定时任务生成报表数据
• 从其他系统同步数据

这些场景的共同特点是需要高效地插入大量数据，传统的单条插入方式性能极差，必须采用批量处理的方式。

2.2 技术选型考量

我们主要对比了两种实现方案：

1. MyBatis批量插入

   • 优点：与ORM框架集成度高，代码简洁
   • 缺点：需要合理配置批处理参数

2. JDBC批量插入

   • 优点：性能最优，直接操作数据库
   • 缺点：代码较为底层，需要手动处理连接和事务

最终我们两种方案都实现了，根据实际场景选择使用。

3. 数据库表设计

3.1 表结构定义

我们使用以下简单的用户表作为测试表：

sql复制CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户id',
  `username` varchar(64) DEFAULT NULL COMMENT '用户名称',
  `age` int(4) DEFAULT NULL COMMENT '年龄',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户信息表';

3.2 索引优化建议

对于批量插入场景，建议：

1. 插入前暂时移除非主键索引
2. 插入完成后再重建索引
3. 使用ALTER TABLE ... DISABLE KEYS和ALTER TABLE ... ENABLE KEYS命令

这样可以显著减少插入时的索引维护开销。

4. MyBatis批量插入实现

4.1 基础配置

首先配置MyBatis环境和Mapper：

1. 实体类定义：

java复制@Data
public class User {
    private int id;
    private String username;
    private int age;
}

2. Mapper接口：

java复制public interface UserMapper {
    void batchInsertUser(@Param("list") List<User> userList);
}

3. Mapper XML：

xml复制<insert id="batchInsertUser" parameterType="java.util.List">
    insert into t_user(username,age) values
    <foreach collection="list" item="item" index="index" separator=",">
        (#{item.username}, #{item.age})
    </foreach>
</insert>

4.2 批量插入优化

经过多次测试，我们总结出最优的批量插入方案：

java复制@Test
public void testBatchInsertUser() throws IOException {
    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession session = sqlSessionFactory.openSession();
    
    System.out.println("===== 开始插入数据 =====");
    long startTime = System.currentTimeMillis();
    
    try {
        List<User> userList = new ArrayList<>();
        for (int i = 1; i <= 300000; i++) {
            User user = new User();
            user.setId(i);
            user.setUsername("用户_" + i);
            user.setAge((int) (Math.random() * 100));
            userList.add(user);
            
            if (i % 5000 == 0) {
                session.insert("batchInsertUser", userList);
                session.commit();
                userList.clear();
            }
        }
        
        if(!userList.isEmpty()) {
            session.insert("batchInsertUser", userList);
            session.commit();
        }
        
        long spendTime = System.currentTimeMillis()-startTime;
        System.out.println("成功插入30万条数据,耗时："+spendTime+"毫秒");
    } finally {
        session.close();
    }
}

关键优化点：

1. 批处理大小设置为5000条
2. 及时提交事务并清空列表
3. 处理剩余数据

4.3 性能对比

我们测试了不同批处理大小的性能表现：

从测试结果看，5000条是一个较好的平衡点。

5. JDBC批量插入实现

5.1 基础实现

java复制@Test
public void testJDBCBatchInsertUser() throws SQLException {
    Connection connection = null;
    PreparedStatement preparedStatement = null;
    
    String url = "jdbc:mysql://localhost:3306/test";
    String user = "root";
    String password = "root";
    
    try {
        connection = DriverManager.getConnection(url, user, password);
        connection.setAutoCommit(false);
        
        System.out.println("===== 开始插入数据 =====");
        long startTime = System.currentTimeMillis();
        
        String sql = "INSERT INTO t_user (username, age) VALUES (?, ?)";
        preparedStatement = connection.prepareStatement(sql);
        
        Random random = new Random();
        for (int i = 1; i <= 300000; i++) {
            preparedStatement.setString(1, "用户_" + i);
            preparedStatement.setInt(2, random.nextInt(100));
            preparedStatement.addBatch();
            
            if (i % 5000 == 0) {
                preparedStatement.executeBatch();
                connection.commit();
                System.out.println("已插入：" + i + "条");
            }
        }
        
        preparedStatement.executeBatch();
        connection.commit();
        
        long spendTime = System.currentTimeMillis()-startTime;
        System.out.println("成功插入30万条数据,耗时："+spendTime+"毫秒");
    } finally {
        if (preparedStatement != null) preparedStatement.close();
        if (connection != null) connection.close();
    }
}

5.2 JDBC优化技巧

1. 使用addBatch()和executeBatch()方法
2. 关闭自动提交，手动控制事务
3. 合理设置批处理大小
4. 使用连接池管理连接
5. 预处理SQL语句

6. 性能优化总结

6.1 关键优化点

1. 批处理大小：5000-10000条为最佳实践
2. 事务控制：适当分批次提交事务
3. 连接管理：使用连接池避免频繁创建连接
4. 索引优化：大批量插入时暂时禁用索引
5. 服务器配置：
   • 调整max_allowed_packet参数
   • 优化InnoDB缓冲池大小
   • 配置合理的redo log大小

6.2 不同场景下的选择建议

1. 小批量数据：MyBatis批量插入更方便
2. 超大批量数据：JDBC性能更优
3. 实时性要求高：适当减小批处理大小
4. 资源有限环境：增加批处理间隔时间

7. 常见问题与解决方案

7.1 内存溢出问题

现象：批处理过程中出现OOM错误

解决方案：

1. 减小批处理大小
2. 增加批处理间隔时间
3. 优化JVM内存参数
4. 使用游标方式处理数据

7.2 超时问题

现象：执行过程中出现超时错误

解决方案：

1. 增加数据库连接超时时间
2. 优化SQL语句
3. 分批处理数据
4. 调整数据库服务器配置

7.3 性能不稳定

现象：相同代码在不同时段执行时间差异大

解决方案：

1. 避开数据库高峰期执行
2. 监控服务器资源使用情况
3. 优化数据库参数配置
4. 考虑使用读写分离

8. 高级优化技巧

8.1 多线程批量插入

对于超大规模数据，可以考虑使用多线程并行插入：

java复制ExecutorService executor = Executors.newFixedThreadPool(4);
List<Future<?>> futures = new ArrayList<>();

int total = 300000;
int batchSize = 5000;
int threads = 4;
int perThread = total / threads;

for (int t = 0; t < threads; t++) {
    final int start = t * perThread;
    final int end = (t == threads - 1) ? total : start + perThread;
    
    futures.add(executor.submit(() -> {
        // 每个线程执行自己的批量插入逻辑
    }));
}

// 等待所有线程完成
for (Future<?> future : futures) {
    future.get();
}
executor.shutdown();

注意事项：

1. 确保线程安全
2. 合理设置线程数
3. 处理数据分片
4. 监控资源使用

8.2 数据库特定优化

针对MySQL的特别优化：

1. 使用LOAD DATA INFILE命令
2. 调整innodb_buffer_pool_size
3. 优化innodb_log_file_size
4. 使用INSERT DELAYED(MyISAM引擎)

9. 监控与调优

9.1 性能监控指标

1. 执行时间：总耗时和单批次耗时
2. 内存使用：JVM内存和数据库内存
3. CPU使用率：应用和数据库服务器
4. I/O负载：磁盘读写情况
5. 网络流量：数据库连接使用情况

9.2 调优建议

1. 建立基准测试环境
2. 记录每次优化的效果
3. 使用可视化监控工具
4. 定期review优化效果

10. 实际应用建议

根据我们的实践经验，给出以下建议：

1. 预生产环境测试：在大规模使用前充分测试
2. 回滚方案：准备好数据回滚的方案
3. 日志记录：详细记录执行过程和结果
4. 异常处理：完善各种异常情况的处理逻辑
5. 进度展示：对于长时间操作，提供进度反馈

在最近的一个实际项目中，我们使用5000条的批处理大小，配合多线程插入，成功在5分钟内完成了1000万条数据的迁移工作，服务器资源使用平稳，没有出现明显的性能问题。