一、MINIO的安装，MinioTemplate的封装使用

一、MINIO的安装，MinioTemplate的封装使用
二、阿里云OSS，AliossTemplate的封装使用
三、七牛云对象存储，QiniuTemplate的封装使用
四、华为云OBS对象存储，HwObsTemplate的封装使用
五、腾讯COS对象存储，TxCosTemplate的封装使用

一、MINIO的安装，MinioTemplate的封装使用

OSS的使用，涉及到的厂商很多，有AWS这里不使用，开源的可国内的一些有，七牛云、阿里云OSS、华为云OBS、MINIO、腾讯COS等。AWSS3SDK，可以操作大部分厂商的文件，OSS的协议是相同的。下面的链接是阿里云的文档，为了学习使用，这里不使用阿里云的文档。

如何使用AWSS3SDK访问OSS_对象存储(OSS)

为什么要封装，为了后续提取公共组件，封装统一各厂商的接口调用，业务同事不再关心该部分的具体开发工作

1、使用dockercompose安装minio

version: '3'
services:
  minio:
    image: minio/minio
    container_name: minio
    volumes:
      - ./data/minio:/data
    ports:
      - "9000:9000"
      - "9001:9001"
    environment:
      MINIO_ROOT_USER: minio
      MINIO_ROOT_PASSWORD: minio123
    command: server /data --console-address ":9001" # command指令中添加--console-address参数，否则浏览器访问控制台自动跳转端口导致无法访问
    #restart: always

2、minio中常使用的菜单

3、oss服务中的策略

刚开始，我这块只了解公共读，私有写，这是没什么问题的。但是有段时间，公共OSS服务费用不那么正常了，被攻击了，这时候想到了公共读是不行的，只对君子有效，把公共读/私有写改为了私有读写,生成一个需要鉴权的路径，但是也君子协议。

常见问题

问1、bucket设置为私有，能否防止恶意下载

答：不能防止，一但对应资源的签名url对外暴露，在签名url有效期内就可以通过签名url下载对应的资源。

问2、bucket私有，获取到的资源链接是否具有时效性

答：有时效性，一但过期就不可被访问。

问3：获取到的资源链接是否可以永久有效

答：将bucket改为公共读/公共读写，获取到的object链接一般都是永久有效的，但是如果bucket私有则一般获取的链接是有时效的。

4、Javad代码操作minio

4.1 引入依赖

<!--MinIO-->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <scope>provided</scope>
</dependency>

4.2 代码结构如下

4.3 PolicyType代码

package com.toto.core.oss.enums;

import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * @Description: MINI桶策略
 * @Package: com.toto.core.oss
 * @Author gufanbiao
 * @CreateTime 2024-02-17 19:29
 */
@Getter
@AllArgsConstructor
public enum PolicyType {

    /** 只读 */
    READ("read", "只读"),

    /** 只写 */
    WRITE("write", "只写"),

    /** 读写 */
    READ_WRITE("read_write", "读写");

    /** 类型 */
    private final String type;
    /** 描述 */
    private final String policy;

}

4.4 UploadType代码

package com.toto.core.oss.enums;

import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * @Description: UploadType
 * @Package: com.toto.core.oss.enums
 * @Author gufanbiao
 * @CreateTime 2024-05-26 15:51
 */
@Getter
@AllArgsConstructor
public enum UploadType {
    /** 文件上传方式 0: oss存储 1: nas存储 2: FTP存储 3: 本地存储 */
    /** oss存储 */
    OSS("0", "oss存储"),
    /** nas存储 */
    NAS("1", "nas存储"),
    /** ftp存储 */
    FTP("2", "FTP存储"),
    /** nas存储 */
    LOCAL("3", "本地存储");

    /** 类型 */
    private final String type;
    /** 描述 */
    private final String value;
}

4.5 TotoFile代码

package com.toto.core.oss.model;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

@Data
public class TotoFile implements Serializable {

    private static final long serialVersionUID = -6686897799561311877L;

