minio的基本使用——java

小咪咪 2023-10-13 12:32 145阅读 0赞

## 第一步：下载minio服务安装包 ##

去官网下载：[MinIO | 用于创建高性能对象存储的代码和下载内容][MinIO _]

minio的使用文档：[MinIO Object Storage for Kubernetes — MinIO Object Storage for Kubernetes][MinIO Object Storage for Kubernetes _ MinIO Object Storage for Kubernetes]

MinIo有两个重要的对象，服务器minio.exe和客户端minio.client。搭建服务器用于接收文件信息，客户端用于上传文件。![320da31c2267431d92e772ddc6a6954d.png][]

**官网下载有些慢**

**记住一点：如果是下载windows版本的，切记千万不能去双击运行，这样可能会导致最终启动失败；无论是windows还是linux都是通过命令启动的。**

## **第二步：启动minio服务器** ##

### 1.minio服务的启动命令 ###

在windows环境下，在你的minio.exe文件所在位置的文件夹下（最好在同级路径下创建一个类似data的文件夹，用于存储数据），打开cmd命令框，

输入：minio.exe server D:\\Java\_study\\javaEE-study\\JAVA\\minio\\data（后面的数据存储路径文件夹是自定义的）

（如果是linux启动minio服务器，则在对应的minio存放的路径下输入：./minio server ./data）

![3c942652bfb545eca0ad0c578dcdd7d8.png][]

### 2.访问minio服务器 ###

打开浏览器输入上面的访问地址和端口即可访问minio服务器的ui界面

![73c5bb680cb0457fa1ffde3ad7309acf.png][]

### 3.minio服务端主界面简单介绍 ###

![c70a56bcb6394dd6be821b0e4c6e9984.png][]

点开任意一个桶

### ![324d5b37603d45eab0f1eb6b9ccc3dd7.png][] 4.纯java入门minio参考 ###

