一、创建springboot，引入minio依赖：

    1. <dependency>
    2.     <groupId>io.minio</groupId>
    3.     <artifactId>minio</artifactId>
    4.     <version>7.0.2</version>
    5. </dependency>

    其它的依赖看自己需求引入

    二、创建包结构
    1.png
    三、修改配置文件

    1. min.io.endpoint = http://xx.xx.xx.xx:9000
    2. min.io.accessKey = username
    3. min.io.secretKey = password

    四、编写配置类

    1. package com.zym.minio.config;
    3. import io.minio.MinioClient;
    4. import io.minio.errors.InvalidEndpointException;
    5. import io.minio.errors.InvalidPortException;
    6. import lombok.Data;
    7. import org.springframework.boot.context.properties.ConfigurationProperties;
    8. import org.springframework.context.annotation.Bean;
    9. import org.springframework.stereotype.Component;
    11. @Data
    12. @Component
    13. @ConfigurationProperties(prefix = "min.io")
    14. public class MinIoConfig {
    15.     private String endpoint;
    16.     private String accessKey;
    17.     private String secretKey;
    19.     @Bean
    20.     public MinioClient getMinioClient() throws InvalidPortException, InvalidEndpointException {
    21.         MinioClient client = new MinioClient(endpoint,accessKey,secretKey);
    22.         return client;
    23.     }
    24. }

    五、编写测试方法

    controller:

    1. package com.zym.minio.controller;
    3. import com.zym.minio.common.result.Result;
    4. import com.zym.minio.common.result.ResultUtil;
    5. import com.zym.minio.config.MinIoConfig;
    6. import com.zym.minio.service.MinioService;
    7. import io.swagger.annotations.Api;
    8. import io.swagger.annotations.ApiOperation;
    9. import org.apache.commons.lang3.StringUtils;
    10. import org.springframework.beans.factory.annotation.Autowired;
    11. import org.springframework.web.bind.annotation.PostMapping;
    12. import org.springframework.web.bind.annotation.RequestMapping;
    13. import org.springframework.web.bind.annotation.RestController;
    14. import org.springframework.web.multipart.MultipartFile;
    16. import javax.servlet.http.HttpServletResponse;
    17. import java.text.SimpleDateFormat;
    18. import java.util.Date;
    19. import java.util.UUID;
    21. @RequestMapping("/minio")
    22. @RestController
    23. @Api(tags = "文件操作接口")
    24. public class MinioController {
    26.     @Autowired
    27.     private MinioService minioService;
    29.     @ApiOperation(value = "使用minio文件上传")
    30.     @PostMapping("/uploadFile")
    31.     public Result uploadFile(MultipartFile file, String bucketName) {
    32.         try {
    33.             if (StringUtils.isBlank(bucketName)){
    34.                 return ResultUtil.sendErrorMessage("桶名称不能为空");
    35.             }
    36.             if (!minioService.bucketExists(bucketName)) {
    37.                 minioService.makeBucket(bucketName);
    38.             }
    39.             String fileName = file.getOriginalFilename();
    40.             String objectName = new SimpleDateFormat("yyyy-MM-dd/").format(new Date()) + UUID.randomUUID().toString().replaceAll("-", "")
    41.                     + fileName.substring(fileName.lastIndexOf("."));
    42.             minioService.putObject(bucketName, file, objectName);
    43.             System.out.println("文件格式为:"+file.getContentType());
    44.             System.out.println("文件原名称为:"+fileName);
    45.             System.out.println("文件存储的桶为:"+bucketName);
    46.             System.out.println("文件对象路径为:"+objectName);
    47.             return ResultUtil.success(minioService.getObjectUrl(bucketName, objectName));
    48.         } catch (Exception e) {
    49.             e.printStackTrace();
    50.             return ResultUtil.sendErrorMessage("上传失败");
    51.         }
    52.     }
    54.     @ApiOperation(value = "使用minio文件删除")
    55.     @PostMapping("/deleteFile")
    56.     public Result deleteFile(String bucketName,String filePath) throws Exception {
    57.         if (!minioService.bucketExists(bucketName)){
    58.             throw new Exception("不存在该桶");
    59.         }
    60.         boolean flag = minioService.removeObject(bucketName, filePath);
    61.         if (flag){
    62.             return ResultUtil.sendSuccessMessage("删除成功");
    63.         }else{
    64.             return ResultUtil.sendErrorMessage("删除失败");
    65.         }
    66.     }
    68.     @ApiOperation(value = "使用minio文件下载")
    69.     @PostMapping("/downloadFile")
    70.     public Result downloadFile(String bucketName, String filePath, String originalName, HttpServletResponse response) throws Exception {
    71.         if (!minioService.bucketExists(bucketName)){
    72.             throw new Exception("不存在该桶");
    73.         }
    74.         minioService.downloadFile(bucketName, filePath, originalName, response);
    75.         return ResultUtil.sendSuccessMessage("下载成功");
    76.     }
    77. }

    service:

    1. package com.zym.minio.service;
    3. import org.springframework.web.multipart.MultipartFile;
    5. import javax.servlet.http.HttpServletResponse;
    6. import java.io.InputStream;
    8. public interface MinioService {
    9.     /**
    10.      * 判断 bucket是否存在
    11.      *
    12.      * @param bucketName
    13.      * @return
    14.      */
    15.     boolean bucketExists(String bucketName);
    17.     /**
    18.      * 创建 bucket
    19.      *
    20.      * @param bucketName
    21.      */
    22.     void makeBucket(String bucketName);
    24.     /**
    25.      * 文件上传
    26.      *
    27.      * @param bucketName
    28.      * @param objectName
    29.      * @param filename
    30.      */
    31.     void putObject(String bucketName, String objectName, String filename);
    33.     /**
    34.      * 文件上传
    35.      *
    36.      * @param bucketName
    37.      * @param objectName
    38.      * @param stream
    39.      */
    40.     void putObject(String bucketName, String objectName, InputStream stream, String contentType);
    42.     /**
    43.      * 文件上传
    44.      *
    45.      * @param bucketName
    46.      * @param multipartFile
    47.      */
    48.     void putObject(String bucketName, MultipartFile multipartFile, String filename);
    50.     /**
    51.      * 删除文件
    52.      * @param bucketName
    53.      * @param filePath
    54.      */
    55.     boolean removeObject(String bucketName,String filePath);
    57.     /**
    58.      * 下载文件
    59.      *
    60.      * @param filePath
    61.      * @param originalName
    62.      * @param response
    63.      */
    64.     void downloadFile(String bucketName, String filePath, String originalName, HttpServletResponse response);
    66.     /**
    67.      * 获取文件路径
    68.      * @param bucketName
    69.      * @param objectName
    70.      * @return
    71.      */
    72.     String getObjectUrl(String bucketName,String objectName);
    74.     /**
    75.      * 以流形式获取文件
    76.      * @param bucketName
    77.      * @param objectName
    78.      * @param offset
    79.      * @return
    80.      */
    81.     InputStream getObject(String bucketName,String objectName,long offset);
    82. }

    impl:

    1. package com.zym.minio.service.impl;
    3. import com.zym.minio.service.MinioService;
    4. import com.zym.minio.util.MinIoUtils;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.stereotype.Service;
    7. import org.springframework.web.multipart.MultipartFile;
    9. import javax.servlet.http.HttpServletResponse;
    10. import java.io.InputStream;
    12. @Service
    13. public class MinioServiceImpl implements MinioService {
    15.     @Autowired
    16.     private MinIoUtils minIoUtils;
    18.     /**
    19.      * 判断 bucket是否存在
    20.      *
    21.      * @param bucketName
    22.      * @return
    23.      */
    24.     @Override
    25.     public boolean bucketExists(String bucketName) {
    26.         return minIoUtils.bucketExists(bucketName);
    27.     }
    29.     /**
    30.      * 创建 bucket
    31.      *
    32.      * @param bucketName
    33.      */
    34.     @Override
    35.     public void makeBucket(String bucketName) {
    36.         minIoUtils.makeBucket(bucketName);
    37.     }
    39.     /**
    40.      * 文件上传
    41.      *
    42.      * @param bucketName
    43.      * @param objectName
    44.      * @param filename
    45.      */
    46.     @Override
    47.     public void putObject(String bucketName, String objectName, String filename) {
    48.         minIoUtils.putObject(bucketName, objectName, filename);
    49.     }
    52.     @Override
    53.     public void putObject(String bucketName, String objectName, InputStream stream, String contentType) {
    54.         minIoUtils.putObject(bucketName, objectName, stream, contentType);
    55.     }
    57.     /**
    58.      * 文件上传
    59.      *
    60.      * @param bucketName
    61.      * @param multipartFile
    62.      */
    63.     @Override
    64.     public void putObject(String bucketName, MultipartFile multipartFile, String filename) {
    65.         minIoUtils.putObject(bucketName, multipartFile, filename);
    66.     }
    68.     /**
    69.      * 删除文件
    70.      * @param bucketName
    71.      * @param filePath
    72.      */
    73.     @Override
    74.     public boolean removeObject(String bucketName,String filePath) {
    75.         return minIoUtils.removeObject(bucketName,filePath);
    76.     }
    78.     /**
    79.      * 下载文件
    80.      *
    81.      * @param filePath
    82.      * @param originalName
    83.      * @param response
    84.      */
    85.     @Override
    86.     public void downloadFile(String bucketName, String filePath, String originalName, HttpServletResponse response) {
    87.         minIoUtils.downloadFile(bucketName,filePath, originalName, response);
    88.     }
    90.     /**
    91.      * 获取文件路径
    92.      * @param bucketName
    93.      * @param objectName
    94.      * @return
    95.      */
    96.     @Override
    97.     public String getObjectUrl(String bucketName,String objectName) {
    98.         return minIoUtils.getObjectUrl(bucketName,objectName);
    99.     }
    100. }

    minioutils:

    1. package com.zym.minio.util;
    3. import io.minio.MinioClient;
    4. import io.minio.ObjectStat;
    5. import io.minio.PutObjectOptions;
    6. import io.minio.Result;
    7. import io.minio.errors.ErrorResponseException;
    8. import io.minio.errors.InvalidExpiresRangeException;
    9. import io.minio.messages.Bucket;
    10. import io.minio.messages.DeleteError;
    11. import io.minio.messages.Item;
    12. import lombok.SneakyThrows;
    13. import org.apache.commons.lang3.StringUtils;
    14. import org.springframework.beans.factory.annotation.Autowired;
    15. import org.springframework.stereotype.Component;
    16. import org.springframework.web.multipart.MultipartFile;
    18. import javax.servlet.ServletOutputStream;
    19. import javax.servlet.http.HttpServletResponse;
    20. import java.io.InputStream;
    21. import java.net.URLEncoder;
    22. import java.nio.charset.StandardCharsets;
    23. import java.util.ArrayList;
    24. import java.util.List;
    26. @Component
    27. public class MinIoUtils {
    29.     @Autowired
    30.     private MinioClient minioClient;
    32.     private static final int DEFAULT_EXPIRY_TIME = 7 * 24 * 3600;
    33.     /**
    34.      * 检查存储桶是否存在
    35.      *
    36.      * @param bucketName 存储桶名称
    37.      * @return
    38.      */
    39.     @SneakyThrows
    40.     public boolean bucketExists(String bucketName) {
    41.         boolean flag = false;
    42.         flag = minioClient.bucketExists(bucketName);
    43.         if (flag) {
    44.             return true;
    45.         }
    46.         return false;
    47.     }
    49.     /**
    50.      * 创建存储桶
    51.      *
    52.      * @param bucketName 存储桶名称
    53.      */
    54.     @SneakyThrows
    55.     public boolean makeBucket(String bucketName) {
    56.         boolean flag = bucketExists(bucketName);
    57.         if (!flag) {
    58.             minioClient.makeBucket(bucketName);
    59.             return true;
    60.         } else {
    61.             return false;
    62.         }
    63.     }
    65.     /**
    66.      * 列出所有存储桶名称
    67.      *
    68.      * @return
    69.      */
    70.     @SneakyThrows
    71.     public List<String> listBucketNames() {
    72.         List<Bucket> bucketList = listBuckets();
    73.         List<String> bucketListName = new ArrayList<>();
    74.         for (Bucket bucket : bucketList) {
    75.             bucketListName.add(bucket.name());
    76.         }
    77.         return bucketListName;
    78.     }
    80.     /**
    81.      * 列出所有存储桶
    82.      *
    83.      * @return
    84.      */
    85.     @SneakyThrows
    86.     public List<Bucket> listBuckets() {
    87.         return minioClient.listBuckets();
    88.     }
    90.     /**
    91.      * 删除存储桶
    92.      *
    93.      * @param bucketName 存储桶名称
    94.      * @return
    95.      */
    96.     @SneakyThrows
    97.     public boolean removeBucket(String bucketName) {
    98.         boolean flag = bucketExists(bucketName);
    99.         if (flag) {
    100.             Iterable<Result<Item>> myObjects = listObjects(bucketName);
    101.             for (Result<Item> result : myObjects) {
    102.                 Item item = result.get();
    103.                 // 有对象文件，则删除失败
    104.                 if (item.size() > 0) {
    105.                     return false;
    106.                 }
    107.             }
    108.             // 删除存储桶，注意，只有存储桶为空时才能删除成功。
    109.             minioClient.removeBucket(bucketName);
    110.             flag = bucketExists(bucketName);
    111.             if (!flag) {
    112.                 return true;
    113.             }
    115.         }
    116.         return false;
    117.     }
    119.     /**
    120.      * 列出存储桶中的所有对象名称
    121.      *
    122.      * @param bucketName 存储桶名称
    123.      * @return
    124.      */
    125.     @SneakyThrows
    126.     public List<String> listObjectNames(String bucketName) {
    127.         List<String> listObjectNames = new ArrayList<>();
    128.         boolean flag = bucketExists(bucketName);
    129.         if (flag) {
    130.             Iterable<Result<Item>> myObjects = listObjects(bucketName);
    131.             for (Result<Item> result : myObjects) {
    132.                 Item item = result.get();
    133.                 listObjectNames.add(item.objectName());
    134.             }
    135.         }
    136.         return listObjectNames;
    137.     }
    139.     /**
    140.      * 列出存储桶中的所有对象
    141.      *
    142.      * @param bucketName 存储桶名称
    143.      * @return
    144.      */
    145.     @SneakyThrows
    146.     public Iterable<Result<Item>> listObjects(String bucketName) {
    147.         boolean flag = bucketExists(bucketName);
    148.         if (flag) {
    149.             return minioClient.listObjects(bucketName);
    150.         }
    151.         return null;
    152.     }
    154.     /**
    155.      * 通过文件上传到对象
    156.      *
    157.      * @param bucketName 存储桶名称
    158.      * @param objectName 存储桶里的对象名称
    159.      * @param fileName   File name
    160.      * @return
    161.      */
    162.     @SneakyThrows
    163.     public boolean putObject(String bucketName, String objectName, String fileName) {
    164.         boolean flag = bucketExists(bucketName);
    165.         if (flag) {
    166.             minioClient.putObject(bucketName, objectName, fileName, null);
    167.             ObjectStat statObject = statObject(bucketName, objectName);
    168.             if (statObject != null && statObject.length() > 0) {
    169.                 return true;
    170.             }
    171.         }
    172.         return false;
    174.     }
    176.     /**
    177.      * 文件上传
    178.      *
    179.      * @param bucketName
    180.      * @param multipartFile
    181.      */
    182.     @SneakyThrows
    183.     public void putObject(String bucketName, MultipartFile multipartFile, String filename) {
    184.         PutObjectOptions putObjectOptions = new PutObjectOptions(multipartFile.getSize(), PutObjectOptions.MIN_MULTIPART_SIZE);
    185.         putObjectOptions.setContentType(multipartFile.getContentType());
    186.         minioClient.putObject(bucketName, filename, multipartFile.getInputStream(), putObjectOptions);
    187.     }
    190.     /**
    191.      * 通过InputStream上传对象
    192.      *
    193.      * @param bucketName 存储桶名称
    194.      * @param objectName 存储桶里的对象名称
    195.      * @param stream     要上传的流
    196.      * @param stream     要上传的文件类型 MimeTypeUtils.IMAGE_JPEG_VALUE
    197.      * @return
    198.      */
    199.     @SneakyThrows
    200.     public boolean putObject(String bucketName, String objectName, InputStream stream,String contentType) {
    201.         boolean flag = bucketExists(bucketName);
    202.         if (flag) {
    203.             PutObjectOptions putObjectOptions = new PutObjectOptions(stream.available(), -1);
    204.             /**
    205.              * 开启公共类功能设置setContentType
    206.              */
    207.             if (StringUtils.isNotBlank(contentType)) {
    208.                 putObjectOptions.setContentType(contentType);
    209.             }
    210.             minioClient.putObject(bucketName, objectName, stream, putObjectOptions);
    211.             ObjectStat statObject = statObject(bucketName, objectName);
    212.             if (statObject != null && statObject.length() > 0) {
    213.                 return true;
    214.             }
    215.         }
    216.         return false;
    217.     }
    219.     /**
    220.      * 以流的形式获取一个文件对象
    221.      *
    222.      * @param bucketName 存储桶名称
    223.      * @param objectName 存储桶里的对象名称
    224.      * @return
    225.      */
    226.     @SneakyThrows
    227.     public InputStream getObject(String bucketName, String objectName) {
    228.         boolean flag = bucketExists(bucketName);
    229.         if (flag) {
    230.             ObjectStat statObject = statObject(bucketName, objectName);
    231.             if (statObject != null && statObject.length() > 0) {
    232.                 InputStream stream = minioClient.getObject(bucketName, objectName);
    233.                 return stream;
    234.             }
    235.         }
    236.         return null;
    237.     }
    239.     /**
    240.      * 以流的形式获取一个文件对象（断点下载）
    241.      *
    242.      * @param bucketName 存储桶名称
    243.      * @param objectName 存储桶里的对象名称
    244.      * @param offset     起始字节的位置
    245.      * @param length     要读取的长度 (可选，如果无值则代表读到文件结尾)
    246.      * @return
    247.      */
    248.     @SneakyThrows
    249.     public InputStream getObject(String bucketName, String objectName, long offset, Long length) {
    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(bucketName, objectName, offset, length);
    255.                 return stream;
    256.             }
    257.         }
    258.         return null;
    259.     }
    261.     /**
    262.      * 下载并将文件保存到本地
    263.      *
    264.      * @param bucketName 存储桶名称
    265.      * @param objectName 存储桶里的对象名称
    266.      * @param fileName   File name
    267.      * @return
    268.      */
    269.     @SneakyThrows
    270.     public boolean getObject(String bucketName, String objectName, String fileName) {
    271.         boolean flag = bucketExists(bucketName);
    272.         if (flag) {
    273.             ObjectStat statObject = statObject(bucketName, objectName);
    274.             if (statObject != null && statObject.length() > 0) {
    275.                 minioClient.getObject(bucketName, objectName, fileName);
    276.                 return true;
    277.             }
    278.         }
    279.         return false;
    280.     }
    282.     /**
    283.      * 删除一个对象
    284.      *
    285.      * @param bucketName 存储桶名称
    286.      * @param objectName 存储桶里的对象名称
    287.      */
    288.     @SneakyThrows
    289.     public boolean removeObject(String bucketName, String objectName) {
    290.         boolean flag = bucketExists(bucketName);
    291.         if (flag) {
    292.             minioClient.removeObject(bucketName, objectName);
    293.             return true;
    294.         }
    295.         return false;
    296.     }
    298.     /**
    299.      * 删除指定桶的多个文件对象,返回删除错误的对象列表，全部删除成功，返回空列表
    300.      *
    301.      * @param bucketName  存储桶名称
    302.      * @param objectNames 含有要删除的多个object名称的迭代器对象
    303.      * @return
    304.      */
    305.     @SneakyThrows
    306.     public List<String> removeObject(String bucketName, List<String> objectNames) {
    307.         List<String> deleteErrorNames = new ArrayList<>();
    308.         boolean flag = bucketExists(bucketName);
    309.         if (flag) {
    310.             Iterable<Result<DeleteError>> results = minioClient.removeObjects(bucketName, objectNames);
    311.             for (Result<DeleteError> result : results) {
    312.                 DeleteError error = result.get();
    313.                 deleteErrorNames.add(error.objectName());
    314.             }
    315.         }
    316.         return deleteErrorNames;
    317.     }
    319.     /**
    320.      * 生成一个给HTTP GET请求用的presigned URL。
    321.      * 浏览器/移动端的客户端可以用这个URL进行下载，即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间，默认值是7天。
    322.      *
    323.      * @param bucketName 存储桶名称
    324.      * @param objectName 存储桶里的对象名称
    325.      * @param expires    失效时间（以秒为单位），默认是7天，不得大于七天
    326.      * @return
    327.      */
    328.     @SneakyThrows
    329.     public String presignedGetObject(String bucketName, String objectName, Integer expires) {
    330.         boolean flag = bucketExists(bucketName);
    331.         String url = "";
    332.         if (flag) {
    333.             if (expires < 1 || expires > DEFAULT_EXPIRY_TIME) {
    334.                 throw new InvalidExpiresRangeException(expires,
    335.                         "expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
    336.             }
    337.             url = minioClient.presignedGetObject(bucketName, objectName, expires);
    338.         }
    339.         return url;
    340.     }
    342.     /**
    343.      * 生成一个给HTTP PUT请求用的presigned URL。
    344.      * 浏览器/移动端的客户端可以用这个URL进行上传，即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间，默认值是7天。
    345.      *
    346.      * @param bucketName 存储桶名称
    347.      * @param objectName 存储桶里的对象名称
    348.      * @param expires    失效时间（以秒为单位），默认是7天，不得大于七天
    349.      * @return
    350.      */
    351.     @SneakyThrows
    352.     public String presignedPutObject(String bucketName, String objectName, Integer expires) {
    353.         boolean flag = bucketExists(bucketName);
    354.         String url = "";
    355.         if (flag) {
    356.             if (expires < 1 || expires > DEFAULT_EXPIRY_TIME) {
    357.                 throw new InvalidExpiresRangeException(expires,
    358.                         "expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
    359.             }
    360.             url = minioClient.presignedPutObject(bucketName, objectName, expires);
    361.         }
    362.         return url;
    363.     }
    365.     /**
    366.      * 获取对象的元数据
    367.      *
    368.      * @param bucketName 存储桶名称
    369.      * @param objectName 存储桶里的对象名称
    370.      * @return
    371.      */
    372.     @SneakyThrows
    373.     public ObjectStat statObject(String bucketName, String objectName) {
    374.         boolean flag = bucketExists(bucketName);
    375.         if (flag) {
    376.             ObjectStat statObject = minioClient.statObject(bucketName, objectName);
    377.             return statObject;
    378.         }
    379.         return null;
    380.     }
    382.     /**
    383.      * 文件访问路径
    384.      *
    385.      * @param bucketName 存储桶名称
    386.      * @param objectName 存储桶里的对象名称
    387.      * @return
    388.      */
    389.     @SneakyThrows
    390.     public String getObjectUrl(String bucketName, String objectName) {
    391.         boolean flag = bucketExists(bucketName);
    392.         String url = "";
    393.         if (flag) {
    394.             url = minioClient.getObjectUrl(bucketName, objectName);
    395.         }
    396.         return url;
    397.     }
    399.     public void downloadFile(String bucketName, String filePath, String originalName, HttpServletResponse response) {
    400.         try {
    402.             InputStream file = minioClient.getObject(bucketName, filePath);
    403.             if (StringUtils.isNotEmpty(originalName)) {
    404.                 response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(originalName,"UTF-8"));
    405.             }else{
    406.                 String filename = new String(filePath.getBytes("ISO8859-1"), StandardCharsets.UTF_8);
    407.                 response.setHeader("Content-Disposition", "attachment;filename=" + filename);
    408.             }
    409.             ServletOutputStream servletOutputStream = response.getOutputStream();
    410.             int len;
    411.             byte[] buffer = new byte[1024];
    412.             while ((len = file.read(buffer)) > 0) {
    413.                 servletOutputStream.write(buffer, 0, len);
    414.             }
    415.             servletOutputStream.flush();
    416.             file.close();
    417.             servletOutputStream.close();
    418.         } catch (ErrorResponseException e) {
    419.             e.printStackTrace();
    420.         } catch (Exception e) {
    421.             e.printStackTrace();
    422.         }
    423.     }
    424. }

    源码地址：https://gitee.com/zym213/springboot-minio.git
    下一篇说一下如何用nginx做minio的负载均衡