SpringBoot整合Minio(支持公有及私有bucket)

😊 @ 作者：一恍过去

💖 @ 主页： https://blog.csdn.net/zhuocailing3390

🎊 @ 社区： Java技术栈交流

🎉 @ 主题： SpringBoot整合Minio(支持公有及私有bucket)

⏱️ @ 创作时间： 2024年06月19日

1、Bucket、Object
2、常用API
3、整合SpringBoot
- 3.1、yaml配置
- 3.2、MinIo配置
- 3.3、Bucket 操作
- 3.4、Object操作
- - 1. 上传文件
  - 2、获取文件状态(是否存在)
  - 3、生成带签名公共访问连接
  - 4、下载文件流
  - 5、获取文件列表
  - 6、删除文件信息

1、Bucket、Object

Bucket 是存储Object的逻辑空间，每个Bucket之间的数据是相互隔离的，对用户而言，相当于存放文件的顶层文件夹；
Object 是存储到MinIO的基本对象，对用户而言，相当于文件；

2、常用API

bucketExists()：用于检查指定的存储桶是否存在，返回布尔值，表示存储桶是否存在；
makeBucket()：用于创建一个新的存储桶（bucket），需要指定存储桶的名称；
listBuckets()：用于列出用户有权访问的所有存储桶，返回存储桶的列表；
removeBucket()：用于删除一个已存在的存储桶（bucket），删除失败会抛出异常；
putObject()：用于上传文件到指定的存储桶；
statObject()：用于检查指定的对象（文件）的状态，判断是否存在；
getPresignedObjectUrl()：用于生成一个对象（文件）的签名URL，以便可以通过HTTP访问；
getObject()：用于从指定的存储桶中下载文件；
listObjects()：用于列出指定存储桶中的所有对象（文件）；
removeObject()：用于删除指定存储桶中的对象，需要指定存储桶名称和对象键；

3、整合SpringBoot

引入POM包：

    <dependencies>
		<!-- minio -->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.5.9</version>
        </dependency>
	</dependencies>

3.1、yaml配置

minio:
  # 连接地址
  endpoint: http://127.0.0.1:9000
  # 用户名
  accessKey: admin
  # 密码
  secretKey: 123456789
  # 设置共有桶，具体名称可以在MinIo后台设置，可以直接访问，格式：http://1ip:port/bucketName/fileName
  publicBucket: public-test
  # 设置私有桶，具体名称可以在MinIo后台设置，需要通过getPresignedObjectUrl方法获取签名链接
  privateBucket: private-test

3.2、MinIo配置

MinIOInfoConfig：

@Data
@Component
@ConfigurationProperties(prefix = "minio")
public class MinIOInfoConfig {

    /**
     * 连接地址
     */
    private String endpoint;

    /**
     * 用户名
     */
    private String accessKey;

    /**
     * 密码
     */
    private String secretKey;

    /**
     * 私有bucket
     */
    private String privateBucket;

    /**
     * 公共bucket
     */
    private String publicBucket;

}

MinioConfig：

import io.minio.MinioClient;
import jakarta.annotation.Resource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MinioConfig {

    @Resource
    private MinIOInfoConfig minIOInfoConfig;

    @Bean
    public MinioClient minioClient() {
        //链式编程，构建MinioClient对象
        return MinioClient.builder()
                .endpoint(minIOInfoConfig.getEndpoint())
                .credentials(minIOInfoConfig.getAccessKey(), minIOInfoConfig.getSecretKey())
                .build();
    }
}

3.3、Bucket 操作

上传文件前，需要先进行Bucket 的创建操作，可以直接到MinIo后台进行创建，也可以通过API接口进行创建，代码示例如下

@Service
public class MinIOService {
    
    @Resource
    private MinioClient minioClient;

    public void bucket() {
        try {
            String bucketName = "test-bucket";

            // 判断是否存在
            boolean bucketExists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            System.out.println("bucketExists1 = " + bucketExists);

            // 创建
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());

            // 再次判断
            bucketExists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            System.out.println("bucketExists2 = " + bucketExists);

            // 查询列表
            List<Bucket> bucketList = minioClient.listBuckets();
            List<String> list = bucketList.stream().map(Bucket::name).toList();
            System.out.println("bucketList = " + list);

            // 删除
            minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());

            // 再次判断
            bucketExists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            System.out.println("bucketExists3 = " + bucketExists);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

3.4、Object操作

1. 上传文件

@Service
public class MinIOService {
    
    @Resource
    private MinioClient minioClient;
    
