minio 总结

最近项目遇到需要频繁从minio上下载数据,下载的都是小文件, 瓦片数据, 遇到大数据量下载后文件下载失败的情况, 并且需要保证上传文件还能保证相对路径,后期下载的时候可以保证按照路径下载,复制. 大文件分片上传也是常见操作了.

下载

1. 授权链接下载
2. 文件流下载

文件上传

1. 授权链接上传

这里不在叙述

2. 分片上传

   1. 定义文件分片大小，按照分片大小定义每个分片的上传链接，以及uploadId
   2. 前端分片裁切文件，上传完成后请求合并（这里需要保存minio上传完成后的etag）
   3. 后端请求minio完成文件合并

3. 文件夹上传

文件夹上传的基于前端需要读取文件夹的目录结构，保持原有的目录结构生成文件的目录结构，为每个文件生成授权链接上传，前端按照对应的文件上传完成即可， 这里用我实现demo演示：

上传
    @Test
    public void testGenUploadUrl() {
        String root = "xs";
        List<FileNode> fileNodes = FileNode.buildFileTree(path);
        log.info("fileNodes:{}", fileNodes);

        fileNodes.stream().forEach(fileNode -> {
            if ("file".equals(fileNode.getType())) {
                // 使用标准化的路径格式生成上传路径
               upload(fileNode,root);
            }else {
                List<FileNode> children = fileNode.getChildren();
                children.stream().forEach(child -> {
                    upload(child,root);
                });
//                upload(fileNode,root);
            }
        });
    }

// fileNode 
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class FileNode {

    public final static String FILE = "file";
    public final static String DIRECTORY = "directory";

    private String name;
    private String type;
    private String rootPath;
    /**
     * 父路径 内部使用前端不用传递
     */
    private String parentPath;
    private String path;
    private String uploadUrl; // file 节点才有
    private Integer size;   // 文件大小

    private List<FileNode> children;


    public static List<FileNode> buildFileTree(List<FileNode> fileNodes) {

        // 干掉上级路径
        Map<String, List<FileNode>> map = fileNodes.stream()
            .map(node -> {
                node.setParentPath(initParentPath(node.path));
                node.setName(initName(node.path));
                return node;
            })
            .collect(Collectors.groupingBy(FileNode::getParentPath));


        fileNodes = map.keySet().stream().map(
            key -> {
                List<FileNode> children = map.get(key);
                FileNode rootNode = new FileNode();
                rootNode.name = key.substring(key.lastIndexOf("/") + 1);
                rootNode.type = DIRECTORY;
                rootNode.path = key;
                rootNode.children = children;
                return rootNode;
            }
        ).collect(Collectors.toList());
        if (fileNodes.size()==1){
            return fileNodes;
        }else {
            return  buildFileTree(fileNodes);
        }

    }

    // 辅助方法：获取给定路径的父路径
    private  static String initParentPath(String path) {
        int lastSlashIndex = path.lastIndexOf("/");
        if (lastSlashIndex <= 0) {
            return ""; // 返回空字符串表示没有父路径（即为根路径）
        }
        return path.substring(0, lastSlashIndex); // 返回父路径
    }

    private  static String initName(String path) {
        return path.substring(path.lastIndexOf("/") + 1);
    }


    public static List<FileNode> buildFileTree(String directoryPath) {
        return buildFileTree(null, directoryPath);
    }

    public static List<FileNode> buildFileTree(String rootPath, String directoryPath) {
        List<FileNode> rootNodes = new ArrayList<>();
        File directory = new File(directoryPath);
        if (rootPath == null) {
            rootPath = directory.getAbsolutePath();
        }

        if (!directory.exists() || !directory.isDirectory()) {
            return rootNodes;
        }

        File[] files = directory.listFiles();

        if (files != null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    List<FileNode> fileNodes = buildFileTree(rootPath, file.getAbsolutePath());
                    if (fileNodes != null) {
                        FileNode fileNode = new FileNode();
                        fileNode.name = file.getName();
                        fileNode.type = DIRECTORY;
                        fileNode.path = file.getAbsolutePath().replace(rootPath, "");
                        fileNode.children = fileNodes;
                        rootNodes.add(fileNode);
                    }
                } else {
                    FileNode fileNode = new FileNode();
                    fileNode.name = file.getName();
                    fileNode.path = file.getAbsolutePath().replace(rootPath, "");
                    fileNode.type = DIRECTORY;
                    // 对于文件节点，设置uploadUrl为null或根据需要设置
                    fileNode.uploadUrl = null;
                    fileNode.children = null;
                    rootNodes.add(fileNode);
                }
            }
        }

        return rootNodes;
    }


}

