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

已于 2022-09-16 16:30:29 修改
阅读量2.5k 收藏 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
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
MyBatis批量插入(ExecutorType.BATCH和＜foreach＞)
ShanHuHai26的博客
09-25 1969
MyBatis批量插入(ExecutorType.BATCH和foreach) MyBatis分批次批量插入 foreach标签批量插入 MyBatis ExecutorType.BATCH批量插入
spring中使用mybatis实现批量插入的示例代码
08-19
使用 ExecutorType.BATCH 方式可以实现批量插入操作，优点是可以控制批量大小和提交频率。 五、总结 本文介绍了 Spring 中使用 MyBatis 实现批量插入的示例代码，主要分为三种实现方式：foreach、Spring 事务、...
Excel 5s内导入20w条简单数据（ExecutorType.BATCH）Mybatis批处理的应用
微风轻吟挽歌的博客
10-20 1288
ExecutorType.BATCH会将一批SQL语句集中在一起批量执行，减少了与数据库的交互次数，提高性能。 - 多条SQL语句会一起提交到数据库执行，可以提升执行效率。 - 可以通过sqlSessionFactory.openSession(ExecutorType.BATCH)方法手动触发批量执行。 - 适用于需要执行大量SQL操作的场景，如批量插入、更新或删除多条记录。
Mybatis插入大量数据效率对比：foreach插入、SqlSession批量插入、sql插入
2401_84048034的博客
04-09 753
sql插入的效率最高，sqlsession次之，mybatis框架foreach插入效率最低。执行效率echarts图：来源：blog.csdn.net/chenping1993/自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
(工具类)mybatis如何开启batch模式
lisheng19870305的专栏
04-08 1569
一般来说，对于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）
诚的博客
07-02 6132
一、在mybatis中ExecutorType的使用 1.Mybatis内置的ExecutorType有3种，默认的是simple，该模式下它为每个语句的执行创建一个新的预处理语句，单条提交sql；而batch模式重复使用已经预处理的语句， 并且批量执行所有更新语句，显然batch性能将更优； 2.但batch模式也有自己的问题，比如在Insert操作时，在事务没有提交之前，是没有办法获取到自增的id，这在某型情形下是不符合业务要求的； 在测试中使用simple模式提交10000条数据，时间为18248 毫
mybatis使用ExecutorType.BATCH方式批量插入数据
zhangbeihai8的博客
09-26 3231
2.mapper.xml文件,我这里是写的是插入或更新语句,数据库是oracle,所以用merge into这种写法,判断条件,如果流水号存在,则更新,否则插入,mysql则是insert on duplicate key update 那种写法,如果这里不需要插入或更新,那就写普通的insert语句就可以了.有从excel中导入大量数据到数据库这种需求,如果一条一条insert就会很慢,mybatis默认是ExecutorType.SIMPLE方式.3.经过测试,导入五千条数据,几秒钟就可以插入完成.
mybatis ExecutorType.BATCH 批量插入
素颜的博客
09-18 5231
@Autowired private SqlSessionFactory sqlSessionFactory; @org.junit.Test public void test2(){ SqlSession session =sqlSessionFactory.openSession(ExecutorType.BATCH); try { ...
mybatis的ExecutorType.BATCH模式批量插入SqlServe/2012下 70w条数据与JDBC批量插入方式对比
中年人
01-08 1105
如果使用Spring集成Mybatis，SqlSessionTemplate会判断当前是否存在事务，不存在的话，每次执行sql都会进行提交，这样的话即使ExecutorType设置为BATCH，批量操作也不会生效。最近在学习Mybatis框架，关于事务和批处理的关系，原生Mybatis、Mybatis-Spring和底层JDBC的事务的关系，还有许多问题有待梳理。
mybatis执行批量更新batch update 的方法（oracle,mysql两种）
08-31
在MyBatis中，批量更新（batch update）是一种提高数据库操作效率的重要手段，尤其是在处理大量数据更新时。这里我们将详细探讨如何在Oracle和MySQL数据库中使用MyBatis进行批量更新。 1. **Oracle数据库的批量更新...
MyBatis通过BATCH批量提交的方法
08-26
"MyBatis通过BATCH批量提交的方法" MyBatis是一个基于Java的持久层框架，它提供了许多实用的功能来简化数据库访问和操作。今天，我们将讨论MyBatis通过BATCH批量提交的方法，这是一种高效的方式来执行批量操作。 ...
mybatis-plus_batch_insert：mybatis_plus添加批量插入
02-14
在处理大量数据时，批量插入（Batch Insert）是一种非常有效的方法，可以显著提高数据库操作的效率。本篇文章将详细介绍如何在 MyBatis-Plus 中实现批量插入。 ### 1. MyBatis-Plus 简介 MyBatis-Plus 是 MyBatis ...
mybatisx.zip
11-08
MybatisX是一个专门为Java开发人员设计的IntelliJ IDEA插件，它极大地简化了MyBatis框架的使用，提高了开发效率。这个压缩包文件“mybatisx.zip”包含了多个版本的MybatisX插件，包括MybatisX-1.4.16.zip、MybatisX-...
MyBatis 学习笔记（七）批量插入ExecutorType.BATCH效率对比
全力以赴烂口发_青春饭耗不起
01-09 2507
https://www.cnblogs.com/zhaoyan001/p/10905826.html MyBatis 学习笔记（七）批量插入ExecutorType.BATCH效率对比 MyBatis 学习笔记（七）批量插入ExecutorType.BATCH效率对比 一、在mybatis中ExecutorType的使用 1.Mybatis内置的ExecutorType有3种，默认的是simp...
Mybatis批处理ExecutorType.BATCH
qq_28865843的博客
07-27 1023
我们改为用原生的Batch插入，这样子的话，只要500多毫秒，也就是0.5秒的样子。通过批处理的方式，我们就可以在 JDBC 客户端缓存多条 SQL 语句，然后在 flush 或缓存满的时候，将多条 SQL 语句打包发送到数据库执行，这样就可以有效地降低上述两方面的损耗，从而提高系统性能。每次向数据库发送的 SQL 语句的条数是有上限的，如果批量执行的时候超过这个上限值，数据库就会抛出异常，拒绝执行这一批 SQL 语句，所以我们需要控制批量发送 SQL 语句的条数和频率。
mybatis 别再用foreach批量插入了，ExecutorType.BATCH更加高效的批量插入，省带宽、省时、查错方便、日志简洁
阿里渣渣java研发组-群主
11-24 2450
一、在mybatis中ExecutorType的使用 Mybatis内置的ExecutorType有3种，默认的是simple，该模式下它为每个语句的执行创建一个新的预处理语句，单条提交sql；而batch模式重复使用已经预处理的语句， 并且批量执行所有更新语句，显然batch性能将更优； 但batch模式也有自己的问题，比如在Insert操作时，在事务没有提交之前，是没有办法获取到自增的id，这在某型情形下是不符合业务要求的； 在测试中使用simple模式提交10000条数据，时间为18248
mybatis批量插入优化（ExecutorType.BATCH/BatchInsert/executeBatch）
热门推荐
★【World Of Moshow 郑锴】★
12-29 2万+
Mybatis内置的有3种，默认的是simple单句模式，该模式下它为每个语句的执行创建一个新的预处理语句，单句提交sql；batch模式重复使用已经预处理的语句，并且批量执行所有语句，大批量模式下性能更优。请注意batch模式在Insert操作时事务没有提交之前，是没有办法获取到自增的id，所以请根据业务情况使用。使用simple模式提交10000条数据，时间为19s，batch模式为6s ，大致情况如此，优化的具体还要看提交的语句情况。如果需要使用foreach。
Mybatis 使用ExecutorType.BATCH批量插入数据
菜鸟记录
11-21 3666
⏹当插入大量数据时,推荐使用Mybatis的ExecutorType.BATCH
mybatis BATCH 批量插入
最新发布
05-10
MyBatis是一个优秀的持久层框架，BATCH批量插入是MyBatis提供的一种高效的数据批量插入方式。BATCH的实现原理是将多个insert语句合并成一个批量插入语句，通过一次数据库访问完成多条记录的插入操作，从而提高插入效率。BATCH插入的使用方式如下： 1. 定义一个Mapper接口方法，用于批量插入数据： ``` public interface UserMapper { void batchInsert(List<User> userList); } ``` 2. 在Mapper XML文件中，使用foreach标签进行批量插入操作： ``` <insert id="batchInsert" parameterType="java.util.List"> insert into user(id, name, age) values <foreach collection="list" item="user" separator=","> (#{user.id}, #{user.name}, #{user.age}) </foreach> </insert> ``` 3. 在Java代码中，调用Mapper接口方法进行批量插入： ``` SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH); try { UserMapper userMapper = sqlSession.getMapper(UserMapper.class); userMapper.batchInsert(userList); sqlSession.commit(); } finally { sqlSession.close(); } ``` 注意事项： 1. 批量操作需要关闭自动提交事务，否则每次插入一条记录就会自动提交一次事务，效率非常低。 2. 批量操作需要使用ExecutorType.BATCH类型的SqlSession，该类型SqlSession会缓存多个Statement对象，并在调用flushStatements()方法时一次性将多个Statement对象提交到数据库执行。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值