高性能对象存储MinIO学习&API使用&使用api创建文件夹&MinIO工具类

Bertha 。 2023-09-30 12:58 40阅读 0赞

MinIO 是GlusterFS创始人之一Anand Babu Periasamy发布的开源项目，基于Apache V2 license 100% 开放源代码。MinIO采用Golang实现，客户端支持Java、Python、Javacript、Golang语言等。

其设计的主要目标是作为私有云对象存储的标准方案。非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据、容器和虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T。

MinIO有中文文档，见：http://docs.minio.org.cn/

## 1、MinIO的优点 ##

#### （1）安装部署（运维简单） ####

MinIO在安装过程是黑盒的，不用深入关注它的架构，也不需要进行零件组装，基本上可以做到开箱即用。普通的技术人员就能够参与后期的运维。

MinIO提供了两种部署方式：单机部署和分布式，两种部署方式都非常简单，其中分布式部署还提供了纠删码功能来降低数据丢失的风险。

#### （2）UI界面 ####

MinIO自带UI界面，且页面不需要你单独的部署，和服务端一并安装。开箱即用，爱了爱了。

#### （3）高性能 ####

MinIO号称是世界上速度最快的对象存储服务器。在标准硬件上，对象存储的读/写速度最高可以达到183 GB/s和171 GB/s。对象存储可以充当主存储层，以处理Spark、Presto、TensorFlow、H2O.ai等各种复杂工作负载以及成为Hadoop HDFS的替代品。MinIO用作云原生应用程序的主要存储，与传统对象存储相比，云原生应用程序需要更高的吞吐量和更低的延迟。而这些都是MinIO能够达成的性能指标。

#### （4）容器化支持 ####

MinIO 符合一切原生云计算的架构和构建过程，并且包含最新的云计算的全新的技术和概念。其中包括支持Kubernetes 、Docker、微服和多租户的的容器技术。

#### （5）丰富的SDK支持 ####

MinIO几乎提供了所有主流开发语言的SDK以及文档。

#### （6）AWS S3标准兼容 ####

亚马逊云的 S3 API（接口协议） 是在全球范围内达到共识的对象存储的协议，是全世界内大家都认可的标准。MinIO 在很早的时候就采用了 S3 兼容协议，并且MinIO 是第一个支持 S3 Select 的产品. MinIO对其兼容性的全面性感到自豪， 并且得到了 750多个组织的认同, 包括Microsoft Azure使用MinIO的S3网关 - 这一指标超过其他同类产品的总和。

怎么理解呢？可以这么说你目前为了节约成本使用MinIO，等你的公司壮大了、有钱了。不想自己运维基础设施了，你就可以把对象存储放到云上，只要云厂商支持S3标准，你的应用程序是不需要重新开发的。

#### （7）可扩展性 ####

MinIO利用了Web缩放器的来之不易的知识，为对象存储带来了简单的缩放模型。这是我们坚定的理念 “简单可扩展.” 在 MinIO, 扩展从单个群集开始，该群集可以与其他MinIO群集联合以创建全局名称空间, 并在需要时可以跨越多个不同的数据中心。通过添加更多集群可以扩展名称空间, 更多机架，直到实现目标。

## 2、MinIO的缺点 ##

MinIO不支持动态增加节点，MinIO创始人的设计理念就是动态增加节点太复杂，后续会采用其它方案来支持扩容。目前只能是新增节点后手动重启系统才生效，系统会自动平衡数据，这种设计到底对系统后续有什么影响，我觉得使用者需要考虑清楚点。

这里有个方案可以参考下，就是事先准备好一套容量适中且是开启状态的MinIO集群，当业务量陡增、原MinIO集群容量告警时，应用自动启用备份MinIO集群，后续再整合两个集群的文件成一个更大的集群。否则不支持在线动态扩容，确实是个硬伤。

## Java之MinIO存储桶和对象API使用 ##

MinIO Java Client SDK提供简单的API来访问任何与Amazon S3兼容的对象存储服务。

*  官方demo: https://github.com/minio/minio-java
 *  官方文档：https://docs.min.io/docs/java-client-api-reference.html

新版 MinIO和旧版在API使用上还是有一定的区别，比如：新版 MinIO采用 Builder构建者模式来构造 MinioClient对象。所以，官方demo仅供参考，尽量查看英文官方文档。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAQ2hhcmdlOA_size_20_color_FFFFFF_t_70_g_se_x_16]

## 一、环境搭建 ##

**1、创建一个 maven项目，引入依赖：**

<dependency>
          <groupId>io.minio</groupId>
          <artifactId>minio</artifactId>
          <version>8.3.3</version>
        </dependency>
        
        <dependency>
          <groupId>me.tongfei</groupId>
          <artifactId>progressbar</artifactId>
          <version>0.7.4</version>
        </dependency>
        
        <dependency>
          <groupId>com.squareup.okhttp3</groupId>
          <artifactId>okhttp</artifactId>
          <version>4.9.2</version>
        </dependency>

这里我把 官方demo 放到了我的项目中，所以必须引入 progressbar依赖。否则忽略它。

**2、初始化Minio客户端**  
`注意：`

*  新版 MinIO 采用 Builder构建者模式来构造 MinioClient对象。
 *  API端口和 访问控制台端口不要搞混了。
    
        // 初始化Minio客户端
            MinioClient minioClient = MinioClient.builder()
                    .endpoint("http://xxx.xxx.xxx.xxx:9000/")
                    .credentials("admin", "xxx")
                    .build();
            System.out.println(minioClient);

