详细分析Java中的Minio类各API（附win配置安装）（全）

前言

对应的下载界面可以通过官方进行查看：minio官方下载

MinIO 是一款开源的对象存储服务器软件，旨在提供高性能和可扩展的分布式存储解决方案。

以下是对 MinIO 的主要特点和功能的总结：

• 对象存储： MinIO 提供了对象存储服务，允许用户以对象的形式存储和检索任意类型的数据，如图片、视频、文档等

• 分布式架构： MinIO 的设计理念是构建一个高度可扩展的分布式系统
  它支持水平扩展，可以在多个节点上部署，以满足不断增长的存储需求

• 高性能： MinIO 通过采用并行处理和优化的存储引擎，实现了出色的性能
  它能够利用硬件的多核和多硬盘来提高读写速度

• S3兼容性： MinIO 提供了 S3 兼容的 API，使得它能够与现有的 S3 应用程序和工具协同工作
  这使得 MinIO 成为一个理想的私有云存储解决方案

• 安全性： MinIO 提供了多层次的安全性措施，包括数据加密、访问控制、身份验证、防盗链等功能，以保护存储的数据。

• 可扩展性： MinIO 具有良好的可扩展性，可以轻松地添加新的节点以增加存储容量和吞吐量，同时无需中断服务。

• 开源： MinIO 是一款开源软件，采用Apache License 2.0许可证，使得用户可以自由使用、修改和分发软件。

总的来说，MinIO 是一个强大、灵活且具有良好性能的对象存储系统，适用于各种规模的应用和场景，特别是对于需要构建私有云存储的组织和开发者而言，是一个值得考虑的选择。

其中涉及的基本概念有必要提前认知：

概念	定义
桶（Bucket）	1.桶是 MinIO 中用于组织和存储对象的基本容器 2.每个对象都存储在特定的桶中 3.桶的命名是唯一的，因此在 MinIO 中，每个桶都必须具有唯一的名称。
对象（Object）	1.对象是 MinIO 中的基本存储单元，它可以是任何类型的文件（文本文件、图像、视频等） 2.每个对象都存储在一个特定的桶中，而且在该桶中必须具有唯一的对象名称
Multipart上传	1.Multipart上传是一种在 MinIO 中上传大型对象的方法 2.它将大对象划分为小的分片，分别上传，并最终合并成一个完整的对象。
权限与策略	设置桶（Bucket）和对象（Object）的访问权限和策略。包括对桶和对象的读取、写入和删除权限的控制
版本控制	1.支持版本控制，允许对存储桶启用或禁用版本追踪 2.启用版本控制后，每次对对象的写操作都会创建一个新版本
事件通知	支持事件通知，允许通过配置事件规则，使 MinIO 在特定事件发生时触发通知，例如对象的创建、删除等
存储类别	提供不同的存储类别，例如标准存储、低频存储等，以满足不同数据访问模式和成本需求
生命周期管理	允许配置对象的生命周期，定义在对象创建一定时间后自动转换为低频存储、删除等操作

对应的Java接口可看如下例子：https://github.com/minio/minio-java

1. Window配置

1. 下载

官网页面中有服务端、客户端以及不同语言SDK的依赖包

可以点击DOWNLOAD的下载服务端按钮，或者执行该命令：

Invoke-WebRequest -Uri "https://dl.min.io/server/minio/release/windows-amd64/minio.exe" -OutFile "C:\minio.exe"

其中"C:\minio.exe"为下载的路径位置，可以放在F盘的位置上！

2. 设置临时密码（重启密码失效）

设置账号密码，并查看环境变量：

set MINIO_ROOT_USER=admin
set MINIO_ROOT_PASSWORD=password

#查看环境变量
echo %MINIO_ROOT_USER%
echo %MINIO_ROOT_PASSWORD%

截图如下：

启动命令：minio.exe server F:\data --console-address ":9001"

登录：http://10.197.2.28:9001/，截图如下：

3. 设置永久密码：

#用户环境变量
setx MINIO_ROOT_USER admin
setx MINIO_ROOT_PASSWORD password

#系统环境变量(需管理员)
setx MINIO_ROOT_USER admin /m
setx MINIO_ROOT_PASSWORD password /m

具体的配置在如下界面：

