Java 集成 MinIO：大文件分片上传与预签名 URL 实战

这种方式既保证了安全性（URL 有时效、可限制操作类型），又提升了性能。

AWS 官方对预签名 URL 的说明可参考：https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-presigned-url.html

整体架构设计

为了兼顾大文件支持与安全性，我们采用 分片上传 + 预签名 URL 的组合方案。整体流程如下：

1. 前端发起初始化请求（文件名、大小）。
2. 后端创建分片上传任务（CreateMultipartUpload），返回 uploadId。
3. 前端请求第 N 个分片的预签名 URL。
4. 后端生成并返回预签名 URL。
5. 前端直接上传分片至 MinIO（PUT 到预签名 URL）。
6. 前端收集分片 ETag 和序号，上报后端。
7. 后端调用 CompleteMultipartUpload 合并分片。
8. 返回最终文件访问地址。

该架构实现了：

• 前端直传：减少后端带宽压力。
• 分片容错：支持断点续传。
• 权限控制：所有关键操作由后端发起，前端仅持有临时凭证。
• 状态同步：后端掌握完整上传状态，便于后续业务处理。

环境准备

1. 启动 MinIO 服务

你可以通过 Docker 快速启动 MinIO：

docker run -p 9000:9000 -p 9001:9001 \
  -e "MINIO_ROOT_USER=minioadmin" \
  -e "MINIO_ROOT_PASSWORD=minioadmin" \
  minio/minio server /data --console-address ":9001"

• 9000：API 端口（S3 兼容接口）
• 9001：Web 控制台端口

访问 http://localhost:9001 可进入管理界面。

2. 创建 Bucket

登录控制台，创建一个名为 file-upload-bucket 的存储桶（Bucket），并设置为私有（Private）。

3. Java 项目依赖

使用 Spring Boot 作为基础框架，添加 MinIO Java SDK：

<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.5.7</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

注意：MinIO Java SDK 版本建议使用 8.x 以上，以获得完整的分片上传支持。

核心代码实现

我们将构建一个 FileUploadService，封装 MinIO 的分片上传逻辑。

1. MinIO 客户端配置

首先，定义 MinIO 客户端 Bean：

@Configuration
public class MinioConfig {
    @Value("${minio.endpoint}")
    private String endpoint;
    
    @Value("${minio.access-key}")
    private String accessKey;
    
    @Value("${minio.secret-key}")
    private String secretKey;
    
    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder()
                .endpoint(endpoint)
                .credentials(accessKey, secretKey)
                .build();
    }
}

application.yml 配置：

minio:
  endpoint: http://localhost:9000
  access-key: minioadmin
  secret-key: minioadmin

2. 初始化分片上传

当用户开始上传一个大文件时，前端先调用 /initiate 接口，后端创建分片上传任务：

@RestController
@RequestMapping("/api/upload")
@RequiredArgsConstructor
public class FileUploadController {
    private final FileUploadService fileUploadService;

