Spring框架下mybatis及mybatisPlus批量插入和批量更新方案整理和性能测试

最新推荐文章于 2024-04-23 08:17:33 发布
最新推荐文章于 2024-04-23 08:17:33 发布
阅读量1.8k 收藏 8
点赞数 1
文章标签： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42093668/article/details/130484625
版权

        在项目开发中，经常面临数据的批量导入以及接口数据的批量插入或更新操作的需求。利用项目间隙，整理了下找到的解决方案，并对每个方案的性能进行了简单测试。代码地址：github。

项目中使用了postgresql数据库。

目录

一、批量插入

       1. service层

2.Mapper层

3.实体类

4.测试类以及测试结果

二、批量更新

更新service层

mapper层

测试类以及测试结果

一、批量插入

        批量插入有四种方案。代码如下：

       1. service层

    /**
     * 使用mybatisplus 批量插入
     * @param list 用户集合
     * @return @link com.ufc.dream.web_start.entity.SysUser
     */
    int saveBatchMybatisPlus(List<SysUser> list);

    /**
     *  使用 循环插入
     * @param list
     * @return
     */
    int saveForeach(List<SysUser> list);

    /**
     * 使用sqlSession批量插入
     * @param list
     * @return
     */
    int saveSession(List<SysUser> list);

    /**
     *  拼装sql批量插入
     * @param list
     * @return
     */
    int saveSql(List<SysUser> list);

