数据库表伪造假数据

目的：用于试验数据量较大的数据库表查询

需要支持mybatis-plus以及spring test。插入10w条数据。

用户表：

create
database if not exists nami;

use
nami;

-- 用户表
create table user
(
    username     varchar(256) null comment '用户昵称',
    id           bigint auto_increment comment 'id'
        primary key,
    userAccount  varchar(256) null comment '账号',
    avatarUrl    varchar(1024) null comment '用户头像',
    gender       tinyint null comment '性别',
    userPassword varchar(512)       not null comment '密码',
    phone        varchar(128) null comment '电话',
    email        varchar(512) null comment '邮箱',
    userStatus   int      default 0 not null comment '状态 0 - 正常',
    createTime   datetime default CURRENT_TIMESTAMP null comment '创建时间',
    updateTime   datetime default CURRENT_TIMESTAMP null on update CURRENT_TIMESTAMP,
    isDelete     tinyint  default 0 not null comment '是否删除',
    userRole     int      default 0 not null comment '用户角色 0 - 普通用户 1 - 管理员',
    tags         varchar(1024) null comment '标签 json 列表'
) comment '用户';

服务类

package com.nami.usercenter.service;

import com.nami.usercenter.model.domain.User;
import com.baomidou.mybatisplus.extension.service.IService;

public interface UserService extends IService<User> {
        // 一些其他提供服务的方法，后面使用的是UserService的saveBatch()方法，是继承自IService()的。
}

for循环插入

package com.nami.usercenter.service;

import com.nami.usercenter.model.domain.User;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.util.StopWatch;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

@SpringBootTest
public class InsertUsersTest {

    @Resource
    private UserService userService;

    @Test
    public void doInsertUsers(){
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        final int INSERT_NUM=100000;
        List<User> userList = new ArrayList<>();
        for (int i = 0; i < INSERT_NUM; i++) {
            User user = new User();
            user.setUsername("假数据");
            user.setUserAccount("fakeaccount");
            user.setAvatarUrl("https://images.cnblogs.com/cnblogs_com/techgy/1640002/o_230705123154_%E5%A4%B4%E5%83%8F.jpg");
            user.setGender(0);
            user.setUserPassword("231313123");
            user.setPhone("1231312");
            user.setEmail("12345678@qq.com");
            user.setUserStatus(0);
            user.setUserRole(0);
            user.setTags("[]");
            userList.add(user);
        }
        userService.saveBatch(userList,10000);
        stopWatch.stop();
        System.out.println(stopWatch.getTotalTimeMillis());
    }
}

执行结果：

并发执行
线程池可以使用默认的也可以自定义，两种方法区别是：自定义可以跑满线程，而默认的只能跑CPU核数-1。
代码上的区别：就是在异步执行处加上自定义的线程名

@SpringBootTest
public class InsertUsersTest {
    @Resource
    private UserService userService;

    private ExecutorService executorService = new ThreadPoolExecutor(15,1000,10000, TimeUnit.MINUTES,new ArrayBlockingQueue<>(10000));

    @Test
    public void doConcurrencyInsertUsers(){
          StopWatch stopWatch = new StopWatch();
          stopWatch.start();
          //分10组
          int batchSize = 5000;
          int j=0;
          List<CompletableFuture<Void>> futureList = new ArrayList<>();
          for (int i = 0; i < 20; i++) {
              List<User> userList = new ArrayList<>();
              while (true){
                  j++;
                  User user = new User();
                  user.setUsername("假数据");
                  user.setUserAccount("fakeaccount");
                  user.setAvatarUrl("https://images.cnblogs.com/cnblogs_com/techgy/1640002/o_230705123154_%E5%A4%B4%E5%83%8F.jpg");
                  user.setGender(0);
                  user.setUserPassword("231313123");
                  user.setPhone("1231312");
                  user.setEmail("12345678@qq.com");
                  user.setUserStatus(0);
                  user.setUserRole(0);
                  user.setTags("[]");
                  userList.add(user);
                  if (j % batchSize==0){
                      break;
                  }
              }
              //异步执行
              CompletableFuture<Void> future = CompletableFuture.runAsync(() ->{
                  System.out.println("threadName:"+Thread.currentThread().getName());
                  userService.saveBatch(userList,batchSize);
              },executorService);
              futureList.add(future);
          }
          CompletableFuture.allOf(futureList.toArray(new CompletableFuture[]{})).join();

          stopWatch.stop();
          System.out.println(stopWatch.getTotalTimeMillis());
      }
}

执行结果：

__EOF__

本文作者：techgy
本文链接：https://www.cnblogs.com/techgy/p/17529865.html
关于博主：I am a good person
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！