从80s到1s！看看人家的 MyBatis 批量插入数据优化，那叫一个优雅！

公众号-芋道源码 公众号-芋道源码 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 100+累计阅读 171平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄10年
关注
转载 最新推荐文章于 2026-08-26 12:50:49 发布 171 阅读 AI 写同款· GEO 优化 ›
MyBatisPlus高效开发与性能优化实战 MyBatisPlus作为MyBatis的增强工具包，通过内置通用CRUD方法、智能条件构造器和代码生成器，大幅提升Java持久层开发效率。其核心原理在于动态SQL生成与自动化代码处理，技术价值体现在减少重复代码、提高开发速度300%以上。典型应用场景包括分库分表、多租户隔离和逻辑删除等企业级需求。特别是在动态表名处理、批量操作优化等实战技巧中，MyBatisPlus展现出强大的工程实践价值。结合性能监控与分布式ID生成等进阶功能，成为现代Java项目的高效开发利器。 阅读详情

👉 这是一个或许对你有用的社群

🐱 一对一交流/面试小册/简历优化/求职解惑，欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料： 

77702ae68352b38bf291f2c126f5e715.gif

👉这是一个或许对你有用的开源项目

国产 Star 破 10w+ 的开源项目，前端包括管理后台 + 微信小程序，后端支持单体和微服务架构。

功能涵盖 RBAC 权限、SaaS 多租户、数据权限、商城、支付、工作流、大屏报表、微信公众号、CRM 等等功能：

  • Boot 仓库：https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • Cloud 仓库：https://gitee.com/zhijiantianya/yudao-cloud

  • 视频教程：https://doc.iocoder.cn

【国内首批】支持 JDK 21 + SpringBoot 3.2.2、JDK 8 + Spring Boot 2.7.18 双版本 

来源：juejin.cn/post/
7261894465064353829

看到一篇实践 JDBC 和 MyBatis / MyBatis Plus 实现批量插入的文章，内容挺不错的，分享一下。

前言

最近在项目上遇到了批量插入的场景问题，由于每次需要插入超过 10w+ 的数据量并且字段也蛮多的导致如果使用循环单次插入的方式插入数据插入的效率不高。相信读者们在实际开发中也遇到过这样类似的场景，那么批量插入如何实现呢？

其实我也是一知半解，之前只见过别人博客上的批量插入实现，对于实际优化上的细节以及优化的程度并不了解。所以正好借此机会，在这里认真地把批量插入的实现及优化过程实操一遍并记录下来，有兴趣的读者们可以接着往下观看，有不对的地方还希望能在评论里指出来。

既然涉及到了数据库层面的操作，我想从 JDBC 和 MyBatis / MyBatis Plus 两个层面分别实现一下批量插入，下面将依次讲解实现及优化过程。

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址：https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程：https://doc.iocoder.cn/video/

JDBC 实现批量插入

在编写代码前，先准备一下 JDBC 批量插入需要的测试环境。

JDBC 测试环境

建表语句（使用数据库版本 mysql 5.7.19）

DROP TABLE IF EXISTS `fee`;
CREATE TABLE `fee`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `owner` varchar(64) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL COMMENT '归属人',
  `fee1` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用1',
  `fee2` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用2',
  `fee3` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用3',
  `fee4` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用4',
  `fee5` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用5',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_unicode_ci COMMENT = '费用表' ROW_FORMAT = Dynamic;

maven 坐标（使用 Java 版本 JDK 1.8）

!-- MySQL 驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.9</version>
</dependency>

普通插入

在实现批量插入之前呢，为了更明显的看到普通插入方式和批量插入方式的不同，先来写一遍普通插入（循环插入）的实现并记录一下插入所需时间。

使用 JDBC 不需要添加额外的配置文件，直接上代码：

/**
 * JDBC - 普通插入（循环遍历一条一条插入）
 * @author 单程车票
 */
public class JDBCDemo {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/test";
        String user = "root";
        String password = "123456";
        String driver = "com.mysql.jdbc.Driver";
        // sql语句
        String sql = "INSERT INTO fee(`owner`,`fee1`,`fee2`,`fee3`,`fee4`,`fee5`) VALUES (?,?,?,?,?,?);";
        Connection conn = null;
        PreparedStatement ps = null;
        // 开始时间
        long start = System.currentTimeMillis();
        try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, user, password);
            ps = conn.prepareStatement(sql);
            // 循环遍历插入数据
            for (int i = 1; i <= 100000; i++) {
                ps.setString(1, "o"+i);
                ps.setBigDecimal(2, new BigDecimal("11111.111"));
                ps.setBigDecimal(3, new BigDecimal("11111.111"));
                ps.setBigDecimal(4, new BigDecimal("11111.111"));
                ps.setBigDecimal(5, new BigDecimal("11111.111"));
                ps.setBigDecimal(6, new BigDecimal("11111.111"));
                ps.executeUpdate();
            }
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（普通插入方式）：" + (end - start) + " ms");
    }
}

执行结果：

