如何优化 30 万条数据插入MySQL数据库

我不是女神ヾ 2024-05-07 22:29 13阅读 0赞

## 1 前言 ##

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

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

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

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

**①实体类**

/**
     * <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 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>

## 3 几种实现方式的尝试 ##

### 3.1 30万条直接插入 ###

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.

![在这里插入图片描述][5cab2dff2b5340eab838c5751ad8065a.png]  
超出最大数据包限制了，可以通过调整 max\_allowed\_packet 限制来提高可以传输的内容，不过由于 30 万条数据超出太多，这个不可取

既然直接插入不行那我们就一条一条循环着插入行不行呢？

### 3.2 循环逐条插入 ###

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 占比飙升，一直处于高位。

![在这里插入图片描述][23d74e1ddf814ede9d42e048f157b82d.png]  
需要等待好久好久,但还是没执行完

![在这里插入图片描述][994e53babf1143b8a88b3b6fe32220bb.gif_pic_center]  
执行完成后控制台显示执行时间4小时,这显然不符合预期

![在这里插入图片描述][e5a693eee86b42d89f525941294e162d.png]

### 3.3 MyBatis 实现批处理插入 30 万条数据 ###

以下是通过 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 条数据放在一个批次中插入，能够较为有效地提高插入速度。同时请注意在循环插入时要带有合适的等待时间和批处理大小，以防止出现内存占用过高等问题。此外，还需要在配置文件中设置合理的连接池和数据库的参数，以获得更好的性能。

![在这里插入图片描述][2b280eb3ea41494793007b4ed19593fc.png]  
在上面的示例中，我们每插入 1000 行数据就进行一次批处理提交，并等待10秒钟。这有助于控制内存占用，并确保插入操作平稳进行。

![在这里插入图片描述][1574419abdf343cca0fc3d3246e09055.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 秒可以完成数据插入操作：

![在这里插入图片描述][3bcfdd12b8a843b5a8022ce1aee52ae9.png]  
![在这里插入图片描述][a5731da9f1ab49fbaabbbf40b44f4274.png]  
可以看到短时CPU和磁盘占用会飙高。

把批处理的量再调大一些调到 5000，在执行：

![在这里插入图片描述][5e85c9d683414b608dbc9ba32ddac3fb.png]  
13 秒插入成功 30 万条

### 3.4 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();
                }
            }
        }
    }

![在这里插入图片描述][f2364ec9be55483e9757a9376e0ede70.gif_pic_center]  
![在这里插入图片描述][c8d39dbc003c47ae8fe5ccb094abeb4b.png]  
上述示例代码中，我们通过 JDBC 连接 MySQL 数据库，并执行批处理操作插入数据。具体实现步骤如下：

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

使用 setAutoCommit(false) 来禁止自动提交事务，然后在每次批量插入之后手动提交事务。每次插入数据时都新建一个 PreparedStatement 对象以避免状态不一致问题。在插入数据的循环中，每 10000 条数据就执行一次 executeBatch() 插入数据。

另外，需要根据实际情况优化连接池和数据库的相关配置，以防止连接超时等问题。

## 4 总结 ##

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

**1. 批处理**

批量提交 SQL 语句可以降低网络传输和处理开销，减少与数据库交互的次数。在 Java 中可以使用 Statement 或者 PreparedStatement 的addBatch() 方法来添加多个 SQL 语句，然后一次性执行 executeBatch() 方法提交批处理的 SQL 语句。

在循环插入时带有适当的等待时间和批处理大小，从而避免内存占用过高等问题：

设置适当的批处理大小： 批处理大小指在一次插入操作中插入多少行数据。如果批处理大小太小，插入操作的频率将很高，而如果批处理大小太大，可能会导致内存占用过高。通常，建议将批处理大小设置为 1000-5000 行，这将减少插入操作的频率并降低内存占用。

采用适当的等待时间： 等待时间指在批处理操作之间等待的时间量。等待时间过短可能会导致内存占用过高，而等待时间过长则可能会延迟插入操作的速度。通常，建议将等待时间设置为几秒钟到几十秒钟之间，这将使操作变得平滑且避免出现内存占用过高等问题。

可以考虑使用一些内存优化的技巧： 例如使用内存数据库或使用游标方式插入数据，以减少内存占用。

总的来说，选择适当的批处理大小和等待时间可以帮助您平稳地进行插入操作，避免出现内存占用过高等问题。

**2. 索引**

在大量数据插入前暂时去掉索引，最后再打上，这样可以大大减少写入时候的更新索引的时间。

**3. 数据库连接池**

使用数据库连接池可以减少数据库连接建立和关闭的开销，提高性能。在没有使用数据库连接池的情况，记得在 finally 中关闭相关连接。

**4. 数据库参数调整**

增加 MySQL 数据库缓冲区大小、配置高性能的磁盘和 I/O 等。

[5cab2dff2b5340eab838c5751ad8065a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/07/3bb42a2305364cd7ab6797df2e243a2a.png
[23d74e1ddf814ede9d42e048f157b82d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/07/ab458228d62d4e26a87319240067ec05.png
[994e53babf1143b8a88b3b6fe32220bb.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/07/4ca4ee555ac44a5a9f77683794a571ce.gif
[e5a693eee86b42d89f525941294e162d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/07/501b7a3371134948861c542799bf79cc.png
[2b280eb3ea41494793007b4ed19593fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/07/9b27ebad1a664bdea7447dfc9110819f.png
[1574419abdf343cca0fc3d3246e09055.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/07/a975f67f194a43f1a98492884412f57a.png
[3bcfdd12b8a843b5a8022ce1aee52ae9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/07/b8497879b7154815b612c64c05733e15.png
[a5731da9f1ab49fbaabbbf40b44f4274.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/07/ef018f227b0045739678e1e7b6c264a2.png
[5e85c9d683414b608dbc9ba32ddac3fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/07/7e1937740c184d408b5af8148625f4fa.png
[f2364ec9be55483e9757a9376e0ede70.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/07/f21ff4f0a6b64df0860f438b3ac544be.gif
[c8d39dbc003c47ae8fe5ccb094abeb4b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/07/731dcb0e468b4f7baa44028f1fd1567c.png