批量导入大数据以及数据去重，CSV多线程导入100w数据
mysql层面去重：https://www.cnblogs.com/duanxiaojun/p/6855680.html
数据库层面具体使用哪个sql语句去重，根据业务情况来定。
数据库连接池默认开启连接50，最大100
由于mybatis有一次sql的大小限制或者数据库也有大小限制，因此可以将其分为多个list集合，使用ExcutorService、callable、futuretask、countdownlatch（用于计算分段list集合个数），多线程并发插入数据。程序方面对Excel中的数据去重：将数据封装为对象，对象重写equals方法和hashCode方法，这里equals就只对那2个字段进行比较即可，并将对象放入set中去重。数据库方面去重：利用数据库设置联合唯一索引。然后通过insert ignore into语句去执行。insert ignore into：重复或语句错误报错都会被忽略（根据主键和唯一索引判断重复）
程序方面的去重与上一点大致相同。区别是equals和hashCode需要判断全部的属性字段。
以上也可以考虑用redis的zset去重，但是会增加网络延时问题，以及每次都要以网络形式分批去读取redis中的数据，并且反序列化，会增加一定的网络不及时响应等问题。如果程序没有考虑从缓存中读取数据，使用redis去重存储数据，是得不偿失的。如果本身系统查数据都是从redis中获取，那么使用redis的zset存储数据库的数据是可以的。
引入一个问题，如何知道redis上的哪些数据是没有被持久化到数据库中的呢？
经济允许，可以创建两个zset集合，一个zset集合（A）是缓存全部数据，一个zset集合（B）存需要插入到数据库的全部数据。那么多个用户并行上传数据后，将这些数据都存入A和B中，由于前端是从缓存A中获取数据，所以很快就能响应，然后后台异步操作对B中的数据多线程的存入数据库中，将持久化到数据库中的数据再从B中删除即可。这里就需要数据库层面sql再次对insert的数据进行重复控制，将插入到数据库与已存在数据库中的数据进行重复控制。(zset 是根据score参数来判定排序顺序，且存入的数据是不重复的，因此可以根据业务来确定score值，如果是根据创建时间排序，socre就可以存入创建时间字段的时间戳，zrange 命令从小到大排序，zrevrange 命令从大到小排序)
如果批量导入100w+的数据，存在的技术难点：
1）一次读取加载到内存会OOM；
2）调用接口保存一次传输数据量大，网络传输压力大；
3）一句SQL批量插入，对数据库压力大，如果同时操作该表，会造成死锁情况；
4）使用excel会造成大量的繁琐操作，由于数据不可磁盘分区操作，一次性读入会导致1）问题。
解决：
1）将文件以流的形式存入磁盘中，然后通过多线程去分区读取（使用FileChannel、RandomAccessFile实现）；
2）根据分区读取的内容数量进行数据库连接的调用，因此不会造成网络传输压力大的问题；
3）分批插入数据到数据库，就不会造成数据库压力大；
4）提示用户将excel保存为csv格式，使用csv的优点在于，一条数据就是一行有利于多线程分区读取文件，不会造成一条数据被分成两部分。
用到文件内存映射。
需要注意的是，如果数据量小的话，不适宜这样做，应为初始化MappedByteBuffer会比较耗时间，因此可以根据文件大小，来判断使用哪种导入方式。
4.0.0
com.turbo
BatchBigFile
1.0-SNAPSHOT
8
8
org.projectlombok
lombok
1.18.16
org.apache.commons
commons-lang3
3.12.0
@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class Person {
private String name;
private String age;
private String gender;
}
/**
-
业务处理接口
/
public interface IHandle {
/*- 用于处理业务
- @param line 每行的数据
*/
void handle(String line);
/**
- 用于业务处理
- @param personSet 集合
*/
void handleSet(Set personSet);
}
package com.turbo;
import lombok.*;
import lombok.experimental.Accessors;
import org.apache.commons.lang3.StringUtils;
import java.io.;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.;
import java.util.concurrent.atomic.AtomicLong;
public class BigFileReader {
private final byte newLineByte = ‘\n’;
private final byte enterByte = ‘\r’;
private final int threadSize;
private final long fileLength;
private final int bufferSize;
private final String charSet;
private final IHandle ihandle;
private RandomAccessFile rAccessFile;
private final ExecutorService executorService;
private final Set startEndPairs;
/** 性能测试 */
private CyclicBarrier cyclicBarrier;
private final AtomicLong countLine = new AtomicLong(0L);
public BigFileReader(File file, Integer bufferSize, String charSet, Integer threadSize, IHandle handle) {
this.fileLength = file.length();
this.bufferSize = bufferSize;
this.charSet = charSet;
this.threadSize = threadSize;
this.ihandle = handle;
try {
this.rAccessFile = new RandomAccessFile(file, "r");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
this.executorService = new ThreadPoolExecutor(threadSize,
threadSize,
0,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(threadSize),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
this.startEndPairs = new HashSet<>();
}
public void start(){
long perSize = this.fileLength / threadSize;
try {
calculateStartEnd(0, perSize);
} catch (IOException e) {
e.printStackTrace();
}
// 性能测试开始 */
final long startTime = System.currentTimeMillis();
cyclicBarrier = new CyclicBarrier(startEndPairs.size(), () -> {
System.out.println("use time: " + (System.currentTimeMillis() - startTime));
System.out.println("all line: " + countLine.get());
});
// 性能测试结束 */
for (StartEndPair pair : startEndPairs) {
executorService.execute(new SliceReaderTask(pair));
}
}
/**
* 计算分区读取的起始位置与结束位置
* 保证每个分区的结束位置都是换行或回车的位置，以避免一条数据分成两个部分到不同的线程中
* @author zwx
* @param start 起始位置
* @param perSize 平分处理数据的大小
* @throws IOException io异常
*/
private void calculateStartEnd(long start, long perSize) throws IOException {
if (start > fileLength-1){
return;
}
StartEndPair pair = new StartEndPair();
pair.start = start;
long endPosition = start + perSize - 1;
if (endPosition >= fileLength){
pair.end = fileLength - 1;
startEndPairs.add(pair);
return;
}
rAccessFile.seek(endPosition);
byte tmp = (byte)rAccessFile.read();
while (tmp != newLineByte && tmp != enterByte){
endPosition++;
if (endPosition >= fileLength - 1){
endPosition = fileLength - 1;
break;
}
rAccessFile.seek(endPosition);
tmp = (byte)rAccessFile.read();
}
pair.end = endPosition;
startEndPairs.add(pair);
calculateStartEnd(endPosition + 1, perSize);
}
/**
* 线程处理过程
* @author zwx
*/
private class SliceReaderTask implements Runnable {
private final long start;
private final long sliceSize;
private final byte[] readBuff;
// private Set personSet;
public SliceReaderTask(StartEndPair pair){
this.start = pair.start;
this.sliceSize = pair.end - pair.start + 1;
this.readBuff = new byte[bufferSize];
}
@Override
public void run() {
try {
MappedByteBuffer mapBuffer = rAccessFile.getChannel().map(FileChannel.MapMode.READ_ONLY, start, sliceSize);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
for (int offset = 0; offset < sliceSize; offset += bufferSize) {
int readLength;
if (offset + bufferSize <= sliceSize){
readLength = bufferSize;
}else {
readLength = (int)sliceSize - offset;
}
// 将内存映射中的数据读到readBuff中，从readBuff索引0开始存储到索引readLength
mapBuffer.get(readBuff, 0, readLength);
// 遍历readBuff 将每行的数据写入到bos中，然后传给IHandle处理
for (int i = 0; i < readLength; i++) {
byte tmp = readBuff[i];
if (tmp == newLineByte || tmp == enterByte){
handle(bos.toByteArray());
bos.reset();
}else {
bos.write(tmp);
}
}
}
if (bos.size() > 0){
handle(bos.toByteArray());
}
// 性能测试用，记录完成线程数 */
cyclicBarrier.await();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 如果要批量导入到数据库，起始这里的方法可以改成将每一行的数据都封装到对应的集合中
* 如：person实体，这里可以将每行数据封装到person实体中，然后add到personSet集合中
* 封装完成之后再调用IHandle，函数式接口去insert数据
* @author zwx
* @param bytes 每行数据 字节
* @throws UnsupportedEncodingException 编码异常
*/
private void handle(byte[] bytes) throws UnsupportedEncodingException {
String line;
if (charSet == null){
line = new String(bytes);
}else {
line = new String(bytes, charSet);
}
if (StringUtils.isNotBlank(line)){
ihandle.handle(line);
// 记录行数 */
countLine.incrementAndGet();
}
}
}
/**
* 该类用于存储每个分区的开始位置与结束位置
* @author zwx
*/
@Setter
@Getter
@ToString
@NoArgsConstructor
@AllArgsConstructor
private static class StartEndPair{
private Long start;
private Long end;
@Override
public int hashCode() {
final int prime = 11;
int result = 30;
result = prime * result + ((start == null) ? 0 : start.hashCode());
result = prime * result + ((end == null) ? 0 : end.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (obj instanceof StartEndPair){
StartEndPair objSe = (StartEndPair) obj;
return objSe.start.equals(this.start) && objSe.end.equals(this.end);
}
return false;
}
}
/**
* 构建一个bigFileReader
* @author zwx
*/
@Data
@NoArgsConstructor
@Accessors(chain = true)
public static class Builder{
private Integer bufferSize = 1024*1024;
private String charSet;
private Integer threadSize;
private IHandle handle;
private File file;
public Builder(String filePath, IHandle handle){
this.file = new File(filePath);
if (!this.file.exists()){
throw new IllegalArgumentException("文件不存在");
}
this.handle = handle;
}
public BigFileReader build(){
return new BigFileReader(this.file, this.bufferSize, this.charSet, this.threadSize, this.handle);
}
}
}
import java.util.Set;
/**
-
实现处理大文件
-
通过内存映射，多个线程分区读取文件内容，且每个线程
-
读取的分区结束都以换行符或者回车符结束。
-
特适合处理csv文件
*/
public class Main {public static void main(String[] args) {
BigFileReader.Builder builder = new BigFileReader.Builder(“D:/test.csv”, new IHandle() {@Override public void handle(String line) { String enComma = ","; String[] split = line.split(enComma); System.out.println(new Person().setName(split[0]).setAge(split[1]).setGender(split[2])); } @Override public void handleSet(SetpersonSet) { // 对其导入数据库操作 或者 其他操作 } }); // 线程数、缓存大小 根据实际业务情况来定 BigFileReader bigFileReader = builder.setThreadSize(6).setBufferSize(100).setCharSet("utf-8").build(); bigFileReader.start(); }
}