d0d0ecaeb25ea7c2c3d5322607b485c9.jpeg

可以看到使用普通插入的方式插入 10w 条数据需要的时间大概在 80 s 左右，接下来看看使用批量插入的方式优化了多少。

批处理插入

下面就是 JDBC 批量插入的实现方式：批处理插入方式 + 手动事务提交。

代码：

/**
 * JDBC - 批处理插入
 */
public class JDBCPlusDemo {
    public static void main(String[] args) {
        // url 设置允许重写批量提交 rewriteBatchedStatements=true
        String url = "jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true";
        String user = "root";
        String password = "123456";
        String driver = "com.mysql.jdbc.Driver";
        // sql语句（注意url设置为rewriteBatchedStatements=true时，不允许sql语句带有;号，否则会抛出BatchUpdateException异常）
        String sql = "INSERT INTO fee(`owner`,`fee1`,`fee2`,`fee3`,`fee4`,`fee5`) VALUES (?,?,?,?,?,?)";
        Connection conn = null;
        PreparedStatement ps = null;
        // 开始时间
        long start = System.currentTimeMillis();
        try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, user, password);
            ps = conn.prepareStatement(sql);
            // 关闭自动提交
            conn.setAutoCommit(false);
            for (int i = 1; i <= 100000; i++) {
                ps.setString(1, "o"+i);
                ps.setBigDecimal(2, new BigDecimal("11111.111"));
                ps.setBigDecimal(3, new BigDecimal("11111.111"));
                ps.setBigDecimal(4, new BigDecimal("11111.111"));
                ps.setBigDecimal(5, new BigDecimal("11111.111"));
                ps.setBigDecimal(6, new BigDecimal("11111.111"));
                // 加入批处理（将当前sql加入缓存）
                ps.addBatch();
                // 以 1000 条数据作为分片
                if (i % 1000 == 0) {
                    // 执行缓存中的sql语句
                    ps.executeBatch();
                    // 清空缓存
                    ps.clearBatch();
                }
            }
            ps.executeBatch();
            ps.clearBatch();
            // 事务提交（实际开发中需要判断有插入失败的需要在 finally 中做好事务回滚操作）
            conn.commit();
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（批处理插入）：" + (end - start) + " ms");
    }
}

执行结果：

b37c6fe908a6b382e35678d6ecf5dd5d.jpeg

可以看到使用批处理+手动提交的方式插入 10w 条数据的执行时间大概在 1s 左右，速度明显提高了很多。接下来看看批处理方式需要注意的细节和重点有哪些：

  1. 利用 PreparedStatement 批量处理的三个方法来实现批量操作，分别是：

  • addBatch()：该方法用于向批处理中添加一批参数。通常在执行批量操作之前，通过多次调用该方法，将不同的参数添加到批处理中，然后一次性将这些参数一起提交给数据库执行。

  • executeBatch()：该方法用于执行当前的批处理。一旦添加完所有参数到批处理后，可以调用该方法将这些参数提交给数据库执行。该方法会返回一个整数数组，表示批处理中每个操作所影响的行数。

  • clearBatch()：该方法用于清空当前的批处理。在执行完当前批处理后需要清空当前批处理，可以调用该方法来清空之前添加的所有参数。

  1. 在配置 MySQL 的 url 时需要加上 rewriteBatchedStatements=true 才能达到真正意义上的批处理效果。

  • 这个设置是为了把允许重写批量提交（rewriteBatchedStatements）开启。

  • 在默认不开启的情况下，会无视 executeBatch() 方法，将原本应该批量执行的 sql 语句又拆散成单条语句执行。也就是说如果不开启允许重写批量提交，实际上批处理操作和原本的单条语句循环插入的效果一样。

  1. 使用 JDBC 时需要注意插入的 sql 语句结尾不能带 ; 号，否则会抛出 BatchUpdateException 异常。

  • 如图：01d51844c8213f27c40af15a8bebe9b5.jpeg

  • 这是因为使用批处理是会在结尾处进行拼接，如果结尾有 ; 号会导致插入语句变成 INSERT INTO TABLE(X,X,X,X) VALUES (X,X,X,X);,(X,X,X,X);,(X,X,X,X);,这样自然会出现 sql 语法错误。

  1. 需要注意批量处理时的分片操作，上面代码的分片大小为 1000（这是参考了后面 MP 框架的默认分片大小），分片操作可以避免一次性提交的数据量过大从而导致数据库在处理时出现的性能问题和内存占用过高问题，有效的分片可以减轻数据库的负担。

  2. 使用手动事务提交可以提高插入速度，在批量插入大量数据时，手动事务提交相对于自动提交事务来说可以减少磁盘的写入次数，减少锁竞争，从而提高插入的性能。

  • 可以通过 setAutoCommit(false) 来关闭自动提交事务，等全部批量插入完成后再通过 commit() 手动提交事务。

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址：https://github.com/YunaiV/yudao-cloud

  • 视频教程：https://doc.iocoder.cn/video/

MyBatis / MyBatis Plus 实现批量插入

