第一步：下载minio服务安装包
去官网下载：MinIO | 用于创建高性能对象存储的代码和下载内容
minio的使用文档：MinIO Object Storage for Kubernetes — MinIO Object Storage for Kubernetes
MinIo有两个重要的对象，服务器minio.exe和客户端minio.client。搭建服务器用于接收文件信息，客户端用于上传文件。
官网下载有些慢
记住一点：如果是下载windows版本的，切记千万不能去双击运行，这样可能会导致最终启动失败；无论是windows还是linux都是通过命令启动的。
第二步：启动minio服务器
1.minio服务的启动命令
在windows环境下，在你的minio.exe文件所在位置的文件夹下（最好在同级路径下创建一个类似data的文件夹，用于存储数据），打开cmd命令框，
输入：minio.exe server D:\Java_study\javaEE-study\JAVA\minio\data （后面的数据存储路径文件夹是自定义的）
（如果是linux启动minio服务器，则在对应的minio存放的路径下输入：./minio server ./data）
2.访问minio服务器
打开浏览器输入上面的访问地址和端口即可访问minio服务器的ui界面
3.minio服务端主界面简单介绍
点开任意一个桶
4.纯java入门minio参考
package com.jdh.minio;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.List;
import io.minio.*;
import io.minio.messages.Bucket;
/**
* @ClassName: FileUploader
* @Author: jdh
* @CreateTime: 2022-04-15
* @Description: minio基本操作demo
*/
public class FileUploader {
public static void main(String[] args) {
try {
// 创建客户端
MinioClient minioClient =
MinioClient.builder()
// api地址
.endpoint("127.0.0.1",9000,true)
// .endpoint("http://127.0.0.1:9000")
// 前面设置的账号密码
.credentials("minioadmin", "minioadmin")
.build();
System.out.println(minioClient);
// 检查桶是否存在
boolean found = minioClient.bucketExists(BucketExistsArgs.builder().bucket("test").build());
if (!found) {
// 创建桶
minioClient.makeBucket(MakeBucketArgs.builder().bucket("test").build());
}
//列出所有桶名
List<Bucket> buckets = minioClient.listBuckets();
for (Bucket i : buckets){
System.out.println(i.name());
}
//删除某一个桶
// minioClient.removeBucket(
// RemoveBucketArgs.builder()
// .bucket("桶名称")
// .build());
System.out.println("开始你的操作");
File file = new File("D:\\Java_study\\javaEE-study\\user.xlsx");
String fileName = file.getName();
String realFileName = fileName.substring(fileName.lastIndexOf("\\")+1, fileName.lastIndexOf("."));
String fileType = fileName.substring(fileName.lastIndexOf(".")+1);
//通过路径上传一个文件
ObjectWriteResponse testDir = minioClient.uploadObject(
UploadObjectArgs.builder()
.bucket("test")
.object("user_Path1")//文件名字
.filename("D:\\Java_study\\javaEE-study\\user.xlsx")//文件存储的路径
.contentType(fileType)
.build());
//通过文件格式上传一个文件
InputStream fileInputStream = new FileInputStream(file);
long size = file.length();
minioClient.putObject(
PutObjectArgs.builder()
.bucket("test")
.object("user_File1")
.stream(fileInputStream, size, -1)
.contentType(fileType)
.build());
//文件下载，都是这种下载到指定路径
minioClient.downloadObject(DownloadObjectArgs.builder()
.bucket("test")
.object("user")
.filename("D:\\Java_study\\javaEE-study\\user_test.xlsx")
.build());
} catch (Exception e) {
e.printStackTrace();
}
}
}
第三步：java整合minio
此demo演示的是springboot项目整合minio，demo中minio版本是8.0.3，但参考版本最低7.x以上。
demo项目gitee连接：https://gitee.com/java_utils_demo/java_minio_demo.git
1.创建一个springboot的项目
2.在pom里面引入对应的依赖
（新手别忘记引入springboot的父依赖）
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
<!--此依赖为minio的服务依赖-->
<dependency>
<groupId>io.minio</groupId>
<artifactId>minio</artifactId>
<version>8.0.3</version>
</dependency>
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
<version>2.0.12</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>3.在application.yml配置文件配置
下面的配置实际可有可无，只是在创建minio的客户端的时候需要的一些连接服务端的一些相关配置信息
server:
port: 8080
# Minio配置
minio:
config:
ip: 127.0.0.1 #ip地址
port: 9000 # 端口号
accessKey: minioadmin # 账号
secretKey: minioadmin # 密码
secure: false #如果是true，则用的是https而不是http,默认值是true
bucketName: "jdh-bucket" # 桶的名字
downloadDir: "/data/excel" #保存到本地的路径
4.创建一个配置文件类
下面配置文件类就是通过spring的ConfigurationProperties注解完成配置文件中相关参数的注入
package com.jdh.minio.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* @ClassName: MinioProperties
* @Author: jdh
* @CreateTime: 2022-04-15
* @Description:
*/
@Component
@Data
@ConfigurationProperties(prefix = "minio.config")
public class MinioProperties {
/**
* API调用地址ip
*/
private String ip;
/**
* API调用地址端口
*/
private Integer port;
/**
* 连接账号
*/
private String accessKey;
/**
* 连接秘钥
*/
private String secretKey;
/**
* minio存储桶的名称
*/
private String bucketName;
/**
* 文件下载到本地的路径
*/
private String downloadDir;
/**
* #如果是true，则用的是https而不是http,默认值是true
*/
private Boolean secure;
}
5.封装一些简单的方法
如：获取一个minio连接客户端、文件上下传封装、创建\删除桶、列出所有桶\文件信息等
package com.jdh.minio.config;
import io.minio.*;
import io.minio.errors.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.DeleteObject;
import io.minio.messages.Item;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.time.LocalDateTime;
import java.time.ZonedDateTime;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
/**
* @ClassName: MinioFile
* @Author: jdh
* @CreateTime: 2022-04-15
* @Description:
*/
@Configuration
@Slf4j
public class MinioFileUtil {
@Resource
private MinioProperties minioProperties;
private MinioClient minioClient;
/**
* 这个是6.0.左右的版本
* @return MinioClient
*/
// @Bean
// public MinioClient getMinioClient(){
//
// String url = "http:" + minioProperties.getIp() + ":" + minioProperties.getPort();
//
// try {
// return new MinioClient(url, minioProperties.getAccessKey(), minioProperties.getSecretKey());
// } catch (InvalidEndpointException | InvalidPortException e) {
// e.printStackTrace();
// log.info("-----创建Minio客户端失败-----");
// return null;
// }
// }
/**
* 下面这个和上面的意思差不多，但是这个是新版本
* 获取一个连接minio服务端的客户端
*
* @return MinioClient
*/
@Bean
public MinioClient getClient() {
String url = "http:" + minioProperties.getIp() + ":" + minioProperties.getPort();
MinioClient minioClient = MinioClient.builder()
.endpoint(url) //两种都可以,这种全路径的其实就是下面分开配置一样的
// .endpoint(minioProperties.getIp(),minioProperties.getPort(),minioProperties.getSecure())
.credentials(minioProperties.getAccessKey(), minioProperties.getSecretKey())
.build();
this.minioClient = minioClient;
return minioClient;
}
/**
* 创建桶
*
* @param bucketName 桶名称
*/
public void createBucket(String bucketName) throws Exception {
if (!StringUtils.hasLength(bucketName)) {
throw new RuntimeException("创建桶的时候，桶名不能为空！");
}
// Create bucket with default region.
minioClient.makeBucket(MakeBucketArgs.builder()
.bucket(bucketName)
.build());
}
/**
* 创建桶,固定minio容器
*
* @param bucketName 桶名称
*/
public void createBucketByRegion(String bucketName, String region) throws Exception {
if (!StringUtils.hasLength(bucketName)) {
throw new RuntimeException("创建桶的时候，桶名不能为空！");
}
MinioClient minioClient = this.getClient();
// Create bucket with specific region.
minioClient.makeBucket(MakeBucketArgs.builder()
.bucket(bucketName)
.region(region) //
.build());
// // Create object-lock enabled bucket with specific region.
// minioClient.makeBucket(
// MakeBucketArgs.builder()
// .bucket("my-bucketname")
// .region("us-west-1")
// .objectLock(true)
// .build());
}
/**
* 修改桶名
* (minio不支持直接修改桶名，但是可以通过复制到一个新的桶里面，然后删除老的桶)
*
* @param oldBucketName 桶名称
* @param newBucketName 桶名称
*/
public void renameBucket(String oldBucketName, String newBucketName) throws Exception {
if (!StringUtils.hasLength(oldBucketName) || !StringUtils.hasLength(newBucketName)) {
throw new RuntimeException("修改桶名的时候，桶名不能为空！");
}
}
/**
* 删除桶
*
* @param bucketName 桶名称
*/
public void deleteBucket(String bucketName) throws Exception {
if (!StringUtils.hasLength(bucketName)) {
throw new RuntimeException("删除桶的时候，桶名不能为空！");
}
minioClient.removeBucket(
RemoveBucketArgs.builder()
.bucket(bucketName)
.build());
}
/**
* 检查桶是否存在
*
* @param bucketName 桶名称
* @return boolean true-存在 false-不存在
*/
public boolean checkBucketExist(String bucketName) throws Exception {
if (!StringUtils.hasLength(bucketName)) {
throw new RuntimeException("检测桶的时候，桶名不能为空！");
}
return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
}
/**
* 列出所有的桶
*
* @return 所有桶名的集合
*/
public List<Bucket> getAllBucketInfo() throws Exception {
//列出所有桶
List<Bucket> buckets = minioClient.listBuckets();
return buckets;
}
/**
* 列出某个桶中的所有文件名
* 文件夹名为空时，则直接查询桶下面的数据，否则就查询当前桶下对于文件夹里面的数据
*
* @param bucketName 桶名称
* @param folderName 文件夹名
* @param isDeep 是否递归查询
*/
public Iterable<Result<Item>> getBucketAllFile(String bucketName, String folderName, Boolean isDeep) throws Exception {
if (!StringUtils.hasLength(bucketName)) {
throw new RuntimeException("获取桶中文件列表的时候，桶名不能为空！");
}
if (!StringUtils.hasLength(folderName)) {
folderName = "";
}
System.out.println(folderName);
Iterable<Result<Item>> listObjects = minioClient.listObjects(
ListObjectsArgs
.builder()
.bucket(bucketName)
.prefix(folderName + "/")
.recursive(isDeep)
.build());
// for (Result<Item> result : listObjects) {
// Item item = result.get();
// System.out.println(item.objectName());
// }
return listObjects;
}
/**
* 删除文件夹
*
* @param bucketName 桶名
* @param objectName 文件夹名
* @param isDeep 是否递归删除
* @return
*/
public Boolean deleteBucketFile(String bucketName, String objectName) {
if (!StringUtils.hasLength(bucketName) || !StringUtils.hasLength(objectName)) {
throw new RuntimeException("删除文件的时候，桶名或文件名不能为空！");
}
try {
minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
return true;
} catch (Exception e) {
log.info("删除文件失败");
return false;
}
}
/**
* 删除文件夹
*
* @param bucketName 桶名
* @param objectName 文件夹名
* @param isDeep 是否递归删除
* @return
*/
public Boolean deleteBucketFolder(String bucketName, String objectName, Boolean isDeep) {
if (!StringUtils.hasLength(bucketName) || !StringUtils.hasLength(objectName)) {
throw new RuntimeException("删除文件夹的时候，桶名或文件名不能为空！");
}
try {
ListObjectsArgs args = ListObjectsArgs.builder().bucket(bucketName).prefix(objectName + "/").recursive(isDeep).build();
Iterable<Result<Item>> listObjects = minioClient.listObjects(args);
listObjects.forEach(objectResult -> {
try {
Item item = objectResult.get();
minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(item.objectName()).build());
} catch (Exception e) {
log.info("删除文件夹中的文件异常", e);
}
});
return true;
} catch (Exception e) {
log.info("删除文件夹失败");
return false;
}
}
/**
* 获取文件下载地址
*
* @param bucketName 桶名
* @param objectName 文件名
* @param expires 过期时间,默认秒
* @return
* @throws Exception
*/
public String getFileDownloadUrl(String bucketName, String objectName, Integer expires) throws Exception {
GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder()
.method(Method.GET)//下载地址的请求方式
.bucket(bucketName)
.object(objectName)
.expiry(expires, TimeUnit.SECONDS)//下载地址过期时间
.build();
String objectUrl = minioClient.getPresignedObjectUrl(args);
return objectUrl;
}
/**
* 获取文件上传地址(暂时还未实现)
*
* @param bucketName 桶名
* @param objectName 文件名
* @param expires 过期时间,默认秒
* @return
* @throws Exception
*/
public String getFileUploadUrl(String bucketName, String objectName, Integer expires) throws Exception {
// 过期时间
ZonedDateTime zonedDateTime = ZonedDateTime.now().plusSeconds(60);
PostPolicy postPolicy = new PostPolicy(bucketName, zonedDateTime);
// 获取对象的默认权限策略
StatObjectResponse statObjectResponse = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
String objectPolicy = statObjectResponse.headers().get("x-amz-object-policy");
String presignedObjectUrl = minioClient.getPresignedObjectUrl(
GetPresignedObjectUrlArgs.builder()
.bucket(bucketName)
.object(objectName)
.method(Method.POST)
.expiry(expires) // 预签名的 URL 有效期为 1 小时
.build());
MyMinioClient client = new MyMinioClient(minioClient);
return presignedObjectUrl;
}
/**
* 创建文件夹
*
* @param bucketName 桶名
* @param folderName 文件夹名称
* @return
* @throws Exception
*/
public ObjectWriteResponse createBucketFolder(String bucketName, String folderName) throws Exception {
if (!checkBucketExist(bucketName)) {
throw new RuntimeException("必须在桶存在的情况下才能创建文件夹");
}
if (!StringUtils.hasLength(folderName)) {
throw new RuntimeException("创建的文件夹名不能为空");
}
PutObjectArgs putObjectArgs = PutObjectArgs.builder()
.bucket(bucketName)
.object(folderName + "/")
.stream(new ByteArrayInputStream(new byte[0]), 0, 0)
.build();
ObjectWriteResponse objectWriteResponse = minioClient.putObject(putObjectArgs);
return objectWriteResponse;
}
/**
* 检测某个桶内是否存在某个文件
*
* @param objectName 文件名称
* @param bucketName 桶名称
*/
public boolean getBucketFileExist(String objectName, String bucketName) throws Exception {
if (!StringUtils.hasLength(objectName) || !StringUtils.hasLength(bucketName)) {
throw new RuntimeException("检测文件的时候，文件名和桶名不能为空！");
}
try {
// 判断文件是否存在
boolean exists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build()) &&
minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build()) != null;
return exists;
} catch (ErrorResponseException e) {
log.info("文件不存在 ! Object does not exist");
return false;
} catch (Exception e) {
throw new Exception(e);
}
}
/**
* 判断桶中是否存在文件夹
*
* @param bucketName 同名称
* @param objectName 文件夹名称
* @param isDeep 是否递归查询(暂不支持)
* @return
*/
public Boolean checkBucketFolderExist(String bucketName, String objectName, Boolean isDeep) {
Iterable<Result<Item>> results = minioClient.listObjects(
ListObjectsArgs.builder().bucket(bucketName).prefix(objectName).recursive(isDeep).build());
return results.iterator().hasNext(); // 文件夹下存在文件
}
/**
* 根据MultipartFile file上传文件
* minio 采用文件流上传，可以换成下面的文件上传
*
* @param file 上传的文件
* @param bucketName 上传至服务器的桶名称
*/
public boolean uploadFile(MultipartFile file, String bucketName) throws Exception {
if (file == null || file.getSize() == 0 || file.isEmpty()) {
throw new RuntimeException("上传文件为空，请重新上传");
}
if (!StringUtils.hasLength(bucketName)) {
log.info("传入桶名为空，将设置默认桶名：" + minioProperties.getBucketName());
bucketName = minioProperties.getBucketName();
if (!this.checkBucketExist(minioProperties.getBucketName())) {
this.createBucket(minioProperties.getBucketName());
}
}
if (!this.checkBucketExist(bucketName)) {
throw new RuntimeException("当前操作的桶不存在！");
}
// 获取上传的文件名
String filename = file.getOriginalFilename();
assert filename != null;
//可以选择生成一个minio中存储的文件名称
String minioFilename = UUID.randomUUID().toString() + "_" + filename;
String url = "http:" + minioProperties.getIp() + ":" + minioProperties.getPort();
InputStream inputStream = file.getInputStream();
long size = file.getSize();
String contentType = file.getContentType();
// Upload known sized input stream.
minioClient.putObject(
PutObjectArgs.builder()
.bucket(bucketName) //上传到指定桶里面
.object(minioFilename)//文件在minio中存储的名字
//p1:上传的文件流；p2:上传文件总大小；p3：上传的分片大小
.stream(inputStream, size, -1) //上传分片文件流大小，如果分文件上传可以采用这种形式
.contentType(contentType) //文件的类型
.build());
return this.getBucketFileExist(minioFilename, bucketName);
}
/**
* 上传本地文件，根据路径上传
* minio 采用文件内容上传，可以换成上面的流上传
*
* @param filePath 上传本地文件路径
* @Param bucketName 上传至服务器的桶名称
*/
public boolean uploadPath(String filePath, String bucketName) throws Exception {
File file = new File(filePath);
if (!file.isFile()) {
throw new RuntimeException("上传文件为空，请重新上传");
}
if (!StringUtils.hasLength(bucketName)) {
log.info("传入桶名为空，将设置默认桶名：" + minioProperties.getBucketName());
bucketName = minioProperties.getBucketName();
if (!this.checkBucketExist(minioProperties.getBucketName())) {
this.createBucket(minioProperties.getBucketName());
}
}
if (!this.checkBucketExist(bucketName)) {
throw new RuntimeException("当前操作的桶不存在！");
}
String minioFilename = UUID.randomUUID().toString() + "_" + file.getName();//获取文件名称
String fileType = minioFilename.substring(minioFilename.lastIndexOf(".") + 1);
minioClient.uploadObject(
UploadObjectArgs.builder()
.bucket(bucketName)
.object(minioFilename)//文件存储在minio中的名字
.filename(filePath)//上传本地文件存储的路径
.contentType(fileType)//文件类型
.build());
return this.getBucketFileExist(minioFilename, bucketName);
}
/**
* 文件下载,通过http返回，即在浏览器下载
*
* @param response http请求的响应对象
* @param bucketName 下载指定服务器的桶名称
* @param objectName 下载的文件名称
*/
public void downloadFile(HttpServletResponse response, String bucketName, String objectName) throws Exception {
if (response == null || !StringUtils.hasLength(bucketName) || !StringUtils.hasLength(objectName)) {
throw new RuntimeException("下载文件参数不全！");
}
if (!this.checkBucketExist(bucketName)) {
throw new RuntimeException("当前操作的桶不存在！");
}
//获取一个下载的文件输入流操作
GetObjectResponse objectResponse = minioClient.getObject(
GetObjectArgs.builder()
.bucket(bucketName)
.object(objectName)
.build());
OutputStream outputStream = response.getOutputStream();
int len = 0;
byte[] buf = new byte[1024 * 8];
while ((len = objectResponse.read(buf)) != -1) {
outputStream.write(buf, 0, len);
}
if (outputStream != null) {
outputStream.close();
outputStream.flush();
}
objectResponse.close();
}
/**
* 文件下载到指定路径
*
* @param downloadPath 下载到本地路径
* @param bucketName 下载指定服务器的桶名称
* @param objectName 下载的文件名称
*/
public void downloadPath(String downloadPath, String bucketName, String objectName) throws Exception {
if (downloadPath.isEmpty() || !StringUtils.hasLength(bucketName) || !StringUtils.hasLength(objectName)) {
throw new RuntimeException("下载文件参数不全！");
}
if (!new File(downloadPath).isDirectory()) {
throw new RuntimeException("本地下载路径必须是一个文件夹或者文件路径！");
}
if (!this.checkBucketExist(bucketName)) {
throw new RuntimeException("当前操作的桶不存在！");
}
downloadPath += objectName;
minioClient.downloadObject(
DownloadObjectArgs.builder()
.bucket(bucketName) //指定是在哪一个桶下载
.object(objectName)//是minio中文件存储的名字;本地上传的文件是user.xlsx到minio中存储的是user-minio,那么这里就是user-minio
.filename(downloadPath)//需要下载到本地的路径，一定是带上保存的文件名；如 d:\\minio\\user.xlsx
.build());
}
}6.对上面封装的方法进行验证
可以在controller中写http接口来进行验证，本文采用的单元测试进行验证。
package com.jdh.minio.config;
import io.minio.*;
import io.minio.messages.Bucket;
import io.minio.messages.Item;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.commons.CommonsMultipartFile;
import java.io.*;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
@SpringBootTest
class MinioFileUtilTest {
@Autowired
private MinioFileUtil minioFileUtil;
/**
* 创建一个桶
*/
@Test
void createBucket() throws Exception {
minioFileUtil.createBucket("minio-file");
/**
这里创建桶的命名规则在默认情况下有要求
用于存储 CloudTrail 日志文件的 Amazon S3 存储桶的名称必须符合非美国标准区域的命名要求。
Amazon S3 存储桶的命名需符合以下一个或多个规则（用句点分隔开）：
1.存储桶名称的长度介于 3 和 63 个字符之间，并且只能包含小写字母、数字、句点和短划线。
2.存储桶名称中的每个标签必须以小写字母或数字开头。
3.存储桶名称不能包含下划线、以短划线结束、包含连续句点或在句点旁边使用短划线。
4.存储桶名称不能采用 IP 地址格式 (198.51.100.24)。
*/
boolean minioFile = minioFileUtil.checkBucketExist("minio-file");
System.out.println(minioFile);
}
/**
* 创建一个桶
*/
@Test
void createBucketByRegion() throws Exception {
minioFileUtil.createBucketByRegion("minio-file", "minio-region");
boolean minioFile = minioFileUtil.checkBucketExist("minio-file");
System.out.println(minioFile);
}
/**
* 删除一个桶
*/
@Test
void deleteBucket() throws Exception {
minioFileUtil.deleteBucket("minio-file");
boolean minioFile = minioFileUtil.checkBucketExist("minio-file");
System.out.println(minioFile);
}
/**
* 检测桶是否存在
*/
@Test
void checkBucketExist() throws Exception {
boolean test = minioFileUtil.checkBucketExist("test");
System.out.println(test);
}
/**
* 获取所有的桶信息
*/
@Test
void getAllBucketInfo() throws Exception {
List<Bucket> allBucketName = minioFileUtil.getAllBucketInfo();
allBucketName.forEach(e -> System.out.println(e.name()));
}
/**
* 获取某个桶中的全部文件
*/
@Test
void getBucketAllFile() throws Exception {
Iterable<Result<Item>> allFile = minioFileUtil.getBucketAllFile("minio-folder", "part", true);
for (Result<Item> result : allFile) {
Item item = result.get();
System.out.println(item.objectName());
}
}
/**
* 检测某个桶中是否存在某个文件
*/
@Test
void getBucketFileExist() throws Exception {
boolean fileExist = minioFileUtil.getBucketFileExist("8aa570f9-53f5-4cb5-a0d1-c122ef4e3f89_出师表.docx", "minio-bucket");
System.out.println(fileExist);
}
/**
* 删除桶中的一个文件
*
* @throws Exception
*/
@Test
void deleteBucketFile() throws Exception {
Boolean b = minioFileUtil.deleteBucketFile("minio-folder", "出师表.docx");
System.out.println(b);
}
/**
* 删除桶中的一个文件夹
*
* @throws Exception
*/
@Test
void deleteBucketFolder() throws Exception {
boolean b = minioFileUtil.deleteBucketFolder("minio-folder", "tempFile", true);
System.out.println(b);
}
/**
* 获取文件下载路径
*/
@Test
void getFileDownloadUrl() throws Exception {
String fileUrl = minioFileUtil.getFileDownloadUrl("minio-bucket", "出师表.docx", 60);
System.out.println(fileUrl);
}
/**
* 获取文件上传路径
*/
@Test
void getFileUploadUrl() throws Exception {
String fileUrl = minioFileUtil.getFileUploadUrl("minio-bucket", "出师表1.docx", 3600);
System.out.println(fileUrl);
}
/**
* 在一个桶中创建一个空文件夹
*
* @throws Exception
*/
@Test
void createBucketFolder() throws Exception {
String buckName = "minio-bucket";
String folderName = "part";
ObjectWriteResponse bucketFolder = minioFileUtil.createBucketFolder(buckName, folderName);
}
/**
* 在一个桶中创建一个空文件夹
*
* @throws Exception
*/
@Test
void checkBucketFolderExist() throws Exception {
Boolean tempFile = minioFileUtil.checkBucketFolderExist("minio-bucket", "down", true);
System.out.println(tempFile);
}
/**
* 文件上传，通过MultipartFile形式
*/
@Test
void uploadFile() throws Exception {
File file = new File("D:\\file\\出师表.docx");
FileInputStream fileInputStream = new FileInputStream(file);
String fileName = file.getName();
MockMultipartFile multipartFile = new MockMultipartFile(fileName, fileName, "docx", fileInputStream);
boolean uploadFile = minioFileUtil.uploadFile(multipartFile, "minio-folder");
System.out.println(uploadFile);
}
/**
* 文件上传，通过本地路径
*
* @throws Exception
*/
@Test
void uploadPath() throws Exception {
boolean uploadPath = minioFileUtil.uploadPath("D:\\file\\出师表.docx", "minio-bucket");
System.out.println(uploadPath);
}
/**
* 文件下载，通过http响应下载
*/
@Test
void downloadFile() {
//这里可以使用模拟请求来验证
}
/**
* 文件下载，通过路径直接下载到本地
*
* @throws Exception
*/
@Test
void downloadPath() throws Exception {
MinioClient client = minioFileUtil.getClient();
minioFileUtil.downloadPath("D:\\file\\", "minio-bucket", "8aa570f9-53f5-4cb5-a0d1-c122ef4e3f89_出师表.docx");
}
}7.验证结果
通过访问minio的服务端界面查看功能是否验证通过
文章出处登录后可见！
已经登录？立即刷新
