Java怎么实现几十万条数据插入(30万条数据插入MySQL仅需13秒)

已于 2023-03-25 10:40:57 修改
阅读量7.3w 收藏 449
点赞数 154
分类专栏： # Mybatis&Mybatis-Plus 🐬数据库 文章标签： java mysql mybatis
于 2023-03-20 13:11:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35427589/article/details/129665307
版权

本文主要讲述通过MyBatis、JDBC等做大数据量数据插入的案例和结果。

30万条数据插入插入数据库验证


验证的数据库表结构如下： 

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='用户信息表';

话不多说，开整！

实体类、mapper和配置文件定义

User实体

/**
 * <p>用户实体</p>
 *
 * @Author zjq
 * @Date 2021/8/3
 */
@Data
public class User {

    private int id;
    private String username;
    private int age;

}

mapper接口

public interface UserMapper {

    /**
     * 批量插入用户
     * @param userList
     */
    void batchInsertUser(@Param("list") List<User> userList);


}

mapper.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>

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

sqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--通过properties标签加载外部properties文件-->
    <properties resource="jdbc.properties"></properties>


    <!--自定义别名-->
    <typeAliases>
        <typeAlias type="com.zjq.domain.User" alias="user"></typeAlias>
    </typeAliases>


    <!--数据源环境-->
    <environments default="developement">
        <environment id="developement">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>


    <!--加载映射文件-->
    <mappers>
        <mapper resource="com/zjq/mapper/UserMapper.xml"></mapper>
    </mappers>


</configuration>

不分批次直接梭哈

MyBatis直接一次性批量插入30万条，代码如下：

    @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);
            }
            session.insert("batchInsertUser", userList); // 最后插入剩余的数据
            session.commit();

            long spendTime = System.currentTimeMillis()-startTime;
            System.out.println("成功插入 30 万条数据,耗时："+spendTime+"毫秒");
        } finally {
            session.close();
        }
    }

可以看到控制台输出：

Cause: com.mysql.jdbc.PacketTooBigException: Packet for query is too large (27759038 >yun 4194304). You can change this value on the server by setting the max_allowed_packet’ variable.

Cause: com.mysql.jdbc.PacketTooBigException: Packet for query is too large (27759038 >yun 4194304). You can change this value on the server by setting the max_allowed_packet' variable

超出最大数据包限制了，可以通过调整max_allowed_packet限制来提高可以传输的内容，不过由于30万条数据超出太多，这个不可取，梭哈看来是不行了 😅😅😅
既然梭哈不行那我们就一条一条循环着插入行不行呢

循环逐条插入

mapper接口和mapper文件中新增单个用户新增的内容如下:

    /**
     * 新增单个用户
     * @param user
     */
    void insertUser(User user);

    <!-- 新增用户信息 -->
    <insert id="insertUser" parameterType="user">
        insert into t_user(username,age) values
            (
            #{username},
            #{age}
            )
    </insert>

调整执行代码如下：

    @Test
    public void testCirculateInsertUser() 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 {
            for (int i = 1; i <= 300000; i++) {
                User user = new User();
                user.setId(i);
                user.setUsername("共饮一杯无 " + i);
                user.setAge((int) (Math.random() * 100));
                // 一条一条新增
                session.insert("insertUser", user);
                session.commit();
            }

            long spendTime = System.currentTimeMillis()-startTime;
            System.out.println("成功插入 30 万条数据,耗时："+spendTime+"毫秒");
        } finally {
            session.close();
        }
    }

执行后可以发现磁盘IO占比飙升，一直处于高位。
在这里插入图片描述

等啊等等啊等，好久还没执行完

ccc.gif
先不管他了太慢了先搞其他的，等会再来看看结果吧。
two thousand year later …
控制台输出如下：
在这里插入图片描述
总共执行了14909367毫秒，换算出来是4小时八分钟。太慢了。。
image.png
👇👇👇还是优化下之前的批处理方案吧

MyBatis实现插入30万条数据

先清理表数据，然后优化批处理执行插入：

-- 清空用户表
TRUNCATE table  t_user;

以下是通过 MyBatis 实现 30 万条数据插入代码实现：

    /**
     * 分批次批量插入
     * @throws IOException
     */
    @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();
        int waitTime = 10;
        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 % 1000 == 0) {
                    session.insert("batchInsertUser", userList);
                    // 每 1000 条数据提交一次事务
                    session.commit();
                    userList.clear();

                    // 等待一段时间
                    Thread.sleep(waitTime * 1000);
                }
            }
            // 最后插入剩余的数据
            if(!CollectionUtils.isEmpty(userList)) {
                session.insert("batchInsertUser", userList);
                session.commit();
            }

            long spendTime = System.currentTimeMillis()-startTime;
            System.out.println("成功插入 30 万条数据,耗时："+spendTime+"毫秒");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

