验证mybatis批量插入能否一次能插入1万条数据

Posted 老程不秃

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了验证mybatis批量插入能否一次能插入1万条数据相关的知识,希望对你有一定的参考价值。

提到用Mybatis批量插入数据,把上限1万条数据一次性的插入到表中。面试官对一次性插入1万条数据有疑问,认为不可以插入这么多数据,但是我做这个功能的时候确实是成功的,那具体能一次插入数据的上限我也不确定,后面就找时间做了下面这个实验。

首先自己搭建了SpringBoot+Mybatis的项目测试的,搭建步骤如下

1. 搭建测试工程

idea构建SpringBoot+MyBatis项目

gitee上代码:https://gitee.com/AJiSun/SpringBoot-MyBatis

File->New->Project

依赖:不选也行,后续在pom中添加,这里就选了一个mysql的依赖

添加需要的pom

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.0</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
复制代码

然后就是新建文件夹,新建需要的文件,我的目录结构如下

application.yml中的配置

server:
port: 7070
spring:
application:
  name: ajisun-mybatis
datasource:
  driver-class-name: com.mysql.jdbc.Driver
  url: jdbc:mysql://localhost:3306/ajisun_mybatis?useUnicode=true&characterEncoding=utf-8&useSSL=false&useInformationSchema=true
  username: root
  password: root
​
mybatis:
mapperLocations: classpath:mapper/*.xml
typeAliasesPackage: com.ajisun.coding.ajisunmybatis.entity
 #开启驼峰命名
configuration:
    map-underscore-to-camel-case: true
复制代码

启动类中加上注解@MapperScan(启动的时候能够扫描到mapper)

@SpringBootApplication
@MapperScan("com.ajisun.coding.ajisunmybatis.mapper")
public class AjisunMybatisApplication 
public static void main(String[] args) 
SpringApplication.run(AjisunMybatisApplication.class, args);

​

复制代码

实体类中的内容

public class SyncEmployee implements Serializable 
   private Long syncId;
   private Long syncCode;
   private String employeeNum;
   private String imageUrl;
.......
   // set/get省略

复制代码

mapper.java中内容

public interface SyncEmployeeMapper 
   /**
    * 查询列表
    * @return
    */
   List<SyncEmployee> selectList();

复制代码

mapper.xml中内容

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
​
<mapper namespace="com.ajisun.coding.ajisunmybatis.mapper.SyncEmployeeMapper">
   <select id="selectList" resultType="com.ajisun.coding.ajisunmybatis.entity.SyncEmployee">
      SELECT * FROM sync_employee;
   </select>
</mapper>
复制代码

Interface service类 中的内容

public interface SyncEmployeeService 
   /**
    * 查询列表
    * @return
    */
   List<SyncEmployee> selectList();

复制代码

实现Interface service的类中的内容

加上@Service 注解,标明这个类是一个service,会被springboot扫描。

@Service
public class SyncEmployeeServiceImpl implements SyncEmployeeService 
​
   @Autowired
   private SyncEmployeeMapper syncEmployeeMapper;
​
   /**
    * 查询列表
    * @return
    */
   @Override
   public List<SyncEmployee> selectList() 
       return syncEmployeeMapper.selectList();
  
复制代码

接口文件controller的内容

@RestController
@RequestMapping("/user")
public class SyncEmployeeController 
​
   @Autowired
   private SyncEmployeeService syncEmployeeService;
​
   @GetMapping("/list")
   public ResponseEntity<List<SyncEmployee>>  list()
       return ResponseEntity.ok(syncEmployeeService.selectList());
  

复制代码

至此就可以启动了,端口是yml中配置的7070,访问接口是【get】http://localhost:7070/user/list

2. 造数据,做测试

1. 表结构