    /** 主键id */
    private Long id;
    /** 业务主键 */
    private Long businessId;
    /** 文件名 */
    private String fileName;
    /** 初始文件名 */
    private String originalName;
    /** 文件地址(link) */
    private String fileUrl;
    /** 域名地址 */
    private String domain;
    /** 文件类型 */
    private String fileType;
    /** 文本类型 类似text/plain audio/mpeg */
    private String contentType;
    /** 文件大小 */
    private Long fileSize;
    /** 文件上传方式 0: oss存储 1: nas存储 2: ftp存储 3: 本地存储 */
    private String uploadType;
    /** 文件hash值 */
    public String hash;
    /** 文件上传时间 */
    private Date uploadTime;
    /** 用户id */
    private Long userId;
    /** 模块名- 一级 */
    private String module;
    /** 业务模块名 二级 */
    private String cmodule;
    /** OSS服务 ObjectKey */
    private String objectKey;
}

4.6 OssUtil代码

package com.toto.core.oss.tool;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.toto.core.oss.OssProperties;

import java.io.File;

/**
 * @Description: OssUtil
 * @Package: com.toto.core.oss
 * @Author gufanbiao
 * @CreateTime 2024-05-26 14:30
 */
public class OssUtil {

    public static String fileName(String originalFilename) {
        return "upload/" + DateUtil.today() + "/" +  IdUtil.simpleUUID() + "." + getFileExtension(originalFilename);
    }

    public static String getOssHost(OssProperties ossProperties, String bucketName) {
        return ossProperties.getEndpoint() + "/" + bucketName;
    }

    private static String getFileExtension(String fullName) {
        if (StrUtil.isBlank(fullName)) return "";
        String fileName = new File(fullName).getName();
        int dotIndex = fileName.lastIndexOf(".");
        return (dotIndex == -1) ? "" : fileName.substring(dotIndex + 1);
    }
}

4.7 OssTemplate代码

package com.toto.core.oss;

import com.toto.core.oss.model.TotoFile;
import io.minio.GetPresignedObjectUrlArgs;
import io.minio.errors.*;
import io.minio.http.Method;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.List;

/**
 * OssTemplate抽象方法
 */
@SuppressWarnings("all")
public interface OssTemplate {

	/**
	 * 创建 存储桶
	 * @param bucketName 存储桶名称
	 */
	void makeBucket(String bucketName);

	/**
	 * 删除 存储桶
	 * @param bucketName 存储桶名称
	 */
	void deleteBucket(String bucketName);

	/**
	 * 存储桶是否存在
	 * @param bucketName 存储桶名称
	 * @return boolean
	 */
	boolean bucketExists(String bucketName);

	/**
	 * 拷贝文件
	 * @param bucketName     存储桶名称
	 * @param fileName       存储桶文件名称
	 * @param destBucketName 目标存储桶名称
	 */
	void copyFile(String bucketName, String fileName, String destBucketName) throws Exception;

	/**
	 * 拷贝文件
	 * @param bucketName     存储桶名称
	 * @param fileName       存储桶文件名称
	 * @param destBucketName 目标存储桶名称
	 * @param destFileName   目标存储桶文件名称
	 */
	void copyFile(String bucketName, String fileName, String destBucketName, String destFileName) throws Exception;

	/**
	 * 获取文件信息
	 * @param fileName 存储桶文件名称
	 * @return InputStream
	 */
	TotoFile getFile(String fileName) throws Exception;

	/**
	 * 获取文件信息
	 * @param bucketName 存储桶名称
	 * @param fileName   存储桶文件名称
	 * @return InputStream
	 */
	TotoFile getFile(String bucketName, String fileName) throws Exception;

	/**
	 * 获取文件相对路径
	 * @param fileName 存储桶对象名称
	 * @return String
	 */
	String getPath(String fileName);

	/**
	 * 获取文件相对路径
	 * @param bucketName 存储桶名称
	 * @param fileName   存储桶对象名称
	 * @return String
	 */
	String getPath(String bucketName, String fileName);

	/**
	 * 获取文件地址
	 * @param fileName 存储桶对象名称
	 * @return String
	 */
	String fileUrl(String fileName);

	/**
	 * 获取文件地址
	 * @param bucketName 存储桶名称
	 * @param fileName   存储桶对象名称
	 * @return String
	 */
	String fileUrl(String bucketName, String fileName);

	/**
	 * 获取文件临时地址
	 * @param bucketName bucket名称
	 * @param fileName   文件名称
	 * @param expires    过期时间
	 * @return url
	 */
	public String getShortlytUrl(String bucketName, String fileName, Integer expires) throws Exception;

