MinIO相关工具库，上传下载等

目录结构

配置文件-application.properties

server.port=8888
spring.servlet.multipart.max-file-size=100MB
spring.servlet.multipart.max-request-size=100MB

minio.config.accessKey=bunny
minio.config.secretKey=112233
#minio.config.url=http://192.168.31.140:9000
minio.config.url=http://192.168.2.156:9000

config包

在文件夹下新建config包，在里面新建java类—MinioConfig

package com.example.minio.config;


import io.minio.MinioClient;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Data
@Configuration
@ConfigurationProperties(prefix = "minio.config")
public class MinioConfig {
    private String url;
    private String accessKey;
    private String secretKey;

    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder().endpoint(url).credentials(accessKey, secretKey).build();
    }
}

utiles包下新建MinioUtils

package com.example.minio.utils;

import io.minio.*;
import io.minio.errors.*;
import io.minio.messages.*;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

@Component
@Log4j2
public class MinioUtils {
    @Autowired
    private MinioClient minioClient;

    /**
     * 判断桶是否存在
     *
     * @param bucketName 桶名称
     * @return 布尔值，是否存在
     */
    public boolean bucketExists(String bucketName) {
        boolean found = false;
        try {
            found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return found;
    }

    /**
     * 删除桶的加密配置
     *
     * @param bucketName 桶名称
     * @return 是否删除成功，返回布尔值
     */
    public boolean deleteBucketEncryption(String bucketName) {
        boolean isDelete = false;
        try {
            minioClient.deleteBucketEncryption(DeleteBucketEncryptionArgs.builder().build());
            isDelete = true;
            log.info("删除桶的加密配置 ------ 成功");
        } catch (Exception exception) {
            log.info("删除桶的加密配置 ------ 失败");
            exception.printStackTrace();
        }

        return isDelete;
    }

    /**
     * 删除桶的生命周期配置。
     *
     * @param bucketName 桶名称
     * @return 返回布尔值，是否删除成功
     */
    public boolean deleteBucketLifecycle(String bucketName) {
        boolean isDelete = false;

        try {
            minioClient.deleteBucketLifecycle(DeleteBucketLifecycleArgs.builder().build());
            isDelete = true;
            log.info("删除桶的生命周期配置 ------ 成功");
        } catch (Exception exception) {
            exception.printStackTrace();
            log.info("删除桶的生命周期配置 ------ 失败");
        }
        return isDelete;
    }

    /**
     * 删除桶的通知配置。
     *
     * @param bucketName 桶的名称
     * @return 返回布尔值是否删除成功
     */
    public boolean deleteBucketNotification(String bucketName) {
        boolean isDelete = false;
        try {
            minioClient.deleteBucketNotification(DeleteBucketNotificationArgs.builder().bucket(bucketName).build());
            isDelete = true;
            log.info("删除桶的通知配置。 ------ 成功");
        } catch (Exception exception) {
            exception.printStackTrace();
            log.info("删除桶的通知配置。 ------ 失败");
        }

        return isDelete;
    }

    /**
     * 删除桶中的对象锁配置。
     *
     * @param bucketName 桶的名称
     * @return 返回布尔值是否删除成功
     */
    public boolean deleteObjectLockConfiguration(String bucketName) {
        boolean isDelete = false;

        try {
            minioClient.deleteObjectLockConfiguration(DeleteObjectLockConfigurationArgs.builder().bucket(bucketName).build());
            isDelete = true;
            log.info("删除桶中的对象锁配置。 ------ 成功");
        } catch (Exception exception) {
            exception.printStackTrace();
            log.info("删除桶中的对象锁配置。 ------ 失败");
        }

        return isDelete;
    }

    /**
     * 删除桶策略配置。
     *
     * @param bucketName 桶的名称
     * @return 返回布尔值是否删除成功
     */
    public boolean deleteBucketPolicy(String bucketName) {
        boolean isDelete = false;

        try {
            minioClient.deleteBucketPolicy(DeleteBucketPolicyArgs.builder().bucket(bucketName).build());
            isDelete = true;
            log.info("删除桶中的对象锁配置。 ------ 成功");
        } catch (Exception exception) {
            exception.printStackTrace();
            log.info("删除桶中的对象锁配置。 ------ 失败");
        }

        return isDelete;
    }

    /**
     * 删除桶的桶复制配置。
     *
     * @param bucketName 桶的名称
     * @return 返回布尔值是否删除成功
     */
    public boolean deleteBucketReplication(String bucketName) {
        boolean isDelete = false;

        try {
            minioClient.deleteBucketReplication(DeleteBucketReplicationArgs.builder().bucket(bucketName).build());
            isDelete = true;
            log.info("删除桶中的对象锁配置。 ------ 成功");
        } catch (Exception exception) {
            exception.printStackTrace();
            log.info("删除桶中的对象锁配置。 ------ 失败");
        }

        return isDelete;
    }

    /**
     * 删除桶的标签。
     *
     * @param bucketName 桶的名称
     * @return 返回布尔值是否删除成功
     */
    public boolean deleteBucketTags(String bucketName) {
        boolean isDelete = false;

        try {
            minioClient.deleteBucketTags(DeleteBucketTagsArgs.builder().bucket(bucketName).build());
            isDelete = true;
            log.info("删除桶的标签。 ------ 成功");
        } catch (Exception exception) {
            exception.printStackTrace();
            log.info("删除桶的标签。 ------ 失败");
        }

        return isDelete;
    }

    /**
     * 获取存储桶的加密配置。
     *
     * @param bucketName 桶的名称
     * @return SseConfiguration 获取成功不为null
     */
    public SseConfiguration getBucketEncryption(String bucketName) {
        SseConfiguration conf = null;

        try {
            conf = minioClient.getBucketEncryption(GetBucketEncryptionArgs.builder().bucket(bucketName).build());
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        return conf;
    }

    /**
     * 获取存储桶的生命周期配置。
     *
     * @param bucketName 桶的名称
     * @return LifecycleConfiguration 获取成功不为null
     */
    public LifecycleConfiguration getBucketLifecycle(String bucketName) {
        LifecycleConfiguration lifecycle = null;
        try {
            lifecycle = minioClient.getBucketLifecycle(GetBucketLifecycleArgs.builder().bucket(bucketName).build());
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        return lifecycle;
    }

    /**
     * 获取存储桶的通知配置。
     *
     * @param bucketName 桶的名称
     * @return NotificationConfiguration 获取成功不为null
     */
    public NotificationConfiguration getBucketNotification(String bucketName) {
        NotificationConfiguration configuration = null;

        try {
            configuration = minioClient.getBucketNotification(GetBucketNotificationArgs.builder().bucket(bucketName).build());
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        return configuration;
    }

    /**
     * 获取桶的桶策略配置。
     *
     * @param bucketName 桶的名称
     * @return String 获取成功不为null
     */
    public String getBucketPolicy(String bucketName) {
        String config = null;

        try {
            config = minioClient.getBucketPolicy(GetBucketPolicyArgs.builder().bucket(bucketName).build());
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        return config;
    }

    /**
     * 获取桶的桶策略配置
     *
     * @param bucketName 桶的名称
     * @return ReplicationConfiguration 获取成功不为null
     */
    public ReplicationConfiguration getBucketReplication(String bucketName) {
        ReplicationConfiguration configuration = null;

        try {
            configuration = minioClient.getBucketReplication(GetBucketReplicationArgs.builder().bucket(bucketName).build());
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        return configuration;
    }

    /**
     * 获取存储桶的标签。
     *
     * @param bucketName 桶的名称
     * @return Tags 获取成功不为null
     */
    public Tags getBucketTags(String bucketName) {
        Tags tags = null;

        try {
            tags = minioClient.getBucketTags(GetBucketTagsArgs.builder().bucket(bucketName).build());
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return tags;
    }

    /**
     * 获取存储桶的版本控制配置。
     *
     * @param bucketName 桶的名称
     * @return Tags 获取成功不为null
     */
    public VersioningConfiguration getBucketVersioning(String bucketName) {
        VersioningConfiguration configuration = null;

        try {
            configuration = minioClient.getBucketVersioning(GetBucketVersioningArgs.builder().bucket(bucketName).build());
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        return configuration;
    }

    /**
     * 获取存储桶中的对象锁配置。
     *
     * @param bucketName 桶的名称
     * @return Tags 获取成功不为null
     */
    public ObjectLockConfiguration getObjectLockConfiguration(String bucketName) {
        ObjectLockConfiguration configuration = null;
        try {
            configuration = minioClient.getObjectLockConfiguration(GetObjectLockConfigurationArgs.builder().bucket(bucketName).build());
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        return configuration;
    }

    /**
     * 列出所有桶的桶信息。
     *
     * @return Tags 获取成功不为null
     */
    public List<Bucket> listBuckets() {
        List<Bucket> buckets = null;

        try {
            buckets = minioClient.listBuckets();
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        return buckets;
    }

    /**
     * 创建一个启用了给定区域和对象锁特性的桶。
     *
     * @param bucketName 桶的名称
     * @return boolean 返回是否创建成功
     */
    public boolean makeBucket(String bucketName) {
        boolean isComplete = false;

        try {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            isComplete = true;
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        return isComplete;
    }

    /**
     * 移除空桶。
     *
     * @param bucketName 桶的名称
     * @return boolean 是否删除成功
     */
    public boolean removeBucket(String bucketName) {
        boolean isRemoved = false;

        try {
            minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
            isRemoved = true;
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        return isRemoved;
    }

    /**
     * 设置桶的加密配置。
     *
     * @param bucketName    同名称
     * @param configuration 配置信息
     * @return 布尔值是否完成
     */
    public boolean setBucketEncryption(String bucketName, SseConfiguration configuration) {
        boolean isComplete = false;

        try {
            minioClient.setBucketEncryption(SetBucketEncryptionArgs
                    .builder()
                    .bucket(bucketName)
                    .config(configuration)
                    .build());
            isComplete = true;
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        return isComplete;
    }

    /**
     * 设置桶的版本配置。
     *
     * @param bucketName    同名称
     * @param configuration VersioningConfiguration 配置信息
     * @return 布尔值是否完成
     */
    public boolean setBucketVersioning(String bucketName, VersioningConfiguration configuration) {
        boolean isComplete = false;

        try {
            minioClient.setBucketVersioning(
                    SetBucketVersioningArgs.builder().bucket(bucketName).config(configuration).build());
            isComplete = true;
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        return isComplete;
    }

    /**
     * 设置/修改桶标签
     *
     * @param bucketName 桶名称
     * @param map        Map<String, String> map集合
     * @return 布尔值是否完成
     */
    public boolean setBucketTags(String bucketName, Map<String, String> map) {
        boolean isComplete = false;
        try {
            minioClient.setBucketTags(SetBucketTagsArgs.builder().bucket(bucketName).tags(map).build());
            isComplete = true;
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return isComplete;
    }

    /**
     * 复制另一个桶中文件
     *
     * @param bucketName       桶中名字
     * @param objectName       复制名称
     * @param sourceBucketName 复制到桶中名称
     * @param sourceObjectName 复制完成后名称
     * @return 布尔值是否完成
     */
    public boolean copyObject(String bucketName, String objectName, String sourceBucketName, String sourceObjectName) {
        boolean isComplete = false;

        try {
            minioClient.copyObject(
                    CopyObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .source(
                                    CopySource.builder()
                                            .bucket(sourceBucketName)
                                            .object(sourceObjectName)
                                            .build())
                            .build());
            isComplete = true;
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        return isComplete;
    }

    /**
     * 删除对象的标记。
     *
     * @param bucketName 桶中名字
     * @param objectName 复制名称
     * @return 布尔值是否完成
     */
    public boolean deleteObjectTags(String bucketName, String objectName) {
        boolean isComplete = false;

        try {
            minioClient.deleteObjectTags(DeleteObjectTagsArgs.builder().bucket(bucketName).object(objectName).build());
            isComplete = true;
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        return isComplete;
    }

    /**
     * 下载文件
     *
     * @param bucketName 桶名称
     * @param objectName 对象名称
     * @param filename   文件名
     */
    public void downloadObject(String bucketName, String objectName, String filename) {
        try {
            minioClient.downloadObject(
                    DownloadObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .filename(filename)
                            .build());
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }

    /**
     * 获取文件
     *
     * @param bucketName 桶名称
     * @param objectName 对象名称
     */
    public InputStream getObject(String bucketName, String objectName) {
        try {
            return minioClient.getObject(GetObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .build());
        } catch (Exception exception) {
            exception.printStackTrace();
            return null; // 或者抛出自定义异常
        }
    }

    /**
     * 上传文件
     *
     * @param bucketName  桶名称
     * @param filename    文件名
     * @param inputStream 输入流
     * @param size        大小
     */
    public void putObject(String bucketName, String filename, InputStream inputStream, Long size) {
        try {
            minioClient.putObject(
                    PutObjectArgs.builder().bucket(bucketName)
                            .object(filename)
                            .stream(inputStream, size, -1)
                            .build());
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }


    /**
     * 上传文件
     *
     * @param bucketName  桶名称
     * @param filename    文件名
     * @param contentType 文件类型
     * @param inputStream 输入流
     * @param size        大小
     */
    public void putObject(String bucketName, String filename, String contentType, InputStream inputStream, Long size) {
        try {
            minioClient.putObject(
                    PutObjectArgs.builder().bucket(bucketName)
                            .object(filename)
                            .stream(inputStream, size, -1)
                            .contentType(contentType)
                            .build());
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }

    /**
     * 删除文件
     *
     * @param bucketName 桶名称
     * @param objectName 对象名称
     */
    public void removeObject(String bucketName, String objectName) {
        try {
            minioClient.removeObject(
                    RemoveObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .build());
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }
}