获取到 MinioClient对象，就可以进行 MinIO的 API操作使用了。

## 二、存储桶基本使用 ##

### 1、检查存储桶是否存在。 ###

*  boolean bucketExists(BucketExistsArgs args)：检查存储桶是否存在。

示例：

BucketExistsArgs btest2 = BucketExistsArgs.builder().bucket("btest2").build();
    boolean existFlag = minioClient.bucketExists(btest2);

`注意：` 旧版参数是字符串 - 存储桶名，新版需要 build来构造 BucketExistsArgs对象。

### 2、创建存储桶 ###

*  public void makeBucket(MakeBucketArgs args)：创建一个启用给定区域和对象锁定功能的存储桶。

示例1：存储桶不存在则创建

String bucketName = "java.minio.demo";
    		// 存储桶不存在则创建
    		if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
        
    			minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
    			System.out.printf("%s,创建成功
    ", bucketName);
    		}else{
        
    			System.out.printf("%s,已存在
    ", bucketName);
    		}

### 3、查询存储桶 ###

#### 3.1 查询所有桶的列表信息 ####

*  public List listBuckets()：列出所有桶的桶信息。

示例：

List<Bucket> bucketList = minioClient.listBuckets();
            bucketList.forEach(bucket -> {
        
                System.out.printf("存储桶名：%s,创建时间：%s 
    ", bucket.name(), bucket.creationDate());
            });

![在这里插入图片描述][62bcacc5aad0404994b1edfcc8450cd7.png]  
`注意：`桶的创建时间默认是美国时间，创建桶时我们可以指定桶的时区或者设置 MinIO服务器时区。

### 4、删除存储桶 ###

*  public void removeBucket(RemoveBucketArgs args)：删除一个空桶。

示例：

String bucketName2 = "btest3";       minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName2).build());

`注意：`如果存储桶存在对象不为空时，删除会报错。

## 二、对象基本使用 ##

### 1、上传对象 ###

#### 1.1 PutObject方法 ####

*  public ObjectWriteResponse putObject(PutObjectArgs args)：将给定的流上传为存储桶中的对象。

示例1，InputStream上传：

String bucketName = "java.minio.demo";
            // 创建InputStream上传
            File file = new File("D:\DownUpLoadTempFiles\100元.jpg");
            InputStream inputStream = new FileInputStream(file);
    
            long start = System.currentTimeMillis();
            // 上传流
            minioClient.putObject(
                    PutObjectArgs.builder()
                            .bucket(bucketName)
                            .object("2021/11/28/" + file.getName()).stream(inputStream, inputStream.available(), -1)
                            .build());
            inputStream.close();
            System.out.println("uploaded successfully 耗时：" + (System.currentTimeMillis() - start));

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAQ2hhcmdlOA_size_11_color_FFFFFF_t_70_g_se_x_16]  
`注意：`

*  添加的Object大小不能超过 5GB。
 *  默认情况下，如果已存在同名Object且对该Object有访问权限，则新添加的Object将覆盖原有的Object，并返回 200 OK。
 *  OSS没有文件夹的概念，所有资源都是以文件来存储，但您可以通过创建一个以正斜线（/）结尾，大小为 0的Object来创建模拟文件夹（指定 /后，默认会自动创建）。

上传文件是也可以使用SSE-C加密，添加自定义元数据及消息头等操作。

#### 1.2 uploadObject方法 ####

*  public void uploadObject(UploadObjectArgs args)：将文件中的内容作为存储桶中的对象上传。

不太常用，一般适合上传磁盘文件（mc cp命令更方便）。  
示例：

String bucketName = "java.minio.demo";
            
            long start = System.currentTimeMillis();
            // 上传文件
            minioClient.uploadObject(
                    UploadObjectArgs.builder()
                            .bucket(bucketName)
                            .object("2021/11/28/100元2.jpg")
                            .filename("D:\DownUpLoadTempFiles\100元.jpg")
                            .build());
            System.out.println("uploaded successfully 耗时：" + (System.currentTimeMillis() - start));

### 2、获取对象 ###

#### 2.1 getObject方法 ####

*  public GetObjectResponse getObject(GetObjectArgs args)：获取对象的数据。

示例：

String bucketName = "java.minio.demo";
    
    		// GetObjectResponse 继承了 InputStream类
    		GetObjectResponse objectResponse = minioClient.getObject(GetObjectArgs.builder()
    				.bucket(bucketName)
    				.object("2021/11/28/100元2.jpg")
    				.build());
    		System.out.println(objectResponse.bucket());
    		System.out.println(objectResponse.object());
    		byte[] allBytes = objectResponse.readAllBytes();
    		System.out.println(allBytes);
    		
    		// Close the input stream.
    		objectResponse.close();

**注意：**

*  返回结果是 `GetObjectResponse类，它继承了 InputStream类`。
 *  GetObjectResponse使用后返回必须关闭以释放网络资源。
 *  此操作需要对此Object具有读权限。

#### 2.2 downloadObject方法 ####

*  public void downloadObject(DownloadObjectArgs args)：将对象的数据下载到磁盘。
    
        String bucketName = "java.minio.demo";
        
            minioClient.downloadObject(DownloadObjectArgs.builder()
                    .bucket(bucketName)
                    .object("2021/11/28/100元2.jpg")
                    .filename("D:\TempFiles\100元2.jpg") // 必须指定文件名
                    .build());

#### 2.3 getPresignedObjectUrl方法 ####

