第2-3-3章文件处理策略-文件存储服务系统-nginx/fastDFS/minio/阿里云oss/七牛云oss

文章目录

- - 5.2 文件处理策略
  - - 5.2.1 FileStrategy
    - 5.2.2 AbstractFileStrategy
    - 5.2.3 LocalServiceImpl
    - 5.2.4 FastDfsServiceImpl
    - 5.2.5 AliServiceImpl
    - 5.2.6 MinioServiceImpl

5.2 文件处理策略

在开发fastDFS和minio实现类之前，需要提前安装部署好fastDFS和minio。搭建教程可参考前面的章节。

第2-1-2章传统方式安装FastDFS-附FastDFS常用命令
第2-1-3章 docker-compose安装FastDFS,实现文件存储服务
第2-1-5章 docker安装MinIO实现文件存储服务-springboot整合minio-minio全网最全的资料

全套代码及资料全部完整提供，点此处下载
由于我们当前的文件服务需要给客户端提供统一的服务接口，这就需要文件服务屏蔽底层的具体文件存储方式，所以对文件处理策略进行如下类和接口的设计：

在这里插入图片描述

5.2.1 FileStrategy

FileStrategy是文件处理策略顶层接口，是对文件处理的顶层抽象，具体代码如下：

package com.itheima.pinda.file.strategy;

import com.itheima.pinda.file.domain.FileDeleteDO;
import com.itheima.pinda.file.entity.File;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;
/**
 * 文件策略接口
 */
public interface FileStrategy {
    /**
     * 文件上传
     *
     * @param file 文件
     * @return 文件对象
     */
    File upload(MultipartFile file);

    /**
     * 删除文件
     *
     * @param list 列表
     */
    boolean delete(List<FileDeleteDO> list);
}

5.2.2 AbstractFileStrategy

AbstractFileStrategy是抽象文件策略处理类，实现了FileStrategy接口。

AbstractFileStrategy实现主要的文件上传、删除的处理流程，例如异常情况的判断，文件对象的封装等，但是真正上传的处理过程需要其子类来完成，因为不同的存储方案处理方式是不同的。

package com.itheima.pinda.file.strategy.impl;

import com.itheima.pinda.exception.BizException;
import com.itheima.pinda.file.domain.FileDeleteDO;
import com.itheima.pinda.file.entity.File;
import com.itheima.pinda.file.enumeration.IconType;
import com.itheima.pinda.file.properties.FileServerProperties;
import com.itheima.pinda.file.strategy.FileStrategy;
import com.itheima.pinda.file.utils.FileDataTypeUtil;
import com.itheima.pinda.utils.DateUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.multipart.MultipartFile;
import java.time.LocalDateTime;
import java.util.List;
import static com.itheima.pinda.exception.code.ExceptionCode.BASE_VALID_PARAM;

/**
 * 文件抽象策略处理类
 */
@Slf4j
public abstract class AbstractFileStrategy implements FileStrategy {
    private static final String FILE_SPLIT = ".";
    @Autowired
    protected FileServerProperties fileProperties;

    protected FileServerProperties.Properties properties;

    /**
     * 上传文件
     *
     * @param multipartFile
     * @return
     */
    @Override
    public File upload(MultipartFile multipartFile) {
        try {
            if (!multipartFile.getOriginalFilename().contains(FILE_SPLIT)) {
                throw BizException.wrap(BASE_VALID_PARAM.build("缺少后缀名"));
            }

            File file = File.builder()
                    .isDelete(false).
                submittedFileName(multipartFile.getOriginalFilename())
                    .contextType(multipartFile.getContentType())
                    .dataType(FileDataTypeUtil.getDataType(multipartFile.getContentType()))
                    .size(multipartFile.getSize())
                    .ext(FilenameUtils.getExtension(multipartFile.getOriginalFilename()))
                    .build();
            file.setIcon(IconType.getIcon(file.getExt()).getIcon());
            setDate(file);
            uploadFile(file, multipartFile);
            return file;
        } catch (Exception e) {
            log.error("e={}", e);
            throw BizException.wrap(BASE_VALID_PARAM.build("文件上传失败"));
        }
    }

    /**
     * 获取下载地址前缀
     */
    protected String getUriPrefix() {
        if (StringUtils.isNotEmpty(properties.getUriPrefix())) {
            return properties.getUriPrefix();
        } else {
            return properties.getEndpoint();
        }
    }

    /**
     * 具体类型执行上传操作
     *
     * @param file
     * @param multipartFile
     * @throws Exception
     */
    protected abstract void uploadFile(File file, MultipartFile multipartFile) throws Exception;

