mybatis的ExecutorType.BATCH真的能提高批量插入速度吗？（存疑）

已于 2022-09-16 16:30:29 修改
阅读量2.7k 收藏 10
点赞数 4
分类专栏： mybatis 文章标签： mybatis batch java
于 2022-09-16 16:25:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jdbcmeng/article/details/126891492
版权

以前面试时，有人问我mybatis批量插入数据怎么做？我说用foreach，他说不对。回去查了一下，原来是ExecutorType.BATCH，涨知识了。
今天心血来潮测试了一下，发现好像并不是那么回事…

先说结论：我测试的是，ExecutorType.BATCH远不如foreach速度快！但愿是我代码写错了！

环境准备

建表：

CREATE TABLE `result` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `title` varchar(255) DEFAULT NULL COMMENT '标题',
  `content` varchar(255) DEFAULT NULL COMMENT '内容',
  `source_url` varchar(255) DEFAULT NULL COMMENT '内容来源',
  `img_url` varchar(255) DEFAULT NULL COMMENT '封面图片',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `del_flag` tinyint(4) DEFAULT '0' COMMENT '是否删除',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2398003 DEFAULT CHARSET=utf8mb4 COMMENT='结果表';

dao:

@Repository
public interface BaiDuResultDao {

    int insert(BaiDuResult record);

    int insertBatch(List<BaiDuResult> list);

mapper.xml

  <insert id="insert" parameterType="com.meng.entity.BaiDuResult" >
    insert into result (id, title, content, 
      source_url, img_url, create_time, 
      update_time, del_flag)
    values (#{id,jdbcType=BIGINT}, #{title,jdbcType=VARCHAR}, #{content,jdbcType=VARCHAR}, 
      #{sourceUrl,jdbcType=VARCHAR}, #{imgUrl,jdbcType=VARCHAR}, #{createTime,jdbcType=TIMESTAMP}, 
      #{updateTime,jdbcType=TIMESTAMP}, #{delFlag,jdbcType=TINYINT})
  </insert>


  <insert id="insertBatch" parameterType="com.meng.entity.BaiDuResult" >
    insert into result (id, title, content,
      source_url, img_url, create_time,
      update_time, del_flag)
    values
    <foreach collection="list" item="result" separator=",">
      (
      #{result.id,jdbcType=BIGINT}, #{result.title,jdbcType=VARCHAR}, #{result.content,jdbcType=VARCHAR},
      #{result.sourceUrl,jdbcType=VARCHAR}, #{result.imgUrl,jdbcType=VARCHAR}, #{result.createTime,jdbcType=TIMESTAMP},
      #{result.updateTime,jdbcType=TIMESTAMP}, #{result.delFlag,jdbcType=TINYINT}
      )
    </foreach>

测试过程

  1. 先用每次插入单条数据的方式插入10万条数据
    @Test
    public void test1Insert(){
        long begin = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            BaiDuResult result = new BaiDuResult();
            result.setTitle("这是标题" + i);
            result.setContent("这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容 " + i);
            result.setCreateTime(new Date());
            result.setUpdateTime(new Date());
            dao.insert(result);
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时多少秒(end - begin)/1000 = " + (end - begin) / 1000);

        /**
         * 耗时多少秒(end - begin)/1000 = 159
         */
    }

结果是耗时159秒

  1. 使用foreach的方式插入
@Test
    public void test2ForEachInsert(){
        long begin = System.currentTimeMillis();
        List<BaiDuResult> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            BaiDuResult result = new BaiDuResult();
            result.setTitle("这是标题" + i);
            result.setContent("这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容 " + i);
            result.setCreateTime(new Date());
            result.setUpdateTime(new Date());
            list.add(result);
            if(i % 1000 == 0){
                dao.insertBatch(list);
                list.clear();
            }
        }
        if(list.size() > 0){
            dao.insertBatch(list);
            list.clear();
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时多少秒(end - begin)/1000 = " + (end - begin) / 1000);

        /**
         * 耗时多少秒(end - begin)/1000 = 7   -- 十万数据，7秒
         * 耗时多少秒(end - begin)/1000 = 55  -- 百万数据，55秒
         */
    }

结果惊人！！！ 百万数据插入也只是用了55秒！！！！
注意：foreach插入时，每次执行的数据不能太多，否则报错：
在这里插入图片描述
3、使用ExecutorType.BATCH

    @Test
    public void test4BatchInsert(){
        SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH, false);
        BaiDuResultDao batchDao = sqlSession.getMapper(BaiDuResultDao.class);
        long begin = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            BaiDuResult result = new BaiDuResult();
            result.setTitle("这是标题" + i);
            result.setContent("这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容这是内容 " + i);
            result.setCreateTime(new Date());
            result.setUpdateTime(new Date());
            batchDao.insert(result);
        }
        sqlSession.commit();
        sqlSession.close();
        long end = System.currentTimeMillis();
        System.out.println("耗时多少秒(end - begin)/1000 = " + (end - begin) / 1000);

