mybatis的批量操作的几种方式

最新推荐文章于 2024-08-23 17:37:30 发布
最新推荐文章于 2024-08-23 17:37:30 发布
阅读量8.9k 收藏 16
点赞数 2
分类专栏： mybatis

MyBatis简介

MyBatis是一个支持普通SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索封装。MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。

一、mybiats foreach标签

foreach的主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合。foreach元素的属性主要有 item，index，collection，open，separator，close。item表示集合中每一个元素进行迭代时的别名，index指 定一个名字，用于表示在迭代过程中，每次迭代到的位置，open表示该语句以什么开始，separator表示在每次进行迭代之间以什么符号作为分隔 符，close表示以什么结束，在使用foreach的时候最关键的也是最容易出错的就是collection属性，该属性是必须指定的，但是在不同情况 下，该属性的值是不一样的，主要有一下3种情况：

如果传入的是单参数且参数类型是一个List的时候，collection属性值为list

如果传入的是单参数且参数类型是一个array数组的时候，collection的属性值为array

如果传入的参数是多个的时候，我们就需要把它们封装成一个Map了

具体用法如下:

 <insert id="insertUserbatch" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id">
        insert into user(username,birthday,sex,address) values
        <foreach collection="list" item="user" separator=",">
            (#{user.username},#{user.birthday},#{user.sex},#{user.address} )
        </foreach>
 </insert>

 

二、mybatis ExecutorType.BATCH

Mybatis内置的ExecutorType有3种，默认的是simple，该模式下它为每个语句的执行创建一个新的预处理语句，单条提交sql；而batch模式重复使用已经预处理的语句，并且批量执行所有更新语句，显然batch性能将更优； 但batch模式也有自己的问题，比如在Insert操作时，在事务没有提交之前，是没有办法获取到自增的id，这在某型情形下是不符合业务要求的

具体用法如下:

*方式一 spring+mybatis 的

  public SqlSession getSqlSession() throws Exception{
        InputStream inputStream =Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
        return sqlSession;
    }


    @Test
    public void getfind2() throws Exception{
        SqlSession sqlSession = getSqlSession();
        long start = System.currentTimeMillis();
        User2Mapper user2Mapper = sqlSession.getMapper(User2Mapper.class);
        User user1 = new User("ew1",new Date(),"1","1321");
        for (int i =0;i<10000;i++){
           user2Mapper.insertUserbatchForNew(user1);
        }
        System.out.println(user1.getId());
        sqlSession.commit();
        long end  = System.currentTimeMillis();
        System.out.println(end - start);
        System.out.println(user1.getId());

    }

 <insert id="insertUserbatchForNew" parameterType="com.he.Po.User" useGeneratedKeys="true" keyProperty="id">
        insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address} )

 </insert>

以上是mybatis的批量操作情况，对于mybatis可以对比下面的jdbc批量操作的情况

DROP PROCEDURE IF EXISTS proc_initData;--如果存在此存储过程则删掉
DELIMITER $
CREATE PROCEDURE proc_initData()
BEGIN
    DECLARE i INT DEFAULT 1;
    WHILE i<=100000 DO
        INSERT INTO text VALUES(i,CONCAT('姓名',i),'XXXXXXXXX');
        SET i = i+1;
    END WHILE;
END $
CALL proc_initData();

 

 

执行CALL proc_initData()后，本来想想，再慢10W条数据顶多30分钟能搞定吧，结果我打了2把LOL后，回头一看，还在执行，此时心里是彻底懵逼的....待我打完第三把结束后，终于执行完了，这种方法若是让我等上几百万条数据，是不是早上去上班，下午下班回来还没结束呢？10W条数据，有图有真相

JDBC往数据库中普通插入方式

后面查了一下，使用JDBC批量操作往数据库插入100W+的数据貌似也挺快的，

先来说说JDBC往数据库中普通插入方式，简单的代码大致如下，循环了1000条，中间加点随机的数值，毕竟自己要拿数据测试，数据全都一样也不好区分