service实现

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int saveBatchMybatisPlus(List<SysUser> list) {
        saveBatch(list);
        return list.size();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int saveForeach(List<SysUser> list) {
        for (SysUser user : list) {
            getBaseMapper().insertEntity(user);
        }
        return list.size();
    }

    @Override
    public int saveSession(List<SysUser> list) {

        SqlSession batchSqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
        try {
            // 获取批量操作的新的map
            SysUserMapper mapper = batchSqlSession.getMapper(SysUserMapper.class);
            for (SysUser user : list) {
                mapper.insertEntity(user);
            }
            // session 提交
            batchSqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
            batchSqlSession.rollback();
        } finally {
            // session 关闭
            batchSqlSession.close();
        }
        return list.size();
    }
    

    // 超过数据库长度限制，分批插入
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int saveSql(List<SysUser> list) {
        int size = list.size();
        int num = size/1000;
        if (size%1000!=0){
            num += 1;
        }
        for (int i = 0; i < num; i++) {
            if (i == num - 1) {
                getBaseMapper().insertEntitySql(list.subList(i*1000, list.size()));
            }
            getBaseMapper().insertEntitySql(list.subList(i*1000, (i+1) * 1000));
        }

        return list.size();
    }

因为mybatisPlus自带的saveBatch方法上有@Transactional注解，影响事务管理器的选择，所以我重写了saveBatch方法。

public class BaseServiceImpl <M extends BaseMapper<T>, T > extends ServiceImpl<M, T> implements IBaseService<T> {


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

2.Mapper层

mapper接口：

    int insertEntity(SysUser user);

    int insertEntitySql(List<SysUser> list);

mapper.xml


    <insert id="insertEntity">
        insert into sys_user (user_no, weixin, phone, user_name, password)
        values (#{userNo}, #{weixin}, #{phone}, #{userName}, #{password})
    </insert>

    <insert id="insertEntitySql">
        insert into sys_user (user_no, weixin, phone, user_name, password)
        values
        <foreach collection="list" item="item" separator=",">
            (#{item.userNo}, #{item.weixin}, #{item.phone}, #{item.userName}, #{item.password})
        </foreach>
    </insert>

3.实体类

bean定义

@TableName(value ="sys_user")
@Data
public class SysUser implements Serializable {
    /**
     * 
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    /**
     * 
     */
    private String userNo;

    /**
     * 
     */
    private String weixin;

    /**
     * 
     */
    private String phone;

    /**
     * 
     */
    private String userName;

    /**
     * 
     */
    private String password;
}

4.测试类以及测试结果

测试类

    /**
     *  插入10000条耗时
     *  Foreach: 2452
     * Session: 277
     * Sql: 602
     * mybatisPlus: 436
     */
    @Test
    public void testSave(){
        List<SysUser> list = new ArrayList<SysUser>();
        SysUser user = null;
        for (int i = 0; i < 10000; i++) {
            user = new SysUser();
            user.setUserNo("1");
            user.setUserName("username");
            list.add(user);
        }
        long start = System.currentTimeMillis();
        sysUserServiceImpl.saveForeach(list);
        long foreachEnd = System.currentTimeMillis();
        sysUserServiceImpl.saveSession(list);
        long sessionEnd = System.currentTimeMillis();
        sysUserServiceImpl.saveSql(list);
        long sqlEnd = System.currentTimeMillis();
        sysUserServiceImpl.saveBatchMybatisPlus(list);
        long mybatisPlusEnd = System.currentTimeMillis();

        System.out.println("Foreach: " + (foreachEnd - start));
        System.out.println("Session: " + (sessionEnd - foreachEnd));
        System.out.println("Sql: " + (sqlEnd - sessionEnd));
        System.out.println("mybatisPlus: " + (mybatisPlusEnd - sqlEnd));
    }

测试结果：

插入1000条的耗时：

插入10000条耗时：

其中foreach循环是最慢的，使用SqlSession的批量操作是最快的。mybatisplus的saveBatch的实现也是使用了SqlSession但逻辑更复杂稍慢。

二、批量更新

测试使用的根据主键来更新数据。主要的方案有循环更新、mybatisPlus批量更新、sqlsession批量处理，使用case拼装sql、还有直接拼装sql。

更新service层


    /**
     *  根据 id 使用mybatisplus 批量插入
     * @param list
     * @return
     */
    int updateBatchWithId(List<SysUser> list);


    /**
     *  使用 case when 批量更新
     * @param list
     * @return
     */
    int updateCase(List<SysUser> list);


    /**
     *  使用 拼装sql批量更新
     * @param list
     * @return
     */
    int updateSql(List<SysUser> list);

    /**
     * 使用 sqlsession 批量更新
     * @param list
     * @return
     */
    int updateSession(List<SysUser> list);

    /**
     *  使用foreach 批量更新
     * @param list
     * @return
     */
    int updateForeach(List<SysUser> list);

service实现

 @Override
    @Transactional(rollbackFor = Exception.class)
    public int updateBatchWithId(List<SysUser> list) {
        updateBatchById(list);
        return list.size();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int updateCase(List<SysUser> list) {
        getBaseMapper().updateUserNameByIdSql(list);
        return list.size();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int updateSql(List<SysUser> list) {
        getBaseMapper().updateUserNameByIdSql(list);
        return list.size();
    }

    @Override
    public int updateSession(List<SysUser> list) {
        SqlSession batchSqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
        try {
            // 获取批量操作的新的map
            SysUserMapper mapper = batchSqlSession.getMapper(SysUserMapper.class);

            for (SysUser user : list) {
                mapper.updateUserNameById(user);
            }
            // session 提交
            batchSqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
            batchSqlSession.rollback();
        } finally {
            // session 关闭
            batchSqlSession.close();
        }
        return list.size();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int updateForeach(List<SysUser> list) {
        for (SysUser user : list) {
            getBaseMapper().updateUserNameById(user);
        }
        return list.size();
    }

mapper层

mapper接口

    int updateUserNameById(SysUser user);

    int updateUserNameByIdCase(List<SysUser> list);

    int updateUserNameByIdSql(List<SysUser> list);

mapper的xml文件

   <update id="updateUserNameById">
        update sys_user set user_name = #{userName}
        where id = #{id}
    </update>


    <update id="updateUserNameByIdCase" parameterType="list">
        update sys_user set user_name =
        <foreach collection="list" item="item" separator=" " open="case id" close="end">
            when #{item.id} then #{item.userName}
        </foreach>
        where id in
        <foreach collection="list" item="item" separator="," open="(" close=")">
            #{item}
        </foreach>
    </update>
    <update id="updateUserNameByIdSql">
        <foreach collection="list" item="item" separator=";">
            update sys_user set user_name = #{item.userName}
            where id = #{item.id}
        </foreach>
    </update>

测试类以及测试结果

 /**
     *  更新10000 条耗时
     *  Foreach: 1570
     * Session: 344
     * Sql: 1283
     * Case: 1076
     * mybatisPlus: 510
     */
    @Test
    public void testUpdate(){
        List<SysUser> listFor = sysUserServiceImpl.queryTestList(1,10000);
        List<SysUser> listSes = sysUserServiceImpl.queryTestList(10000,10000);
        List<SysUser> listSql = sysUserServiceImpl.queryTestList(20000,10000);
        List<SysUser> listCase= sysUserServiceImpl.queryTestList(30000,10000);
        List<SysUser> listPlus = sysUserServiceImpl.queryTestList(40000,10000);

        long start = System.currentTimeMillis();
        sysUserServiceImpl.updateForeach(listFor);
        long foreachEnd = System.currentTimeMillis();
        sysUserServiceImpl.updateSession(listSes);
        long sessionEnd = System.currentTimeMillis();
        sysUserServiceImpl.updateSql(listSql);
        long sqlEnd = System.currentTimeMillis();
        sysUserServiceImpl.updateCase(listCase);
        long caseEnd = System.currentTimeMillis();
        sysUserServiceImpl.updateBatchWithId(listPlus);
        long plusEnd = System.currentTimeMillis();

        System.out.println("Foreach: " + (foreachEnd - start));
        System.out.println("Session: " + (sessionEnd - foreachEnd));
        System.out.println("Sql: " + (sqlEnd - sessionEnd));
        System.out.println("Case: " + (caseEnd - sqlEnd));
        System.out.println("mybatisPlus: " + (plusEnd - caseEnd));
    }

测试更新1000条耗时：

测试更新10000条耗时：

更新的耗时结果和插入的耗时结果相一致。都是使用sqlsession的耗时是最短的,mybatisplus的批量操作耗时和它最接近。foreach插入效率是最低的。

思维穿梭
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Mybatis批量更新三种方式的实现
08-26
主要介绍了Mybatis批量更新三种方式的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
【mybatis-plus 根据指定字段批量更新数据库记录】
huang_hai_an的博客
07-27 1367
【代码】【mybatis-plus 根据指定字段批量更新数据库记录】
mybatis数据批量更新
xieqj_0511的博客
07-23 1万+
数据批量更新
MybatisPlus——批量新增
最新发布
LIUCHANGSHUO的博客
04-23 2000
在yml的jdbc的配置上加入一个rewriteBatchedStatements=true。缺点：因为每次的插入数量的限制，这就会在预编译的批处理产生一百条插入语句，也很耗时。要想只编译为一条sql语句，就要和这样插入语句一样。缺点：每插入一次，就会生成一条插入语句，极其耗时。再次执行这段代码，运行时间缩短很多。
批量插入或更新数据(MyBatis-plus框架)
热门推荐
hauchun的博客
08-23 5万+
插入数据时，我们经常会遇到这样的情况：1、首先判断数据是否存在；2、如果不存在，则插入；3、如果存在，则更新需求：根据表中的部分字段去判断插入或者更新有一张表 hh_adx_monitor_summary需要通过code,plan_id,dimension_time判断插入或者更新此时会发现依然会重复插入数据，需要创建一个组合索引添加完索引再次尝试，code,plan_id,dimension_time相同的情况下只会更新不会新增。
mybatis-plus的批量新增/批量更新以及问题
Filwaod
11-23 4万+
批量新增/修改的几种常用方法实现
MyBatis-Plus批量更新
m0_67390379的博客
08-22 9641
调用时直接 empService.updateBatchById 即可。ServiceImpl 是MyBatis-Plus 提供的,
mybatis-plus批量更新updateBatchById
qq_23851649的博客
04-27 3万+
mybatis-plus真正的批量更新updateBatchById
mybatis中批量插入的两种方式(高效插入)
09-01
MyBatis是一个强大的持久层框架，它允许开发者编写SQL查询，使用存储过程，并进行高级映射，无需手动处理JDBC代码和结果集的封装。在处理大量数据时，批量插入是一种提高性能的有效策略。本文将深入探讨MyBatis中...
springmvc4+mybatis+mybatisplus整合
03-18
此外，MyBatisPlus还支持条件查询、分页查询、填充实体类的父类属性、批量插入、批量更新等高级特性。其强大的自动化代码生成工具，可以自动生成Mapper、Mapper XML、Service、Controller等代码，大大减少了开发工作...
Spring及Mybatis整合占位符解析失败问题解决
08-18
在Spring框架中，@PropertySource注解可以用来加载配置文件，而在Mybatis中，MapperScannerConfigurer可以用来配置Mapper的扫描路径。然而，在使用@PropertySource注解加载配置文件时，可能会出现占位符未被正确解析...
springboot+mybatis配置clickhouse实现插入查询功能
08-18
这些依赖包括 Spring Boot 的 Web、AOP 和测试模块，MyBatis 的 Spring Boot starter，Druid 的 Spring Boot starter，ClickHouse 的 JDBC 驱动程序等。 二、配置数据源 在配置数据源时，需要在 application....
mybatispuls3.5使用批量插入
07-21
在Spring框架中，可以通过在批量插入方法上添加`@Transactional`注解来开启事务： ```java @Transactional public void batchInsert() { // ... } ``` 7. 考虑性能优化： 批量插入的大小也需要根据实际业务和数据库...
[ Mybatis-Puls ] 批量更新（UpdateWrapper）分组查询 （groupBy(“type“)）
weixin_70506521的博客
06-01 5120
[ Mybatis-Puls ] 批量更新（UpdateWrapper）分组查询
Mybatis-Plus批量更新原理
qq_37436172的博客
03-14 6024
默认batchSize = 1000 进入executeBatch方法在这个方法基本就能看出来了,执行1000次方法后执行一次flushStatements，也就是说理论上是积累了1000个更新sql，才进行一次数据库更新使用的是BatchExcutor进行批量执行的。
MyBatis-Plus 3 实现批量新增和批量修改
zhouzhiwengang的专栏
06-21 5237
是因为spring boot配置文件中，关于数据库的连接配置，并没有允许进行批量更新的操作。这种方式就是通过SQL拼接，单条单条的进行更新，如果行数多的情况下给不建议使用。在数据库连接配置中必须添加 &allowMultiQueries=true，通过case when语句进行批量更新，只要一条SQL语句.mapper xml: 批量插入xml。mapper 接口:批量方法插入。mapper 接口:批量方法插入。mapper xml: 分页查询。mapper 接口:分页查询。- 页面显示条数 size。
Mybatis Plus用自定义新增，来实现真正的批量新增方式！
TaylorSwiftRed的博客
10-23 4205
Mybatis plus 的批量插入方法saveBatch或者批量更新方法updateBatch，批量新增其实它是一个伪批量新增方法和更新方法，打印SQL日志的时候，我们可以发现它还是一条条执行insert语句的。今天带大家在 Mybatis Plus 中，实现 MySQL 真实的批量新增，即insert(…) values(xx,x),(xx,x);而不是伪批量新增insert
mybatisplus高效批量更新_Mybatis中实现批量更新的几种姿势，总有一款适合你
weixin_39913141的博客
12-20 2万+
Mybatis中实现批量更新的几种姿势，总有一款适合你一、概述mybatis中实现批量插入是很简单的，相比大家都知道，这里就不赘述，本文主要讲述如何实现批量更新。下面介绍本文要讲的几种方式主要是在xml中实现，不包含需要改动代码逻辑的方法，这里，除了网上说的普通情况，还有适合mysql和oracle的批量更新方式： 1. case when 2. foreach成多条sql 3. ON DUPLI...
Mybatis-plus批量插入更新
xugehahaha的博客
04-17 2240
个人比较推荐方案三，感觉代码更优雅一点（手动狗头），这里也只实现方案三的代码，重写saveOrUpdateBatch()方法，通过构建updateWrapper来自定义更新数据的相关字段和更新条件，同时通过@Transactional管理事务，保证操作前后的数据一致性。由于是批量推送数据，如果使用遍历更新的方式会因为重复与数据库进行连接、断开，导致性能较差，因此考虑采用批量插入、更新的方式。例如：我们需要批量插入或更新员工信息，员工编号code是唯一键，通过code实现员工数据的新增和更新。
mysqlplus 批量插入_mybatis+mysql批量插入和批量更新、存在及更新
05-29
对于Mybatis和MySQL的批量插入和批量更新，可以使用以下方法： 1. 批量插入 使用MyBatis的foreach标签，可以很方便地实现批量插入操作。示例如下： ```xml <insert id="batchInsert" parameterType="java.util.List"> insert into my_table (col1, col2, col3) values <foreach collection="list" item="item" separator=","> (#{item.col1}, #{item.col2}, #{item.col3}) </foreach> </insert> ``` 其中，parameterType指定参数类型为List，collection属性指定要插入的List对象，item指定List中的元素，separator指定分隔符。 在Java代码中，调用该方法时，将List对象作为参数传入即可。 2. 批量更新 对于批量更新，可以使用MySQL的replace into语句来实现。示例如下： ```xml <update id="batchUpdate" parameterType="java.util.List"> <foreach collection="list" item="item" separator=";"> replace into my_table (id, col1, col2, col3) values (#{item.id}, #{item.col1}, #{item.col2}, #{item.col3}) </foreach> </update> ``` 其中，replace into语句会先尝试插入记录，如果记录已存在，则更新记录。参数类型和调用方式与批量插入相同。 3. 存在即更新 如果只想更新已存在的记录，可以使用MySQL的on duplicate key update语句。示例如下： ```xml <update id="updateIfExists" parameterType="com.example.MyEntity"> insert into my_table (id, col1, col2, col3) values (#{id}, #{col1}, #{col2}, #{col3}) on duplicate key update col1 = values(col1), col2 = values(col2), col3 = values(col3) </update> ``` 其中，id字段为主键。如果该记录已存在，则更新col1、col2、col3字段；否则插入新记录。参数类型为MyEntity，调用方式为传入一个MyEntity对象。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值