Mybatis-Plus saveBatch() 批量保存失效

问题

在使用IService.savebatch方法批量插入数据时,观察控制台打印的Sql发现并没有像预想的一样,而是以逐条方式进行插入,插1000条数据就得10s多,正常假如批量插入应该是一条语句:

insert table (field1, field2) values (val1, val2), (val3, val4), (val5, val6), ... ;

而我的是这样:

insert table (field1, field2) values (val1, val2);
insert table (field1, field2) values (val3, val4);
...

问题环境

jdk 1.8
spring-boot-starter 2.1.1.RELEASE
mybatis-plus 3.4.1
mysql-connector-java 8.0.13

排查过程

先是网上搜索有没有类似的经验,看到最多的是:在JDBC连接串最后添加参数rewriteBatchedStatements=true,可以大大增加批量插入的效率,加上了发现还是一条一条插,然后又搜索为什么这个参数没用,有说数据条数要>3,这个我肯定满足,有说JDBC驱动版本问题的,都试了没用。
多方查询无果,决定从源码入手,一步一步跟进看这个saveBatch到底怎么实现的,在哪一步出了问题。

  1. ServiceImpl.java
    /**
     * 批量插入
     *
     * @param entityList ignore
     * @param batchSize  ignore
     * @return ignore
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean saveBatch(Collection<T> entityList, int batchSize) {
        String sqlStatement = getSqlStatement(SqlMethod.INSERT_ONE);
        return executeBatch(entityList, batchSize, (sqlSession, entity) -> sqlSession.insert(sqlStatement, entity));
    }

入口函数,没什么好说的,重点看这个executeBatch
2. SqlHelper.java

    /**
     * 执行批量操作
     *
     * @param entityClass 实体类
     * @param log         日志对象
     * @param list        数据集合
     * @param batchSize   批次大小
     * @param consumer    consumer
     * @param <E>         T
     * @return 操作结果
     * @since 3.4.0
     */
    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");
        return !CollectionUtils.isEmpty(list) && executeBatch(entityClass, log, sqlSession -> {
            int size = list.size();
            int i = 1;
            for (E element : list) {
                consumer.accept(sqlSession, element);
                if ((i % batchSize == 0) || i == size) {
                    sqlSession.flushStatements();
                }
                i++;
            }
        });
    }

 /**
     * 执行批量操作
     *
     * @param entityClass 实体
     * @param log         日志对象
     * @param consumer    consumer
     * @return 操作结果
     * @since 3.4.0
     */
    public static boolean executeBatch(Class<?> entityClass, Log log, Consumer<SqlSession> consumer) {
        SqlSessionFactory sqlSessionFactory = sqlSessionFactory(entityClass);
        SqlSessionHolder sqlSessionHolder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sqlSessionFactory);
        boolean transaction = TransactionSynchronizationManager.isSynchronizationActive();
        if (sqlSessionHolder != null) {
            SqlSession sqlSession = sqlSessionHolder.getSqlSession();
            //原生无法支持执行器切换,当存在批量操作时,会嵌套两个session的,优先commit上一个session
            //按道理来说,这里的值应该一直为false。
            sqlSession.commit(!transaction);
        }
        SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
        if (!transaction) {
            log.warn("SqlSession [" + sqlSession + "] was not registered for synchronization because DataSource is not transactional");
        }
        try {
            consumer.accept(sqlSession);
            //非事物情况下,强制commit。
            sqlSession.commit(!transaction);
            return true;
        } catch (Throwable t) {
            sqlSession.rollback();
            Throwable unwrapped = ExceptionUtil.unwrapThrowable(t);
            if (unwrapped instanceof RuntimeException) {
                MyBatisExceptionTranslator myBatisExceptionTranslator
                    = new MyBatisExceptionTranslator(sqlSessionFactory.getConfiguration().getEnvironment().getDataSource(), true);
                throw Objects.requireNonNull(myBatisExceptionTranslator.translateExceptionIfPossible((RuntimeException) unwrapped));
            }
            throw ExceptionUtils.mpe(unwrapped);
        } finally {
            sqlSession.close();
        }
    }

打断点发现,每经过一次consumer.accept(sqlSession),就打印一行insert语句出来,看看里面搞了什么鬼
3. MybatisBatchExecutor.java