CREATE TABLE `ajisun_mybatis`.`sync_employee`  (
  `sync_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `sync_code` bigint(30) NOT NULL COMMENT '同步批次号',
  `employee_num` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '员工编码',
  `name` varchar(60) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '员工姓名',
  `tenant_id` bigint(20) NOT NULL DEFAULT 0 COMMENT '租户ID',
  `email` varchar(60) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '电子邮件',
  `mobile` varchar(60) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '移动电话',
  `inter_code` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '国际码',
  `code_mobile` varchar(60) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '国际码+手机号',
  `gender` tinyint(4) NULL DEFAULT NULL,
  `cid` varchar(60) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '身份编码',
  `status` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '员工状态',
  `enabled_flag` tinyint(1) NULL DEFAULT NULL COMMENT '启用状态',
  `entry_date` datetime(0) NULL DEFAULT NULL COMMENT '员工入职时间',
  `birthday` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '出生日期',
  `ldap_flag` tinyint(1) NOT NULL DEFAULT 0 COMMENT '否是ldap用户',
  `password` varchar(40) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '密码',
  `image_url` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '头像',
  `sync_status` tinyint(1) NOT NULL DEFAULT 1 COMMENT 'sync状态',
  `sync_message` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT 'sync信息',
  PRIMARY KEY (`sync_id`) USING BTREE,
  INDEX `sync_emp_n1`(`sync_code`, `tenant_id`) USING BTREE,
  INDEX `sync_emp_n2`(`email`, `sync_code`, `tenant_id`) USING BTREE,
  INDEX `sync_emp_n3`(`mobile`, `sync_code`, `tenant_id`) USING BTREE,
  INDEX `sync_emp_n4`(`employee_num`, `tenant_id`, `sync_code`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin COMMENT = '员工同步中间表' ROW_FORMAT = Dynamic;
复制代码

在SpringBoot-Mybatis 的项目中添加方法(具体参考代码,这里只说主要的地方)

2. mapper.xml中批量insert代码

<insert id="batchInsertData">
      insert into sync_employee (sync_id,sync_code,employee_num,name,tenant_id,
      email,mobile,inter_code,code_mobile,gender,cid,status,enabled_flag,
      entry_date,birthday,ldap_flag,image_url,sync_status,sync_message)
      values
       <foreach collection="syncEmployeeList" item="sync" separator=",">
          (
          #sync.syncId,
          #sync.syncCode,
          #sync.employeeNum,
          #sync.name,
          #sync.tenantId,
          #sync.email,
          #sync.mobile,
          #sync.interCode,
          #sync.codeMobile,
          #sync.gender,
          #sync.cid,
          #sync.status,
          #sync.enabledFlag,
          #sync.entryDate,
          #sync.birthday,
          #sync.ldapFlag,
          #sync.imageUrl,
          0,
          #sync.syncMessage
          )
       </foreach>
   </insert>
复制代码

3. service中的代码(循环造需要的数据量)

@Override
   public void batchInsertData(Long syncCode) 
       List<SyncEmployee> syncEmployeeList = new ArrayList<SyncEmployee>();
       for (int i=10000;i<20000;i++)
           SyncEmployee ee = new SyncEmployee();
           ee.setSyncId(Long.valueOf(i));
           ee.setSyncCode(syncCode);
           ee.setEmail(i+"@qq.com");
           ee.setMobile("121000"+String.valueOf(+i));
           ee.setCodeMobile(ee.getInterCode()+"-"+ee.getMobile());
           ee.setEmployeeNum("ajisun"+i);
           ee.setEnabledFlag(1);
           ee.setGender(i%2);
           ee.setImageUrl("http://ajisun.com/头像.png");
           ee.setName(i+"");
           ee.setLdapFlag(i%2);
           ee.setEntryDate(new Date());
           ee.setStatus("ON");
           ee.setTenantId(0L);
           ee.setBirthday("1900-01-01");
           ee.setSyncMessage("new data "+i);
           syncEmployeeList.add(ee);
      
       long start = System.currentTimeMillis();
       syncEmployeeMapper.batchInsertData(syncEmployeeList);
       long end = System.currentTimeMillis();
       System.out.println(end-start);
  
复制代码

4. 准备完毕,开始执行

通过上述方法一次构造一万条数据,然后通过sql批量插入

com.mysql.cj.jdbc.exceptions.PacketTooBigException: Packet for query is too large (4,879,714 > 4,194,304). You can change this valueon the server by setting the 'max_allowed_packet' variable.
复制代码

报错了,根据错误信息知道 构造的一万条数据的大小超过了mysql限制的大小,但是我开发环境并没有问题啊(去开发环境看了下这个值确实比较大)

查看当前环境max_allowed_packet的大小,如下 这个版本默认是4M的大小

mysql> show global variables like 'max_allowed_packet';
+--------------------+---------+
| Variable_name      | Value   |
+--------------------+---------+
| max_allowed_packet | 4194304 |
+--------------------+---------+
1 row in set (0.01 sec)
​
mysql> select 4194304/1024/1024;
+-------------------+
| 4194304/1024/1024 |
+-------------------+
|        4.00000000 |
+-------------------+
1 row in set (0.00 sec)
复制代码

把这个参数改大点试试(设置10M)

mysql> set global max_allowed_packet = 1024*1024*10;
Query OK, 0 rows affected (0.01 sec)
复制代码

命令set采用的临时修改方式,需要打开新的会话才能生效,重启SpringBoot服务然后在调用接口。(还可以通过修改mysql配置文件使其永久生效 max_allowed_packet = 1024* 1024*10)。

还可以通过修改mysql配置文件使其永久生效 max_allowed_packet = 1024* 1024*10

再次调用接口就成功了

继续加大操作数据量,修改循环条件(3万数据量),数据量的总大小在14M左右

com.mysql.cj.jdbc.exceptions.PacketTooBigException: Packet for query is too large (14,637,233 > 10,485,760). You can change this value on the server by setting the 'max_allowed_packet' variable.
复制代码

如上还是出现了相同的max_allowed_packet 错误,packet的大小超过了max_allowed_packet的值。

所以经过测试可以确定Mybatis究竟能插入多少数据取决于mysql的max_allowed_packet大小限制,而不是其自身的限制。

3. 总结

本文着重在于测试mybatis对批量插入的数据量是否有影响,经过测试发现并没有影响,主要是mysql自身对接收数据量的大小限制,通过参数max_allowed_packet控制。

但是使用mybatis大数据量批量插入要注意效率问题,这里只是测试,并不推荐这种方式。

Java怎么实现几十万条数据插入(30万条数据插入MySQL仅需13秒)

本文主要讲述通过MyBatis、JDBC等做大数据量数据插入的案例和结果。

30万条数据插入插入数据库验证


验证的数据库表结构如下:

CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户id',
  `username` varchar(64) DEFAULT NULL COMMENT '用户名称',
  `age` int(4) DEFAULT NULL COMMENT '年龄',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户信息表';

话不多说,开整!

实体类、mapper和配置文件定义

User实体

/**
 * <p>用户实体</p>
 *
 * @Author zjq
 * @Date 2021/8/3
 */
@Data
public class User 

    private int id;
    private String username;
    private int age;


mapper接口

public interface UserMapper 

    /**
     * 批量插入用户
     * @param userList
     */
    void batchInsertUser(@Param("list") List<User> userList);



mapper.xml文件

    <!-- 批量插入用户信息 -->
    <insert id="batchInsertUser" parameterType="java.util.List">
        insert into t_user(username,age) values
        <foreach collection="list" item="item" index="index" separator=",">
            (
            #item.username,
            #item.age
            )
        </foreach>
    </insert>

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

sqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--通过properties标签加载外部properties文件-->
    <properties resource="jdbc.properties"></properties>


    <!--自定义别名-->
    <typeAliases>
        <typeAlias type="com.zjq.domain.User" alias="user"></typeAlias>
    </typeAliases>


    <!--数据源环境-->
    <environments default="developement">
        <environment id="developement">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="$jdbc.driver"/>
                <property name="url" value="$jdbc.url"/>
                <property name="username" value="$jdbc.username"/>
                <property name="password" value="$jdbc.password"/>
            </dataSource>
        </environment>
    </environments>


    <!--加载映射文件-->
    <mappers>
        <mapper resource="com/zjq/mapper/UserMapper.xml"></mapper>
    </mappers>


</configuration>

不分批次直接梭哈

MyBatis直接一次性批量插入30万条,代码如下:

    @Test
    public void testBatchInsertUser() throws IOException 
        InputStream resourceAsStream =
                Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession session = sqlSessionFactory.openSession();
        System.out.println("===== 开始插入数据 =====");
        long startTime = System.currentTimeMillis();
        try 
            List<User> userList = new ArrayList<>();
            for (int i = 1; i <= 300000; i++) 
                User user = new User();
                user.setId(i);
                user.setUsername("共饮一杯无 " + i);
                user.setAge((int) (Math.random() * 100));
                userList.add(user);
            
            session.insert("batchInsertUser", userList); // 最后插入剩余的数据
            session.commit();

            long spendTime = System.currentTimeMillis()-startTime;
            System.out.println("成功插入 30 万条数据,耗时:"+spendTime+"毫秒");
         finally 
            session.close();
        
    

可以看到控制台输出:

Cause: com.mysql.jdbc.PacketTooBigException: Packet for query is too large (27759038 >yun 4194304). You can change this value on the server by setting the max_allowed_packet’ variable.

超出最大数据包限制了,可以通过调整max_allowed_packet限制来提高可以传输的内容,不过由于30万条数据超出太多,这个不可取,梭哈看来是不行了 😅😅😅
既然梭哈不行那我们就一条一条循环着插入行不行呢

循环逐条插入

mapper接口和mapper文件中新增单个用户新增的内容如下:

    /**
     * 新增单个用户
     * @param user
     */
    void insertUser(User user);
    <!-- 新增用户信息 -->
    <insert id="insertUser" parameterType="user">
        insert into t_user(username,age) values
            (
            #username,
            #age
            )
    </insert>

调整执行代码如下:

    @Test
    public void testCirculateInsertUser() throws IOException 
        InputStream resourceAsStream =
                Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession session = sqlSessionFactory.openSession();
        System.out.println("===== 开始插入数据 =====");
        long startTime = System.currentTimeMillis();
        try 
            for (int i = 1; i <= 300000; i++) 
                User user = new User();
                user.setId(i);
                user.setUsername("共饮一杯无 " + i);
                user.setAge((int) (Math.random() * 100));
                // 一条一条新增
                session.insert("insertUser", user);
                session.commit();
            

            long spendTime = System.currentTimeMillis()-startTime;
            System.out.println("成功插入 30 万条数据,耗时:"+spendTime+"毫秒");
         finally 
            session.close();
        
    

执行后可以发现磁盘IO占比飙升,一直处于高位。

等啊等等啊等,好久还没执行完


先不管他了太慢了先搞其他的,等会再来看看结果吧。
two thousand year later …
控制台输出如下:

总共执行了14909367毫秒,换算出来是4小时八分钟。太慢了。。

👇👇👇还是优化下之前的批处理方案吧

MyBatis实现插入30万条数据

先清理表数据,然后优化批处理执行插入:

-- 清空用户表
TRUNCATE table  t_user;

以下是通过 MyBatis 实现 30 万条数据插入代码实现:

    /**
     * 分批次批量插入
     * @throws IOException
     */
    @Test
    public void testBatchInsertUser() throws IOException 
        InputStream resourceAsStream =
                Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession session = sqlSessionFactory.openSession();
        System.out.println("===== 开始插入数据 =====");
        long startTime = System.currentTimeMillis();
        int waitTime = 10;
        try 
            List<User> userList = new ArrayList<>();
            for (int i = 1; i <= 300000; i++) 
                User user = new User();
                user.setId(i);
                user.setUsername("共饮一杯无 " + i);
                user.setAge((int) (Math.random() * 100));
                userList.add(user);
                if (i % 1000 == 0) 
                    session.insert("batchInsertUser", userList);
                    // 每 1000 条数据提交一次事务
                    session.commit();
                    userList.clear();

                    // 等待一段时间
                    Thread.sleep(waitTime * 1000);
                
            
            // 最后插入剩余的数据
            if(!CollectionUtils.isEmpty(userList)) 
                session.insert("batchInsertUser", userList);
                session.commit();
            

            long spendTime = System.currentTimeMillis()-startTime;
            System.out.println("成功插入 30 万条数据,耗时:"+spendTime+"毫秒");
         catch (Exception e) 
            e.printStackTrace();
         finally 
            session.close();
        
    

使用了 MyBatis 的批处理操作,将每 1000 条数据放在一个批次中插入,能够较为有效地提高插入速度。同时请注意在循环插入时要带有合适的等待时间和批处理大小,以防止出现内存占用过高等问题。此外,还需要在配置文件中设置合理的连接池和数据库的参数,以获得更好的性能。

在上面的示例中,我们每插入1000行数据就进行一次批处理提交,并等待10秒钟。这有助于控制内存占用,并确保插入操作平稳进行。

五十分钟执行完毕,时间主要用在了等待上。

如果低谷时期执行,CPU和磁盘性能又足够的情况下,直接批处理不等待执行:

    /**
     * 分批次批量插入
     * @throws IOException
     */
    @Test
    public void testBatchInsertUser() throws IOException 
        InputStream resourceAsStream =
                Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession session = sqlSessionFactory.openSession();
        System.out.println("===== 开始插入数据 =====");
        long startTime = System.currentTimeMillis();
        int waitTime = 10;
        try 
            List<User> userList = new ArrayList<>();
            for (int i = 1; i <= 300000; i++) 
                User user = new User();
                user.setId(i);
                user.setUsername("共饮一杯无 " + i);
                user.setAge((int) (Math.random() * 100));
                userList.add(user);
                if (i % 1000 == 0) 
                    session.insert("batchInsertUser", userList);
                    // 每 1000 条数据提交一次事务
                    session.commit();
                    userList.clear();
                
            
            // 最后插入剩余的数据
            if(!CollectionUtils.isEmpty(userList)) 
                session.insert("batchInsertUser", userList);
                session.commit();
            

            long spendTime = System.currentTimeMillis()-startTime;
            System.out.println("成功插入 30 万条数据,耗时:"+spendTime+"毫秒");
         catch (Exception e) 
            e.printStackTrace();
         finally 
            session.close();
        
    

则24秒可以完成数据插入操作:


可以看到短时CPU和磁盘占用会飙高。
把批处理的量再调大一些调到5000,在执行:

13秒插入成功30万条,直接芜湖起飞🛫🛫🛫

JDBC实现插入30万条数据

JDBC循环插入的话跟上面的mybatis逐条插入类似,不再赘述。
以下是 Java 使用 JDBC 批处理实现 30 万条数据插入的示例代码。请注意,该代码仅提供思路,具体实现需根据实际情况进行修改。

    /**
     * JDBC分批次批量插入
     * @throws IOException
     */
    @Test
    public void testJDBCBatchInsertUser() throws IOException 
        Connection connection = null;
        PreparedStatement preparedStatement = null;

        String databaseURL = "jdbc:mysql://localhost:3306/test";
        String user = "root";
        String password = "root";

        try 
            connection = DriverManager.getConnection(databaseURL, user, password);
            // 关闭自动提交事务,改为手动提交
            connection.setAutoCommit(false);
            System.out.println("===== 开始插入数据 =====");
            long startTime = System.currentTimeMillis();
            String sqlInsert = "INSERT INTO t_user ( username, age) VALUES ( ?, ?)";
            preparedStatement = connection.prepareStatement(sqlInsert);

            Random random = new Random();
            for (int i = 1; i <= 300000; i++) 
                preparedStatement.setString(1, "共饮一杯无 " + i);
                preparedStatement.setInt(2, random.nextInt(100));<

以上是关于验证mybatis批量插入能否一次能插入1万条数据的主要内容,如果未能解决你的问题,请参考以下文章

Java通过Mybatis实现批量插入数据到Oracle中

mybatis批量插入的方式

批量向MySQL导入1000万条数据的优化

如何快速安全的插入千万条数据?

MySQL 批量操作,一次插入多少行数据效率最高?

MySQL 批量操作,一次插入多少行数据效率最高?