*  public String getPresignedObjectUrl(GetPresignedObjectUrlArgs args)：获取 HTTP 方法、到期时间和自定义请求参数的对象的预签名 URL。

示例：返回获取文件对象的URL GET请求，此 URL过期时间为一分钟。

String bucketName = "java.minio.demo";
    
            String objectUrl = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                    .bucket(bucketName)
                    .object("2021/11/28/100元2.jpg")
                    .method(Method.GET)
                    //.expiry(60) // 单位秒
                    .expiry(30, TimeUnit.SECONDS)
                    .build());
            System.out.println(objectUrl);

返回带签名的URL有点小长，过期之后访问会报错。  
![在这里插入图片描述][46a7d76a391b40b5a0dc8a5fc6fcc260.png]  
使用此方法，可以提供给不用登录进行图片浏览，第三方共享访问等。  
我们还可以对返回 URL，根据业务做一些参数验签等控制。

#### 2.4 getPresignedPostFormData方法 ####

*  public Map<String,String> getPresignedPostFormData(PostPolicy policy)：获取对象的PostPolicy的表单数据以使用 POST 方法上传其数据。
    
        String bucketName = "java.minio.demo";
            String objectName = "2021/11/28/100元3.jpg";
        
            // 1. 创建一个Post 策略
            // 为存储桶创建一个上传策略，过期时间为7天
            PostPolicy policy = new PostPolicy(bucketName, ZonedDateTime.now().plusDays(7));
            // 设置一个参数key-value，值为上传对象的名称（保存在桶中的名字）
            policy.addEqualsCondition("key", objectName);
            // 添加 Content-Type以"image/"开头，表示只能上传照片
            policy.addStartsWithCondition("Content-Type", "image/");
            // 设置上传文件的大小 10kiB to 10MiB.
            policy.addContentLengthRangeCondition(10 * 1024, 10 * 1024 * 1024);
        
            // 2. 获取策略的 认证令牌、签名等信息
            Map<String, String> formData = minioClient.getPresignedPostFormData(policy);
        
            // 3.模拟第三方，使用 OkHttp调用 Post上传对象
            // 创建 MultipartBody对象
            MultipartBody.Builder multipartBuilder = new MultipartBody.Builder();
            multipartBuilder.setType(MultipartBody.FORM);
            for (Map.Entry<String, String> entry : formData.entrySet()) {
              
                multipartBuilder.addFormDataPart(entry.getKey(), entry.getValue());
            }
            multipartBuilder.addFormDataPart("key", objectName);// 必须要和策略参数一样
            multipartBuilder.addFormDataPart("Content-Type", "image/png");
            File uploadFile = new File("D:\DownUpLoadTempFiles\100元.jpg");
            // 上传文件的 fileName自定义，这里方便就用 objectName
            multipartBuilder.addFormDataPart(
                    "file", objectName, RequestBody.create(uploadFile, null));
            // 使用OkHttp调用Post上传对象
            Request request =
                    new Request.Builder()
                            .url("http://192.168.198.110:9000/" + bucketName)
                            .post(multipartBuilder.build())
                            .build();
            OkHttpClient httpClient = new OkHttpClient().newBuilder().build();
            Response response = httpClient.newCall(request).execute();
            if (response.isSuccessful()) {
              
                System.out.println("uploaded successfully using POST object");
            } else {
              
                System.out.println("Failed to upload Pictures");
            }

使用此方法，获取对象的上传策略（包含签名、文件信息、路径等），然后使用这些信息采用 POST 方法的表单数据上传数据。也就是可以生成一个临时上传的信息对象，第三方可以使用这些信息，就可以上传文件。

**注意：**

*  第三方请求中的签名必须和 创建策略中的签名参数等一致，不符合策略要求的就会上传失败。

**一般使用场景：**

1.  第三方请求应用服务器接口，来获取一个上传策略信息。
2.  第三方使用 Http+访问策略信息直接请求应用服务器接口进行上传文件。

### 3、复制对象 ###

#### 3.1 copyObject方法 ####

*  public ObjectWriteResponse copyObject(CopyObjectArgs args)：通过服务器端从另一个对象复制数据来创建一个对象。

示例：

String bucketName = "java.minio.demo";
            String bucketName2 = "btest2";
    
            // 将 bucketName中的100元2.jpg文件，复制到bucketName2桶下
            minioClient.copyObject(CopyObjectArgs.builder()
                    .source(CopySource.builder()
                            .bucket(bucketName)
                            .object("2021/11/28/100元2.jpg")
                            .build())
                    .bucket(bucketName2)
                    .object("2021/11/28/100元copy.jpg")
                    .build());

mc cp命令更方便。

### 4、删除对象 ###

#### 4.1 removeObject方法 ####

*  public void removeObject(RemoveObjectArgs args) ：移除一个对象。

示例：

String bucketName = "java.minio.demo";
    
            minioClient.removeObject(RemoveObjectArgs.builder()
                    .bucket(bucketName)
                    .object("2021/11/28/100元2.jpg")
                    //.versionId("my-versionid") //还可以删除指定版本号的对象
                    .build());

#### 4.2 removeObjects方法 ####

*  public Iterable removeObjects(RemoveObjectsArgs args)：懒惰地删除多个对象。它需要迭代返回的 Iterable 以执行删除。

示例：