    @PostMapping("/initiate")
    public ResponseEntity<InitiateResponse> initiateUpload(@RequestBody InitiateRequest request) {
        String uploadId = fileUploadService.initiateMultipartUpload(request.getFileName(), request.getBucket());
        return ResponseEntity.ok(new InitiateResponse(uploadId));
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class InitiateRequest {
    private String fileName;
    private String bucket; // 可选，默认使用配置的 bucket
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class InitiateResponse {
    private String uploadId;
}

对应的 Service 方法：

@Service
@RequiredArgsConstructor
public class FileUploadService {
    private final MinioClient minioClient;
    private final String defaultBucket = "file-upload-bucket";

    public String initiateMultipartUpload(String fileName, String bucket) {
        if (bucket == null || bucket.isEmpty()) {
            bucket = defaultBucket;
        }
        try {
            CreateMultipartUploadResponse response = minioClient.createMultipartUpload(
                    CreateMultipartUploadArgs.builder()
                            .bucket(bucket)
                            .object(fileName)
                            .build());
            return response.result().uploadId();
        } catch (Exception e) {
            throw new RuntimeException("Failed to initiate multipart upload", e);
        }
    }
}

此方法调用 MinIO 的 createMultipartUpload，返回一个唯一的 uploadId，用于标识本次上传会话。

3. 生成分片预签名 URL

前端拿到 uploadId 后，按需请求每个分片的上传 URL。例如，上传第 1 个分片：

@PostMapping("/presign-part")
public ResponseEntity<PresignPartResponse> presignPart(@RequestBody PresignPartRequest request) {
    String url = fileUploadService.getPresignedUrlForPart(
            request.getBucket(), request.getFileName(), request.getUploadId(), request.getPartNumber());
    return ResponseEntity.ok(new PresignPartResponse(url));
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class PresignPartRequest {
    private String bucket;
    private String fileName;
    private String uploadId;
    private int partNumber; // 从 1 开始
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class PresignPartResponse {
    private String url;
}

Service 实现：

public String getPresignedUrlForPart(String bucket, String object, String uploadId, int partNumber) {
    if (bucket == null || bucket.isEmpty()) {
        bucket = defaultBucket;
    }
    try {
        // 构建分片上传的请求参数
        Map<String, String> extraQueryParams = new HashMap<>();
        extraQueryParams.put("uploadId", uploadId);
        extraQueryParams.put("partNumber", String.valueOf(partNumber));

        // 生成预签名 URL，有效期 5 分钟
        return minioClient.getPresignedObjectUrl(
                GetPresignedObjectUrlArgs.builder()
                        .method(Method.PUT)
                        .bucket(bucket)
                        .object(object)
                        .expiry(5 * 60) // 5 minutes
                        .extraQueryParams(extraQueryParams)
                        .build());
    } catch (Exception e) {
        throw new RuntimeException("Failed to generate presigned URL for part " + partNumber, e);
    }
}

关键点：

• 通过 extraQueryParams 添加 uploadId 和 partNumber，这是 S3 分片上传协议的要求。
• expiry 设置为 5 分钟，确保安全性。

4. 前端上传分片

前端收到预签名 URL 后，直接使用 fetch 或 axios 上传分片：

// 伪代码
const uploadPart = async (file, start, end, partNumber, presignedUrl) => {
    const blob = file.slice(start, end);
    const response = await fetch(presignedUrl, {
        method: 'PUT',
        body: blob,
        headers: { 'Content-Type': 'application/octet-stream' }
    });
    const etag = response.headers.get('ETag'); // MinIO 返回的 ETag
    return { partNumber, etag };
};

注意：ETag 是 MinIO 对每个分片计算的 MD5 值，后续合并时必须提供。

5. 收集分片信息并完成上传

前端上传完所有分片后，将每个分片的 partNumber 和 ETag 发送给后端，触发合并操作：

@PostMapping("/complete")
public ResponseEntity<CompleteResponse> completeUpload(@RequestBody CompleteRequest request) {
    String objectUrl = fileUploadService.completeMultipartUpload(
            request.getBucket(), request.getFileName(), request.getUploadId(), request.getParts());
    return ResponseEntity.ok(new CompleteResponse(objectUrl));
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class CompleteRequest {
    private String bucket;
    private String fileName;
    private String uploadId;
    private List<Part> parts; // 包含 partNumber 和 etag
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class Part {
    private int partNumber;
    private String etag;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class CompleteResponse {
    private String objectUrl;
}

Service 实现合并逻辑：

public String completeMultipartUpload(String bucket, String object, String uploadId, List<Part> parts) {
    if (bucket == null || bucket.isEmpty()) {
        bucket = defaultBucket;
    }
    try {
        // 将前端传来的 Part 转换为 MinIO SDK 所需的 Part 类型
        List<Part> minioParts = parts.stream()
                .map(p -> new Part(p.partNumber, p.etag.replace("\"", ""))) // 移除 ETag 的引号
                .sorted(Comparator.comparingInt(Part::partNumber)) // 必须按 partNumber 升序
                .collect(Collectors.toList());

        CompleteMultipartUploadResponse response = minioClient.completeMultipartUpload(
                CompleteMultipartUploadArgs.builder()
                        .bucket(bucket)
                        .object(object)
                        .uploadId(uploadId)
                        .parts(minioParts)
                        .build());

        // 构造最终的文件访问 URL
        return String.format("%s/%s/%s", minioClient.getRegion(), bucket, object);
    } catch (Exception e) {
        // 如果合并失败，可选择 abort 上传以清理临时分片
        try {
            minioClient.abortMultipartUpload(AbortMultipartUploadArgs.builder()
                    .bucket(bucket).object(object).uploadId(uploadId).build());
        } catch (Exception abortEx) {
            // 记录日志
        }
        throw new RuntimeException("Failed to complete multipart upload", e);
    }
}

重要细节：

• ETag 处理：HTTP 响应头中的 ETag 通常带双引号（如 "abc123"），需去除后再传给 MinIO。
• 排序要求：S3 协议要求 parts 必须按 partNumber 升序排列，否则合并失败。
• 异常清理：若合并失败，应调用 abortMultipartUpload 删除已上传的分片，避免垃圾数据。

6. （可选）获取文件访问 URL

如果需要生成文件的下载链接（例如用于预览），可再生成一个 GET 类型的预签名 URL：

public String getDownloadUrl(String bucket, String object, int expirySeconds) {
    if (bucket == null || bucket.isEmpty()) {
        bucket = defaultBucket;
    }
    try {
        return minioClient.getPresignedObjectUrl(
                GetPresignedObjectUrlArgs.builder()
                        .method(Method.GET)
                        .bucket(bucket)
                        .object(object)
                        .expiry(expirySeconds)
                        .build());
    } catch (Exception e) {
        throw new RuntimeException("Failed to generate download URL", e);
    }
}

分片策略与前端配合

分片大小的选择直接影响上传效率和内存使用。常见策略：

• 固定分片大小：如 5MB、10MB。MinIO 要求每个分片 ≥ 5MB（除最后一个）。
• 动态分片：根据文件总大小调整。例如：
  • < 100MB：不分片，直接上传。
  • 100MB ~ 1GB：每片 10MB。

  • 1GB：每片 50MB 或 100MB。

前端需实现文件切片逻辑：

function calculateChunks(fileSize, chunkSize = 10 * 1024 * 1024) {
    const chunks = [];
    let start = 0;
    let partNumber = 1;
    while (start < fileSize) {
        const end = Math.min(start + chunkSize, fileSize);
        chunks.push({ start, end, partNumber });
        start = end;
        partNumber++;
    }
    return chunks;
}

⚠️ 注意：最后一个分片可以小于 5MB，但其他分片必须 ≥ 5MB，否则 MinIO 会拒绝。

异常处理与重试机制

网络环境复杂，上传过程中可能出现各种异常：

• 分片上传超时
• 预签名 URL 过期
• ETag 不匹配
• 服务端错误

前端重试策略

• 对每个分片上传实现指数退避重试（如最多 3 次）。
• 若预签名 URL 过期，重新向后端请求新的 URL。
• 记录已成功上传的分片，避免重复上传。

后端清理机制

长时间未完成的分片上传会占用存储空间。MinIO 提供了生命周期管理（Lifecycle Management）功能，可自动清理过期的未完成上传。

你也可以在后端定期扫描并清理：

public void cleanupStaleUploads(String bucket, Duration maxAge) {
    try {
        ListMultipartUploadsResponse response = minioClient.listMultipartUploads(
                ListMultipartUploadsArgs.builder().bucket(bucket).build());
        Instant now = Instant.now();
        for (Result<MultipartUpload> upload : response.result().uploads()) {
            MultipartUpload u = upload.get();
            if (Duration.between(u.initiated().toInstant(), now).compareTo(maxAge) > 0) {
                minioClient.abortMultipartUpload(AbortMultipartUploadArgs.builder()
                        .bucket(bucket).object(u.object()).uploadId(u.uploadId()).build());
            }
        }
    } catch (Exception e) {
        // log error
    }
}

可配合 Spring 的 @Scheduled 定时任务每天执行一次。

安全性考量

虽然预签名 URL 提供了便利，但也带来安全风险，需谨慎处理：

1. URL 有效期

• 始终设置较短的有效期（如 5 分钟）。
• 不要将 URL 永久暴露或缓存。

2. 权限最小化

• MinIO 的访问密钥应遵循最小权限原则。上传服务使用的账号只应有 s3:PutObject, s3:CreateMultipartUpload 等必要权限。
• 可通过 IAM 策略或桶策略限制操作。

3. 文件类型校验

• 前端可伪造文件扩展名。后端应在 initiate 阶段校验文件类型（如通过 Magic Number）。
• 限制允许的 MIME 类型和文件大小。

@PostMapping("/initiate")
public ResponseEntity<InitiateResponse> initiateUpload(@RequestBody InitiateRequest request) {
    // 示例：只允许图片
    String ext = getFileExtension(request.getFileName()).toLowerCase();
    if (!Set.of("jpg", "jpeg", "png", "gif").contains(ext)) {
        throw new IllegalArgumentException("Unsupported file type");
    }
    // ... 其他校验
}

4. 防止路径遍历

• 用户提供的文件名可能包含 ../，导致写入非法路径。
• 应对文件名进行清洗或使用 UUID 重命名。

String safeFileName = UUID.randomUUID() + "." + ext;

性能优化建议

1. 并行上传分片

前端可同时上传多个分片（如并发 4~6 个），大幅提升大文件上传速度。

2. 使用 CDN 加速下载

上传完成后，可通过 CDN 分发文件。MinIO 可与 Nginx、Cloudflare 等集成。

3. 后端异步处理

complete 操作可能耗时（尤其大文件），可改为异步：

• 前端上传完分片后，后端立即返回'处理中'。
• 后台线程池执行 completeMultipartUpload。
• 前端轮询或通过 WebSocket 获取最终结果。

4. 监控与日志

• 记录每次上传的 uploadId、文件大小、耗时等指标。
• 集成 Prometheus + Grafana 监控 MinIO 性能。

测试与验证

单元测试

使用 Testcontainers 启动真实 MinIO 实例进行集成测试：

@Testcontainers
@SpringBootTest
class FileUploadServiceTest {
    @Container
    static MinIOContainer minio = new MinIOContainer("minio/minio:RELEASE.2023-10-23T03-42-26Z");

    @Autowired
    private FileUploadService fileUploadService;

    @Test
    void testMultipartUpload() {
        // 1. initiate
        String uploadId = fileUploadService.initiateMultipartUpload("test.txt", "test-bucket");
        assertNotNull(uploadId);
        // 2. upload part via presigned URL (mock or real HTTP call)
        // 3. complete
        // 4. verify object exists
    }
}

注意：Testcontainers 需要 Docker 环境。

手动测试

1. 启动 MinIO 和 Java 应用。
2. 使用 Postman 或 curl 调用 /initiate。
3. 获取 uploadId。
4. 请求第一个分片的预签名 URL。
5. 记录返回的 ETag。
6. 调用 /complete 合并。
7. 在 MinIO 控制台查看文件是否生成。

用 curl 上传一个文本分片：

curl -X PUT -H "Content-Type: text/plain" --data "Hello Part 1" \
  "http://localhost:9000/...?uploadId=...&partNumber=1"

常见问题排查

Q1: 分片上传返回 403 Forbidden

• 检查 MinIO 的访问密钥是否正确。
• 确认账号是否有 s3:PutObject 权限。
• 预签名 URL 是否包含正确的 uploadId 和 partNumber。

Q2: Complete 时提示 'InvalidPart'

• 分片 ETag 未去除双引号。
• parts 列表未按 partNumber 排序。
• 某些分片未成功上传。

Q3: 预签名 URL 无法访问

• 检查 MinIO 的 endpoint 配置是否为公网可访问地址（开发环境常用 http://host.docker.internal:9000）。
• 确保 URL 未过期。

Q4: 大文件上传慢

• 增加前端并发分片数。
• 检查网络带宽和 MinIO 磁盘 I/O。
• 考虑使用更大的分片（如 50MB）。

扩展：断点续传支持

要实现真正的断点续传，需在后端记录每个上传任务的状态：

1. 创建 UploadSession 表，记录 uploadId, fileName, totalParts, uploadedParts。
2. 每次前端上报分片 ETag，更新 uploadedParts。
3. 用户重新上传时，先查询已有 session，返回已上传的分片列表。
4. 前端只上传缺失的分片。

这需要引入数据库（如 MySQL 或 Redis），但能极大提升用户体验。

总结

通过结合 MinIO 的分片上传 与 预签名 URL，我们构建了一个高性能、高可靠、安全的文件上传中间件。它具备以下优势：

• 前端直传：减轻后端带宽压力。
• 分片容错：支持大文件、断点续传。
• 临时授权：通过预签名 URL 实现细粒度权限控制。
• 易于扩展：可集成校验、异步处理、监控等模块。

在实际项目中，还需根据业务场景调整分片策略、安全策略和错误处理机制。MinIO 作为轻量级对象存储，完美适配微服务架构，是替代商业 S3 服务的理想选择。

希望本文的详细讲解和代码示例能为你在 Java 项目中集成 MinIO 提供坚实基础。

参考资料：

• MinIO 官方文档：https://min.io/docs/minio/linux/index.html
• AWS S3 分片上传指南：https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html