SpringBoot三十六：整合MinIo文件服务

最新推荐文章于 2024-05-10 10:31:54 发布
最新推荐文章于 2024-05-10 10:31:54 发布
阅读量6.6k 收藏 46
点赞数 10
分类专栏： # SpringBoot 文章标签： docker java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45730091/article/details/106780517
版权

文章目录

什么是MinIo

Minio是Apcche旗下的一款开源的轻量级文件服务器，基于对象存储，协议是基于Apache License v2.0，开源可用于商务。

Minio主要用来存储非结构化的数据，类似文件，图片，照片，日志文件，各类备份文件等，按照官网描述，文件的大小从几KB到5TB。

Minio提供了非常方便，友好的界面，并且文档也是非常丰富，具体可以参考它的文档：https://docs.min.io/cn/

为什么选择MinIo

在之前开发中曾使用了分布式文件服务FASTDFS和阿里云的OSS对象存储来存储。奈何OSS太贵，FASTDFS搭建配置又太繁琐，今天给大家推荐一款极易上手的高性能对象存储服务MinIo。

MinIO 是高性能的对象存储，兼容 Amazon S3接口，充分考虑开发人员的需求和体验；支持分布式存储，具备高扩展性、高可用性；部署简单但功能丰富。官方的文档也很详细。它有多种不同的部署模式（单机部署，分布式部署）。

为什么说 MinIO 简单易用，原因就在于它的启动、运行和配置都很简单。可以通过 docker 方式进行安装运行，也可以下载二进制文件，然后使用脚本运行。

安装MinIo

推荐使用 docker 一键安装：

docker run -it -p 9000:9000 --name minio \
-d --restart=always \
-e "MINIO_ACCESS_KEY=admin" \
-e "MINIO_SECRET_KEY=admin123456" \
-v /mnt/minio/data:/data \
-v /mnt/minio/config:/root/.minio \
minio/minio server /data

注意：

  • 密钥必须大于8位，否则会创建失败
  • 文件目录和配置文件一定要映射到主机，你懂得

整合Nginx

server{
    listen 80;
    server_name minio.javakf.com.cn;
    location /{
        proxy_set_header Host $http_host;
        proxy_pass http://localhost:9000;
    }
    location ~ /\.ht {
        deny  all;
    }
}

这样，通过浏览器访问配置的地址，使用指定的 MINIO_ACCESS_KEY 及 MINIO_SECRET_KEY 登录即可。

简单看了一下，功能还算可以，支持创建Bucket，文件上传、删除、分享、下载，同时可以对Bucket设置读写权限。

整合SpringBoot

Minio支持接入JavaScript、Java、Python、Golang等多种语言，这里我们选择最熟悉的Java语言，使用最流行的框架 SpringBoot。

pom.xml

<dependency>
	<groupId>io.minio</groupId>
	<artifactId>minio</artifactId>
	<version>7.0.2</version>
</dependency>
<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
</dependency>

application.yml

#minio配置
minio:
  endpoint: http://192.168.179.131:9000/
  accessKey: admin
  secretKey: admin123456

Minio客户端配置类，并注入到Spring中

@Data
@Configuration
@ConfigurationProperties(prefix = "minio")
public class MinioConfig {

	private String endpoint;
	private String accessKey;
	private String secretKey;

	@Bean
	public MinioClient getMinioClient() throws InvalidEndpointException, InvalidPortException {
		MinioClient minioClient = new MinioClient(endpoint, accessKey, secretKey);
		return minioClient;
	}

}

工具类

@Component
public class MinioUtil {

	@Autowired
	private MinioClient minioClient;

	private static final int DEFAULT_EXPIRY_TIME = 7 * 24 * 3600;