String bucketName = "java.minio.demo";
            
            // 构建需要删除的对象
            List<DeleteObject> objects = new LinkedList<>();
            objects.add(new DeleteObject("2021/11/28/100元.jpg"));
            objects.add(new DeleteObject("2021/11/28/100元2.jpg"));
            objects.add(new DeleteObject("2021/11/28/100元3.jpg"));
            // 删除
            Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder()
                    .bucket(bucketName)
                    .objects(objects)
                    .build());
            for (Result<DeleteError> result : results) {
        
                // 删除文件不存在时，不会报错
                DeleteError error = result.get();
                System.out.println("Error in deleting object " + error.objectName() + "; " + error.message());
            }

### 5、桶的对象信息查询 ###

*  public Iterable listObjects(ListObjectsArgs args)：列出桶的对象信息。

#### 5.1 查询桶下对象 ####

String bucketName2 = "btest2";
    
            Iterable<Result<Item>> listObjects = minioClient.listObjects(ListObjectsArgs.builder()
                    .bucket(bucketName2)
                    .build());
    
            for (Result<Item> result : listObjects) {
        
                Item item = result.get();
                System.out.println(item.objectName() + "	" + item.size() );
            }

![在这里插入图片描述][c5aeb1a06ee148a0b3f100ead8a96699.png]

#### 5.2 递归查询桶下对象 ####

String bucketName2 = "btest2";
    
            Iterable<Result<Item>> listObjects = minioClient.listObjects(ListObjectsArgs.builder()
                    .bucket(bucketName2)
                    .recursive(true)
                    .build());
    
            for (Result<Item> result : listObjects) {
        
                Item item = result.get();
                System.out.println(item.objectName() + "	" + item.size() );
            }

![在这里插入图片描述][670d85513bb34c77be09d5a95a78357a.png]

#### 5.3 条件查询 ####

// 条件查询
            Iterable<Result<Item>> listObjects = minioClient.listObjects(ListObjectsArgs.builder()
                    .bucket(bucketName2)
                    .startAfter("2021")
                    .prefix("2") // 指定前缀
                    .maxKeys(100) // 最大数量
                    .recursive(true) // 递归
                    .build());
    
            for (Result<Item> result : listObjects) {
        
                Item item = result.get();
                System.out.println(item.objectName() + "	" + item.size() );
            }

![在这里插入图片描述][9a9ad5b0fb824f4f9cc0d45a77988758.png]

### MinIO api创建文件夹 ###

近期公司业务需求，将OSS迁移到MinIO上，发现**创建空文件夹**有很大的问题，请注意，\*\*一定要引\**7.1.0\*版本的minio SDK*，才能实现创建空文件夹。

## 代码 ##

minioClient.putObject(
        PutObjectArgs.builder().bucket("my-bucketname").object("path/to/").stream(
                new ByteArrayInputStream(new byte[] {
        }), 0, -1)
            .build());

实际创建的还是文件对象，只不过以"/"结尾，模拟了文件夹或目录

### 其他版本，同样以"/"结尾 ###

3.0.10：创建文件夹报错

7.0.2：传入"/“结尾ObjectName，创建出来的是文件，自动去掉了”/"

## MinIO工具类 ##

pom.xml中引依赖

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

配置

minio:
      endpoint: http://127.0.0.1:9000 #MinIO服务所在地址
      bucketName: test #存储桶名称
      accessKey: admin #访问的key
      secretKey: admin123 #访问的秘钥

项目启动，创建bean：MinioConfig.java

import com.mgmiot.dlp.file.utils.MinioUtils;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.integration.annotation.IntegrationComponentScan;
     
    @Configuration
    @IntegrationComponentScan
    @Slf4j
    public class MinioConfig {
        
     
      @Value("${minio.endpoint}")
      private String endpoint;
      @Value("${minio.bucketName}")
      private String bucketName;
      @Value("${minio.accessKey}")
      private String accessKey;
      @Value("${minio.secretKey}")
      private String secretKey;
     
      @Bean
      public MinioUtils creatMinioClient() {
        
        return new MinioUtils(endpoint, bucketName, accessKey, secretKey);
      }
     
    }

Minio工具类：MinioUtils.java

