Springboot integrates minio components - distributed file storage

1. Quick start

Minlo description:

1. Minio is an open source lightweight file server under Apcche, based on object storage, the protocol is based on Apache License v2.0, open source can be used for business.
2. Minio is mainly used to store unstructured data, such as files, pictures, photos, log files, various backup files, etc. According to the official website description, the file size ranges from a few KB to 5TB.
3. Minio provides a very convenient and friendly interface, and the documentation is also very rich. For details, please refer to its documentation: https://docs.min.io/cn/
4. Minlo is similar to FastDFS and Alibaba Cloud's OSS for object storage
5. Install minlo server reference: https://blog.csdn.net/u010189683/article/details/108171562

1. Add dependencies

<!--minio方案-->
<dependency>
	<groupId>io.minio</groupId>
	<artifactId>minio</artifactId>
	<version>7.0.2</version>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-configuration-processor</artifactId>
	<optional>true</optional>
</dependency>

2. Add configuration items

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

3. Configuration items and tools

@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 {
    
    
    
    @Value("${minio.endpoint}")
    private String endpoint;
    @Value("${minio.accessKey}")
    private String accessKey;
    @Value("${minio.secretKey}")
    private String secretKey;

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

	private static MinioClient minioClient;

    @Autowired
    @SneakyThrows
    public MinioClient setMinioClient(){
    
    
         MinioClient minioClient = new MinioClient(endpoint, accessKey, secretKey);
         return minioClient;
    }

	/**
	 * 检查存储桶是否存在
	 */
    @SneakyThrows
	public boolean bucketExists(String bucketName){
    
    
		boolean flag = minioClient.bucketExists(bucketName);
        return flag ? true : false;
	}

	/**
	 * 创建存储桶
	 */
    @SneakyThrows
	public boolean makeBucket(String bucketName) {
    
    
		boolean flag = bucketExists(bucketName);
        if(flag) return false;
        minioClient.makeBucket(bucketName);
        return true;
	}

	/**
	 * 列出所有存储桶名称
	 */
    @SneakyThrows
	public List<String> listBucketNames() {
    
    
		List<Bucket> bucketList = listBuckets();
        return bucketList.stream().map(item->bucket.name()).collect(Collector.toList())
	}

	/**
	 * 列出所有存储桶
	 */
    @SneakyThrows
	public List<Bucket> listBuckets() {
    
    
		return minioClient.listBuckets();
	}

	/**
	 * 删除存储桶
	 */
    @SneakyThrows
	public boolean removeBucket(String bucketName) {
    
    
		boolean flag = bucketExists(bucketName);
        if(flag) return false;
        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;
        }
	}

	/**
	 * 列出存储桶中的所有对象名称
	 */
    @SneakyThrows
	public List<String> listObjectNames(String bucketName) {
    
    
		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;
	}

	/**
	 * 列出存储桶中的所有对象
	 */
    @SneakyThrows
	public Iterable<Result<Item>> listObjects(String bucketName)  {
    
    
		boolean flag = bucketExists(bucketName);
        return flag?minioClient.listObjects(bucketName):null;
	}

	/**
	 * 通过文件上传到对象
	 */
    @SneakyThrows
	public boolean putObject(String bucketName, String objectName, String fileName){
    
    
		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上传对象
	 */
    @SneakyThrows
	public boolean putObject(String bucketName, String objectName, InputStream stream) {
    
    
		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;
	}

	/**
	 * 以流的形式获取一个文件对象
	 */
    @SneakyThrows
	public InputStream getObject(String bucketName, String objectName){
    
    
		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;
	}

	/**
	 * 以流的形式获取一个文件对象（断点下载）
	 */
    @SneakyThrows
	public InputStream getObject(String bucketName, String objectName, long offset, Long length){
    
    
		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;
	}

	/**
	 * 下载并将文件保存到本地
	 */
    @SneakyThrows
	public boolean getObject(String bucketName, String objectName, String fileName) {
    
    
		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;
	}

	/**
	 * 删除一个对象
	 */
    @SneakyThrows
	public boolean removeObject(String bucketName, String objectName) {
    
    
		boolean flag = bucketExists(bucketName);
		if (flag) {
    
    
			minioClient.removeObject(bucketName, objectName);
			return true;
		}
		return false;
	}

	/**
	 * 删除指定桶的多个文件对象,返回删除错误的对象列表，全部删除成功，返回空列表
	 */
    @SneakyThrows
	public List<String> removeObject(String bucketName, List<String> objectNames){
    
    
		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天。
	 */
    @SneakyThrows
	public String presignedGetObject(String bucketName, String objectName, Integer expires) {
    
    
		boolean flag = bucketExists(bucketName);
        return bucketExists(bucketName) ? minioClient.presignedGetObject(bucketName, objectName, expires):null;
	}

	/**
	 * 生成一个给HTTP PUT请求用的presigned URL。
	 * 浏览器/移动端的客户端可以用这个URL进行上传，即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间，默认值是7天。
	 */
    @SneakyThrows
	public String presignedPutObject(String bucketName, String objectName, Integer expires) {
    
    
		return bucketExists(bucketName) ? minioClient.presignedPutObject(bucketName, objectName, expires):null;
	}

	/**
	 * 获取对象的元数据
	 */
    @SneakyThrows
	public ObjectStat statObject(String bucketName, String objectName){
    
    
        return bucketExists(bucketName) ? minioClient.statObject(bucketName, objectName) : null;
	}

	/**
	 * 文件访问路径
	 */
    @SneakyThrows
	public String getObjectUrl(String bucketName, String objectName) {
    
    
		return bucketExists(bucketName) ? minioClient.getObjectUrl(bucketName, objectName) : "";
	}
}