	/**
	 * 上传文件
	 * @param file 上传文件类
	 * @return TotoFile
	 */
	TotoFile putFile(MultipartFile file) throws Exception;

	/**
	 * 上传文件
	 * @param file     上传文件类
	 * @param fileName 上传文件名
	 * @return TotoFile
	 */
	TotoFile putFile(String fileName, MultipartFile file) throws Exception;

	/**
	 * 上传文件
	 * @param bucketName 存储桶名称
	 * @param fileName   上传文件名
	 * @param file       上传文件类
	 * @return TotoFile
	 */
	TotoFile putFile(String bucketName, String fileName, MultipartFile file) throws Exception;

	/**
	 * 上传文件
	 * @param fileName 存储桶对象名称
	 * @param stream   文件流
	 * @return TotoFile
	 */
	TotoFile putFile(String fileName, InputStream stream) throws Exception;

	/**
	 * 上传文件
	 * @param bucketName 存储桶名称
	 * @param fileName   存储桶对象名称
	 * @param stream     文件流
	 * @return TotoFile
	 */
	TotoFile putFile(String bucketName, String fileName, InputStream stream) throws Exception;

	/**
	 * 上传文件
	 * @param bucketName 存储桶名称
	 * @param fileName   存储桶对象名称
	 * @param stream     文件流
	 * @param file       上传文件类
	 * @return TotoFile
	 */
	TotoFile putFile(String bucketName, String fileName, InputStream stream, MultipartFile file) throws Exception;

	/**
	 * 删除文件
	 * @param fileName 存储桶对象名称
	 */
	void deleteFile(String fileName) throws Exception ;

	/**
	 * 删除文件
	 * @param bucketName 存储桶名称
	 * @param fileName   存储桶对象名称
	 */
	void deleteFile(String bucketName, String fileName) throws Exception;

	/**
	 * 批量删除文件
	 * @param fileNames 存储桶对象名称集合
	 */
	void deleteFiles(List<String> fileNames) throws Exception ;

	/**
	 * 批量删除文件
	 * @param bucketName 存储桶名称
	 * @param fileNames  存储桶对象名称集合
	 */
	void deleteFiles(String bucketName, List<String> fileNames) throws Exception ;

}

4.8 OssProperties代码

package com.toto.core.oss;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;

/**
 * @Description: OssProperties
 * @Package: com.toto.core.oss
 * @Author gufanbiao
 * @CreateTime 2024-02-15 00:10
 */
@Data
@EnableConfigurationProperties(OssProperties.class) // 或者在启动类上引用该类
@ConfigurationProperties(prefix = "toto.oss")
public class OssProperties {
    /** 是否启用 */
    private Boolean enabled;

    /** 对象存储名称 */
    private String name;

    /** 是否开启租户模式 */
    private Boolean tenantMode = false;

    /** 对象存储服务的URL */
    private String endpoint;

    /** 应用ID TencentCOS需要 */
    private String appId;

    /** 区域简称 TencentCOS需要 */
    private String region;

    /** Access key就像用户ID，可以唯一标识你的账户 */
    private String accessKey;

    /** Secret key是你账户的密码 */
    private String secretKey;

    /** 默认的存储桶名称 */
    private String bucketName = "toto";

}

4.9 MinioTemplate代码

package com.toto.core.oss;

import cn.hutool.core.util.ObjectUtil;
import com.toto.core.oss.enums.PolicyType;
import com.toto.core.oss.enums.UploadType;
import com.toto.core.oss.model.TotoFile;
import com.toto.core.oss.tool.OssUtil;
import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.DeleteObject;
import lombok.AllArgsConstructor;
import lombok.SneakyThrows;
import org.springframework.web.multipart.MultipartFile;

import java.io.InputStream;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@AllArgsConstructor
public class MinioTemplate implements OssTemplate {

    /** MinIO客户端 */
    private final MinioClient client;

    /** 配置类 */
    private final OssProperties ossProperties;

