• 你可需要的对象存储中间件《Minio使用》

    最近的项目中因为需要做一些上传和下载的工作，所以选择了minio。当然这也是公司的选择，废话不多说，今天主要是记录下经验。

    1、minio相关信息

    1.1 官方信息

    中文网站：MinIO | 高性能，对Kubernetes友好的对象存储

    你懂得，去掉cn 就是官方网站。在官方网站上有你要的信息。不打开看看吗？看起来了不起的样子

    MinIO 是一款高性能、分布式的对象存储系统. 它是一款软件产品, 可以100%的运行在标准硬件。即X86等低成本机器也能够很好的运行MinIO。

    MinIO与传统的存储和其他的对象存储不同的是：它一开始就针对性能要求更高的私有云标准进行软件架构设计。因为MinIO一开始就只为对象存储而设计。所以他采用了更易用的方式进行设计，它能实现对象存储所需要的全部功能，在性能上也更加强劲，它不会为了更多的业务功能而妥协，失去MinIO的易用性、高效性。 这样的结果所带来的好处是：它能够更简单的实现局有弹性伸缩能力的原生对象存储服务。

    MinIO在传统对象存储用例（例如辅助存储，灾难恢复和归档）方面表现出色。同时，它在机器学习、大数据、私有云、混合云等方面的存储技术上也独树一帜。当然，也不排除数据分析、高性能应用负载、原生云的支持。

    在中国：阿里巴巴、腾讯、百度、中国联通、华为、中国移动等等9000多家企业也都在使用MinIO产品

    1.2 MinIO优势

    1、数据安全

    分布式存储，保证数据安全

    2、高可用

    分布式多副本机制，可以保证服务的高可用，即使挂掉几个也能保证服务

    3、一致性

    1.3 应用场景

    互联网非结构化数据的存储需求

    • 电商网站：海量商品图片
    • 视频网站：海量视频文件
    • 网盘：海量文件

    2、部署

    懒省事，直接选择docker部署，看下脚本吧，没啥问题。

    1. docker run  -p 9000:9000 --net=host \
    2. --name minio1 \
    3.        -d \
    4. -e MINIO_ACCESS_KEY=minio \
    5. -e MINIO_SECRET_KEY=minio@123 \
    6. -v /home/docker/minio/data:/data \
    7. -v /home/docker/minio/config:/root/.minio \
    8.  minio/minio server /data

    启动起来登录进控制台

    管理地址：http://172.26.1.152:9000/，用户名和地址在上面的脚本里

    3、Springboo继承Minio

    1、添加依赖

    这里在线上直接找了一个，你可以在repo里查找最新的 

    1. <dependency>
    2.     <groupId>io.miniogroupId>
    3.     <artifactId>minioartifactId>
    4.     <version>8.0.0version>
    5. dependency>

    2、配置文件

    application.yml，这里直接创建了一个配置，你可以根据自己的需求定义格式

    1. minio:
    2.   endpoint: http://172.26.1.152:9000  # endpoint
    3.   accessKey: minio  #用户名
    4.   secretKey: minio@123 # 密码
    5.   bucketName: apply # bucketName

    3、读取配置文件

    这里使用了lombok，如果你没使用的话，可以去除data注解，然后创建一些get/set方法。

    1. import io.minio.MinioClient;
    2. import lombok.Data;
    3. import org.springframework.boot.context.properties.ConfigurationProperties;
    4. import org.springframework.context.annotation.Bean;
    5. import org.springframework.context.annotation.Configuration;
    6.  
    7. @Data
    8. @Configuration
    9. @ConfigurationProperties(prefix = "minio")
    10. public class MinioConfig {
    11.     private String endpoint;
    12.     private String accessKey;
    13.     private String secretKey;
    14.     @Bean
    15.     public MinioClient minioClient()  {
    16.         MinioClient minioClient = MinioClient.builder()
    17.                 .endpoint(endpoint)
    18.                 .credentials(accessKey, secretKey)
    19.                 .build();
    20.         return minioClient;
    21.     }
    22. }

    4、创建一个工具类

    这里借鉴了一些线上的文档，然后加了一些修改，可以直接拷贝到项目中使用。

    1. package com.xin.miniodemo.config;
    2.  
    3. import io.minio.*;
    4. import io.minio.messages.Bucket;
    5. import io.minio.messages.DeleteError;
    6. import io.minio.messages.DeleteObject;
    7. import io.minio.messages.Item;
    8. import lombok.extern.slf4j.Slf4j;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10. import org.springframework.stereotype.Component;
    11. import org.springframework.util.FastByteArrayOutputStream;
    12. import org.springframework.web.multipart.MultipartFile;
    13.  
    14. import javax.servlet.ServletOutputStream;
    15. import javax.servlet.http.HttpServletResponse;
    16. import java.util.ArrayList;
    17. import java.util.List;
    18. import java.util.stream.Collectors;
    19.  
    20. /**
    21.  * minio 工具类
    22.  */
    23. @Component
    24. @Slf4j
    25. public class MinioUtil {
    26.     @Autowired
    27.     private MinioClient minioClient;
    28.  
    29.     /**
    30.      * 查看存储bucket是否存在
    31.      *
    32.      * @return boolean
    33.      */
    34.     public boolean bucketExists(String bucketName) {
    35.         boolean found = false;
    36.         try {
    37.             BucketExistsArgs args = BucketExistsArgs.builder().bucket(bucketName)
    38.                     .build();
    39.             found = minioClient.bucketExists(args);
    40.         } catch (Exception e) {
    41.             log.error("bucketExists  ", e);
    42.         }
    43.         return found;
    44.     }
    45.  
    46.     /**
    47.      * 创建存储bucket
    48.      *
    49.      * @return Boolean
    50.      */
    51.     public boolean makeBucket(String bucketName) {
    52.         try {
    53.             MakeBucketArgs makeArgs = MakeBucketArgs.builder()
    54.                     .bucket(bucketName)
    55.                     .build();
    56.             minioClient.makeBucket(makeArgs);
    57.         } catch (Exception e) {
    58.             log.error("makeBucket  ", e);
    59.             return false;
    60.         }
    61.         return true;
    62.     }
    63.  
    64.     /**
    65.      * 删除存储bucket
    66.      *
    67.      * @return Boolean
    68.      */
    69.     public boolean removeBucket(String bucketName) {
    70.         try {
    71.             RemoveBucketArgs removeArgs = RemoveBucketArgs.builder()
    72.                     .bucket(bucketName)
    73.                     .build();
    74.             minioClient.removeBucket(removeArgs);
    75.         } catch (Exception e) {
    76.             log.error("removeBucket  ", e);
    77.             return false;
    78.         }
    79.         return true;
    80.     }
    81.  
    82.     /**
    83.      * 获取全部bucket
    84.      */
    85.     public List getAllBuckets() {
    86.         try {
    87.             return minioClient.listBuckets();
    88.         } catch (Exception e) {
    89.             log.error("getAllBuckets  ", e);
    90.         }
    91.         return null;
    92.     }
    93.  
    94.     /**
    95.      * 文件上传
    96.      *
    97.      * @param bucketName
    98.      * @param fileName   上传文件的路径和名字
    99.      * @param file
    100.      * @return
    101.      */
    102.     public boolean upload(String bucketName, String fileName, MultipartFile file) {
    103.         try {
    104.             PutObjectArgs objectArgs = PutObjectArgs.builder()
    105.                     .bucket(bucketName)
    106.                     .object(fileName)
    107.                     .stream(file.getInputStream(), file.getSize(), -1)
    108.                     .contentType(file.getContentType())
    109.                     .build();
    110.             //文件名称相同会覆盖
    111.             minioClient.putObject(objectArgs);
    112.         } catch (Exception e) {
    113.             log.error("upload  ", e);
    114.             return false;
    115.         }
    116.         return true;
    117.     }
    118.  
    119.  
    120.     /**
    121.      * 文件下载
    122.      *
    123.      * @param fileName 文件的路径和名字
    124.      * @return Boolean
    125.      */
    126.     public void download(String fileName, String saveName, String bucketName) {
    127.         DownloadObjectArgs build = DownloadObjectArgs.builder()
    128.                 .bucket(bucketName)
    129.                 .filename(saveName)
    130.                 .object(fileName)
    131.                 .build();
    132.         try {
    133.             minioClient.downloadObject(build);
    134.         } catch (Exception e) {
    135.             throw new RuntimeException(e);
    136.         }
    137.     }
    138.  
    139.     /**
    140.      * web下载文件
    141.      *
    142.      * @param fileName   文件的路径和名字
    143.      * @param bucketName
    144.      * @param resp
    145.      */
    146.     public void webDownload(String fileName, String bucketName, HttpServletResponse resp) {
    147.         GetObjectArgs objectArgs = GetObjectArgs.builder()
    148.                 .bucket(bucketName)
    149.                 .object(fileName)
    150.                 .build();
    151.         try (GetObjectResponse response = minioClient.getObject(objectArgs)) {
    152.             byte[] buf = new byte[1024];
    153.             int len;
    154.             try (FastByteArrayOutputStream os = new FastByteArrayOutputStream()) {
    155.                 while ((len = response.read(buf)) != -1) {
    156.                     os.write(buf, 0, len);
    157.                 }
    158.                 os.flush();
    159.                 byte[] bytes = os.toByteArray();
    160.                 resp.setCharacterEncoding("utf-8");
    161.                 //设置强制下载不打开
    162.                 //res.setContentType("application/force-download");
    163.                 resp.addHeader("Content-Disposition", "attachment;fileName=" + fileName);
    164.                 try (ServletOutputStream stream = resp.getOutputStream()) {
    165.                     stream.write(bytes);
    166.                     stream.flush();
    167.                 }
    168.             }
    169.         } catch (Exception e) {
    170.             log.error("webDownload  ", e);
    171.         }
    172.     }
    173.  
    174.     /**
    175.      * 查看文件对象
    176.      *
    177.      * @return 存储bucket内文件对象信息
    178.      */
    179.     public List listObjects(String bucketName) {
    180.         ListObjectsArgs listObjectsArgs = ListObjectsArgs.builder()
    181.                 .bucket(bucketName)
    182.                 .build();
    183.         Iterable> results = minioClient.listObjects(listObjectsArgs);
    184.         List itemList = new ArrayList<>();
    185.         try {
    186.             for (Result result : results) {
    187.                 itemList.add(result.get());
    188.             }
    189.         } catch (Exception e) {
    190.             log.error("listObjects  ", e);
    191.             return null;
    192.         }
    193.         return itemList;
    194.     }
    195.  
    196.     /**
    197.      * 删除
    198.      *
    199.      * @param fileName
    200.      * @return
    201.      * @throws Exception
    202.      */
    203.     public boolean removeOne(String fileName, String bucketName) {
    204.         try {
    205.             RemoveObjectArgs removeArgs = RemoveObjectArgs.builder()
    206.                     .bucket(bucketName)
    207.                     .object(fileName)
    208.                     .build();
    209.             minioClient.removeObject(removeArgs);
    210.         } catch (Exception e) {
    211.             log.error("remove  ", e);
    212.             return false;
    213.         }
    214.         return true;
    215.     }
    216.  
    217.     /**
    218.      * 批量删除文件对象
    219.      *
    220.      * @param objects 对象名称集合
    221.      */
    222.     public Iterable> removeObjects(List objects, String bucketName) {
    223.         List dos = objects.stream().map(DeleteObject::new).collect(Collectors.toList());
    224.         RemoveObjectsArgs build = RemoveObjectsArgs.builder()
    225.                 .bucket(bucketName)
    226.                 .objects(dos)
    227.                 .build();
    228.         Iterable> results = minioClient.removeObjects(build);
    229.         return results;
    230.     }
    231. }
    232.  
    233.

    5、测试代码，

    这里直接创建了一个controller测试

    1. import com.xin.miniodemo.config.MinioUtil;
    2. import org.springframework.beans.factory.annotation.Autowired;
    3. import org.springframework.web.bind.annotation.PostMapping;
    4. import org.springframework.web.bind.annotation.RequestMapping;
    5. import org.springframework.web.bind.annotation.RestController;
    6. import org.springframework.web.multipart.MultipartFile;
    7.  
    8. import javax.servlet.http.HttpServletResponse;
    9. import java.util.Arrays;
    10. import java.util.List;
    11.  
    12. @RestController
    13. @RequestMapping
    14. public class TestController {
    15.     @Autowired
    16.     private MinioUtil minioUtil;
    17.     @PostMapping("/upload")
    18.     public String test(MultipartFile file) {
    19.          minioUtil.upload("chongxin",file.getOriginalFilename(),file);
    20.         return "Hello";
    21.     }
    22.     @PostMapping("/delete")
    23.     public String delete(String fileName) {
    24.         String[] fileArr = fileName.split(",");
    25.         List fl = Arrays.asList(fileArr);
    26.         minioUtil.removeObjects(fl,"chongxin");
    27.         return "Hello";
    28.     }
    29.     @PostMapping("/download")
    30.     public String download(String fileName) {
    31.  
    32.         minioUtil.download(fileName,"chongxin.jpg","chongxin.jpg");
    33.         return "Hello";
    34.     }
    35.     @PostMapping("/webdownload")
    36.     public String download(String fileName, HttpServletResponse response) {
    37.  
    38.         minioUtil.webDownload(fileName,"chongxin",response);
    39.         return "Hello";
    40.     }
    41. }

    4、总结

    在开发的过程中还是出现一些问题的，但是已经都解决了，没有及时记录问题，这个有点可惜。

    撸代码的时间还是快乐的，特别是解决问题之后，很开心

    你的点赞是我分享的动力，欢迎点赞评论分享

  • 相关阅读:
    LeetCode中等题之前K个高频单词
    博客资源汇总
    【Vue】Router路由无法跳转问题整理
    关于MP3文件中找不到TAG标签的问题
    腾讯云轻量应用服务器怎么样？来自学生的评价
    Vuex--模块化+命名空间
    中小企业有哪些平台可以引流？SEO搜索流量与推荐信息流流量怎么选？
    mybatis 07: sql标签中 "#{}" 和 "${}" 的作用和比较
    Spring Boot中添加Thymeleaf模板
    MySQL主从数据库搭建
  • 原文地址：https://blog.csdn.net/perfect2011/article/details/128192559