SpringBoot集成MinIO实现分片存储、生命周期管理与多租户隔离

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

minio:
  endpoint: https://minio.internal:9000
  access-key: ${MINIO_ROOT_USER}
  secret-key: ${MINIO_ROOT_PASSWORD}
  region: cn-east-1
  enable-ssl: true

@Configuration
public class MinioConfig {
    @Bean
    public MinioClient minioClient(@Value("${minio.endpoint}") String endpoint,
                                   @Value("${minio.access-key}") String ak,
                                   @Value("${minio.secret-key}") String sk) {
        // 显式定制连接池，避免默认 5 个连接撑不住大文件并发
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
            .connectTimeout(Duration.ofSeconds(5))
            .readTimeout(Duration.ofSeconds(30))
            .writeTimeout(Duration.ofSeconds(30))
            // 保持长连接，空闲 15 分钟回收，最大 200 个连接
            .connectionPool(new ConnectionPool(200, 15, TimeUnit.MINUTES))
            .retryOnConnectionFailure(true)
            .build();

        return MinioClient.builder()
            .endpoint(endpoint)
            .credentials(ak, sk)
            .region("cn-east-1")
            .httpClient(okHttpClient)
            .build();
    }
}

@RestControllerAdvice
public class MinioExceptionHandler {
    @ExceptionHandler(ErrorResponseException.class)
    public ResponseEntity<ApiResult> handleMinioError(ErrorResponseException ex) {
        String code = ex.error().code();
        HttpStatus status;
        if ("NoSuchKey".equals(code)) {
            status = HttpStatus.NOT_FOUND;
        } else if ("AccessDenied".equals(code) || "SignatureDoesNotMatch".equals(code)) {
            status = HttpStatus.FORBIDDEN;
        } else {
            // 网络抖动或内部错误，可配合 Spring Retry 做有限重试
            status = HttpStatus.INTERNAL_SERVER_ERROR;
        }
        return ResponseEntity.status(status).body(ApiResult.fail(status.value(), code + ": " + ex.getMessage()));
    }
}

@Service
@RequiredArgsConstructor
public class MultipartUploadService {
    private final MinioClient minioClient;
    private final StringRedisTemplate redis;

    // 1. 初始化，返回 uploadId
    public String initUpload(String bucket, String object) throws Exception {
        var resp = minioClient.createMultipartUpload(
            CreateMultipartUploadArgs.builder().bucket(bucket).object(object).build());
        String uploadId = resp.result().uploadId();
        redis.opsForHash().put("upload:meta", uploadId,
            Map.of("bucket", bucket, "object", object, "status", "UPLOADING"));
        return uploadId;
    }

    // 2. 签发分片上传 URL（给前端直传用）
    public String getPartPresignedUrl(String uploadId, int partNumber, String contentType) throws Exception {
        var meta = (Map<?, ?>) redis.opsForHash().get("upload:meta", uploadId);
        if (meta == null) throw new IllegalStateException("UploadId not found or expired");
        
        return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
            .method(Method.PUT)
            .bucket((String) meta.get("bucket"))
            .object((String) meta.get("object"))
            .expiry(Duration.ofMinutes(15))
            .extraQueryParams(Map.of("partNumber", String.valueOf(partNumber), "uploadId", uploadId))
            .build());
    }

    // 3. 合并分片
    public void completeUpload(String uploadId, List<Part> parts) throws Exception {
        var meta = (Map<?, ?>) redis.opsForHash().get("upload:meta", uploadId);
        if (meta == null) throw new IllegalStateException("Upload meta lost");

        minioClient.completeMultipartUpload(CompleteMultipartUploadArgs.builder()
            .bucket((String) meta.get("bucket"))
            .object((String) meta.get("object"))
            .uploadId(uploadId)
            .parts(parts)
            .build());

        redis.delete("upload:meta:" + uploadId);
        // 触发后续业务逻辑（如更新文件表状态、生成缩略图等）
    }
}

public void applyLifecycle(String bucket) throws Exception {
    var rules = List.of(
        // 临时目录：3 天后自动清理
        LifecycleRule.builder()
            .status(Status.ENABLED)
            .filter(Filter.builder().prefix("temp/").build())
            .expiration(Expiration.newDays(3))
            .build(),
        // 业务目录：90 天转低热存储，730 天彻底删除
        LifecycleRule.builder()
            .status(Status.ENABLED)
            .filter(Filter.builder().prefix("biz/").build())
            .transition(Transition.newDays(90).storageClass("TIER_COLD"))
            .expiration(Expiration.newDays(730))
            .build()
    );
    minioClient.setBucketLifecycle(SetBucketLifecycleArgs.builder()
        .bucket(bucket)
        .config(new LifecycleConfiguration(rules))
        .build());
}

public String genDownloadUrl(String bucket, String object) throws Exception {
    return minioClient.getPresignedObjectUrl(
        GetPresignedObjectUrlArgs.builder()
            .method(Method.GET)
            .bucket(bucket).object(object)
            .expiry(Duration.ofMinutes(15))
            .build());
}

@Configuration
public class ImageProcessConfig {
    @Bean
    public Consumer<Message<MinioEvent>> processImage() {
        return msg -> {
            MinioEvent event = msg.getPayload();
            if (!event.key().matches(".*\\.(jpg|jpeg|png)$")) return;

            try (var in = minioClient.getObject(GetObjectArgs.builder()
                    .bucket("tenant-raw").object(event.key()).build())) {
                
                // 用临时文件处理，避免大图片撑爆内存
                File tempOut = File.createTempFile("thumb_", ".webp");
                try (var out = new FileOutputStream(tempOut)) {
                    Thumbnails.of(in)
                        .size(800, 0) // 固定宽，高自适应
                        .outputFormat("webp")
                        .quality(0.75f)
                        .toOutputStream(out);
                }

                // 回传处理结果
                try (var fis = new FileInputStream(tempOut)) {
                    String newKey = event.key().replace("raw/", "thumb/").replaceFirst("\\.(jpg|jpeg|png)$", ".webp");
                    minioClient.putObject(PutObjectArgs.builder()
                        .bucket("tenant-processed")
                        .object(newKey)
                        .stream(fis, tempOut.length(), -1)
                        .contentType("image/webp")
                        .build());
                }
                dbService.markImageProcessed(event.key(), newKey);
            } catch (Exception e) {
                log.error("图片处理失败，key: {}", event.key(), e);
                // 投递死信队列，人工介入或稍后重试
                deadLetterQueue.send(msg);
            }
        };
    }
}