SpringBoot中MinIO处理大文件上传的避坑(含异步优化)

<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.5.2</version>
</dependency>

minio:
  endpoint: http://127.0.0.1:9000
  access-key: your-access-key
  secret-key: your-secret-key
  bucket-name: upload-bucket
  secure: false

@Configuration
@ConfigurationProperties(prefix = "minio")
public class MinioConfig {
    private String endpoint;
    private String accessKey;
    private String secretKey;
    private String bucketName;
    private boolean secure;
    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder()
                .endpoint(endpoint)
                .credentials(accessKey, secretKey)
                .build();
    }
}

private static final int PART_SIZE = 10 * 1024 * 1024; // 10MB
public String uploadInChunks(MultipartFile file) throws IOException {
    InputStream inputStream = file.getInputStream();
    long fileSize = file.getSize();
    int partCount = (int) Math.ceil((double) fileSize / PART_SIZE);
    List<String> partEtags = new ArrayList<>();
    for (int i = 0; i < partCount; i++) {
        long startPos = i * PART_SIZE;
        long partLength = Math.min(PART_SIZE, fileSize - startPos);
        InputStream partStream = new BoundedInputStream(inputStream, partLength);
        String partEtag = uploadPart(partStream, i+1);
        partEtags.add(partEtag);
    }
    return completeMultipartUpload(partEtags);
}

try (InputStream mainStream = file.getInputStream()) {
    byte[] buffer = new byte[PART_SIZE];
    while ((bytesRead = mainStream.read(buffer)) != -1) {
        try (InputStream partStream = new ByteArrayInputStream(buffer, 0, bytesRead)) {
            // 上传逻辑
        }
    }
}

public String uploadParallel(MultipartFile file) throws Exception {
    List<CompletableFuture<String>> futures = new ArrayList<>();
    InputStream inputStream = file.getInputStream();
    int partNumber = 1;
    byte[] buffer = new byte[PART_SIZE];
    int bytesRead;
    while ((bytesRead = inputStream.read(buffer)) != -1) {
        final int currentPart = partNumber++;
        final byte[] partData = Arrays.copyOf(buffer, bytesRead);
        futures.add(CompletableFuture.supplyAsync(() -> {
            try (InputStream partStream = new ByteArrayInputStream(partData)) {
                return uploadPart(partStream, currentPart);
            } catch (IOException e) {
                throw new CompletionException(e);
            }
        }, executorService));
    }
    CompletableFuture<Void> allDone = CompletableFuture.allOf(
        futures.toArray(new CompletableFuture[0])
    );
    return allDone.thenApply(v -> 
        futures.stream()
            .map(CompletableFuture::join)
            .collect(Collectors.toList())
    ).thenApply(this::completeMultipartUpload).join();
}

@Bean
public ExecutorService uploadExecutor() {
    int cores = Runtime.getRuntime().availableProcessors();
    return new ThreadPoolExecutor(
        cores * 2,       // 核心线程数
        cores * 4,       // 最大线程数
        60L,            // 空闲线程存活时间
        TimeUnit.SECONDS,
        new LinkedBlockingQueue<>(100), // 任务队列
        new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
    );
}

location /minio/ {
    proxy_pass http://minio-server:9000;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

public String resumeUpload(MultipartFile file, String fileMd5) {
    String redisKey = "upload:progress:" + fileMd5;
    Map<Object, Object> progress = redisTemplate.opsForHash().entries(redisKey);
    if (progress.isEmpty()) {
        // 全新上传
        initializeUploadProgress(fileMd5, file.getSize());
    } else {
        // 断点续传
        resumeFromProgress(progress);
    }
    // ...上传逻辑
}