devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

MinIO文件服务器的安装使用_minio安装

作者：Gausst松鼠会 | 2024-05-08 11:27:37

赞

踩

minio安装

什么是MinIO？

MinIO 是一款高性能、分布式的对象存储系统

MinIO提供高性能、S3兼容的对象存储

目录

一、安装步骤

1.1 连接服务器（此处为linux系统）

1.2 使用命令在root目录下创建minio文件夹，打开minio文件夹，下载minio

1.3 下载完成后会在当前目录下出现一个minio目录，为该文件添加可执行权限

1.4 创建minio文件存储目录及日志目录

1.5 在 /root/minio/目录下，新建一个run.sh并编辑以下内容，使用命令vim run.sh,然后将以下内容保存到run.sh。注：用户名和密码自己设置

1.6 为其赋予执行权限chmod u+x run.sh

1.7 启动minio并查看日志

1.8 访问其中的http://192.169.1.6:9002,使用5中配置的用户名密码登录

 1.9 创建Buckets（桶）

1.10 创建访问密钥并保存。注：springboot整合需要用到

 二、使用步骤

2.1 项目引入依赖

2.2 application.yml文件里配置minio。注：minio配置信息需改为自身的

2.3 创建minio配置类和工具类

2.4 创建一个数据表，用于保存上传到minio的文件的信息

2.5 使用代码自动生成器生成entity、controller、service、mapper。

2.6 创建minio上传、删除接口

2.7 封装上传返回数据MinioResponseDTO对象

2.8 测试

一、安装步骤

1.1 连接服务器（此处为linux系统）

1.2 使用命令在root目录下创建minio文件夹，打开minio文件夹，下载minio

  1. cd
  2. mkdir minio
  3. cd minio
  4. wget https://dl.min.io/server/minio/release/linux-amd64/minio

1.3 下载完成后会在当前目录下出现一个minio目录，为该文件添加可执行权限

chmod +x minio

1.4 创建minio文件存储目录及日志目录

  1. # 创建minio文件存储目录及日志目录
  2. mkdir -p /root/data/minio;
  3. mkdir -p /root/logs/minio;

1.5 在 /root/minio/目录下，新建一个run.sh并编辑以下内容，使用命令vim run.sh,然后将以下内容保存到run.sh。注：用户名和密码自己设置

  1. #!/bin/bash
  2. export MINIO_ROOT_USER=minio-username
  3. export MINIO_ROOT_PASSWORD=minio-password
  4. # nohup启动服务 指定文件存放路径 /root/data 还有设置日志文件路径 /root/minio/log
  5. nohup ./minio server --address :9002 --console-address :9001 /root/data/minio > /root/logs/minio/minio.log 2>&1 &

1.6 为其赋予执行权限chmod u+x run.sh

chmod u+x run.sh

1.7 启动minio并查看日志

  1. # 启动minio服务
  2. bash run.sh
  3. # 查看日志
  4. tail -200f /root/logs/minio/minio.log

 出现以下内容即安装成功

1.8 访问其中的http://192.169.1.6:9002,使用5中配置的用户名密码登录

 1.9 创建Buckets（桶）

1.10 创建访问密钥并保存。注：springboot整合需要用到

 二、使用步骤

2.1 项目引入依赖

  1. <dependencies>
  2.    <dependency>
  3.        <groupId>io.minio</groupId>
  4.        <artifactId>minio</artifactId>
  5.        <version>7.1.0</version>
  6.    </dependency>
  7. </dependencies>

2.2 application.yml文件里配置minio。注：minio配置信息需改为自身的

  1. minio:
  2.   endpoint: http://192.168.1.6：9002
  3.   # 安装步骤10中创建的访问密钥
  4.   accessKey: ***************
  5.   secretKey: ********************
  6.   # 安装步骤9中创建的bckets名字
  7.   bucketName: test
  8.   secure: false
  9. spring:
  10.      mvc:
  11.       hiddenmethod:
  12.         filter:
  13.           enabled: true
  14. #        设置文件上传大小限制
  15.   servlet:
  16.     multipart:
  17.       max-file-size: 100MB
  18.       max-request-size: 150MB

2.3 创建minio配置类和工具类

