JPA SaveAll的分析

使用 Springboot JPA 插入单条数据使用 save 方法，插入多条使用 saveAll，但是仔细看相应的源码，发现 saveAll 就是循环调用 save ，效率能高吗？看下面的代码

    @Transactional
    @Override
    public <S extends T> List<S> saveAll(Iterable<S> entities) {
        Assert.notNull(entities, "Entities must not be null!");
        List<S> result = new ArrayList<S>();
        for (S entity : entities) {
            result.add(save(entity));
        }
        return result;
    }

尝试自己写一个循环去 save ，发现执行时长比 saveAll 长很多，仔细观察才发现是注解 @Transactional 的原因。

1. 准备测试代码

准备了4个函数，分别是带事务的循环调用 save，不带事务的循环调用 save ，带事务的调用 saveAll 和 不带事务的调用 saveAll，代码如下：

   @Transactional(rollbackFor = Exception.class)
    public void insert1() throws Exception {
        insert2();
    }

    public void insert2() throws Exception {
        for (int i = 0; i < length; i++) {
            SampleEntity entity = new SampleEntity();
            entity.setId(MyUtils.generate32Id());
            entity.setIntField(i);
            entity.setStringField(i + "");
            entity.setDateTimeField(LocalDateTime.now());
            sampleDao.save(entity);
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void insert3() throws Exception {
        insert4();
    }

    public void insert4() throws Exception {
        List<SampleEntity> list = new ArrayList<>(length);
        for (int i = 0; i < length; i++) {
            SampleEntity entity = new SampleEntity();
            entity.setId(MyUtils.generate32Id());
            entity.setIntField(i);
            entity.setStringField(i + "");
            entity.setDateTimeField(LocalDateTime.now());
            list.add(entity);
        }
        sampleDao.saveAll(list);
    }

分别执行这4个 insert 方法，100000条记录，数据库是mysql8. 打印他们的执行时间，结果如下：

image.png

可以看到只有不带事务注解的循环执行 save 耗时很长，其它都差不多。

2. 分析原因

从二个方面来分析：

2.1 首先

是看看这4个函数分别对应了什么 sql 语句，通过在 application.properties 里加上 spring.jpa.show-sql=true, 可以看到基本的 sql ，但是觉得还是不够完整。尝试直接在 mysql 里查看详细的 sql 日志，缺省 sql 日志是不记录的，需要执行语句打开，但是处理完后记得关闭，否则日志会很多很大的。

SET GLOBAL log_output = 'TABLE';SET GLOBAL general_log = 'ON';//打开sql日志记录
SELECT * from mysql.general_log ORDER BY event_time ASC; //查询sql日志记录
truncate table mysql.general_log;// 清空sql日志表
SET GLOBAL log_output = 'TABLE'; SET GLOBAL general_log = 'OFF';//关闭sql日志记录

1644401704(1).png

然后把代码里10w条记录改成2条，执行后再去查询 sql 日志表，可以看到对应的完整 sql 。

insert1函数 insert2函数 insert3函数 insert4函数

通过查看日志，可以得到以下结论：

1. 每次执行都会先关闭自动提交，最后 commit 之后再打开自动提交
2. insert 前会先执行 select
3. insert2 函数比其它函数耗时的原因是因为每组 sql（1个select，1个insert）都会做一次 commit ，10w条数据得执行10w次commit。而其它函数速度快是因为只有最后才 commit 一次

2.2 我们再通过查看源码的角度来分析：

1. 为什么每次 save 都要先 select 再 insert，原因就是 save 的时候需要下判断一下 entity 是否是全新的记录，如果不是的话，会执行 merge（也就是 update ），否则才执行 persist （insert）

    @Transactional
    @Override
    public <S extends T> S save(S entity) {
        Assert.notNull(entity, "Entity must not be null.");
        if (entityInformation.isNew(entity)) {
            em.persist(entity);
            return entity;
        } else {
            return em.merge(entity);
        }
    }

2. commit 从哪里来的，答案就是注解 @Transactional ，标记了这个注解的函数内部的 sql 语句执行之前会自动加上 set autocommit=0,然后在函数结束后自动加上 commit和set autcommit=1。而且如果发生嵌套，也就是函数内调用的函数又包含了注解 @Transactional，那内部的注解就会失效，以最上层的注解为准。
   insert2 函数之所以慢，之所以有这么多次 commit，就是因为 save 函数是带注解 @Transactional 的，每调用一次 save 就执行一次 commit 。insert1 带了注解 @Transactional ，就会忽略 save 的注解，最终只会执行一次 commit。

3. saveall 函数相当于执行了10w 次 isNew(select) 函数和 persist(insert)函数，但是并不是很耗时，因为这里还没有涉及到真正序列化到数据库，只是10w次的内存操作，而调用 flush 函数才会真正存到数据库，是最耗时，也就是 commit 的时候才会调用 flush 函数，当然你也可通过调用 saveandflush 强行提交，参考源码

    @Transactional
    @Override
    public <S extends T> S saveAndFlush(S entity) {
        S result = save(entity);
        flush();
        return result;
    }

3. 进一步优化 saveAll

最佳的优化批量的插入是把多个 insert 语句转成1个 insert 语句，insert 本来就支持同时插入多数据。简单查了一下，通过设置 jdbc url 添加&rewriteBatchedStatements=true 可以实现，但是不支持 JPA。
JPA想要优化还有一个办法就是，每次 save 都要执行2个 sql，一个 select，一个insert，如果能去掉对应的 select，只保留 insert ，这样效率就能提高一倍，实际执行的效果也确实是，执行10w条时间差不多缩短了一半。
实现的基本方式就是重写 saveAll 方法（不是我写的，但是找不到出处了，对作者抱歉一下）

    @Transactional(rollbackFor = Exception.class)
    @Override
    public <S extends T> List<S> saveAll(Iterable<S> entities) {
        Iterator<S> iterator = entities.iterator();
        List<S> list = new ArrayList<>();
        int index = 0;
        while (iterator.hasNext()) {
            S next = iterator.next();
            entityManager.persist(next);
            index++;
            if (index % batchSize == 0) {
                entityManager.flush();
                entityManager.clear();
            }
            list.add(next);
        }
        if (index % batchSize != 0) {
            entityManager.flush();
            entityManager.clear();
        }
        return list;
    }

可以看到基本原理就是不判断 entity 是否是新的，直接 persist，然后分组 commit，每组的大小通过 spring.jpa.properties.hibernate.jdbc.batch_size来设置。
执行的 sql 参考下图，只有 insert 没有 select。

image.png
使用的时候只需要新建一个实现类实现对应的 dao 接口。注意实现类的文件名称必须是 dao 类后面加 Impl，一点都不能错。这样调用 saveall 的时候会自动调用重写的 saveall 函数。
image.png

源码参考地址