@Override
    public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException {
        final Configuration configuration = ms.getConfiguration();
        final StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, RowBounds.DEFAULT, null, null);
        final BoundSql boundSql = handler.getBoundSql();
        final String sql = boundSql.getSql();
        final Statement stmt;
        if (sql.equals(currentSql) && ms.equals(currentStatement)) {
            int last = statementList.size() - 1;
            stmt = statementList.get(last);
            applyTransactionTimeout(stmt);
            handler.parameterize(stmt);//fix Issues 322
            BatchResult batchResult = batchResultList.get(last);
            batchResult.addParameterObject(parameterObject);
        } else {
            Connection connection = getConnection(ms.getStatementLog());
            stmt = handler.prepare(connection, transaction.getTimeout());
            if (stmt == null) {
                return 0;
            }
            handler.parameterize(stmt);    //fix Issues 322
            currentSql = sql;
            currentStatement = ms;
            statementList.add(stmt);
            batchResultList.add(new BatchResult(ms, sql, parameterObject));
        }
        handler.batch(stmt);
        return BATCH_UPDATE_RETURN_VALUE;
    }

一顿Step Into后进入了这个doUpdate方法,看了一下,if体内的应该就是批量拼接sql的关键,走了几个循环发现我的代码都是从else体里走了,也就拆成了一条一条的插入语句,那他为什么不进if呢,看了下判断条件,每次进来。statement都是一个,那问题就出在sql.equals(currentSql) 上面,我比对了下第二个实体的sql和第一个实体的sql,很快就发现了问题,他们竟然不!一!样!。
原因是在拼接insert语句时,如果实体的某个属性值为空,那他将不参与拼接,所以如果你的数据null值比较多且比较随机的分布在各个属性上,那生成出来的sql就会不一样,也就没法走批处理逻辑了。
为了验证这个发现,我写了两段测试代码比对:
a. list新增三个实体,每个实体在不同的属性上设置空值

	@Autowired
    private IBPModelService modelService;

	@PostMapping("/save")
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public R testSaveBatch() {
        BPModel model_1 = new BPModel();
        model_1.setModelName("模型1");
        BPModel model_2 = new BPModel();
        model_2.setContent("模型2 content");
        BPModel model_3 = new BPModel();
        model_3.setModelDesc("模型3 desc");
        List<BPModel> list = new ArrayList<>();
        list.add(model_1);
        list.add(model_2);
        list.add(model_3);
        modelService.saveBatch(list);
        return R.ok();
    }

打印结果(三个语句):

JDBC Connection [com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl@75dbdb41] will be managed by Spring
==>  Preparing: INSERT INTO BP_MODEL ( model_name ) VALUES ( ? )
==> Parameters: 模型1(String)
==>  Preparing: INSERT INTO BP_MODEL ( content ) VALUES ( ? )
==> Parameters: 模型2 content(String)
==>  Preparing: INSERT INTO BP_MODEL ( model_desc ) VALUES ( ? )
==> Parameters: 模型3 desc(String)

b. 还是生成三个实体,但是在相同属性上设置空值,保证数据格式一致性

 @PostMapping("/save")
 @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
 public R testSaveBatch() {
        BPModel model_1 = new BPModel();
        model_1.setModelName("模型1");
        BPModel model_2 = new BPModel();
        model_2.setModelName("模型2");
        BPModel model_3 = new BPModel();
        model_3.setModelName("模型3");
        List<BPModel> list = new ArrayList<>();
        list.add(model_1);
        list.add(model_2);
        list.add(model_3);
        modelService.saveBatch(list);
        return R.ok();
 }

打印结果(一个语句):

JDBC Connection [com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl@6e4b5fc7] will be managed by Spring
==>  Preparing: INSERT INTO BP_MODEL ( model_name ) VALUES ( ? )
==> Parameters: 模型1(String)
==> Parameters: 模型2(String)
==> Parameters: 模型3(String)

果然,验证结论正确,实体属性为null时,会影响生成的插入sql,进而影响批量保存逻辑。

解决方案

定位到了问题,那就也便于解决了,问题原因是生成插入sql时,对null值的处理策略造成的,查阅mybatis-plus官方文档发现,有一个配置项可以解决这个问题:

insertStrategy
类型:com.baomidou.mybatisplus.annotation.FieldStrategy
默认值:NOT_NULL
字段验证策略之 insert,在 insert 的时候的字段验证策略

默认为NOT_NULL就是导致问题的关键,改成IGNORED就好了

再查资料发现,在@TableField注解内也可局部制定insertStrategy属性, 那解决方案就比较多样化了:

  • 全局配置insertStrategy为IGNORED