package com.jdh.minio;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.InputStream;
    import java.util.List;
    
    import io.minio.*;
    import io.minio.messages.Bucket;
    
    /**
     * @ClassName: FileUploader
     * @Author: jdh
     * @CreateTime: 2022-04-15
     * @Description: minio基本操作demo
     */
    
    public class FileUploader {
    
        public static void main(String[] args) {
            try {
                // 创建客户端
                MinioClient minioClient =
                        MinioClient.builder()
                                // api地址
                                .endpoint("127.0.0.1",9000,true)
    //                            .endpoint("http://127.0.0.1:9000")
                                // 前面设置的账号密码
                                .credentials("minioadmin", "minioadmin")
                                .build();
    
                System.out.println(minioClient);
                // 检查桶是否存在
                boolean found = minioClient.bucketExists(BucketExistsArgs.builder().bucket("test").build());
                if (!found) {
                    // 创建桶
                    minioClient.makeBucket(MakeBucketArgs.builder().bucket("test").build());
                }
    
                //列出所有桶名
                List<Bucket> buckets = minioClient.listBuckets();
                for (Bucket i : buckets){
                    System.out.println(i.name());
                }
    
                //删除某一个桶
    //            minioClient.removeBucket(
    //                    RemoveBucketArgs.builder()
    //                            .bucket("桶名称")
    //                            .build());
    
    
    
                System.out.println("开始你的操作");
    
                File file = new File("D:\\Java_study\\javaEE-study\\user.xlsx");
    
                String fileName = file.getName();
                String realFileName = fileName.substring(fileName.lastIndexOf("\\")+1, fileName.lastIndexOf("."));
                String fileType = fileName.substring(fileName.lastIndexOf(".")+1);
    
                //通过路径上传一个文件
                ObjectWriteResponse testDir = minioClient.uploadObject(
                        UploadObjectArgs.builder()
                                .bucket("test")
                                .object("user_Path1")//文件名字
                                .filename("D:\\Java_study\\javaEE-study\\user.xlsx")//文件存储的路径
                                .contentType(fileType)
                                .build());
    
                //通过文件格式上传一个文件
                InputStream fileInputStream = new FileInputStream(file);
                long size = file.length();
    
                minioClient.putObject(
                        PutObjectArgs.builder()
                                .bucket("test")
                                .object("user_File1")
                                .stream(fileInputStream, size, -1)
                                .contentType(fileType)
                                .build());
    
                //文件下载，都是这种下载到指定路径
                minioClient.downloadObject(DownloadObjectArgs.builder()
                        .bucket("test")
                        .object("user")
                        .filename("D:\\Java_study\\javaEE-study\\user_test.xlsx")
                        .build());
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

## 第三步：java整合minio ##

此demo演示的是springboot项目整合minio，demo中minio版本是8.0.3，但参考版本最低7.x以上。

demo项目gitee连接：[https://gitee.com/java\_utils\_demo/java\_minio\_demo.git][https_gitee.com_java_utils_demo_java_minio_demo.git]

### 1.创建一个springboot的项目 ###

![91640e1e4bc647219e360e65bb535233.png][]

### 2.在pom里面引入对应的依赖 ###

（新手别忘记引入springboot的父依赖）

<dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
            </dependency>
            
            <dependency>
                <groupId>io.minio</groupId>
                <artifactId>minio</artifactId>
                <version>8.0.3</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba.fastjson2</groupId>
                <artifactId>fastjson2</artifactId>
                <version>2.0.12</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        </dependencies>

### 3.在application.yml配置文件配置 ###

下面的配置实际可有可无，只是在创建minio的客户端的时候需要的一些连接服务端的一些相关配置信息

server:
      port: 8080
    # Minio配置
    minio:
      config:
        ip: 127.0.0.1 #ip地址
        port: 9000  #  端口号
        accessKey: minioadmin #  账号
        secretKey: minioadmin #  密码
        secure: false #如果是true，则用的是https而不是http,默认值是true
        bucketName: "jdh-bucket"  # 桶的名字
        downloadDir: "/data/excel"  #保存到本地的路径

### 4.创建一个配置文件类 ###

下面配置文件类就是通过spring的ConfigurationProperties注解完成配置文件中相关参数的注入

package com.jdh.minio.config;
    
    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    /**
     * @ClassName: MinioProperties
     * @Author: jdh
     * @CreateTime: 2022-04-15
     * @Description:
     */
    @Component
    @Data
    @ConfigurationProperties(prefix = "minio.config")
    public class MinioProperties {
    
        /**
         * API调用地址ip
         */
        private String ip;
    
        /**
         * API调用地址端口
         */
        private Integer port;
    
        /**
         * 连接账号
         */
        private String accessKey;
    
        /**
         * 连接秘钥
         */
        private String secretKey;
    
        /**
         * minio存储桶的名称
         */
        private String bucketName;
    
        /**
         * 文件下载到本地的路径
         */
        private String downloadDir;
    
        /**
         * #如果是true，则用的是https而不是http,默认值是true
         */
        private Boolean secure;
    
    }

### 5.封装一些简单的方法 ###

如：获取一个minio连接客户端、文件上下传封装、创建\\删除桶、列出所有桶\\文件信息等

package com.jdh.minio.config;
    
    import io.minio.*;
    import io.minio.errors.*;
    import io.minio.http.Method;
    import io.minio.messages.Bucket;
    import io.minio.messages.DeleteObject;
    import io.minio.messages.Item;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.util.StringUtils;
    import org.springframework.web.multipart.MultipartFile;
    
    import javax.annotation.Resource;
    import javax.servlet.http.HttpServletResponse;
    import java.io.*;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.time.LocalDateTime;
    import java.time.ZonedDateTime;
    import java.util.List;
    import java.util.Map;
    import java.util.UUID;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @ClassName: MinioFile
     * @Author: jdh
     * @CreateTime: 2022-04-15
     * @Description:
     */
    @Configuration
    @Slf4j
    public class MinioFileUtil {
    
        @Resource
        private MinioProperties minioProperties;
    
        private MinioClient minioClient;
    
        /**
         * 这个是6.0.左右的版本
         * @return MinioClient
         */
    //    @Bean
    //    public MinioClient getMinioClient(){
    //
    //        String url = "http:" + minioProperties.getIp() + ":" + minioProperties.getPort();
    //
    //        try {
    //            return new MinioClient(url, minioProperties.getAccessKey(), minioProperties.getSecretKey());
    //        } catch (InvalidEndpointException | InvalidPortException e) {
    //            e.printStackTrace();
    //            log.info("-----创建Minio客户端失败-----");
    //            return null;
    //        }
    //    }
    
        /**
         * 下面这个和上面的意思差不多，但是这个是新版本
         * 获取一个连接minio服务端的客户端
         *
         * @return MinioClient
         */
        @Bean
        public MinioClient getClient() {
    
            String url = "http:" + minioProperties.getIp() + ":" + minioProperties.getPort();
            MinioClient minioClient = MinioClient.builder()
                    .endpoint(url)    //两种都可以,这种全路径的其实就是下面分开配置一样的
    //                        .endpoint(minioProperties.getIp(),minioProperties.getPort(),minioProperties.getSecure())
                    .credentials(minioProperties.getAccessKey(), minioProperties.getSecretKey())
                    .build();
            this.minioClient = minioClient;
            return minioClient;
        }
    
        /**
         * 创建桶
         *
         * @param bucketName 桶名称
         */
        public void createBucket(String bucketName) throws Exception {
            if (!StringUtils.hasLength(bucketName)) {
                throw new RuntimeException("创建桶的时候，桶名不能为空！");
            }
    
            // Create bucket with default region.
            minioClient.makeBucket(MakeBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        }
    
        /**
         * 创建桶,固定minio容器
         *
         * @param bucketName 桶名称
         */
        public void createBucketByRegion(String bucketName, String region) throws Exception {
            if (!StringUtils.hasLength(bucketName)) {
                throw new RuntimeException("创建桶的时候，桶名不能为空！");
            }
            MinioClient minioClient = this.getClient();
    
            // Create bucket with specific region.
            minioClient.makeBucket(MakeBucketArgs.builder()
                    .bucket(bucketName)
                    .region(region) //
                    .build());
    
    //        // Create object-lock enabled bucket with specific region.
    //        minioClient.makeBucket(
    //                MakeBucketArgs.builder()
    //                        .bucket("my-bucketname")
    //                        .region("us-west-1")
    //                        .objectLock(true)
    //                        .build());
        }
    
        /**
         * 修改桶名
         * (minio不支持直接修改桶名，但是可以通过复制到一个新的桶里面，然后删除老的桶)
         *
         * @param oldBucketName 桶名称
         * @param newBucketName 桶名称
         */
        public void renameBucket(String oldBucketName, String newBucketName) throws Exception {
            if (!StringUtils.hasLength(oldBucketName) || !StringUtils.hasLength(newBucketName)) {
                throw new RuntimeException("修改桶名的时候，桶名不能为空！");
            }
    
        }
    
        /**
         * 删除桶
         *
         * @param bucketName 桶名称
         */
        public void deleteBucket(String bucketName) throws Exception {
            if (!StringUtils.hasLength(bucketName)) {
                throw new RuntimeException("删除桶的时候，桶名不能为空！");
            }
    
            minioClient.removeBucket(
                    RemoveBucketArgs.builder()
                            .bucket(bucketName)
                            .build());
        }
    
        /**
         * 检查桶是否存在
         *
         * @param bucketName 桶名称
         * @return boolean true-存在 false-不存在
         */
        public boolean checkBucketExist(String bucketName) throws Exception {
            if (!StringUtils.hasLength(bucketName)) {
                throw new RuntimeException("检测桶的时候，桶名不能为空！");
            }
    
            return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        }
    
        /**
         * 列出所有的桶
         *
         * @return 所有桶名的集合
         */
        public List<Bucket> getAllBucketInfo() throws Exception {
    
            //列出所有桶
            List<Bucket> buckets = minioClient.listBuckets();
            return buckets;
        }
    
        /**
         * 列出某个桶中的所有文件名
         * 文件夹名为空时，则直接查询桶下面的数据，否则就查询当前桶下对于文件夹里面的数据
         *
         * @param bucketName 桶名称
         * @param folderName 文件夹名
         * @param isDeep     是否递归查询
         */
        public Iterable<Result<Item>> getBucketAllFile(String bucketName, String folderName, Boolean isDeep) throws Exception {
            if (!StringUtils.hasLength(bucketName)) {
                throw new RuntimeException("获取桶中文件列表的时候，桶名不能为空！");
            }
            if (!StringUtils.hasLength(folderName)) {
                folderName = "";
            }
            System.out.println(folderName);
            Iterable<Result<Item>> listObjects = minioClient.listObjects(
                    ListObjectsArgs
                            .builder()
                            .bucket(bucketName)
                            .prefix(folderName + "/")
                            .recursive(isDeep)
                            .build());
    
    //        for (Result<Item> result : listObjects) {
    //            Item item = result.get();
    //            System.out.println(item.objectName());
    //        }
    
            return listObjects;
        }
    
        /**
         * 删除文件夹
         *
         * @param bucketName 桶名
         * @param objectName 文件夹名
         * @param isDeep     是否递归删除
         * @return
         */
        public Boolean deleteBucketFile(String bucketName, String objectName) {
            if (!StringUtils.hasLength(bucketName) || !StringUtils.hasLength(objectName)) {
                throw new RuntimeException("删除文件的时候，桶名或文件名不能为空！");
            }
            try {
                minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
                return true;
            } catch (Exception e) {
                log.info("删除文件失败");
                return false;
            }
        }
    
        /**
         * 删除文件夹
         *
         * @param bucketName 桶名
         * @param objectName 文件夹名
         * @param isDeep     是否递归删除
         * @return
         */
        public Boolean deleteBucketFolder(String bucketName, String objectName, Boolean isDeep) {
            if (!StringUtils.hasLength(bucketName) || !StringUtils.hasLength(objectName)) {
                throw new RuntimeException("删除文件夹的时候，桶名或文件名不能为空！");
            }
            try {
                ListObjectsArgs args = ListObjectsArgs.builder().bucket(bucketName).prefix(objectName + "/").recursive(isDeep).build();
                Iterable<Result<Item>> listObjects = minioClient.listObjects(args);
                listObjects.forEach(objectResult -> {
                    try {
                        Item item = objectResult.get();
                        minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(item.objectName()).build());
                    } catch (Exception e) {
                        log.info("删除文件夹中的文件异常", e);
                    }
                });
                return true;
            } catch (Exception e) {
                log.info("删除文件夹失败");
                return false;
            }
        }
    
        /**
         * 获取文件下载地址
         *
         * @param bucketName 桶名
         * @param objectName 文件名
         * @param expires    过期时间,默认秒
         * @return
         * @throws Exception
         */
        public String getFileDownloadUrl(String bucketName, String objectName, Integer expires) throws Exception {
    
            GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder()
                    .method(Method.GET)//下载地址的请求方式
                    .bucket(bucketName)
                    .object(objectName)
                    .expiry(expires, TimeUnit.SECONDS)//下载地址过期时间
                    .build();
            String objectUrl = minioClient.getPresignedObjectUrl(args);
            return objectUrl;
        }
    
        /**
         * 获取文件上传地址(暂时还未实现)
         *
         * @param bucketName 桶名
         * @param objectName 文件名
         * @param expires    过期时间,默认秒
         * @return
         * @throws Exception
         */
        public String getFileUploadUrl(String bucketName, String objectName, Integer expires) throws Exception {
    
            // 过期时间
            ZonedDateTime zonedDateTime = ZonedDateTime.now().plusSeconds(60);
            PostPolicy postPolicy = new PostPolicy(bucketName, zonedDateTime);
    
            // 获取对象的默认权限策略
            StatObjectResponse statObjectResponse = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
            String objectPolicy = statObjectResponse.headers().get("x-amz-object-policy");
    
            String presignedObjectUrl = minioClient.getPresignedObjectUrl(
                    GetPresignedObjectUrlArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .method(Method.POST)
                            .expiry(expires) // 预签名的 URL 有效期为 1 小时
                            .build());
    
            MyMinioClient client = new MyMinioClient(minioClient);
    
            return presignedObjectUrl;
        }
    
        /**
         * 创建文件夹
         *
         * @param bucketName 桶名
         * @param folderName 文件夹名称
         * @return
         * @throws Exception
         */
        public ObjectWriteResponse createBucketFolder(String bucketName, String folderName) throws Exception {
    
            if (!checkBucketExist(bucketName)) {
                throw new RuntimeException("必须在桶存在的情况下才能创建文件夹");
            }
            if (!StringUtils.hasLength(folderName)) {
                throw new RuntimeException("创建的文件夹名不能为空");
            }
            PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(folderName + "/")
                    .stream(new ByteArrayInputStream(new byte[0]), 0, 0)
                    .build();
            ObjectWriteResponse objectWriteResponse = minioClient.putObject(putObjectArgs);
    
    
            return objectWriteResponse;
        }
    
        /**
         * 检测某个桶内是否存在某个文件
         *
         * @param objectName 文件名称
         * @param bucketName 桶名称
         */
        public boolean getBucketFileExist(String objectName, String bucketName) throws Exception {
            if (!StringUtils.hasLength(objectName) || !StringUtils.hasLength(bucketName)) {
                throw new RuntimeException("检测文件的时候，文件名和桶名不能为空！");
            }
    
            try {
                // 判断文件是否存在
                boolean exists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build()) &&
                        minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build()) != null;
                return exists;
            } catch (ErrorResponseException e) {
                log.info("文件不存在 ! Object does not exist");
                return false;
            } catch (Exception e) {
                throw new Exception(e);
            }
        }
    
        /**
         * 判断桶中是否存在文件夹
         *
         * @param bucketName 同名称
         * @param objectName 文件夹名称
         * @param isDeep     是否递归查询(暂不支持)
         * @return
         */
        public Boolean checkBucketFolderExist(String bucketName, String objectName, Boolean isDeep) {
    
            Iterable<Result<Item>> results = minioClient.listObjects(
                    ListObjectsArgs.builder().bucket(bucketName).prefix(objectName).recursive(isDeep).build());
    
            return results.iterator().hasNext(); // 文件夹下存在文件
        }
    
        /**
         * 根据MultipartFile file上传文件
         * minio 采用文件流上传，可以换成下面的文件上传
         *
         * @param file       上传的文件
         * @param bucketName 上传至服务器的桶名称
         */
        public boolean uploadFile(MultipartFile file, String bucketName) throws Exception {
    
            if (file == null || file.getSize() == 0 || file.isEmpty()) {
                throw new RuntimeException("上传文件为空，请重新上传");
            }
    
            if (!StringUtils.hasLength(bucketName)) {
                log.info("传入桶名为空，将设置默认桶名：" + minioProperties.getBucketName());
                bucketName = minioProperties.getBucketName();
                if (!this.checkBucketExist(minioProperties.getBucketName())) {
                    this.createBucket(minioProperties.getBucketName());
                }
            }
    
            if (!this.checkBucketExist(bucketName)) {
                throw new RuntimeException("当前操作的桶不存在！");
            }
    
            // 获取上传的文件名
            String filename = file.getOriginalFilename();
            assert filename != null;
            //可以选择生成一个minio中存储的文件名称
            String minioFilename = UUID.randomUUID().toString() + "_" + filename;
            String url = "http:" + minioProperties.getIp() + ":" + minioProperties.getPort();
    
            InputStream inputStream = file.getInputStream();
            long size = file.getSize();
            String contentType = file.getContentType();
    
            // Upload known sized input stream.
            minioClient.putObject(
                    PutObjectArgs.builder()
                            .bucket(bucketName) //上传到指定桶里面
                            .object(minioFilename)//文件在minio中存储的名字
                            //p1:上传的文件流；p2:上传文件总大小；p3：上传的分片大小
                            .stream(inputStream, size, -1) //上传分片文件流大小，如果分文件上传可以采用这种形式
                            .contentType(contentType) //文件的类型
                            .build());
    
            return this.getBucketFileExist(minioFilename, bucketName);
        }
    
        /**
         * 上传本地文件，根据路径上传
         * minio 采用文件内容上传，可以换成上面的流上传
         *
         * @param filePath 上传本地文件路径
         * @Param bucketName 上传至服务器的桶名称
         */
        public boolean uploadPath(String filePath, String bucketName) throws Exception {
    
            File file = new File(filePath);
            if (!file.isFile()) {
                throw new RuntimeException("上传文件为空，请重新上传");
            }
    
            if (!StringUtils.hasLength(bucketName)) {
                log.info("传入桶名为空，将设置默认桶名：" + minioProperties.getBucketName());
                bucketName = minioProperties.getBucketName();
                if (!this.checkBucketExist(minioProperties.getBucketName())) {
                    this.createBucket(minioProperties.getBucketName());
                }
            }
    
            if (!this.checkBucketExist(bucketName)) {
                throw new RuntimeException("当前操作的桶不存在！");
            }
    
            String minioFilename = UUID.randomUUID().toString() + "_" + file.getName();//获取文件名称
            String fileType = minioFilename.substring(minioFilename.lastIndexOf(".") + 1);
    
            minioClient.uploadObject(
                    UploadObjectArgs.builder()
                            .bucket(bucketName)
                            .object(minioFilename)//文件存储在minio中的名字
                            .filename(filePath)//上传本地文件存储的路径
                            .contentType(fileType)//文件类型
                            .build());
    
            return this.getBucketFileExist(minioFilename, bucketName);
        }
    
        /**
         * 文件下载,通过http返回，即在浏览器下载
         *
         * @param response   http请求的响应对象
         * @param bucketName 下载指定服务器的桶名称
         * @param objectName 下载的文件名称
         */
        public void downloadFile(HttpServletResponse response, String bucketName, String objectName) throws Exception {
            if (response == null || !StringUtils.hasLength(bucketName) || !StringUtils.hasLength(objectName)) {
                throw new RuntimeException("下载文件参数不全！");
            }
    
            if (!this.checkBucketExist(bucketName)) {
                throw new RuntimeException("当前操作的桶不存在！");
            }
    
            //获取一个下载的文件输入流操作
            GetObjectResponse objectResponse = minioClient.getObject(
                    GetObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .build());
    
            OutputStream outputStream = response.getOutputStream();
            int len = 0;
            byte[] buf = new byte[1024 * 8];
            while ((len = objectResponse.read(buf)) != -1) {
                outputStream.write(buf, 0, len);
            }
            if (outputStream != null) {
                outputStream.close();
                outputStream.flush();
            }
            objectResponse.close();
        }
    
        /**
         * 文件下载到指定路径
         *
         * @param downloadPath 下载到本地路径
         * @param bucketName   下载指定服务器的桶名称
         * @param objectName   下载的文件名称
         */
        public void downloadPath(String downloadPath, String bucketName, String objectName) throws Exception {
            if (downloadPath.isEmpty() || !StringUtils.hasLength(bucketName) || !StringUtils.hasLength(objectName)) {
                throw new RuntimeException("下载文件参数不全！");
            }
    
            if (!new File(downloadPath).isDirectory()) {
                throw new RuntimeException("本地下载路径必须是一个文件夹或者文件路径！");
            }
    
            if (!this.checkBucketExist(bucketName)) {
                throw new RuntimeException("当前操作的桶不存在！");
            }
    
            downloadPath += objectName;
    
            minioClient.downloadObject(
                    DownloadObjectArgs.builder()
                            .bucket(bucketName) //指定是在哪一个桶下载
                            .object(objectName)//是minio中文件存储的名字;本地上传的文件是user.xlsx到minio中存储的是user-minio,那么这里就是user-minio
                            .filename(downloadPath)//需要下载到本地的路径，一定是带上保存的文件名；如 d:\\minio\\user.xlsx
                            .build());
        }
    
    }

### 6.对上面封装的方法进行验证 ###

可以在controller中写http接口来进行验证，本文采用的单元测试进行验证。

package com.jdh.minio.config;
    
    import io.minio.*;
    import io.minio.messages.Bucket;
    import io.minio.messages.Item;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.mock.web.MockMultipartFile;
    import org.springframework.web.multipart.MultipartFile;
    import org.springframework.web.multipart.commons.CommonsMultipartFile;
    
    import java.io.*;
    import java.util.List;
    
    import static org.junit.jupiter.api.Assertions.*;
    
    @SpringBootTest
    class MinioFileUtilTest {
    
        @Autowired
        private MinioFileUtil minioFileUtil;
    
        /**
         * 创建一个桶
         */
        @Test
        void createBucket() throws Exception {
            minioFileUtil.createBucket("minio-file");
    
            /**
             这里创建桶的命名规则在默认情况下有要求
             用于存储 CloudTrail 日志文件的 Amazon S3 存储桶的名称必须符合非美国标准区域的命名要求。
             Amazon S3 存储桶的命名需符合以下一个或多个规则（用句点分隔开）：
             1.存储桶名称的长度介于 3 和 63 个字符之间，并且只能包含小写字母、数字、句点和短划线。
             2.存储桶名称中的每个标签必须以小写字母或数字开头。
             3.存储桶名称不能包含下划线、以短划线结束、包含连续句点或在句点旁边使用短划线。
             4.存储桶名称不能采用 IP 地址格式 (198.51.100.24)。
             */
            boolean minioFile = minioFileUtil.checkBucketExist("minio-file");
            System.out.println(minioFile);
        }
    
        /**
         * 创建一个桶
         */
        @Test
        void createBucketByRegion() throws Exception {
            minioFileUtil.createBucketByRegion("minio-file", "minio-region");
    
            boolean minioFile = minioFileUtil.checkBucketExist("minio-file");
            System.out.println(minioFile);
        }
    
        /**
         * 删除一个桶
         */
        @Test
        void deleteBucket() throws Exception {
            minioFileUtil.deleteBucket("minio-file");
    
            boolean minioFile = minioFileUtil.checkBucketExist("minio-file");
            System.out.println(minioFile);
        }
    
        /**
         * 检测桶是否存在
         */
        @Test
        void checkBucketExist() throws Exception {
            boolean test = minioFileUtil.checkBucketExist("test");
            System.out.println(test);
        }
    
        /**
         * 获取所有的桶信息
         */
        @Test
        void getAllBucketInfo() throws Exception {
            List<Bucket> allBucketName = minioFileUtil.getAllBucketInfo();
            allBucketName.forEach(e -> System.out.println(e.name()));
        }
    
        /**
         * 获取某个桶中的全部文件
         */
        @Test
        void getBucketAllFile() throws Exception {
            Iterable<Result<Item>> allFile = minioFileUtil.getBucketAllFile("minio-folder", "part", true);
    
            for (Result<Item> result : allFile) {
                Item item = result.get();
                System.out.println(item.objectName());
            }
        }
    
        /**
         * 检测某个桶中是否存在某个文件
         */
        @Test
        void getBucketFileExist() throws Exception {
            boolean fileExist = minioFileUtil.getBucketFileExist("8aa570f9-53f5-4cb5-a0d1-c122ef4e3f89_出师表.docx", "minio-bucket");
            System.out.println(fileExist);
        }
    
        /**
         * 删除桶中的一个文件
         *
         * @throws Exception
         */
        @Test
        void deleteBucketFile() throws Exception {
            Boolean b = minioFileUtil.deleteBucketFile("minio-folder", "出师表.docx");
            System.out.println(b);
        }
    
        /**
         * 删除桶中的一个文件夹
         *
         * @throws Exception
         */
        @Test
        void deleteBucketFolder() throws Exception {
            boolean b = minioFileUtil.deleteBucketFolder("minio-folder", "tempFile", true);
            System.out.println(b);
        }
    
        /**
         * 获取文件下载路径
         */
        @Test
        void getFileDownloadUrl() throws Exception {
            String fileUrl = minioFileUtil.getFileDownloadUrl("minio-bucket", "出师表.docx", 60);
            System.out.println(fileUrl);
        }
    
        /**
         * 获取文件上传路径
         */
        @Test
        void getFileUploadUrl() throws Exception {
            String fileUrl = minioFileUtil.getFileUploadUrl("minio-bucket", "出师表1.docx", 3600);
            System.out.println(fileUrl);
        }
    
        /**
         * 在一个桶中创建一个空文件夹
         *
         * @throws Exception
         */
        @Test
        void createBucketFolder() throws Exception {
    
            String buckName = "minio-bucket";
    
            String folderName = "part";
    
            ObjectWriteResponse bucketFolder = minioFileUtil.createBucketFolder(buckName, folderName);
        }
    
        /**
         * 在一个桶中创建一个空文件夹
         *
         * @throws Exception
         */
        @Test
        void checkBucketFolderExist() throws Exception {
            Boolean tempFile = minioFileUtil.checkBucketFolderExist("minio-bucket", "down", true);
            System.out.println(tempFile);
        }
    
        /**
         * 文件上传，通过MultipartFile形式
         */
        @Test
        void uploadFile() throws Exception {
            File file = new File("D:\\file\\出师表.docx");
            FileInputStream fileInputStream = new FileInputStream(file);
            String fileName = file.getName();
    
            MockMultipartFile multipartFile = new MockMultipartFile(fileName, fileName, "docx", fileInputStream);
    
            boolean uploadFile = minioFileUtil.uploadFile(multipartFile, "minio-folder");
            System.out.println(uploadFile);
        }
    
        /**
         * 文件上传，通过本地路径
         *
         * @throws Exception
         */
        @Test
        void uploadPath() throws Exception {
    
            boolean uploadPath = minioFileUtil.uploadPath("D:\\file\\出师表.docx", "minio-bucket");
            System.out.println(uploadPath);
        }
    
        /**
         * 文件下载，通过http响应下载
         */
        @Test
        void downloadFile() {
            //这里可以使用模拟请求来验证
        }
    
        /**
         * 文件下载，通过路径直接下载到本地
         *
         * @throws Exception
         */
        @Test
        void downloadPath() throws Exception {
            MinioClient client = minioFileUtil.getClient();
            minioFileUtil.downloadPath("D:\\file\\", "minio-bucket", "8aa570f9-53f5-4cb5-a0d1-c122ef4e3f89_出师表.docx");
        }
    }

### 7.验证结果 ###

通过访问minio的服务端界面查看功能是否验证通过

[MinIO _]: https://www.minio.org.cn/download.shtml
[MinIO Object Storage for Kubernetes _ MinIO Object Storage for Kubernetes]: https://www.minio.org.cn/docs/minio/kubernetes/upstream/
[320da31c2267431d92e772ddc6a6954d.png]: https://img-blog.csdnimg.cn/320da31c2267431d92e772ddc6a6954d.png
[3c942652bfb545eca0ad0c578dcdd7d8.png]: https://img-blog.csdnimg.cn/3c942652bfb545eca0ad0c578dcdd7d8.png
[73c5bb680cb0457fa1ffde3ad7309acf.png]: https://img-blog.csdnimg.cn/73c5bb680cb0457fa1ffde3ad7309acf.png
[c70a56bcb6394dd6be821b0e4c6e9984.png]: https://img-blog.csdnimg.cn/c70a56bcb6394dd6be821b0e4c6e9984.png
[324d5b37603d45eab0f1eb6b9ccc3dd7.png]: https://img-blog.csdnimg.cn/324d5b37603d45eab0f1eb6b9ccc3dd7.png
[https_gitee.com_java_utils_demo_java_minio_demo.git]: https://gitee.com/java_utils_demo/java_minio_demo.git
[91640e1e4bc647219e360e65bb535233.png]: https://img-blog.csdnimg.cn/91640e1e4bc647219e360e65bb535233.png