devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

MinIO文件服务器，从安装到使用_minio安装

作者：凡人多烦事01 | 2024-05-08 11:32:32

赞

踩

minio安装

以往的项目，用的比较多的OSS服务是腾讯云和阿里云的存储服务，不过从去年到今年，最近的几个项目，普遍要使用Minio,所以我在开发服务器和测试服务器上都装上了minio

一、首先minio的安装

MInIO的安装有很多方法、单实例的、集群分布式的、docker部署的、支持k8s的，我们使用最简单的一种安装方式：linux单节点安装。

如果希望对MinIO有深入的掌握，访问MinIO官网：https://min.io

1.1 安装工作

首先在/root目录下创建一个minio文件夹

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

等待下载完成后：

在当前minio目录下，会出现一个minio目录

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

然后在 /root/minio/目录下，新建一个run.sh并编辑以下内容

vim run.sh,然后将以下内容保存到run.sh,并为其赋予执行权限chmod u+x run.sh

  1. #!/bin/bash
  2. export MINIO_ROOT_USER=root
  3. export MINIO_ROOT_PASSWORD=xiaomifeng1010
  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 &

注意：以前的老版本minio的配置中，配置用户名和密码时，是这两个参数：

MINIO_ACCESS_KEY 和MINIO_SECRET_KEY

而现在比较新的版本的minio，需要替换成MINIO_ROOT_USER和MINIO_ROOT_PASSWORD

并且用户名和密码都是由长度限制的，用户名长度不能小于3，密码不能小于8个字符

当然，minio安装完成，以及配置完成后，启动项目的run.sh的时候，如果你设置的用户名和密码长度不够，会有警告提示的，还有就是如果你的配置参数写成以前的旧版本的参数，也会提示你替换成对应的MINIO_ROOT_USER和MINIO_ROOT_PASSWORD

--address :9002 --console-address :9001 是配置端口，默认minio端口是9000，如果9000端口被占用了，那就加上这一串配置，端口号的冒号之前不需要特意写出ip，当然如果你的ip的动态变化的，而不是静态的话，前边的ip不用写上，当然最好是用静态的ip

然后启动minio

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

 ​​

然后会有日志打印信息，然后可以看到minio服务器地址，和控制台信息地址

然后在浏览器中访问地址

http://ip:9002,输入这个地址后会重定向到控制台登录地址http://ip:9001/login

然后在登录界面输入用户名和密码即可登录

   然后登录后进入首页，创建一个bucket

  创建一个xxx-test，区分开发环境和测试环境，当然我在开发环境服务器上创建的是xxx-dev，由于当前在开发阶段，所以项目中我也配置的是xxx-dev这个桶

 接下来我以开发环境中的桶演示minio文件的上传和下载等

二，springboot项目整合MinIO的javaSDK

2.1 项目的pom文件中引入minio依赖

  1.  <properties>
  2.         <maven.compiler.source>8</maven.compiler.source>
  3.         <maven.compiler.target>8</maven.compiler.target>
  4.         <minio.version>7.1.0</minio.version>
  5.     </properties>
  6.  
  7.     <dependencies>
  8.         <dependency>
  9.             <groupId>io.minio</groupId>
  10.             <artifactId>minio</artifactId>
  11.             <version>${minio.version}</version>
  12.         </dependency>
  13.    </dependencies>

2.2 在application-dev.yml文件中配置minio

  1. minio:
  2.   endpoint: http://serverip
  3.   port: 9002
  4.   bucketName: xxx-dev
  5.   secure: false
  6.  
  7. spring:
  8.      mvc:
  9.       hiddenmethod:
  10.         filter:
  11.           enabled: true
  12. #        设置文件上传大小限制
  13.   servlet:
  14.     multipart:
  15.       max-file-size: 100MB
  16.       max-request-size: 150MB

     由于csdn的限制不允许出现账号和密码相关配置，所以以上的yml配置请参照下边的minio配置类中的属性名，在yml文件中添加上 

2.3 创建minio配置类和工具类