由于 MyBatis Plus 相对于 MyBatis 来说只做了增强并没有改变 MyBatis 的功能，所以接下来将以 MyBatis Plus 来实现批量插入，其中有些方式是两个框架都可以使用的，有些则是 MP 独有的，会在后续讲解中标注出来。

MyBatis Plus 测试环境

先来配一下 MP 需要的测试环境，继续利用上文的 JDBC 测试环境并补充 MP 需要的测试环境：

maven 坐标：

<!-- MyBatis Plus 依赖 -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.3.1</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

application.properties ：

# 配置数据库
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true
spring.datasource.username=root
spring.datasource.password=123456

实现代码

由于 MyBatis / MyBatis Plus 的测试代码过多，所以在这里统一展示实体类、service、mapper 的实现代码，后续只给出测试代码。

Fee.java - 实体类

/**
 * Fee 实体类
 */
@TableName("fee")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Fee {

    @TableId(type = IdType.AUTO)
    private Long id;
    private String owner;
    private BigDecimal fee1;
    private BigDecimal fee2;
    private BigDecimal fee3;
    private BigDecimal fee4;
    private BigDecimal fee5;

}

FeeMapper.java - Mapper 接口

/**
 * Fee Mapper接口
 */
@Mapper
public interface FeeMapper extends BaseMapper<Fee> {

    /**
     * 单条数据插入
     * @param fee 实体类
     * @return 插入结果
     */
    int insertByOne(Fee fee);

    /**
     * foreach动态拼接sql插入
     * @param feeList 实体类集合
     * @return 插入结果
     */
    int insertByForeach(List<Fee> feeList);
}

这里继承 BaseMapper 只是为了使用最后的 MP 自带的批处理插入方法。如果不使用那种方式则可以不继承。

