• SpringBoot + minio实现分片上传、秒传、续传

    MinIO是一个基于Go实现的高性能、兼容S3协议的对象存储。它采用GNU AGPL v3开源协议，项目地址是https://github.com/minio/minio。

    引用官网：

    MinIO是根据GNU Affero通用公共许可证v3.0发布的高性能对象存储。它与Amazon S3云存储服务兼容。使用MinIO构建用于机器学习，分析和应用程序数据工作负载的高性能基础架构。

    官网地址：

    MinIO | High Performance, Kubernetes Native Object Storage 

    文档地址：

    MinIO Object Storage for Kubernetes — MinIO Object Storage for Kubernetes 

    一. 使用docker 搭建minio 服务 

    GNU / Linux和macOS

    1. docker run -p 9000:9000 \
    2.   --name minio1 \
    3.   -v /mnt/data:/data \
    4.   -e "MINIO_ROOT_USER=AKIAIOSFODNN7EXAMPLE" \
    5.   -e "MINIO_ROOT_PASSWORD=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" \
    6.   minio/minio server /data

    windows

    1. docker run -p 9000:9000 \
    2.   --name minio1 \
    3.   -v D:\data:/data \
    4.   -e "MINIO_ROOT_USER=AKIAIOSFODNN7EXAMPLE" \
    5.   -e "MINIO_ROOT_PASSWORD=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" \
    6.   minio/minio server /data

    • MINIO_ROOT_USER：为用户key

    • MINIO_ROOT_PASSWORD：为用户密钥

    以上搭建的都是单机版的。想要了解分布式 的方式请查看官网文档。

    这就是在win的docker上运行的。

    当启动后在浏览器访问http://localhost:9000就可以访问minio的图形化界面了，如图所示：

     

    二. 下面开始搭建springboot 环境 

    初始化一个springboot项目大家都会，这里不多做介绍。

    主要是介绍需要引入的依赖：

    3.     org.springframework.boot
    4.     spring-boot-starter-thymeleaf
    8.     io.minio
    9.     minio
    10.     8.2.1
    14.     org.projectlombok
    15.     lombok
    16.     true

    依赖可以官方文档里找：https://docs.min.io/docs/java-client-quickstart-guide.html

    下面介绍配置文件：

    1. spring:
    2.   servlet:
    3.     multipart:
    4.       max-file-size: 10MB
    5.       max-request-size: 10MB
    6. #minio配置
    7.   minio:
    8.     access-key: AKIAIOSFODNN7EXAMPLE      #key就是docker初始化是设置的，密钥相同
    9.     secret-key: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
    10.     url: http://localhost:9000
    11.     bucket-name: wdhcr
    12.   thymeleaf:
    13.     cache: false

     

    创建minio的配置类:

    1. @Configuration
    2. @ConfigurationProperties(prefix = "spring.minio")
    3. @Data
    4. public class MinioConfiguration {
    5.     private String accessKey;
    6.  
    7.     private String secretKey;
    8.  
    9.     private String url;
    10.  
    11.     private String bucketName;
    12.  
    13.     @Bean
    14.     public MinioClient minioClient() {
    15.         return MinioClient.builder()
    16.                 .endpoint(url)
    17.                 .credentials(accessKey, secretKey)
    18.                 .build();
    19.     }
    20. }

    使用配置属性绑定进行参数绑定,并初始化一个minio client对象放入容器中。

    下面就是我封装的minio client 操作minio的简单方法的组件。

    1. @Component
    2. public class MinioComp {
    3.  
    4.     @Autowired
    5.     private MinioClient minioClient;
    6.  
    7.     @Autowired
    8.     private MinioConfiguration configuration;
    9.  
    10.     /**
    11.      * @description: 获取上传临时签名
    12.      */
    13.     public Map getPolicy(String fileName, ZonedDateTime time) {
    14.         PostPolicy postPolicy = new PostPolicy(configuration.getBucketName(), time);
    15.         postPolicy.addEqualsCondition("key", fileName);
    16.         try {
    17.             Map map = minioClient.getPresignedPostFormData(postPolicy);
    18.             HashMap map1 = new HashMap<>();
    19.             map.forEach((k,v)->{
    20.                map1.put(k.replaceAll("-",""),v);
    21.            });
    22.             map1.put("host",configuration.getUrl()+"/"+configuration.getBucketName());
    23.             return map1;
    24.         } catch (ErrorResponseException e) {
    25.             e.printStackTrace();
    26.         } catch (InsufficientDataException e) {
    27.             e.printStackTrace();
    28.         } catch (InternalException e) {
    29.             e.printStackTrace();
    30.         } catch (InvalidKeyException e) {
    31.             e.printStackTrace();
    32.         } catch (InvalidResponseException e) {
    33.             e.printStackTrace();
    34.         } catch (IOException e) {
    35.             e.printStackTrace();
    36.         } catch (NoSuchAlgorithmException e) {
    37.             e.printStackTrace();
    38.         } catch (ServerException e) {
    39.             e.printStackTrace();
    40.         } catch (XmlParserException e) {
    41.             e.printStackTrace();
    42.         }
    43.         return null;
    44.     }
    45.  
    46.     /**
    47.      * @description: 获取上传文件的url
    48.      */
    49.     public String getPolicyUrl(String objectName, Method method, int time, TimeUnit timeUnit) {
    50.         try {
    51.             return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
    52.                     .method(method)
    53.                     .bucket(configuration.getBucketName())
    54.                     .object(objectName)
    55.                     .expiry(time, timeUnit).build());
    56.         } catch (ErrorResponseException e) {
    57.             e.printStackTrace();
    58.         } catch (InsufficientDataException e) {
    59.             e.printStackTrace();
    60.         } catch (InternalException e) {
    61.             e.printStackTrace();
    62.         } catch (InvalidKeyException e) {
    63.             e.printStackTrace();
    64.         } catch (InvalidResponseException e) {
    65.             e.printStackTrace();
    66.         } catch (IOException e) {
    67.             e.printStackTrace();
    68.         } catch (NoSuchAlgorithmException e) {
    69.             e.printStackTrace();
    70.         } catch (XmlParserException e) {
    71.             e.printStackTrace();
    72.         } catch (ServerException e) {
    73.             e.printStackTrace();
    74.         }
    75.         return null;
    76.     }
    77.  
    78.  
    79.     /**
    80.      * @description: 上传文件
    81.      */
    82.     public void upload(MultipartFile file, String fileName) {
    83.         // 使用putObject上传一个文件到存储桶中。
    84.         try {
    85.             InputStream inputStream = file.getInputStream();
    86.             minioClient.putObject(PutObjectArgs.builder()
    87.                     .bucket(configuration.getBucketName())
    88.                     .object(fileName)
    89.                     .stream(inputStream, file.getSize(), -1)
    90.                     .contentType(file.getContentType())
    91.                     .build());
    92.         } catch (ErrorResponseException e) {
    93.             e.printStackTrace();
    94.         } catch (InsufficientDataException e) {
    95.             e.printStackTrace();
    96.         } catch (InternalException e) {
    97.             e.printStackTrace();
    98.         } catch (InvalidKeyException e) {
    99.             e.printStackTrace();
    100.         } catch (InvalidResponseException e) {
    101.             e.printStackTrace();
    102.         } catch (IOException e) {
    103.             e.printStackTrace();
    104.         } catch (NoSuchAlgorithmException e) {
    105.             e.printStackTrace();
    106.         } catch (ServerException e) {
    107.             e.printStackTrace();
    108.         } catch (XmlParserException e) {
    109.             e.printStackTrace();
    110.         }
    111.     }
    112.   /**
    113.      * @description: 根据filename获取文件访问地址
    114.      */
    115.     public String getUrl(String objectName, int time, TimeUnit timeUnit) {
    116.         String url = null;
    117.         try {
    118.             url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
    119.                     .method(Method.GET)
    120.                     .bucket(configuration.getBucketName())
    121.                     .object(objectName)
    122.                     .expiry(time, timeUnit).build());
    123.         } catch (ErrorResponseException e) {
    124.             e.printStackTrace();
    125.         } catch (InsufficientDataException e) {
    126.             e.printStackTrace();
    127.         } catch (InternalException e) {
    128.             e.printStackTrace();
    129.         } catch (InvalidKeyException e) {
    130.             e.printStackTrace();
    131.         } catch (InvalidResponseException e) {
    132.             e.printStackTrace();
    133.         } catch (IOException e) {
    134.             e.printStackTrace();
    135.         } catch (NoSuchAlgorithmException e) {
    136.             e.printStackTrace();
    137.         } catch (XmlParserException e) {
    138.             e.printStackTrace();
    139.         } catch (ServerException e) {
    140.             e.printStackTrace();
    141.         }
    142.         return url;
    143.     }
    144. }

    简单说明：

    • 使用MultipartFile接收前端文件流，再上传到minio。

    • 构建一个formData的签名数据，给前端，让前端之前上传到minio。

    • 构建一个可以上传的临时URL给前端，前端通过携带文件请求该URL进行上传。

    • 使用filename请求服务端获取临时访问文件的URL。（最长时间为7 天，想要永久性访问，需要其他设置，这里不做说明。）

    下面展示页面html，使用的是VUE+element-ui进行渲染。

    4.     "UTF-8">
    5.     
    6.     "stylesheet" href="https://unpkg.com/element-ui/lib/theme-chalk/index.css">
    7.     上传图片
    10. "app">
    11.  
    12.     "2">
    13.         "8">
    14.             
      "div-center-class">
    15.                 
      "">
    16.                     
      传统上传
    17.                     
    18.                             class="upload-demo"
    19.                             action="#"
    20.                             drag
    21.                             :http-request="uploadHandle">
    22.                         "el-icon-upload">
    23.                         
      "el-upload__text">将文件拖到此处，或点击上传
    24.                         
      "el-upload__tip" slot="tip">只能上传jpg/png文件，且不超过500kb
    25.                     
    26.                     
      if="imgUrl">
    27.                         "imgUrl" style="width: 40px;height: 40px">
    28.
  • "8">
  • "div-center-class">
  • "">

  • 前端formData直传

  • class="upload-demo"
  • action="#"
  • drag
  • :http-request="httpRequestHandle">
  • "el-icon-upload">
  • "el-upload__text">将文件拖到此处，或点击上传
  • "el-upload__tip" slot="tip">只能上传jpg/png文件，且不超过500kb
  • if="directUrl">
  • "directUrl" style="width: 40px;height: 40px">
  • "8">
  • "div-center-class">
  • "">

  • 前端Url直传

  • class="upload-demo"
  • action="#"
  • drag
  • :http-request="UrlUploadHandle">
  • "el-icon-upload">
  • "el-upload__text">将文件拖到此处，或点击上传
  • "el-upload__tip" slot="tip">只能上传jpg/png文件，且不超过500kb
  • if="uploadUrl">
  • "uploadUrl" style="width: 40px;height: 40px">

    • 页面的效果就如上图所示。

    可以分别体验不同的实现效果。

    以上就是使用springboot搭建基于minio的高性能存储服务的全部步骤了。

    本项目地址:
    https://gitee.com/jack_whh/minio-upload

     

  • 相关阅读:
    Springboot 引入第三方jar包，并打包运行
    C++学习资源
    Linux内核设计与实现 第六章 内核数据结构
    Leetcode739. 每日温度
    低代码掀起“数字革命”，引领制造业数字化转型
    Jmeter基础入门教程【12】--常用功能详解：JDBC
    基于RuoYi-Flowable-Plus的若依ruoyi-nbcio支持自定义业务表单流程（一）
    网络流问题
    Spring MVC基于注解的使用：JSON数据处理
    【云原生】k8s中volumeMounts.subPath的巧妙用法
  • 原文地址：https://blog.csdn.net/LU58542226/article/details/133104926