具体实现看后文

 /**
     * 服务商
     */
    private final String configKey;

    /**
     * 配置属性
     */
    private final OssProperties properties;

    /**
     * Amazon S3 异步客户端
     */
    private final S3AsyncClient client;

    /**
     * 用于管理 S3 数据传输的高级工具
     */
    private final S3TransferManager transferManager;

    /**
     * AWS S3 预签名 URL 的生成器
     */
    private final S3Presigner presigner;


    private static final String UPLOAD_KEY = "upload_file:";

    /**
     * 构造方法
     *
     * @param configKey     配置键
     * @param ossProperties Oss配置属性
     */
    public OssClient(String configKey, OssProperties ossProperties) {
        this.configKey = configKey;
        this.properties = ossProperties;
        try {
            // 创建 AWS 认证信息
            StaticCredentialsProvider credentialsProvider = StaticCredentialsProvider.create(
                AwsBasicCredentials.create(properties.getAccessKey(), properties.getSecretKey()));

            // MinIO 使用 HTTPS 限制使用域名访问，站点填域名。需要启用路径样式访问
            boolean isStyle = !StringUtils.containsAny(properties.getEndpoint(), OssConstant.CLOUD_SERVICE);

            // 创建AWS基于 CRT 的 S3 客户端
            this.client = S3AsyncClient.crtBuilder()
                .credentialsProvider(credentialsProvider)
                .endpointOverride(URI.create(getEndpoint()))
                .region(of())
                .targetThroughputInGbps(20.0)
                .minimumPartSizeInBytes(10 * 1025 * 1024L)
                .checksumValidationEnabled(false)
                .forcePathStyle(isStyle)
                .httpConfiguration(S3CrtHttpConfiguration.builder()
                    .connectionTimeout(Duration.ofSeconds(60)) // 设置连接超时
                    .build())
                .build();

            //AWS基于 CRT 的 S3 AsyncClient 实例用作 S3 传输管理器的底层客户端
            this.transferManager = S3TransferManager.builder().s3Client(this.client).build();

            // 创建 S3 配置对象
            S3Configuration config = S3Configuration.builder().chunkedEncodingEnabled(false)
                .pathStyleAccessEnabled(isStyle).build();

            // 创建 预签名 URL 的生成器 实例，用于生成 S3 预签名 URL
            this.presigner = S3Presigner.builder()
                .region(of())
                .credentialsProvider(credentialsProvider)
                .endpointOverride(URI.create(getDomain()))
                .serviceConfiguration(config)
                .build();

            // 创建存储桶
            createBucket();
        } catch (Exception e) {
            if (e instanceof OssException) {
                throw e;
            }
            throw new OssException("配置错误! 请检查系统配置:[" + e.getMessage() + "]");
        }
    }

    /**
     * 同步创建存储桶
     * 如果存储桶不存在，会进行创建；如果存储桶存在，不执行任何操作
     *
     * @throws OssException 当创建存储桶时发生异常时抛出
     */
    public void createBucket() {
        String bucketName = properties.getBucketName();
        try {
            // 尝试获取存储桶的信息
            client.headBucket(
                    x -> x.bucket(bucketName)
                        .build())
                .join();
        } catch (Exception ex) {
            if (ex.getCause() instanceof NoSuchBucketException) {
                try {
                    // 存储桶不存在，尝试创建存储桶
                    client.createBucket(
                            x -> x.bucket(bucketName))
                        .join();

                    // 设置存储桶的访问策略（Bucket Policy）
                    client.putBucketPolicy(
                            x -> x.bucket(bucketName)
                                .policy(getPolicy(bucketName, getAccessPolicy().getPolicyType())))
                        .join();
                } catch (S3Exception e) {
                    // 存储桶创建或策略设置失败
                    throw new OssException("创建Bucket失败, 请核对配置信息:[" + e.getMessage() + "]");
                }
            } else {
                throw new OssException("判断Bucket是否存在失败，请核对配置信息:[" + ex.getMessage() + "]");
            }
        }
    }

    /**
     * 上传文件到 Amazon S3，并返回上传结果
     *
     * @param filePath    本地文件路径
     * @param key         在 Amazon S3 中的对象键
     * @param md5Digest   本地文件的 MD5 哈希值（可选）
     * @param contentType 文件内容类型
     * @return UploadResult 包含上传后的文件信息
     * @throws OssException 如果上传失败，抛出自定义异常
     */
    public UploadResult upload(Path filePath, String key, String md5Digest, String contentType) {
        try {
            // 构建上传请求对象
            FileUpload fileUpload = transferManager.uploadFile(
                x -> x.putObjectRequest(
                        y -> y.bucket(properties.getBucketName())
                            .key(key)
                            .contentMD5(StringUtils.isNotEmpty(md5Digest) ? md5Digest : null)
                            .contentType(contentType)
                            // 用于设置对象的访问控制列表（ACL）。不同云厂商对ACL的支持和实现方式有所不同，
                            // 因此根据具体的云服务提供商，你可能需要进行不同的配置（自行开启，阿里云有acl权限配置，腾讯云没有acl权限配置）
                            //.acl(getAccessPolicy().getObjectCannedACL())
                            .build())
                    .addTransferListener(LoggingTransferListener.create())
                    .source(filePath).build());

            // 等待上传完成并获取上传结果
            CompletedFileUpload uploadResult = fileUpload.completionFuture().join();
            String eTag = uploadResult.response().eTag();

            // 提取上传结果中的 ETag，并构建一个自定义的 UploadResult 对象
            return UploadResult.builder().url(getUrl() + StringUtils.SLASH + key).filename(key).eTag(eTag).build();
        } catch (Exception e) {
            // 捕获异常并抛出自定义异常
            throw new OssException("上传文件失败，请检查配置信息:[" + e.getMessage() + "]");
        } finally {
            // 无论上传是否成功，最终都会删除临时文件
            FileUtils.del(filePath);
        }
    }

    /**
     * 上传 InputStream 到 Amazon S3
     *
     * @param inputStream 要上传的输入流
     * @param key         在 Amazon S3 中的对象键
     * @param length      输入流的长度
     * @param contentType 文件内容类型
     * @return UploadResult 包含上传后的文件信息
     * @throws OssException 如果上传失败，抛出自定义异常
     */
    public UploadResult upload(InputStream inputStream, String key, Long length, String contentType) {
        // 如果输入流不是 ByteArrayInputStream，则将其读取为字节数组再创建 ByteArrayInputStream
        if (!(inputStream instanceof ByteArrayInputStream)) {
            inputStream = new ByteArrayInputStream(IoUtil.readBytes(inputStream));
        }
        try {
            // 创建异步请求体（length如果为空会报错）
            BlockingInputStreamAsyncRequestBody body = BlockingInputStreamAsyncRequestBody.builder()
                .contentLength(length)
                .subscribeTimeout(Duration.ofSeconds(30))
                .build();

            // 使用 transferManager 进行上传
            Upload upload = transferManager.upload(
                x -> x.requestBody(body)
                    .putObjectRequest(
                        y -> y.bucket(properties.getBucketName())
                            .key(key)
                            .contentType(contentType)
                            // 用于设置对象的访问控制列表（ACL）。不同云厂商对ACL的支持和实现方式有所不同，
                            // 因此根据具体的云服务提供商，你可能需要进行不同的配置（自行开启，阿里云有acl权限配置，腾讯云没有acl权限配置）
                            //.acl(getAccessPolicy().getObjectCannedACL())
                            .build())
                    .build());

            // 将输入流写入请求体
            body.writeInputStream(inputStream);

            // 等待文件上传操作完成
            CompletedUpload uploadResult = upload.completionFuture().join();
            String eTag = uploadResult.response().eTag();

            // 提取上传结果中的 ETag，并构建一个自定义的 UploadResult 对象
            return UploadResult.builder().url(getUrl() + StringUtils.SLASH + key).filename(key).eTag(eTag).build();
        } catch (Exception e) {
            throw new OssException("上传文件失败，请检查配置信息:[" + e.getMessage() + "]");
        }
    }

    /**
     * 生成用于上传文件的预签名URL
     *
     * @param objectKey  上传的目标对象键（即文件在S3中的路径）
     * @param expiration 预签名URL的有效时间（单位：秒）
     * @return 返回预签名的上传URL
     */
    public UploadResult generatePreSignedUploadUrl(String objectKey, Integer expiration, String contentType) {
        try {
            // 使用 S3Presigner 生成预签名的上传 URL
            URL url = presigner.presignPutObject(
                x -> x.signatureDuration(Duration.ofSeconds(expiration))
                    .putObjectRequest(
                        y -> y.bucket(properties.getBucketName())
                            .key(objectKey)
                            .contentType(contentType)
                            .build()
                    )
                    .build()
            ).url();


            return UploadResult.builder().url(url.toString()).filename(objectKey).build();
        } catch (Exception e) {
            throw new OssException("生成预签名上传链接失败，请检查配置信息:[" + e.getMessage() + "]");
        }
    }

    /**
     * 下载文件从 Amazon S3 到临时目录
     *
     * @param path 文件在 Amazon S3 中的对象键
     * @return 下载后的文件在本地的临时路径
     * @throws OssException 如果下载失败，抛出自定义异常
     */
    public Path fileDownload(String path) {
        // 构建临时文件
        Path tempFilePath = FileUtils.createTempFile().toPath();
        // 使用 S3TransferManager 下载文件
        FileDownload downloadFile = transferManager.downloadFile(
            x -> x.getObjectRequest(
                    y -> y.bucket(properties.getBucketName())
                        .key(removeBaseUrl(path))
                        .build())
                .addTransferListener(LoggingTransferListener.create())
                .destination(tempFilePath)
                .build());
        // 等待文件下载操作完成
        downloadFile.completionFuture().join();
        return tempFilePath;
    }

    /**
     * 下载文件从 Amazon S3 到 输出流
     *
     * @param key 文件在 Amazon S3 中的对象键
     * @param out 输出流
     * @return 输出流中写入的字节数（长度）
     * @throws OssException 如果下载失败，抛出自定义异常
     */
    public long download(String key, OutputStream out) {
        try {
            // 构建下载请求
            DownloadRequest<ResponseInputStream<GetObjectResponse>> downloadRequest = DownloadRequest.builder()
                // 文件对象
                .getObjectRequest(y -> y.bucket(properties.getBucketName())
                    .key(key)
                    .build())
                .addTransferListener(LoggingTransferListener.create())
                // 使用订阅转换器
                .responseTransformer(AsyncResponseTransformer.toBlockingInputStream())
                .build();
            // 使用 S3TransferManager 下载文件
            Download<ResponseInputStream<GetObjectResponse>> responseFuture = transferManager.download(downloadRequest);
            // 输出到流中
            try (ResponseInputStream<GetObjectResponse> responseStream = responseFuture.completionFuture().join().result()) { // auto-closeable stream
                return responseStream.transferTo(out); // 阻塞调用线程 blocks the calling thread
            }
        } catch (Exception e) {
            throw new OssException("文件下载失败，错误信息:[" + e.getMessage() + "]");
        }
    }

    /**
     * 删除云存储服务中指定路径下文件
     *
     * @param path 指定路径
     */
    public void delete(String path) {
        try {
            client.deleteObject(
                x -> x.bucket(properties.getBucketName())
                    .key(removeBaseUrl(path))
                    .build());
        } catch (Exception e) {
            throw new OssException("删除文件失败，请检查配置信息:[" + e.getMessage() + "]");
        }
    }

    /**
     * 获取私有URL链接
     *
     * @param objectKey 对象KEY
     * @param second    授权时间
     */
    public String getPrivateUrl(String objectKey, Integer second) {
        // 使用 AWS S3 预签名 URL 的生成器 获取对象的预签名 URL
        URL url = presigner.presignGetObject(
                x -> x.signatureDuration(Duration.ofSeconds(second))
                    .getObjectRequest(
                        y -> y.bucket(properties.getBucketName())
                            .key(objectKey)
                            .build())
                    .build())
            .url();
        return url.toString();
    }

    /**
     * 上传 byte[] 数据到 Amazon S3，使用指定的后缀构造对象键。
     *
     * @param data   要上传的 byte[] 数据
     * @param suffix 对象键的后缀
     * @return UploadResult 包含上传后的文件信息
     * @throws OssException 如果上传失败，抛出自定义异常
     */
    public UploadResult uploadSuffix(byte[] data, String suffix, String contentType) {
        return upload(new ByteArrayInputStream(data), getPath(properties.getPrefix(), suffix), Long.valueOf(data.length), contentType);
    }

    /**
     * 上传 InputStream 到 Amazon S3，使用指定的后缀构造对象键。
     *
     * @param inputStream 要上传的输入流
     * @param suffix      对象键的后缀
     * @param length      输入流的长度
     * @return UploadResult 包含上传后的文件信息
     * @throws OssException 如果上传失败，抛出自定义异常
     */
    public UploadResult uploadSuffix(InputStream inputStream, String suffix, Long length, String contentType) {
        return upload(inputStream, getPath(properties.getPrefix(), suffix), length, contentType);
    }

    /**
     * 上传文件到 Amazon S3，使用指定的后缀构造对象键
     *
     * @param file   要上传的文件
     * @param suffix 对象键的后缀
     * @return UploadResult 包含上传后的文件信息
     * @throws OssException 如果上传失败，抛出自定义异常
     */
    public UploadResult uploadSuffix(File file, String suffix) {
        return upload(file.toPath(), getPath(properties.getPrefix(), suffix), null, FileUtils.getMimeType(suffix));
    }


    /**
     * 上传 byte[] 数据到 Amazon S3，使用指定的后缀构造对象键。
     *
     * @param data 要上传的 byte[] 数据
     * @param path 路径
     * @return UploadResult 包含上传后的文件信息
     * @throws OssException 如果上传失败，抛出自定义异常
     */
    public UploadResult uploadPath(byte[] data, String path, String contentType) {
        return upload(new ByteArrayInputStream(data), path, Long.valueOf(data.length), contentType);
    }

    /**
     * 上传 InputStream 到 Amazon S3，使用指定的后缀构造对象键。
     *
     * @param inputStream 要上传的输入流
     * @param path        对象键的后缀
     * @param length      输入流的长度
     * @return UploadResult 包含上传后的文件信息
     * @throws OssException 如果上传失败，抛出自定义异常
     */
    public UploadResult uploadPath(InputStream inputStream, String path, Long length, String contentType) {
        return upload(inputStream, path, length, contentType);
    }

    /**
     * 上传文件到 Amazon S3，使用指定的后缀构造对象键
     *
     * @param file 要上传的文件
     * @param path 目标文件
     * @return UploadResult 包含上传后的文件信息
     * @throws OssException 如果上传失败，抛出自定义异常
     */
    public UploadResult uploadPath(File file, String path, String contentType) {
        return upload(file.toPath(), path, null, contentType);
    }


    /**
     * 上传文件到 Amazon S3，使用指定的后缀构造对象键
     *
     * @param fileName 要上传的文件
     * @param suffix   文就按后缀
     * @return UploadResult 包含上传后的文件信息
     */
    public UploadResult uploadUrl(String fileName, String suffix, Boolean resetPath) {
        String path;
        if (resetPath) {
            path = getPath(properties.getPrefix(), suffix);
        } else {
            path = fileName;
        }
        // 创建生成预签名 URL 的请求

        PutObjectPresignRequest putObjectPresignRequest = PutObjectPresignRequest.builder()
            // 签名有效期为 10 分钟
            .signatureDuration(Duration.ofHours(2))
            .putObjectRequest(b -> b.bucket(properties.getBucketName()).key(path)
                .contentType(getContentType(suffix))
            )
            .build();
        PresignedPutObjectRequest presignedPutObjectRequest = presigner.presignPutObject(putObjectPresignRequest);
        URL url = presignedPutObjectRequest.url();

        return UploadResult.builder().url(url.toString()).filename(fileName).build();

    }

    /**
     * 根据文件后缀名获取Content-Type
     *
     * @param extension 文件后缀名
     * @return Content-Type
     */
    private static String getContentType(String extension) {
        if (extension.contains("jpg") || extension.contains("jpeg")) {
            return "image/jpeg";
        } else if (extension.contains("gif")) {
            return "image/gif";
        } else if (extension.contains("png")) {
            return "image/png";
        } else if (extension.contains("pdf")) {
            return "application/pdf";
        } else if (extension.contains("doc")) {
            return "application/msword";
        } else if (extension.contains("docx")) {
            return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
        } else if (extension.contains("xls") || extension.contains("xlsx")) {
            return "application/vnd.ms-excel";
        } else if (extension.contains("txt")) {
            return "text/plain";
        } else if (extension.contains("json")) {
            return "application/json";
        } else {
            return "application/octet-stream";
        }
    }

    /**
     * 初始化分片上传
     *
     * @param po 文件信息
     * @return 分片上传信息
     */
    public PartUploadVo initUpload(InitFileBo po) {
        String fileName = po.getFileName();
        Integer totalSize = po.getSize();
        int chunkSize = po.getChunkSize();

        // 计算分片数量
        int totalChunks = (int) Math.ceil((double) totalSize / chunkSize);
        // 获取文件后缀
        String suffix = StringUtils.substring(fileName, fileName.lastIndexOf("."), fileName.length());

        String path = getPath(properties.getPrefix(), suffix);
        // 构建多部分上传请求
        CreateMultipartUploadRequest request = CreateMultipartUploadRequest.builder()
            .bucket(properties.getBucketName())
            .key(path)
            .build();

        try {
            // 发起初始化请求
            CreateMultipartUploadResponse response = client.createMultipartUpload(request).join();
            String uploadId = response.uploadId();

            List<UploadUrl> uploadUrl = new ArrayList<>();
            for (int i = 0; i < totalChunks; i++) {
                int index = i + 1;
                UploadPartPresignRequest uploadPartPresignRequest = UploadPartPresignRequest.builder()
                    .signatureDuration(Duration.ofMinutes(10)) // 签名有效期为 10 分钟
                    .uploadPartRequest(b -> b
                        .bucket(properties.getBucketName())
                        .key(path)
                        .uploadId(uploadId)
                        .partNumber(index))
                    .build();
                PresignedUploadPartRequest presignedUploadPartRequest = presigner.presignUploadPart(uploadPartPresignRequest);
                URL url = presignedUploadPartRequest.url();
                uploadUrl.add(new UploadUrl(index, String.valueOf(index), url.toString(), null));
            }


            PartUploadVo partUploadVo = new PartUploadVo();
            partUploadVo.setUploadId(uploadId);
            partUploadVo.setUploadUrl(uploadUrl);
            partUploadVo.setPartCount((long) totalChunks);
            partUploadVo.setPath(path);
            partUploadVo.setUrl(getUrl() + StringUtils.SLASH + path);
            partUploadVo.setFileName(fileName);


            RedisUtils.setObjectIfAbsent(UPLOAD_KEY + uploadId, partUploadVo, Duration.ofHours(6));

            return partUploadVo;
        } catch (Exception e) {
            throw new OssException("初始化分片上传失败，请检查配置信息: [" + e.getMessage() + "]");
        }
    }


    /**
     * 分片上传 - 完成分片上传并合并文件
     *
     * @param uploadId  分片上传任务 ID
     * @param uploadUrl 已上传分片的 ETag 列表
     * @return UploadResult 合并后的文件信息
     */
    public UploadResult completeMultipartUpload(String uploadId, List<UploadUrl> uploadUrl) {
        try {
            List<CompletedPart> completedParts = new ArrayList<>();
            for (int i = 0; i < uploadUrl.size(); i++) {
                completedParts.add(
                    CompletedPart.builder()
                        .partNumber(i + 1)
                        .eTag(uploadUrl.get(i).getEtag())
                        .build()
                );
            }
            PartUploadVo uploadVo = (PartUploadVo) RedisUtils.getCacheObject(UPLOAD_KEY + uploadId);

            if (uploadVo == null) {
                throw new OssException("上传失败,文件合并超时,或文件Id不合法");
            }

            // 完成分片上传
            CompleteMultipartUploadRequest request = CompleteMultipartUploadRequest.builder()
                .bucket(properties.getBucketName())
                .key(uploadVo.getPath())
                .uploadId(uploadId)
                .multipartUpload(CompletedMultipartUpload.builder().parts(completedParts).build())
                .build();

            CompleteMultipartUploadResponse response = client.completeMultipartUpload(request).join();
            RedisUtils.deleteKeys(UPLOAD_KEY + uploadId);
            return UploadResult.builder().url(response.location()).filename(uploadVo.getFileName()).build();
        } catch (Exception e) {
            throw new OssException("合并分片失败，请检查配置信息: [" + e.getMessage() + "]");
        }
    }

    /**
     * 获取文件列表
     *
     * @param path 路径
     * @return 文件列表
     */
    public List<FileNode> listFile(String path) {

        CompletableFuture<ListObjectsResponse> listObjectsResponseCompletableFuture = client.listObjects(
            ListObjectsRequest.builder()
                .bucket(properties.getBucketName())
                .prefix(path)
                .build());
        List<FileNode> fileNodes = listObjectsResponseCompletableFuture.join().contents().stream()
            .map(object -> FileNode.builder()
                .name(object.key())
                .type(object.size() > 0 ? "file" : "folder")
                .path(object.key())
                .size((int) (object.size() / 1024 / 1024))
                .uploadUrl(getUrl() + StringUtils.SLASH + object.key())
                .build())
            .collect(Collectors.toList());
        return fileNodes;
    }

    /**
     * 获取文件输入流
     *
     * @param path 完整文件路径
     * @return 输入流
     */
    public InputStream getObjectContent(String path) throws IOException {
        // 下载文件到临时目录
        Path tempFilePath = fileDownload(path);
        // 创建输入流
        InputStream inputStream = Files.newInputStream(tempFilePath);
        // 删除临时文件
        FileUtils.del(tempFilePath);
        // 返回对象内容的输入流
        return inputStream;
    }

    /**
     * 获取 S3 客户端的终端点 URL
     *
     * @return 终端点 URL
     */
    public String getEndpoint() {
        // 根据配置文件中的是否使用 HTTPS，设置协议头部
        String header = getIsHttps();
        // 拼接协议头部和终端点，得到完整的终端点 URL
        return header + properties.getEndpoint();
    }

    /**
     * 获取 S3 客户端的终端点 URL（自定义域名）
     *
     * @return 终端点 URL
     */
    public String getDomain() {
        // 从配置中获取域名、终端点、是否使用 HTTPS 等信息
        String domain = properties.getDomain();
        String endpoint = properties.getEndpoint();
        String header = getIsHttps();

        // 如果是云服务商，直接返回域名或终端点
        if (StringUtils.containsAny(endpoint, OssConstant.CLOUD_SERVICE)) {
            return StringUtils.isNotEmpty(domain) ? header + domain : header + endpoint;
        }

        // 如果是 MinIO，处理域名并返回
        if (StringUtils.isNotEmpty(domain)) {
            return domain.startsWith(Constants.HTTPS) || domain.startsWith(Constants.HTTP) ? domain : header + domain;
        }

        // 返回终端点
        return header + endpoint;
    }

    /**
     * 根据传入的 region 参数返回相应的 AWS 区域
     * 如果 region 参数非空，使用 Region.of 方法创建并返回对应的 AWS 区域对象
     * 如果 region 参数为空，返回一个默认的 AWS 区域（例如，us-east-1），作为广泛支持的区域
     *
     * @return 对应的 AWS 区域对象，或者默认的广泛支持的区域（us-east-1）
     */
    public Region of() {
        //AWS 区域字符串
        String region = properties.getRegion();
        // 如果 region 参数非空，使用 Region.of 方法创建对应的 AWS 区域对象，否则返回默认区域
        return StringUtils.isNotEmpty(region) ? Region.of(region) : Region.US_EAST_1;
    }

    /**
     * 获取云存储服务的URL
     *
     * @return 文件路径
     */
    public String getUrl() {
        String domain = properties.getDomain();
        String endpoint = properties.getEndpoint();
        String header = getIsHttps();
        // 云服务商直接返回
        if (StringUtils.containsAny(endpoint, OssConstant.CLOUD_SERVICE)) {
            return header + (StringUtils.isNotEmpty(domain) ? domain : properties.getBucketName() + "." + endpoint);
        }
        // MinIO 单独处理
        if (StringUtils.isNotEmpty(domain)) {
            // 如果 domain 以 "https://" 或 "http://" 开头
            return (domain.startsWith(Constants.HTTPS) || domain.startsWith(Constants.HTTP)) ?
                domain + StringUtils.SLASH + properties.getBucketName() : header + domain + StringUtils.SLASH + properties.getBucketName();
        }
        return header + endpoint + StringUtils.SLASH + properties.getBucketName();
    }

    /**
     * 生成一个符合特定规则的、唯一的文件路径。通过使用日期、UUID、前缀和后缀等元素的组合，确保了文件路径的独一无二性
     *
     * @param prefix 前缀
     * @param suffix 后缀
     * @return 文件路径
     */
    public String getPath(String prefix, String suffix) {
        // 生成uuid
        String uuid = IdUtil.fastSimpleUUID();
        // 生成日期路径
        String datePath = DateUtils.datePath();
        // 拼接路径
        String path = StringUtils.isNotEmpty(prefix) ?
            prefix + StringUtils.SLASH + datePath + StringUtils.SLASH + uuid : datePath + StringUtils.SLASH + uuid;
        return path + suffix;
    }

    /**
     * 移除路径中的基础URL部分，得到相对路径
     *
     * @param path 完整的路径，包括基础URL和相对路径
     * @return 去除基础URL后的相对路径
     */
    public String removeBaseUrl(String path) {
        return path.replace(getUrl() + StringUtils.SLASH, "");
    }

    /**
     * 服务商
     */
    public String getConfigKey() {
        return configKey;
    }

    /**
     * 获取是否使用 HTTPS 的配置，并返回相应的协议头部。
     *
     * @return 协议头部，根据是否使用 HTTPS 返回 "https://" 或 "http://"
     */
    public String getIsHttps() {
        return OssConstant.IS_HTTPS.equals(properties.getIsHttps()) ? Constants.HTTPS : Constants.HTTP;
    }

    /**
     * 检查配置是否相同
     */
    public boolean checkPropertiesSame(OssProperties properties) {
        return this.properties.equals(properties);
    }

    /**
     * 获取当前桶权限类型
     *
     * @return 当前桶权限类型code
     */
    public AccessPolicyType getAccessPolicy() {
        return AccessPolicyType.getByType(properties.getAccessPolicy());
    }

    /**
     * 生成 AWS S3 存储桶访问策略
     *
     * @param bucketName 存储桶
     * @param policyType 桶策略类型
     * @return 符合 AWS S3 存储桶访问策略格式的字符串
     */
    private static String getPolicy(String bucketName, PolicyType policyType) {
        String policy = switch (policyType) {
            case WRITE -> """
                {
                  "Version": "2012-10-17",
                  "Statement": []
                }
                """;
            case READ_WRITE -> """
                {
                  "Version": "2012-10-17",
                  "Statement": [
                    {
                      "Effect": "Allow",
                      "Principal": "*",
                      "Action": [
                        "s3:GetBucketLocation",
                        "s3:ListBucket",
                        "s3:ListBucketMultipartUploads"
                      ],
                      "Resource": "arn:aws:s3:::bucketName"
                    },
                    {
                      "Effect": "Allow",
                      "Principal": "*",
                      "Action": [
                        "s3:AbortMultipartUpload",
                        "s3:DeleteObject",
                        "s3:GetObject",
                        "s3:ListMultipartUploadParts",
                        "s3:PutObject"
                      ],
                      "Resource": "arn:aws:s3:::bucketName/*"
                    }
                  ]
                }
                """;
            case READ -> """
                {
                  "Version": "2012-10-17",
                  "Statement": [
                    {
                      "Effect": "Allow",
                      "Principal": "*",
                      "Action": ["s3:GetBucketLocation"],
                      "Resource": "arn:aws:s3:::bucketName"
                    },
                    {
                      "Effect": "Deny",
                      "Principal": "*",
                      "Action": ["s3:ListBucket"],
                      "Resource": "arn:aws:s3:::bucketName"
                    },
                    {
                      "Effect": "Allow",
                      "Principal": "*",
                      "Action": "s3:GetObject",
                      "Resource": "arn:aws:s3:::bucketName/*"
                    }
                  ]
                }
                """;
        };
        return policy.replaceAll("bucketName", bucketName);
    }


}