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

目录

• 1、Bucket、Object
• 2、常用API
• 3、整合SpringBoot
• 3.1、yaml配置
• 3.2、MinIo配置
• 3.3、Bucket 操作
• 3.4、Object操作

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 操作

上传文件前，需要先进行B编程客栈ucket 的创建操作，可以直接到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(bucket编程客栈Name).build());
            // 再次判断
            bucketExists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            Systemhttp://www.devze.com.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("删除文件失败");
        }
    }
}

到此这篇关于SpringBoot整合Minio(支持公有及私有bucket)的文章就介绍到这了,更多相关SpringBoot整合Minio内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！