如何快速上传10G文件

如何快速上传10G文件

关于 10G 大文件上传问题，我会从「前端优化 - 后端架构 - 网络优化 - 异常保障」四个维度来设计完整方案，核心思路是「化整为零 + 并行加速 + 断点续传 + 秒传兜底」，下面我详细说明 👇

🚀 核心架构总览（一句话讲清）

将 10G 大文件切片成 N 个小文件块，前端并发上传多个块，后端接收后暂存，全部上传完成后合并成完整文件；同时支持断点续传和秒传功能，解决网络中断和重复上传问题。

关键技术点详解（面试必答）

1. 前端分片与并发控制 ⚡

• 分片大小：建议设置为5MB~20MB（太小会增加 HTTP 请求数，太大失败重试成本高）
• 并发数：控制在3~5 个并发（浏览器同源请求限制一般为 6 个）
• MD5 计算优化：使用SparkMD5库增量计算 MD5，避免一次性加载整个文件到内存导致浏览器崩溃
• 分片序号：给每个分片加上序号（如file_001、file_002），保证后端合并顺序正确

2. 后端分片接收与合并 📦

关于这个问题的底层原理和更多实战细节，我整理了一份《大厂面试手册》，包含大厂高频面试题、源码解析和性能调优案例。
关注公众号【Rain的Java大神之路】，回复“Java”即可免费领取，持续更新中。

推荐方案：MinIO 原生分片上传 + Redis 记录上传状态

MinIO 完全兼容 S3 协议，内置Multipart Upload接口，自动处理分片接收、合并和并发控制，开发成本极低。

3. 断点续传实现 🔄

• 上传中断后，前端向后端发送文件 MD5，后端返回已上传的分片序号列表
• 前端只上传未上传的分片，避免重复上传
• 后端使用Redis Hash存储上传状态：key=文件MD5，field=分片序号，value=上传状态

4. 秒传功能（用户体验杀手级优化） ✨

• 上传前先计算文件 MD5，向后端查询是否存在相同 MD5 的文件
• 如果存在，直接返回上传成功，无需传输任何数据
• 对于企业内部场景，秒传率可以达到30% 以上，极大提升用户体验

🛠️ Java 后端核心代码示例

// 分片上传接口
@PostMapping("/upload/chunk")
public ResponseEntity uploadChunk(
        @RequestParam String fileMd5,
        @RequestParam Integer chunkNumber,
        @RequestParam Integer totalChunks,
        @RequestParam MultipartFile chunk) {
    
    // 1. 检查分片是否已上传
    if (redisTemplate.opsForHash().hasKey(fileMd5, chunkNumber.toString())) {
        return ResponseEntity.ok(ChunkUploadResult.success("分片已上传"));
    }
    
    // 2. 保存分片到MinIO
    String chunkObjectName = String.format("chunks/%s/%d", fileMd5, chunkNumber);
    minioClient.putObject(
        PutObjectArgs.builder()
            .bucket("file-upload")
            .object(chunkObjectName)
            .stream(chunk.getInputStream(), chunk.getSize(), -1)
            .build()
    );
    
    // 3. 记录分片上传状态
    redisTemplate.opsForHash().put(fileMd5, chunkNumber.toString(), "uploaded");
    
    // 4. 检查是否所有分片都已上传
    Long uploadedChunks = redisTemplate.opsForHash().size(fileMd5);
    if (uploadedChunks == totalChunks) {
        // 异步合并文件
        fileMergeService.mergeChunksAsync(fileMd5, totalChunks);
    }
    
    return ResponseEntity.ok(ChunkUploadResult.success("分片上传成功"));
}

异常处理与优化点

1. 网络超时：设置合理的超时时间（30s~60s），失败自动重试 3 次
2. 分片丢失：合并前校验所有分片的 MD5，缺失则通知前端重传
3. 内存溢出：后端合并文件时使用流式处理，避免一次性加载所有分片到内存
4. 磁盘空间不足：设置分片过期时间（24 小时），自动清理未合并的分片
5. 大文件合并慢：使用硬链接或零拷贝技术合并文件，减少 IO 操作