配置类：

  1. import io.minio.MinioClient;
  2. import io.minio.errors.InvalidPortException;
  3. import lombok.Data;
  4. import org.springframework.boot.context.properties.ConfigurationProperties;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.stereotype.Component;
  8.  
  9. /**
  10.  * @author Lannibar
  11.  * @date: 2023-5-17
  12.  * @Description minio配置
  13.  */
  14. @Configuration
  15. @Component
  16. @ConfigurationProperties(prefix = "minio")
  17. @Data
  18. public class MinioConfig {
  19.  
  20.     private String endpoint;
  21.  
  22.     private int port;
  23.  
  24.     private String accessKey;
  25.  
  26.     private String secretKey;
  27.  
  28.     private Boolean secure;
  29.  
  30.     private String bucketName;
  31.  
  32.     @Bean
  33.     public MinioClient getMinioClient() throws InvalidPortException {
  34.         MinioClient minioClient = MinioClient.builder().endpoint(endpoint)
  35.                 .credentials(accessKey, secretKey)
  36.                 .build();
  37.         return minioClient;
  38.     }
  39.  
  40. }

工具类：

  1. package com.xiaomifeng.minio.util;
  2.  
  3. import io.minio.*;
  4. import io.minio.errors.*;
  5. import io.minio.http.Method;
  6. import io.minio.messages.Bucket;
  7. import io.minio.messages.DeleteError;
  8. import io.minio.messages.DeleteObject;
  9. import io.minio.messages.Item;
  10. import lombok.extern.slf4j.Slf4j;
  11. import org.apache.commons.lang.StringUtils;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.stereotype.Component;
  14. import org.springframework.web.multipart.MultipartFile;
  15. import javax.servlet.ServletOutputStream;
  16. import javax.servlet.http.HttpServletResponse;
  17. import java.io.IOException;
  18. import java.io.InputStream;
  19. import java.nio.charset.StandardCharsets;
  20. import java.security.InvalidKeyException;
  21. import java.security.NoSuchAlgorithmException;
  22. import java.util.ArrayList;
  23. import java.util.List;
  24.  
  25. /**
  26.  * MinIO 客户端工具类
  27.  */
  28. @Component
  29. @Slf4j
  30. public class MinioClientUtils {
  31.  
  32.     @Autowired
  33.     private MinioClient minioClient;
  34.  
  35.     private static final int DEFAULT_EXPIRY_TIME = 7 * 24 * 3600;
  36.  
  37.     /**
  38.      * 检查存储桶是否存在
  39.      *
  40.      * @param bucketName 存储桶名称
  41.      * @return boolean
  42.      */
  43.     public boolean bucketExists(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
  44.         boolean flag = false;
  45.         flag = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
  46.         if (flag) {
  47.             return true;
  48.         }
  49.         return false;
  50.     }
  51.  
  52.     /**
  53.      * 创建存储桶
  54.      *
  55.      * @param bucketName 存储桶名称
  56.      */
  57.     public boolean makeBucket(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, RegionConflictException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
  58.         boolean flag = bucketExists(bucketName);
  59.         if (!flag) {
  60.             minioClient.makeBucket(
  61.                     MakeBucketArgs.builder()
  62.                             .bucket(bucketName)
  63.                             .build());
  64.             return true;
  65.         } else {
  66.             return false;
  67.         }
  68.     }
  69.  
  70.     /**
  71.      * 列出所有存储桶名称
  72.      *
  73.      * @return List<String>
  74.      */
  75.     public List<String> listBucketNames() throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
  76.         List<Bucket> bucketList = listBuckets();
  77.         List<String> bucketListName = new ArrayList<>();
  78.         for (Bucket bucket : bucketList) {
  79.             bucketListName.add(bucket.name());
  80.         }
  81.         return bucketListName;
  82.     }
  83.  
  84.     /**
  85.      * 列出所有存储桶
  86.      *
  87.      * @return List<Bucket>
  88.      */
  89.     public List<Bucket> listBuckets() throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
  90.         return minioClient.listBuckets();
  91.     }
  92.  
  93.     /**
  94.      * 删除存储桶
  95.      *
  96.      * @param bucketName 存储桶名称
  97.      * @return boolean
  98.      */
  99.     public boolean removeBucket(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
  100.         boolean flag = bucketExists(bucketName);
  101.         if (flag) {
  102.             Iterable<Result<Item>> myObjects = listObjects(bucketName);
  103.             for (Result<Item> result : myObjects) {
  104.                 Item item = result.get();
  105.                 // 有对象文件，则删除失败
  106.                 if (item.size() > 0) {
  107.                     return false;
  108.                 }
  109.             }
  110.             // 删除存储桶，注意，只有存储桶为空时才能删除成功。
  111.             minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
  112.             flag = bucketExists(bucketName);
  113.             if (!flag) {
  114.                 return true;
  115.             }
  116.  
  117.         }
  118.         return false;
  119.     }
  120.  
  121.     /**
  122.      * 列出存储桶中的所有对象名称
  123.      *
  124.      * @param bucketName 存储桶名称
  125.      * @return List<String>
  126.      */
  127.     public List<String> listObjectNames(String bucketName) throws XmlParserException, IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, InvalidBucketNameException, InsufficientDataException, InternalException {
  128.         List<String> listObjectNames = new ArrayList<>();
  129.         boolean flag = bucketExists(bucketName);
  130.         if (flag) {
  131.             Iterable<Result<Item>> myObjects = listObjects(bucketName);
  132.             for (Result<Item> result : myObjects) {
  133.                 Item item = result.get();
  134.                 listObjectNames.add(item.objectName());
  135.             }
  136.         }
  137.         return listObjectNames;
  138.     }
  139.  
  140.     /**
  141.      * 列出存储桶中的所有对象
  142.      *
  143.      * @param bucketName 存储桶名称
  144.      * @return Iterable<Result<Item>>
  145.      */
  146.     public Iterable<Result<Item>> listObjects(String bucketName) throws XmlParserException, IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, InvalidBucketNameException, InsufficientDataException, InternalException {
  147.         boolean flag = bucketExists(bucketName);
  148.         if (flag) {
  149.             return minioClient.listObjects( ListObjectsArgs.builder().bucket(bucketName).build());
  150.         }
  151.         return null;
  152.     }
  153.  
  154.     /**
  155.      * 通过文件上传到对象
  156.      *
  157.      * @param bucketName 存储桶名称
  158.      * @param objectName 存储桶里的对象名称
  159.      * @param fileName   File name
  160.      * @return boolean
  161.      */
  162.     public boolean uploadObject(String bucketName, String objectName, String fileName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
  163.         boolean flag = bucketExists(bucketName);
  164.         if (flag) {
  165.             minioClient.uploadObject(
  166.                     UploadObjectArgs.builder()
  167.                             .bucket(bucketName).object(objectName).filename(fileName).build());
  168.             ObjectStat statObject = statObject(bucketName, objectName);
  169.             if (statObject != null && statObject.length() > 0) {
  170.                 return true;
  171.             }
  172.         }
  173.         return false;
  174.  
  175.     }
  176.  
  177.     /**
  178.      * 文件上传
  179.      *
  180.      * @param bucketName 存储捅名称
  181.      * @param multipartFile 文件
  182.      * @param filename   文件名
  183.      */
  184.     public void putObject(String bucketName, MultipartFile multipartFile, String filename) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
  185.         PutObjectOptions putObjectOptions = new PutObjectOptions(multipartFile.getSize(), PutObjectOptions.MIN_MULTIPART_SIZE);
  186.         putObjectOptions.setContentType(multipartFile.getContentType());
  187.         minioClient.putObject(
  188.                 PutObjectArgs.builder().bucket(bucketName).object(filename).stream(
  189.                         multipartFile.getInputStream(), multipartFile.getSize(), -1).contentType(multipartFile.getContentType())
  190.                         .build());
  191.     }
  192.  
  193.     /**
  194.      * 通过InputStream上传对象
  195.      *
  196.      * @param bucketName 存储桶名称
  197.      * @param objectName 存储桶里的对象名称
  198.      * @param inputStream     要上传的流
  199.      * @param contentType 上传的文件类型 例如 video/mp4  image/jpg
  200.      * @return boolean
  201.      */
  202.     public boolean putObject(String bucketName, String objectName, InputStream inputStream,String contentType) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
  203.         boolean flag = bucketExists(bucketName);
  204.         if (flag) {
  205.             minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(
  206.                     //不清楚文件的大小时，可以传-1，10485760。如果知道大小也可以传入size，partsize。
  207.                     inputStream,  -1, 10485760)
  208.                     .contentType(contentType)
  209.                     .build());
  210.             ObjectStat statObject = statObject(bucketName, objectName);
  211.             if (statObject != null && statObject.length() > 0) {
  212.                 return true;
  213.             }
  214.         }
  215.         return false;
  216.     }
  217.  
  218.     /**
  219.      * 以流的形式获取一个文件对象
  220.      *
  221.      * @param bucketName 存储桶名称
  222.      * @param objectName 存储桶里的对象名称
  223.      * @return InputStream
  224.      */
  225.     public InputStream getObject(String bucketName, String objectName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
  226.         boolean flag = bucketExists(bucketName);
  227.         if (flag) {
  228.             ObjectStat statObject = statObject(bucketName, objectName);
  229.             if (statObject != null && statObject.length() > 0) {
  230.                 InputStream stream = minioClient.getObject( GetObjectArgs.builder()
  231.                         .bucket(bucketName)
  232.                         .object(objectName)
  233.                         .build());
  234.                 return stream;
  235.             }
  236.         }
  237.         return null;
  238.     }
  239.  
  240.     /**
  241.      * 以流的形式获取一个文件对象（断点下载）
  242.      *
  243.      * @param bucketName 存储桶名称
  244.      * @param objectName 存储桶里的对象名称
  245.      * @param offset     起始字节的位置
  246.      * @param length     要读取的长度 (可选，如果无值则代表读到文件结尾)
  247.      * @return InputStream
  248.      */
  249.     public InputStream getObject(String bucketName, String objectName, long offset, Long length) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
  250.         boolean flag = bucketExists(bucketName);
  251.         if (flag) {
  252.             ObjectStat statObject = statObject(bucketName, objectName);
  253.             if (statObject != null && statObject.length() > 0) {
  254.                 InputStream stream = minioClient.getObject(  GetObjectArgs.builder()
  255.                         .bucket(bucketName)
  256.                         .object(objectName)
  257.                         .offset(1024L)
  258.                         .length(4096L)
  259.                         .build());
  260.                 return stream;
  261.             }
  262.         }
  263.         return null;
  264.     }
  265.  
  266.     /**
  267.      * 下载并将文件保存到本地
  268.      *
  269.      * @param bucketName 存储桶名称
  270.      * @param objectName 存储桶里的对象名称
  271.      * @param fileName   File name
  272.      * @return boolean
  273.      */
  274.     public boolean downloadObject(String bucketName, String objectName, String fileName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
  275.         boolean flag = bucketExists(bucketName);
  276.         if (flag) {
  277.             ObjectStat statObject = statObject(bucketName, objectName);
  278.             if (statObject != null && statObject.length() > 0) {
  279.                 minioClient.downloadObject(DownloadObjectArgs.builder()
  280.                         .bucket(bucketName)
  281.                         .object(objectName)
  282.                         .filename(fileName)
  283.                         .build());
  284.                 return true;
  285.             }
  286.         }
  287.         return false;
  288.     }
  289.  
  290.     /**
  291.      * 删除一个对象
  292.      *
  293.      * @param bucketName 存储桶名称
  294.      * @param objectName 存储桶里的对象名称
  295.      */
  296.     public boolean removeObject(String bucketName, String objectName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
  297.         boolean flag = bucketExists(bucketName);
  298.         if (flag) {
  299.             minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
  300.             return true;
  301.         }
  302.         return false;
  303.     }
  304.  
  305.     /**
  306.      * 删除指定桶的多个文件对象,返回删除错误的对象列表，全部删除成功，返回空列表
  307.      *
  308.      * @param bucketName  存储桶名称
  309.      * @param objectNames 含有要删除的多个object名称的迭代器对象
  310.      * @return
  311.      * eg:
  312.      * List<DeleteObject> objects = new LinkedList<>();
  313.      * objects.add(new DeleteObject("my-objectname1"));
  314.      * objects.add(new DeleteObject("my-objectname2"));
  315.      * objects.add(new DeleteObject("my-objectname3"));
  316.      */
  317.     public List<String> removeObjects(String bucketName, List<DeleteObject> objectNames) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
  318.         List<String> deleteErrorNames = new ArrayList<>();
  319.         boolean flag = bucketExists(bucketName);
  320.         if (flag) {
  321.             Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(objectNames).build());
  322.             for (Result<DeleteError> result : results) {
  323.                 DeleteError error = result.get();
  324.                 deleteErrorNames.add(error.objectName());
  325.             }
  326.         }
  327.         return deleteErrorNames;
  328.     }
  329.  
  330.     /**
  331.      * 生成一个给HTTP GET请求用的presigned URL。
  332.      * 浏览器/移动端的客户端可以用这个URL进行下载，即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间，默认值是7天。
  333.      *
  334.      * @param bucketName 存储桶名称
  335.      * @param objectName 存储桶里的对象名称
  336.      * @param expires    失效时间（以秒为单位），默认是7天，不得大于七天
  337.      * @return
  338.      */
  339.     public String getPresignedObjectUrl(String bucketName, String objectName, Integer expires) throws InvalidExpiresRangeException, IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
  340.         boolean flag = bucketExists(bucketName);
  341.         String url = "";
  342.         if (flag) {
  343.             if (expires < 1 || expires > DEFAULT_EXPIRY_TIME) {
  344.                 throw new InvalidExpiresRangeException(expires,
  345.                         "expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
  346.             }
  347.             try {
  348.                 url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
  349.                         .method(Method.GET)
  350.                         .bucket(bucketName)
  351.                         .object(objectName)
  352.                         .expiry(expires)//动态参数
  353.                         //                       .expiry(24 * 60 * 60)//用秒来计算一天时间有效期
  354. //                        .expiry(1, TimeUnit.DAYS)//按天传参
  355. //                        .expiry(1, TimeUnit.HOURS)//按小时传参数
  356.                         .build());
  357.             } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidBucketNameException | InvalidExpiresRangeException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {
  358.                 e.printStackTrace();
  359.             }
  360.         }
  361.         return url;
  362.     }
  363.  
  364.     /**
  365.      * 生成一个给HTTP PUT请求用的presigned URL。
  366.      * 浏览器/移动端的客户端可以用这个URL进行上传，即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间，默认值是7天。
  367.      *
  368.      * @param bucketName 存储桶名称
  369.      * @param objectName 存储桶里的对象名称
  370.      * @param expires    失效时间（以秒为单位），默认是7天，不得大于七天
  371.      * @return String
  372.      */
  373.     public String presignedPutObject(String bucketName, String objectName, Integer expires) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
  374.         boolean flag = bucketExists(bucketName);
  375.         String url = "";
  376.         if (flag) {
  377.             if (expires < 1 || expires > DEFAULT_EXPIRY_TIME) {
  378.                 try {
  379.                     throw new InvalidExpiresRangeException(expires,
  380.                             "expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
  381.                 } catch (InvalidExpiresRangeException e) {
  382.                     e.printStackTrace();
  383.                 }
  384.             }
  385.             try {
  386.                 url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
  387.                         .method(Method.PUT)
  388.                         .bucket(bucketName)
  389.                         .object(objectName)
  390.                         .expiry(expires)//动态参数
  391.                         //                       .expiry(24 * 60 * 60)//用秒来计算一天时间有效期
  392. //                        .expiry(1, TimeUnit.DAYS)//按天传参
  393. //                        .expiry(1, TimeUnit.HOURS)//按小时传参数
  394.                         .build());
  395.             } catch (ErrorResponseException | InsufficientDataException e) {
  396.                 e.printStackTrace();
  397.             } catch (InternalException e) {
  398.                 log.error("InternalException",e);
  399.             } catch (InvalidBucketNameException e) {
  400.                 log.error("InvalidBucketNameException",e);
  401.             } catch (InvalidExpiresRangeException e) {
  402.                 log.error("InvalidExpiresRangeException",e);
  403.             } catch (InvalidKeyException e) {
  404.                 log.error("InvalidKeyException",e);
  405.             } catch (InvalidResponseException e) {
  406.                 log.error("InvalidResponseException",e);
  407.             } catch (IOException e) {
  408.                 log.error("IOException",e);
  409.             } catch (NoSuchAlgorithmException e) {
  410.                 log.error("NoSuchAlgorithmException",e);
  411.             } catch (ServerException e) {
  412.                 log.error("ServerException",e);
  413.             } catch (XmlParserException e) {
  414.                 log.error("XmlParserException",e);
  415.             }
  416.         }
  417.         return url;
  418.     }
  419.  
  420.     /**
  421.      * 获取对象的元数据
  422.      *
  423.      * @param bucketName 存储桶名称
  424.      * @param objectName 存储桶里的对象名称
  425.      * @return
  426.      */
  427.     public ObjectStat statObject(String bucketName, String objectName) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
  428.         boolean flag = bucketExists(bucketName);
  429.         if (flag) {
  430.             ObjectStat statObject = null;
  431.             try {
  432.                 statObject = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
  433.             } catch (ErrorResponseException e) {
  434.                 log.error("ErrorResponseException",e);
  435.             } catch (InsufficientDataException e) {
  436.                 log.error("ErrorResponseException",e);
  437.                 e.printStackTrace();
  438.             } catch (InternalException e) {
  439.                 log.error("InternalException",e);
  440.             } catch (InvalidBucketNameException e) {
  441.                 log.error("InvalidBucketNameException",e);
  442.             } catch (InvalidKeyException e) {
  443.                 log.error("InvalidKeyException",e);
  444.             } catch (InvalidResponseException e) {
  445.                 log.error("InvalidResponseException",e);
  446.             } catch (IOException e) {
  447.                 log.error("IOException",e);
  448.             } catch (NoSuchAlgorithmException e) {
  449.                 log.error("NoSuchAlgorithmException",e);
  450.             } catch (ServerException e) {
  451.                 log.error("ServerException",e);
  452.             } catch (XmlParserException e) {
  453.                 log.error("XmlParserException",e);
  454.             }
  455.             return statObject;
  456.         }
  457.         return null;
  458.     }
  459.  
  460.     /**
  461.      * 文件访问路径
  462.      *
  463.      * @param bucketName 存储桶名称
  464.      * @param objectName 存储桶里的对象名称
  465.      * @return String
  466.      */
  467.     public String getObjectUrl(String bucketName, String objectName) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
  468.         boolean flag = bucketExists(bucketName);
  469.         String url = "";
  470.         if (flag) {
  471.             try {
  472.                 url = minioClient.getObjectUrl(bucketName, objectName);
  473.             } catch (ErrorResponseException e) {
  474.                 log.error("XmlParserException",e);
  475.             } catch (InsufficientDataException e) {
  476.                 log.error("InsufficientDataException",e);
  477.             } catch (InternalException e) {
  478.                 log.error("InternalException",e);
  479.             } catch (InvalidBucketNameException e) {
  480.                 log.error("InvalidBucketNameException",e);
  481.             } catch (InvalidKeyException e) {
  482.                 log.error("InvalidKeyException",e);
  483.             } catch (InvalidResponseException e) {
  484.                 log.error("InvalidResponseException",e);
  485.             } catch (IOException e) {
  486.                 log.error("IOException",e);
  487.             } catch (NoSuchAlgorithmException e) {
  488.                 log.error("NoSuchAlgorithmException",e);
  489.             } catch (ServerException e) {
  490.                 log.error("ServerException",e);
  491.             } catch (XmlParserException e) {
  492.                 log.error("XmlParserException",e);
  493.             }
  494.         }
  495.         return url;
  496.     }
  497.  
  498.  
  499.  
  500.     public void downloadFile(String bucketName, String fileName, String originalName, HttpServletResponse response) {
  501.         try {
  502.  
  503.             InputStream file = minioClient.getObject(GetObjectArgs.builder()
  504.                     .bucket(bucketName)
  505.                     .object(fileName)
  506.                     .build());
  507.             String filename = new String(fileName.getBytes("ISO8859-1"), StandardCharsets.UTF_8);
  508.             if (StringUtils.isNotEmpty(originalName)) {
  509.                 fileName = originalName;
  510.             }
  511.             response.setHeader("Content-Disposition", "attachment;filename=" + filename);
  512.             ServletOutputStream servletOutputStream = response.getOutputStream();
  513.             int len;
  514.             byte[] buffer = new byte[1024];
  515.             while ((len = file.read(buffer)) > 0) {
  516.                 servletOutputStream.write(buffer, 0, len);
  517.             }
  518.             servletOutputStream.flush();
  519.             file.close();
  520.             servletOutputStream.close();
  521.         } catch (ErrorResponseException e) {
  522.             log.error("ErrorResponseException",e);
  523.         } catch (Exception e) {
  524.             log.error("Exception",e);
  525.         }
  526.     }
  527. }

