MinIO是什么？如何使用

缺乏、安全感 2024-03-04 01:49 148阅读 0赞

> 哈喽！大家好，我是旷世奇才李先生  
> 文章持续更新，可以微信搜索【小奇JAVA面试】第一时间阅读，回复【资料】更有我为大家准备的福利哟，回复【项目】获取我为大家准备的项目

#### 文章目录 ####

*  一、MinIO介绍
 *   *  1、简介
     *  2、优缺点
 *  二、MinIO 使用
 *   *  1、使用docker进行环境部署和启动
     *  2、minio中建立一个存储的桶
     *  3、java代码整合minio使用
     *  4、封装MinIO为starter
 *  三、总结

相关阅读

*  [面试官：Zookeeper是什么，它有什么特性与使用场景？][Zookeeper]
 *  [面试官：Redis如何实现持久化的、主从哨兵又是什么？][Redis]

## 一、MinIO介绍 ##

### 1、简介 ###

MinIO基于Apache License v2.0开源协议的对象存储服务，可以做为云存储的解决方案用来保存海量的图片，视频，文档。由于采用Golang实现，服务端可以工作在Windows,Linux, OS X和FreeBSD上。配置简单，基本是复制可执行程序，单行命令可以运行起来。

MinIO兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。

### 2、优缺点 ###

![在这里插入图片描述][21fa438ac22d4e5fbd78b2fdae894c87.png]

## 二、MinIO 使用 ##

### 1、使用docker进行环境部署和启动 ###

启动docker容器

docker run -p 9000:9000 --name minio -d --restart=always -e "MINIO_ACCESS_KEY=minio" -e "MINIO_SECRET_KEY=minio123" -v /home/data:/data -v /home/config:/root/.minio minio/minio server /data

访问登录地址 http://192.168.200.130:9000

登录页面如下

![在这里插入图片描述][efd5857a9eb345d7b5778daea13d17b7.png]

用户名为：minio 密码为：minio123

### 2、minio中建立一个存储的桶 ###

![在这里插入图片描述][2a72918f9540430882c2ddcab076c7e0.png]  
点击这个create bucket按钮创建一个桶的名字

### 3、java代码整合minio使用 ###