配置类：

  1. package com.xiaomifeng1010.minio.configuration;
  2.  
  3. import io.minio.MinioClient;
  4. import io.minio.errors.InvalidPortException;
  5. import lombok.Getter;
  6. import lombok.Setter;
  7. import org.springframework.boot.context.properties.ConfigurationProperties;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.stereotype.Component;
  11.  
  12. /**
  13.  * @author xiaomifeng1010
  14.  * @version 1.0
  15.  * @Description minio配置
  16.  */
  17. @Configuration
  18. @Component
  19. @ConfigurationProperties(prefix = "minio")
  20. @Getter
  21. @Setter
  22. public class MinioConfig {
  23.     private String endpoint;
  24.     private int port;
  25. //           对应账号（请手动加到yml文件中）
  26.     private String accessKey;
  27. //           对应密码（请手动加到yml文件中）
  28.     private String secretKey;
  29.     private Boolean secure;
  30.     private String bucketName;
  31.  
  32.     @Bean
  33.     public MinioClient getMinioClient() throws InvalidPortException {
  34.         MinioClient minioClient = MinioClient.builder().endpoint(endpoint, port, secure)
  35.                 .credentials(accessKey, secretKey)
  36.                 .build();
  37.         return minioClient;
  38.     }
  39. //
  40. //    @Bean(name = "multipartResolver")
  41. //    public MultipartResolver multipartResolver(){
  42. //        CommonsMultipartResolver resolver = new CommonsMultipartResolver();
  43. //        resolver.setDefaultEncoding("UTF-8");
  44. //        //resolveLazily属性启用是为了推迟文件解析，以在在UploadAction中捕获文件大小异常
  45. //        resolver.setResolveLazily(true);
  46. //        resolver.setMaxInMemorySize(40960);
  47. //        //上传文件大小 50M 50*1024*1024
  48. //        resolver.setMaxUploadSize(50*1024*1024);
  49. //        return resolver;
  50. //    }
  51. }
  52.

如何你要配置ip和port在同一个参数中，不分开，或者是直接配置域名(域名映射了ip和port)，那么配置的yml 修改如下：

 把port注释掉，同时配置类也修改一下就可以了：

 工具类：

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

2.3 创建一个数据表，用于保存上传到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,
  11.   `create_time` datetime DEFAULT NULL,
  12.   `update_by` varchar(25) COLLATE utf8mb4_bin DEFAULT NULL,
  13.   `update_time` datetime DEFAULT NULL,
  14.   PRIMARY KEY (`id`)
  15. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

然后使用idea自动代码生成插件，生成对应的实体类，mapper和service层