    private void setDate(File file) {
        LocalDateTime now = LocalDateTime.now();
        file.setCreateMonth(DateUtils.formatAsYearMonthEn(now))
                .setCreateWeek(DateUtils.formatAsYearWeekEn(now))
                .setCreateDay(DateUtils.formatAsDateEn(now));
    }

    @Override
    public boolean delete(List<FileDeleteDO> list) {
        if (list.isEmpty()) {
            return true;
        }
        boolean flag = false;
        for (FileDeleteDO file : list) {
            try {
                delete(file);
                flag = true;
            } catch (Exception e) {
                log.error("删除文件失败", e);
            }
        }
        return flag;
    }

    /**
     * 具体执行删除方法， 无需处理异常
     */
    protected abstract void delete(FileDeleteDO file);

}

5.2.3 LocalServiceImpl

LocalServiceImpl是AbstractFileStrategy的子类，负责处理存储策略为本地时的文件上传和删除操作。为了使程序能够动态选择具体的策略处理类，可以提供一个配置类，在配置类中定义LocalServiceImpl，具体代码如下：

package com.itheima.pinda.file.storage;

import cn.hutool.core.util.StrUtil;
import com.itheima.pinda.file.domain.FileDeleteDO;
import com.itheima.pinda.file.entity.File;
import com.itheima.pinda.file.properties.FileServerProperties;
import com.itheima.pinda.file.strategy.impl.AbstractFileStrategy;
import com.itheima.pinda.utils.StrPool;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import java.nio.file.Paths;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.UUID;
import static com.itheima.pinda.utils.DateUtils.DEFAULT_MONTH_FORMAT_SLASH;
/**
 * 本地上传配置
 */
@EnableConfigurationProperties(FileServerProperties.class)
@Configuration
@ConditionalOnProperty(name = "pinda.file.type", havingValue = "LOCAL")
@Slf4j
public class LocalAutoConfigure {
    /**
     * 本地文件策略处理类
     */
    @Service
    public class LocalServiceImpl extends AbstractFileStrategy {
        private void buildClient() {
            properties = fileProperties.getLocal();
        }

        /**
         * 上传文件
         * @param file
         * @param multipartFile
         * @throws Exception
         */
        @Override
        protected void uploadFile(File file, MultipartFile multipartFile) throws Exception {
            buildClient();
            //生成文件名
            String fileName = UUID.randomUUID().toString() + StrPool.DOT + file.getExt();
            //日期文件夹，例如：2020\04
            String relativePath = Paths.get(LocalDate.now().format(DateTimeFormatter.ofPattern(DEFAULT_MONTH_FORMAT_SLASH))).toString();
            // web服务器存放的绝对路径，例如：D:\\uploadFiles\\oss-file-service\\2020\\04
            String absolutePath = Paths.get(properties.getEndpoint(), properties.getBucketName(), relativePath).toString();
            //目标输出文件
            java.io.File outFile = new java.io.File(Paths.get(absolutePath, fileName).toString());
            //向目标文件写入数据
            org.apache.commons.io.FileUtils.writeByteArrayToFile(outFile, multipartFile.getBytes());

            String url = new StringBuilder(getUriPrefix())
                    .append(StrPool.SLASH)
                    .append(properties.getBucketName())
                    .append(StrPool.SLASH)
                    .append(relativePath)
                    .append(StrPool.SLASH)
                    .append(fileName)
                    .toString();
            //替换掉windows环境的\路径
            url = StrUtil.replace(url, "\\\\", StrPool.SLASH);
            url = StrUtil.replace(url, "\\", StrPool.SLASH);
            file.setUrl(url);
            file.setFilename(fileName);
            file.setRelativePath(relativePath);
        }

        /**
         * 文件删除
         * @param file
         */
        @Override
        protected void delete(FileDeleteDO file) {
            java.io.File ioFile = 
                new java.io.File(Paths.get(properties.getEndpoint(), 
                                           properties.getBucketName(), 
                                           file.getRelativePath(), 
                                           file.getFileName()).toString());
            
            org.apache.commons.io.FileUtils.deleteQuietly(ioFile);
        }
    }
}

通过上面的代码可以看到，在进行文件上传和文件删除时都会使用到配置文件中的配置项，关于本地文件处理策略的配置如下：

pinda:
  mysql:
    database: pd_files
  nginx:
    ip: ${spring.cloud.client.ip-address} #正式环境要将该ip设置成nginx对应的公网ip
    port: 10000   #正式环境需要将该ip设置成nginx对应的公网端口
  file:
    type: LOCAL
    local:
      uriPrefix: http://${pinda.nginx.ip}:${pinda.nginx.port}
      bucket-name: oss-file-service
      endpoint: D:\soft\nginx-1.23.0\uploadFiles