📈 性能数据参考

注：以上数据基于国内普通家庭宽带（100Mbps~500Mbps），实际速度取决于用户网络环境。

🎯 面试官追问预判与回答

问：为什么不用 FTP 上传？

答：FTP 协议穿透性差，很多企业防火墙会屏蔽 FTP 端口；而且 FTP 不支持断点续传和秒传，用户体验差。

问：MD5 碰撞怎么办？

答：可以使用SHA-256替代 MD5，或者结合文件大小和文件名进行双重校验，碰撞概率几乎为 0。

问：如何支持超大文件（100GB 以上）？

答：可以将分片大小调整为50MB_{100MB**，同时增加并发数到**6}8 个；后端使用分布式对象存储集群，避免单机瓶颈。

💻 核心代码与技术亮点（面试必背）

🌟 前端核心代码（2 个关键亮点）

1. WebWorker+SparkMD5 增量计算 MD5（解决浏览器崩溃问题）

技术亮点：不一次性加载整个文件到内存，使用 WebWorker 多线程计算，不阻塞 UI 线程，支持 100GB + 文件 MD5 计算，内存占用稳定在 50MB 以内。

// 主线程：调用WebWorker计算MD5
function calculateFileMD5(file) {
  return new Promise((resolve) => {
    const worker = new Worker('/js/md5-worker.js');
    worker.postMessage({ file });
    worker.onmessage = (e) => {
      worker.terminate();
      resolve(e.data.md5);
    };
  });
}

// md5-worker.js：独立线程增量计算MD5
importScripts('https://cdn.jsdelivr.net/npm/spark-md5@3.0.2/spark-md5.min.js');

self.onmessage = async (e) => {
  const file = e.data.file;
  const chunkSize = 2 * 1024 * 1024; // 2MB切片计算
  const chunks = Math.ceil(file.size / chunkSize);
  const spark = new SparkMD5.ArrayBuffer();
  let currentChunk = 0;

  const fileReader = new FileReader();
  fileReader.onload = (e) => {
    spark.append(e.target.result);
    currentChunk++;
    if (currentChunk < chunks) {
      loadNext();
    } else {
      self.postMessage({ md5: spark.end() });
    }
  };

  function loadNext() {
    const start = currentChunk * chunkSize;
    const end = Math.min(start + chunkSize, file.size);
    fileReader.readAsArrayBuffer(file.slice(start, end));
  }
  loadNext();
};

2. 并发控制 + 指数退避失败重试（解决网络不稳定问题）

技术亮点：基于 Promise 实现并发池，动态调整并发数；失败重试采用指数退避算法，避免网络拥塞。

class ConcurrentUploader {
  constructor(concurrency=4) {
    this.concurrency=concurrency;
    this.running=0;
    this.queue=[];
  }

  addTask(task) {
    this.queue.push(task);
    this.run();
  }

  run() {
    while (this.running0) {
      const task=this.queue.shift();
      this.running++;
      task()
        .catch((err) => {
          // 指数退避重试：最多3次，间隔1s/2s/4s
          if (task.retryCount===undefined) task.retryCount=0;
          if (task.retryCount<3) {
            task.retryCount++;
            setTimeout(() => {
              this.queue.unshift(task);
              this.run();
            }, Math.pow(2, task.retryCount)*1000);
          }
        })
        .finally(() => {
          this.running--;
          this.run();
        });
    }
  }
}

// 使用示例
const uploader=new ConcurrentUploader(4);
chunks.forEach((chunk, index) => {
  uploader.addTask(() => uploadChunk(fileMd5, index, chunk));
});

🌟 后端核心代码（3 个关键亮点）

1. 分片级 MD5 完整性校验（解决分片损坏问题）

技术亮点：不仅校验整个文件的 MD5，还校验每个分片的 MD5，只重传损坏的分片，无需重传整个文件。

