springboot整合Minio(十一)-搭建自己的OSS(云存储服务)

青旅半醒 2023-10-07 15:46 13阅读 0赞

## MinIO是什么 ##

MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。  
MinIO是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL。

1.MinIO是高性能对象存储的先驱  
MinIO是世界上速度最快的对象存储服务器。在标准硬件上，对象存储的读/写速度分别为183 GB/s和171 GB/s，可以作为一组不同工作负载的主存储层，这些工作负载包括Spark、Presto、TensorFlow、H2O.ai以及Hadoop HDFS的替代品。

2.建立在web规模的规则之上  
MinIO利用了web定标器来之不易的知识，为对象存储带来了一个简单的定标器模型。在MinIO，扩展从一个集群开始，这个集群可以与其他MinIO集群联合以创建一个全局命名空间，如果需要，可以跨越多个数据中心。这也是《财富》500强中超过一半的人使用MinIO的原因之一。

3.为云而生  
MinIO是在过去四年中从头开始构建的，是定义云的技术和架构的原生版本。其中包括集装箱化、与Kubernetes的协调、微服务和多租户。没有比Kubernetes更友好的对象存储了。

4.排名第一的开源对象存储服务，对企业友好  
MinIO在Apache V2许可和Affero通用公共许可版本3（AGPLv3）下是100%开源的。这意味着MinIO的客户可以自由锁定、自由检查、自由创新、自由修改和自由重新分配。其部署的多样性使该软件变得更加强大，这是专有软件永远无法提供的。

5.亚马逊S3兼容性的事实标准  
Amazon的S3 API是对象存储领域的事实标准。MinIO是S3兼容性的事实上的标准，是第一个采用API和第一个添加对S3 Select支持的标准之一。包括微软Azure在内的750多家公司使用MinIO的S3网关，这一数字超过了业内其他公司的总和。

6.Simplicity 简单并且功能非常强大  
极简主义是MinIO的一个指导性设计原则。简单性减少了错误的机会，提高了正常运行时间，提供了可靠性，同时也为性能奠定了基础。MinIO可以在几分钟内安装和配置。配置选项和变量的数量保持在最低限度，这将导致几乎为零的系统管理任务和更少的故障路径。