使用了 MyBatis 的批处理操作，将每 1000 条数据放在一个批次中插入，能够较为有效地提高插入速度。同时请注意在循环插入时要带有合适的等待时间和批处理大小，以防止出现内存占用过高等问题。此外，还需要在配置文件中设置合理的连接池和数据库的参数，以获得更好的性能。
CPU和磁盘占用情况
在上面的示例中，我们每插入1000行数据就进行一次批处理提交，并等待10秒钟。这有助于控制内存占用，并确保插入操作平稳进行。
image.png
五十分钟执行完毕，时间主要用在了等待上。

如果低谷时期执行，CPU和磁盘性能又足够的情况下，直接批处理不等待执行：

    /**
     * 分批次批量插入
     * @throws IOException
     */
    @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();
        int waitTime = 10;
        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 % 1000 == 0) {
                    session.insert("batchInsertUser", userList);
                    // 每 1000 条数据提交一次事务
                    session.commit();
                    userList.clear();
                }
            }
            // 最后插入剩余的数据
            if(!CollectionUtils.isEmpty(userList)) {
                session.insert("batchInsertUser", userList);
                session.commit();
            }

            long spendTime = System.currentTimeMillis()-startTime;
            System.out.println("成功插入 30 万条数据,耗时："+spendTime+"毫秒");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

则24秒可以完成数据插入操作：
在这里插入图片描述
image.png
可以看到短时CPU和磁盘占用会飙高。
把批处理的量再调大一些调到5000，在执行：
在这里插入图片描述
13秒插入成功30万条，直接芜湖起飞🛫🛫🛫

JDBC实现插入30万条数据