private String url = "jdbc:mysql://localhost:3306/test01";
    private String user = "root";
    private String password = "123456";
    @Test
    public void Test(){
        Connection conn = null;
        PreparedStatement pstm =null;
        ResultSet rt = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection(url, user, password);        
            String sql = "INSERT INTO userinfo(uid,uname,uphone,uaddress) VALUES(?,CONCAT('姓名',?),?,?)";
            pstm = conn.prepareStatement(sql);
            Long startTime = System.currentTimeMillis();
            Random rand = new Random();
            int a,b,c,d;
            for (int i = 1; i <= 1000; i++) {
                    pstm.setInt(1, i);
                    pstm.setInt(2, i);
                    a = rand.nextInt(10);
                    b = rand.nextInt(10);
                    c = rand.nextInt(10);
                    d = rand.nextInt(10);
                    pstm.setString(3, "188"+a+"88"+b+c+"66"+d);
                    pstm.setString(4, "xxxxxxxxxx_"+"188"+a+"88"+b+c+"66"+d);27                     pstm.executeUpdate();
            }
            Long endTime = System.currentTimeMillis();
            System.out.println("OK,用时：" + (endTime - startTime)); 
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }finally{
            if(pstm!=null){
                try {
                    pstm.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
            if(conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
        }
    }

 

输出结果：OK,用时：738199，单位毫秒，也就是说这种方式与直接数据库中循环是差不多的。

在讨论批量处理之前，先说说遇到的坑，首先，JDBC连接的url中要加rewriteBatchedStatements参数设为true是批量操作的前提，其次就是检查mysql驱动包时候是5.1.13以上版本（低于该版本不支持），因网上随便下载了5.1.7版本的，然后执行批量操作（100W条插入），结果因为驱动器版本太低缘故并不支持，导致停止掉java程序后，mysql还在不断的往数据库中插入数据，最后不得不停止掉数据库服务才停下来...

那么低版本的驱动包是否对100W+数据插入就无力了呢？实际还有另外一种方式，效率相比来说还是可以接受的。

使用事务提交方式

先将命令的提交方式设为false，即手动提交conn.setAutoCommit(false);最后在所有命令执行完之后再提交事务conn.commit();

private String url = "jdbc:mysql://localhost:3306/test01";
    private String user = "root";
    private String password = "123456";
    @Test
    public void Test(){
        Connection conn = null;
        PreparedStatement pstm =null;
        ResultSet rt = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection(url, user, password);        
            String sql = "INSERT INTO userinfo(uid,uname,uphone,uaddress) VALUES(?,CONCAT('姓名',?),?,?)";
            pstm = conn.prepareStatement(sql);
            conn.setAutoCommit(false);
            Long startTime = System.currentTimeMillis();
            Random rand = new Random();
            int a,b,c,d;
            for (int i = 1; i <= 100000; i++) {
                    pstm.setInt(1, i);
                    pstm.setInt(2, i);
                    a = rand.nextInt(10);
                    b = rand.nextInt(10);
                    c = rand.nextInt(10);
                    d = rand.nextInt(10);
                    pstm.setString(3, "188"+a+"88"+b+c+"66"+d);
                    pstm.setString(4, "xxxxxxxxxx_"+"188"+a+"88"+b+c+"66"+d);
                    pstm.executeUpdate();
            }
            conn.commit();
            Long endTime = System.currentTimeMillis();
            System.out.println("OK,用时：" + (endTime - startTime)); 
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }finally{
            if(pstm!=null){
                try {
                    pstm.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
            if(conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
        }
    }

以上代码插入10W条数据，输出结果：OK,用时：18086，也就十八秒左右的时间，理论上100W也就是3分钟这样，勉强还可以接受。

批量处理

接下来就是批量处理了，注意，一定要5.1.13以上版本的驱动包。

private String url = "jdbc:mysql://localhost:3306/test01?rewriteBatchedStatements=true";
    private String user = "root";
    private String password = "123456";
    @Test
    public void Test(){
        Connection conn = null;
        PreparedStatement pstm =null;
        ResultSet rt = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection(url, user, password);        
            String sql = "INSERT INTO userinfo(uid,uname,uphone,uaddress) VALUES(?,CONCAT('姓名',?),?,?)";
            pstm = conn.prepareStatement(sql);
            Long startTime = System.currentTimeMillis();
            Random rand = new Random();
            int a,b,c,d;
            for (int i = 1; i <= 100000; i++) {
                    pstm.setInt(1, i);
                    pstm.setInt(2, i);
                    a = rand.nextInt(10);
                    b = rand.nextInt(10);
                    c = rand.nextInt(10);
                    d = rand.nextInt(10);
                    pstm.setString(3, "188"+a+"88"+b+c+"66"+d);
                    pstm.setString(4, "xxxxxxxxxx_"+"188"+a+"88"+b+c+"66"+d);
                    pstm.addBatch();
            }
            pstm.executeBatch();
            Long endTime = System.currentTimeMillis();
            System.out.println("OK,用时：" + (endTime - startTime)); 
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }finally{
            if(pstm!=null){
                try {
                    pstm.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
            if(conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
        }
    }

10W输出结果：OK,用时：3386，才3秒钟.

批量操作+事务

然后我就想，要是批量操作+事务提交呢？会不会有神器的效果？

private String url = "jdbc:mysql://localhost:3306/test01?rewriteBatchedStatements=true";
    private String user = "root";
    private String password = "123456";
    @Test
    public void Test(){
        Connection conn = null;
        PreparedStatement pstm =null;
        ResultSet rt = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection(url, user, password);        
            String sql = "INSERT INTO userinfo(uid,uname,uphone,uaddress) VALUES(?,CONCAT('姓名',?),?,?)";
            pstm = conn.prepareStatement(sql);
            conn.setAutoCommit(false);
            Long startTime = System.currentTimeMillis();
            Random rand = new Random();
            int a,b,c,d;
            for (int i = 1; i <= 100000; i++) {
                    pstm.setInt(1, i);
                    pstm.setInt(2, i);
                    a = rand.nextInt(10);
                    b = rand.nextInt(10);
                    c = rand.nextInt(10);
                    d = rand.nextInt(10);
                    pstm.setString(3, "188"+a+"88"+b+c+"66"+d);
                    pstm.setString(4, "xxxxxxxxxx_"+"188"+a+"88"+b+c+"66"+d);
                    pstm.addBatch();
            }
            pstm.executeBatch();
            conn.commit();
            Long endTime = System.currentTimeMillis();
            System.out.println("OK,用时：" + (endTime - startTime)); 
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }finally{
            if(pstm!=null){
                try {
                    pstm.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
            if(conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
        }
    }

以下是100W数据输出对比：（5.1.17版本MySql驱动包下测试，交替两种方式下的数据测试结果对比）

批量操作(10W)批量操作+事务提交(10W)批量操作(100W)批量错作+事务提交(100W)

OK,用时：3901

OK,用时：3343

OK,用时：44242

OK,用时：39798

OK,用时：4142

OK,用时：2949

OK,用时：44248

OK,用时：39959

OK,用时：3664

OK,用时：2689

OK,用时：44389

OK,用时：39367

可见有一定的效率提升，但是并不是太明显，当然因为数据差不算太大，也有可能存在偶然因数，毕竟每项只测3次。

预编译+批量操作

网上还有人说使用预编译+批量操作的方式能够提高效率更明显，但是本人亲测，效率不高反降，可能跟测试的数据有关吧。

预编译的写法，只需在JDBC的连接url中将写入useServerPrepStmts=true即可，

如：

private String url = "jdbc:mysql://localhost:3306/test01?useServerPrepStmts=true&rewriteBatchedStatements=true"

 

好了，先到这里...

 

文章来源  https://www.cnblogs.com/fnz0/p/5713102.html

https://blog.csdn.net/xiyang_1990/article/details/78598371

 

will的猜想
关注
专栏目录
mybatis批量操作
Kiss键
04-20 565
foreach 用于迭代传入过来的参数，在sql中通常放在in关键字后面。 它的属性介绍分别是collection：表示传入过来的参数的数据类型。该参数为必选。要做 foreach 的对象，作为入参时，List 对象默认用 list 代替作为键，数组对象有 array 代替作为键，Map 对象没有默认的键。当然在作为入参时可以使用 @Param(“keyName”) 来设置键，设置 keyName...
mybatis中批量插入的两种方式(高效插入)
09-01
本文将深入探讨MyBatis中实现批量插入的两种高效方式。 ### 1. MyBatis `foreach` 标签 `foreach` 是MyBatis中用于在SQL语句中迭代集合的标签，特别适合构建`IN`条件。`foreach` 元素的属性包括： - `item`: 集合...
MyBatis执行批量操作
奔跑的小豪吖的博客
06-21 6243
Mybatis常会出现批量操作，如批量查询，批量插入，批量修改(replace into)。批量操作要比循环执行效率提升很多，这里对mybatis的批量操作做一个总结讲解。 foreach的主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合。foreach标签的属性主要有item，index，collection，open，separator，close。在使用foreach的时候最关键的也是最容易出错的就是collection属性，该属性是必须指定的，但是在不同情况下，该属性的值是不一样的，主要
MyBatis配置允许批量插入或更新数据
最新发布
LMY0210的博客
08-23 471
这个配置项告诉MyBatis允许在单个数据库连接中执行多个SQL语句，从而实现批量插入或更新数据的功能。但是要注意，在开启批量操作之前，确保你已经了解并理解了可能引发的安全风险，并且在使用批量操作时要进行适当的验证和控制，以确保数据的完整性和安全性。在许多情况下，数据的插入和更新都需要经过验证和控制，以确保数据的完整性和一致性。如果允许默认的批量操作，可能会导致不正确的数据插入或更新，从而影响应用程序的正常运行。可以用于某些情况下的方便性，但出于安全和性能的考虑，通常不建议在生产环境中启用它。
Mybatis 批量操作8种实现总结
热门推荐
程序员小强的博客
12-09 2万+
Mybatis 批量操作8种实现总结超全带实例
mybatis的批量操作
gys9895的博客
04-16 452
系列文章目录 文章目录系列文章目录一、模糊查询1.concat2.INSTR 一、模糊查询 1.concat <if test="queryDTO.regid != null and queryDTO.regid !=''"> AND lca.RegId like concat("%",#{queryDTO.regid},"%") </if> 2.INSTR <if test="queryDTO.tagid != null and queryDTO.tagid !='
Mybatis批量操作
咸鱼老罗的博客
09-08 1万+
Mybatis常会出现批量操作，如批量查询，批量插入，批量修改(replace into)。批量操作要比循环执行效率提升很多，这里对mybatis的批量操作做一个总结讲解。 Foreach foreach：foreach的主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合。foreach元素的属性主要有 item，index，collection，open，separator，clo
Mybatis批量修改的操作代码
08-29
Mybatis提供了多种批量修改的方式，包括以下几种： 1. 修改的字段值都是一样的，id不同 例如： ```xml update cbp_order set status=1 where id in (" separator="," close=")"> #{id} ``` 这种方式可以...
基于mybatis batch实现批量提交大量数据
08-19
MyBatis批量提交大量数据是一种高效的数据批量操作方式，通过MyBatis的BATCH方式执行增删改方法，可以实现在短时间内处理大量数据。下面对MyBatis批量提交大量数据的实现进行了详细的介绍。 MyBatis批量提交的优点 ...
Mybatis批量更新报错问题
08-31
本文将详细分析Mybatis批量更新的报错问题及其解决方法。 首先，报错可能由于不支持批量更新操作的JDBC配置引起。在MySQL中，如果不开启`allowMultiQueries`参数，Mybatis尝试执行包含多个SQL语句的批量更新时，会...
spring中使用mybatis实现批量插入的示例代码
08-19
本文将详细介绍 Spring 中使用 MyBatis 实现批量插入的示例代码，主要分为三种实现方式：foreach、Spring 事务、ExecutorType.BATCH。 二、foreach 方式 foreach 方式实际是对 SQL 语句进行拼接，生成一个长长的 ...
mybatis 批量操作大全
demo_yo的博客
08-04 331
代码】mybatis 批量操作大全。
MyBatis实现批量操作
qq_47759220的博客
05-03 452
<update id="batchUpdateDbInfo"> <foreach collection="list" item="item" index="index" separator=";" open="begin" close=";end;"> UPDATE AS_DETAILED_FORM SET equ_Place = #{item.equPlace},USE_DEP_ID = #{item.useDepId} ,equ_Pe..
mybatis批量处理
Cowboy
12-23 1722
Mybatis技术学习，更多知识请访问https://www.itkc8.com foreach的主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合。foreach元素的属性主要有 item，index，collection，open，separator，close。item表示集合中每一个元素进行迭代时的别名，index指 定一个名字，用于表示在迭代过程中，每次迭代到的位置，open...
kafka 高级应用 springboot2.1 (1)
weixin_30894389的博客
08-01 421
官网：http://kafka.apache.org/21/documentation.html 依赖: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot...
mybatis各种批量操作(优秀摘录)
m0_59176231的博客
03-20 492
是扩展运算符，是es6的新语法for：简单、可以通过索引访问或者修改原数组while、do while：循环条件确定，和java一样for in：可以遍历对象出对象的属性和属性值。for of：既可以遍历列表也可以遍历对象。可以拿到列表的索引和值，也可以拿到对象的属性和属性值forEach：省内存，但是不能使用for寻找中的break。可以拿到数组的索引和元素。可以获取对象中的属性值。注意：forEach会改变原来数组中的值。forEach方法没有返回值，一般用于直接修改原数组；
# mybatis批量操作
weixin_34004576的博客
11-01 124
mybatis批量操作   应用场景：今天做了一个插入数据的小功能，将含有50个对象的集合(List)插入到数据库。自然而然的就要到了mybatis批量插入，记得刚参加工作时，类似场景我会写一个for循环，逐条插入数据。   操作数据库的时候会经过这样一个流程：创建、打开、执行SQL、关闭连接，创建和打开数据库连接对性能是有损失的,下面简单地说一下批量插入和逐条插入的区别。 逐条插入会...
MyBatis批量保存实体数据实战教程
在MyBatis中，单笔批量保存实体数据是一种提高数据库操作效率的方式，它允许我们在一次数据库事务中处理多条记录，而不是逐条插入或更新。这种方法减少了数据库连接的开销，提高了整体性能。下面将详细介绍如何在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值