MinIo工具包

最新推荐文章于 2024-04-23 22:56:34 发布
最新推荐文章于 2024-04-23 22:56:34 发布
阅读量266 收藏
点赞数
文章标签： java 前端 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37335177/article/details/127426862
版权

MinIo工具包

概念

	MinIO 是在 GNU Affero 通用公共许可证 v3.0 下发布的高性能对象存储。 它是与 Amazon S3 云存储服务兼容的 API。 使用 MinIO 为机器学习、分析和应用程序数据工作负载构建高性能基础架构。

特性

本节选自官网介绍

MinIo工具包

POM

<dependency>
	<groupId>io.minio</groupId>
	<artifactId>minio</artifactId>
	<version>8.3.0</version>
</dependency>

MinioUtils

import com.alibaba.fastjson.JSONObject;
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.web.multipart.MultipartFile;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.time.ZonedDateTime;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @Author: zrs
 * @Date: 2020/12/01/10:02
 * @Description: Minio工具类
 */
@Slf4j
public class MinioUtils {

    private static MinioClient minioClient;

    private static String endpoint;
    private static String bucketName;
    private static String accessKey;
    private static String secretKey;
    private static String folder;

    private static final String SEPARATOR = "/";

    private MinioUtils() {
    }

    public MinioUtils(MinIoConfig minIoConfig) {
        MinioUtils.endpoint = minIoConfig.getEndpoint();
        MinioUtils.bucketName = minIoConfig.getBucketName();
        MinioUtils.accessKey = minIoConfig.getAccessKey();
        MinioUtils.secretKey = minIoConfig.getSecretKey();
        MinioUtils.folder = minIoConfig.getFolder();
        createMinioClient();
    }

    public MinioUtils(String endpoint, String bucketName, String accessKey, String secretKey, String folder) {
        MinioUtils.endpoint = endpoint;
        MinioUtils.bucketName = bucketName;
        MinioUtils.accessKey = accessKey;
        MinioUtils.secretKey = secretKey;
        MinioUtils.folder = folder;
        createMinioClient();
    }

    /**
     * 创建minioClient
     */
    public void createMinioClient() {
        try {
            if (null == minioClient) {
                log.info("minioClient create start");
                minioClient = MinioClient.builder().endpoint(endpoint).credentials(accessKey, secretKey)
                        .build();
                createBucket();
                log.info("minioClient create end");
            }
        } catch (Exception e) {
            log.error("连接MinIO服务器异常：{}", e);
        }
    }

    /**
     * 获取上传文件的基础路径
     *
     * @return url
     */
    public static String getBasisUrl() {
        return endpoint + SEPARATOR + bucketName + SEPARATOR;
    }

    //操作存储桶