此处创建桶

在此处设置规则：
对应设置成readwrite ，才可进行读取文件（其余两个规则为readonly 或者 writeonly）

2. 存储桶的基本方法

操作代码的前提先引入依赖：

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

对应的API接口如下：

• 检查桶是否存在：boolean BucketExists (BucketExists Args args)
• 创建存储桶：public void makeBucket(MakeBucketArgs args)
• 列举所有桶：public List listBuckets() （此处输出的桶为美国时间，可以在创建的时候指定时区）
• 删除桶：public void removeBucket(RemoveBucketArgs args)

操作上述的接口，先看首页的桶id：

配合代码一起使用：

import io.minio.BucketExists Args;
import io.minio.MakeBucketArgs;
import io.minio.MinioClient;
import io.minio.RemoveBucketArgs;
import io.minio.errors.MinioException;
import io.minio.messages.Bucket;

import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.List;

public class BucketExists  {
    /** MinioClient.BucketExists () example. */
    private static final String ENDPOINT = "http://127.0.0.1:9000";
    private static final String ACCESS_KEY = "admin";
    private static final String SECRET_KEY = "12345678";
    public static void main(String[] args) {

        try {
            // 1. 创建MinioClient实例
            MinioClient minioClient = MinioClient.builder()
                    .endpoint(ENDPOINT)
                    .credentials(ACCESS_KEY, SECRET_KEY)
                    .build();
            boolean found =
                    minioClient.BucketExists (BucketExists Args.builder().bucket("test").build());
            if (found) {
                System.out.println("my-bucketname exists");
            } else {
                System.out.println("my-bucketname does not exist");
            }
    
            // 2. 创建Bucket的同时，先判定是否存在
            String bucketName = "test1";
            // 存储桶不存在则创建
            if (!minioClient.BucketExists (BucketExists Args.builder().bucket(bucketName).build())) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
                System.out.printf("%s,创建成功\n", bucketName);
            }else{
                System.out.printf("%s,已存在\n", bucketName);
            }
    
    
            // 3. 列举Buckets
            List<Bucket> buckets = minioClient.listBuckets();
            for (Bucket bucket : buckets) {
                System.out.println("Bucket Name: " + bucket.name() + ",Bucket Date:" + bucket.creationDate());
            }
    
    
            // 4. 删除刚刚创建的存储桶
            minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    
            
        } catch (MinioException | IOException | NoSuchAlgorithmException | InvalidKeyException e) {
            e.printStackTrace();
        }
  
    }
}

截图如下：

3. 存储对象的基本方法

3.1 上传对象

• uploadObject 方法：

参数类型： UploadObjectArgs
使用场景： 适用于需要上传大型对象的情况，因为它支持 Multipart 上传，可以将大对象划分为小的分片，然后并发上传这些分片，最终合并成一个完整的对象。这种方法适用于大文件，可以提高上传效率。

minioClient.uploadObject(
        UploadObjectArgs.builder()
                .bucket("my-bucket")
                .object("path/to/my-object")
                .filename("/path/to/local/file")
                .build());

• putObject 方法：

参数类型： PutObjectArgs
使用场景： 适用于小文件或者希望简单上传整个对象的情况。putObject 方法将整个对象一次性上传，适用于对象较小的情况。

minioClient.putObject(
        PutObjectArgs.builder()
                .bucket("my-bucket")
                .object("path/to/my-object")
                .stream(inputStream, size, -1)
                .build());

需要上传大型对象并希望提高效率，可以选择使用 uploadObject 方法
而对于小文件或者简单场景，使用 putObject 方法即可

3.1.1 putObject

先科普一些基本的知识：

1. 对象大小限制
   默认情况下，MinIO服务器不强制对象的大小限制。然而，通常情况下，会参考AWS S3的限制，其中对象的最大大小为5GB。需要注意的是，MinIO通过使用Multipart Upload等技术支持更大的对象上传。在实际应用中，应该根据服务器的配置和性能来调整相关参数，以确保可以处理大文件上传。

2. 覆盖同名对象
   当使用putObject上传对象时，如果已存在同名的对象并且具有足够的权限，新添加的对象将会覆盖原有的对象。这是因为MinIO按照对象的键（Key）来存储数据，相同键的对象被视为同一个对象。因此，如果权限允许，新的上传会覆盖已存在的对象。