MinIO官网链接: [https://docs.minio.io/docs/minio-quickstart-guide.html][https_docs.minio.io_docs_minio-quickstart-guide.html].  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70]

## windows安装MinIO ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 1]  
这里使用MinIO镜像下载: [http://dl.minio.org.cn/server/minio/release/windows-amd64/][http_dl.minio.org.cn_server_minio_release_windows-amd64].  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 2]

### 在 minio.exe 所在文件夹 cmd打开命令窗口 ![在这里插入图片描述][20210303135644654.png] ###

### 输入 minio.exe server D:\\minio\\bucket ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 3]

### 启动成功后可以通过 127.0.0.1:9000 来访问 ###

默认用户名和密码 是 minioadmin/minioadmin

### 设置桶bucket的访问权限 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 5]

## springboot整合Minio ##

### pom.xml依赖 ###

<dependencies>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
            </dependency>
            <dependency>
                <groupId>commons-fileupload</groupId>
                <artifactId>commons-fileupload</artifactId>
                <version>1.3.1</version>
            </dependency>
            
            <dependency>
                <groupId>net.coobird</groupId>
                <artifactId>thumbnailator</artifactId>
                <version>0.4.8</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.12</version>
            </dependency>
    
            <dependency>
                <groupId>io.minio</groupId>
                <artifactId>minio</artifactId>
                <version>7.0.2</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
                <optional>true</optional>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
    
        </dependencies>

### application.yml配置 ###

server:
      port: 9100
    
    min:
      io:
        endpoint: http://127.0.0.1:9000
        accessKey: minioadmin
        secretKey: minioadmin
    
    spring:
      servlet:
        multipart:
          max-file-size: 5MB
          max-request-size: 15MB

### 核心代码 ###

import io.minio.MinioClient;
    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.stereotype.Component;
    
    @Data
    @Component
    @ConfigurationProperties(prefix = "min.io")
    public class MinIoProperties {
        
    
        /**
         * Minio 服务端ip
         */
        private String endpoint;
    
        private String accessKey;
    
        private String secretKey;
    
        @Bean
        public MinioClient getMinioClient() {
        
            return MinioClient.builder()
                    .endpoint(endpoint).credentials(accessKey, secretKey).build();
        }
    
    }

import com.wkr.oss.config.MinIoProperties;
    import com.wkr.oss.dto.MinIoUploadResDTO;
    import io.minio.*;
    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 lombok.SneakyThrows;
    import org.apache.tomcat.util.http.fileupload.IOUtils;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.multipart.MultipartFile;
    
    import javax.annotation.Resource;
    import javax.servlet.http.HttpServletResponse;
    import java.io.ByteArrayInputStream;
    import java.io.InputStream;
    import java.util.*;
    
    
    @Configuration
    @EnableConfigurationProperties({
        MinIoProperties.class})
    public class MinIoUtils {
        
    
        @Resource
        private MinioClient instance;
    
        private static final String SEPARATOR_DOT = ".";
    
        private static final String SEPARATOR_ACROSS = "-";
    
        private static final String SEPARATOR_STR = "";
    
        // 存储桶名称
        private static final String chunkBucKet = "miniobucket";
    
        /**
         * 不排序
         */
        public final static boolean NOT_SORT = false;
    
        /**
         * 排序
         */
        public final static boolean SORT = true;
    
        /**
         * 默认过期时间(分钟)
         */
        private final static Integer DEFAULT_EXPIRY = 60;
    
        /**
         * 删除分片
         */
        public final static boolean DELETE_CHUNK_OBJECT = true;
        /**
         * 不删除分片
         */
        public final static boolean NOT_DELETE_CHUNK_OBJECT = false;
    
        /**
         * @param bucketName
         * @return boolean
         * @Description 判断 bucket是否存在
         * @author exe.wangtaotao
         * @date 2020/10/21 16:33
         */
        public boolean bucketExists(String bucketName) {
        
            try {
        
                return instance.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            return false;
        }
    
    
        /**
         * 创建存储桶
         * 创建 bucket
         *
         * @param bucketName
         */
        public void makeBucket(String bucketName) {
        
            try {
        
                boolean isExist = bucketExists(bucketName);
                if (!isExist) {
        
                    instance.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    
        /**
         * @param
         * @return java.util.List<java.lang.String>
         * @Description 获取文件存储服务的所有存储桶名称
         * @author exe.wangtaotao
         * @date 2020/10/21 16:35
         */
        public List<String> listBucketNames() {
        
            List<Bucket> bucketList = listBuckets();
            List<String> bucketListName = new ArrayList<>();
            for (Bucket bucket : bucketList) {
        
                bucketListName.add(bucket.name());
            }
            return bucketListName;
        }
    
        /**
         * @return java.util.List<io.minio.messages.Bucket>
         * @Description 列出所有存储桶
         */
        @SneakyThrows
        private List<Bucket> listBuckets() {
        
            return instance.listBuckets();
        }
    
    
        /**
         * 获取对象文件名称列表
         *
         * @param bucketName 存储桶名称
         * @param prefix     对象名称前缀(文件夹 /xx/xx/xxx.jpg 中的 /xx/xx/)
         * @return objectNames
         */
        public List<String> listObjectNames(String bucketName, String prefix) {
        
            return listObjectNames(bucketName, prefix, NOT_SORT);
        }
    
    
        /**
         * 获取对象文件名称列表
         *
         * @param bucketName 存储桶名称
         * @param prefix     对象名称前缀(文件夹 /xx/xx/xxx.jpg 中的 /xx/xx/)
         * @param sort       是否排序(升序)
         * @return objectNames
         */
        @SneakyThrows
        public List<String> listObjectNames(String bucketName, String prefix, Boolean sort) {
        
    
            boolean flag = bucketExists(bucketName);
            if (flag) {
        
    
                ListObjectsArgs listObjectsArgs;
                if (null == prefix) {
        
                    listObjectsArgs = ListObjectsArgs.builder()
                            .bucket(bucketName)
                            .recursive(true)
                            .build();
                } else {
        
                    listObjectsArgs = ListObjectsArgs.builder()
                            .bucket(bucketName)
                            .prefix(prefix)
                            .recursive(true)
                            .build();
                }
                Iterable<Result<Item>> chunks = instance.listObjects(listObjectsArgs);
                List<String> chunkPaths = new ArrayList<>();
                for (Result<Item> item : chunks) {
        
                    chunkPaths.add(item.get().objectName());
                }
                if (sort) {
        
                    chunkPaths.sort(new Str2IntComparator(false));
                }
                return chunkPaths;
            }
            return new ArrayList<>();
        }
    
        /**
         * 在桶下创建文件夹,文件夹层级结构根据参数决定
         *
         * @param bucket 桶名称
         * @param WotDir 格式为 xxx/xxx/xxx/
         */
        @SneakyThrows
        public String createDirectory(String bucket, String WotDir) {
        
            if (!this.bucketExists(bucket)) {
        
                return null;
            }
            instance.putObject(PutObjectArgs.builder().bucket(bucket).object(WotDir).stream(
                    new ByteArrayInputStream(new byte[]{
        }), 0, -1)
                    .build());
            return WotDir;
        }
    
    
        /**
         * 删除一个文件
         *
         * @param bucketName
         * @param objectName
         */
        @SneakyThrows
        public boolean removeObject(String bucketName, String objectName) {
        
    
            if (!bucketExists(bucketName)) {
        
                return false;
            }
            instance.removeObject(
                    RemoveObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .build());
            return true;
        }
    
        /**
         * @param bucketName
         * @param objectNames
         * @return java.util.List<java.lang.String>
         * @Description 删除指定桶的多个文件对象, 返回删除错误的对象列表，全部删除成功，返回空列表
         * @author exe.wangtaotao
         * @date 2020/10/21 16:43
         */
        @SneakyThrows
        public List<String> removeObjects(String bucketName, List<String> objectNames) {
        
            if (!bucketExists(bucketName)) {
        
                return new ArrayList<>();
            }
            List<DeleteObject> deleteObjects = new ArrayList<>(objectNames.size());
            for (String objectName : objectNames) {
        
                deleteObjects.add(new DeleteObject(objectName));
            }
            List<String> deleteErrorNames = new ArrayList<>();
            Iterable<Result<DeleteError>> results = instance.removeObjects(
                    RemoveObjectsArgs.builder()
                            .bucket(bucketName)
                            .objects(deleteObjects)
                            .build());
            for (Result<DeleteError> result : results) {
        
                DeleteError error = result.get();
                deleteErrorNames.add(error.objectName());
            }
            return deleteErrorNames;
        }
    
    
        /**
         * 获取访问对象的外链地址
         * 获取文件的下载url
         *
         * @param bucketName 存储桶名称
         * @param objectName 对象名称
         * @param expiry     过期时间(分钟) 最大为7天 超过7天则默认最大值
         * @return viewUrl
         */
        @SneakyThrows
        public String getObjectUrl(String bucketName, String objectName, Integer expiry) {
        
            expiry = expiryHandle(expiry);
            return instance.getPresignedObjectUrl(
                    GetPresignedObjectUrlArgs.builder()
                            .method(Method.GET)
                            .bucket(bucketName)
                            .object(objectName)
                            .expiry(expiry)
                            .build()
            );
        }
    
    
        /**
         * 创建上传文件对象的外链
         *
         * @param bucketName 存储桶名称
         * @param objectName 欲上传文件对象的名称
         * @return uploadUrl
         */
        public String createUploadUrl(String bucketName, String objectName) {
        
            return createUploadUrl(bucketName, objectName, DEFAULT_EXPIRY);
        }
    
        /**
         * 创建上传文件对象的外链
         *
         * @param bucketName 存储桶名称
         * @param objectName 欲上传文件对象的名称
         * @param expiry     过期时间(分钟) 最大为7天 超过7天则默认最大值
         * @return uploadUrl
         */
        @SneakyThrows
        public String createUploadUrl(String bucketName, String objectName, Integer expiry) {
        
            expiry = expiryHandle(expiry);
            return instance.getPresignedObjectUrl(
                    GetPresignedObjectUrlArgs.builder()
                            .method(Method.PUT)
                            .bucket(bucketName)
                            .object(objectName)
                            .expiry(expiry)
                            .build()
            );
        }
    
    
        /**
         * 批量下载
         *
         * @param directory
         * @return
         */
        @SneakyThrows
        public List<String> downLoadMore(String bucket, String directory) {
        
            Iterable<Result<Item>> objs = instance.listObjects(ListObjectsArgs.builder().bucket(bucket).prefix(directory).useUrlEncodingType(false).build());
            List<String> list = new ArrayList<>();
            for (Result<Item> result : objs) {
        
                String objectName = null;
                objectName = result.get().objectName();
                ObjectStat statObject = instance.statObject(StatObjectArgs.builder().bucket(bucket).object(objectName).build());
                if (statObject != null && statObject.length() > 0) {
        
                    String fileurl = instance.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().bucket(bucket).object(statObject.name()).method(Method.GET).build());
                    list.add(fileurl);
                }
            }
            return list;
        }
    
    
        /**
         * @param multipartFile
         * @param bucketName
         * @param directory image/
         * @return java.lang.String
         * @Description 文件上传
         * @author exe.wangtaotao
         * @date 2020/10/21 13:45
         */
        public MinIoUploadResDTO upload(MultipartFile multipartFile,String bucketName,String directory) throws Exception {
        
            if (!this.bucketExists(bucketName)) {
        
                this.makeBucket(bucketName);
            }
            InputStream inputStream = multipartFile.getInputStream();
            directory = Optional.ofNullable(directory).orElse("");
            String minFileName = directory + minFileName(multipartFile.getOriginalFilename());
            System.out.println(minFileName);
            //上传文件到指定目录
            instance.putObject(PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(minFileName)
                    .contentType(multipartFile.getContentType())
                    .stream(inputStream, inputStream.available(), -1)
                    .build());
            inputStream.close();
            // 返回生成文件名、访问路径
            return new MinIoUploadResDTO(minFileName, getObjectUrl(bucketName, minFileName, DEFAULT_EXPIRY));
        }
    
        /**
         * @param response
         * @return java.lang.String
         * @Description 下载文件
         * @author exe.wangtaotao
         * @date 2020/10/21 15:18
         */
        public void download(HttpServletResponse response, String bucketName, String minFileName) throws Exception {
        
            InputStream fileInputStream = instance.getObject(GetObjectArgs.builder()
                    .bucket(bucketName)
                    .object(minFileName).build());
            response.setHeader("Content-Disposition", "attachment;filename=" + minFileName);
            response.setContentType("application/force-download");
            response.setCharacterEncoding("UTF-8");
            IOUtils.copy(fileInputStream, response.getOutputStream());
        }
    
    
        /**
         * 批量创建分片上传外链
         *
         * @param bucketName 存储桶名称
         * @param objectMD5  欲上传分片文件主文件的MD5
         * @param chunkCount 分片数量
         * @return uploadChunkUrls
         */
        public List<String> createUploadChunkUrlList(String bucketName, String objectMD5, Integer chunkCount) {
        
            if (null == bucketName) {
        
                bucketName = chunkBucKet;
            }
            if (null == objectMD5) {
        
                return null;
            }
            objectMD5 += "/";
            if (null == chunkCount || 0 == chunkCount) {
        
                return null;
            }
            List<String> urlList = new ArrayList<>(chunkCount);
            for (int i = 1; i <= chunkCount; i++) {
        
                String objectName = objectMD5 + i + ".chunk";
                urlList.add(createUploadUrl(bucketName, objectName, DEFAULT_EXPIRY));
            }
            return urlList;
        }
    
        /**
         * 创建指定序号的分片文件上传外链
         *
         * @param bucketName 存储桶名称
         * @param objectMD5  欲上传分片文件主文件的MD5
         * @param partNumber 分片序号
         * @return uploadChunkUrl
         */
        public String createUploadChunkUrl(String bucketName, String objectMD5, Integer partNumber) {
        
            if (null == bucketName) {
        
                bucketName = chunkBucKet;
            }
            if (null == objectMD5) {
        
                return null;
            }
            objectMD5 += "/" + partNumber + ".chunk";
            return createUploadUrl(bucketName, objectMD5, DEFAULT_EXPIRY);
        }
    
    
        /**
         * 获取分片文件名称列表
         *
         * @param bucketName 存储桶名称
         * @param ObjectMd5  对象Md5
         * @return objectChunkNames
         */
        public List<String> listChunkObjectNames(String bucketName, String ObjectMd5) {
        
            if (null == bucketName) {
        
                bucketName = chunkBucKet;
            }
            if (null == ObjectMd5) {
        
                return null;
            }
            return listObjectNames(bucketName, ObjectMd5, SORT);
        }
    
        /**
         * 获取分片名称地址HashMap key=分片序号 value=分片文件地址
         *
         * @param bucketName 存储桶名称
         * @param ObjectMd5  对象Md5
         * @return objectChunkNameMap
         */
        public Map<Integer, String> mapChunkObjectNames(String bucketName, String ObjectMd5) {
        
            if (null == bucketName) {
        
                bucketName = chunkBucKet;
            }
            if (null == ObjectMd5) {
        
                return null;
            }
            List<String> chunkPaths = listObjectNames(bucketName, ObjectMd5);
            if (null == chunkPaths || chunkPaths.size() == 0) {
        
                return null;
            }
            Map<Integer, String> chunkMap = new HashMap<>(chunkPaths.size());
            for (String chunkName : chunkPaths) {
        
                Integer partNumber = Integer.parseInt(chunkName.substring(chunkName.indexOf("/") + 1, chunkName.lastIndexOf(".")));
                chunkMap.put(partNumber, chunkName);
            }
            return chunkMap;
        }
    
    
        /**
         * 合并分片文件成对象文件
         *
         * @param chunkBucKetName   分片文件所在存储桶名称
         * @param composeBucketName 合并后的对象文件存储的存储桶名称
         * @param chunkNames        分片文件名称集合
         * @param objectName        合并后的对象文件名称
         * @return true/false
         */
        @SneakyThrows
        public boolean composeObject(String chunkBucKetName, String composeBucketName, List<String> chunkNames, String objectName, boolean isDeleteChunkObject) {
        
            if (null == chunkBucKetName) {
        
                chunkBucKetName = chunkBucKet;
            }
            List<ComposeSource> sourceObjectList = new ArrayList<>(chunkNames.size());
            for (String chunk : chunkNames) {
        
                sourceObjectList.add(
                        ComposeSource.builder()
                                .bucket(chunkBucKetName)
                                .object(chunk)
                                .build()
                );
            }
            instance.composeObject(
                    ComposeObjectArgs.builder()
                            .bucket(composeBucketName)
                            .object(objectName)
                            .sources(sourceObjectList)
                            .build()
            );
            if (isDeleteChunkObject) {
        
                removeObjects(chunkBucKetName, chunkNames);
            }
            return true;
        }
    
        /**
         * 合并分片文件成对象文件
         *
         * @param bucketName 存储桶名称
         * @param chunkNames 分片文件名称集合
         * @param objectName 合并后的对象文件名称
         * @return true/false
         */
        public boolean composeObject(String bucketName, List<String> chunkNames, String objectName) {
        
            return composeObject(chunkBucKet, bucketName, chunkNames, objectName, NOT_DELETE_CHUNK_OBJECT);
        }
    
        /**
         * 合并分片文件成对象文件
         *
         * @param bucketName 存储桶名称
         * @param chunkNames 分片文件名称集合
         * @param objectName 合并后的对象文件名称
         * @return true/false
         */
        public boolean composeObject(String bucketName, List<String> chunkNames, String objectName, boolean isDeleteChunkObject) {
        
            return composeObject(chunkBucKet, bucketName, chunkNames, objectName, isDeleteChunkObject);
        }
    
        /**
         * 合并分片文件，合并成功后删除分片文件
         *
         * @param bucketName 存储桶名称
         * @param chunkNames 分片文件名称集合
         * @param objectName 合并后的对象文件名称
         * @return true/false
         */
        public boolean composeObjectAndRemoveChunk(String bucketName, List<String> chunkNames, String objectName) {
        
            return composeObject(chunkBucKet, bucketName, chunkNames, objectName, DELETE_CHUNK_OBJECT);
        }
    
    
        /**
         * @param originalFileName
         * @return java.lang.String
         * @Description 生成上传文件名
         * @author exe.wangtaotao
         * @date 2020/10/21 15:07
         */
        private String minFileName(String originalFileName) {
        
            String suffix = originalFileName;
            if (originalFileName.contains(SEPARATOR_DOT)) {
        
                suffix = originalFileName.substring(originalFileName.lastIndexOf(SEPARATOR_DOT));
            }
            return UUID.randomUUID().toString().replace(SEPARATOR_ACROSS, SEPARATOR_STR).toUpperCase() + suffix;
        }
    
    
        /**
         * 将分钟数转换为秒数
         *
         * @param expiry 过期时间(分钟数)
         * @return expiry
         */
        private static int expiryHandle(Integer expiry) {
        
            expiry = expiry * 60;
            if (expiry > 604800) {
        
                return 604800;
            }
            return expiry;
        }
    
        static class Str2IntComparator implements Comparator<String> {
        
            private final boolean reverseOrder; // 是否倒序
    
            public Str2IntComparator(boolean reverseOrder) {
        
                this.reverseOrder = reverseOrder;
            }
    
            @Override
            public int compare(String arg0, String arg1) {
        
                Integer intArg0 = Integer.parseInt(arg0.substring(arg0.indexOf("/") + 1, arg0.lastIndexOf(".")));
                Integer intArg1 = Integer.parseInt(arg1.substring(arg1.indexOf("/") + 1, arg1.lastIndexOf(".")));
                if (reverseOrder) {
        
                    return intArg1 - intArg0;
                } else {
        
                    return intArg0 - intArg1;
                }
            }
        }
    
    }

import lombok.Data;
    
    import java.io.Serializable;
    
    @Data
    public class MinIoUploadResDTO implements Serializable {
        
    
        private static final long serialVersionUID = 475040120689218785L;
        private String minFileName;
        private String minFileUrl;
    
        public MinIoUploadResDTO(String minFileName,String minFileUrl) {
        
            this.minFileName = minFileName;
            this.minFileUrl = minFileUrl;
        }
    
    }

import java.io.Serializable;
    
    public class Result<T> implements Serializable {
        
    
        private static final long serialVersionUID = 6273326371984994386L;
        private Integer code;
        private String msg;
        private T data;
    
        private Result() {
        
            this.code = 200;
            this.msg = "OK";
        }
    
        private Result(T data) {
        
            this.code = 200;
            this.msg = "OK";
            this.setData(data);
        }
    
        private Result(Integer code, String msg) {
        
            this.code = code;
            this.msg = msg;
        }
    
        private Result(Integer code, String msg, T data) {
        
            this.code = code;
            this.msg = msg;
            this.data = data;
        }
    
        public Result<T> setError(Integer code, String msg) {
        
            this.setCode(code);
            this.setMsg(msg);
            return this;
        }
    
        public boolean isSuccess() {
        
            return this.getCode().equals(200);
        }
    
        public static Result ok() {
        
            return new Result();
        }
    
        public static <T> Result ok(T data) {
        
            return new Result(data);
        }
    
        public static <T> Result ok(Integer code, String msg) {
        
            return new Result(code, msg);
        }
    
        public static <T> Result ok(Integer code, String msg, T data) {
        
            return new Result(code, msg, data);
        }
    
        public static <T> Result error() {
        
            return new Result(500, "failed");
        }
    
        public static <T> Result error(String msg) {
        
            return new Result(500, msg);
        }
    
        public static <T> Result error(Integer code, String msg) {
        
            return new Result(code, msg);
        }
    
        public static <T> Result error(Integer code, String msg, T data) {
        
            return new Result(code, msg, data);
        }
    
        public Integer getCode() {
        
            return this.code;
        }
    
        public void setCode(Integer code) {
        
            this.code = code;
        }
    
        public String getMsg() {
        
            return this.msg;
        }
    
        public void setMsg(String msg) {
        
            this.msg = msg;
        }
    
        public T getData() {
        
            return this.data;
        }
    
        public void setData(T data) {
        
            this.data = data;
        }
    }

import com.wkr.oss.base.Result;
    import com.wkr.oss.utils.MinIoUtils;
    import com.wkr.oss.vo.RemoveListReq;
    import com.wkr.oss.vo.RemoveListRes;
    import com.wkr.oss.vo.RemoveObjectReq;
    
    import org.springframework.web.bind.annotation.*;
    import org.springframework.web.multipart.MultipartFile;
    
    import javax.annotation.Resource;
    import javax.servlet.http.HttpServletResponse;
    import java.util.List;
    
    @RestController
    public class MinIoController {
        
    
        @Resource
        private MinIoUtils minIoUtils;
    
        // 存储桶名称
        private static final String MINIO_BUCKET = "img";
    
        @RequestMapping(value = "/upload", method = RequestMethod.POST)
        public Result upload(@RequestParam(value = "files") MultipartFile files){
        
            try {
        
                return Result.ok(minIoUtils.upload(files,MINIO_BUCKET,null));
            } catch (Exception e) {
        
                return Result.error(e.getMessage());
            }
        }
    }

### 上传图片并访问 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 6]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 7]

### 可以结合Nginx访问 ###

链接: [在windows上安装Nginx参考][windows_Nginx].  
nginx配置链接: [方式二nginx简单配置][nginx].

按方式二nginx简单配置 修改其中 root 图片路径为启动minio的路径

location ~ \.(html|js|css|png|gif|img|jpg)$ {
                root   D:\minio\bucket;
    }

### 启动nginx后访问127.0.0.1/img/xxx ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 8]

### 注意访问不到可能是nginx配置的静态资源出错，注意文件格式 ###

### Windows下的Minio服务修改密码 ###

修改密码的路径：\[保存路径\]/.minio.sys/config/config.json  
打开 config.json 文件，直接搜索 access\_key 和 secret\_key 修改后面value中的值就可以了  
修改完成后重新启动就可以了

[https_docs.minio.io_docs_minio-quickstart-guide.html]: https://docs.minio.io/docs/minio-quickstart-guide.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210303134735665.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210303135401117.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw,size_16,color_FFFFFF,t_70
[http_dl.minio.org.cn_server_minio_release_windows-amd64]: http://dl.minio.org.cn/server/minio/release/windows-amd64/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210303135029322.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw,size_16,color_FFFFFF,t_70
[20210303135644654.png]: https://img-blog.csdnimg.cn/20210303135644654.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210303135842661.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210318201624461.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210318201915654.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210318204726855.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20210318204811201.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw,size_16,color_FFFFFF,t_70
[windows_Nginx]: https://blog.csdn.net/qq_41604890/article/details/113664424
[nginx]: https://blog.csdn.net/qq_41604890/article/details/114553632
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20210318210711794.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw,size_16,color_FFFFFF,t_70