@PostMapping("/upload/chunk")
public ResponseEntity uploadChunk(
        @RequestParam String fileMd5,
        @RequestParam Integer chunkNumber,
        @RequestParam String chunkMd5, // 前端传过来的分片MD5
        @RequestParam MultipartFile chunk) {

    // 1. 原子检查分片是否已上传
    String redisKey="upload:status:"+fileMd5;
    if (redisTemplate.opsForHash().hasKey(redisKey, chunkNumber.toString())) {
        return ResponseEntity.ok(ChunkUploadResult.success("分片已上传"));
    }

    // 2. 校验分片MD5完整性
    String calculatedChunkMd5=DigestUtils.md5Hex(chunk.getInputStream());
    if (!calculatedChunkMd5.equals(chunkMd5)) {
        return ResponseEntity.badRequest().body(ChunkUploadResult.fail("分片损坏，请重传"));
    }

    // 3. 保存分片到MinIO
    String chunkObjectName=String.format("chunks/%s/%d", fileMd5, chunkNumber);
    minioClient.putObject(
        PutObjectArgs.builder()
            .bucket("file-upload")
            .object(chunkObjectName)
            .stream(chunk.getInputStream(), chunk.getSize(), -1)
            .build()
    );

    // 4. 原子记录分片状态
    redisTemplate.opsForHash().put(redisKey, chunkNumber.toString(), chunkMd5);
    redisTemplate.expire(redisKey, 24, TimeUnit.HOURS); // 24小时过期

    // 5. 检查是否所有分片都已上传
    Long uploadedChunks=redisTemplate.opsForHash().size(redisKey);
    if (uploadedChunks==totalChunks) {
        // 发送消息触发异步合并
        rabbitTemplate.convertAndSend("file-merge-queue", fileMd5);
    }

    return ResponseEntity.ok(ChunkUploadResult.success("分片上传成功"));
}

2. 分布式锁 + 异步消息合并（解决高并发重复合并问题）

技术亮点：使用 RabbitMQ 异步解耦合并操作，避免同步合并阻塞接口；使用 Redisson 分布式锁防止多个实例同时合并同一个文件。

@Component
@RabbitListener(queues="file-merge-queue")
public class FileMergeConsumer {

    @Autowired
    private RedissonClient redissonClient;
    @Autowired
    private MinioClient minioClient;