	/**
	 * 检查存储桶是否存在
	 * 
	 * @param bucketName 存储桶名称
	 * @return
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 */
	public boolean bucketExists(String bucketName) throws InvalidKeyException, ErrorResponseException,
			IllegalArgumentException, InsufficientDataException, InternalException, InvalidBucketNameException,
			InvalidResponseException, NoSuchAlgorithmException, XmlParserException, IOException {
		boolean flag = minioClient.bucketExists(bucketName);
		if (flag) {
			return true;
		}
		return false;
	}

	/**
	 * 创建存储桶
	 * 
	 * @param bucketName 存储桶名称
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 * @throws RegionConflictException
	 */
	public boolean makeBucket(String bucketName)
			throws InvalidKeyException, ErrorResponseException, IllegalArgumentException, InsufficientDataException,
			InternalException, InvalidBucketNameException, InvalidResponseException, NoSuchAlgorithmException,
			XmlParserException, IOException, RegionConflictException {
		boolean flag = bucketExists(bucketName);
		if (!flag) {
			minioClient.makeBucket(bucketName);
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 列出所有存储桶名称
	 * 
	 * @return
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 */
	public List<String> listBucketNames() throws InvalidKeyException, ErrorResponseException, IllegalArgumentException,
			InsufficientDataException, InternalException, InvalidBucketNameException, InvalidResponseException,
			NoSuchAlgorithmException, XmlParserException, IOException {
		List<Bucket> bucketList = listBuckets();
		List<String> bucketListName = new ArrayList<>();
		for (Bucket bucket : bucketList) {
			bucketListName.add(bucket.name());
		}
		return bucketListName;
	}

	/**
	 * 列出所有存储桶
	 * 
	 * @return
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 */
	public List<Bucket> listBuckets() throws InvalidKeyException, ErrorResponseException, IllegalArgumentException,
			InsufficientDataException, InternalException, InvalidBucketNameException, InvalidResponseException,
			NoSuchAlgorithmException, XmlParserException, IOException {
		return minioClient.listBuckets();
	}

	/**
	 * 删除存储桶
	 * 
	 * @param bucketName 存储桶名称
	 * @return
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 */
	public boolean removeBucket(String bucketName) throws InvalidKeyException, ErrorResponseException,
			IllegalArgumentException, InsufficientDataException, InternalException, InvalidBucketNameException,
			InvalidResponseException, NoSuchAlgorithmException, XmlParserException, IOException {
		boolean flag = bucketExists(bucketName);
		if (flag) {
			Iterable<Result<Item>> myObjects = listObjects(bucketName);
			for (Result<Item> result : myObjects) {
				Item item = result.get();
				// 有对象文件，则删除失败
				if (item.size() > 0) {
					return false;
				}
			}
			// 删除存储桶，注意，只有存储桶为空时才能删除成功。
			minioClient.removeBucket(bucketName);
			flag = bucketExists(bucketName);
			if (!flag) {
				return true;
			}

		}
		return false;
	}

	/**
	 * 列出存储桶中的所有对象名称
	 * 
	 * @param bucketName 存储桶名称
	 * @return
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 */
	public List<String> listObjectNames(String bucketName) throws InvalidKeyException, ErrorResponseException,
			IllegalArgumentException, InsufficientDataException, InternalException, InvalidBucketNameException,
			InvalidResponseException, NoSuchAlgorithmException, XmlParserException, IOException {
		List<String> listObjectNames = new ArrayList<>();
		boolean flag = bucketExists(bucketName);
		if (flag) {
			Iterable<Result<Item>> myObjects = listObjects(bucketName);
			for (Result<Item> result : myObjects) {
				Item item = result.get();
				listObjectNames.add(item.objectName());
			}
		}
		return listObjectNames;
	}

	/**
	 * 列出存储桶中的所有对象
	 * 
	 * @param bucketName 存储桶名称
	 * @return
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 */
	public Iterable<Result<Item>> listObjects(String bucketName) throws InvalidKeyException, ErrorResponseException,
			IllegalArgumentException, InsufficientDataException, InternalException, InvalidBucketNameException,
			InvalidResponseException, NoSuchAlgorithmException, XmlParserException, IOException {
		boolean flag = bucketExists(bucketName);
		if (flag) {
			return minioClient.listObjects(bucketName);
		}
		return null;
	}

	/**
	 * 通过文件上传到对象
	 * 
	 * @param bucketName 存储桶名称
	 * @param objectName 存储桶里的对象名称
	 * @param fileName   File name
	 * @return
	 * @throws InvalidKeyException
	 * @throws ErrorResponseException
	 * @throws IllegalArgumentException
	 * @throws InsufficientDataException
	 * @throws InternalException
	 * @throws InvalidBucketNameException
	 * @throws InvalidResponseException
	 * @throws NoSuchAlgorithmException
	 * @throws XmlParserException
	 * @throws IOException
	 */
	public boolean putObject(String bucketName, String objectName, String fileName)
			throws InvalidKeyException, ErrorResponseException, IllegalArgumentException, InsufficientDataException,
			InternalException, InvalidBucketNameException, InvalidResponseException, NoSuchAlgorithmException,
			XmlParserException, IOException {
		boolean flag = bucketExists(bucketName);
		if (flag) {
			minioClient.putObject(bucketName, objectName, fileName, null);
			ObjectStat statObject = statObject(bucketName, objectName);
			if (statObject != null && statObject.length() > 0) {
				return true;
			}
		}
		return false;

	}

	/**
	 * 通过InputStream上传对象
	 * 
	 * @param bucketName 存储桶名称
	 * @param objectName 存储桶里的对象名称
	 * @param stream     要上传的流
	 * @return
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 */
	public boolean putObject(String bucketName, String objectName, InputStream stream)
			throws InvalidKeyException, ErrorResponseException, IllegalArgumentException, InsufficientDataException,
			InternalException, InvalidBucketNameException, InvalidResponseException, NoSuchAlgorithmException,
			XmlParserException, IOException {
		boolean flag = bucketExists(bucketName);
		if (flag) {
			minioClient.putObject(bucketName, objectName, stream, new PutObjectOptions(stream.available(), -1));
			ObjectStat statObject = statObject(bucketName, objectName);
			if (statObject != null && statObject.length() > 0) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 以流的形式获取一个文件对象
	 * 
	 * @param bucketName 存储桶名称
	 * @param objectName 存储桶里的对象名称
	 * @return
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 */
	public InputStream getObject(String bucketName, String objectName)
			throws InvalidKeyException, ErrorResponseException, IllegalArgumentException, InsufficientDataException,
			InternalException, InvalidBucketNameException, InvalidResponseException, NoSuchAlgorithmException,
			XmlParserException, IOException {
		boolean flag = bucketExists(bucketName);
		if (flag) {
			ObjectStat statObject = statObject(bucketName, objectName);
			if (statObject != null && statObject.length() > 0) {
				InputStream stream = minioClient.getObject(bucketName, objectName);
				return stream;
			}
		}
		return null;
	}

	/**
	 * 以流的形式获取一个文件对象（断点下载）
	 * 
	 * @param bucketName 存储桶名称
	 * @param objectName 存储桶里的对象名称
	 * @param offset     起始字节的位置
	 * @param length     要读取的长度 (可选，如果无值则代表读到文件结尾)
	 * @return
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 */
	public InputStream getObject(String bucketName, String objectName, long offset, Long length)
			throws InvalidKeyException, ErrorResponseException, IllegalArgumentException, InsufficientDataException,
			InternalException, InvalidBucketNameException, InvalidResponseException, NoSuchAlgorithmException,
			XmlParserException, IOException {
		boolean flag = bucketExists(bucketName);
		if (flag) {
			ObjectStat statObject = statObject(bucketName, objectName);
			if (statObject != null && statObject.length() > 0) {
				InputStream stream = minioClient.getObject(bucketName, objectName, offset, length);
				return stream;
			}
		}
		return null;
	}

	/**
	 * 下载并将文件保存到本地
	 * 
	 * @param bucketName 存储桶名称
	 * @param objectName 存储桶里的对象名称
	 * @param fileName   File name
	 * @return
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 */
	public boolean getObject(String bucketName, String objectName, String fileName)
			throws InvalidKeyException, ErrorResponseException, IllegalArgumentException, InsufficientDataException,
			InternalException, InvalidBucketNameException, InvalidResponseException, NoSuchAlgorithmException,
			XmlParserException, IOException {
		boolean flag = bucketExists(bucketName);
		if (flag) {
			ObjectStat statObject = statObject(bucketName, objectName);
			if (statObject != null && statObject.length() > 0) {
				minioClient.getObject(bucketName, objectName, fileName);
				return true;
			}
		}
		return false;
	}

	/**
	 * 删除一个对象
	 * 
	 * @param bucketName 存储桶名称
	 * @param objectName 存储桶里的对象名称
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 */
	public boolean removeObject(String bucketName, String objectName)
			throws InvalidKeyException, ErrorResponseException, IllegalArgumentException, InsufficientDataException,
			InternalException, InvalidBucketNameException, InvalidResponseException, NoSuchAlgorithmException,
			XmlParserException, IOException {
		boolean flag = bucketExists(bucketName);
		if (flag) {
			minioClient.removeObject(bucketName, objectName);
			return true;
		}
		return false;

	}

	/**
	 * 删除指定桶的多个文件对象,返回删除错误的对象列表，全部删除成功，返回空列表
	 * 
	 * @param bucketName  存储桶名称
	 * @param objectNames 含有要删除的多个object名称的迭代器对象
	 * @return
	 * @throws InvalidKeyException
	 * @throws ErrorResponseException
	 * @throws IllegalArgumentException
	 * @throws InsufficientDataException
	 * @throws InternalException
	 * @throws InvalidBucketNameException
	 * @throws InvalidResponseException
	 * @throws NoSuchAlgorithmException
	 * @throws XmlParserException
	 * @throws IOException
	 */
	public List<String> removeObject(String bucketName, List<String> objectNames)
			throws InvalidKeyException, ErrorResponseException, IllegalArgumentException, InsufficientDataException,
			InternalException, InvalidBucketNameException, InvalidResponseException, NoSuchAlgorithmException,
			XmlParserException, IOException {
		List<String> deleteErrorNames = new ArrayList<>();
		boolean flag = bucketExists(bucketName);
		if (flag) {
			Iterable<Result<DeleteError>> results = minioClient.removeObjects(bucketName, objectNames);
			for (Result<DeleteError> result : results) {
				DeleteError error = result.get();
				deleteErrorNames.add(error.objectName());
			}
		}
		return deleteErrorNames;
	}

	/**
	 * 生成一个给HTTP GET请求用的presigned URL。
	 * 浏览器/移动端的客户端可以用这个URL进行下载，即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间，默认值是7天。
	 * 
	 * @param bucketName 存储桶名称
	 * @param objectName 存储桶里的对象名称
	 * @param expires    失效时间（以秒为单位），默认是7天，不得大于七天
	 * @return
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 * @throws InvalidExpiresRangeException
	 */
	public String presignedGetObject(String bucketName, String objectName, Integer expires)
			throws InvalidKeyException, ErrorResponseException, IllegalArgumentException, InsufficientDataException,
			InternalException, InvalidBucketNameException, InvalidResponseException, NoSuchAlgorithmException,
			XmlParserException, IOException, InvalidExpiresRangeException {
		boolean flag = bucketExists(bucketName);
		String url = "";
		if (flag) {
			if (expires < 1 || expires > DEFAULT_EXPIRY_TIME) {
				throw new InvalidExpiresRangeException(expires,
						"expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
			}
			url = minioClient.presignedGetObject(bucketName, objectName, expires);
		}
		return url;
	}

	/**
	 * 生成一个给HTTP PUT请求用的presigned URL。
	 * 浏览器/移动端的客户端可以用这个URL进行上传，即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间，默认值是7天。
	 * 
	 * @param bucketName 存储桶名称
	 * @param objectName 存储桶里的对象名称
	 * @param expires    失效时间（以秒为单位），默认是7天，不得大于七天
	 * @return
	 * @throws InvalidKeyException
	 * @throws ErrorResponseException
	 * @throws IllegalArgumentException
	 * @throws InsufficientDataException
	 * @throws InternalException
	 * @throws InvalidBucketNameException
	 * @throws InvalidResponseException
	 * @throws NoSuchAlgorithmException
	 * @throws XmlParserException
	 * @throws IOException
	 * @throws InvalidExpiresRangeException
	 */
	public String presignedPutObject(String bucketName, String objectName, Integer expires)
			throws InvalidKeyException, ErrorResponseException, IllegalArgumentException, InsufficientDataException,
			InternalException, InvalidBucketNameException, InvalidResponseException, NoSuchAlgorithmException,
			XmlParserException, IOException, InvalidExpiresRangeException {
		boolean flag = bucketExists(bucketName);
		String url = "";
		if (flag) {
			if (expires < 1 || expires > DEFAULT_EXPIRY_TIME) {
				throw new InvalidExpiresRangeException(expires,
						"expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
			}
			url = minioClient.presignedPutObject(bucketName, objectName, expires);
		}
		return url;
	}

	/**
	 * 获取对象的元数据
	 * 
	 * @param bucketName 存储桶名称
	 * @param objectName 存储桶里的对象名称
	 * @return
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 */
	public ObjectStat statObject(String bucketName, String objectName)
			throws InvalidKeyException, ErrorResponseException, IllegalArgumentException, InsufficientDataException,
			InternalException, InvalidBucketNameException, InvalidResponseException, NoSuchAlgorithmException,
			XmlParserException, IOException {
		boolean flag = bucketExists(bucketName);
		if (flag) {
			ObjectStat statObject = minioClient.statObject(bucketName, objectName);
			return statObject;
		}
		return null;
	}

	/**
	 * 文件访问路径
	 * 
	 * @param bucketName 存储桶名称
	 * @param objectName 存储桶里的对象名称
	 * @return
	 * @throws IOException
	 * @throws XmlParserException
	 * @throws NoSuchAlgorithmException
	 * @throws InvalidResponseException
	 * @throws InvalidBucketNameException
	 * @throws InternalException
	 * @throws InsufficientDataException
	 * @throws IllegalArgumentException
	 * @throws ErrorResponseException
	 * @throws InvalidKeyException
	 */
	public String getObjectUrl(String bucketName, String objectName) throws InvalidKeyException, ErrorResponseException,
			IllegalArgumentException, InsufficientDataException, InternalException, InvalidBucketNameException,
			InvalidResponseException, NoSuchAlgorithmException, XmlParserException, IOException {
		boolean flag = bucketExists(bucketName);
		String url = "";
		if (flag) {
			url = minioClient.getObjectUrl(bucketName, objectName);
		}
		return url;
	}

}

目前SDK不支持文件夹的创建，如果想创建文件夹，只能通过文件的方式上传并创建。

minIoUtils.putObject("javakf","test/1.jpg","C:\\1.jpg");

一个实例只能有一个账号，如果想使用多个账号，需要创建多个实例。此外 minio还支持单主机，多块磁盘以及分布式部署，不过对于大部分单体应用来说，单体已经够用了。

上传文件

@RestController
public class MinioController {

	@Autowired
	private MinioUtil minioUtil;

	@PostMapping("/upload")
	public String MinIOUpload(MultipartFile file) {
		if (file.isEmpty() || file.getSize() == 0) {
			return "文件为空";
		}
		try {
			if (!minioUtil.bucketExists("javakf")) {
				minioUtil.makeBucket("javakf");
			}

			String fileName = file.getOriginalFilename();
			String newName = "image/" + UUID.randomUUID().toString().replaceAll("-", "")
					+ fileName.substring(fileName.lastIndexOf("."));

			InputStream inputStream = file.getInputStream();
			minioUtil.putObject("javakf", newName, inputStream);
			inputStream.close();

			String url = minioUtil.getObjectUrl("javakf", newName);
			return url;
		} catch (Exception e) {
			e.printStackTrace();
			return "上传失败";
		}
	}

}

postman测试

在这里插入图片描述

访问配置

MinIO形式上传的文件也不能直接访问，需要设置bucket的policy策略
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
3.0.10版本： minioClient.setBucketPolicy("javakf", "image", PolicyType.READ_ONLY);

参数类型描述
bucketNameString存储桶名称
objectPrefixString对象前缀
policyPolicyType要赋予的策略，可选值有[PolicyType.NONE, PolicyType.READ_ONLY, PolicyType.READ_WRITE, PolicyType.WRITE_ONLY]

代码托管：springboot_minio

​​
关注
  • 10
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SpringBoot(31) 整合MinIO实现文件上传与下载
08-17
在本教程中，我们将深入探讨如何使用SpringBoot框架与MinIO进行集成，以实现文件的上传和下载功能。SpringBoot以其简洁的配置和强大的功能深受Java开发者喜爱，而MinIO则是一个高性能的对象存储服务器，适合处理大...
minio 安装步骤以及springboot 如何集成minio
08-07
将MinIO集成到SpringBoot应用中，可以方便地管理和使用对象存储服务。下面我们将详细探讨MinIO的安装过程以及如何在SpringBoot应用中进行集成。 ### MinIO的安装步骤 1. **下载MinIO**: 首先，你需要从MinIO的官方...
Minio文件服务器(超详细!)
weixin_48911650的博客
08-19 1089
使用Minio存储文件
SpringBoot + minio 实现高性能存储服务
weixin_45647685的博客
09-24 1798
说白了，minio就是一个高性能的对象存储。就像我们用的百度网盘一样，可以用来存各种各样的文件，我们可以将静态资源文件 图片视频啥的存储在minio中，减少服务器的压力。和阿里云的OSS对象存储服务 一样。minio官网：https://min.io/
minio安装配置（2024）
最新发布
LB_bei的博客
05-10 1271
cmd的方式打开minio.exe所在的文件夹。
Minio搭建文件服务器
m0_50281408的博客
03-10 1315
目前可用于文件存储的网络服务选择也有不少，比如阿里云OSS、七牛云、腾讯云等等，可是收费都有点小贵。为了节约成本，很多公司使用MinIO做为文件服务器。官网：https://www.minio.org.cn/MinIO是一个开源的分布式对象存储服务器，支持S3协议并且可以在多节点上实现数据的高可用和容错。它采用Go语言开发，拥有轻量级、高性能、易部署等特点，并且可以自由选择底层存储介质。它基于Apache License 开源协议，兼容Amazon S3云存储接口。
SpringBoot整合MinIO
w1245247503的博客
02-27 902
MinIO的安装和运行以及SpringBoot整合MinIO
SpringBoot集成Minio实战详解
weixin_46242847的博客
02-06 2309
本博客旨在快速使用sringBoot集成MinIo,具有很强的使用性和参考意义，可减少初学者的学习成本，快速提高技术。
SpringBoot2 整合MinIO中间件实现文件便捷管理功能
08-18
SpringBoot2 整合 MinIO 中间件...SpringBoot2 整合 MinIO 中间件可以实现文件便捷管理功能，主要通过 MinIO 简介、MinIO 存储机制、MinIO 环境搭建、SpringBoot 整合 MinIO、MinIO 配置类和文件上传六个方面来实现。
Spring boot整合MinIO客户端实现文件管理
06-27
本项目集成Minio的java客户端SDK，对Minio文件服务器进行读写，将操作封装为MinioUtil工具，直接在项目中可以复用。其操作主要包括： 上传文件 下载文件 读取桶列表 读取桶中的文件列表 删除桶 删除文件 Spring ...
SpringBoot整合minio
03-31
**SpringBoot整合MinIO详解** 在现代Web应用开发中，数据存储和文件管理是一个不可或缺的部分。SpringBoot作为Java领域的一款轻量级框架，为开发者提供了快速构建应用的便利。而MinIO是一款开源的对象存储服务器，...
Minio 文件服务
爱是与世界平行
08-06 1138
文章目录一、Minio简介二、Minio优势2.1 UI界面2.2 性能2.3 容器化支持2.4 丰富的SDK支持三、存储机制3.1 纠删码3.2 RS code编码数据恢复原理：3.3 实践四、部署4.1 单节点4.2 多节点五、Java SDK访问Minio服务 相关内容整理自： 博客园：字母哥：MinIO很强-让我放弃FastDFS拥抱MinIO的8个理由 简书：黄宝玲_1003：Minio 文件服务（1）—— Minio部署使用及存储机制分析 Minio 文件服务（2）—— Minio用Nginx做
Springboot整合MinIO
普通人一枚
04-24 1148
Springboot整合MinIO
基于MinIO搭建高性能文件服务器
文艺倾年的博客
04-27 3356
目录1. MinIO 简介2. MinIO Server 安装2.1 快速安装2.1.1 Windows2.1.2 Linux2.1.3 MacOS2.1.4 Docker2.2 访问UI界面2.3 新建存储桶3. MinIO Client 命令行工具4. Spring Boot 实战 1. MinIO 简介 MinIO 是一个基于 Go 实现的高性能、兼容 S3 协议的对象存储。它采用 GNU AGPL v3 开源协议，项目地址是 https://github.com/minio/minio，官网是 h
读取及合并minio上csv文件，处理数据结构，保存至本地
weixin_37699342的博客
12-08 1367
读取及合并minio上csv文件，处理数据结构，保存至本地
Springboot集成Minio
HoJe的博客
03-11 482
本文主要是讲解SpringBoot如何集成Minio的Java SDK。有不懂的同学可以私信我，评论，看到了会一一答复的。我们下期再见。
第03讲：MinIO分布式文件服务器
分享日常工作技术
04-06 1502
Minio 是个基于 Golang 编写的开源对象存储套件，虽然轻量，却拥有着不错的性能。何为对象存储？对象存储服务（ Object Storage Service，OSS ）是一种海量、安全、低成本、高可靠的云存储服务，适合存放任意类型的文件。容量和处理能力弹性扩展，多种存储类型供选择，全面优化存储成本。对于中小型企业，如果不选择存储上云，那么 Minio 是个不错的选择，麻雀虽小，五脏俱全。
Spring Boot 整合 Minio(分布式存储服务)
Xin Adn Meng
11-08 792
Spring Boot 整合 Minio
使用springboot搭建基于minio的高性能存储服务
weixin_45089791的博客
05-17 1164
什么是minio 引用官网： MinIO是根据GNU Affero通用公共许可证v3.0发布的高性能对象存储。它与Amazon S3云存储服务兼容。使用MinIO构建用于机器学习，分析和应用程序数据工作负载的高性能基础架构。 官网地址 文档地址 一. 使用docker 搭建minio 服务。 GNU / Linux和macOS docker run -p 9000:9000 \ --name minio1 \ -v /mnt/data:/data \ -e "MINIO_ROOT_USE
springboot 整合minio 实现多级目录下文件的下载
05-24
要实现Spring Boot整合MinIO实现多级目录下文件的下载，可以按照以下步骤进行： 1. 引入MinIO的依赖 在pom.xml文件中添加以下依赖： ```xml <groupId>io.minio <artifactId>minio <version>7.1.0 ``` 2. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值