# mybatis 全局配置
mybatis-plus:
  mapper-locations: classpath:mapper/*.xml
  global-config:
    db-config:
      id-type: auto
      insert-strategy: ignored
  configuration:
    map-underscore-to-camel-case: true
    call-setters-on-nulls: true

  • 为可能受影响的属性添加注解
 @TableField(insertStrategy = FieldStrategy.IGNORED)
 private String content;

  • 不管他那套,自己重写个批量保存方法,自己写xml拼接sql,简单粗暴(小心sql超出最大长度)
  <insert id="insertBatch" parameterType="java.util.List">
        insert into table_name (id,code,name,content) VALUES
        <foreach collection ="list" item="entity" index= "index" separator =",">
            (
            #{entity.id}, #{entity.code}, #{entity.name}, #{entity.content}
            )
        </foreach>
</insert>

  • 19
    点赞
  • 47
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
### 回答1: mybatis-plus的savebatch用法是批量插入数据的方法,可以将多条数据一次性插入到数据库中。使用该方法需要先创建一个实体类,然后通过该实体类的List集合来传递多条数据,最后调用savebatch方法即可完成批量插入操作。在使用该方法时需要注意,插入的数据必须符合数据库表的字段类型和约束条件,否则会插入失败。同时,该方法也支持自动生成主键的功能,可以通过在实体类的主键字段上添加注解来实现。 ### 回答2: Mybatis-plus是一个基于Mybatis的增强工具库,能够简化开发中的Mybatis操作。其中有一个saveBatch方法就是用来批量添加数据的,本文将详细介绍saveBatch的用法。 saveBatch方法的定义如下: ```java boolean saveBatch(Collection<T> entityList, int batchSize) ``` 其中,entityList表示待添加的数据列表,batchSize表示每批次添加的数量。 使用saveBatch方法的步骤如下: 1.在mapper接口中定义相应的方法。mapper接口需要继承BaseMapper接口,并指定类型参数,如下: ```java public interface UserMapper extends BaseMapper<User> { } ``` 2.实现mapper接口中的定义方法。如下: ```java public class UserMapperImpl extends ServiceImpl<UserMapper, User> implements UserMapper { } ``` 3.使用saveBatch方法添加数据。如下: ```java List<User> userList = new ArrayList<>(); for (int i = 0; i < 10000; i++) { User user = new User(); user.setName("Tom" + i); user.setAge(i); userList.add(user); } userMapper.saveBatch(userList, 1000); ``` 注:上述代码中的userMapper为UserMapper类型的对象。 以上是saveBatch方法的基本使用方法。需要注意的是,当批次量较大时,可以适当调大batchSize的值。同时,还需注意存在主键冲突的情况,需要在代码中进行处理。如果需要批量添加不同类型的数据,则需要在mapper接口中定义多个方法,并实现相应的实现类。 总之,Mybatis-plus的saveBatch方法可以极大地简化添加数据的操作,提高代码效率,也是业务开发中经常使用的一个方法。 ### 回答3: Mybatis-Plus是一个基于Mybatis的增强工具,可以轻松地操作数据库。其中,SaveBatchMybatis-Plus针对批量插入数据提供的一种方法。SaveBatch的使用方法如下: 1.定义实体类 首先,我们需要定义一个实体类,该实体类的属性与数据库表字段相对应。 例如,定义一个User实体类,在User实体类中定义需要保存的字段属性: ```java @Data public class User { private Long id; private String name; private Integer age; } ``` 2.定义Mapper接口 接着,我们需要定义一个Mapper接口,用于定义需要对数据库进行的操作,包括插入、查询、删除等操作。在Mapper接口中定义SaveBatch方法,用于批量插入数据。 例如,定义一个UserMapper接口,在UserMapper接口中定义SaveBatch方法: ```java public interface UserMapper extends BaseMapper<User> { void saveBatch(List<User> userList); } ``` 3.调用SaveBatch方法 最后,我们可以通过Mybatis-Plus提供的BaseMapper接口,调用SaveBatch方法,将需要插入的数据集合传递给SaveBatch方法即可。 例如,在业务代码中,需要批量插入userList数据集合,可以调用UserMapper接口的SaveBatch方法: ```java @Service public class UserServiceImpl implements UserService { @Autowired private UserMapper userMapper; @Override public void insertBatch(List<User> userList) { userMapper.saveBatch(userList); } } ``` 需要注意的是,在批量插入数据时,数据库表中的字段需要与实体类中的属性名称一一对应,否则会报错。另外,SaveBatch方法执行效率较高,相较于逐条插入数据,可大大提高数据插入的效率。 以上就是Mybatis-Plus SaveBatch的用法,希望对大家有所帮助。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

凌兮~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值