    @RabbitHandler
    public void mergeFile(String fileMd5) {
        RLock lock=redissonClient.getLock("upload:merge:"+fileMd5);
        try {
            // 尝试获取锁，最多等待10秒，锁自动释放时间30分钟
            if (lock.tryLock(10, 1800, TimeUnit.SECONDS)) {
                // 1. 从Redis获取所有分片信息
                String redisKey="upload:status:"+fileMd5;
                Map chunkStatus=redisTemplate.opsForHash().entries(redisKey);
                int totalChunks=chunkStatus.size();

                // 2. 零拷贝合并文件（见下文）
                String finalObjectName="files/"+fileMd5;
                zeroCopyMerge(fileMd5, totalChunks, finalObjectName);

                // 3. 校验整体MD5
                String finalMd5=DigestUtils.md5Hex(minioClient.getObject(
                    GetObjectArgs.builder().bucket("file-upload").object(finalObjectName).build()
                ));
                if (!finalMd5.equals(fileMd5)) {
                    throw new RuntimeException("文件合并失败，MD5不匹配");
                }

                // 4. 删除临时分片和Redis状态
                minioClient.removeObjects(
                    RemoveObjectsArgs.builder()
                        .bucket("file-upload")
                        .objects(IntStream.range(0, totalChunks)
                            .mapToObj(i -> "chunks/"+fileMd5+"/"+i)
                            .collect(Collectors.toList()))
                        .build()
                );
                redisTemplate.delete(redisKey);
            }
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

3. NIO 零拷贝合并文件（解决大文件合并 IO 瓶颈）

技术亮点：使用 Java NIO 的transferTo方法实现零拷贝，避免内核态和用户态之间的多次数据复制，合并速度提升 10 倍以上，CPU 占用降低 80%。

private void zeroCopyMerge(String fileMd5, int totalChunks, String finalObjectName) throws Exception {
    // 1. 创建最终文件的输出流
    ObjectWriteResponse finalFile=minioClient.putObject(
        PutObjectArgs.builder()
            .bucket("file-upload")
            .object(finalObjectName)
            .stream(null, -1, 10*1024*1024) // 10MB缓冲区
            .build()
    );

    // 2. 逐个合并分片，使用零拷贝
    try (FileChannel outChannel=((FileOutputStream) finalFile).getChannel()) {
        for (int i=0; i

// 1. Web Worker 计算 SHA-256（不卡主线程）
// hash.worker.js
self.onmessage = async (e) => {
  const file = e.data;
  const chunkSize = 5 * 1024 * 1024; // 5MB 分片
  const chunks = Math.ceil(file.size / chunkSize);
  const hashBuffer = await crypto.subtle.digest('SHA-256', await file.slice(0, chunkSize).arrayBuffer());
  // 实际生产会遍历所有分片做增量哈希，这里简化为首片演示
  const hashHex = Array.from(new Uint8Array(hashBuffer)).map(b => b.toString(16).padStart(2, '0')).join('');
  self.postMessage({ hash: hashHex, totalChunks: chunks });
};

// 2. 并发上传池控制（最多6个并发）
async function uploadFile(file) {
  const { hash, totalChunks } = await computeHashInWorker(file);
  // 请求 init 接口
  const { uploadId, missingChunks } = await initUpload({ fileHash: hash, totalSize: file.size });
  if (missingChunks.length === 0) return { url: uploadId.url }; // 秒传

  // 并发补传缺失分片，收集 ETag
  const pool = new PromisePool(6); // 自定义并发控制类
  const partResults = [];
  for (const partNum of missingChunks) {
    const task = uploadPart(file, partNum, uploadId);
    pool.add(task.then(etag => partResults.push({ partNum, etag })));
  }
  await pool.drain(); // 等待所有上传完成

  // 通知服务端合并
  return await completeUpload({ uploadId, parts: partResults });
}

// InitUpload 接口核心逻辑
@PostMapping("/api/file/initUpload")
public InitResult initUpload(@RequestBody InitRequest req) {
    String hash = req.getFileHash();
    long size = req.getTotalSize();

    // 1. 秒传检测：查询文件是否已存在完整对象
    if (ossClient.doesObjectExist(BUCKET, hash)) {
        return InitResult.quick(ossClient.generatePresignedUrl(BUCKET, hash, Duration.ofHours(1)));
    }

    // 2. 断点续传：从 Redis 获取已有上传记录
    String uploadId = redisTemplate.opsForValue().get("upload:hash:" + hash);
    if (uploadId == null) {
        // 首次上传，请求 OSS 创建新的分片上传任务
        uploadId = ossClient.initiateMultipartUpload(BUCKET, hash).getUploadId();
    }

    // 3. 计算缺失分片列表
    Set doneParts = redisTemplate.opsForSet()
            .members("upload:parts:" + uploadId).stream()
            .map(Integer::parseInt).collect(Collectors.toSet());
    List missingChunks = IntStream.rangeClosed(1, (int) Math.ceil(size / (double) CHUNK_SIZE))
            .filter(i -> !doneParts.contains(i))
            .boxed().collect(Collectors.toList());

    // 4. 为缺失分片批量生成预签名上传 URL
    List urls = new ArrayList<>();
    for (int partNum : missingChunks) {
        String url = ossClient.generatePresignedUrl(BUCKET, hash, partNum, uploadId, Duration.ofMinutes(10));
        urls.add(new PartUploadUrl(partNum, url));
    }

    // 5. 写 Redis，设置24小时过期
    redisTemplate.opsForValue().set("upload:hash:" + hash, uploadId, 24, TimeUnit.HOURS);
    return InitResult.resume(uploadId, urls);
}