Minio8.*版本工具类

已于 2022-11-17 10:53:10 修改
阅读量636 收藏
点赞数
分类专栏： util 文章标签： java 服务器 数据库
于 2022-11-17 10:47:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73510682/article/details/127899606
版权 
@Component
public class MinioUtil {

    private static MinioClient minioClient = SpringUtils.getBean("minio");

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

/*Object: 存储到MinIO的基本对象，如文件、字节流...

Bucket: 用来存储Object的逻辑空间。每个Bucket之间的数据是相互隔离的。

Drive: 部署MinIO时设置的磁盘，MinIO中所有的对象数据都会存储到Drive。

Set: 一组Drive的集合，MinIO会自动根据Drive数量，将若干个Drive划分为多个Set（For example: {1...64} is divided into 4 sets each of size 16
*/


    /**
     * 检查存储桶是否存在
     *
     * @param bucketName 存储桶名称
     * @return
     */
    @SneakyThrows
    public boolean bucketExists(String bucketName) {
        boolean flag = false;
        flag = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        if (flag) {
            return true;
        }
        return false;
    }

    @SneakyThrows
    public boolean makeBucket(String bucketName) {
        boolean flag = bucketExists(bucketName);
        if (!flag) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            return true;
        } else {
            return false;
        }
    }

    /**
     * 列出所有存储桶名称
     *
     * @return
     */
    @SneakyThrows
    public List<String> listBucketNames() {
        List<Bucket> bucketList = listBuckets();
        List<String> bucketListName = new ArrayList<>();
        for (Bucket bucket : bucketList) {
            bucketListName.add(bucket.name());
        }
        return bucketListName;
    }

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

        List<Bucket> buckets = minioClient.listBuckets();
        return buckets;
    }

    /**
     * 删除存储桶
     *
     * @param bucketName 存储桶名称
     * @return
     */
    @SneakyThrows
    public boolean removeBucket(String bucketName) {
        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(RemoveBucketArgs.builder().bucket(bucketName).build());
            flag = bucketExists(bucketName);
            if (!flag) {
                return true;
            }

        }
        return false;
    }


    /**
     * 列出存储桶中的所有对象名称
     *
     * @param bucketName 存储桶名称
     * @return
     */
    @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;
    }

    /**
     * 列出存储桶中的所有对象
     *
     * @param bucketName 存储桶名称
     * @return
     */
    @SneakyThrows
    public Iterable<Result<Item>> listObjects(String bucketName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            return minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName).build());
        }
        return null;
    }

    /**
     * 通过文件上传到对象
     *
     * @param bucketName 存储桶名称
     * @param
     * @param file       File
     * @return
     */
    @SneakyThrows
    public boolean putObject(String bucketName, String objectName, MultipartFile file) {
        boolean flag = bucketExists(bucketName);
        if (flag) {

            PutObjectArgs objectArgs = PutObjectArgs.builder().bucket(bucketName).object(objectName)
                    .stream(file.getInputStream(), file.getSize(), -1).contentType(file.getContentType()).build();
            minioClient.putObject(objectArgs);
            StatObjectResponse statObject = statObject(bucketName, objectName);
            if (statObject != null && statObject.size() > 0) {
                return true;
            }

        }
        return false;

    }

    /**
     * 获取对象的元数据
     *
     * @param bucketName 存储桶名称
     * @param filename   存储桶里的对象名称
     * @return
     */
    @SneakyThrows
    public StatObjectResponse statObject(String bucketName, String filename) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            /*  StatObjectArgs build =  StatObjectArgs.builder().bucket(bucketName).object(filename).build();*/
            StatObjectArgs build = StatObjectArgs.builder().bucket(bucketName).object(filename).build();
            StatObjectResponse statObjectResponse = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(filename).build());
          /*  StatObjectResponse statObjectResponse = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(filename).build());*/
            if (statObjectResponse==null){

                return  null;
            }

            return statObjectResponse;
        }
        return null;
    }

    /**
     * 通过InputStream上传对象
     *
     * @param bucketName 存储桶名称
     * @param filename   存储桶里的对象名称
     * @param stream     要上传的流
     * @return
     */
    @SneakyThrows
    public boolean putObject(String bucketName, String filename, InputStream stream) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            PutObjectArgs stream1 = PutObjectArgs.builder().bucket(bucketName).object(filename).stream(stream, stream.available(), -1).build();
            minioClient.putObject(stream1);
            StatObjectResponse statObject = statObject(bucketName, filename);
            if (statObject != null && statObject.size() > 0) {
                return true;
            }
        }
        return false;
    }

    /**
     * 以流的形式获取一个文件对象
     *
     * @param bucketName 存储桶名称
     * @param fileName   存储桶里的对象名称
     * @return
     */
    @SneakyThrows
    public InputStream getObject(String bucketName, String fileName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            StatObjectResponse statObject = statObject(bucketName, fileName);
            if (statObject != null && statObject.size() > 0) {
                InputStream stream = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileName).build());
                return stream;
            }
        }
        return null;
    }

    /**
     * 下载并将文件保存到本地
     *
     * @param bucketName 存储桶名称
     * @param bucketName   存储桶里的对象名称
     * @param objectName   File name
     * @return
     */
    @SneakyThrows
    public boolean getObject(String bucketName, String objectName, HttpServletResponse response) {
        boolean flag = bucketExists(bucketName);
        try {
            if (flag) {
                StatObjectResponse stat = minioClient.statObject(
                        StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
                response.setContentType(stat.contentType());
                response.setHeader("Content-Disposition", "attachment;fileName=" + URLEncoder.encode(objectName, "utf-8"));
                StatObjectResponse statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.size() > 0) {
                    GetObjectResponse object = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(objectName).build());
                    IOUtils.copy(object, response.getOutputStream());
                    object.close();
                    return true;
                }
            }
        } catch (Exception e) {
            e.getMessage();
        }
        return false;
    }

    /**
     * 删除一个对象
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     */
    @SneakyThrows
    public boolean removeObject(String bucketName, String objectName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {

            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
            return true;
        }
        return false;
    }

    /**
     * 删除指定桶的多个文件对象,返回删除错误的对象列表，全部删除成功，返回空列表
     *
     * @param bucketName  存储桶名称
     * @param objectNames 含有要删除的多个object名称的迭代器对象
     * @return
     */
    @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);*/
            List<DeleteObject> deleteObjectList = new CopyOnWriteArrayList<>();
            for (String objectName : objectNames) {
                deleteErrorNames.add(objectName);
            }

            Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(deleteObjectList).build());
            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
     */
    @SneakyThrows
    public String presignedGetObject(String bucketName, String objectName, Integer expires) {
        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.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().bucket(bucketName).object(objectName).build());
        }
        return url;
    }

    /**
     * 生成一个给HTTP PUT请求用的presigned URL。
     * 浏览器/移动端的客户端可以用这个URL进行上传，即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间，默认值是7天。
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     * @param expires    失效时间（以秒为单位），默认是7天，不得大于七天
     * @return
     */
    @SneakyThrows
    public String presignedPutObject(String bucketName, String objectName, Integer expires) {
        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.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().bucket(bucketName).object(objectName).build());
        }
        return url;
    }


    /**
     * 文件访问路径
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     * @return
     */
    @SneakyThrows
    public String getObjectUrl(String bucketName, String objectName) {
        boolean flag = bucketExists(bucketName);
        String url = "";
        if (flag) {
//            url = minioClient.getObjectUrl(bucketName, objectName);
            url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().bucket(bucketName).object(objectName).build());
        }
        return url;
    }


    public void downloadFile(String bucketName, String fileName, String originalName, HttpServletResponse response) {
        try {

            InputStream file = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileName).build());

            String filename = new String(fileName.getBytes("ISO8859-1"), StandardCharsets.UTF_8);
            if (StringUtils.isNotEmpty(originalName)) {
                fileName = originalName;
            }
            response.setHeader("Content-Disposition", "attachment;filename=" + filename);
            ServletOutputStream servletOutputStream = response.getOutputStream();
            int len;
            byte[] buffer = new byte[1024];
            while ((len = file.read(buffer)) > 0) {
                servletOutputStream.write(buffer, 0, len);
            }
            servletOutputStream.flush();
            file.close();
            servletOutputStream.close();
        } catch (ErrorResponseException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

依赖

<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
</dependency>
20岁30年经验的码农
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【MinIO-8.2.1】上传文件触发 OOM 异常【非完美解决方案】
小帅丶的专栏
07-07 2376
使用MinIO上传大文件老是会OOM 受到 https://blog.csdn.net/luo4105/article/details/115296654 提醒 。故此换了一种方式去解决。 MinIO版本 排除一些JAR非必要操作，根据实际情况来。我这边是SpringBoot 2.1.3.RELEASE 搭建。可能引用的其他有重复依赖。故此把MinIO重复的依赖进行了排除 <!-- mini文件存储服务 --> <dependency> <groupId&g..
springboot整合MinIO实现视频的分片上传/断点续传
weixin_44153131的博客
02-28 8490
之前做了一个慕课网上的仿短视频开发，里面有很多比较粗糙的实现，比如视频上传部分是直接由前端上传云服务，没考虑到客户的网络环境质量等问题，如果一个视频快上传完了，但是网断了没有上传完成需要客户重新上传，这对于用户体验是极差的。那么我们对于视频文件的上传可以采取断点续传，上传过程中，如果出现网络异常或程序崩溃导致文件上传失败时，将从断点记录处继续上传未上传完成的部分，断点续传依赖于MD5和分片上传，对于本demo分片上传的流程如图。
MinIO版本控制详解
最新发布
m0_63004124的博客
05-10 926
两个人上传同一张图片到MinIO中，MinIO只会保留一份数据。如果某一个人删除了图片，那么另一个人就会受到影响。MinIO的版本控制使用户可以在同一存储桶中保留对象的多个变体。
MinIO InvalidEndpointException: invalid host问题解决
旭东怪的博客
04-18 6797
问题描述： Caused by: io.minio.errors.InvalidEndpointException: invalid host 问题分析： 1、MinIO文件服务器地址的格式不正确。 解决办法： MinIO文件服务器地址的格式如下所示。 http://localhost:9000
Minio对象存储服务介绍、单机和集群部署及其使用
勤快的小蚂蚁的博客
04-19 3255
在企业中,我们通常会将一些图片、视频、文档等相关数据存储在对象存储中。常见的对象存储服务包括阿里云OSS对象存储、FastDFS分布式文件系统和公司私有云平台,方便数据存储和快速访问。但是,随着业务的快速发展,我们需要存储一些文件相关数据。我们选择使用兼容S3协议的Minio进行自建服务。开源分布式对象存储。MinIO 是全球领先的对象存储先锋。在标准硬件上，读/写速度上高达183 GB / 秒 和 171 GB / 秒。MinIO对象存储系统专为海量数据存储、人工智能和大数据分析而设计。
wget下载minio文件报403错误
longqqq211的博客
04-26 865
url加上引号。
Mall脚手架总结(五) —— SpringBoot整合MinIO实现文件管理
荔枝当大佬的博客
10-15 811
在这篇文章中，荔枝主要今朝已然成为过去，明日依然向往未来！我是荔枝，在技术成长之路上与您相伴~~~如果博文对您有帮助的话，可以给荔枝一键三连嘿，您的支持和鼓励是荔枝最大的动力！如果博文内容有误，也欢迎各位大佬在下方评论区批评指正！！！
java操作minio文件服务的通用工具类
08-19
java操作minio文件服务的通用工具类,可以实现使用指定方法就能控制文件的上传下载删除以及更多操作
文件-AES-MD5-Upload-Minio工具类.zip
01-30
AESFileUtil MD5FileUtils FileUploadUtil FileUtil MinioUtils
22.JavaWeb-Minio存储服务器 工具类
07-17
Minio存储服务器 工具类
Spring Boot 集成 MinIO（分布式对象存储系统）
09-27
在手写MinIO 工具类的过程中会摘取整体框架中的核心逻辑，简化代码实现过程，保留核心功能，例如：IOC、AOP、Bean生命周期、上下文、作用域、资源处理等内容实现。 适合人群：具备一定编程基础，工作1-3年的研发人员...
Java分片上传Minio分片上传Demo可用实例，直接导入使用
01-19
Java分片上传Minio分片上传Demo可用实例，直接导入使用
java连接minio工具类
09-21
MinIO is a software-defined high performance distributed object storage server. You can run MinIO on consumer or enterprise-grade hardware and a variety of operating ...本文是基于Java sdk 编写的工具类
【大数据 minio】10分钟了解大数据存储的方案minio
赖德发的博客
07-29 3519
docker-compose部署方案，我们需要进行安装docker与docker-compose，这个在docker文档中都有，可以参考docker-compose官网。企业上我们可以利用其分布式的功能，内部搭建图片处理服务器，文件存储服务器，公司内部的文件存储服务器，这样就不用限制存储的大小，也不限制存储位置。可以兼容亚马逊的S3存储服务接口，非常适合存储大容量的非结构化数据。我们个人可以直接在家庭内部搭建个人的云盘服务，开心的保存家里面的数据文件，再也不担心数据丢失的问题了。...
文件服务器MinIO的下载与安装
我是聂可的博客
05-12 4636
前言 本篇文章是基于win10操作系统下载与安装MinIO文件服务器 1、下载MinIO MinIO官网：http://docs.minio.org.cn/docs/master/distributed-minio-quickstart-guide MinIO下载地址：http://docs.minio.org.cn/docs/master/minio-client-quickstart-guide ...
特别篇:java实现将视频分片上传到minio(二):视频文件写入到minio
qq_37716298的博客
10-06 2159
上期回顾 特别篇:java实现将视频分片上传到minio(一):视频分片 实现想法 上期我们已经将视频分片写到对应的文件夹中，那这期我们是不是只需要读取到对应的文件，然后将文件上传到minio中就可以了。 视频文件写入到minio minio版本 <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId>
MinIO，Zuul
菜鸟的博客
08-13 2950
熔断机制
【对象存储】minio的安装、使用及springboot集成
Think_and_work的博客
07-25 2160
终于不用花钱搞oss了
minio单机、集群搭建、Spring Boot集成，详细步骤
localhost
05-17 2546
一、单机minio搭建 1.下载rpm包 下载地址：https://dl.min.io/server/minio/release/linux-amd64/ 2.安装 rpm -ivh minio-20220504074527.0.0.x86_64.rpm 修改 /etc/systemd/system/minio.service文件 #启动的用户和用户组 User=root Group=root #配置文件地址 EnvironmentFile=-/etc/default/minio..
springboot minio文件分片下载工具类
07-12
你可以使用以下工具类来实现Spring Boot与MinIO结合进行文件分片下载： ```java import io.minio.MinioClient; import io.minio.ObjectStat; import io.minio.errors.*; import io.minio.messages.Part; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.springframework.util.StringUtils; import java.io.BufferedInputStream; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.util.List; @Component public class MinioFileDownloader { @Autowired private MinioClient minioClient; public void downloadFile(String bucketName, String objectName, String filePath) throws IOException, NoSuchAlgorithmException, InvalidKeyException, InsufficientDataException, InternalException, InvalidResponseException, ErrorResponseException, XmlParserException, InvalidArgumentException { // 获取文件的元数据 ObjectStat objectStat = minioClient.statObject(bucketName, objectName); long fileSize = objectStat.length(); if (fileSize <= 0) { throw new IOException("File is empty"); } // 分片下载文件 int partSize = 5 * 1024 * 1024; // 分片大小为5MB long totalPartsCount = (long) Math.ceil((double) fileSize / partSize); for (int partNumber = 1; partNumber <= totalPartsCount; partNumber++) { long offset = (partNumber - 1) * partSize; long size = Math.min(partSize, fileSize - offset); InputStream inputStream = minioClient.getObject(bucketName, objectName, offset, size); try (BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream)) { byte[] buffer = new byte[(int) size]; bufferedInputStream.read(buffer, 0, (int) size); // 将分片写入文件 writeToFile(buffer, filePath); } } } private void writeToFile(byte[] data, String filePath) throws IOException { try (FileOutputStream outputStream = new FileOutputStream(filePath, true)) { outputStream.write(data); } } } ``` 你可以将以上代码添加到你的Spring Boot项目中，然后通过注入`MinioClient`来使用`MinioFileDownloader`类进行文件的分片下载。请确保已经正确配置了MinIO客户端以及相应的依赖包。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

20岁30年经验的码农

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值