    @Override
    @SneakyThrows
    public void makeBucket(String bucketName) {
        if (!client.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
            client.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            client.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(getPolicyType(bucketName, PolicyType.READ)).build());
            // 设置tag,这里不做封装，用到时再做处理
            //client.setBucketTags(SetBucketTagsArgs.builder().tags(Tags.newBucketTags()));
        }
    }

    @Override
    @SneakyThrows
    public void deleteBucket(String bucketName) {
        client.removeBucket(
                RemoveBucketArgs.builder().bucket(bucketName).build()
        );
    }

    @Override
    @SneakyThrows
    public boolean bucketExists(String bucketName) {
        return client.bucketExists(
                BucketExistsArgs.builder().bucket(bucketName).build()
        );
    }

    @Override
    public void copyFile(String bucketName, String fileName, String destBucketName) throws Exception {
        copyFile(bucketName, fileName, destBucketName, fileName);
    }

    @Override
    public void copyFile(String bucketName, String fileName, String destBucketName, String destFileName) throws Exception {
        client.copyObject(
                CopyObjectArgs.builder()
                        .source(CopySource.builder().bucket(bucketName).object(fileName).build())
                        .bucket(destBucketName)
                        .object(destFileName)
                        .build()
        );
    }

    @Override
    public TotoFile getFile(String fileName) throws Exception {
        return getFile(ossProperties.getBucketName(), fileName);
    }

    @Override
    public TotoFile getFile(String bucketName, String fileName) throws Exception {
        StatObjectResponse statObject = client.statObject(
                StatObjectArgs.builder().bucket(bucketName).object(fileName).build()
        );
        TotoFile file = new TotoFile();
        file.setFileName(ObjectUtil.isNotNull(statObject.object()) ? statObject.object() : fileName);
        file.setFileUrl(fileUrl(file.getFileName()));
        file.setHash(String.valueOf(statObject.hashCode()));
        file.setFileSize(statObject.size());
        file.setUploadTime(Date.from(statObject.lastModified().toInstant()));
        file.setContentType(statObject.contentType());
        return file;
    }

    @Override
    public String getPath(String fileName) {
        return ossProperties.getBucketName().concat("/").concat(fileName);
    }

    @Override
    public String getPath(String bucketName, String fileName) {
        return ossProperties.getBucketName().concat("/").concat(fileName);
    }

    @Override
    public String fileUrl(String fileName) {
        return ossProperties.getEndpoint().concat("/").concat(ossProperties.getBucketName()).concat("/").concat(fileName);
    }

    @Override
    public String fileUrl(String bucketName, String fileName) {
        return ossProperties.getEndpoint().concat("/").concat(bucketName).concat("/").concat(fileName);
    }

    @Override
    public String getShortlytUrl(String bucketName, String fileName, Integer expires) throws Exception {
        return client.getPresignedObjectUrl(
                GetPresignedObjectUrlArgs.builder()
                        .method(Method.GET)
                        .bucket(bucketName)
                        .object(fileName)
                        .expiry(expires)
                        .build()
        );
    }

    @Override
    public TotoFile putFile(MultipartFile file) throws Exception {
        return putFile(ossProperties.getBucketName(), file.getOriginalFilename(), file);
    }

    @Override
    public TotoFile putFile(String fileName, MultipartFile file) throws Exception {
        return putFile(ossProperties.getBucketName(), fileName, file);
    }

    @Override
    public TotoFile putFile(String bucketName, String fileName, MultipartFile file) throws Exception {
        return putFile(bucketName, fileName, file.getInputStream(), file);
    }

    @Override
    public TotoFile putFile(String fileName, InputStream stream) throws Exception {
        return putFile(ossProperties.getBucketName(), fileName, stream);
    }

    @Override
    public TotoFile putFile(String bucketName, String fileName, InputStream stream) throws Exception {
        return putFile(bucketName, fileName, stream, "application/octet-stream",null);
    }

    @Override
    public TotoFile putFile(String bucketName, String fileName, InputStream stream, MultipartFile file) throws Exception {
        return putFile(bucketName, fileName, stream, "application/octet-stream", file);
    }

    private TotoFile putFile(String bucketName, String fileName, InputStream stream, String contentType, MultipartFile multipartFile) throws Exception {
        makeBucket(bucketName);
        String originalName = fileName;
        fileName = OssUtil.fileName(fileName);
        client.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(fileName)
                        .stream(stream, stream.available(), -1)
                        .contentType(contentType)
                        .build()
        );
        TotoFile file = new TotoFile();
        file.setOriginalName(originalName);
        file.setFileName(fileName);
        file.setDomain(OssUtil.getOssHost(ossProperties,bucketName));
        file.setFileUrl(fileUrl(bucketName, fileName));
        file.setFileType(originalName.substring(originalName.lastIndexOf(".") + 1));
        file.setUploadType(UploadType.OSS.getType());
        if(ObjectUtil.isNotNull(multipartFile)){
            file.setFileSize(multipartFile.getSize());
            file.setContentType(multipartFile.getContentType());
            file.setUploadTime(new Date());
        }
        return file;
    }

    @Override
    public void deleteFile(String fileName) throws Exception {
        deleteFile(ossProperties.getBucketName(), fileName);
    }

    @Override
    public void deleteFile(String bucketName, String fileName) throws Exception {
        client.removeObject(
                RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build()
        );
    }

    @Override
    public void deleteFiles(List<String> fileNames) throws Exception {
        deleteFiles(ossProperties.getBucketName(), fileNames);
    }

    @Override
    public void deleteFiles(String bucketName, List<String> fileNames) throws Exception {
        Stream<DeleteObject> stream = fileNames.stream().map(DeleteObject::new);
        List<DeleteObject> objects = fileNames.stream().map(m -> {
            return new DeleteObject(m);
        }).collect(Collectors.toList());
        client.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(objects).build());
    }

    /**
     * 获取存储桶策略
     *
     * @param bucketName 存储桶名称
     * @param policyType 策略枚举
     * @return String
     */
    public static String getPolicyType(String bucketName, PolicyType policyType) {
        StringBuilder builder = new StringBuilder();
        builder.append("{\n");
        builder.append("    \"Statement\": [\n");
        builder.append("        {\n");
        builder.append("            \"Action\": [\n");

        switch (policyType) {
            case WRITE:
                builder.append("                \"s3:GetBucketLocation\",\n");
                builder.append("                \"s3:ListBucketMultipartUploads\"\n");
                break;
            case READ_WRITE:
                builder.append("                \"s3:GetBucketLocation\",\n");
                builder.append("                \"s3:ListBucket\",\n");
                builder.append("                \"s3:ListBucketMultipartUploads\"\n");
                break;
            default:
                builder.append("                \"s3:GetBucketLocation\"\n");
                break;
        }

        builder.append("            ],\n");
        builder.append("            \"Effect\": \"Allow\",\n");
        builder.append("            \"Principal\": \"*\",\n");
        builder.append("            \"Resource\": \"arn:aws:s3:::");
        builder.append(bucketName);
        builder.append("\"\n");
        builder.append("        },\n");
        if (PolicyType.READ.equals(policyType)) {
            builder.append("        {\n");
            builder.append("            \"Action\": [\n");
            builder.append("                \"s3:ListBucket\"\n");
            builder.append("            ],\n");
            builder.append("            \"Effect\": \"Deny\",\n");
            builder.append("            \"Principal\": \"*\",\n");
            builder.append("            \"Resource\": \"arn:aws:s3:::");
            builder.append(bucketName);
            builder.append("\"\n");
            builder.append("        },\n");

        }
        builder.append("        {\n");
        builder.append("            \"Action\": ");

        switch (policyType) {
            case WRITE:
                builder.append("[\n");
                builder.append("                \"s3:AbortMultipartUpload\",\n");
                builder.append("                \"s3:DeleteObject\",\n");
                builder.append("                \"s3:ListMultipartUploadParts\",\n");
                builder.append("                \"s3:PutObject\"\n");
                builder.append("            ],\n");
                break;
            case READ_WRITE:
                builder.append("[\n");
                builder.append("                \"s3:AbortMultipartUpload\",\n");
                builder.append("                \"s3:DeleteObject\",\n");
                builder.append("                \"s3:GetObject\",\n");
                builder.append("                \"s3:ListMultipartUploadParts\",\n");
                builder.append("                \"s3:PutObject\"\n");
                builder.append("            ],\n");
                break;
            default:
                builder.append("\"s3:GetObject\",\n");
                break;
        }

        builder.append("            \"Effect\": \"Allow\",\n");
        builder.append("            \"Principal\": \"*\",\n");
        builder.append("            \"Resource\": \"arn:aws:s3:::");
        builder.append(bucketName);
        builder.append("/*\"\n");
        builder.append("        }\n");
        builder.append("    ],\n");
        builder.append("    \"Version\": \"2012-10-17\"\n");
        builder.append("}\n");
        return builder.toString();
    }
}