2.4 创建minio上传接口

  1. package com.xiaomifeng1010.module.minio.controller;
  2.  
  3. import cn.hutool.core.io.FileUtil;
  4. import com.xiaomifeng1010.base.util.ApiResult;
  5. import com.xiaomifeng1010.module.minio.configuration.MinioConfig;
  6. import com.xiaomifeng1010.module.minio.dto.response.MinioResponseDTO;
  7. import com.xiaomifeng1010.module.minio.entity.MinioFile;
  8. import com.xiaomifeng1010.module.util.MinioClientUtils;
  9. import io.swagger.annotations.Api;
  10. import io.swagger.annotations.ApiImplicitParam;
  11. import io.swagger.annotations.ApiOperation;
  12. import lombok.AllArgsConstructor;
  13. import lombok.extern.slf4j.Slf4j;
  14. import org.apache.commons.collections4.CollectionUtils;
  15. import org.apache.commons.lang3.RandomStringUtils;
  16. import org.apache.commons.lang3.math.NumberUtils;
  17. import org.springframework.stereotype.Controller;
  18. import org.springframework.web.bind.annotation.*;
  19. import org.springframework.web.multipart.MultipartFile;
  20.  
  21. import java.io.FileInputStream;
  22. import java.time.Instant;
  23. import java.util.ArrayList;
  24. import java.util.List;
  25.  
  26. /**
  27.  * @author xiaomifeng1010
  28.  * @version 1.0
  29.  * @Description  minio 文件处理（上传，下载，获取文件地址等）
  30.  */
  31. @Controller
  32. @RequestMapping("/fileHandle")
  33. @Slf4j
  34. @AllArgsConstructor
  35. @Api(tags = "文件处理模块")
  36. public class FileHandleController {
  37.  
  38.     private MinioClientUtils minioClientUtils;
  39.  
  40.     private MinioConfig minioConfig;
  41.  
  42.     @PostMapping(value = {"/admin/uploadFile","/web/uploadFile"})
  43.     @ResponseBody
  44.     @ApiOperation(value = "上传文件,支持批量上传")
  45.     @ApiImplicitParam(name = "files",value = "文件对象",dataType = "File")
  46.     public ApiResult uploadFile(@RequestParam("files") List<MultipartFile> files) {
  47.         log.info(files.toString());
  48.         if (CollectionUtils.isEmpty(files)){
  49.             return ApiResult.error("未选择文件！");
  50.         }
  51.  
  52.         List<MinioResponseDTO> MinioResponseDTOList=new ArrayList<>();
  53.         for (MultipartFile file : files) {
  54.             String originalFilename = file.getOriginalFilename();
  55. //            获取文件拓展名
  56.             String extName = FileUtil.extName(originalFilename);
  57.             log.info("文件拓展名:"+extName);
  58. //            生成新的文件名，存入到minio
  59.             long millSeconds = Instant.now().toEpochMilli();
  60.             String minioFileName=millSeconds+ RandomStringUtils.randomNumeric(12)+"."+extName;
  61.             String contentType = file.getContentType();
  62.             log.info("文件mime:{}",contentType);
  63. //            返回文件大小,单位字节
  64.             long size = file.getSize();
  65.             log.info("文件大小："+size);
  66.             try {
  67.                 String bucketName = minioConfig.getBucketName();
  68.                 minioClientUtils.putObject(bucketName,file,minioFileName);
  69.                 String fileUrl = minioClientUtils.getObjectUrl(bucketName, minioFileName);
  70.                 MinioFile minioFile = new MinioFile();
  71.                 minioFile.setOriginalFileName(originalFilename);
  72.                 minioFile.setFileExtName(extName);
  73.                 minioFile.setFileName(minioFileName);
  74.                 minioFile.setFileSize(size);
  75.                 minioFile.setMime(contentType);
  76.                 minioFile.setIsDelete(NumberUtils.INTEGER_ZERO);
  77.                 minioFile.setFileUrl(fileUrl);
  78.                 boolean insert = minioFile.insert();
  79.                 if (insert) {
  80.                     MinioResponseDTO minioResponseDTO = new MinioResponseDTO();
  81.                     minioResponseDTO.setFileId(minioFile.getId());
  82.                     minioResponseDTO.setOriginalFileName(originalFilename);
  83.                     minioResponseDTO.setFileUrl(fileUrl);
  84.                     MinioResponseDTOList.add(minioResponseDTO);
  85.                 }
  86.  
  87.  
  88.  
  89.             } catch (Exception e) {
  90.                 log.error("上传文件出错:{}",e);
  91.                 return ApiResult.error("上传文件出错");
  92.  
  93.             }
  94.         }
  95.  
  96.         return ApiResult.success(MinioResponseDTOList);
  97.     }
  98.  
  99.  
  100.     /**
  101.      * 仅仅用于测试，是否可以正常上传文件
  102.      * @return
  103.      * @throws Exception
  104.      */
  105.     @GetMapping("/test")
  106.     @ApiOperation(value = "测试minio文件上传")
  107.     public ApiResult testPutObject() throws Exception {
  108.         FileInputStream fileInputStream = new FileInputStream("C:\\Users\\MSI\\Desktop\\新建文本文档.txt");
  109.         boolean bs = minioClientUtils.putObject("xxx-dev", "新建文本文档.txt", fileInputStream, "image/jpg");
  110.         log.info("上传成功?"+bs);
  111.         return ApiResult.success("上传成功");
  112.     }
  113.  
  114.  
  115. }

为了在上传文件后，把问价地址返回给前端，所以封装了一个返回数据对象DTO

  1. package com.xiaomifeng1010.module.minio.dto.response;
  2.  
  3. import lombok.Data;
  4.  
  5. /**
  6.  * @author xiaomifeng1010
  7.  * @version 1.0
  8.  * @Description
  9.  */
  10. @Data
  11. public class MinioResponseDTO {
  12.  
  13.     private  Long fileId;
  14.  
  15.     private String fileUrl;
  16.  
  17.     private String originalFileName;
  18. }

然后启动项目在knife4j文档页面测试，或者在postman中测试

 由于设置了文件上传的最大限制，所以超出100兆，会抛出异MaxUploadSizeExceededException