    @Resource
    private MinIOInfoConfig minIOInfoConfig;
    
        public void upload(MultipartFile file) {
        try {
            String originalFilename = file.getOriginalFilename();
            
            // 上传文件
            minioClient.putObject(PutObjectArgs.builder()
                    .bucket(minIOInfoConfig.getPrivateBucket())
                    .object(originalFilename)
                    .stream(file.getInputStream(), file.getSize(), -1)
                    .build()
            );
            // 判断文件是否存在
            
            // 获取访问地址
            
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

2、获取文件状态(是否存在)

@Service
public class MinIOService {
    
    @Resource
    private MinioClient minioClient;
    
    @Resource
    private MinIOInfoConfig minIOInfoConfig;
    
    public void fileState(String fileName) {
        try {
            StatObjectResponse response = minioClient.statObject(StatObjectArgs.builder()
                    .bucket(minIOInfoConfig.getPrivateBucket())
                    .object(fileName)
                    .build());
            System.out.println("response = " + response);
        } catch (Exception e) {
            log.error("文件不存在");
        }
    }
}

3、生成带签名公共访问连接

1、通过getPresignedObjectUrl方法，生成一个带到期时间、签名的URL，这个地址可以提供给没有登录的第三方共享访问或者上传对象，针对于Bucket为私有的情况。

2、对于共有的的文件，可以通过http://1ip:port/bucketName/fileName格式直接访问。

@Service
public class MinIOService {
    
    @Resource
    private MinioClient minioClient;
    
    @Resource
    private MinIOInfoConfig minIOInfoConfig;
    
    public String getPresignedObjectUrl(String fileName) {
        try {
            String presignedObjectUrl = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                    .bucket(minIOInfoConfig.getPrivateBucket())
                    .object(fileName)
                    // 设置过期时间，3分钟
                    .expiry(3, TimeUnit.MINUTES)
                    .method(Method.GET)
                    .build());
            System.out.println(presignedObjectUrl);

            return presignedObjectUrl;
        } catch (Exception e) {
            return "获取链接失败";
        }
    }
}

4、下载文件流

1、通过getObject()方法可以直接获取文件流，将文件流通过浏览器直接下；

2、使用该方式的好处是，在业务上可以由前端传入文件Id，服务端通过文件Id查询到文件名称再调用MinIO的API接口获取文件流，这样可以实现系统自身对文件的水平权限管理。

@Service
public class MinIOService {
    
    @Resource
    private MinioClient minioClient;
    
    @Resource
    private MinIOInfoConfig minIOInfoConfig;
    
    public void getObjectByStream(String fileName, HttpServletResponse response) {
        try {
            GetObjectResponse getObjectResponse = minioClient.getObject(GetObjectArgs.builder()
                    .bucket(minIOInfoConfig.getPrivateBucket())
                    .object(fileName)
                    .build());

            // 转化为流
            getObjectResponse.transferTo(response.getOutputStream());
        } catch (Exception e) {
            log.error("获取文件失败");
        }
    }
}

5、获取文件列表

@Service
public class MinIOService {
    
    @Resource
    private MinioClient minioClient;
    
    @Resource
    private MinIOInfoConfig minIOInfoConfig;
    
    public void listObjects() {
        try {
            Iterable<Result<Item>> listObjects = minioClient.listObjects(ListObjectsArgs.builder()
                    .bucket(minIOInfoConfig.getPrivateBucket())
                    // 以xx开头的文件名称
                    // .prefix("/")
                    .build());

            listObjects.forEach(itemResult -> {
                try {
                    Item item = itemResult.get();
                    log.info("文件名称：" + item.objectName());
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            });
        } catch (Exception e) {
            log.error("获取文件失败");
        }
    }
}

6、删除文件信息

@Service
public class MinIOService {
    
    @Resource
    private MinioClient minioClient;
    
    @Resource
    private MinIOInfoConfig minIOInfoConfig;
    
    public void removeObject(String fileName) {
        try {
            // 单个删除
            minioClient.removeObject(RemoveObjectArgs.builder()
                    .bucket(minIOInfoConfig.getPrivateBucket())
                    .object(fileName)
                    .build());

            // 批量删除
            List<DeleteObject> list = new ArrayList<>();
            list.add(new DeleteObject(fileName));
            minioClient.removeObjects(RemoveObjectsArgs.builder()
                    .bucket(minIOInfoConfig.getPrivateBucket())
                    .objects(list)
                    .build());
        } catch (Exception e) {
            log.error("删除文件失败");
        }
    }
}