        /**
         *耗时多少秒(end - begin)/1000 = 151   这种方式不对啊，太慢了
         */
    }

结果并不是我认为的那样！！！除非是我的代码写错了！！！
我也怀疑是我的代码写错了，我试着去百度，结果TMD那么多写mybatis批量插入的文章，几乎都是复制粘贴，完全一样！代码甚至都不完整！自己压根就没试过，就把文章复制过来，当成自己的，鲁迅的拿来主义还真是研究的透透的！MD！
有一篇文章倒是和我的测试结果类似 foreach 和 数据库批量执行 效率比较

分析

我尝试着去翻mybatis官网 mybatis官网，发现对于ExecutorType.BATCH的描述是这样的：

这里是引用你可能对 ExecutorType 参数感到陌生。这个枚举类型定义了三个值:
ExecutorType.SIMPLE：该类型的执行器没有特别的行为。它为每个语句的执行创建一个新的预处理语句。
ExecutorType.REUSE：该类型的执行器会复用预处理语句。
ExecutorType.BATCH：该类型的执行器会批量执行所有更新语句，如果 SELECT 在多个更新中间执行，将在必要时将多条更新语句分隔开来，以方便理解。

这里只是说会批量执行语句，但没有说速度快
这种方式是把多条语句一起执行，所以它的速度比你一条一条执行的快（但我的测试并没有快的多明显），而foreach是把多条数据拼成一条sql ，这样的

insert into table (con1,con2…) values (value1 , value2),(value1 , value2),(value1 , value2)…

这也就解释了为什么foeach执行的数据太多报错的问题，因为拼成的sql太长了，所以要控制这个批量执行的数量，找到速度最快的数量配置。

如果使用原生的JDBC批量插入，速度如何？

原生JDBC批量插入

  1. 一条一条插入
    @Test
    public void test6JDBCBatchInsertOne() throws Exception{
        long begin = System.currentTimeMillis();
        Connection connection = DriverManager.getConnection("jdbc:mysql://192.168.233.136:3306/mydata","root","123456");
        PreparedStatement ps = connection.prepareStatement(
                "    insert into result (title, content, create_time, update_time) values (?, ?, ?, ?)");
        for (int i = 0; i < 100000; i++) {
            ps.setString(1 ,"title" + i);
            ps.setString(2 ,"contentcontentcontentcontentcontentcontentcontentcontent " + i);
            ps.setDate(3 ,new java.sql.Date(new Date().getTime()));
            ps.setDate(4 ,new java.sql.Date(new Date().getTime()));
            ps.execute();
        }
        connection.close();

        long end = System.currentTimeMillis();
        System.out.println("耗时多少秒(end - begin)/1000 = " + (end - begin) / 1000);

        /**
         *耗时多少秒(end - begin)/1000 = 158
         */
    }

可以看到，这样的一条一条插入，和mybatis的一条一条插入，速度差不多

  1. 使用addBatch()批量插入
    @Test
    public void test6JDBCBatchInsert2() throws Exception{
        long begin = System.currentTimeMillis();
        Connection connection = DriverManager.getConnection("jdbc:mysql://192.168.233.136:3306/mydata","root","123456");
        connection.setAutoCommit(false);
        PreparedStatement ps = connection.prepareStatement(
                "    insert into result (title, content, create_time, update_time) values (?, ?, ?, ?)");
        for (int i = 0; i < 100000; i++) {
            ps.setString(1 ,"title" + i);
            ps.setString(2 ,"contentcontentcontentcontentcontentcontentcontentcontent " + i);
            ps.setDate(3 ,new java.sql.Date(new Date().getTime()));
            ps.setDate(4 ,new java.sql.Date(new Date().getTime()));
            ps.addBatch();
            if(i%1000 == 0){
                ps.executeBatch();
                ps.clearBatch();
            }
        }
        connection.commit();
        connection.close();
        long end = System.currentTimeMillis();
        System.out.println("耗时多少秒(end - begin)/1000 = " + (end - begin) / 1000);
        /**
         *耗时多少秒(end - begin)/1000 = 102   
         */
    }