4.10 MinioTest代码

package com.toto;

import com.alibaba.fastjson.JSONObject;
import com.toto.core.oss.MinioTemplate;
import com.toto.core.oss.OssProperties;
import com.toto.core.oss.enums.PolicyType;
import com.toto.core.oss.model.TotoFile;
import io.minio.MinioClient;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

/**
 * @Description: MinioTest
 * @Package: com.toto
 * @Author gufanbiao
 * @CreateTime 2024-05-26 12:20
 */
@SpringBootTest
public class MinioTest {

    private static String ENDPOINT = "http://127.0.0.1:9000";
    private static String ACCESS_KEY = "OkxioFM5dP9o0ydB4HKI";
    private static String SECRET_KEY = "Fbp6zrdZQZjkEe9OvD8EMScVhbqmEeZlYPSuwNIO";
    private static String BUCKET_NAME = "toto.test";
    private static String BUCKET_DEST_NAME = "toto.dest";

    public static MinioTemplate template() {
        // 创建配置类
        OssProperties ossProperties = new OssProperties();
        ossProperties.setEndpoint(ENDPOINT);
        ossProperties.setAccessKey(ACCESS_KEY);
        ossProperties.setSecretKey(SECRET_KEY);
        ossProperties.setBucketName(BUCKET_NAME);
        // 创建客户端
        MinioClient minioClient = MinioClient.builder()
                .endpoint(ENDPOINT)
                .credentials(ACCESS_KEY, SECRET_KEY)
                .build();
        return new MinioTemplate(minioClient, ossProperties);
    }