import com.alibaba.fastjson.JSONObject;
    import io.minio.BucketExistsArgs;
    import io.minio.CopyObjectArgs;
    import io.minio.CopySource;
    import io.minio.GetBucketPolicyArgs;
    import io.minio.GetObjectArgs;
    import io.minio.ListObjectsArgs;
    import io.minio.MakeBucketArgs;
    import io.minio.MinioClient;
    import io.minio.ObjectStat;
    import io.minio.ObjectWriteResponse;
    import io.minio.PostPolicy;
    import io.minio.PutObjectArgs;
    import io.minio.RemoveBucketArgs;
    import io.minio.RemoveObjectArgs;
    import io.minio.Result;
    import io.minio.StatObjectArgs;
    import io.minio.UploadObjectArgs;
    import io.minio.errors.BucketPolicyTooLargeException;
    import io.minio.errors.ErrorResponseException;
    import io.minio.errors.InsufficientDataException;
    import io.minio.errors.InternalException;
    import io.minio.errors.InvalidBucketNameException;
    import io.minio.errors.InvalidExpiresRangeException;
    import io.minio.errors.InvalidResponseException;
    import io.minio.errors.RegionConflictException;
    import io.minio.errors.ServerException;
    import io.minio.errors.XmlParserException;
    import io.minio.messages.Bucket;
    import io.minio.messages.DeleteObject;
    import io.minio.messages.Item;
    import java.io.ByteArrayInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.UnsupportedEncodingException;
    import java.net.URLDecoder;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.time.ZonedDateTime;
    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    import java.util.Optional;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.multipart.MultipartFile;
     
    /**
     * @Author: zrs
     * @Date: 2020/12/01/10:02
     * @Description: Minio工具类
     */
    @Slf4j
    public class MinioUtils {
        
     
      private static MinioClient minioClient;
     
      private static String endpoint;
      private static String bucketName;
      private static String accessKey;
      private static String secretKey;
     
      private static final String SEPARATOR = "/";
     
      private MinioUtils() {
        
      }
     
      public MinioUtils(String endpoint, String bucketName, String accessKey, String secretKey) {
        
        MinioUtils.endpoint = endpoint;
        MinioUtils.bucketName = bucketName;
        MinioUtils.accessKey = accessKey;
        MinioUtils.secretKey = secretKey;
        createMinioClient();
      }
     
      /**
       * 创建minioClient
       */
      public void createMinioClient() {
        
        try {
        
          if (null == minioClient) {
        
            log.info("minioClient create start");
            minioClient = MinioClient.builder().endpoint(endpoint).credentials(accessKey, secretKey)
                .build();
            createBucket();
            log.info("minioClient create end");
          }
        } catch (Exception e) {
        
          log.error("连接MinIO服务器异常：{}", e);
        }
      }
     
      /**
       * 获取上传文件的基础路径
       *
       * @return url
       */
      public static String getBasisUrl() {
        
        return endpoint + SEPARATOR + bucketName + SEPARATOR;
      }
       操作存储桶 
     
      /**
       * 初始化Bucket
       *
       * @throws Exception 异常
       */
      private static void createBucket()
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException, RegionConflictException {
        
        if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
        
          minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        }
      }
     
      /**
       * 验证bucketName是否存在
       *
       * @return boolean true:存在
       */
      public static boolean bucketExists()
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        
        return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
      }
     
      /**
       * 创建bucket
       *
       * @param bucketName bucket名称
       */
      public static void createBucket(String bucketName)
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException, RegionConflictException {
        
        if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
        
          minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        }
      }
     
      /**
       * 获取存储桶策略
       *
       * @param bucketName 存储桶名称
       * @return json
       */
      private JSONObject getBucketPolicy(String bucketName)
          throws IOException, InvalidKeyException, InvalidResponseException, BucketPolicyTooLargeException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, InsufficientDataException, ErrorResponseException {
        
        String bucketPolicy = minioClient
            .getBucketPolicy(GetBucketPolicyArgs.builder().bucket(bucketName).build());
        return JSONObject.parseObject(bucketPolicy);
      }
     
      /**
       * 获取全部bucket
       * <p>
       * https://docs.minio.io/cn/java-client-api-reference.html#listBuckets
       */
      public static List<Bucket> getAllBuckets()
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        
        return minioClient.listBuckets();
      }
     
      /**
       * 根据bucketName获取信息
       *
       * @param bucketName bucket名称
       */
      public static Optional<Bucket> getBucket(String bucketName)
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        
        return minioClient.listBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
      }
     
      /**
       * 根据bucketName删除信息
       *
       * @param bucketName bucket名称
       */
      public static void removeBucket(String bucketName)
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
      }
     
       操作文件对象 
     
      /**
       * 判断文件是否存在
       *
       * @param bucketName 存储桶
       * @param objectName 对象
       * @return true：存在
       */
      public static boolean doesObjectExist(String bucketName, String objectName) {
        
        boolean exist = true;
        try {
        
          minioClient
              .statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
        } catch (Exception e) {
        
          exist = false;
        }
        return exist;
      }
     
      /**
       * 判断文件夹是否存在
       *
       * @param bucketName 存储桶
       * @param objectName 文件夹名称（去掉/）
       * @return true：存在
       */
      public static boolean doesFolderExist(String bucketName, String objectName) {
        
        boolean exist = false;
        try {
        
          Iterable<Result<Item>> results = minioClient.listObjects(
              ListObjectsArgs.builder().bucket(bucketName).prefix(objectName).recursive(false).build());
          for (Result<Item> result : results) {
        
            Item item = result.get();
            if (item.isDir() && objectName.equals(item.objectName())) {
        
              exist = true;
            }
          }
        } catch (Exception e) {
        
          exist = false;
        }
        return exist;
      }
     
      /**
       * 根据文件前置查询文件
       *
       * @param bucketName bucket名称
       * @param prefix 前缀
       * @param recursive 是否递归查询
       * @return MinioItem 列表
       */
      public static List<Item> getAllObjectsByPrefix(String bucketName, String prefix,
          boolean recursive)
          throws ErrorResponseException, InsufficientDataException, InternalException, InvalidBucketNameException, InvalidKeyException, InvalidResponseException,
          IOException, NoSuchAlgorithmException, ServerException, XmlParserException {
        
        List<Item> list = new ArrayList<>();
        Iterable<Result<Item>> objectsIterator = minioClient.listObjects(
            ListObjectsArgs.builder().bucket(bucketName).prefix(prefix).recursive(recursive).build());
        if (objectsIterator != null) {
        
          for (Result<Item> o : objectsIterator) {
        
            Item item = o.get();
            list.add(item);
          }
        }
        return list;
      }
     
      /**
       * 获取文件流
       *
       * @param bucketName bucket名称
       * @param objectName 文件名称
       * @return 二进制流
       */
      public static InputStream getObject(String bucketName, String objectName)
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        
        return minioClient
            .getObject(GetObjectArgs.builder().bucket(bucketName).object(objectName).build());
      }
     
      /**
       * 断点下载
       *
       * @param bucketName bucket名称
       * @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 {
        
        return minioClient.getObject(
            GetObjectArgs.builder().bucket(bucketName).object(objectName).offset(offset).length(length)
                .build());
      }
     
      /**
       * 获取路径下文件列表
       *
       * @param bucketName bucket名称
       * @param prefix 文件名称
       * @param recursive 是否递归查找，如果是false,就模拟文件夹结构查找
       * @return 二进制流
       */
      public static Iterable<Result<Item>> listObjects(String bucketName, String prefix,
          boolean recursive) {
        
        return minioClient.listObjects(
            ListObjectsArgs.builder().bucket(bucketName).prefix(prefix).recursive(recursive).build());
      }
     
      /**
       * 通过MultipartFile，上传文件
       *
       * @param bucketName 存储桶
       * @param file 文件
       * @param objectName 对象名
       */
      public static ObjectWriteResponse putObject(String bucketName, MultipartFile file,
          String objectName, String contentType)
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        
        InputStream inputStream = file.getInputStream();
        return minioClient.putObject(
            PutObjectArgs.builder().bucket(bucketName).object(objectName).contentType(contentType)
                .stream(
                    inputStream, inputStream.available(), -1)
                .build());
      }
     
      /**
       * 上传本地文件
       *
       * @param bucketName 存储桶
       * @param objectName 对象名称
       * @param fileName 本地文件路径
       */
      public static ObjectWriteResponse putObject(String bucketName, String objectName,
          String fileName)
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        
        return minioClient.uploadObject(
            UploadObjectArgs.builder()
                .bucket(bucketName).object(objectName).filename(fileName).build());
      }
     
      /**
       * 通过流上传文件
       *
       * @param bucketName 存储桶
       * @param objectName 文件对象
       * @param inputStream 文件流
       */
      public static ObjectWriteResponse putObject(String bucketName, String objectName,
          InputStream inputStream)
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        
        return minioClient.putObject(
            PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(
                inputStream, inputStream.available(), -1)
                .build());
      }
     
      /**
       * 创建文件夹或目录
       *
       * @param bucketName 存储桶
       * @param objectName 目录路径
       */
      public static ObjectWriteResponse putDirObject(String bucketName, String objectName)
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        
        return minioClient.putObject(
            PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(
                new ByteArrayInputStream(new byte[]{
        }), 0, -1)
                .build());
      }
     
      /**
       * 获取文件信息, 如果抛出异常则说明文件不存在
       *
       * @param bucketName bucket名称
       * @param objectName 文件名称
       */
      public static ObjectStat statObject(String bucketName, String objectName)
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        
        return minioClient
            .statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
      }
     
      /**
       * 拷贝文件
       *
       * @param bucketName bucket名称
       * @param objectName 文件名称
       * @param srcBucketName 目标bucket名称
       * @param srcObjectName 目标文件名称
       */
      public static ObjectWriteResponse copyObject(String bucketName, String objectName,
          String srcBucketName, String srcObjectName)
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        
        return minioClient.copyObject(
            CopyObjectArgs.builder()
                .source(CopySource.builder().bucket(bucketName).object(objectName).build())
                .bucket(srcBucketName)
                .object(srcObjectName)
                .build());
      }
     
      /**
       * 删除文件
       *
       * @param bucketName bucket名称
       * @param objectName 文件名称
       */
      public static void removeObject(String bucketName, String objectName)
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        
        minioClient
            .removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
      }
     
      /**
       * 批量删除文件
       *
       * @param bucketName bucket
       * @param keys 需要删除的文件列表
       * @return
       */
      /*public static Iterable<Result<DeleteError>> removeObjects(String bucketName, List<String> keys) {
        List<DeleteObject> objects = new LinkedList<>();
        keys.forEach(s -> {
          objects.add(new DeleteObject(s));
        });
        return minioClient.removeObjects(
            RemoveObjectsArgs.builder().bucket(bucketName).objects(objects).build());
      }*/
      public static void removeObjects(String bucketName, List<String> keys) {
        
        List<DeleteObject> objects = new LinkedList<>();
        keys.forEach(s -> {
        
          objects.add(new DeleteObject(s));
          try {
        
            removeObject(bucketName, s);
          } catch (Exception e) {
        
            log.error("批量删除失败！error:{}",e);
          }
        });
      }
     
       操作Presigned 
     
      /**
       * 获取文件外链
       *
       * @param bucketName bucket名称
       * @param objectName 文件名称
       * @param expires 过期时间 <=7 秒级
       * @return url
       */
      public static String getPresignedObjectUrl(String bucketName, String objectName,
          Integer expires)
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, InvalidExpiresRangeException, ServerException, InternalException, NoSuchAlgorithmException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        
        return minioClient.presignedGetObject(bucketName, objectName, expires);
      }
     
      /**
       * 给presigned URL设置策略
       *
       * @param bucketName 存储桶
       * @param objectName 对象名
       * @param expires 过期策略
       * @return map
       */
      public static Map<String, String> presignedGetObject(String bucketName, String objectName,
          Integer expires)
          throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, InvalidExpiresRangeException, ServerException, InternalException, NoSuchAlgorithmException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        
        PostPolicy policy = new PostPolicy(bucketName, objectName,
            ZonedDateTime.now().plusDays(7));
        policy.setContentType("image/png");
        return minioClient.presignedPostPolicy(policy);
      }
     
     
      /**
       * 将URLDecoder编码转成UTF8
       *
       * @param str
       * @return
       * @throws UnsupportedEncodingException
       */
      public static String getUtf8ByURLDecoder(String str) throws UnsupportedEncodingException {
        
        String url = str.replaceAll("%(?![0-9a-fA-F]{2})", "%25");
        return URLDecoder.decode(url, "UTF-8");
      }
     
    }