，所以需要在全局异常处理器中处理

  1. package com.xiaomifeng1010.module.exception.handler;
  2.  
  3. import com.xiaomifeng1010.base.handler.GlobalExceptionHandler;
  4. import com.xiaomifeng1010.base.util.ApiResult;
  5. import com.xiaomifeng1010.base.util.StatusEnum;
  6. import com.xiaomifeng1010.module.exception.EnterpriseBusinessException;
  7. import lombok.extern.slf4j.Slf4j;
  8. import org.apache.commons.lang3.StringUtils;
  9. import org.apache.tomcat.util.http.fileupload.impl.FileSizeLimitExceededException;
  10. import org.springframework.beans.factory.annotation.Value;
  11. import org.springframework.core.Ordered;
  12. import org.springframework.core.annotation.Order;
  13. import org.springframework.http.HttpStatus;
  14. import org.springframework.validation.BindException;
  15. import org.springframework.validation.BindingResult;
  16. import org.springframework.validation.FieldError;
  17. import org.springframework.web.bind.MethodArgumentNotValidException;
  18. import org.springframework.web.bind.annotation.ExceptionHandler;
  19. import org.springframework.web.bind.annotation.RestControllerAdvice;
  20. import org.springframework.web.multipart.MaxUploadSizeExceededException;
  21.  
  22. import javax.validation.ConstraintViolation;
  23. import javax.validation.ConstraintViolationException;
  24. import java.util.stream.Collectors;
  25.  
  26. /**
  27.  * @author xiaomifeng1010
  28.  * @version 1.0
  29.  * @Description 全局异常处理器
  30.  */
  31. @RestControllerAdvice
  32. @Order(value = Ordered.HIGHEST_PRECEDENCE)
  33. @Slf4j
  34. public class BaseExceptionHandler extends GlobalExceptionHandler {
  35.  
  36.     @Value("${spring.servlet.multipart.max-file-size}")
  37.     private String maxFileSize;
  38.  
  39.     @ExceptionHandler(value = MethodArgumentNotValidException.class)
  40.     public ApiResult handleValidException(MethodArgumentNotValidException exception) {
  41.         BindingResult result = exception.getBindingResult();
  42.         String errorMessage = StringUtils.EMPTY;
  43.         if (result.hasErrors()) {
  44.             errorMessage = result.getFieldErrors().stream().map(FieldError::getDefaultMessage).collect(Collectors.joining(","));
  45.             log.error("请求对象[{}]验证错误信息{}", result.getFieldErrors().get(0).getObjectName(), errorMessage);
  46.         }
  47.         return ApiResult.error(HttpStatus.BAD_REQUEST.value(), errorMessage);
  48.     }
  49.  
  50.     @ExceptionHandler(value = BindException.class)
  51.     public ApiResult handleValidException(BindException exception) {
  52.         BindingResult result = exception.getBindingResult();
  53.         String errorMessage = StringUtils.EMPTY;
  54.         if (result.hasErrors()) {
  55.             errorMessage = result.getFieldErrors().stream().map(FieldError::getDefaultMessage).collect(Collectors.joining(","));
  56.             log.error("请求对象[{}]验证错误信息{}", result.getFieldErrors().get(0).getObjectName(), errorMessage);
  57.         }
  58.         return ApiResult.error(HttpStatus.BAD_REQUEST.value(), errorMessage);
  59.     }
  60.  
  61.  
  62.     @ExceptionHandler(value = {MaxUploadSizeExceededException.class})
  63.     public ApiResult handleValidException(MaxUploadSizeExceededException exception) {
  64.         long maxUploadSize = exception.getMaxUploadSize();
  65.         log.error("允许的最大上传字节为:{}",maxUploadSize);
  66.         String errorMessage = "文件大于最大限制"+maxFileSize+",请重新上传";
  67.         log.error(errorMessage);
  68.         return ApiResult.error(HttpStatus.BAD_REQUEST.value(), errorMessage);
  69.     }
  70.  
  71.     @Override
  72.     @ExceptionHandler({ConstraintViolationException.class})
  73.     public ApiResult handleConstraintValidationException(final ConstraintViolationException ex) {
  74.         String errorMessage = ex.getConstraintViolations().stream().map(ConstraintViolation::getMessage).collect(Collectors.joining(","));
  75.         return ApiResult.error(HttpStatus.BAD_REQUEST.value(), errorMessage);
  76.  
  77.     }
  78.  
  79.  
  80.  
  81.     @ExceptionHandler({EnterpriseBusinessException.class})
  82.     public ApiResult handEnterpriseBusinessException(EnterpriseBusinessException e) {
  83.         log.error("当前请求出现业务异常！", e);
  84.         return ApiResult.error(e.getCode(), e.getMessage());
  85.     }
  86.  
  87.  
  88.     @Override
  89.     @ExceptionHandler({Exception.class})
  90.     public ApiResult handleUnknownException(final Exception ex) {
  91.         if (ex instanceof MaxUploadSizeExceededException || ex instanceof FileSizeLimitExceededException) {
  92.             String errorMessage = "文件超出限制，请重新上传";
  93.             return ApiResult.error(errorMessage);
  94.         }
  95.         log.error("==> Error {} detected when request", ex.getMessage(), ex);
  96.         return ApiResult.error(StatusEnum.INTERNAL_SERVER_ERROR);
  97.     }
  98.  
  99.  
  100. }

 接着再postman中上传一个100多兆的sql脚本文件

会提示超出文件最大限制 

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

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

  

闽ICP备14008679号