2.4 创建一个数据表，用于保存上传到minio的文件的信息

  1. CREATE TABLE `minio_file` (
  2.   `id` bigint(20) NOT NULL COMMENT '文件id',
  3.   `original_file_name` varchar(255) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '原始文件名称',
  4.   `file_ext_name` varchar(15) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '文件拓展名',
  5.   `file_size` bigint(20) DEFAULT NULL COMMENT '文件大小(单位：字节）',
  6.   `file_name` varchar(35) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '存入minio时的文件名称',
  7.   `mime` varchar(50) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '文件的content-type',
  8.   `file_url` varchar(255) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '文件路径',
  9.   `is_delete` tinyint(1) DEFAULT NULL COMMENT '是否删除 0 否 1 是',
  10.   `create_by` varchar(25) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '创建者',
  11.   `update_by` varchar(25) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '更改者',
  12.   `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  13.   `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  14.   PRIMARY KEY (`id`)
  15. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

2.5 使用代码自动生成器生成entity、controller、service、mapper。

代码自动生成器文章地址：代码自动生成器_芒果味的戏子的博客-CSDN博客

2.6 创建minio上传、删除接口

  1. import cn.hutool.core.io.FileUtil;
  2. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  3. import io.swagger.annotations.Api;
  4. import io.swagger.annotations.ApiImplicitParam;
  5. import io.swagger.annotations.ApiOperation;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.apache.commons.collections4.CollectionUtils;
  8. import org.apache.commons.lang3.RandomStringUtils;
  9. import org.apache.commons.lang3.math.NumberUtils;
  10. import org.jeecg.common.api.vo.Result;
  11. import org.jeecg.config.oss.MinioConfig;
  12. import org.jeecg.modules.dto.MinioResponseDTO;
  13. import org.jeecg.modules.entity.MinioFile;
  14. import org.jeecg.modules.service.MinioFileService;
  15. import org.jeecg.modules.util.MinioClientUtils;
  16. import org.springframework.beans.factory.annotation.Autowired;
  17. import org.springframework.web.bind.annotation.*;
  18. import org.springframework.web.multipart.MultipartFile;
  19. import javax.annotation.Resource;
  20. import java.time.Instant;
  21. import java.util.ArrayList;
  22. import java.util.List;
  23.  
  24. /**
  25.  * @author xiaomifeng1010
  26.  * @version 1.0
  27.  * @date: 2022/5/21 10:33
  28.  * @Description  minio 文件处理（上传，下载，获取文件地址等）
  29.  */
  30. @Slf4j
  31. @Api(tags = "文件处理模块")
  32. @RestController
  33. @CrossOrigin //处理跨域请求
  34. @RequestMapping("/minioFile")
  35. public class MinioFileController {
  36.  
  37.     @Resource
  38.     private MinioClientUtils minioClientUtils;
  39.  
  40.     @Resource
  41.     private MinioConfig minioConfig;
  42.  
  43.     @Autowired
  44.     private MinioFileService minioFileService;
  45.  
  46.     @PostMapping(value = "/uploadFile")
  47.     @ApiOperation(value = "上传文件,支持批量上传")
  48.     @ApiImplicitParam(name = "files",value = "文件对象",dataType = "File")
  49.     public Result uploadFile(@RequestParam("files") List<MultipartFile> files) {
  50.         log.info(files.toString());
  51.         if (CollectionUtils.isEmpty(files)){
  52.             return Result.error("未选择文件！");
  53.         }
  54.  
  55.         List<MinioResponseDTO> MinioResponseDTOList=new ArrayList<>();
  56.         for (MultipartFile file : files) {
  57.             String originalFilename = file.getOriginalFilename();
  58. //            获取文件拓展名
  59.             String extName = FileUtil.extName(originalFilename);
  60.             log.info("文件拓展名:"+extName);
  61. //            生成新的文件名，存入到minio
  62.             long millSeconds = Instant.now().toEpochMilli();
  63.             String minioFileName=millSeconds+ RandomStringUtils.randomNumeric(12)+"."+extName;
  64.             String contentType = file.getContentType();
  65.             log.info("文件mime:{}",contentType);
  66. //            返回文件大小,单位字节
  67.             long size = file.getSize();
  68.             log.info("文件大小："+size);
  69.             try {
  70.                 String bucketName = minioConfig.getBucketName();
  71.                 minioClientUtils.putObject(bucketName,file,minioFileName);
  72.                 String fileUrl = minioClientUtils.getObjectUrl(bucketName, minioFileName);
  73.                 MinioFile minioFile = new MinioFile();
  74.                 minioFile.setOriginalFileName(originalFilename);
  75.                 minioFile.setFileExtName(extName);
  76.                 minioFile.setFileName(minioFileName);
  77.                 minioFile.setFileSize(size);
  78.                 minioFile.setMime(contentType);
  79. //                minioFile.setIsDelete(NumberUtils.INTEGER_ZERO);
  80.                 minioFile.setIsDelete(NumberUtils.INTEGER_ZERO == 0 ? false : true);
  81.  
  82.                 minioFile.setFileUrl(fileUrl);
  83.                 boolean insert = minioFileService.save(minioFile);
  84.                 if (insert) {
  85.                     MinioResponseDTO minioResponseDTO = new MinioResponseDTO();
  86.                     minioResponseDTO.setFileId(minioFile.getId());
  87.                     minioResponseDTO.setOriginalFileName(originalFilename);
  88.                     minioResponseDTO.setFileUrl(fileUrl);
  89.                     MinioResponseDTOList.add(minioResponseDTO);
  90.                 }
  91.  
  92.             } catch (Exception e) {
  93.                 log.error("上传文件出错:{}",e);
  94.                 return Result.error("上传文件出错");
  95.  
  96.             }
  97.         }
  98.  
  99.         return Result.ok(MinioResponseDTOList);
  100.     }
  101.  
  102.     /**
  103.      * 删除文件
  104.      * @param minioFileName 文件名称
  105.      * @return
  106.      */
  107.     @ApiOperation(value = "删除文件" , notes = "删除文件")
  108.     @RequestMapping(value = "/deleteMinioFile",method = RequestMethod.GET)
  109.     public Result<?> deleteMinioFile(@RequestParam String minioFileName){
  110.         try {
  111.             String bucketName = minioConfig.getBucketName();
  112.             minioClientUtils.removeObject(bucketName,minioFileName);
  113.             MinioFile minioFile = minioFileService.getOne(new QueryWrapper<MinioFile>().eq("file_name",minioFileName));
  114.             if (minioFile == null){
  115.                 log.error("文件不存在数据库表中！");
  116.                 return Result.error("文件不存在数据库表中！");
  117.             }else{
  118.                 minioFileService.removeById(minioFile);
  119.             }
  120.         }catch (Exception e){
  121.             log.error("删除文件失败！");
  122.             return Result.error("删除文件失败！");
  123.         }
  124.         return Result.ok("删除文件成功");
  125.     }
  126. }

2.7 封装上传返回数据MinioResponseDTO对象

  1. import io.swagger.annotations.ApiModelProperty;
  2. import lombok.Data;
  3.  
  4. /**
  5.  * 该实体主要用于封装用户提交的文件信息表单
  6.  *
  7.  * @author Lannibar
  8.  * @since 2023-5-18
  9.  */
  10. @Data
  11. public class MinioResponseDTO {
  12.  
  13.     @ApiModelProperty(value = "文件id")
  14.     private Long fileId;
  15.  
  16.     @ApiModelProperty(value = "文件访问地址")
  17.     private String fileUrl;
  18.  
  19.     @ApiModelProperty(value = "文件名")
  20.     private String originalFileName;
  21.  
  22. }

2.8 测试

上传：

数据库数据：

 使用返回的访问地址访问： 

删除：

至此，MinIO文件服务的安装和使用已完成。

文章仅供自身学习和参考。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/554312
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号