<!-- MinIO Java SDK（兼容S3 API） -->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.5.10</version> <!-- 建議使用最新穩(wěn)定版 -->
</dependency>
<!-- 可選：Apache HttpClient（用于HTTP請求，部分場景依賴） -->
<dependency>
    <groupId>org.apache.httpcomponents.client5</groupId>
    <artifactId>httpclient5</artifactId>
    <version>5.3</version>
</dependency>

import io.minio.MinioClient;
import io.minio.errors.InvalidEndpointException;
import io.minio.errors.InvalidPortException;
public class MinioClientUtil {
    // MinIO服務(wù)地址（格式：http://IP:端口 或 https://IP:端口）
    private static final String MINIO_ENDPOINT = "http://localhost:9000";
    // 訪問密鑰（MinIO控制臺創(chuàng)建的accessKey）
    private static final String MINIO_ACCESS_KEY = "minioadmin";
    // 秘密密鑰（MinIO控制臺創(chuàng)建的secretKey）
    private static final String MINIO_SECRET_KEY = "minioadmin";
    /**
     * 初始化MinIO客戶端（單例模式，避免重復創(chuàng)建連接）
     * @return MinioClient對象
     */
    public static MinioClient getMinioClient() {
        try {
            // 構(gòu)建客戶端：傳入地址、賬號、密碼
            MinioClient client = MinioClient.builder()
                    .endpoint(MINIO_ENDPOINT)
                    .credentials(MINIO_ACCESS_KEY, MINIO_SECRET_KEY)
                    .build();
            // 可選：驗證客戶端是否可用（避免后續(xù)操作才發(fā)現(xiàn)連接失?。?
            client.listBuckets(); // 調(diào)用簡單接口測試連接
            return client;
        } catch (InvalidEndpointException | InvalidPortException e) {
            throw new RuntimeException("MinIO地址/端口錯誤：" + e.getMessage(), e);
        } catch (Exception e) {
            throw new RuntimeException("MinIO客戶端初始化失敗：" + e.getMessage(), e);
        }
    }
}

