springboot mybatis批量数据写入数据速度测试

项目场景：

突然想测试一下mbatis最快的插入速率是多少，因此做下实验。

---

环境准备

安装mysql，我本地的mysql版本为8.0.12，springboot版本为2.4.4
本次采用druid线程池+线程池+excutor batch的模式进行插入测试，有的同学可能会认为单表插入，单线程会更快，其实不是的，在数据库保存操作的时候对表的锁定，只是commit的时候会有竞争。也就是说，数据插入会有sql解析+sql优化等其他耗时操作，最后才是锁表的commit操作，因此使用多线程插入是比单线程要快的。
建立表a DDL如下

-- test1.a definition

CREATE TABLE `a` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `name` varchar(255) DEFAULT NULL,
  `sex` int(255) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `insertTime` datetime DEFAULT NULL,
  UNIQUE KEY `id` (`id`),
  KEY `nameindex` (`name`,`sex`,`age`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=52893 DEFAULT CHARSET=utf8;

---

批量插入：

1.使用mybatis druid连接池。

引入druid 自动装配

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.17</version>
        </dependency>

加入druid配置。

spring.datasource.druid.initialSize=8
spring.datasource.druid.minIdle=10
spring.datasource.druid.maxActive=50
spring.datasource.druid.maxWait=60000
spring.datasource.druid.timeBetweenEvictionRunsMillis=60000
spring.datasource.druid.minEvictableIdleTimeMillis=300000
spring.datasource.druid.validationQuery=SELECT 1 FROM DUAL
spring.datasource.druid.testWhileIdle=true
spring.datasource.druid.testOnBorrow=false
spring.datasource.druid.testOnReturn=false
spring.datasource.druid.poolPreparedStatements=true
spring.datasource.druid.maxPoolPreparedStatementPerConnectionSize=20
spring.datasource.druid.useGlobalDataSourceStat=true
spring.datasource.druid.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

最大数据库连接配置为50。

2. 代码配置线程池类

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Configuration
public class ExcutorPool {
    @Bean
    public ThreadPoolExecutor threadPoolExecutor() {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(20, 50, 5, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100));
        executor.allowCoreThreadTimeOut(true);
        return executor;
    }
}

这里使用20个线程并发写入。

3. 写入service

    @Autowired
    private SqlSessionTemplate sqlSessionTemplate;

    @Autowired
    private ThreadPoolExecutor threadPoolExecutor;
    @Override
    public void insertUser() {
        for(int i = 0; i < 20; i++) {
            threadPoolExecutor.execute(new RunTask(sqlSessionTemplate));
        }
        threadPoolExecutor.shutdown();
        long t1 = System.currentTimeMillis();
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(threadPoolExecutor.isTerminated()){
                System.out.println("都结束了！耗时："+ ((System.currentTimeMillis()-t1)/1000)+"s");
                break;
            }
    }
    }

循环20次，20个线程插入。线程池任务执行完打印都结束了。

3.runTask

package com.example.springdemo.demo.service.impl;

import com.example.springdemo.demo.dao.UserDao;
import com.example.springdemo.demo.model.User;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class RunTask implements Runnable {

    private SqlSessionTemplate sqlSessionTemplate;


    public  RunTask(SqlSessionTemplate sqlSessionTemplate){
        this.sqlSessionTemplate= sqlSessionTemplate;
    }
    @Override
    public void run() {
        System.out.println("开始执行插入任务："+Thread.currentThread().getName());
        long beginTime = System.currentTimeMillis();
        SqlSession session = sqlSessionTemplate.getSqlSessionFactory().openSession(ExecutorType.BATCH,false);
        //通过新的session获取mapper
        UserDao userDao = session.getMapper(UserDao.class);
        int size = 5000;
        try{
            for(int i = 0; i < size; i++) {
                User user = new User();
                Date date = new Date();
                user.setName("小红"+date.getTime());
                user.setAge(12);
                user.setSex(1);
                user.setInsertTime(date);
                userDao.insertUser(user);
            }
            //手动每1000个一提交，提交后无法回滚
            session.commit();
//清理缓存，防止溢出
            session.clearCache();
        } catch (Exception e) {
//没有提交的数据可以回滚
            session.rollback();
        } finally{
            session.close();
        }
        System.out.println("thread:"+ Thread.currentThread().getName()+"，耗时："+ ((System.currentTimeMillis()-beginTime)/1000)+"s");
    }
}

runtask执行具体的保存任务，每5000条记录，做一次commit操作。
并且任务执行完毕打印5000条保存记录耗时多少秒。

4.dao接口以及sql

@Repository
public interface UserDao {

    User getUser();
    void insertUser(User user);
}

<insert id="insertUser" parameterType="com.example.springdemo.demo.model.User">
    insert into a (name,sex,age,insertTime) values (#{name},#{sex},#{age},#{insertTime});
</insert>

model类

@Data
public class User {

    private Integer id;
    @NotBlank
    private String name;

    private Integer sex;

    private Integer age;

    private Date insertTime;
}

5.开始测试

测试的时候我是定义了一个get请求去请求的，这个就不写了。这里是循环20次每次5000插入，也就是10w数据插入速度测试，更多的数据就不测试了，10w也可以基本计算出速率了。

开始执行任务，
查看磁盘写入速率。


刚开始的时候写入速率比较高，后面平均在700kb左右。

耗时481s，每秒插入200条。

总结：

本次测试仅仅是本人自己做的实验，仅供参考，具体的生产环境可能是有很大差异的，毕竟表字段也不会像我这里的这么简单。其实插入的时候可以使用insert into values的写法，但是这种写法拼接5000条，应该会报错，sql太长了，实际使用不会这么写这种情况就不测试了，感兴趣的小伙伴可以自己测试玩玩。