3. 文件夹模拟
   在对象存储中，没有真正的文件夹概念。路径信息只是对象键（Key）中的一部分，而不是实际的文件夹结构。通过在键中使用斜杠 / 可以模拟文件夹结构，但这只是一种表现方式。创建一个以 / 结尾的对象可以用来模拟文件夹，但这个对象实际上是一个零字节大小的对象，不占用实际存储空间。文件夹模拟主要是为了方便组织和管理对象。

import io.minio.*;
import io.minio.errors.MinioException;
import io.minio.messages.Bucket;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.time.LocalDateTime;
import java.util.List;

public class BucketExists  {
    // MinIO服务器的地址
    private static final String ENDPOINT = "http://127.0.0.1:9000";
    // MinIO服务器的访问密钥
    private static final String ACCESS_KEY = "admin";
    // MinIO服务器的秘密密钥
    private static final String SECRET_KEY = "12345678";

    public static void main(String[] args) {
        try {
            // 创建 MinioClient 实例
            MinioClient minioClient = MinioClient.builder()
                    .endpoint(ENDPOINT)
                    .credentials(ACCESS_KEY, SECRET_KEY)
                    .build();

            // 指定桶名称和上传文件的本地路径
            String bucketName = "test";
            File file = new File("d:\\Users\\lixiaosong\\桌面\\test.png");

            // 创建输入流，用于读取文件内容
            try (InputStream inputStream = new FileInputStream(file)) {
                // 记录上传开始时间
                long start = System.currentTimeMillis();

                // 上传流
                minioClient.putObject(
                        PutObjectArgs.builder()
                                .bucket(bucketName)
                                .object(LocalDateTime.now().getYear() + "/" + file.getName()) // 使用当前时间作为对象名
                                .stream(inputStream, inputStream.available(), -1) // 使用输入流上传文件
                                .build());

                // 记录上传成功及耗时
                System.out.println("上传成功，耗时：" + (System.currentTimeMillis() - start) + " 毫秒");
            }

        } catch (MinioException | IOException | NoSuchAlgorithmException | InvalidKeyException e) {
            e.printStackTrace();
        }

    }
}

截图如下：

最终的代码也是成功执行：

3.1.2 uploadObject

import io.minio.*;
import io.minio.errors.MinioException;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;


public class BucketExists  {
    // MinIO服务器的地址
    private static final String ENDPOINT = "http://127.0.0.1:9000";
    // MinIO服务器的访问密钥
    private static final String ACCESS_KEY = "admin";
    // MinIO服务器的秘密密钥
    private static final String SECRET_KEY = "12345678";

    public static void main(String[] args) {
        try {
            // 创建 MinioClient 实例
            MinioClient minioClient = MinioClient.builder()
                    .endpoint(ENDPOINT)
                    .credentials(ACCESS_KEY, SECRET_KEY)
                    .build();

            // 指定桶名称和上传文件的本地路径
            String bucketName = "test";
            String ObjectName = "test.png";
            String filePath = "d:\\Users\\lixiaosong\\桌面\\test.png";

            long start = System.currentTimeMillis();
            // 上传文件
            minioClient.uploadObject(
                    UploadObjectArgs.builder()
                            .bucket(bucketName)
                            .object(ObjectName)
                            .filename(filePath)
                            .build());

            // 记录上传成功及耗时
            System.out.println("上传成功，耗时：" + (System.currentTimeMillis() - start) + " 毫秒");


        } catch (MinioException | IOException | NoSuchAlgorithmException | InvalidKeyException e) {
            e.printStackTrace();
        }

    }
}

服务器截图如下：

终端截图如下：

3.2 操作对象

以下方法较为简单，就简单说明：

• getObject方法：获取对象数据

// 指定桶名称和上传文件的本地路径
String bucketName = "test";
String objectName = "test.png"; // 对象的名称

// 使用 MinIO 客户端获取对象
GetObjectResponse objectResponse = minioClient.getObject(GetObjectArgs.builder()
        .bucket(bucketName)
        .object(objectName)
        .build());

// 打印获取的对象信息
System.out.println("获取的对象信息 - Bucket: " + objectResponse.bucket() + ", Object: " + objectResponse.object());