import io.minio.BucketArgs;
import io.minio.MinioClient;
import io.minio.errors.MinioException;
public class MinioBucketDemo {
    public static void main(String[] args) {
        MinioClient client = MinioClientUtil.getMinioClient();
        String bucketName = "uploads"; // 桶名（必須小寫，不能包含特殊字符）
        try {
            // 1. 檢查桶是否已存在（避免重復創(chuàng)建報錯）
            boolean bucketExists = client.bucketExists(
                    BucketArgs.builder().bucket(bucketName).build()
            );
            if (bucketExists) {
                System.out.println("桶已存在：" + bucketName);
                return;
            }
            // 2. 創(chuàng)建桶（設(shè)置桶的區(qū)域，默認"us-east-1"即可）
            client.makeBucket(
                    io.minio.MakeBucketArgs.builder()
                            .bucket(bucketName)
                            .region("us-east-1") // 區(qū)域配置，無需修改（MinIO兼容S3的區(qū)域概念）
                            .build()
            );
            System.out.println("桶創(chuàng)建成功：" + bucketName);
        } catch (MinioException e) {
            throw new RuntimeException("創(chuàng)建桶失?。? + e.getMessage(), e);
        } catch (Exception e) {
            throw new RuntimeException("未知錯誤：" + e.getMessage(), e);
        }
    }
}

import io.minio.Bucket;
import io.minio.MinioClient;
import java.util.List;
public class MinioListBucketsDemo {
    public static void main(String[] args) {
        MinioClient client = MinioClientUtil.getMinioClient();
        try {
            // 調(diào)用listBuckets()獲取所有桶
            List<Bucket> buckets = client.listBuckets();
            // 遍歷桶列表，打印桶名和創(chuàng)建時間
            System.out.println("MinIO中的桶列表：");
            for (Bucket bucket : buckets) {
                System.out.println("桶名：" + bucket.name() + "，創(chuàng)建時間：" + bucket.creationDate());
            }
        } catch (Exception e) {
            throw new RuntimeException("查詢桶列表失?。? + e.getMessage(), e);
        }
    }
}

import io.minio.BucketArgs;
import io.minio.MinioClient;
public class MinioDeleteBucketDemo {
    public static void main(String[] args) {
        MinioClient client = MinioClientUtil.getMinioClient();
        String bucketName = "test-bucket";
        try {
            // 1. 檢查桶是否存在
            boolean bucketExists = client.bucketExists(
                    BucketArgs.builder().bucket(bucketName).build()
            );
            if (!bucketExists) {
                System.out.println("桶不存在：" + bucketName);
                return;
            }
            // 2. （可選）刪除桶內(nèi)所有對象（桶必須為空才能刪除）
            deleteAllObjectsInBucket(client, bucketName);
            // 3. 刪除桶
            client.removeBucket(
                    BucketArgs.builder().bucket(bucketName).build()
            );
            System.out.println("桶刪除成功：" + bucketName);
        } catch (Exception e) {
            throw new RuntimeException("刪除桶失?。? + e.getMessage(), e);
        }
    }
    /**
     * 輔助方法：刪除桶內(nèi)所有對象
     */
    private static void deleteAllObjectsInBucket(MinioClient client, String bucketName) throws Exception {
        // 遍歷桶內(nèi)所有對象并刪除
        client.listObjects(
                io.minio.ListObjectsArgs.builder()
                        .bucket(bucketName)
                        .recursive(true) // 遞歸查詢所有對象（包括子目錄）
                        .build()
        ).forEach(object -> {
            try {
                client.removeObject(
                        io.minio.RemoveObjectArgs.builder()
                                .bucket(bucketName)
                                .object(object.get().objectName())
                                .build()
                );
            } catch (Exception e) {
                throw new RuntimeException("刪除對象失?。? + object.get().objectName(), e);
            }
        });
    }
}

import io.minio.BucketArgs;
import io.minio.MinioClient;
import io.minio.SetBucketPolicyArgs;
public class MinioBucketPolicyDemo {
    public static void main(String[] args) {
        MinioClient client = MinioClientUtil.getMinioClient();
        String bucketName = "uploads";
        try {
            // 1. 定義桶策略（JSON格式）：公開讀（所有人可下載桶內(nèi)對象，不可寫）
            String publicReadPolicy = "{\n" +
                    "  \"Version\": \"2012-10-17\",\n" +
                    "  \"Statement\": [\n" +
                    "    {\n" +
                    "      \"Effect\": \"Allow\",\n" +
                    "      \"Principal\": \"*\",\n" +
                    "      \"Action\": \"s3:GetObject\",\n" +
                    "      \"Resource\": \"arn:aws:s3:::" + bucketName + "/*\"\n" +
                    "    }\n" +
                    "  ]\n" +
                    "}";
            // 2. 設(shè)置桶策略
            client.setBucketPolicy(
                    SetBucketPolicyArgs.builder()
                            .bucket(bucketName)
                            .config(publicReadPolicy) // 傳入JSON格式的策略
                            .build()
            );
            System.out.println("桶策略設(shè)置成功：" + bucketName + "（公開讀）");
        } catch (Exception e) {
            throw new RuntimeException("設(shè)置桶策略失敗：" + e.getMessage(), e);
        }
    }
}

import io.minio.MinioClient;
import io.minio.PutObjectArgs;
import java.io.FileInputStream;
import java.io.InputStream;
public class MinioSimpleUploadDemo {
    public static void main(String[] args) {
        MinioClient client = MinioClientUtil.getMinioClient();
        String bucketName = "uploads";
        String objectName = "docs/test.pdf"; // 對象在桶中的路徑（類似"文件夾/文件名"）
        String localFilePath = "C:\\test.pdf"; // 本地文件路徑
        try (InputStream fileStream = new FileInputStream(localFilePath)) {
            // 上傳對象：傳入桶名、對象路徑、文件流、文件大小、MIME類型
            client.putObject(
                    PutObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName) // 桶內(nèi)路徑，支持多級目錄（如"docs/2024/test.pdf"）
                            .stream(fileStream, fileStream.available(), -1) // 流、大?。?1表示自動識別）
                            .contentType("application/pdf") // MIME類型（如PDF是"application/pdf"，圖片是"image/jpeg"）
                            .build()
            );
            System.out.println("文件上傳成功：" + objectName);
        } catch (Exception e) {
            throw new RuntimeException("文件上傳失敗：" + e.getMessage(), e);
        }
    }
}

import io.minio.GetObjectArgs;
import io.minio.MinioClient;
import io.minio.errors.MinioException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class MinioDownloadDemo {
    public static void main(String[] args) {
        MinioClient client = MinioClientUtil.getMinioClient();
        String bucketName = "uploads";
        String objectName = "docs/test.pdf"; // 要下載的對象路徑
        String localSavePath = "C:\\downloads\\test.pdf"; // 本地保存路徑

        try (
                // 1. 獲取MinIO對象的輸入流
                InputStream minioStream = client.getObject(
                        GetObjectArgs.builder()
                                .bucket(bucketName)
                                .object(objectName)
                                .build()
                );
                // 2. 創(chuàng)建本地文件輸出流
                OutputStream localStream = new FileOutputStream(localSavePath)
        ) {
            // 3. 流拷貝（邊讀邊寫，避免大文件OOM）
            byte[] buffer = new byte[8192]; // 8KB緩沖（平衡性能和內(nèi)存）
            int bytesRead;
            while ((bytesRead = minioStream.read(buffer)) != -1) {
                localStream.write(buffer, 0, bytesRead);
            }
            System.out.println("文件下載成功：" + localSavePath);
        } catch (MinioException e) {
            throw new RuntimeException("下載對象失敗：" + e.getMessage(), e);
        } catch (Exception e) {
            throw new RuntimeException("本地寫入失?。? + e.getMessage(), e);
        }
    }
}

import io.minio.MinioClient;
import io.minio.RemoveObjectArgs;
public class MinioDeleteObjectDemo {
    public static void main(String[] args) {
        MinioClient client = MinioClientUtil.getMinioClient();
        String bucketName = "uploads";
        String objectName = "docs/test.pdf"; // 要刪除的對象路徑
        try {
            // 1. 檢查對象是否存在（可選，避免刪除不存在的對象報錯）
            boolean objectExists = checkObjectExists(client, bucketName, objectName);
            if (!objectExists) {
                System.out.println("對象不存在：" + objectName);
                return;
            }
            // 2. 刪除對象
            client.removeObject(
                    RemoveObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .build()
            );
            System.out.println("對象刪除成功：" + objectName);
        } catch (Exception e) {
            throw new RuntimeException("刪除對象失?。? + e.getMessage(), e);
        }
    }
    /**
     * 輔助方法：檢查對象是否存在
     */
    private static boolean checkObjectExists(MinioClient client, String bucketName, String objectName) throws Exception {
        try {
            // 調(diào)用statObject獲取對象元數(shù)據(jù)，若不存在會拋異常
            client.statObject(
                    io.minio.StatObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .build()
            );
            return true;
        } catch (io.minio.errors.ErrorResponseException e) {
            // 404錯誤表示對象不存在
            if (e.errorResponse().code().equals("NoSuchKey")) {
                return false;
            }
            throw e; // 其他錯誤（如權(quán)限不足）重新拋出
        }
    }
}

import io.minio.MinioClient;
import io.minio.StatObjectArgs;
import io.minio.StatObjectResponse;
public class MinioObjectMetaDemo {
    public static void main(String[] args) {
        MinioClient client = MinioClientUtil.getMinioClient();
        String bucketName = "uploads";
        String objectName = "docs/test.pdf";
        try {
            // 獲取對象元數(shù)據(jù)
            StatObjectResponse meta = client.statObject(
                    StatObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .build()
            );
            // 打印元數(shù)據(jù)信息
            System.out.println("對象元數(shù)據(jù)：");
            System.out.println("對象名稱：" + meta.objectName());
            System.out.println("文件大?。ㄗ止?jié)）：" + meta.size());
            System.out.println("創(chuàng)建時間：" + meta.lastModified());
            System.out.println("MIME類型：" + meta.contentType());
            System.out.println("ETag（文件MD5的十六進制）：" + meta.etag());
        } catch (Exception e) {
            throw new RuntimeException("查詢對象元數(shù)據(jù)失?。? + e.getMessage(), e);
        }
    }
}

import io.minio.CreateMultipartUploadArgs;
import io.minio.MinioClient;
import io.minio.Result;
import io.minio.UploadPartResponse;
public class MinioMultipartInitDemo {
    public static void main(String[] args) {
        MinioClient client = MinioClientUtil.getMinioClient();
        String bucketName = "uploads";
        String objectName = "large-files/video.mp4"; // 大文件在桶中的路徑
        String contentType = "video/mp4"; // MIME類型
        try {
            // 初始化分片上傳，獲取上傳ID
            String uploadId = client.createMultipartUpload(
                    CreateMultipartUploadArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .contentType(contentType)
                            .build()
            ).result().uploadId();
            System.out.println("分片上傳初始化成功，上傳ID：" + uploadId);
            // 后續(xù)上傳分片和合并時，需要用到這個uploadId
        } catch (Exception e) {
            throw new RuntimeException("初始化分片上傳失敗：" + e.getMessage(), e);
        }
    }
}

import io.minio.MinioClient;
import io.minio.UploadPartArgs;
import io.minio.UploadPartResponse;
import java.io.FileInputStream;
import java.io.InputStream;
public class MinioUploadPartDemo {
    public static void main(String[] args) {
        MinioClient client = MinioClientUtil.getMinioClient();
        String bucketName = "uploads";
        String objectName = "large-files/video.mp4";
        String uploadId = "mpu-1234567890"; // 從初始化分片獲取的uploadId
        int partNumber = 1; // 分片編號（從1開始，必須連續(xù)）
        String partFilePath = "C:\\parts\\video_part_1.mp4"; // 單個分片的本地路徑
        try (InputStream partStream = new FileInputStream(partFilePath)) {
            // 上傳分片
            UploadPartResponse response = client.uploadPart(
                    UploadPartArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .uploadId(uploadId)
                            .partNumber(partNumber) // 分片編號（1-10000，MinIO限制最大10000片）
                            .stream(partStream, partStream.available(), -1) // 分片流
                            .build()
            );
            // 保存分片的ETag（合并分片時需要傳入所有分片的ETag和編號）
            String partEtag = response.etag();
            System.out.println("分片上傳成功：編號=" + partNumber + "，ETag=" + partEtag);
        } catch (Exception e) {
            throw new RuntimeException("上傳分片失?。? + e.getMessage(), e);
        }
    }
}

import io.minio.CompleteMultipartUploadArgs;
import io.minio.CompletedPart;
import io.minio.MinioClient;
import java.util.ArrayList;
import java.util.List;
public class MinioCompleteMultipartDemo {
    public static void main(String[] args) {
        MinioClient client = MinioClientUtil.getMinioClient();
        String bucketName = "uploads";
        String objectName = "large-files/video.mp4";
        String uploadId = "mpu-1234567890"; // 初始化分片時的uploadId
        try {
            // 1. 準備分片列表（編號→ETag的映射，需按編號排序）
            List<CompletedPart> completedParts = new ArrayList<>();
            // 假設(shè)上傳了3個分片，添加每個分片的編號和ETag
            completedParts.add(new CompletedPart(1, "etag-1"));
            completedParts.add(new CompletedPart(2, "etag-2"));
            completedParts.add(new CompletedPart(3, "etag-3"));
            // 2. 合并分片
            client.completeMultipartUpload(
                    CompleteMultipartUploadArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .uploadId(uploadId)
                            .parts(completedParts) // 所有分片的編號和ETag
                            .build()
            );
            System.out.println("分片合并成功：" + objectName);
        } catch (Exception e) {
            throw new RuntimeException("合并分片失?。? + e.getMessage(), e);
        }
    }
}

import io.minio.GetPresignedObjectUrlArgs;
import io.minio.MinioClient;
import io.minio.http.Method;
import java.util.concurrent.TimeUnit;
public class MinioPresignedUrlDemo {
    public static void main(String[] args) {
        MinioClient client = MinioClientUtil.getMinioClient();
        String bucketName = "uploads";
        String objectName = "docs/test.pdf";
        int expiryHours = 1; // URL有效期（1小時）
        try {
            // 生成預(yù)簽名URL（支持GET下載、PUT上傳、DELETE刪除等方法）
            String presignedUrl = client.getPresignedObjectUrl(
                    GetPresignedObjectUrlArgs.builder()
                            .method(Method.GET) // 方法：GET=下載，PUT=上傳，DELETE=刪除
                            .bucket(bucketName)
                            .object(objectName)
                            .expiry(expiryHours, TimeUnit.HOURS) // 有效期（1小時）
                            .build()
            );
            System.out.println("預(yù)簽名下載URL（" + expiryHours + "小時內(nèi)有效）：");
            System.out.println(presignedUrl);
            // 前端可直接用這個URL下載文件，無需MinIO賬號密碼
        } catch (Exception e) {
            throw new RuntimeException("生成預(yù)簽名URL失敗：" + e.getMessage(), e);
        }
    }
}

// 合并分片（用composeObject合并，適合已上傳的分片）
public String mergeChunks(String fileMd5, String fileName, List<String> partPaths) throws Exception {
    MinioClient client = MinioClientUtil.getMinioClient();
    String bucketName = "uploads";
    String mergedPath = "merged/" + fileName;
    // 準備分片源（每個分片的路徑）
    List<ComposeSource> sources = partPaths.stream()
            .map(path -> ComposeSource.builder()
                    .bucket(bucketName)
                    .object(path)
                    .build())
            .collect(Collectors.toList());
    // 合并分片（composeObject適用于合并已存在的對象）
    client.composeObject(
            ComposeObjectArgs.builder()
                    .bucket(bucketName)
                    .object(mergedPath)
                    .sources(sources)
                    .build()
    );
    // 生成預(yù)簽名URL
    String presignedUrl = client.getPresignedObjectUrl(
            GetPresignedObjectUrlArgs.builder()
                    .method(Method.GET)
                    .bucket(bucketName)
                    .object(mergedPath)
                    .expiry(1, TimeUnit.HOURS)
                    .build()
    );
    // 刪除臨時分片
    for (String partPath : partPaths) {
        client.removeObject(
                RemoveObjectArgs.builder()
                        .bucket(bucketName)
                        .object(partPath)
                        .build()
        );
    }
    return presignedUrl;
}

// 配置連接池（添加到MinioClientUtil）
private static final HttpClient httpClient = HttpClient.newBuilder()
        .connectionPoolSize(20) // 最大連接數(shù)
        .connectTimeout(Duration.ofSeconds(30))
        .build();
public static MinioClient getMinioClient() {
    return MinioClient.builder()
            .endpoint(MINIO_ENDPOINT)
            .credentials(MINIO_ACCESS_KEY, MINIO_SECRET_KEY)
            .httpClient(httpClient) // 傳入連接池
            .build();
}