import lombok.RequiredArgsConstructor;
    import org.springframework.stereotype.Service;
    import org.springframework.web.multipart.MultipartFile;
    
    import java.util.ArrayList;
    import java.util.List;
    
    @Service
    @RequiredArgsConstructor
    public class AttachmentManagementService {
        
    
        private final MinIOFileManagementService fileManagementService;
    
        public String save(ModuleTypeEnum moduleTypeEnum, Long sourceId, MultipartFile attachment) {
        
            return save(moduleTypeEnum, sourceId.toString(), attachment);
        }
    
        public String save(ModuleTypeEnum moduleTypeEnum, String sourceId, MultipartFile attachment) {
        
            if (attachment != null) {
        
                return fileManagementService.storage(moduleTypeEnum, sourceId, attachment);
            }
            return null;
        }
    
        public List<String> save(ModuleTypeEnum moduleTypeEnum, Long sourceId, MultipartFile[] attachments) {
        
            List<String> result = new ArrayList<>();
            if (attachments != null) {
        
                for (MultipartFile attachment : attachments) {
        
                    String fileName = save(moduleTypeEnum, sourceId, attachment);
                    if (fileName != null) {
        
                        result.add(fileName);
                    }
                }
            }
            return result;
        }
    
        public void delete(ModuleTypeEnum moduleTypeEnum, Long sourceId) {
        
            fileManagementService.delete(moduleTypeEnum, sourceId.toString());
        }
    
        public void delete(ModuleTypeEnum moduleTypeEnum, List<Long> sourceIdList) {
        
            if (DataStructureUtils.isValid(sourceIdList)) {
        
                for (Long sourceId : sourceIdList) {
        
                    delete(moduleTypeEnum, sourceId);
                }
            }
        }
    
        public String update(ModuleTypeEnum moduleTypeEnum, Long sourceId, MultipartFile attachment) {
        
            delete(moduleTypeEnum, sourceId);
            return save(moduleTypeEnum, sourceId, attachment);
        }
    
        public List<String> update(ModuleTypeEnum moduleTypeEnum, Long sourceId, MultipartFile[] attachments, List<String> delAttachmentNameList) {
        
            if (DataStructureUtils.isValid(delAttachmentNameList)) {
        
                for (String delAttachmentName : delAttachmentNameList) {
        
                    fileManagementService.delete(delAttachmentName);
                }
            }
            return save(moduleTypeEnum, sourceId, attachments);
        }
    
        public void delete(List<String> delAttachmentNameList) {
        
            if (DataStructureUtils.isValid(delAttachmentNameList)) {
        
                for (String delAttachmentName : delAttachmentNameList) {
        
                    fileManagementService.delete(delAttachmentName);
                }
            }
        }
    
    }