JDBC循环插入的话跟上面的mybatis逐条插入类似，不再赘述。
以下是 Java 使用 JDBC 批处理实现 30 万条数据插入的示例代码。请注意，该代码仅提供思路，具体实现需根据实际情况进行修改。

    /**
     * JDBC分批次批量插入
     * @throws IOException
     */
    @Test
    public void testJDBCBatchInsertUser() throws IOException {
        Connection connection = null;
        PreparedStatement preparedStatement = null;

        String databaseURL = "jdbc:mysql://localhost:3306/test";
        String user = "root";
        String password = "root";

        try {
            connection = DriverManager.getConnection(databaseURL, user, password);
            // 关闭自动提交事务，改为手动提交
            connection.setAutoCommit(false);
            System.out.println("===== 开始插入数据 =====");
            long startTime = System.currentTimeMillis();
            String sqlInsert = "INSERT INTO t_user ( username, age) VALUES ( ?, ?)";
            preparedStatement = connection.prepareStatement(sqlInsert);

            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 % 1000 == 0) {
                    // 每1000条数据提交一次
                    preparedStatement.executeBatch();
                    connection.commit();
                    System.out.println("成功插入第 "+ i+" 条数据");
                }

            }
            // 处理剩余的数据
            preparedStatement.executeBatch();
            connection.commit();
            long spendTime = System.currentTimeMillis()-startTime;
            System.out.println("成功插入 30 万条数据,耗时："+spendTime+"毫秒");
        } catch (SQLException e) {
            System.out.println("Error: " + e.getMessage());
        } finally {
            if (preparedStatement != null) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

ccc.gif
在这里插入图片描述

上述示例代码中，我们通过 JDBC 连接 MySQL 数据库，并执行批处理操作插入数据。具体实现步骤如下：

  1. 获取数据库连接。
  2. 创建 Statement 对象。
  3. 定义 SQL 语句，使用 PreparedStatement 对象预编译 SQL 语句并设置参数。
  4. 执行批处理操作。
  5. 处理剩余的数据。
  6. 关闭 Statement 和 Connection 对象。

使用setAutoCommit(false) 来禁止自动提交事务，然后在每次批量插入之后手动提交事务。每次插入数据时都新建一个 PreparedStatement 对象以避免状态不一致问题。在插入数据的循环中，每 10000 条数据就执行一次 executeBatch() 插入数据。
另外，需要根据实际情况优化连接池和数据库的相关配置，以防止连接超时等问题。

总结

实现高效的大量数据插入需要结合以下优化策略（建议综合使用）：

  1. 批处理：批量提交SQL语句可以降低网络传输和处理开销，减少与数据库交互的次数。在Java中可以使用Statement或者PreparedStatement的addBatch()方法来添加多个SQL语句，然后一次性执行executeBatch()方法提交批处理的SQL语句。
  • 在循环插入时带有适当的等待时间和批处理大小，从而避免内存占用过高等问题：
    • 设置适当的批处理大小：批处理大小指在一次插入操作中插入多少行数据。如果批处理大小太小，插入操作的频率将很高，而如果批处理大小太大，可能会导致内存占用过高。通常，建议将批处理大小设置为1000-5000行，这将减少插入操作的频率并降低内存占用。
    • 采用适当的等待时间：等待时间指在批处理操作之间等待的时间量。等待时间过短可能会导致内存占用过高，而等待时间过长则可能会延迟插入操作的速度。通常，建议将等待时间设置为几秒钟到几十秒钟之间，这将使操作变得平滑且避免出现内存占用过高等问题。
    • 可以考虑使用一些内存优化的技巧，例如使用内存数据库或使用游标方式插入数据，以减少内存占用。
  • 总的来说，选择适当的批处理大小和等待时间可以帮助您平稳地进行插入操作，避免出现内存占用过高等问题。
  1. 索引: 在大量数据插入前暂时去掉索引，最后再打上，这样可以大大减少写入时候的更新索引的时间。
  2. 数据库连接池：使用数据库连接池可以减少数据库连接建立和关闭的开销，提高性能。在没有使用数据库连接池的情况，记得在finally中关闭相关连接。
  3. 数据库参数调整：增加MySQL数据库缓冲区大小、配置高性能的磁盘和I/O等。

本文内容到此结束了，
如有收获欢迎点赞👍收藏💖关注✔️，您的鼓励是我最大的动力。
如有错误❌疑问💬欢迎各位指出。
主页：共饮一杯无的博客汇总👨‍💻

保持热爱，奔赴下一场山海。🏃🏃🏃

共饮一杯无
关注
  • 154
    点赞
  • 踩
  • 449
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 95
    评论
专栏目录
75.批量插入几百万条数据方案（非常重要）.avi
03-09
mysql快速查询百万条数据 批量插入几百万条数据方案（非常重要）.avi
教你如何6秒钟往MySQL插入100万条数据的实现
09-08
主要介绍了教你如何6秒钟往MySQL插入100万条数据的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
13 秒插入 30 万条数据，这才是 Java 批量插入正确的姿势！
最新发布
03-18 1606
13 秒插入 30 万条数据，这才是 Java 批量插入正确的姿势！
88秒插入1000万条数据到MySQL数据库表的操作方法
09-09
主要介绍了88秒插入1000万条数据到MySQL数据库表的操作方法，首先给大家说下我用到的数据库表为mysql数据库5.7版本的。具体操作方法大家跟随小编一起通过本文学习吧
mysql 单sql最大时间_MySQL系列分析Sql执行时间及查询执行计划(附数据库和一千万数据)...
weixin_28852151的博客
02-01 783
北京时间周一晚9点28分，文章走起。写给自己看的，总结下学习知识，梳理下知识点。Netty系列文章先告一段落了，因为这些知识已经满足我当前工作的需求。后续项目中遇到问题和问题解决，会继续更新Netty相关文章。哈哈哈 啰嗦的话有点多。接下来我将更新MySQL系列的文章，主要涉及MySQL的索引、调优、整体架构、引擎、分库分表、扩容、索引的深入探究等等。感兴趣的可以持续关注，不感兴趣的略过...
（转）快速安全的往mysql里插入千万条数据
weixin_46011971的博客
10-02 3042
来源：ksfzhaohui juejin.im/post/5da5b568f265da5b6c4bc13d 概述 有个需求解析一个订单文件了，并且说明文件可达到千万条数据，每条数据大概在20哥字段左右，每个字段使用逗号分隔，需要尽量在半小时内入库 思路 1.估算文件大小 因为告诉文件有千万条，同时每条记录大概在20哥字段左右，所以可用大致估算一下整个订单文件的大小，方法也很简单使用FileWriter往文件中插入一千万条数据，查看文件大小，经测试大概在1.5G左右； 2.如何批量插入 由上可知文件比较大，一
Java怎么实现几十万条同时数据插入（三种基本方法测试）
weixin_46504244的博客
04-12 3715
在Java中实现插入几十万条数据，有多种方法可以使用。
JAVA高效率 (秒级) 入库千万级别数据
weixin_44825912的博客
02-16 3280
JAVA高效率 (秒级) 入库千万级别数据 问题背景： 多个定时任务定期运行，各任务从若干张表中取出数据处理后形成千万级别数据再入库表，任务之间有关联关系，任务B依赖任务A产出的表，任务C依赖任务B产出的表....。
Java多线程百万数据快速入库实战
热门推荐
张俊杰 的博客
10-12 1万+
出自: 腾讯课堂 700多分钟干货实战Java多线程高并发高性能实战全集 , 我学习完了之后,我做了个笔记. 背景 某应用程序(单台服务器,非分布式的多台服务器),这单台服务器就是你的笔记本电脑了, ​ 并发产生100万条数据,这100w条数据是你自己产生的,假设你是架构师,如何运用多线程等基础知识将这100万条数据,快速同步(4分钟以内)到MySQL数据库? ​ 分析百万数据快速入库的特点 1.百万数据快速入库的特点: 数据量比较大(高并发),时间很短(性能), 100万条数据如果一条一条的插入到
java 批量插入千万条数据优化方案【值得收藏】
javaXingzhe的博客
03-01 7533
java 千万条数据插入mysql优化
java实现批量插入数据
qq_58545721的博客
03-27 6356
java实现批量插入数据
MySQL创建存储过程批量插入10万条数据
01-19
MySQL创建存储过程批量插入10万条数据 存储过程 1、首先防止主键冲突，我们清空表。 TRUNCATE table A_student; 2、编写存储过程 delimiter ‘$’; CREATE PROCEDURE batchInsert(in args int) BEGIN declare i int ...
Java使用JDBC向MySQL数据库批次插入10W条数据(测试效率)
08-31
使用JDBC连接MySQL数据库进行数据插入的时候，特别是大批量数据连续插入（100000），如何提高效率呢?今天小编通过本教程给大家介绍下
JAVA读取TXT文件，将数据存到Mysql数据库，大量数据并使用 JPA 批量插入优化1000秒-＞190秒，有则更新，没有则新增 批量saveAll。并实时获取入库进度
m0_72405471的博客
07-05 2254
20W条数据。从1000秒 至 190 秒
用java写一个多线程异步批量入库
Somnus的专栏
12-07 462
【代码】用java写一个多线程异步批量入库。
java中批量插入数据优化问题
ClearDream__的博客
01-14 465
开发中遇到excel大量数据批量入库时候，逐条插入数据很慢导致卡顿问题。
JAVA如何处理各种批量数据入库(BlockingQueue)
qq_41128049的博客
11-16 437
将数据先写入队列中，然后开启多个消费线程慢慢消费入库。
JAVA超大量数据入库
weixin_47553445的博客
07-19 698
产品需求：生成一串不重复的号码0-19999999且。当消耗一半后需要多少秒才能插入一条数据；我首先生成1000万条数据然后在入库，花费时间8分钟。首先的问题就是，先要插入1000万条数据。
Java如何快速向MySQL插入百万条数据
mirage_zy的博客
04-25 1302
1.使用批量提交数据，url一定要设置允许重写批量提交【rewriteBatchedStatements=true】，以及此时的sql语句一定不能有分号，否则有【BatchUpdateException】异常，2.其他的就正常使用PreparedStatement ps;的以下三个方法即可。
利用MySQL存储过程实现向60个表里插入10万条数据
05-31
可以使用以下存储过程来向60个表里插入10万条数据： ``` CREATE PROCEDURE insert_data_to_tables() BEGIN DECLARE i INT DEFAULT 1; DECLARE j INT DEFAULT 1; WHILE i <= 100000 DO WHILE j <= 60 DO SET @table_name = CONCAT('table_', j); SET @insert_sql = CONCAT('INSERT INTO ', @table_name, ' (column1, column2, column3) VALUES (', i, ', \'value\', NOW())'); PREPARE stmt FROM @insert_sql; EXECUTE stmt; DEALLOCATE PREPARE stmt; SET j = j + 1; END WHILE; SET j = 1; SET i = i + 1; END WHILE; END; ``` 该存储过程中使用了两个循环，外层循环控制插入的行数，内层循环控制插入的表。在循环中，使用 `CONCAT` 函数动态生成表名和插入语句，并使用 `PREPARE` 和 `EXECUTE` 语句动态执行插入语句，最后使用 `DEALLOCATE PREPARE` 释放资源。 你可以根据需要修改存储过程中的表名、列名和插入的数据。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 95
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

共饮一杯无

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值