可以看到，速度有明显提升，但是和mybatis的foreach比，它就是个弟弟

总结

批量插入速度最快的方式是foreach，但是要控制每次插入的数量，否则就是个坑
以上结论接受反驳，但要拿出实质的证据

jdbcmeng
关注
专栏目录
【Mybatis源码解析第十章】详细说说Mybatis中的ExecutorType
诺浅的专栏
02-26 7975
缘起 上一章我们说到，在mybatis的ExecutorType中，执行sql有三种执行模式，分别为 SIMPLE REUSE BATCH 那么这三种模式有什么区别呢？ 其实这三种模式分别对应着三种执行器 SimpleExecutor、ReuseExecutor、BatchExecutor SimpleExecutor @Override public int doUpdate(Ma...
Mybatis 批量插入Batch模式与foreach对比
NothingToSay
11-25 4352
mysql默认接受sql的大小是 1M， 即第三种方式若数据量超过1M会报如下异常：（可通过调整MySQL安装目录下的my.ini文件中[mysqld]段的＂max_allowed_packet = 1M＂） JDBC连接url中添加参数rewriteBatchedStatements=true可 准备工作 表结构 CREATE TABLE `t_user` ( `id` varchar(32) CHARACTER SET utf8 NOT NULL COMMENT '主键', `name`.
MyBatis批量插入(ExecutorType.BATCH和＜foreach＞)
ShanHuHai26的博客
09-25 2091
MyBatis批量插入(ExecutorType.BATCH和foreach) MyBatis分批次批量插入 foreach标签批量插入 MyBatis ExecutorType.BATCH批量插入
mybatis批量插入优化（ExecutorType.BATCH/BatchInsert/executeBatch）
热门推荐
★【World Of Moshow 郑锴】★
12-29 3万+
Mybatis内置的有3种，默认的是simple单句模式，该模式下它为每个语句的执行创建一个新的预处理语句，单句提交sql；batch模式重复使用已经预处理的语句，并且批量执行所有语句，大批量模式下性能更优。请注意batch模式在Insert操作时事务没有提交之前，是没有办法获取到自增的id，所以请根据业务情况使用。使用simple模式提交10000条数据，时间为19s，batch模式为6s ，大致情况如此，优化的具体还要看提交的语句情况。如果需要使用foreach。
MyBatis 批量插入（ExecutorType.BATCH）
诚的博客
07-02 6243
一、在mybatis中ExecutorType的使用 1.Mybatis内置的ExecutorType有3种，默认的是simple，该模式下它为每个语句的执行创建一个新的预处理语句，单条提交sql；而batch模式重复使用已经预处理的语句， 并且批量执行所有更新语句，显然batch性能将更优； 2.但batch模式也有自己的问题，比如在Insert操作时，在事务没有提交之前，是没有办法获取到自增的id，这在某型情形下是不符合业务要求的； 在测试中使用simple模式提交10000条数据，时间为18248 毫
Mybatis批处理ExecutorType.BATCH
最新发布
qq_28865843的博客
07-27 1557
我们改为用原生的Batch插入，这样子的话，只要500多毫秒，也就是0.5秒的样子。通过批处理的方式，我们就可以在 JDBC 客户端缓存多条 SQL 语句，然后在 flush 或缓存满的时候，将多条 SQL 语句打包发送到数据库执行，这样就可以有效地降低上述两方面的损耗，从而提高系统性能。每次向数据库发送的 SQL 语句的条数是有上限的，如果批量执行的时候超过这个上限值，数据库就会抛出异常，拒绝执行这一批 SQL 语句，所以我们需要控制批量发送 SQL 语句的条数和频率。
mybatis使用ExecutorType.BATCH方式批量插入数据
zhangbeihai8的博客
09-26 3324
2.mapper.xml文件,我这里是写的是插入或更新语句,数据库是oracle,所以用merge into这种写法,判断条件,如果流水号存在,则更新,否则插入,mysql则是insert on duplicate key update 那种写法,如果这里不需要插入或更新,那就写普通的insert语句就可以了.有从excel中导入大量数据到数据库这种需求,如果一条一条insert就会很慢,mybatis默认是ExecutorType.SIMPLE方式.3.经过测试,导入五千条数据,几秒钟就可以插入完成.
mybatis中批量插入的两种方式(高效插入)
09-01
总结来说，MyBatis 通过`foreach` 标签和`ExecutorType.BATCH` 提供了灵活且高效的批量插入机制。`foreach` 适用于构建动态SQL，处理`IN`条件；而`ExecutorType.BATCH` 优化了批量插入的性能，通过调整提交频率和...
Spring MyBatis 批量插入：foreach, Spring事务, ExecutorType.BATCH 实现解析
在Spring中，集成MyBatis实现批量插入数据是常见的需求，尤其在处理大量数据时能够显著提高效率。这里我们将详细探讨三种实现方式：`foreach`、Spring事务以及使用`ExecutorType.BATCH`。 1. Foreach方式 这种方法...
mybatis执行批量更新batch update 的方法（oracle,mysql两种）
08-31
在MyBatis中，批量更新（batch update）是一种提高数据库操作效率的重要手段，尤其是在处理大量数据更新时。这里我们将详细探讨如何在Oracle和MySQL数据库中使用MyBatis进行批量更新。 1. **Oracle数据库的批量更新...
MyBatis 学习笔记（七）批量插入ExecutorType.BATCH效率对比
anyway, life must全力以赴
01-09 2571
https://www.cnblogs.com/zhaoyan001/p/10905826.html MyBatis 学习笔记（七）批量插入ExecutorType.BATCH效率对比 MyBatis 学习笔记（七）批量插入ExecutorType.BATCH效率对比 一、在mybatis中ExecutorType的使用 1.Mybatis内置的ExecutorType有3种，默认的是simp...
Mybatis批处理，使用ExecutorType.BATCH
huan1213858的博客
03-10 1550
批处理
mybatis 别再用foreach批量插入了，ExecutorType.BATCH更加高效的批量插入，省带宽、省时、查错方便、日志简洁
阿里渣渣java研发组-群主
11-24 2594
一、在mybatis中ExecutorType的使用 Mybatis内置的ExecutorType有3种，默认的是simple，该模式下它为每个语句的执行创建一个新的预处理语句，单条提交sql；而batch模式重复使用已经预处理的语句， 并且批量执行所有更新语句，显然batch性能将更优； 但batch模式也有自己的问题，比如在Insert操作时，在事务没有提交之前，是没有办法获取到自增的id，这在某型情形下是不符合业务要求的； 在测试中使用simple模式提交10000条数据，时间为18248
(工具类)mybatis如何开启batch模式
lisheng19870305的专栏
04-08 1608
一般来说，对于SSM项目工程来说，mybatis的ExectoryType默认是simple，那么又如何能动态使用batch模式呢？ 直接上源码实现干货： import org.apache.ibatis.session.ExecutorType; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.mybatis.spring.SqlSes
mybatis ExecutorType.BATCH 批量插入
素颜的博客
09-18 5285
@Autowired private SqlSessionFactory sqlSessionFactory; @org.junit.Test public void test2(){ SqlSession session =sqlSessionFactory.openSession(ExecutorType.BATCH); try { ...
Mybatis 使用ExecutorType.BATCH批量插入数据
菜鸟记录
11-21 3849
⏹当插入大量数据时,推荐使用Mybatis的ExecutorType.BATCH
mybatis的ExecutorType.BATCH模式批量插入SqlServe/2012下 70w条数据与JDBC批量插入方式对比
中年人
01-08 1423
如果使用Spring集成Mybatis，SqlSessionTemplate会判断当前是否存在事务，不存在的话，每次执行sql都会进行提交，这样的话即使ExecutorType设置为BATCH，批量操作也不会生效。最近在学习Mybatis框架，关于事务和批处理的关系，原生Mybatis、Mybatis-Spring和底层JDBC的事务的关系，还有许多问题有待梳理。
mybatis 批量插入速度慢
caibird_li的博客
07-13 3162
mybatis 批量插入速度慢 原因以及解决方式
springboot 集成的 mybatis 设置 executorType 为 batch模式
gzt19881123的专栏
02-12 1万+
springboot 集成的 mybatis 设置 executorType 为 batch模式 mybatis提供三种sql执行器，分别是SIMPLE（默认）、REUSE、BATCH。 SIMPLE（SimpleExecutor），相当于JDBC的stmt.execute(sql)； REUSE（ReuseExecutor），相当于JDBC重用一条sql，再通过stmt传入多项参数值，然后执行stmt.executeUpdate()或stmt.executeBatch()； BATCH（B.
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值