// 关闭输入流，释放资源
objectResponse.close();

3.2.1 getPresignedObjectUrl

getPresignedObjectUrl 方法是 MinIO Java SDK 提供的一个方法，用于生成预签名（Pre-Signed）的对象 URL。预签名 URL 允许在不暴露敏感信息（如访问密钥和秘密密钥）的情况下，通过该 URL 对对象进行访问。

以下是关于 getPresignedObjectUrl 方法的一些关键点：

• 生成预签名 URL： 通过调用 getPresignedObjectUrl 方法，你可以生成一个包含签名的 URL，用于访问特定的对象。

• 过期时间： 预签名 URL 包含一个过期时间，一旦过期，该 URL 将不再有效。过期时间通过参数传递给该方法。

• 用途： 预签名 URL 可用于临时授权第三方访问 MinIO 存储桶中的对象，而无需提供访问密钥和秘密密钥。

完整的代码如下：

// 指定桶名称和上传文件的本地路径
String bucketName = "test";
String ObjectName = "test.png";

// 获取预签名的对象URL
/**
 * GetPresignedObjectUrlArgs 用于构建获取预签名对象URL的参数，包括指定的桶名、对象名、HTTP方法（此处为GET）以及链接的有效期。
 * minioClient.getPresignedObjectUrl(...) 用于获取预签名的对象URL。预签名URL是一种带有签名的URL，可以用于在给定的有效期内执行指定的HTTP方法（此处为GET）。
 * .expiry(30, TimeUnit.SECONDS) 指定预签名URL的有效期为30秒。可以根据实际需求调整有效期的时间。
 * 打印预签名的对象URL，可以用于临时授权他人访问该对象
 */
String objectUrl = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
.bucket(bucketName)
.object(objectName)
.method(Method.GET) // 指定URL的HTTP方法，此处为GET
//.expiry(60) // 链接有效期，单位秒，默认值是7天
.expiry(30, TimeUnit.SECONDS) // 在30秒内有效
.build());

3.2.2 getPresignedPostFormData

getPresignedPostFormData 方法是 MinIO Java SDK 提供的一个方法，用于生成预签名 POST 请求的表单数据。这个方法通常用于在客户端生成一个包含认证信息的 HTML 表单，然后让用户在浏览器中提交该表单以执行文件上传操作。

在 MinIO 中，POST 策略是一种用于限制 POST 请求的上传条件的安全机制。通过生成预签名 POST 请求的表单数据，客户端可以使用这些数据在不暴露敏感信息的情况下直接将文件上传到 MinIO 服务器。

下面是关于 getPresignedPostFormData 方法的一些重要说明：

• PostPolicy 对象： 在调用该方法之前，需要创建一个 PostPolicy 对象。PostPolicy 包含了上传策略的详细信息，例如桶名称、对象名称、过期时间、上传条件等。

• 返回值： getPresignedPostFormData 方法返回一个 Map<String, String>，其中包含了表单中的各个字段和对应的值，以及一个特殊的字段 url，它表示 MinIO 服务器的 URL。

• 表单数据的作用： 生成的表单数据中包含了签名、过期时间、桶名称、对象名称等信息。客户端将这些数据填充到 HTML 表单中，并使用浏览器执行 POST 请求时，MinIO 服务器将根据这些信息验证请求的合法性。

• 安全性： 使用预签名 POST 请求，客户端可以在不暴露 MinIO 访问密钥和秘密密钥的情况下进行文件上传。这有助于提高安全性，特别是在将文件上传整合到客户端应用程序中时。

一个包含预签名 POST 请求表单数据的 formData 对象，然后使用这些数据构建 HTML 表单，实现安全地上传文件到 MinIO 服务器

由于使用Post需要过多的校验，此处完整代码：

import io.minio.*;
import io.minio.errors.MinioException;
import okhttp3.*;

import java.io.File;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.time.ZonedDateTime;
import java.util.Map;


public class BucketExists {
    // MinIO服务器的地址
    private static final String ENDPOINT = "http://127.0.0.1:9000";
    // MinIO服务器的访问密钥
    private static final String ACCESS_KEY = "admin";
    // MinIO服务器的秘密密钥
    private static final String SECRET_KEY = "12345678";

