Spring Boot实现分片上传、断点续传与进度条功能

# Spring Boot 实现分片上传、断点续传与进度条  
## —— 支持 MinIO / RustFS / SeaweedFS 可配置切换
在大文件上传场景下，传统单次上传存在明显问题：
- 文件过大，失败后需要整体重传
- 网络不稳定，用户体验差
- 无法展示上传进度
本文基于 **Spring Boot**，实现一套**生产可用**的大文件上传方案，支持：
- 分片上传
- 断点续传
- 上传进度查询
- MinIO / RustFS / SeaweedFS / 本地存储
- 通过 yml 配置文件切换存储类型
---
## 一、整体架构设计
系统整体采用「接口隔离 + 策略模式」设计：

**核心思想：上传逻辑与底层存储解耦。**
---
## 二、统一配置设计
### 1. 存储类型切换
```yaml
file:
  path: file/
  prefix: pre
  domain: domain/
  storage:
    type: minio   # minio / rustfs / seaweedfs / local

minio:
  url: http://localhost:9000
  accessKey: minioadmin
  secretKey: minioadmin123
  bucketName: xxx

rustfs:
  url: http://localhost:9000
  accessKey: rustfsadmin
  secretKey: rustfsadmin
  bucketName: xxx

seaweedfs:
  url: http://127.0.0.1:8333
  accessKey: weed
  secretKey: weed
  bucketName: xxx

file
├── chunk_0
├── chunk_1
├── chunk_2
└── chunk_n

POST /file/chunk/upload

GET /file/chunk/uploaded?guid=xxx

[0,1,3,5]

进度 = 已上传分片数 / 总分片数 × 100%

{
  "uploaded": 6,
  "total": 10,
  "percent": 60
}

public interface StorageService {
    void uploadChunk(String path, InputStream inputStream);
    boolean exists(String path);
    List<Integer> listChunks(String prefix);
    void mergeChunks(String chunkPrefix, String targetPath, int totalChunk);
    void deleteChunks(String chunkPrefix);
}

@Slf4j
public class MinioStorageService implements StorageService {
    private final MinioClient minioClient;
    private final String bucket;
    public MinioStorageService(MinioClient client, String bucket) {
        this.minioClient = client;
        this.bucket = bucket;
    }
    @Override
    public void uploadChunk(String path, InputStream inputStream) {
        try {
            minioClient.putObject(
                PutObjectArgs.builder()
                    .bucket(bucket)
                    .object(path)
                    .stream(inputStream, -1, 5 * 1024 * 1024)
                    .build()
            );
        } catch (Exception e) {
            throw new RuntimeException("分片上传失败", e);
        }
    }
    @Override
    public boolean exists(String path) {
        try {
            minioClient.statObject(
                StatObjectArgs.builder()
                    .bucket(bucket)
                    .object(path)
                    .build()
            );
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    @Override
    public List<Integer> listChunks(String prefix) {
        List<Integer> chunks = new ArrayList<>();
        Iterable<Result<Item>> results =
            minioClient.listObjects(
                ListObjectsArgs.builder()
                    .bucket(bucket)
                    .prefix(prefix)
                    .build()
            );
        for (Result<Item> r : results) {
            String name = r.get().objectName();
            chunks.add(Integer.parseInt(
                name.substring(name.lastIndexOf("_") + 1)));
        }
        return chunks;
    }
    @Override
    public void mergeChunks(String chunkPrefix,
                            String targetPath,
                            int totalChunk) {
        try {
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            for (int i = 0; i < totalChunk; i++) {
                InputStream in = minioClient.getObject(
                    GetObjectArgs.builder()
                        .bucket(bucket)
                        .object(chunkPrefix + "/chunk_" + i)
                        .build()
                );
                IOUtils.copy(in, out);
            }
            uploadChunk(
                targetPath,
                new ByteArrayInputStream(out.toByteArray()));
        } catch (Exception e) {
            throw new RuntimeException("分片合并失败", e);
        }
    }
    @Override
    public void deleteChunks(String chunkPrefix) {
        // 可按需实现批量删除
    }
}

@Service
public class FileUploadServiceImpl implements FileUploadService {
    @Autowired
    private StorageService storageService;
    @Override
    public void uploadChunk(ChunkUploadDTO dto) throws IOException {
        String path = dto.getGuid() + "/chunk_" + dto.getChunkIndex();
        if (storageService.exists(path)) {
            return;
        }
        storageService.uploadChunk(
            path, dto.getFile().getInputStream());
    }
    @Override
    public List<Integer> uploadedChunks(String guid) {
        return storageService.listChunks(guid + "/");
    }
    @Override
    public void merge(String guid, int totalChunk) {
        storageService.mergeChunks(
            guid, guid + ".final", totalChunk);
        storageService.deleteChunks(guid + "/");
    }
}

@RestController
@RequestMapping("/file/chunk")
public class FileUploadController {
    @Autowired
    private FileUploadService fileUploadService;
    @PostMapping("/upload")
    public void upload(ChunkUploadDTO dto) throws IOException {
        fileUploadService.uploadChunk(dto);
    }
    @GetMapping("/uploaded")
    public List<Integer> uploaded(@RequestParam String guid) {
        return fileUploadService.uploadedChunks(guid);
    }
    @PostMapping("/merge")
    public void merge(@RequestParam String guid,
                      @RequestParam Integer totalChunk) {
        fileUploadService.merge(guid, totalChunk);
    }
}