MinIO之Windos版本安装与SpringBoot集成MinIO简介

亦凉 2022-10-15 00:48 548阅读 0赞

## windows 下安装Minio ##

**1、下载安装包**  
官网地址 [https://min.io/][https_min.io]

github地址：[https://github.com/minio/minio][https_github.com_minio_minio]

windows 服务端下载地址：[ https://dl.minio.io/server/minio/release/windows-amd64/minio.exe][https_dl.minio.io_server_minio_release_windows-amd64_minio.exe]

**2、安装：**  
打开cmd，切换路径到下载好的minio.exe的文件路径下。

此处我是直接放到E盘下面，然后执行如下命令。

.\minio.exe server E:\minio

后面的E:\\minio 是自己指定的文件目录，用来存放数据

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0VzY19UYWJfRW5k_size_16_color_FFFFFF_t_70_pic_center]  
打开上图Endpoint 中的任意一个地址就能访问到页面![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0VzY19UYWJfRW5k_size_16_color_FFFFFF_t_70_pic_center 1]  
使用RootUser和RootPass登录进入。

**3、创建和上传文件**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0VzY19UYWJfRW5k_size_16_color_FFFFFF_t_70_pic_center 2]  
到此，安装的部分就完成了。

## 下面来介绍springboot集成Minio ##

**1、首先我们先引入minio的maven配置：**

<dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>7.1.0</version>
        </dependency>

**2、在配置文件中配置minio的服务地址**

#minIO 地址
    minio:
      endpoint: http://192.168.1.203
      port: 9000
      accessKey: minioadmin
      secretKey: minioadmin
      bucketName: iletter

**3、创建配置类**

import io.minio.MinioClient;
    import io.minio.errors.InvalidEndpointException;
    import io.minio.errors.InvalidPortException;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.stereotype.Component;
    
    @Component
    @ConfigurationProperties(prefix = "minio")
    public class MinioConfig{ 
        private String endpoint;
        private int port;
        private String accessKey;
        private String secretKey;
        private Boolean secure;
        private String bucketName;
        
        @Bean
        public MinioClient getMinioClient() throws InvalidEndpointException, InvalidPortException { 
            MinioClient minioClient = MinioClient.builder().endpoint(endpoint, port, secure)
                            .credentials(accessKey, secretKey)
                            .build();
            return minioClient;
        }
    }

**4、创建API实现代码**

import io.minio.*;
    import io.minio.errors.*;
    import io.minio.http.Method;
    import io.minio.messages.Bucket;
    import io.minio.messages.DeleteError;
    import io.minio.messages.DeleteObject;
    import io.minio.messages.Item;
    import org.apache.commons.lang.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.web.multipart.MultipartFile;
    
    import javax.servlet.ServletOutputStream;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.InputStream;
    import java.nio.charset.StandardCharsets;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.util.*;
    
    /** * @PackageName: com.sdk.minio * @ClassName: MinioClientUtils * @Author Chenxh * @Date 2021/5/22 16:16 * @Description: MinIO 客户端 SDK */
    @Component
    public class MinioClientUtils { 
    
        @Autowired
        private MinioClient minioClient;
    
        private static final int DEFAULT_EXPIRY_TIME = 7 * 24 * 3600;
    
        /** * 检查存储桶是否存在 * * @param bucketName 存储桶名称 * @return */
        public boolean bucketExists(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException { 
            boolean flag = false;
            flag = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            if (flag) { 
                return true;
            }
            return false;
        }
    
        /** * 创建存储桶 * * @param bucketName 存储桶名称 */
        public boolean makeBucket(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, RegionConflictException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException { 
            boolean flag = bucketExists(bucketName);
            if (!flag) { 
                minioClient.makeBucket(
                        MakeBucketArgs.builder()
                                .bucket(bucketName)
                                .build());
                return true;
            } else { 
                return false;
            }
        }
    
        /** * 列出所有存储桶名称 * * @return */
        public List<String> listBucketNames() throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException { 
            List<Bucket> bucketList = listBuckets();
            List<String> bucketListName = new ArrayList<>();
            for (Bucket bucket : bucketList) { 
                bucketListName.add(bucket.name());
            }
            return bucketListName;
        }
    
        /** * 列出所有存储桶 * * @return */
        public List<Bucket> listBuckets() throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException { 
            return minioClient.listBuckets();
        }
    
        /** * 删除存储桶 * * @param bucketName 存储桶名称 * @return */
        public boolean removeBucket(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException { 
            boolean flag = bucketExists(bucketName);
            if (flag) { 
                Iterable<Result<Item>> myObjects = listObjects(bucketName);
                for (Result<Item> result : myObjects) { 
                    Item item = result.get();
                    // 有对象文件，则删除失败
                    if (item.size() > 0) { 
                        return false;
                    }
                }
                // 删除存储桶，注意，只有存储桶为空时才能删除成功。
                minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
                flag = bucketExists(bucketName);
                if (!flag) { 
                    return true;
                }
    
            }
            return false;
        }
    
        /** * 列出存储桶中的所有对象名称 * * @param bucketName 存储桶名称 * @return */
        public List<String> listObjectNames(String bucketName) throws XmlParserException, IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, InvalidBucketNameException, InsufficientDataException, InternalException { 
            List<String> listObjectNames = new ArrayList<>();
            boolean flag = bucketExists(bucketName);
            if (flag) { 
                Iterable<Result<Item>> myObjects = listObjects(bucketName);
                for (Result<Item> result : myObjects) { 
                    Item item = result.get();
                    listObjectNames.add(item.objectName());
                }
            }
            return listObjectNames;
        }
    
        /** * 列出存储桶中的所有对象 * * @param bucketName 存储桶名称 * @return */
        public Iterable<Result<Item>> listObjects(String bucketName) throws XmlParserException, IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, InvalidBucketNameException, InsufficientDataException, InternalException { 
            boolean flag = bucketExists(bucketName);
            if (flag) { 
                return minioClient.listObjects( ListObjectsArgs.builder().bucket(bucketName).build());
            }
            return null;
        }
    
        /** * 通过文件上传到对象 * * @param bucketName 存储桶名称 * @param objectName 存储桶里的对象名称 * @param fileName File name * @return */
        public boolean uploadObject(String bucketName, String objectName, String fileName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException { 
            boolean flag = bucketExists(bucketName);
            if (flag) { 
                minioClient.uploadObject(
                        UploadObjectArgs.builder()
                                .bucket(bucketName).object(objectName).filename(fileName).build());
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) { 
                    return true;
                }
            }
            return false;
    
        }
    
        /** * 文件上传 * * @param bucketName * @param multipartFile */
        public void putObject(String bucketName, MultipartFile multipartFile, String filename) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException { 
            PutObjectOptions putObjectOptions = new PutObjectOptions(multipartFile.getSize(), PutObjectOptions.MIN_MULTIPART_SIZE);
            putObjectOptions.setContentType(multipartFile.getContentType());
            minioClient.putObject(
                    PutObjectArgs.builder().bucket(bucketName).object(filename).stream(
                            multipartFile.getInputStream(), multipartFile.getSize(), -1).contentType(multipartFile.getContentType())
                            .build());
        }
    
        /** * 通过InputStream上传对象 * * @param bucketName 存储桶名称 * @param objectName 存储桶里的对象名称 * @param inputStream 要上传的流 * @param contentType 上传的文件类型 例如 video/mp4 image/jpg * @return */
        public boolean putObject(String bucketName, String objectName, InputStream inputStream,String contentType) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException { 
            boolean flag = bucketExists(bucketName);
            if (flag) { 
                minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(
                        //不清楚文件的大小时，可以传-1，10485760。如果知道大小也可以传入size，partsize。
                        inputStream,  -1, 10485760)
                        .contentType(contentType)
                        .build());
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) { 
                    return true;
                }
            }
            return false;
        }
    
        /** * 以流的形式获取一个文件对象 * * @param bucketName 存储桶名称 * @param objectName 存储桶里的对象名称 * @return */
        public InputStream getObject(String bucketName, String objectName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException { 
            boolean flag = bucketExists(bucketName);
            if (flag) { 
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) { 
                    InputStream stream = minioClient.getObject( GetObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .build());
                    return stream;
                }
            }
            return null;
        }
    
        /** * 以流的形式获取一个文件对象（断点下载） * * @param bucketName 存储桶名称 * @param objectName 存储桶里的对象名称 * @param offset 起始字节的位置 * @param length 要读取的长度 (可选，如果无值则代表读到文件结尾) * @return */
        public InputStream getObject(String bucketName, String objectName, long offset, Long length) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException { 
            boolean flag = bucketExists(bucketName);
            if (flag) { 
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) { 
                    InputStream stream = minioClient.getObject(  GetObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .offset(1024L)
                            .length(4096L)
                            .build());
                    return stream;
                }
            }
            return null;
        }
    
        /** * 下载并将文件保存到本地 * * @param bucketName 存储桶名称 * @param objectName 存储桶里的对象名称 * @param fileName File name * @return */
        public boolean downloadObject(String bucketName, String objectName, String fileName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException { 
            boolean flag = bucketExists(bucketName);
            if (flag) { 
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) { 
                    minioClient.downloadObject(DownloadObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .filename(fileName)
                            .build());
                    return true;
                }
            }
            return false;
        }
    
        /** * 删除一个对象 * * @param bucketName 存储桶名称 * @param objectName 存储桶里的对象名称 */
        public boolean removeObject(String bucketName, String objectName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException { 
            boolean flag = bucketExists(bucketName);
            if (flag) { 
                minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
                return true;
            }
            return false;
        }
    
        /** * 删除指定桶的多个文件对象,返回删除错误的对象列表，全部删除成功，返回空列表 * * @param bucketName 存储桶名称 * @param objectNames 含有要删除的多个object名称的迭代器对象 * @return * eg: * List<DeleteObject> objects = new LinkedList<>(); * objects.add(new DeleteObject("my-objectname1")); * objects.add(new DeleteObject("my-objectname2")); * objects.add(new DeleteObject("my-objectname3")); */
        public List<String> removeObjects(String bucketName, List<DeleteObject> objectNames) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException { 
            List<String> deleteErrorNames = new ArrayList<>();
            boolean flag = bucketExists(bucketName);
            if (flag) { 
                Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(objectNames).build());
                for (Result<DeleteError> result : results) { 
                    DeleteError error = result.get();
                    deleteErrorNames.add(error.objectName());
                }
            }
            return deleteErrorNames;
        }
    
        /** * 生成一个给HTTP GET请求用的presigned URL。 * 浏览器/移动端的客户端可以用这个URL进行下载，即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间，默认值是7天。 * * @param bucketName 存储桶名称 * @param objectName 存储桶里的对象名称 * @param expires 失效时间（以秒为单位），默认是7天，不得大于七天 * @return */
        public String getPresignedObjectUrl(String bucketName, String objectName, Integer expires) throws InvalidExpiresRangeException, IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException { 
            boolean flag = bucketExists(bucketName);
            String url = "";
            if (flag) { 
                if (expires < 1 || expires > DEFAULT_EXPIRY_TIME) { 
                    throw new InvalidExpiresRangeException(expires,
                            "expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
                }
                try { 
                    url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                            .method(Method.GET)
                            .bucket(bucketName)
                            .object(objectName)
                            .expiry(expires)//动态参数
     // .expiry(24 * 60 * 60)//用秒来计算一天时间有效期
    // .expiry(1, TimeUnit.DAYS)//按天传参
    // .expiry(1, TimeUnit.HOURS)//按小时传参数
                            .build());
                } catch (ErrorResponseException e) { 
                    e.printStackTrace();
                } catch (InsufficientDataException e) { 
                    e.printStackTrace();
                } catch (InternalException e) { 
                    e.printStackTrace();
                } catch (InvalidBucketNameException e) { 
                    e.printStackTrace();
                } catch (InvalidExpiresRangeException e) { 
                    e.printStackTrace();
                } catch (InvalidKeyException e) { 
                    e.printStackTrace();
                } catch (InvalidResponseException e) { 
                    e.printStackTrace();
                } catch (IOException e) { 
                    e.printStackTrace();
                } catch (NoSuchAlgorithmException e) { 
                    e.printStackTrace();
                } catch (ServerException e) { 
                    e.printStackTrace();
                } catch (XmlParserException e) { 
                    e.printStackTrace();
                }
            }
            return url;
        }
    
        /** * 生成一个给HTTP PUT请求用的presigned URL。 * 浏览器/移动端的客户端可以用这个URL进行上传，即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间，默认值是7天。 * * @param bucketName 存储桶名称 * @param objectName 存储桶里的对象名称 * @param expires 失效时间（以秒为单位），默认是7天，不得大于七天 * @return */
        public String presignedPutObject(String bucketName, String objectName, Integer expires) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException { 
            boolean flag = bucketExists(bucketName);
            String url = "";
            if (flag) { 
                if (expires < 1 || expires > DEFAULT_EXPIRY_TIME) { 
                    try { 
                        throw new InvalidExpiresRangeException(expires,
                                "expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
                    } catch (InvalidExpiresRangeException e) { 
                        e.printStackTrace();
                    }
                }
                try { 
                    url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                            .method(Method.PUT)
                            .bucket(bucketName)
                            .object(objectName)
                            .expiry(expires)//动态参数
                            // .expiry(24 * 60 * 60)//用秒来计算一天时间有效期
    // .expiry(1, TimeUnit.DAYS)//按天传参
    // .expiry(1, TimeUnit.HOURS)//按小时传参数
                            .build());
                } catch (ErrorResponseException e) { 
                    e.printStackTrace();
                } catch (InsufficientDataException e) { 
                    e.printStackTrace();
                } catch (InternalException e) { 
                    e.printStackTrace();
                } catch (InvalidBucketNameException e) { 
                    e.printStackTrace();
                } catch (InvalidExpiresRangeException e) { 
                    e.printStackTrace();
                } catch (InvalidKeyException e) { 
                    e.printStackTrace();
                } catch (InvalidResponseException e) { 
                    e.printStackTrace();
                } catch (IOException e) { 
                    e.printStackTrace();
                } catch (NoSuchAlgorithmException e) { 
                    e.printStackTrace();
                } catch (ServerException e) { 
                    e.printStackTrace();
                } catch (XmlParserException e) { 
                    e.printStackTrace();
                }
            }
            return url;
        }
    
        /** * 获取对象的元数据 * * @param bucketName 存储桶名称 * @param objectName 存储桶里的对象名称 * @return */
        public ObjectStat statObject(String bucketName, String objectName) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException { 
            boolean flag = bucketExists(bucketName);
            if (flag) { 
                ObjectStat statObject = null;
                try { 
                    statObject = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
                } catch (ErrorResponseException e) { 
                    e.printStackTrace();
                } catch (InsufficientDataException e) { 
                    e.printStackTrace();
                } catch (InternalException e) { 
                    e.printStackTrace();
                } catch (InvalidBucketNameException e) { 
                    e.printStackTrace();
                } catch (InvalidKeyException e) { 
                    e.printStackTrace();
                } catch (InvalidResponseException e) { 
                    e.printStackTrace();
                } catch (IOException e) { 
                    e.printStackTrace();
                } catch (NoSuchAlgorithmException e) { 
                    e.printStackTrace();
                } catch (ServerException e) { 
                    e.printStackTrace();
                } catch (XmlParserException e) { 
                    e.printStackTrace();
                }
                return statObject;
            }
            return null;
        }
    
        /** * 文件访问路径 * * @param bucketName 存储桶名称 * @param objectName 存储桶里的对象名称 * @return */
        public String getObjectUrl(String bucketName, String objectName) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException { 
            boolean flag = bucketExists(bucketName);
            String url = "";
            if (flag) { 
                try { 
                    url = minioClient.getObjectUrl(bucketName, objectName);
                } catch (ErrorResponseException e) { 
                    e.printStackTrace();
                } catch (InsufficientDataException e) { 
                    e.printStackTrace();
                } catch (InternalException e) { 
                    e.printStackTrace();
                } catch (InvalidBucketNameException e) { 
                    e.printStackTrace();
                } catch (InvalidKeyException e) { 
                    e.printStackTrace();
                } catch (InvalidResponseException e) { 
                    e.printStackTrace();
                } catch (IOException e) { 
                    e.printStackTrace();
                } catch (NoSuchAlgorithmException e) { 
                    e.printStackTrace();
                } catch (ServerException e) { 
                    e.printStackTrace();
                } catch (XmlParserException e) { 
                    e.printStackTrace();
                }
            }
            return url;
        }
    
    
    
        public void downloadFile(String bucketName, String fileName, String originalName, HttpServletResponse response) { 
            try { 
    
                InputStream file = minioClient.getObject(GetObjectArgs.builder()
                                                            .bucket(bucketName)
                                                            .object(fileName)
                                                            .build());
                String filename = new String(fileName.getBytes("ISO8859-1"), StandardCharsets.UTF_8);
                if (StringUtils.isNotEmpty(originalName)) { 
                    fileName = originalName;
                }
                response.setHeader("Content-Disposition", "attachment;filename=" + filename);
                ServletOutputStream servletOutputStream = response.getOutputStream();
                int len;
                byte[] buffer = new byte[1024];
                while ((len = file.read(buffer)) > 0) { 
                    servletOutputStream.write(buffer, 0, len);
                }
                servletOutputStream.flush();
                file.close();
                servletOutputStream.close();
            } catch (ErrorResponseException e) { 
                e.printStackTrace();
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    }

**5、测试代码**

@RequestMapping("addfeedback")
        public ModelMap addFeedBack(HttpServletRequest request, HttpServletResponse response){ 
            ModelMap modelMap = new ModelMap();
            byte[] data = null;
            InputStream in = null;
            StringBuilder sb = new StringBuilder();
            String filename = "";
            try { 
                if (request instanceof MultipartHttpServletRequest) { 
                        MultipartHttpServletRequest mr = (MultipartHttpServletRequest) request;
                        Map<String, MultipartFile> map = mr.getFileMap();
                        Set keyset = map.keySet();
                        MultipartFile tmp_MultipartFile = null;
                        Iterator iterable = keyset.iterator();
                        int i = 0;
                        while (iterable.hasNext()) { 
                            filename = "";
                            data = null;
                            Object key = iterable.next();
                            tmp_MultipartFile = map.get(key);
                            if (!ValidUtil.isEmpty(tmp_MultipartFile)) { 
                                in = tmp_MultipartFile.getInputStream();
                                //图片后缀
                                String suffix = tmp_MultipartFile.getOriginalFilename().substring(tmp_MultipartFile.getOriginalFilename().lastIndexOf(".") + 1);
                                //文件名，也是minio中的对象名
                                //这里用请求路径给文件分类文件，再加上用户id+排序号（一次上传多个文件的时候最后有个序号）+时间戳+文件大小+后缀名。
                                filename = "feelback/用户登录id/no"+(i++)+"_time_"+getTimestamp()+"_size_"+tmp_MultipartFile.getSize()+"."+suffix;
                                try { 
                                 //minIO存储 把图片，上传到minIO,
                                    minioClientUtils.putObject(bucketName,filename,in,tmp_MultipartFile.getContentType());
                                } catch (Exception e) { 
                                    e.printStackTrace();
                                    modelMap.put("code","-1");
                                }finally { 
                                    in.close();
                                }
                                //将多张上传到MinIo的文件的对象名拼接
                                sb.append(filename+"||");//多个图片。用竖线拼接
                            }
                        }
                    }
                } catch (IOException e) { 
                    e.printStackTrace();
                }finally { 
                    if(in != null){ 
                        try { 
                            in.close();
                        } catch (IOException e) { 
                            e.printStackTrace();
                        }
                    }
                }
    
    
    
            if(!StringUtils.isNotEmpty(sb)){ 
                Map map = new HashMap();
                map .put("images",sb.toString());
                //这里就用service类来做写入库表操作，这里的Map是为了便于阅读，正常情况下，是要传入业务数据的，只是在此处蒋图片的路径保存到images字段中。
                indexService.addfeedback(map);
                modelMap.put("code","1");
            }
            return modelMap;
        }

**6、效果展示**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0VzY19UYWJfRW5k_size_16_color_FFFFFF_t_70_pic_center 3]  
上传的图片，就上传到了iletter桶下 feelback对象中，该对象的路径是如图，包含了用户id，序号，时间错，大小。这是我个人的命名规则。

**7、权限问题：**  
MinIo中图片可以分享，但是分享时间不超过7天，如果想要图片链接永久可以访问，那么要设置该路径的所有文件都有读权限。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0VzY19UYWJfRW5k_size_16_color_FFFFFF_t_70_pic_center 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0VzY19UYWJfRW5k_size_16_color_FFFFFF_t_70_pic_center 5]

设置了feeldback/ 前缀开头的所有路径都有读取权限后，就可以通过图片的路径链接直接访问图片了。  
访问链接格式：ip:port/bucketName/objectName 不包含minio这一段。  
例如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0VzY19UYWJfRW5k_size_16_color_FFFFFF_t_70_pic_center 6]

到此，简单入门的springboot集成MinIO就完成了，后续的正删改查的接口，就不用一一演示了。

## 有用请点赞 ##

[https_min.io]: https://min.io/
[https_github.com_minio_minio]: https://github.com/minio/minio
[https_dl.minio.io_server_minio_release_windows-amd64_minio.exe]: https://dl.minio.io/server/minio/release/windows-amd64/minio.exe
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0VzY19UYWJfRW5k_size_16_color_FFFFFF_t_70_pic_center]: /images/20221014/34e3b1943d4f4112859733453189929d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0VzY19UYWJfRW5k_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221014/1a7b864190fa412dab430a71419407c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0VzY19UYWJfRW5k_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221014/6f4ef5c592ca46dbbb722cb22ca86bd5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0VzY19UYWJfRW5k_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221014/36b14640150540c19bbbbc533f1d0ce1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0VzY19UYWJfRW5k_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221014/7599715c93a94de98cca60fabe837544.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0VzY19UYWJfRW5k_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221014/d5e7470a41964c8486ecee8f8f477622.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0VzY19UYWJfRW5k_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221014/0d6436c9463d43668211753d7d6406ae.png