    public static void main(String[] args) {
        try {
            // 创建 MinioClient 实例
            MinioClient minioClient = MinioClient.builder()
                    .endpoint(ENDPOINT)
                    .credentials(ACCESS_KEY, SECRET_KEY)
                    .build();

            // 指定桶名称和上传文件的本地路径
            String bucketName = "test";
            String objectName = "test.png";
            String filePath = "d:\\Users\\lixiaosong\\桌面\\test1.jpg";


            // 1. 创建一个Post 策略
            // 为存储桶创建一个上传策略，过期时间为7天
            PostPolicy policy = new PostPolicy(bucketName, ZonedDateTime.now().plusDays(7));
            // 设置一个参数key-value，值为上传对象的名称（保存在桶中的名字）
            policy.addEqualsCondition("key", objectName);
            // 设置文件的格式，public void addStartsWithCondition(@Nonnull String element, @Nonnull String value)
            // 添加 Content-Type以"image/"开头，表示只能上传照片
            policy.addStartsWithCondition("Content-Type", "image/");
            // 文件大小的限制，具体参数：public void addContentLengthRangeCondition(int lowerLimit, int upperLimit)
            policy.addContentLengthRangeCondition(10 * 1024, 10 * 1024 * 1024);

            // 2. 获取策略的 认证令牌、签名等信息
            Map<String, String> formData = minioClient.getPresignedPostFormData(policy);

            // 3.模拟第三方，使用 OkHttp调用 Post上传对象
            // 创建 MultipartBody对象
            MultipartBody.Builder multipartBuilder = new MultipartBody.Builder();
            multipartBuilder.setType(MultipartBody.FORM);

            // 将认证令牌和签名等信息添加到请求体中
            for (Map.Entry<String, String> entry : formData.entrySet()) {
                multipartBuilder.addFormDataPart(entry.getKey(), entry.getValue());
            }

            // 添加其他必要参数
            multipartBuilder.addFormDataPart("key", objectName);// 必须要和策略参数一样
            multipartBuilder.addFormDataPart("Content-Type", "image/png");

            // 上传文件
            File uploadFile = new File(filePath);

            // 具体参数如下：fun addFormDataPart(name: String, filename: String?, body: RequestBody)
            multipartBuilder.addFormDataPart(
                    "file", objectName, RequestBody.create(uploadFile, null));

            // 使用OkHttp调用Post上传对象
            // 构建 POST 请求
            Request request =
                    new Request.Builder()
                            .url(ENDPOINT + "/" + bucketName)
                            .post(multipartBuilder.build())
                            .build();

            OkHttpClient httpClient = new OkHttpClient().newBuilder().build();
            // 发送 POST 请求
            Response response = httpClient.newCall(request).execute();

            // 检查响应是否成功
            if (response.isSuccessful()) {
                System.out.println("对象上传成功，使用 POST 方法");
            } else {
                System.out.println("对象上传失败");
            }


        } catch (MinioException | IOException | NoSuchAlgorithmException | InvalidKeyException e) {
            e.printStackTrace();
        }

    }
}

截图如下：

3.2.3 listObjects

listObjects 方法用于列举存储桶中的对象（或文件）

通过这个方法，可以获取存储桶中所有对象的信息，例如对象名称、大小、最后修改时间等

以下是关于 listObjects 方法的一些关键信息：

1. 返回对象列表： 调用 listObjects 方法将返回一个包含对象信息的列表。每个对象信息包括对象名称、大小、最后修改时间等。

import io.minio.*;
import io.minio.errors.MinioException;
import io.minio.messages.Item;

import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;



public class BucketExists {
    // MinIO服务器的地址
    private static final String ENDPOINT = "http://127.0.0.1:9000";
    // MinIO服务器的访问密钥
    private static final String ACCESS_KEY = "admin";
    // MinIO服务器的秘密密钥
    private static final String SECRET_KEY = "12345678";

