JAVA MyBatis 批量插入慢？优化 JDBC 批处理性能的技巧总结

好的，现在开始我们的讲座：

大家好，今天我们来聊聊在使用 MyBatis 进行批量插入时，如何优化 JDBC 批处理性能。在实际项目中，我们经常会遇到需要批量插入大量数据的场景，例如日志记录、数据同步等等。如果处理不当，批量插入的性能可能会非常糟糕，严重影响系统的整体性能。因此，掌握一些优化技巧至关重要。

1. 问题背景：为什么批量插入会慢？

首先，我们需要理解为什么简单的循环插入效率低下。假设我们有 1000 条数据需要插入。

循环插入: 每次插入一条数据，都需要与数据库建立连接，发送 SQL 语句，数据库执行 SQL，返回结果，断开连接。 1000 条数据就需要 1000 次连接和断开，这会消耗大量的时间在网络通信和数据库的资源管理上。
预编译和参数绑定: 即使使用了预编译，每次执行 SQL 语句也需要进行参数绑定，这也会增加额外的开销。

批量插入的优化目标，就是减少连接次数，减少参数绑定次数，尽可能一次性将多条数据发送到数据库进行处理。

2. MyBatis 的批量插入机制

MyBatis 提供了批量插入的功能，允许我们一次性提交多条 SQL 语句给数据库执行。这大大减少了网络通信的开销。 MyBatis 实现批量插入主要有两种方式：

foreach 循环 + #{}: 在 Mapper XML 文件中使用 <foreach> 标签循环生成 SQL 语句。
ExecutorType.BATCH: 配置 MyBatis 的 ExecutorType 为 BATCH，使用 SqlSession 执行批量操作。

3. 优化策略一：使用 ExecutorType.BATCH

ExecutorType.BATCH 是 MyBatis 提供的一种专门用于批量操作的执行器类型。它的核心思想是：将多个 SQL 语句缓存起来，然后一次性提交给数据库执行。

3.1 配置 MyBatis

首先，需要在 MyBatis 的配置文件 (mybatis-config.xml) 中配置 ExecutorType 为 BATCH。

<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <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>

    <settings>
        <setting name="defaultExecutorType" value="BATCH"/>
    </settings>

    <mappers>
        <mapper resource="com/example/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

或者，你也可以在获取 SqlSession 时指定 ExecutorType。这种方式更加灵活，可以在需要批量操作时才使用 BATCH。

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH); // 指定 ExecutorType.BATCH
try {
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    // ... 执行批量插入操作
    sqlSession.commit();
} catch (Exception e) {
    sqlSession.rollback();
    // ... 异常处理
} finally {
    sqlSession.close();
}

3.2 Mapper 接口和 XML 文件

假设我们有一个 User 实体类：

public class User {
    private Integer id;
    private String username;
    private String email;