5.2.4 FastDfsServiceImpl

FastDfsServiceImpl是AbstractFileStrategy的子类，负责处理存储策略为FastDFS时的文件上传和删除操作。为了使程序能够动态选择具体的策略处理类，可以提供一个配置类，在配置类中定义FastDfsServiceImpl，具体代码如下：

package com.itheima.pinda.file.storage;

import com.github.tobato.fastdfs.domain.fdfs.StorePath;
import com.github.tobato.fastdfs.service.FastFileStorageClient;
import com.itheima.pinda.file.domain.FileDeleteDO;
import com.itheima.pinda.file.entity.File;
import com.itheima.pinda.file.properties.FileServerProperties;
import com.itheima.pinda.file.strategy.impl.AbstractFileStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

/**
 * FastDFS配置
 */
@EnableConfigurationProperties(FileServerProperties.class)
@Configuration
@Slf4j
@ConditionalOnProperty(name = "pinda.file.type", havingValue = "FAST_DFS")
public class FastDfsAutoConfigure {
    /**
     * FastDFS文件策略处理类
     */
    @Service
    public class FastDfsServiceImpl extends AbstractFileStrategy {
        @Autowired
        private FastFileStorageClient storageClient; //操作FastDFS的客户端

        /**
         * 上传文件
         * @param file
         * @param multipartFile
         * @throws Exception
         */
        @Override
        protected void uploadFile(File file, MultipartFile multipartFile) 
            throws Exception {
            //调用FastDFS客户端将文件上传到FastDFS
            StorePath storePath = 
                storageClient.uploadFile(multipartFile.getInputStream(), 
                                         multipartFile.getSize(), 
                                         file.getExt(), 
                                         null);
            
            file.setUrl(fileProperties.getUriPrefix() + 
                        storePath.getFullPath());
            file.setGroup(storePath.getGroup());
            file.setPath(storePath.getPath());
        }

        /**
         * 文件删除
         * @param file
         */
        @Override
        protected void delete(FileDeleteDO file) {
            //调用FastDFS客户端删除文件
            storageClient.deleteFile(file.getGroup(), file.getPath());
        }
    }
}

通过上面代码可以看到要使用FastDFS提供的客户端FastFileStorageClient来实现文件的上传和删除，这就需要在文件服务对应的配置文件中进行如下配置：

pinda:
  mysql:
    database: pd_files
  nginx:
    ip: ${spring.cloud.client.ip-address} #正式环境要将该ip设置成nginx对应的公网ip
    port: 10000  #正式环境需要将该ip设置成nginx对应的公网端口
  file:
    type: FAST_DFS  
    uriPrefix: http://172.17.0.115:8188/ #存储类型为FAST_DFS时使用
#FAST_DFS配置
fdfs:
  soTimeout: 1500
  connectTimeout: 600
  thumb-image:
    width: 150
    height: 150
  tracker-list:
    - 172.17.0.115:22122
  pool:
    #从池中借出的对象的最大数目
    max-total: 153
    max-wait-millis: 102
    jmx-name-base: 1
    jmx-name-prefix: 1

5.2.5 AliServiceImpl