    /*********************************** mock对象信息 *****************************************/
    private static String FILE_NAME = "你好世界.txt";
    private static String CONTENT_TYPE = "text/plain";
    private static String CONTENT = "你好世界!";
    /**
     * mock一个对象 使用Spring框架的MockMultipartFile类创建一个MultipartFile对象
     * @return
     * @throws IOException
     */
    public static MultipartFile createMultipartFile() throws IOException {
        return new MockMultipartFile(FILE_NAME, FILE_NAME, CONTENT_TYPE, CONTENT.getBytes());
    }

    /***********************************据图操作测试*****************************************/
    /**
     * 创建 Bucket
     */
    @Test
    void testCreate() {
        template().makeBucket(BUCKET_DEST_NAME);
    }

    /**
     * 删除 Bucket (桶中如果有文件是不允许被删除的)
     */
    @Test
    void deleteBucket() {
        template().deleteBucket(BUCKET_NAME);
    }

    /**
     * 存储桶是否存在
     */
    @Test
    void bucketExists() {
        boolean b = template().bucketExists(BUCKET_NAME);
        System.out.println("存储桶是否存在：" + b);
    }

    /**
     * 上传文件 MultipartFile格式
     */
    @Test
    void putFile1() throws Exception {
        TotoFile totoFile = template().putFile(MinioTest.createMultipartFile());
        System.out.println("上传文件对象封装：" + JSONObject.toJSON(totoFile));
    }

    /**
     * 上传文件 文件流模式
     */
    @Test
    void putFile2() throws Exception {
        InputStream inputStream = MinioTest.createMultipartFile().getInputStream();
        TotoFile totoFile = template().putFile(FILE_NAME, inputStream);
        System.out.println("上传文件对象封装：" + JSONObject.toJSON(totoFile));
    }

    /**
     * 上传文件 文件流模式
     */
    @Test
    void putFile3() throws Exception {
        TotoFile totoFile = template().putFile("hhhhhhh"+FILE_NAME, MinioTest.createMultipartFile());
        System.out.println("上传文件对象封装：" + JSONObject.toJSON(totoFile));
    }

    /**
     * 文件复制到另一个桶（文件名/路径不变）
     * @throws Exception
     */
    @Test
    void copyFile1() throws Exception {
        template().copyFile(BUCKET_NAME,"upload/2024-05-26/76b4273da33a49649954bb5187bfedbe.txt",BUCKET_DEST_NAME);
    }