    // Getters and setters
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

定义一个 UserMapper 接口：

public interface UserMapper {
    int insertUser(User user);
}

在 UserMapper.xml 文件中定义 insertUser 语句：

<mapper namespace="com.example.mapper.UserMapper">
    <insert id="insertUser" parameterType="com.example.entity.User">
        INSERT INTO user (username, email) VALUES (#{username}, #{email})
    </insert>
</mapper>

3.3 批量插入代码示例

List<User> users = generateUsers(1000); // 假设 generateUsers 方法生成 1000 个 User 对象

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH); // 指定 ExecutorType.BATCH
try {
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    for (User user : users) {
        userMapper.insertUser(user);
    }
    sqlSession.commit(); // 提交事务，批量执行 SQL
} catch (Exception e) {
    sqlSession.rollback();
    // ... 异常处理
} finally {
    sqlSession.close();
}

3.4 ExecutorType.BATCH 的优势和劣势

优势:
- 减少了数据库连接次数，显著提升性能。
- MyBatis 会缓存 SQL 语句，减少了 SQL 解析的开销。
劣势:
- 批量操作需要在内存中缓存 SQL 语句和参数，可能会占用较多的内存。
- 批量操作过程中如果发生异常，回滚操作可能会比较复杂。
- ExecutorType.BATCH 不能获取到每条插入语句的自增主键值。因为它是批量执行，数据库通常不会为每一条语句都立即返回主键。

4. 优化策略二：使用 foreach 循环 + #{} 动态 SQL

如果需要获取自增主键，或者需要更灵活的控制 SQL 语句的生成，可以使用 foreach 循环结合动态 SQL 来实现批量插入。

4.1 Mapper 接口

public interface UserMapper {
    int insertUsers(List<User> users);
}

4.2 Mapper XML 文件

<mapper namespace="com.example.mapper.UserMapper">
    <insert id="insertUsers" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO user (username, email) VALUES
        <foreach collection="list" item="user" separator=",">
            (#{user.username}, #{user.email})
        </foreach>
    </insert>
</mapper>

collection="list": 指定要迭代的集合为传入的 List。
item="user": 指定每次迭代的元素为 user。
separator=",": 指定每个元素之间的分隔符为逗号。
useGeneratedKeys="true": 指定使用自增主键。
keyProperty="id": 指定自增主键对应的属性为 id。

4.3 批量插入代码示例

List<User> users = generateUsers(1000);

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession(); // 默认的 ExecutorType.SIMPLE
try {
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    userMapper.insertUsers(users);
    sqlSession.commit();
    // 此时 users 列表中的每个 User 对象都应该已经设置了自增主键 ID
    for (User user : users) {
        System.out.println("Inserted user ID: " + user.getId());
    }

} catch (Exception e) {
    sqlSession.rollback();
    // ... 异常处理
} finally {
    sqlSession.close();
}

4.4 foreach 循环 + #{} 的优势和劣势

优势:
- 可以获取自增主键。
- 可以更灵活地控制 SQL 语句的生成，例如可以根据不同的数据动态地添加或修改 SQL 语句。
劣势:
- 如果数据量很大，生成的 SQL 语句可能会非常长，超过数据库的限制。 (例如 MySQL 的 max_allowed_packet 参数)
- MyBatis 需要解析包含大量参数的 SQL 语句，可能会影响性能。
- 容易受到 SQL 注入攻击，需要注意对参数进行过滤和转义。

5. 优化策略三：分批插入

当数据量非常大，一次性插入可能会导致内存溢出或者 SQL 语句过长的问题。可以将数据分成多个批次，分批进行插入。这种方法可以有效地降低内存占用，避免 SQL 语句过长。

private static final int BATCH_SIZE = 500; // 每批插入 500 条数据

public void batchInsert(List<User> users) {
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    try {
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        int size = users.size();
        for (int i = 0; i < size; i += BATCH_SIZE) {
            int end = Math.min(i + BATCH_SIZE, size);
            List<User> batch = users.subList(i, end);
            userMapper.insertUsers(batch); // 使用 foreach 循环 + #{} 方式
            sqlSession.commit(); // 每次提交一个批次
        }
    } catch (Exception e) {
        sqlSession.rollback();
        // ... 异常处理
    } finally {
        sqlSession.close();
    }
}

6. 优化策略四：使用 JDBC 的 PreparedStatement 批处理

MyBatis 的底层仍然是 JDBC。可以直接使用 JDBC 的 PreparedStatement 来实现批处理。这种方法通常可以获得最高的性能。但是，需要手动编写 JDBC 代码，相对比较繁琐。

public void batchInsertWithJDBC(List<User> users) {
    Connection connection = null;
    PreparedStatement preparedStatement = null;
    try {
        connection = dataSource.getConnection(); // 从数据源获取连接
        connection.setAutoCommit(false); // 关闭自动提交

        String sql = "INSERT INTO user (username, email) VALUES (?, ?)";
        preparedStatement = connection.prepareStatement(sql);

        for (User user : users) {
            preparedStatement.setString(1, user.getUsername());
            preparedStatement.setString(2, user.getEmail());
            preparedStatement.addBatch(); // 添加到批处理
        }

        preparedStatement.executeBatch(); // 执行批处理
        connection.commit(); // 提交事务

    } catch (SQLException e) {
        try {
            if (connection != null) {
                connection.rollback(); // 回滚事务
            }
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        e.printStackTrace();

    } finally {
        try {
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.setAutoCommit(true); // 恢复自动提交
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

7. 优化策略五：数据库层面的优化

除了在 Java 代码层面进行优化，还可以从数据库层面进行优化，例如：

禁用索引: 在批量插入数据之前，可以先禁用索引，插入完成后再重新启用索引。这可以避免在插入过程中维护索引的开销。 (注意：这可能会影响其他查询操作，需要谨慎使用)
调整数据库参数: 可以调整数据库的一些参数，例如 innodb_buffer_pool_size (MySQL) shared_buffers (PostgreSQL) 等，以提高数据库的性能。
使用 LOAD DATA INFILE (MySQL): 如果数据存储在文件中，可以使用 MySQL 的 LOAD DATA INFILE 命令直接将数据加载到数据库中。这种方法通常是最快的。

8. 各种方法的性能对比

方法	优点	缺点	适用场景
循环插入	简单易懂	性能最差，连接开销大	数据量非常小，对性能要求不高
`ExecutorType.BATCH`	减少连接次数，性能提升明显	不能获取自增主键，内存占用较高，回滚复杂	数据量较大，不需要获取自增主键
`foreach` 循环 + `#{}`	可以获取自增主键，更灵活	SQL 语句可能过长，需要解析大量参数，容易受到 SQL 注入攻击	需要获取自增主键，需要动态生成 SQL 语句，需要注意 SQL 注入问题
分批插入	降低内存占用，避免 SQL 语句过长	性能略低于一次性插入	数据量非常大，需要避免内存溢出和 SQL 语句过长
JDBC `PreparedStatement` 批处理	性能最高，最灵活	代码复杂，需要手动管理连接和事务	对性能要求非常高，需要精细控制 JDBC 操作
数据库层面优化 (禁用索引, 调整参数)	性能提升明显	可能会影响其他操作，需要谨慎使用	适用于所有批量插入场景，可以与其他优化方法结合使用

9. 最佳实践

在实际项目中，选择哪种优化策略取决于具体的业务场景和性能要求。以下是一些建议：

优先考虑 ExecutorType.BATCH: 如果不需要获取自增主键，ExecutorType.BATCH 是一个不错的选择，它可以显著提升性能，而且代码相对简单。
如果需要获取自增主键，可以使用 foreach 循环 + #{}: 但是需要注意 SQL 语句的长度和 SQL 注入问题。可以使用分批插入来避免 SQL 语句过长。
当数据量非常大，需要考虑分批插入: 可以有效地降低内存占用，避免 SQL 语句过长。
如果对性能要求非常高，可以考虑使用 JDBC 的 PreparedStatement 批处理: 但是需要手动编写 JDBC 代码，相对比较繁琐。
结合数据库层面的优化: 例如禁用索引、调整数据库参数等，可以进一步提高性能。
监控和调优: 在生产环境中，需要对批量插入的性能进行监控，并根据实际情况进行调优。

代码示例：生成测试数据的函数

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class UserGenerator {

    private static final Random random = new Random();

    public static List<User> generateUsers(int count) {
        List<User> users = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            User user = new User();
            user.setUsername("user_" + i);
            user.setEmail("user_" + i + "@example.com");
            users.add(user);
        }
        return users;
    }

    public static void main(String[] args) {
        List<User> users = generateUsers(10);
        for (User user : users) {
            System.out.println("Username: " + user.getUsername() + ", Email: " + user.getEmail());
        }
    }
}

10. 总结

批量插入性能优化是一个复杂的问题，需要综合考虑多种因素。通过选择合适的 MyBatis 批量插入方式，结合数据库层面的优化，可以显著提升批量插入的性能，提高系统的整体性能。关键在于理解每种方法的优缺点，并根据具体的业务场景进行选择。

11. 实践才是检验真理的唯一标准

以上只是理论知识，最好的方式是编写测试用例，实际测试各种优化策略的性能，并根据测试结果进行调整。只有通过实践，才能真正掌握批量插入性能优化的技巧。

12. 持续学习，不断进步

技术在不断发展，我们需要不断学习新的知识，才能更好地解决实际问题。希望今天的分享能够帮助大家更好地理解 MyBatis 批量插入性能优化，并在实际项目中应用这些技巧。

JAVA MyBatis 批量插入慢？优化 JDBC 批处理性能的技巧总结

发表回复 取消回复

发表回复取消回复