FeeMapper.xml - Mapper 映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="db.review.mapper.FeeMapper">

    <insert id="insertByOne">
        INSERT INTO fee(`owner`,`fee1`,`fee2`,`fee3`,`fee4`,`fee5`)
        VALUES (#{owner}, #{fee1}, #{fee2}, #{fee3}, #{fee4}, #{fee5})
    </insert>

    <insert id="insertByForeach">
        INSERT INTO fee(`owner`,`fee1`,`fee2`,`fee3`,`fee4`,`fee5`)
        VALUES
        <foreach collection="feeList" item="fee" separator=",">
            (#{fee.owner}, #{fee.fee1}, #{fee.fee2}, #{fee.fee3}, #{fee.fee4}, #{fee.fee5})
        </foreach>
   </insert>

</mapper>

FeeService.java - Service 接口

/**
 * Fee Service 接口
 */
public interface FeeService extends IService<Fee> {

    /**
     * 普通插入
     * @param feeList 实体类列表
     * @return 插入结果
     */
    int saveByFor(List<Fee> feeList);

    /**
     * foreach 动态拼接插入
     * @param feeList 实体类列表
     * @return 插入结果
     */
    int saveByForeach(List<Fee> feeList);


    /**
     * 批处理插入
     * @param feeList 实体类列表
     * @return 插入结果
     */
    int saveByBatch(List<Fee> feeList);
}

同样这里继承 IService 也只是为了使用最后的 MP 自带的批处理插入方法。如果不使用那种方式则可以不继承。

FeeServiceImpl.java - Service 实现类

/**
 * Fee Service 实现类
 */
@Service
public class FeeServiceImpl extends ServiceImpl<FeeMapper, Fee> implements FeeService {

    @Resource
    private FeeMapper feeMapper;

    @Resource
    private SqlSessionFactory sqlSessionFactory;

    @Override
    public int saveByFor(List<Fee> feeList) {
        // 记录结果（影响行数）
        int res = 0;
        // 循环插入
        for (Fee fee : feeList) {
            res += feeMapper.insertByOne(fee);
        }
        return res;
    }

    @Override
    public int saveByForeach(List<Fee> feeList) {
        // 通过mapper的foreach动态拼接sql插入
        return feeMapper.insertByForeach(feeList);
    }

    @Transactional
    @Override
    public int saveByBatch(List<Fee> feeList) {
        // 记录结果（影响行数）
        int res = 0;
        // 开启批处理模式
        SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
        FeeMapper feeMapper = sqlSession.getMapper(FeeMapper.class);
        for (int i = 1; i <= feeList.size(); i++) {
            // 利用mapper的单条插入方法插入
            res += feeMapper.insertByOne(feeList.get(i-1));
            // 进行分片类似 JDBC 的批处理
            if (i % 100000 == 0) {
                sqlSession.commit();
                sqlSession.clearCache();
            }
        }
        sqlSession.commit();
        sqlSession.clearCache();
        return res;
    }
}

同样这里继承 ServiceImpl 也只是为了使用最后的 MP 自带的批处理插入方法。如果不使用那种方式则可以不继承。

普通插入

同样为了形成对比，先来看看循环单条插入所需要的执行时间，通过 SpringBootTest 进行测试：

测试代码（代码没有使用 MyBatis Plus 的增强功能，所以这种方式在 MyBatis 和 MyBatis Plus 两个框架都适用）：

/**
 * MP 测试类
 *
 * @author 单程车票
 */
@SpringBootTest
public class MPDemo {

    @Resource
    private FeeService feeService;

    @Test
    public void mpDemo1() {
        // 获取 10w 条测试数据
        List<Fee> feeList = getFeeList();
        // 开始时间
        long start = System.currentTimeMillis();
        // 普通插入
        feeService.saveByFor(feeList);
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（普通插入方式）：" + (end - start) + " ms");
    }

    private List<Fee> getFeeList() {
        List<Fee> list = new ArrayList<>();
        for (int i = 1; i <= 100000; i++) {
            list.add(new Fee(null, "o" + i,
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111")));
        }
        return list;
    }
}

测试结果：

93996771360a89bf2c6270b5a1d81dfa.jpeg

可以看到花费时间大致和 JDBC 的普通插入方式一致都在 80s 左右。

foreach 动态拼接插入

接下来，看看使用 foreach 动态 sql 来实现拼接 sql 的方式进行插入的执行时间是多少。

测试代码（代码没有使用 MyBatis Plus 的增强功能，所以这种方式在 MyBatis 和 MyBatis Plus 两个框架都适用）：

/**
 * MP 测试类
 */
@SpringBootTest
public class MPDemo {

    @Resource
    private FeeService feeService;

    @Test
    public void mpDemo2() {
        // 获取 10w 条测试数据
        List<Fee> feeList = getFeeList();
        // 开始时间
        long start = System.currentTimeMillis();
        // foreach动态拼接插入
        feeService.saveByForeach(feeList);
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（foreach动态拼接插入方式）：" + (end - start) + " ms");
    }

    private List<Fee> getFeeList() {
        List<Fee> list = new ArrayList<>();
        for (int i = 1; i <= 100000; i++) {
            list.add(new Fee(null, "o" + i,
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111")));
        }
        return list;
    }
}

测试结果：

5656bd36b08546aa259e31e182b68b66.jpeg

可以看到当数据量为 10w 条时，测试结果报错，这是因为默认情况下 MySQL 可执行的最大 SQL 语句大小为 4194304 即 4MB，这里使用动态 SQL 拼接后的大小远大于默认值，故报错。

可以通过设置 MySQL 的默认 sql 大小来解决此问题（这里设置为 10MB）：

sql
复制代码set global max_allowed_packet=10*1024*1024;

重新运行后的测试结果：

21ee3a1a5a9e1a96f71d7773347bbef8.jpeg

可以看到增大默认是 SQL 大小后插入的时间在 3s 左右，相对于 JDBC 的批处理来说速度要稍微慢一点，但比起普通插入来说已经优化很多了。但是这种方式的弊端也很明显，就是无法确定 SQL 究竟多大，不能总是更改默认的 SQL 大小，不实用。

批处理插入

接下来，来看看 JDBC 的批处理插入方式在 MyBatis / MyBatis Plus 框架中是如何实现的。

测试代码（代码没有使用 MyBatis Plus 的增强功能，所以这种方式在 MyBatis 和 MyBatis Plus 两个框架都适用）：

/**
 * MP 测试类
 */
@SpringBootTest
public class MPDemo {

    @Resource
    private FeeService feeService;

    @Test
    public void mpDemo3() {
        // 获取 10w 条测试数据
        List<Fee> feeList = getFeeList();
        // 开始时间
        long start = System.currentTimeMillis();
        // 批处理插入
        feeService.saveByBatch(feeList);
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（批处理插入方式）：" + (end - start) + " ms");
    }

    private List<Fee> getFeeList() {
        List<Fee> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            list.add(new Fee(null, "o" + i,
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111")));
        }
        return list;
    }
}

测试结果：

b61f582f29b9b80d8b974578d52a7403.jpeg

可以看到使用 MyBatis / MyBatis Plus 框架实现的批处理插入方式和 JDBC 的批处理插入方式的执行时间都在 1s 左右。

实现的核心代码如下：

@Transactional
@Override
public int saveByBatch(List<Fee> feeList) {
    // 记录结果（影响行数）
    int res = 0;
    // 开启批处理模式
    SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
    FeeMapper feeMapper = sqlSession.getMapper(FeeMapper.class);
    for (int i = 1; i <= feeList.size(); i++) {
        // 利用mapper的单条插入方法插入
        res += feeMapper.insertByOne(feeList.get(i-1));
        // 进行分片类似 JDBC 的批处理
        if (i % 100000 == 0) {
            sqlSession.commit();
            sqlSession.clearCache();
        }
    }
    sqlSession.commit();
    sqlSession.clearCache();
    return res;
}

需要注意的是：

  • 和 JDBC 一样都需要开启允许重写批量处理提交（即在配置文件的数据库配置 url 中加上rewriteBatchedStatements=true）。

  • 代码中需要使用批处理模式（利用 SqlSessionFactory 设置批处理模式并获取对应的 Mapper 接口）

  • 代码中同样进行了分片操作，目的是为了减轻数据库的负担避免在处理时内存占用过高。

  • 可以在实现方法中加上 @Transactional 注解来起到手动提交事务的效果（好处和 JDBC 一样）。

MP 自带的批处理插入

接下来，看看 MyBatis Plus 自带的批处理方法的执行效率如何。

测试代码（注意代码中没有使用到上面的任何实现代码，而是依靠 MP 自带的 saveBatch() 方法完成批量插入）：

/**
 * MP 测试类
 */
@SpringBootTest
public class MPDemo {

    @Resource
    private FeeService feeService;

    @Test
    public void mpDemo4() {
        // 获取 10w 条测试数据
        List<Fee> feeList = getFeeList();
        // 开始时间
        long start = System.currentTimeMillis();
        // MP 自带的批处理插入
        feeService.saveBatch(feeList);
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（MP 自带的批处理插入方式）：" + (end - start) + " ms");
    }

    private List<Fee> getFeeList() {
        List<Fee> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            list.add(new Fee(null, "o" + i,
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111")));
        }
        return list;
    }
}

测试结果：

bd67262c3253b68acd2c4d1889dd02bd.jpeg

可以看到使用 MP 自带的批处理方法执行时间在 2s 左右，虽然比自己实现的批处理方法差了一点点，但是架不住它可以拿来就用，所以这也是一种好的选择。

注意：这里依旧需要开启允许重写批量处理提交（即在配置文件的数据库配置 url 中加上rewriteBatchedStatements=true）。这个很关键，否则效率上会大打折扣的。

放一张没有开启允许重写批量处理的执行结果：

6d13aa5e8aad6188a676a04b75081756.jpeg

MP 自带的 saveBatch() 方法源码分析

相信大家不只是为了使用 MP 的批量处理方法，应该都好奇 MP 自带的 saveBatch() 方法是如何实现的，那么接下来我想深入源码一起来看看。

进入第一层源码：

ee7605956811b408ec3a82edf86285e5.jpeg

可以看到这里带上了一个参数 batchSize = 1000（这里其实就是分片大小 1000，也是我上述代码借鉴的分片大小），接着往下进入 executeBatch() 方法：

e14377c7705bb2d3ee8e78532237969a.jpeg

可以看到 Lambda 表达式其实跟上面的实现批处理插入方式类似，先一条一条插入数据，当达到分片大小后，提交并刷新，从而达到批处理的效果。再深入到下一个 executeBatch() 方法会看到底层使用的也是批处理模式。

ab43bfcdc4630a9dbb70d2fdc2eaba28.jpeg

所以其实 MP 自带的批处理方法和上文中实现的批处理方法类似。

总要有总结

以上就是这次批量插入场景问题下如何通过 JDBC 和 MyBatis / MyBatis Plus 框架实现批量插入的整个优化过程了。

通过上面的讲解，相信大家应该也可以看出来哪些实现方式是有着良好的效率和性能的。

  • 使用 JDBC 推荐使用自己实现批处理方式。

  • 使用 MyBatis / MyBaits Plus 推荐使用自己实现的批处理方式或 MP 自带的批处理方法。

记得使用批处理方式进行批量插入一定要带上 rewriteBatchedStatements=true，这点很重要。

欢迎加入我的知识星球，全面提升技术能力。

👉 加入方式，“长按”或“扫描”下方二维码噢：

8999c6e3a773b2cda18e4cea1134643e.png

星球的内容包括：项目实战、面试招聘、源码解析、学习路线。

195f01450e4a447108f290b83c16a888.png

1e437e3ee9b6c525d38358705c059538.png860eebfc9919b5ab1c9bce8463eb9fda.png5add3349a3c7c5e9026d75d7a76e64f5.png968b2e96c8aded66f017164806c3902b.png

文章有帮助的话，在看，转发吧。
谢谢支持哟 (*^__^*）
标签
#mybatis
原文链接：https://mp.weixin.qq.com/s?__biz=MzUzMTA2NTU2Ng==&mid=2247589565&idx=4&sn=41fff3fb8605d2868a72dac254a7f5ce&chksm=fb96d39ce036ffd14e74b1d3e792c96874a505e688186bdd2837b6a65722c1db26a029803f3a&scene=126&sessionid=0>
苍穹外卖实战：套餐管理模块的CRUD与业务逻辑精解 本文深入解析苍穹外卖系统中套餐管理模块的CRUD操作与业务逻辑实现。从组合商品特性分析到分层事务控制设计，详细讲解新增套餐的主键回显、批量插入优化等实战技巧，涵盖分页查询优化、状态联动管理、性能调优等企业级解决方案，帮助开发者高效构建高可用的外卖系统套餐管理功能。 阅读详情

相关推荐

若依框架里给TDengine时序库配个‘副驾驶’：多数据源配置实战（附REST连接踩坑点）

本文详细介绍了在若依框架中配置TDengine时序库作为多数据源的实战经验，包括混合架构设计、YAML配置、Java代码调整及性能优化。特别针对REST连接方式的常见问题提供了解决方案，帮助开发者高效处理物联网场景下的高频数据写入与查询需求。

weixin_28396629的博客 279

从120s到2.5s！看看人家的MyBatis批量插入数据优化，那叫一个优雅！

点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 10:33更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析作业调度中间件 E...

芋艿V 269

MySQL数据库实训：从SQL语法到JDBC连接池的实战避坑指南

数据库作为现代应用的核心组件，其核心功能在于高效、安全地存储和管理结构化数据。其工作原理基于客户端-服务器架构，通过SQL语言进行交互，并依靠事务机制保证数据一致性。掌握数据库技术对于构建稳定、可扩展的应用系统具有重要价值，广泛应用于电商、金融、社交等各类互联网场景。在实际开发中，JDBC连接池是提升数据库访问性能的关键技术，它能有效管理连接资源，避免频繁创建和销毁连接的开销。同时，正确处理时区与字符集配置是保障数据准确性的基础，例如在MySQL中统一使用utf8mb4字符集和Asia/Shanghai时区

weixin_33798152的博客 396

MySQL驱动Add Batch优化实现

MySQL 驱动会在 JDBC URL 添加 rewriteBatchedStatements 参数时，对 batch 操作进行优化。本文测试各种参数组合的行为，并结合驱动代码简单分析。

flyingzc的博客 1646

基于SpringBoot的校园二手交易平台：从零搭建与毕设实战指南

在Java Web开发领域，SpringBoot作为一款主流的快速应用开发框架，因其简化配置和强大的生态支持，已成为构建企业级应用的首选。其核心原理在于通过自动配置和起步依赖，极大降低了项目搭建的复杂度，使开发者能聚焦于业务逻辑实现。这一技术价值在快速原型开发和教学实践中尤为突出，特别适用于校园二手交易平台这类具有典型增删改查业务场景的系统。通过整合MyBatis-Plus实现高效数据持久化，并利用Thymeleaf模板引擎进行页面渲染，开发者可以快速构建出功能完整、架构清晰的应用。本文将以一个开箱即用的高

cunfuteng7334的博客 356

SQL查询优化实战：从执行计划到资源友好型设计

SQL查询质量远不止语法正确，其本质是数据库引擎对数据分布、执行路径与资源调度的综合响应。理解执行计划（EXPLAIN）是诊断性能瓶颈的第一步，它揭示全表扫描、临时表、文件排序等真实开销；而索引失效、JOIN语义偏差、OFFSET分页陷阱等高频问题，往往源于对数据分布和业务场景的认知断层。具备‘查询设计意识’的工程师，能预判千万级数据下的执行时间、内存占用与锁行为，实现性能可控、结果准确、维护可持续的SQL交付。本文聚焦真实生产环境中的可落地优化框架，覆盖MySQL/PostgreSQL主流引擎，直击数据分

weixin_33725807的博客 297

Mybatis的三种批量插入方式耗时比较

Mybatis的三种批量插入方式

qq_42615006的博客 917

SQL LIMIT不是语法糖，而是数据库性能生死线

LIMIT是SQL中被严重低估的核心机制，本质并非简单截取结果，而是深度影响查询执行计划的物理扫描控制指令。其性能表现高度依赖索引设计与ORDER BY字段的有序性，尤其在大数据量场景下，OFFSET分页会引发阶梯式IO恶化，而游标分页通过WHERE+排序字段值实现零OFFSET高效定位。技术价值在于以极小开销实现结果集节流、关联规模约束和实时数据采样。典型应用场景包括高并发API分页、子查询结果集压缩、多源搜索聚合及DBA诊断探查。本文聚焦SQL LIMIT、分页性能与大数据量查询三大热词，揭示从执行器介

weixin_34284188的博客 687

MyBatis 批量插入数据的 3 种方法！

作者 | 王磊来源 | Java中文社群（ID：javacn666）转载请联系授权（微信ID：GG_Stone批量插入功能是我们日常工作中比较常见的业务功能之一，之前我也写过一篇关于《My...

磊哥聊Java 3949

现代C++ ORM库ormpp：告别原生SQL拼接，实现类型安全的数据库操作

对象关系映射（ORM）是一种将面向对象编程语言中的对象与关系型数据库中的表进行映射的技术，其核心原理是通过元数据描述对象与表之间的对应关系，自动生成SQL语句并处理数据转换。这项技术能显著提升开发效率，减少手动编写SQL带来的错误风险，并增强代码的可维护性。在C++服务端开发中，直接使用原生数据库API进行开发往往面临代码冗长、类型不安全、SQL注入防护需手动处理等挑战。ormpp作为一个纯头文件的现代C++ ORM库，充分利用C++11/14/17的编译期反射、变参模板等特性，在编译期完成类型检查和SQL

weixin_34262482的博客 447

SpringBoot+Mybatis学生就业管理系统：毕业设计与实战指南

在Java Web开发领域，SpringBoot与Mybatis是构建企业级应用的主流技术组合。SpringBoot通过约定大于配置的理念和自动装配机制，极大地简化了项目初始化和部署流程，使开发者能更专注于业务逻辑的实现。Mybatis作为一款优秀的持久层框架，以其灵活的SQL编写能力和对复杂查询的良好支持，在需要精细控制数据库操作的场景中表现出色，其动态SQL功能能优雅处理多条件组合查询。这两项技术的结合，为开发高效、可维护的后端服务提供了坚实的技术基础，其技术价值在于平衡了开发效率与系统性能。这种组合广

benben 476

批量update实现方案全面解析与最佳实践，带你掌握到底怎么批量更新最快、性能最高

本文全面对比了MyBatis批量更新方案的性能差异。针对百万级数据表测试了三种实现方式：循环单条更新耗时3846ms；foreach多SQL语句方式耗时显著降低；还介绍了其他优化方案。测试表明，批量更新性能受数据量、索引结构、内存缓存等因素影响，大表需更多I/O定位记录。建议根据实际场景选择合适方案，避免for循环内单条操作SQL这种性能瓶颈。文章提供了代码示例和SQL执行流程分析，帮助开发者优化批量更新操作。

weixin_41821642的博客 764

[pcie]gen6 下 L0p

000b~100b： 触发L0p 操作流程协商工作link width 到target link width.为111b:link width 硬件动态调整。硬件动态：Device control 3 register.target link width=111b当pcie链路检测到空闲状态时，设备可以主动进入L0p状态。L0p 是pcie gen6 新引入的链路状态，是L0的子状态。（5）LINK WIDTH：当LINK WIDTH CHANGE.cmd为Request时表示请求的链路宽度。

BIG_APPLE1的博客 1681

从踩坑到优雅：记一次MySQL 8.0 JSON字段与MyBatis集成的完整填坑实录

本文详细记录了MySQL 8.0 JSON字段与MyBatis集成的完整填坑过程，从手动JSON转换到原生JSON类型集成，再到TypeHandler的优化应用，最终解决UTF8MB4编码问题。通过实战案例展示了如何优雅处理JSON数据存储，提升开发效率与系统性能。

weixin_30572613的博客 303

鸿蒙日历组件进阶：教你打造个性化日程管理界面（支持月份切换）

本文深入探讨了鸿蒙应用开发中自定义日历组件的构建方法。通过详解基于Grid的布局设计、核心日期算法、月份切换逻辑以及事件管理集成，指导开发者打造支持个性化日程管理的高性能日历界面，提升应用交互体验。

weixin_29207149的博客 67

LTspice 导入 PSpice 模型实战指南 --（解决语法兼容性与模型优化问题）

本文提供了将PSpice模型成功导入LTspice的详细实战指南。针对两者间的语法兼容性问题，文章以TI UCC23513为例，逐步讲解模型获取、符号创建、常见语法错误修改及仿真验证方法，并分享了模型优化与个人库管理技巧，帮助用户高效解决模型导入与仿真难题。

weixin_28278377的博客 824

MyBatis 深度优化：从 SQL 低效到性能翻倍，10 个企业级实战技巧

摘要：MyBatis性能优化指南分析生产环境高频问题，指出SQL无索引（38%）、全表扫描（27%）等主要瓶颈。提出10个关键优化技巧：1）索引优化（避免SELECT*和模糊查询）；2）合理使用一/二级缓存；3）动态SQL高效拼接；4）结果映射优化等。以电商商品查询为例，通过索引+缓存+分页优化，使查询耗时从3s降至80ms，QPS提升37倍。强调避免过度索引、控制批量操作规模等实践要点，实现数据库负载显著降低。

qq_55253420的博客 626

Docker新手必看：解决‘Unable to find image’错误的完整指南

本文针对Docker新手常见的‘Unable to find image’错误，提供了完整的排查与解决指南。文章深入剖析了权限不足、网络连接失败、Docker服务未运行等核心原因，并给出了将用户加入docker组、配置镜像加速器等实用解决方案，帮助读者彻底理解并解决镜像拉取问题。

weixin_29230901的博客 244

SpringBoot深度实战：从原理到生产级应用，攻克面试与工程难题

SpringBoot作为Java后端开发的主流框架，其核心价值在于简化配置、快速构建应用。其原理基于自动装配机制，通过条件注解按需加载组件，实现了开箱即用的便捷性。这一特性极大地提升了开发效率，降低了项目启动成本，使其成为构建微服务和云原生应用的重要技术选型。在实际工程实践中，SpringBoot不仅用于基础CRUD开发，更需应对生产环境中的复杂挑战，例如服务优雅下线、线上OOM故障排查等。掌握其深度能力，如自定义Starter、集成Actuator监控、利用Profile进行多环境配置管理以及容器化部署，

weixin_30268071的博客 370

AMD 3D V-Cache技术解析：CPU缓存堆叠如何突破性能瓶颈

在半导体领域，缓存（Cache）是提升处理器性能的关键技术，其核心原理是在高速CPU核心与慢速主存之间建立数据中转站，以缓解“内存墙”问题。随着摩尔定律放缓，传统平面扩展缓存面临面积成本高、延迟增加等挑战。3D封装技术应运而生，通过垂直堆叠实现极致的互联密度与带宽，成为突破性能瓶颈的重要工程路径。这项技术的价值在于能以更优的功耗和延迟，显著提升缓存容量，从而改善游戏、科学计算等数据密集型应用的性能。以AMD 3D V-Cache为代表的Hybrid Bonding（混合键合）工艺，正是这一趋势的典型实践，它

weixin_30432579的博客 418

NVIDIA Jetson之交叉编译工具

参考：http://bbs.xfyun.cn/forum.php?mod=viewthread&amp;tid=33630 用TX2做红外热成像仪的识别，厂家不提供源码，只能提供对应版本的SDK，但是需要我们自己提供交叉编译器 由于之前没有做过交叉编译相关工作，对编译工具不太了解，因此查找相关资料学习下 交叉编译知识 一般来说，针对嵌入式平台的开发有两种编译模式：原生编译和交叉编译。原生编...

ZONGXP的博客 8385

Spring Boot+Vue全栈音乐网站实战：从零构建企业级前后端分离项目

前后端分离架构是现代Web开发的主流范式，它将应用逻辑清晰地划分为前端用户界面与后端业务服务。其核心原理在于通过RESTful API进行数据交互，前端负责视图渲染与用户交互，后端专注于数据处理与业务逻辑。这种架构的技术价值在于提升开发效率、便于团队协作、增强应用的可扩展性与可维护性。在电商、社交、内容管理等众多应用场景中，前后端分离已成为标准实践。本文聚焦于一个具体的**音乐网站**项目，深入探讨如何运用**Spring Boot**与**Vue**这两大主流技术栈，实现用户认证、音频播放、歌单管理等核心

weixin_34074740的博客 432

Vue3 - 实现内网使用天地图离线地图，详解项目加载天地图的离线地图服务器部署与使用教程示例源码，vue3如何实现天地图的离线加载部署在内网访问（天地图资源下载/瓦片等流程教学，实现天地图各种功能）

Vue3中加载天地图的离线地图，天地图——内网使用离线地图，vue3+leaflet实现天地图离线访问，vue3项目中利用leaflet使用天地图，vue3项目中使用天地图离线地图，天地图离线瓦片的打包与发布（GeoServer）天地图离线瓦片数据下载及本地化部署，在内网中无法直接使用外网天地图资源怎么办，在vue3中openLayers加载地图 -使用天地图的瓦片数据。VUE3天地图离线怎么使用，内网部署天地图，天地图离线瓦片，部分瓦片数据，天地图如何离线，无需网络调用天地图API，vue天地图离线地图，

🏆 前端领域优质创作者 1万+

Java+Vue+Spring Boot+MySQL课程作业管理系统：毕业设计与实战指南

如果你是一名计算机专业的学生，正在为毕业设计选题而焦虑，或者你是一位刚入行的Java开发者，想找一个完整的、能跑起来的项目来巩固技术栈，那么这篇文章就是为你准备的。毕业设计不是简单的代码堆砌，它考察的是你对一个完整软件系统的理解、设计和实现能力。一个典型的“课程作业管理系统”看似简单，但麻雀虽小五脏俱全，它几乎涵盖了企业级Web应用开发的所有核心环节：前后端分离架构、数据库设计、用户权限管理、业务逻辑实现、API接口设计等。 今天，我们将深入剖析一个基于 Java + Vue + Spring Boot +

weixin_34159110的博客 445

从0到1：用Claude 3.7十日拿下教育部课题申报书（附可修改LaTeX模板）

🟣"作为教育部人文社科项目评审专家，请根据近三年立项数据分析，为[您的学科方向]领域推荐5个具有创新性且符合'十四五'规划的重点选题，要求选题体现交叉学科特征，并标注潜在理论突破点"🟣"根据前期研究基础，创建包含4个研究模块、12个关键节点的三维技术路线图，要求体现实验仿真-实证研究-理论建模的螺旋递进关系，并标注每个节点的预期成果形态"🟣"现在切换至教育部学科评审组组长模式，从选题价值、创新程度、研究可行性三个维度对本申报书进行盲审，生成包含9个扣分风险点的诊断报告及修改优先级排序"

智能AI让学术科研更容易 545

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员，提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列，各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性，请参见数据手册。有关 ARM Cortex™-M4F 内核的信息，请参见《Cortex™-M4F 技术参考手册》。
上一篇： 微服务全做错了！谷歌提出新方法，成本直接降9倍！
下一篇： 2023，那些被“技术网红”误导的技术趋势
点赞 1
评论 0
书签 书签 1
公众号-芋道源码
公众号-芋道源码
博客等级 码龄10年 1634粉丝 377原创
+ 关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值