import io.minio.*;
    import io.minio.http.Method;
    import io.minio.messages.Item;
    import lombok.SneakyThrows;
    import lombok.extern.log4j.Log4j;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Service;
    import org.springframework.web.multipart.MultipartFile;
    
    import javax.annotation.PostConstruct;
    import java.io.*;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    
    @Log4j
    @Service
    public class MinIOFileManagementService {
        
    
        @Value("${url}")
        private String url;
        @Value("${accessKey}")
        private String accessKey;
        @Value("${secretKey}")
        private String secretKey;
        @Value("${bucket}")
        private String bucket;
    
        private MinioClient minioClient;
    
        @PostConstruct
        private void init() {
        
            try {
        
                minioClient = MinioClient.builder().endpoint(url).credentials(accessKey, secretKey).build();
                if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucket).build())) {
        
                    minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucket).build());
                }
            } catch (Exception ignore) {
        
                log.warn("Initialization MinIO client failed.");
            }
        }
    
        public List<String> listFile(String directory) {
        
            List<String> result = new ArrayList<>();
            try {
        
                for (Result<Item> next : minioClient.listObjects(ListObjectsArgs.builder().bucket(bucket).prefix(directory).build())) {
        
                    Item item = next.get();
                    result.add(item.objectName());
                }
            } catch (Exception e) {
        
                log.warn(e);
            }
            return result;
        }
    
        public List<String> listName(String prefix) {
        
            List<String> result = new ArrayList<>();
            try {
        
                for (Result<Item> next : minioClient.listObjects(ListObjectsArgs.builder().bucket(bucket).prefix(prefix).build())) {
        
                    Item item = next.get();
                    if (!item.isDir()) {
        
                        result.add(item.objectName());
                    }
                }
            } catch (Exception e) {
        
                log.warn(e);
            }
            return result;
        }
    
        public boolean isExists(String name) {
        
            return listName(name).contains(name);
        }
    
        public String getAccessUrl(String name) {
        
            if (isExists(name)) {
        
                try {
        
                    return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().bucket(bucket).method(Method.GET).object(name).build());
                } catch (Exception e) {
        
                    log.warn(e);
                }
            }
            return null;
        }
    
        public String getContent(String name) {
        
            if (isExists(name)) {
        
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(minioClient.getObject(GetObjectArgs.builder().bucket(bucket).object(name).build())))) {
        
                    return reader.lines().collect(Collectors.joining("\n"));
                } catch (Exception e) {
        
                    log.warn(e);
                }
            }
            return null;
        }
    
        public void download(OutputStream outputStream, String name) throws Exception {
        
            try (GetObjectResponse object = minioClient.getObject(GetObjectArgs.builder().bucket(bucket).object(name).build())) {
        
                int len;
                byte[] buffer = new byte[1024];
                while ((len = object.read(buffer)) > 0) {
        
                    outputStream.write(buffer, 0, len);
                }
            }
        }
    
        public void createDirectory(String directory) {
        
            try {
        
                minioClient.putObject(PutObjectArgs.builder().bucket(bucket).object(directory).stream(new ByteArrayInputStream(new byte[]{
        }), 0, -1).build());
            } catch (Exception e) {
        
                log.warn(e);
            }
        }
    
        public String storage(String name, MultipartFile file) {
        
            try {
        
                minioClient.putObject(PutObjectArgs.builder().bucket(bucket).object(name).contentType(file.getContentType())
                        .stream(file.getInputStream(), file.getSize(), file.getSize() > -1 ? -1 : 5 * 1024 * 1024).build());
            } catch (Exception e) {
        
                log.warn(e);
            }
            return name;
        }
    
        @SneakyThrows
        public String storage(String name, String content) {
        
            byte[] bytes = content.getBytes();
            minioClient.putObject(PutObjectArgs.builder().bucket(bucket).object(name).contentType("text/plain").stream(new ByteArrayInputStream(bytes), bytes.length, -1).build());
            return name;
        }
    
        public void delete(String name) {
        
            List<String> objectNameList = listName(name);
            if (DataStructureUtils.isValid(objectNameList)) {
        
                try {
        
                    for (String objectName : objectNameList) {
        
                        minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucket).object(objectName).build());
                    }
                } catch (Exception e) {
        
                    log.warn(e);
                }
            }
        }
    
        private String getObjectName(Object... keys) {
        
            return Arrays.stream(keys).map(Object::toString).collect(Collectors.joining("/"));
        }
    
        public List<String> listName(ModuleTypeEnum moduleType, String directory) {
        
            return listName(getObjectName(moduleType.name(), directory, ""));
        }
    
        public String getName(ModuleTypeEnum moduleType, String directory) {
        
            List<String> nameList = listName(moduleType, directory);
            return DataStructureUtils.isValid(nameList) ? nameList.get(0) : null;
        }
    
        public boolean isExists(ModuleTypeEnum moduleType, String directory, String fileName) {
        
            return isExists(getObjectName(moduleType.name(), directory, fileName));
        }
    
        public String getAccessUrl(ModuleTypeEnum moduleType, String directory, String fileName) {
        
            return getAccessUrl(getObjectName(moduleType.name(), directory, fileName));
        }
    
        public String getContent(ModuleTypeEnum moduleType, String directory) {
        
            return getContent(getName(moduleType, directory));
        }
    
        public String getContent(ModuleTypeEnum moduleType, String directory, String fileName) {
        
            return getContent(getObjectName(moduleType.name(), directory, fileName));
        }
    
        public String storage(ModuleTypeEnum moduleType, String directory, MultipartFile file) {
        
            String originalFileName = file.getOriginalFilename();
            if (isExists(moduleType, directory, originalFileName)) {
        
                originalFileName = GeniusFileUtils.modifyDuplicateFileName(originalFileName);
            }
            return storage(getObjectName(moduleType.name(), directory, originalFileName), file);
        }
    
        public String storage(ModuleTypeEnum moduleType, String directory, String fileName, MultipartFile file) {
        
            return storage(getObjectName(moduleType.name(), directory, fileName), file);
        }
    
        public String storage(ModuleTypeEnum moduleType, String directory, String fileName, String content) {
        
            return storage(getObjectName(moduleType.name(), directory, fileName), content);
        }
    
        public void delete(ModuleTypeEnum moduleType, String directory) {
        
            delete(getObjectName(moduleType.name(), directory, ""));
        }
    
        public void delete(ModuleTypeEnum moduleType, String directory, String fileName) {
        
            delete(getObjectName(moduleType.name(), directory, fileName));
        }
    
    }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAQ2hhcmdlOA_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/e8ef1cd48e054b9f87b8717802efb986.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQ2hhcmdlOA==,size_20,color_FFFFFF,t_70,g_se,x_16
[62bcacc5aad0404994b1edfcc8450cd7.png]: https://img-blog.csdnimg.cn/62bcacc5aad0404994b1edfcc8450cd7.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAQ2hhcmdlOA_size_11_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/606f0328f3ef487ba09b6e501cbd9d2e.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQ2hhcmdlOA==,size_11,color_FFFFFF,t_70,g_se,x_16
[46a7d76a391b40b5a0dc8a5fc6fcc260.png]: https://img-blog.csdnimg.cn/46a7d76a391b40b5a0dc8a5fc6fcc260.png
[c5aeb1a06ee148a0b3f100ead8a96699.png]: https://img-blog.csdnimg.cn/c5aeb1a06ee148a0b3f100ead8a96699.png
[670d85513bb34c77be09d5a95a78357a.png]: https://img-blog.csdnimg.cn/670d85513bb34c77be09d5a95a78357a.png
[9a9ad5b0fb824f4f9cc0d45a77988758.png]: https://img-blog.csdnimg.cn/9a9ad5b0fb824f4f9cc0d45a77988758.png