    /**
     * 初始化Bucket
     *
     * @throws Exception 异常
     */
    private static void createBucket()
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        }
    }

    /**
     * 验证bucketName是否存在
     *
     * @return boolean true:存在
     */
    public static boolean bucketExists()
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
    }

    /**
     * 创建bucket
     */
    public static void createBucket(String bucketName)
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        }
    }

    /**
     * 获取存储桶策略
     * <p>
     * 名称
     *
     * @return json
     */
    private JSONObject getBucketPolicy(String bucketName)
            throws IOException, InvalidKeyException, InvalidResponseException, BucketPolicyTooLargeException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InsufficientDataException, ErrorResponseException {
        String bucketPolicy = minioClient
                .getBucketPolicy(GetBucketPolicyArgs.builder().bucket(bucketName).build());
        return JSONObject.parseObject(bucketPolicy);
    }

    /**
     * 获取全部bucket
     * <p>
     * <a href="https://docs.minio.io/cn/java-client-api-reference.html#listBuckets">listBuckets</a>
     */
    public static List<Bucket> getAllBuckets()
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        return minioClient.listBuckets();
    }

    /**
     * 根据bucketName获取信息
     */
    public static Optional<Bucket> getBucket(String bucketName)
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        return minioClient.listBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
    }

    /**
     * 根据bucketName删除信息
     */
    public static void removeBucket(String bucketName)
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    //操作文件对象

    /**
     * 判断文件是否存在
     *
     * @param objectName 文件名称
     * @return true：存在
     */
    public static boolean doesObjectExist(String objectName) {
        boolean exist = true;
        try {
            minioClient
                    .statObject(StatObjectArgs.builder().bucket(bucketName).object(folder + SEPARATOR + objectName).build());
        } catch (Exception e) {
            exist = false;
        }
        return exist;
    }

    /**
     * 判断文件夹是否存在
     *
     * @param objectName 文件名称（去掉/）
     * @return true：存在
     */
    public static boolean doesFolderExist(String objectName) {
        boolean exist = false;
        try {
            Iterable<Result<Item>> results = minioClient.listObjects(
                    ListObjectsArgs.builder().bucket(bucketName).prefix(objectName).recursive(false).build());
            for (Result<Item> result : results) {
                Item item = result.get();
                if (item.isDir() && objectName.equals(item.objectName())) {
                    exist = true;
                }
            }
        } catch (Exception e) {
            exist = false;
        }
        return exist;
    }

    /**
     * 根据文件前置查询文件
     *
     * @param prefix    前缀
     * @param recursive 是否递归查询
     * @return MinioItem 列表
     */
    public static List<Item> getAllObjectsByPrefix(String prefix,
                                                   boolean recursive)
            throws ErrorResponseException, InsufficientDataException, InternalException, InvalidKeyException, InvalidResponseException,
            IOException, NoSuchAlgorithmException, ServerException, XmlParserException {
        List<Item> list = new ArrayList<>();
        Iterable<Result<Item>> objectsIterator = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).prefix(prefix).recursive(recursive).build());
        if (objectsIterator != null) {
            for (Result<Item> o : objectsIterator) {
                Item item = o.get();
                list.add(item);
            }
        }
        return list;
    }

    /**
     * 获取文件流
     *
     * @param objectName 文件名称
     * @return 二进制流
     */
    public static GetObjectResponse getObject(String objectName)
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        return minioClient
                .getObject(GetObjectArgs.builder().bucket(bucketName).object(folder + SEPARATOR + objectName).build());
    }

    /**
     * 断点下载
     *
     * @param objectName 文件名称
     * @param offset     起始字节的位置
     * @param length     要读取的长度
     * @return 流
     */
    public InputStream getObject(String objectName, long offset, long length)
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        return minioClient.getObject(
                GetObjectArgs.builder().bucket(bucketName).object(folder + SEPARATOR + objectName).offset(offset).length(length)
                        .build());
    }

    /**
     * 获取路径下文件列表
     *
     * @param prefix    文件名称
     * @param recursive 是否递归查找，如果是false,就模拟文件夹结构查找
     * @return 二进制流
     */
    public static Iterable<Result<Item>> listObjects(String prefix,
                                                     boolean recursive) {
        return minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).prefix(prefix).recursive(recursive).build());
    }

    /**
     * 通过MultipartFile，上传文件
     *
     * @param file       文件
     * @param objectName 文件名称
     */
    public static ObjectWriteResponse putObject(MultipartFile file,
                                                String objectName, String contentType)
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        InputStream inputStream = file.getInputStream();
        return minioClient.putObject(
                PutObjectArgs.builder().bucket(bucketName).object(folder + SEPARATOR + objectName).contentType(contentType)
                        .stream(
                                inputStream, inputStream.available(), -1)
                        .build());
    }

    /**
     * 上传本地文件
     *
     * @param objectName 文件名称
     * @param fileName   本地文件路径
     */
    public static ObjectWriteResponse putObject(String objectName,
                                                String fileName)
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        return minioClient.uploadObject(
                UploadObjectArgs.builder()
                        .bucket(bucketName).object(folder + SEPARATOR + objectName).filename(fileName).build());
    }

    /**
     * 通过流上传文件
     *
     * @param objectName  文件对象
     * @param inputStream 文件流
     */
    public static ObjectWriteResponse putObject(String objectName,
                                                InputStream inputStream)
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        return minioClient.putObject(
                PutObjectArgs.builder().bucket(bucketName).object(folder + SEPARATOR + objectName).stream(
                                inputStream, inputStream.available(), -1)
                        .build());
    }

    /**
     * 创建文件夹或目录
     *
     * @param objectName 目录路径
     */
    public static ObjectWriteResponse putDirObject(String objectName)
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        return minioClient.putObject(
                PutObjectArgs.builder().bucket(bucketName).object(folder + SEPARATOR + objectName).stream(
                                new ByteArrayInputStream(new byte[]{}), 0, -1)
                        .build());
    }

    /**
     * 获取文件信息, 如果抛出异常则说明文件不存在
     *
     * @param objectName 文件名称
     * @return
     */
    public static StatObjectResponse statObject(String objectName)
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        return minioClient
                .statObject(StatObjectArgs.builder().bucket(bucketName).object(folder + SEPARATOR + objectName).build());
    }

    /**
     * 拷贝文件
     *
     * @param objectName    文件名称
     * @param srcBucketName 目标bucket名称
     * @param srcObjectName 目标文件名称
     */
    public static ObjectWriteResponse copyObject(String objectName,
                                                 String srcBucketName, String srcObjectName)
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        return minioClient.copyObject(
                CopyObjectArgs.builder()
                        .source(CopySource.builder().bucket(bucketName).object(folder + SEPARATOR + objectName).build())
                        .bucket(srcBucketName)
                        .object(srcObjectName)
                        .build());
    }

    /**
     * 删除文件
     *
     * @param objectName 文件名称
     */
    public static void removeObject(String objectName)
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, ErrorResponseException {
        minioClient
                .removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(folder + SEPARATOR + objectName).build());
    }

    /**
     * 批量删除文件
     *
     * @param keys 需要删除的文件列表
     * @return
     */
    public static void removeObjects(List<String> keys) {
        List<DeleteObject> objects = new LinkedList<>();
        keys.forEach(s -> {
            objects.add(new DeleteObject(s));
            try {
                removeObject(s);
            } catch (Exception e) {
                log.error("批量删除失败！error:{}", e);
            }
        });
    }

    //操作Presigned

    /**
     * 获取文件外链
     *
     * @param objectName 文件名称
     * @param expires    过期时间 <=7 秒级
     * @return url
     */
    public static String getPresignedObjectUrl(String objectName,
                                               Integer expires)
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, ServerException, InternalException, NoSuchAlgorithmException, XmlParserException, ErrorResponseException {
        return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                .method(Method.GET)
                .bucket(bucketName)
                .object(folder + SEPARATOR + objectName)
                .expiry(expires, TimeUnit.HOURS)
                .build());
    }

    /**
     * 给presigned URL设置策略
     *
     * @param objectName 文件名称名
     * @param expires    过期策略
     * @return map
     */
    public static Map<String, String> presignedGetObject(String objectName,
                                                         Integer expires)
            throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, ServerException, InternalException, NoSuchAlgorithmException, XmlParserException, ErrorResponseException {
        PostPolicy policy = new PostPolicy(bucketName, ZonedDateTime.now().plusDays(7));
        // Add condition that 'key' (object name) equals to 'my-objectname'.
        policy.addEqualsCondition("key", objectName);
        // Add condition that 'Content-Type' starts with 'image/'.
        policy.addStartsWithCondition("Content-Type", "image/");
        // Add condition that 'content-length-range' is between 64kiB to 10MiB.
        policy.addContentLengthRangeCondition(64 * 1024, 10 * 1024 * 1024);
        return minioClient.getPresignedPostFormData(policy);
    }


    /**
     * 将URLDecoder编码转成UTF8
     *
     * @param str
     * @return
     * @throws UnsupportedEncodingException
     */
    public static String getUtf8ByURLDecoder(String str) throws UnsupportedEncodingException {
        String url = str.replaceAll("%(?![0-9a-fA-F]{2})", "%25");
        return URLDecoder.decode(url, "UTF-8");
    }

}

