Java 操作 MinIO详细步骤

<!-- MinIO Java SDK（兼容S3 API） -->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.5.10</version> <!-- 建议使用最新稳定版 -->
</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服务地址（格式：http://IP:端口 或 https://IP:端口）
    private static final String MINIO_ENDPOINT = "http://localhost:9000";
    // 访问密钥（MinIO控制台创建的AccessKey）
    private static final String MINIO_ACCESS_KEY = "minioadmin";
    // 秘密密钥（MinIO控制台创建的secretKey）
    private static final String MINIO_SECRET_KEY = "minioadmin";
    /**
     * 初始化MinIO客户端（单例模式，避免重复创建连接）
     * @return MinioClient对象
     */
    public static MinioClient getMinioClient() {
        try {
            // 构建客户端：传入地址、账号、密码
            MinioClient client = MinioClient.builder()
                    .endpoint(MINIO_ENDPOINT)
                    .credentials(MINIO_ACCESS_KEY, MINIO_SECRET_KEY)
                    .build();
            // 可选：验证客户端是否可用（避免后续操作才发现连接失败）
            client.listBuckets(); // 调用简单接口测试连接
            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. 检查桶是否已存在（避免重复创建报错）
            boolean bucketExists = client.bucketExists(
                    BucketArgs.builder().bucket(bucketName).build()
            );
            if (bucketExists) {
                System.out.println("桶已存在：" + bucketName);
                return;
            }
            // 2. 创建桶（设置桶的区域，默认"us-east-1"即可）
            client.makeBucket(
                    io.minio.MakeBucketArgs.builder()
                            .bucket(bucketName)
                            .region("us-east-1") // 区域配置，无需修改（MinIO兼容S3的区域概念）
                            .build()
            );
            System.out.println("桶创建成功：" + bucketName);
        } catch (MinioException e) {
            throw new RuntimeException("创建桶失败：" + 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 {
            // 调用listBuckets()获取所有桶
            List<Bucket> buckets = client.listBuckets();
            // 遍历桶列表，打印桶名和创建时间
            System.out.println("MinIO中的桶列表：");
            for (Bucket bucket : buckets) {
                System.out.println("桶名：" + bucket.name() + "，创建时间：" + 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. （可选）删除桶内所有对象（桶必须为空才能删除）
            deleteAllObjectsInBucket(client, bucketName);
            // 3. 删除桶
            client.removeBucket(
                    BucketArgs.builder().bucket(bucketName).build()
            );
            System.out.println("桶删除成功：" + bucketName);
        } catch (Exception e) {
            throw new RuntimeException("删除桶失败：" + e.getMessage(), e);
        }
    }
    /**
     * 辅助方法：删除桶内所有对象
     */
    private static void deleteAllObjectsInBucket(MinioClient client, String bucketName) throws Exception {
        // 遍历桶内所有对象并删除
        client.listObjects(
                io.minio.ListObjectsArgs.builder()
                        .bucket(bucketName)
                        .recursive(true) // 递归查询所有对象（包括子目录）
                        .build()
        ).forEach(object -> {
            try {
  javascript              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格式）：公开读（所有人可下载桶内对象，不可写）
            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. 设置桶策略
            client.setBucketPolicy(
                    SetBucketPolicyArgs.builder()
                            .bucket(bucketName)
                            .config(publicReadPolicy) // 传入JSON格式的策略
                            .build()
            );
            System.out.println("桶策略设置成功：" + bucketName + "（公开读）");
        } catch (Exception e) {
            throw new RuntimeException("设置桶策略失败：" + 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) // 桶内路径，支持多级目录（如"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. 创建本地文件输出流
                OutputStream localStream = new FileOutputStream(localSavePath)
        ) {
            // 3. 流拷贝（边读边写，避免大文件OOM）
            byte[] buffer = new byte[8192]; // 8KB缓冲（平衡性能和内存）
            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 {
            // 调用statObject获取对象元数据，若不存在会抛异常
            client.statObject(
                    io.minio.StatObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .build()
            );
            return true;
      android  } catch (io.minio.errors.ErrorResponseException e) {
            // 404错误表示对象不存在
            if (e.errorResponse().code().equals("NoSuchKey")) {
                return false;
            }
            throw e; // 其他错误（如权限不足）重新抛出
        }
    }
}

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 {
            // 获取对象元数据
            StatObjectResponse meta = client.statObject(
                    StatObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .build()
            );
            // 打印元数据信息
            System.out.println("对象元数据：");
            System.out.println("对象名称：" + meta.objectName());
            System.out.println("文件大小（字节）：" + meta.size());
            System.out.println("创建时间：" + meta.lastModified());
            System.out.println("MIME类型：" + meta.contentType());
            System.out.println("ETag（文件MD5的十六进制）：" + meta.etag());
        } catch (Exception e) {
            throw new RuntimeException("查询对象元数据失败：" + 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);
            // 后续上传分片和合并时，需要用到这个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开始，必须连续）
        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<>();
            // 假设上传了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(
                    CompleteM编程ultipartUploadArgs.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 {
            // 生成预签名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("预签名下载URL（" + expiryHours + "小时内有效）：");
            System.out.println(presignedUrl);
            // 前端可直接用这个URL下载文件，无需MinIO账号密码
        } catch (Exception e) {
            throw new RuntimeException("生成预签名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()
    );
    // 生成预签名URL
    String presignedUrl = client.getPresignedObjectUrl(
            GetPresignedObjectUrlArgs.builder()
                    .method(Method.GET)
                    .bucket(bucketName)
                    .object(mergedPath)
                    .expiry(1, TimeUnit.HOandroidURS)
                    .build()
    );
    // 删除临时分片
    for (String partPath : partPaths) {
        client.removeObject(
                RemoveObjectArgs.builder()
                        .bucket(bucketName)
                        .object(partPath)
                        .build()
        );
    }
    return presignedUrl;
}

// 配置连接池（添加到MinioClientUtandroidil）
private static final HttpClient httpClient = HttpClient.newBuilder()
        .connectionPoolSize(20) // 最大连接数
        .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();
}