AliServiceImpl是AbstractFileStrategy的子类，负责处理存储策略为阿里云OSS时的文件上传和删除操作。为了使程序能够动态选择具体的策略处理类，可以提供一个配置类，在配置类中定义AliServiceImpl，可以参照阿里云OSS官方提供的示例代码(https://help.aliyun.com/document_detail/32011.html?spm=a2c4g.11186623.6.769.652763282djHGw)进行文件的上传和删除。

具体代码如下：

package com.itheima.pinda.file.storage;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.model.*;
import com.itheima.pinda.file.domain.FileDeleteDO;
import com.itheima.pinda.file.entity.File;
import com.itheima.pinda.file.properties.FileServerProperties;
import com.itheima.pinda.file.strategy.impl.AbstractFileStrategy;
import com.itheima.pinda.utils.StrPool;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import java.nio.file.Paths;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.UUID;
import static com.itheima.pinda.utils.DateUtils.DEFAULT_MONTH_FORMAT_SLASH;

/**
 * 阿里云OSS配置
 */
@EnableConfigurationProperties(FileServerProperties.class)
@Configuration
@Slf4j
@ConditionalOnProperty(name = "pinda.file.type", havingValue = "ALI")
public class AliOssAutoConfigure {
    /**
     * 阿里云OSS文件策略处理类
     */
    @Service
    public class AliServiceImpl extends AbstractFileStrategy {
        /**
         * 构建阿里云OSS客户端
         * @return
         */
        private OSS buildClient() {
            properties = fileProperties.getAli();
            return new OSSClientBuilder().
                                    build(properties.getEndpoint(),
                                            properties.getAccessKeyId(),
                                            properties.getAccessKeySecret());
        }

        protected String getUriPrefix() {
            if (StringUtils.isNotEmpty(properties.getUriPrefix())) {
                return properties.getUriPrefix();
            } else {
                String prefix = properties.
                    			getEndpoint().
                    			contains("https://") ? "https://" : "http://";
                return prefix + properties.getBucketName() + "." + 
                    properties.getEndpoint().replaceFirst(prefix, "");
            }
        }

        /**
         * 上传文件
         * @param file
         * @param multipartFile
         * @throws Exception
         */
        @Override
        protected void uploadFile(File file, MultipartFile multipartFile) 
            throws Exception {
            OSS client = buildClient();
            //获得OSS空间名称
            String bucketName = properties.getBucketName();
            if (!client.doesBucketExist(bucketName)) {
                //创建存储空间
                client.createBucket(bucketName);
            }

            //生成文件名
            String fileName = UUID.randomUUID().toString() + 
                				StrPool.DOT + 
                				file.getExt();
            //日期文件夹，例如：2020\04
            String relativePath = 
                Paths.get(LocalDate.now().
                          format(DateTimeFormatter.
                 ofPattern(DEFAULT_MONTH_FORMAT_SLASH))).
                toString();
            // web服务器存放的相对路径
            String relativeFileName = relativePath + StrPool.SLASH + fileName;
            relativeFileName = StrUtil.replace(relativeFileName, "\\\\", 
                                               StrPool.SLASH);
            relativeFileName = StrUtil.replace(relativeFileName, "\\", 
                                               StrPool.SLASH);
            //对象元数据
            ObjectMetadata metadata = new ObjectMetadata();
            metadata.setContentDisposition("attachment;fileName=" + 
                                           file.getSubmittedFileName());
            metadata.setContentType(file.getContextType());

            //上传请求对象
            PutObjectRequest request = 
                new PutObjectRequest(bucketName, relativeFileName, 
                                     multipartFile.getInputStream(), 
                                     metadata);
            //上传文件到阿里云OSS空间
            PutObjectResult result = client.putObject(request);

            log.info("result={}", JSONObject.toJSONString(result));

            String url = getUriPrefix() + StrPool.SLASH + relativeFileName;
            url = StrUtil.replace(url, "\\\\", StrPool.SLASH);
            url = StrUtil.replace(url, "\\", StrPool.SLASH);
            // 写入文件表
            file.setUrl(url);
            file.setFilename(fileName);
            file.setRelativePath(relativePath);

            file.setGroup(result.getETag());
            file.setPath(result.getRequestId());

            //关闭阿里云OSS客户端
            client.shutdown();
        }

        /**
         * 文件删除
         * @param file
         */
        @Override
        protected void delete(FileDeleteDO file) {
            OSS client = buildClient();
            //获得OSS空间名称
            String bucketName = properties.getBucketName();
            // 删除文件
            client.deleteObject(bucketName, file.getRelativePath() + 
                                StrPool.SLASH + file.getFileName());
            //关闭阿里云OSS客户端
            client.shutdown();
        }
    }
}

通过上面代码可以看到要使用阿里云OSS提供的客户端OSS来实现文件的上传和删除，这就需要在文件服务对应的配置文件中进行如下配置：

pinda:
  mysql:
    database: pd_files
  nginx:
    ip: ${spring.cloud.client.ip-address} #正式环境要将该ip设置成nginx对应的公网ip
    port: 10000  #正式环境需要将该ip设置成nginx对应的公网端口
  file:
    type: ALI
    ali:
      # 请填写自己的阿里云存储配置
      bucket-name: bladex-loan
      endpoint: http://oss-cn-qingdao.aliyuncs.com
      access-key-id: LTAI4FhtimFAiz6iLGJSiJui  
      access-key-secret: SsU15qaPwpF1x5xMqwc0XzGuY92fnc

5.2.6 MinioServiceImpl

MinioServiceImpl是AbstractFileStrategy的子类，负责处理存储策略为Minio时的文件上传和删除操作。为了使程序能够动态选择具体的策略处理类，可以提供一个配置类，在配置类中定义MinioServiceImpl，具体代码如下：

package com.itheima.pinda.file.storage;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.itheima.pinda.base.R;
import com.itheima.pinda.file.domain.FileDeleteDO;
import com.itheima.pinda.file.dto.BucketPolicyConfigDTO;
import com.itheima.pinda.file.dto.chunk.FileChunksMergeDTO;
import com.itheima.pinda.file.entity.File;
import com.itheima.pinda.file.properties.FileServerProperties;
import com.itheima.pinda.file.strategy.impl.AbstractFileChunkStrategy;
import com.itheima.pinda.file.strategy.impl.AbstractFileStrategy;
import com.itheima.pinda.utils.DateUtils;
import com.itheima.pinda.utils.StrPool;
import io.minio.BucketExistsArgs;
import io.minio.ComposeObjectArgs;
import io.minio.ComposeSource;
import io.minio.GetObjectArgs;
import io.minio.GetPresignedObjectUrlArgs;
import io.minio.ListObjectsArgs;
import io.minio.MakeBucketArgs;
import io.minio.MinioClient;
import io.minio.ObjectWriteArgs;
import io.minio.PutObjectArgs;
import io.minio.RemoveObjectArgs;
import io.minio.Result;
import io.minio.SetBucketPolicyArgs;
import io.minio.StatObjectArgs;
import io.minio.StatObjectResponse;
import io.minio.http.Method;
import io.minio.messages.Item;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.Nullable;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.nio.ByteBuffer;
import java.nio.file.Paths;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.Vector;
import java.util.concurrent.TimeUnit;

/**
 * @Author: 郭浩伟 qq:912161367
 * @Date: 2022/11/6 0006 19:44
 * @Description: minio
 */
@Configuration
@Slf4j
@EnableConfigurationProperties(FileServerProperties.class)
@ConditionalOnProperty(name = "pinda.file.type", havingValue = "MINIO")
public class MinioAutoConfigure {

    private MinioClient minioClient;

    private String bucketName;
    private String endpoint;
    private static final int DEFAULT_EXPIRY_TIME = 7 * 24 * 3600;

    /**
     * 构建minioClient
     *
     * @return
     */
    private void buildClient(FileServerProperties fileProperties) {
        //加载配置文件相关信息
        FileServerProperties.Properties properties = fileProperties.getMinio();
        endpoint = properties.getEndpoint();
        String accessKey = properties.getAccessKey();
        String secretKey = properties.getSecretKey();
        this.bucketName = properties.getBucketName();
        //创建一个MinIO的Java客户端
        minioClient = MinioClient.builder()
                .endpoint(endpoint)
                .credentials(accessKey, secretKey)
                .build();
    }

    /**
     * 本地文件策略处理类
     */
    @Service
    public class MinioServiceImpl extends AbstractFileStrategy {
        /**
         * 文件上传抽象方法，需要由当前类的子类来实现
         *
         * @param file
         * @param multipartFile
         * @return
         */
        @Override
        public void uploadFile(File file, MultipartFile multipartFile) throws Exception {
            MinioAutoConfigure.this.buildClient(fileProperties);
            //生成文件名 此处并未用原始文件名multipartFile.getOriginalFilename()，因为同名文件会覆盖
            String fileName = UUID.randomUUID() + StrPool.DOT + file.getExt();

            String objectName = doReName(fileName, file);

            MinioAutoConfigure.this.putObject(bucketName, multipartFile, objectName);
            log.info("文件上传成功!");
        }


        /**
         * 文件删除抽象方法，需要当前类的子类来实现
         *
         * @param fileDeleteDO
         */
        @Override
        public void delete(FileDeleteDO fileDeleteDO) throws Exception {
            MinioAutoConfigure.this.buildClient(fileProperties);
            // 设置存储对象名称
            String objectName = Paths.get(fileDeleteDO.getRelativePath(), fileDeleteDO.getFileName()).toString();
            // 替换掉windows环境的\路径
            objectName = StrUtil.replace(objectName, "\\\\", StrPool.SLASH);
            objectName = StrUtil.replace(objectName, "\\", StrPool.SLASH);
            // 执行删除操作
            if (bucketExists(bucketName)) {
                minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
            }
        }
    }
 }

通过上面的代码可以看到，在进行文件上传和文件删除时都会使用到配置文件中的配置项，关于Minio文件处理策略的配置如下：

pinda:
  mysql:
    database: pd_files
  nginx:
    ip: ${spring.cloud.client.ip-address} #正式环境要将该ip设置成nginx对应的公网ip
    port: 10000   #正式环境需要将该ip设置成nginx对应的公网端口
  file:
    type: MINIO
    minio:
      endpoint: http://192.168.86.101:9000 #MinIO服务所在地址
      bucketName: file #存储桶名称
      accessKey: admin #访问的key
      secretKey: admin123456 #访问的秘钥