    /**
     * 文件复制到另一个桶（文件名/路径变更）
     * @throws Exception
     */
    @Test
    void copyFile2() throws Exception {
        template().copyFile(BUCKET_NAME,"upload/2024-05-26/76b4273da33a49649954bb5187bfedbe.txt",BUCKET_DEST_NAME,"upload/2024-05-28/76b4273da33a49649954bb5187bfedbe.txt");
    }

    /**
     * 获取文件信息
     * @throws Exception
     */
    @Test
    void statFile1() throws Exception {
        TotoFile totoFile = template().getFile("upload/2024-05-26/5c88db26e57643de88591453e2385907.txt");
        System.out.println("获取文件对象信息：" + JSONObject.toJSONString(totoFile));
    }

    /**
     * 获取文件信息(指定桶的名称)
     * @throws Exception
     */
    @Test
    void statFile2() throws Exception {
        TotoFile totoFile = template().getFile(BUCKET_NAME,"upload/2024-05-26/5c88db26e57643de88591453e2385907.txt");
        System.out.println("获取文件对象信息：" + JSONObject.toJSONString(totoFile));
    }

    /**
     * 获取文件路径信息（没有什么实质的参考，就是内部组装）
     */
    @Test
    void getPath1() {
        String path = template().getPath("upload/2024-05-26/5c88db26e57643de88591453e2385907.txt");
        System.out.println("获取文件路径信息：" + path);
    }

    /**
     * 获取文件路径信息（没有什么实质的参考，就是内部组装）
     */
    @Test
    void getPath2() {
        String path = template().getPath(BUCKET_NAME,"upload/2024-05-26/5c88db26e57643de88591453e2385907.txt");
        System.out.println("获取文件路径信息：" + path);
    }

    /**
     * 获取文件路径信息（没有什么实质的参考，就是内部组装）
     */
    @Test
    void getFileUrl1(){
        String fileUrl = template().fileUrl("upload/2024-05-26/5c88db26e57643de88591453e2385907.txt");
        System.out.println("获取文件路径信息：" + fileUrl);
    }

    /**
     * 获取文件路径信息（没有什么实质的参考，就是内部组装）
     */
    @Test
    void getFileUrl2(){
        String fileUrl = template().fileUrl(BUCKET_NAME,"upload/2024-05-26/5c88db26e57643de88591453e2385907.txt");
        System.out.println("获取文件路径信息：" + fileUrl);
    }

    /**
     * 获取桶的策略，创建桶时使用，这里创建桶的时候指定的写
     */
    @Test
    void getPolicyType() {
        String policyType = template().getPolicyType(BUCKET_NAME, PolicyType.READ);
        System.out.println("获取桶的策略：" + policyType);
    }

    /**
     * 删除文件，使用配置文件中的桶
     * @throws Exception
     */
    @Test
    void deleteFile1() throws Exception {
        template().deleteFile("upload/2024-05-26/5c88db26e57643de88591453e2385907.txt");
    }

    /**
     * 删除文件指定桶
     * @throws Exception
     */
    @Test
    void deleteFile2() throws Exception {
        template().deleteFile(BUCKET_NAME,"upload/2024-05-26/76b4273da33a49649954bb5187bfedbe.txt");
    }

    /**
     * 批量删除，默认配置文件中的桶(貌似有点问题，有时候可以，有时候不行)
     * @throws Exception
     */
    @Test
    void deleteFile3() throws Exception {
        List<String> fileNames = new ArrayList<>();
        fileNames.add("upload/2024-05-28/0aff844d94514415baac9f972eeef284.txt");
        fileNames.add("upload/2024-05-28/304d7d345b864de5aa2183cdb1553b9f.txt");
        template().deleteFiles(fileNames);
    }

    /**
     * 获取临时地址，临时地址使用在私有写中，才能达到想要的效果
     * @throws Exception
     */
    @Test
    void getShortlytUrl() throws Exception {
        String shortlytUrl = template().getShortlytUrl(BUCKET_NAME, "upload/2024-05-26/76b4273da33a49649954bb5187bfedbe.txt", 30);
        System.out.println("文件临时地址" + shortlytUrl);
    }

}

4.11 application.yml代码

本文不做springBoot的集成，是以单元测试的方式，对API进行的测试，这里仅贴出minio的配置