BeanConfig

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan
@Slf4j
@Data
public class MinIoConfig {

    @Value("${minio.endpoint}")
    private String endpoint;
    @Value("${minio.bucketName}")
    private String bucketName;
    @Value("${minio.accessKey}")
    private String accessKey;
    @Value("${minio.secretKey}")
    private String secretKey;
    @Value("${spring.profiles.active}")
    private String folder;

    @Bean
    public MinioUtils creatMinioClient() {
        return new MinioUtils(endpoint, bucketName, accessKey, secretKey, folder);
    }

}
雨夜星空丶月
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
官网下载Minio工具包
06-09
官网下载Minio工具包
ARM RPM MinIO 包
12-20
5. **易于部署和管理**: 通过RPM包的形式，MinIO在ARM平台上可以轻松安装和升级，利用系统的包管理工具如`yum`或`dnf`进行操作，简化了运维工作。 6. **监控和警报**: MinIO提供全面的监控指标，包括性能、容量和...
Minio工具类 - Java
热门推荐
流氓兔的博客
12-02 3万+
依赖 <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <version>${minio.version}</version> </dependency> 项目启动，创建bean package com.mgmiot.dlp.file.filev2.config; import com.mg
Java中MinIo文件系统工具类
山路曲折盘旋，但毕竟朝着顶峰延伸
12-15 3483
【代码】Java中MinIo文件系统工具类。
黑马Minio（对象存储服务MinIO）
最新发布
weixin_50458070的博客
04-23 1269
MinIO
Minio工具类 MinioUtils
yunnuo的博客
01-30 5298
Minio工具类 MinioUtils import com.alibaba.fastjson.JSONObject; import com.tsms.common.config.minio.MinioProp; import io.minio.MinioClient; import io.minio.ObjectStat; import io.minio.errors.*; import io.minio.messages.Bucket; import org.apache.http.entity.Co
SpringBoot集成Minio搭建自己的分布式文件服务器（Minio集成篇）
搬砖老农工的博客
03-03 3336
1.导入依赖 implementation 'io.minio:minio:8.2.2' 2.创建spring boot工程，工程名为springboot-minio 3.配置minio配置文件 minio: endpoint: http://10.0.1.140:9002 accessKey: minio secretKey: minio123 bucketName: test 4.创建配置类MinioConfig package com.springboot....
非maven项目集成minIO所需要的jar包
04-22
在非Maven项目中集成MinIO可能涉及到手动管理依赖项，这确实是一项挑战，因为需要确保所有必需的jar包正确无误。标题和描述提到了在非Maven项目中集成MinIO时可能会遇到的jar包冲突问题。 以下是你提供的压缩包中的...
最新版的minio命令行工具
03-10
而`mc`（MinIO Client）是MinIO官方提供的命令行工具，用于与MinIO服务器进行交互，包括上传、下载、管理对象以及执行各种其他操作。`mc`是一个轻量级的二进制工具，用户可以直接下载使用，无需复杂安装过程，非常...
s3:使用Minio和AWS开发工具包进行s3功能测试
04-11
使用Minio和AWS开发工具包进行S3功能测试。 安装 安装Minio（ ）。 brew install minio / stable / minio 出口MINIO_ACCESS_KEY =“ Ieteen7g” 出口MINIO_SECRET_KEY =“ Oep0poh3” 以上密钥是通过pwgen...
记一次Minio ComposeObject无法在ceph上合并文件的异常运维
weixin_42340926的博客
01-10 2533
问题复现 直接使用minio java sdk（8.3.3版本）对ceph集群中的compose桶中的已存在的多个文件（test1,test2）进行合并(test)，代码如下 @Test void contextLoads() throws Exception{ MinioClient minioClient = MinioClient.builder() .endpoint("http://172.23.27
Minio常用API用法
qiangzi_lg的博客
06-02 6808
//查看所有文件 final Iterable<Result<Item>> results = minioClient.listObjects(bucket.name()); for (Result<Item> result : results) { System.out.println(result.get().objectName()); ...
minio工具类
xiaoshitou_s的博客
10-30 2498
minio工具类
MinIo工具类
LaDaShuan的博客
01-08 330
MinIo工具类（获取网络图片视频工具类）
Minio Utils
Xin Adn Meng
11-08 607
Minio Utils
MinioUtilS 工具类
世上哪有什么岁月静好,不过是有人替你负重前行
07-25 1031
MinIOClient(mc)为ls，cat，cp，mirror，diff，find等UNIX命令提供了一种替代方案。它支持文件系统和兼容AmazonS3的云存储服务（AWSSignaturev2和v4）。
Minio控制台详细教程
HoJe的博客
03-05 2万+
此文讲解Minio控制台详细教程，可能会涉及到有些知识大家可能不懂情况。需要知道Minio兼容的是AMS S3对象存储服务。需要知道AMS S3对象存储服务是什么，里面涉及的到配置如何去配等等。
Minio工具类
u011250186的博客
12-28 856
Minio工具类
Java minio工具类
10-20
Java minio工具类是基于Java sdk编写的工具类，用于操作MinIO对象存储服务器。它包含了上传文件、设置文件contentType类型、设置全局访问策略等方法。在使用Java minio工具类之前，需要在pom.xml中引入minio依赖，并在yml文件中配置MinIO服务所在地址、存储桶名称、访问的key和秘钥等信息。通过Java minio工具类，可以方便地对MinIO对象存储服务器进行操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值