    public static void main(String[] args) {
        try {
            // 创建 MinioClient 实例
            MinioClient minioClient = MinioClient.builder()
                    .endpoint(ENDPOINT)
                    .credentials(ACCESS_KEY, SECRET_KEY)
                    .build();

            // 指定桶名称和上传文件的本地路径
            String bucketName = "test";
            Iterable<Result<Item>> listObjects = minioClient.listObjects(ListObjectsArgs.builder()
                    .bucket(bucketName)
                    .build());

            for (Result<Item> result : listObjects) {
                Item item = result.get();
                System.out.println("文件名：" + item.objectName() + "\t 文件大小 ： " + item.size() );
            }
            
        } catch (MinioException | IOException | NoSuchAlgorithmException | InvalidKeyException e) {
            e.printStackTrace();
        }

    }
}

截图如下：

第二个关键信息：

2. 前缀和递归： 你可以通过设置前缀来筛选只返回符合条件的对象。此外，通过设置 recursive 参数，可以实现递归列举，即列举指定前缀下的所有对象，包括子文件夹中的对象

会递归文件夹里文件，递归输出！

// 指定桶名称和上传文件的本地路径
String bucketName = "test";
Iterable<Result<Item>> listObjects = minioClient.listObjects(ListObjectsArgs.builder()
        .bucket(bucketName)
        .recursive(true)
        .build());

for (Result<Item> result : listObjects) {
    Item item = result.get();
    System.out.println("文件名：" + item.objectName() + "\t 文件大小 ： " + item.size() );
}

3. 继续标记： 如果存储桶中的对象数量较大，可能会分页返回结果。在这种情况下，listObjects 方法将返回一个继续标记（continuation token），以便获取下一页的结果。

除了上述花样，还可条件查询：

// 指定桶名称和上传文件的本地路径
String bucketName = "test";
// 条件查询
Iterable<Result<Item>> listObjects = minioClient.listObjects(ListObjectsArgs.builder()
        .bucket(bucketName)
        .startAfter("test")
        .prefix("t") // 指定前缀
        .maxKeys(100) // 最大数量
        .recursive(true) // 递归
        .build());


for (Result<Item> result : listObjects) {
    Item item = result.get();
    System.out.println("文件名：" + item.objectName() + "\t 文件大小 ： " + item.size() );
}

3.2.4 copyObject

copyObject 方法用于在 MinIO 中将对象从一个桶（Bucket）复制到另一个桶，或者在同一桶内复制对象。这个方法可以用于创建对象的备份、迁移数据、或在桶内进行对象的重命名。

以下是关于 copyObject 方法的一些关键信息：

• 源对象和目标对象： 在调用 copyObject 方法时，你需要指定源对象的桶名和对象名，以及目标对象的桶名和对象名。

• 可选参数： 除了源对象和目标对象的信息外，copyObject 方法还可以接受一些可选参数，例如设置自定义元数据、存储类别、访问权限等。

• 元数据保留： 在复制对象时，MinIO 会保留源对象的元数据（metadata）。

• copyObject方法：复制对象
  这个方法比较有意思，我就post全部代码

import io.minio.*;
import io.minio.errors.MinioException;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;



public class BucketExists {
    // MinIO服务器的地址
    private static final String ENDPOINT = "http://127.0.0.1:9000";
    // MinIO服务器的访问密钥
    private static final String ACCESS_KEY = "admin";
    // MinIO服务器的秘密密钥
    private static final String SECRET_KEY = "12345678";

    public static void main(String[] args) {
        try {
            // 创建 MinioClient 实例
            MinioClient minioClient = MinioClient.builder()
                    .endpoint(ENDPOINT)
                    .credentials(ACCESS_KEY, SECRET_KEY)
                    .build();

            // 指定桶名称和上传文件的本地路径
            String bucketName = "test";
            String bucketName2 = "test2";
            
            // 某一个桶复制对象到另一个桶
            minioClient.copyObject(CopyObjectArgs.builder()
                    .source(CopySource.builder()
                            .bucket(bucketName)
                            .object("objectName")
                            .build())
                    .bucket(bucketName2)
                    .object("objectName")
                    .build());


        } catch (MinioException | IOException | NoSuchAlgorithmException | InvalidKeyException e) {
            e.printStackTrace();
        }

    }
}

由于我的test2桶没有，代码不会自动创建，所以爆了这个错误：

3.2.5 downloadObject

downloadObject 方法用于从 MinIO 中下载对象到本地文件系统。通过这个方法，可以将存储桶中的对象下载到本地，以便在客户端应用程序中进行处理、查看或保存。

