位置：首页-资讯-后端开发

mybatis和mybatisplus批量插入问题示例详解

2023-05-15 11:34

短信预约 -IT技能 免费直播动态提醒

1. 思路分析：

批量插入是我们日常开放经常会使用到的场景，一般情况下我们也会有两种方案进行实施，如下所示。

方案一就是用 for 循环循环插入：

优点：JDBC 中的 PreparedStatement 有预编译功能，预编译之后会缓存起来，后面的 SQL 执行会比较快并且JDBC 可以开启批处理，这个批处理执行非常给力。

缺点：很多时候我们的 SQL 服务器和应用服务器可能并不是同一台，所以必须要考虑网络 IO，如果网络 IO 比较费时间的话，那么可能会拖慢
SQL 执行的速度。

再来说第二种方案，就是生成一条 SQL 插入：

优势：这种方案的优势在于只有一次网络 IO，即使分片处理也只是数次网络 IO，所以这种方案不会在网络 IO 上花费太多时间。

缺点一是 SQL 太长了，甚至可能需要分片后批量处理；

缺点二是无法充分发挥 PreparedStatement 预编译的优势，SQL 要重新解析且无法复用；三是最终生成的 SQL
太长了，数据库管理器解析这么长的 SQL 也需要时间。

2. rewriteBatchedStatements=true

在jdbc连接后面加上 rewriteBatchedStatements=true ，加上后才是真正的批量插入。

jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&rewriteBatchedStatements=true

3.使用mybatis批量插入：

方案一：使用foreach进行插入（生成一条 SQL 插入）

mapper文件

   <insert id="save" parameterType="java.util.List">
        INSERT INTO test
        (
        id,
        a,
        b,
        c
        )
        VALUES
        <foreach collection="list" item="item" index="index" separator=",">
            (
            #{item.id},
            #{item.a},
            #{item.b},
            #{item.c}
            )
        </foreach>
    </insert>

调用方法

 @Override
    public void add() {
        //时间 一
        long l = System.currentTimeMillis();
        List<TestEntity> list=new ArrayList<>();
        for (int i=0;i<1000;i++){
            TestEntity testEntity=new TestEntity();
            testEntity.setC(i);
            list.add(testEntity);
        }
       testMapper.save(list);
        //时间 二
        long l1 = System.currentTimeMillis();
        System.out.println("耗时"+(l1-l));
    }

插入了1000条数据，耗时535毫秒。

插入了50000条数据，直接报错。

报错原因是因为我们一条SQL进行插入导致SQL太长

解决办法：

1.修改MySQL配置

2.对新增数据进行分片

方案二：一条条插入

mapper

   <insert id="addUserOneByOne" parameterType="com.ruoyi.system.domain.TestEntity">
    insert into test (id,a,b,c) values (#{id},#{a},#{b},#{c})
    </insert>

测试代码

@Service
public class TestServiceimpl extends ServiceImpl<TestMapper, TestEntity> implements TestService {

    @Autowired
  private   TestMapper testMapper;

    @Autowired
  private SqlSessionFactory sqlSessionFactory;
    
    public void addUserOneByOne(List<TestEntity> users) {
        SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH);
        TestMapper um = session.getMapper(TestMapper.class);
        long startTime = System.currentTimeMillis();
        for (TestEntity user : users) {
            um.addUserOneByOne(user);
        }
        session.commit();
        long endTime = System.currentTimeMillis();
        System.out.println("耗时"+(endTime - startTime));
    }
}

插入了1000条数据，耗时959毫秒。

插入50000条数据，耗时11214毫秒。

对比分析：

如果我们批量插入少部分数据，可以使用方式一，一条SQL进行插入。这样是比较快的。

如果我们插入数据达到，1w条，10来万条，这时建议用方式二进行插入是比较快的。

4. 使用mybatisplus批量插入

使用saveBatch（）方法进行批量插入

@Service
public class TestServiceimpl extends ServiceImpl<TestMapper, TestEntity> implements TestService {
    
    @Autowired
  private   TestMapper testMapper;

    @Autowired
  private SqlSessionFactory sqlSessionFactory;

    @Override
    public void add() {
        //时间 一
        long l = System.currentTimeMillis();
        List<TestEntity> list=new ArrayList<>();
        for (int i=0;i<50000;i++){
            TestEntity testEntity=new TestEntity();
            testEntity.setC(i);
            list.add(testEntity);
        }
        saveBatch(list);
        //时间 二
        long l1 = System.currentTimeMillis();
        System.out.println("耗时"+(l1-l));
    }

插入50000条数据，耗时19516毫秒

源码分析

   public boolean saveBatch(Collection<T> entityList, int batchSize) {
        String sqlStatement = this.getSqlStatement(SqlMethod.INSERT_ONE);
        return this.executeBatch(entityList, batchSize, (sqlSession, entity) -> {
            sqlSession.insert(sqlStatement, entity);
        });
    }

这里注意 return 中的第三个参数，是一个 lambda 表达式，这也是 MP 中批量插入的核心逻辑，可以看到，MP 先对数据进行分片（默认分片大小是 1000），分片完成之后，也是一条一条的插入。

 public static <E> boolean executeBatch(Class<?> entityClass, Log log, Collection<E> list, int batchSize, BiConsumer<SqlSession, E> consumer) {
        Assert.isFalse(batchSize < 1, "batchSize must not be less than one", new Object[0]);
        return !CollectionUtils.isEmpty(list) && executeBatch(entityClass, log, (sqlSession) -> {
            int size = list.size();
            int i = 1;

            for(Iterator var6 = list.iterator(); var6.hasNext(); ++i) {
                E element = var6.next();
                consumer.accept(sqlSession, element);
                if (i % batchSize == 0 || i == size) {
                    sqlSession.flushStatements();
                }
            }

        });
    }

继续查看 executeBatch 方法，就会发现这里的 sqlSession 其实也是一个批处理的 sqlSession，并非普通的 sqlSession。和我们mybatis使用的方法二一致。

5业务场景一对多怎么处理：

比如，如下这种一对多场景。

新增的时候保存都好理解，形成一个数组一起保存。

而修改的时候就有点难处理了，比如我修改了第二条，删除了第三条，这时统一保存应该怎么处理？

使用 ON DUPLICATE KEY UPDATE （发生主键冲突就更新，没有发生主键冲突就新增）

有时候由于业务需求，可能需要先去根据某一字段值查询数据库中是否有记录，有则更新，没有则插入。这个时候就可以用到ON DUPLICATE key update这个sql语句了

mapper如下所示

   <insert id="save" parameterType="java.util.List">
        INSERT INTO test
        (
        id,
        a,
        b,
        c
        )
        VALUES
        <foreach collection="list" item="item" index="index" separator=",">
            (
            #{item.id},
            #{item.a},
            #{item.b},
            #{item.c}
            )
        </foreach>
        ON DUPLICATE KEY UPDATE
        id=id,
        a = VALUES(a) ,
        b = VALUES(b),
        c = VALUES(c)
    </insert>

或者在使用mybatisplus时，使用saveOrUpdate（）方法进行一条数据的新增或更新。 saveOrUpdateBatch()方法进行批量数据的新增或更新。