import io.minio.MinioClient;
    import io.minio.PutObjectArgs;
    
    import java.io.FileInputStream;
    
    public class MinIOApplication {
    
        /**
         * @Author: KSQC
         * @Description: 把list.html文件上传到minio中，并且可以在浏览器中访问
         * @Date: 2023/9/9 18:35
         */
        public static void main(String[] args) {
    
            try {
                FileInputStream fileInputStream = new FileInputStream("D:\\list.html");
    
                //1，过去minio的链接信息，创建一个minio的客户端
                MinioClient minioClient = MinioClient.builder().credentials("minio","minio123").endpoint("http://192.168.200.130:9000").build();
    
                //2.上传
                PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                        .object("list.html") //文件名词
                        .contentType("text/html") //文件类型
                        .bucket("leadnews") //桶名称 与minio管理界面创建的桶一致即可
                        .stream(fileInputStream,fileInputStream.available(),-1).build();
                minioClient.putObject(putObjectArgs);
    
                //访问路径
                System.out.println("http://192.168.200.130:9000/leadnews/list.html");
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    }

上传成功后我们访问连接地址可以成功看到结果信息。

![在这里插入图片描述][293cf52c92704451a128e0645ba70d9f.png]

### 4、封装MinIO为starter ###

在微服务项目当中我们需要将文件上传单独抽出一个服务来集中管理，所以这个时候我们创建一个新的模块，然后导入我们的封装好的一些工具类，这样使用的时候更加方便。

首先使MinIOConfig类

package com.heima.file.config;
    
    import com.heima.file.service.FileStorageService;
    import io.minio.MinioClient;
    import lombok.Data;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    
    @Data
    @Configuration
    @EnableConfigurationProperties({MinIOConfigProperties.class})
    //当引入FileStorageService接口时
    @ConditionalOnClass(FileStorageService.class)
    public class MinIOConfig {
    
        @Autowired
        private MinIOConfigProperties minIOConfigProperties;
    
        @Bean
        public MinioClient buildMinioClient() {
            return MinioClient
                    .builder()
                    .credentials(minIOConfigProperties.getAccessKey(), minIOConfigProperties.getSecretKey())
                    .endpoint(minIOConfigProperties.getEndpoint())
                    .build();
        }
    }

然后是MinIOConfigProperties类

package com.heima.file.config;
    
    
    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    import java.io.Serializable;
    
    @Data
    @ConfigurationProperties(prefix = "minio")  // 文件上传 配置前缀file.oss
    public class MinIOConfigProperties implements Serializable {
    
        private String accessKey;
        private String secretKey;
        private String bucket;
        private String endpoint;
        private String readPath;
    }

然后是FileStorageService接口

package com.heima.file.service;
    
    import java.io.InputStream;
    
    /**
     * @author itheima
     */
    public interface FileStorageService {
    
    
        /**
         *  上传图片文件
         * @param prefix  文件前缀
         * @param filename  文件名
         * @param inputStream 文件流
         * @return  文件全路径
         */
        public String uploadImgFile(String prefix, String filename,InputStream inputStream);
    
        /**
         *  上传html文件
         * @param prefix  文件前缀
         * @param filename   文件名
         * @param inputStream  文件流
         * @return  文件全路径
         */
        public String uploadHtmlFile(String prefix, String filename,InputStream inputStream);
    
        /**
         * 删除文件
         * @param pathUrl  文件全路径
         */
        public void delete(String pathUrl);
    
        /**
         * 下载文件
         * @param pathUrl  文件全路径
         * @return
         *
         */
        public byte[]  downLoadFile(String pathUrl);
    
    }

然后是MinIOFileStorageService类

package com.heima.file.service.impl;
    
    
    import com.heima.file.config.MinIOConfig;
    import com.heima.file.config.MinIOConfigProperties;
    import com.heima.file.service.FileStorageService;
    import io.minio.GetObjectArgs;
    import io.minio.MinioClient;
    import io.minio.PutObjectArgs;
    import io.minio.RemoveObjectArgs;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.context.annotation.Import;
    import org.springframework.util.StringUtils;
    
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    @Slf4j
    @EnableConfigurationProperties(MinIOConfigProperties.class)
    @Import(MinIOConfig.class)
    public class MinIOFileStorageService implements FileStorageService {
    
        @Autowired
        private MinioClient minioClient;
    
        @Autowired
        private MinIOConfigProperties minIOConfigProperties;
    
        private final static String separator = "/";
    
        /**
         * @param dirPath
         * @param filename  yyyy/mm/dd/file.jpg
         * @return
         */
        public String builderFilePath(String dirPath,String filename) {
            StringBuilder stringBuilder = new StringBuilder(50);
            if(!StringUtils.isEmpty(dirPath)){
                stringBuilder.append(dirPath).append(separator);
            }
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
            String todayStr = sdf.format(new Date());
            stringBuilder.append(todayStr).append(separator);
            stringBuilder.append(filename);
            return stringBuilder.toString();
        }
    
        /**
         *  上传图片文件
         * @param prefix  文件前缀
         * @param filename  文件名
         * @param inputStream 文件流
         * @return  文件全路径
         */
        @Override
        public String uploadImgFile(String prefix, String filename,InputStream inputStream) {
            String filePath = builderFilePath(prefix, filename);
            try {
                PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                        .object(filePath)
                        .contentType("image/jpg")
                        .bucket(minIOConfigProperties.getBucket()).stream(inputStream,inputStream.available(),-1)
                        .build();
                minioClient.putObject(putObjectArgs);
                StringBuilder urlPath = new StringBuilder(minIOConfigProperties.getReadPath());
                urlPath.append(separator+minIOConfigProperties.getBucket());
                urlPath.append(separator);
                urlPath.append(filePath);
                return urlPath.toString();
            }catch (Exception ex){
                log.error("minio put file error.",ex);
                throw new RuntimeException("上传文件失败");
            }
        }
    
        /**
         *  上传html文件
         * @param prefix  文件前缀
         * @param filename   文件名
         * @param inputStream  文件流
         * @return  文件全路径
         */
        @Override
        public String uploadHtmlFile(String prefix, String filename,InputStream inputStream) {
            String filePath = builderFilePath(prefix, filename);
            try {
                PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                        .object(filePath)
                        .contentType("text/html")
                        .bucket(minIOConfigProperties.getBucket()).stream(inputStream,inputStream.available(),-1)
                        .build();
                minioClient.putObject(putObjectArgs);
                StringBuilder urlPath = new StringBuilder(minIOConfigProperties.getReadPath());
                urlPath.append(separator+minIOConfigProperties.getBucket());
                urlPath.append(separator);
                urlPath.append(filePath);
                return urlPath.toString();
            }catch (Exception ex){
                log.error("minio put file error.",ex);
                ex.printStackTrace();
                throw new RuntimeException("上传文件失败");
            }
        }
    
        /**
         * 删除文件
         * @param pathUrl  文件全路径
         */
        @Override
        public void delete(String pathUrl) {
            String key = pathUrl.replace(minIOConfigProperties.getEndpoint()+"/","");
            int index = key.indexOf(separator);
            String bucket = key.substring(0,index);
            String filePath = key.substring(index+1);
            // 删除Objects
            RemoveObjectArgs removeObjectArgs = RemoveObjectArgs.builder().bucket(bucket).object(filePath).build();
            try {
                minioClient.removeObject(removeObjectArgs);
            } catch (Exception e) {
                log.error("minio remove file error.  pathUrl:{}",pathUrl);
                e.printStackTrace();
            }
        }
    
    
        /**
         * 下载文件
         * @param pathUrl  文件全路径
         * @return  文件流
         *
         */
        @Override
        public byte[] downLoadFile(String pathUrl)  {
            String key = pathUrl.replace(minIOConfigProperties.getEndpoint()+"/","");
            int index = key.indexOf(separator);
            String bucket = key.substring(0,index);
            String filePath = key.substring(index+1);
            InputStream inputStream = null;
            try {
                inputStream = minioClient.getObject(GetObjectArgs.builder().bucket(minIOConfigProperties.getBucket()).object(filePath).build());
            } catch (Exception e) {
                log.error("minio down file error.  pathUrl:{}",pathUrl);
                e.printStackTrace();
            }
    
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] buff = new byte[100];
            int rc = 0;
            while (true) {
                try {
                    if (!((rc = inputStream.read(buff, 0, 100)) > 0)) break;
                } catch (IOException e) {
                    e.printStackTrace();
                }
                byteArrayOutputStream.write(buff, 0, rc);
            }
            return byteArrayOutputStream.toByteArray();
        }
    }

最后我们写一个Test测试类来测试一下

@SpringBootTest(classes = MinIOApplication.class)
    @RunWith(SpringRunner.class)
    public class MinIOTest {
    
        @Autowired
        private FileStorageService fileStorageService;
    
        //把list.html文件上传到minio中，并且可以在浏览器中访问
    
        @Test
        public void test() throws FileNotFoundException {
            FileInputStream fileInputStream = new FileInputStream("D:\\list.html");
            String path = fileStorageService.uploadHtmlFile("", "list.html", fileInputStream);
            System.out.println(path);
        }
        }

上传成功后我们可以看到我们按照日期进行了一个存储目录的区分，以后我们每天上传的文件都在一个文件夹下  
![在这里插入图片描述][aaefe6910f514cbaa1c1b7570a20e819.png]

在看一下我们minio页面创建了时间的目录

![在这里插入图片描述][810126cd855742638d69e563ba2f8d72.png]

![在这里插入图片描述][dfa63bbdd5d04d43bfdfc8112fd079e5.png]

![在这里插入图片描述][31197a624e324e6a8067a7f4634b0de3.png]

真正我们在开发中是需要进行时间的一个分目录操作，因为如果后续排查问题的时候我们可以根据哪一天上传附件有问题然后只看某一天的目录下有没有成功上传这个附件即可。

## 三、总结 ##

项目涉及的功能还是比较全面的，建议大家跟着视频做一遍。可以关注公众号回复【项目】领取项目，如果有用就点赞支持一下吧。

文章持续更新，可以微信搜索【**小奇JAVA面试**】第一时间阅读，回复【**项目**】获取我为大家准备的项目

[Zookeeper]: https://xiaoqijava.blog.csdn.net/article/details/123695087?spm=1001.2014.3001.5502
[Redis]: https://xiaoqijava.blog.csdn.net/article/details/123453838?spm=1001.2014.3001.5502
[21fa438ac22d4e5fbd78b2fdae894c87.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/04/d9df7519e10148ed85f11490ee958d33.png
[efd5857a9eb345d7b5778daea13d17b7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/04/3e4d755e057744c2876324f2d601fc34.png
[2a72918f9540430882c2ddcab076c7e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/04/e765e5fc34cf4353baa7b3e71aafd892.png
[293cf52c92704451a128e0645ba70d9f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/04/49005664d7b34e7488e596e22672b41d.png
[aaefe6910f514cbaa1c1b7570a20e819.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/04/65fb1878ba3c42b5aa07ed168fd53f68.png
[810126cd855742638d69e563ba2f8d72.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/04/2a93b1f140fc4c5ba8ac94cab3f7ce27.png
[dfa63bbdd5d04d43bfdfc8112fd079e5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/04/397bafa19b6541ebb1d367e099a469c5.png
[31197a624e324e6a8067a7f4634b0de3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/04/0422a1b78fb04893ba916724c4fbc595.png