以下是关于 downloadObject 方法的一些关键信息：

1. 指定桶名和对象名： 在调用 downloadObject 方法时，你需要指定源对象的桶名和对象名，以及本地文件系统中保存对象内容的文件路径。

2. 下载范围： 可以通过设置 offset 和 length 参数来下载对象的指定范围。这对于分块下载或断点续传非常有用。

3. 可选参数： 除了桶名、对象名和本地文件路径之外，downloadObject 方法还可以接受一些可选参数，例如设置自定义响应头、版本 ID 等。

// 指定桶名称和上传文件的本地路径
String bucketName = "test";
String ObjectName = "test.png";
String filePath = "d:\\Users\\lixiaosong\\桌面\\test1.jpg";

/**
 * DownloadObjectArgs 用于构建下载对象的参数，包括指定的桶名、对象名和本地文件路径。
 * minioClient.downloadObject(...) 用于将对象从MinIO服务器下载到本地文件。
 * .filename(filePath) 指定本地文件路径，必须提供有效的文件名，以保存下载的对象。
 */
minioClient.downloadObject(DownloadObjectArgs.builder()
        .bucket(bucketName)
        .object(ObjectName)
        .filename(filePath) // 必须指定文件名
        .build());

3.2.6 removeObject

对于删除比较特殊，此处一定要做一个判断

removeObject 方法用于从 MinIO 中删除存储桶中的对象。通过这个方法，可以删除指定桶中的特定对象，清理存储空间或执行一些数据管理任务。

以下是关于 removeObject 方法的一些关键信息：

1. 指定桶名和对象名： 在调用 removeObject 方法时，你需要指定要删除的对象所在的桶名和对象名。

2. 可选参数： 除了桶名和对象名之外，removeObject 方法还可以接受一些可选参数，例如设置版本 ID、法定持有人等。

// 指定桶名称和上传文件的本地路径
String bucketName = "test";
String objectName = "test.png";
minioClient.removeObject(RemoveObjectArgs.builder()
        .bucket(bucketName)
        .object(objectName)
        //.versionId("my-versionid") //还可以删除指定版本号的对象
        .build());

3.2.7 removeObjects

MinIO Java SDK中并没有提供名为 removeObjects 的方法

删除单个对象使用 removeObject 方法，而删除多个对象时，通常会使用 removeObjects 方法，但需要在应用层循环调用 removeObject

// 指定桶名称和上传文件的本地路径
String bucketName = "test";

// 待删除的对象列表
List<String> objectNamesToDelete = Arrays.asList("test.png", "test1.jpg");

// 循环调用 removeObject 删除每个对象
for (String objectName : objectNamesToDelete) {
    minioClient.removeObject(
            RemoveObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .build());
    System.out.println("对象 " + objectName + " 删除成功！");
}

或者另外一种方式：

import io.minio.*;
import io.minio.errors.MinioException;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;

import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.LinkedList;
import java.util.List;


public class BucketExists {
    // MinIO服务器的地址
    private static final String ENDPOINT = "http://127.0.0.1:9000";
    // MinIO服务器的访问密钥
    private static final String ACCESS_KEY = "admin";
    // MinIO服务器的秘密密钥
    private static final String SECRET_KEY = "12345678";

    public static void main(String[] args) {
        try {
            // 创建 MinioClient 实例
            MinioClient minioClient = MinioClient.builder()
                    .endpoint(ENDPOINT)
                    .credentials(ACCESS_KEY, SECRET_KEY)
                    .build();

            // 指定桶名称和上传文件的本地路径
            String bucketName = "test";

            // 构建需要删除的对象
            List<DeleteObject> objects = new LinkedList<>();
            objects.add(new DeleteObject("test.png"));
            objects.add(new DeleteObject("test1.jpg"));
            // 删除
            Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder()
                    .bucket(bucketName)
                    .objects(objects)
                    .build());
            for (Result<DeleteError> result : results) {
                // 删除文件不存在时，不会报错
                DeleteError error = result.get();
                System.out.println("Error in deleting object " + error.objectName() + "; " + error.message());
            }


        } catch (MinioException | IOException | NoSuchAlgorithmException | InvalidKeyException e) {
            e.printStackTrace();
        }

    }
}