中间件(18) : minio

转载 已于 2023-06-02 14:59:00 修改 · 321 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://blog.youkuaiyun.com/weixin_53517860/article/details/126888783
文章标签：

#中间件 #java #spring #minio

于 2023-05-18 14:23:36 首次发布
该代码示例展示了如何在Java中利用MinIO库进行文件上传、删除、列出存储桶及对象、设置公共读权限，并提供了连接MinIO服务器的配置方法。此外，还包含了错误处理和日期格式化的功能。
Seed-Coder-8B-Base

Seed-Coder-8B-Base

文本生成
Seed-Coder

Seed-Coder是一个功能强大、透明、参数高效的 8B 级开源代码模型系列，包括基础变体、指导变体和推理变体，由字节团队开源

参考 : 

        MinIO Java接口实现创建桶,设置桶策略_minio 创建bucket_Meta.Qing的博客-优快云博客 

        Java上传文件到minio_javac-coder的博客-优快云博客 

maven依赖

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

minio配置

# minio
minio.endpoint=http://192.168.1.1:8080
minio.accessKey=minio
minio.secretKey=minio123

minio管理


import io.minio.*;
import io.minio.messages.Bucket;
import io.minio.messages.Item;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.*;

@Service
@Slf4j
public class MinioSaveService {

    @Value("${minio.endpoint:-}")
    private String endpoint;

    @Value("${minio.accessKey:-}")
    private String accessKey;

    @Value("${minio.secretKey:-}")
    private String secretKey;

    private MinioClient minioClient;

    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    // 创建连接
    private MinioClient getMinioClient() {
        try {
            if (minioClient != null) {
                return minioClient;
            }
            minioClient = MinioClient.builder().endpoint(endpoint).credentials(accessKey, secretKey).build();
            log.info("minio连接创建成功");
            return minioClient;
        } catch (Exception e) {
            log.error("minio连接创建失败", e);
            return null;
        }
    }

    // 所有存储桶
    public List<String> listBuckets() throws Exception {
        List<Bucket> buckets = getMinioClient().listBuckets();
        List<String> bs = new LinkedList<>();
        if (!buckets.isEmpty()) {
            buckets.forEach(b -> bs.add(b.name()));
        }
        return bs;
    }

    // 查看目录文件列表
    public List<Map<String, Object>> listObjects(String bucket, String path) throws Exception {
        Iterable<Result<Item>> results = getMinioClient().listObjects(ListObjectsArgs.builder()
                .bucket(bucket)
                .prefix(path).build());
        Iterator<Result<Item>> iterator = results.iterator();
        List<Map<String, Object>> rs = new LinkedList<>();
        while (iterator.hasNext()) {
            Result<Item> next = iterator.next();
            Item item = next.get();
            Map<String, Object> map = new HashMap<>();
            map.put("objectName", item.objectName());
            map.put("isDir", item.isDir());
            try {
                LocalDateTime localDateTime = item.lastModified().toLocalDateTime();
                Date date = Date.from(localDateTime.atZone(ZoneId.systemDefault()).plusHours(8).toInstant());
                map.put("lastModified", simpleDateFormat.format(date));
            } catch (Exception e) {
            }
            if (!item.isDir()) {
                map.put("url", endpoint + "/" + bucket + "/" + item.objectName());
            }
            rs.add(map);
        }
        return rs;
    }

    // 删除文件
    public String deleteFile(String bucket, String objectName) throws Exception {
        getMinioClient().removeObject(RemoveObjectArgs.builder()
                .bucket(bucket)
                .object(objectName)
                .build());
        return "SUCCESS";
    }

    // 上传文件 minioPath前面不带/
    public String uploadFile(MultipartFile file, String bucket, String minioPath) throws Exception {
        // 若不存在创建bucket
        if (!bucketExists(bucket)) {
            getMinioClient().makeBucket(MakeBucketArgs.builder().bucket(bucket).build());
            getMinioClient().setBucketPolicy(
                    SetBucketPolicyArgs.builder()
                            .bucket(bucket)
                            .config(getPolicy3(bucket)) // 1,2,3都可以
                            .build());
        }
        // 上传
        String objectName = minioPath + "/" + file.getOriginalFilename();
        PutObjectArgs args = PutObjectArgs.builder()
                .bucket(bucket)
                .object(objectName)
                .stream(file.getInputStream(), file.getSize(), -1)
                .contentType(file.getContentType())
                .build();
        getMinioClient().putObject(args);
        //返回上传的路径
        return getUrl(bucket, objectName);
    }

    // 获取访问URL
    public String getUrl(String bucket, String objectName) {
        return endpoint + "/" + bucket + "/" + objectName;
    }

    // 判定bucket是否存在
    public boolean bucketExists(String bucketName) throws Exception {
        return getMinioClient().bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
    }

    // 根据URL删除文件
    public Object deleteByUrl(String url) throws Exception {
        String str = url.replace(endpoint + "/", "");
        int i = str.indexOf("/");
        return deleteFile(str.substring(0, i), str.substring(i + 1));
    }

    public static void main(String[] args) {
        String url = "http://10.149.229.82:31004/tmp/2023/20210907093457.jpg";
        String str = url.replace("http://10.149.229.82:31004" + "/", "");
        int i = str.indexOf("/");
        System.out.println(str.substring(0, i));
        System.out.println(str.substring(i + 1));
    }

    // bucket公有
    public static String getPolicy3(String bucket) {
        return "{\n" +
                "    \"Version\": \"2012-10-17\",\n" +
                "    \"Statement\": [\n" +
                "        {\n" +
                "            \"Effect\": \"Allow\",\n" +
                "            \"Principal\": {\n" +
                "                \"AWS\": [\n" +
                "                    \"*\"\n" +
                "                ]\n" +
                "            },\n" +
                "            \"Action\": [\n" +
                "                \"s3:ListBucketMultipartUploads\",\n" +
                "                \"s3:GetBucketLocation\",\n" +
                "                \"s3:ListBucket\"\n" +
                "            ],\n" +
                "            \"Resource\": [\n" +
                "                \"arn:aws:s3:::" + bucket + "\"\n" +
                "            ]\n" +
                "        },\n" +
                "        {\n" +
                "            \"Effect\": \"Allow\",\n" +
                "            \"Principal\": {\n" +
                "                \"AWS\": [\n" +
                "                    \"*\"\n" +
                "                ]\n" +
                "            },\n" +
                "            \"Action\": [\n" +
                "                \"s3:ListMultipartUploadParts\",\n" +
                "                \"s3:PutObject\",\n" +
                "                \"s3:AbortMultipartUpload\",\n" +
                "                \"s3:DeleteObject\",\n" +
                "                \"s3:GetObject\"\n" +
                "            ],\n" +
                "            \"Resource\": [\n" +
                "                \"arn:aws:s3:::" + bucket + "/*\"\n" +
                "            ]\n" +
                "        }\n" +
                "    ]\n" +
                "}";
    }

    // bucket公有
    public static String getPolicy2(String bucket) {
        return "{\n" +
                "    \"Version\": \"2012-10-17\",\n" +
                "    \"Statement\": [\n" +
                "        {\n" +
                "            \"Effect\": \"Allow\",\n" +
                "            \"Principal\": {\n" +
                "                \"AWS\": [\n" +
                "                    \"*\"\n" +
                "                ]\n" +
                "            },\n" +
                "            \"Action\": [\n" +
                "                \"s3:ListBucket\",\n" +
                "                \"s3:ListBucketMultipartUploads\",\n" +
                "                \"s3:GetBucketLocation\"\n" +
                "            ],\n" +
                "            \"Resource\": [\n" +
                "                \"arn:aws:s3:::" + bucket + "\"\n" +
                "            ]\n" +
                "        },\n" +
                "        {\n" +
                "            \"Effect\": \"Allow\",\n" +
                "            \"Principal\": {\n" +
                "                \"AWS\": [\n" +
                "                    \"*\"\n" +
                "                ]\n" +
                "            },\n" +
                "            \"Action\": [\n" +
                "                \"s3:PutObject\",\n" +
                "                \"s3:AbortMultipartUpload\",\n" +
                "                \"s3:DeleteObject\",\n" +
                "                \"s3:GetObject\",\n" +
                "                \"s3:ListMultipartUploadParts\"\n" +
                "            ],\n" +
                "            \"Resource\": [\n" +
                "                \"arn:aws:s3:::" + bucket + "/*\"\n" +
                "            ]\n" +
                "        }\n" +
                "    ]\n" +
                "}";
    }

    // bucket公有
    private static String getPolicy(String bucket) {
        return "{\n" +
                "    \"Version\": \"2012-10-17\",\n" +
                "    \"Statement\": [\n" +
                "        {\n" +
                "            \"Action\": [\n" +
                "                \"s3:GetObject\"\n" +
                "            ],\n" +
                "            \"Effect\": \"Allow\",\n" +
                "            \"Principal\": {\n" +
                "                \"AWS\": [\n" +
                "                    \"*\"\n" +
                "                ]\n" +
                "            },\n" +
                "            \"Resource\": [\n" +
                "                \"arn:aws:s3:::" + bucket + "/*\"\n" +
                "            ]\n" +
                "        }\n" +
                "    ]\n" +
                "}";
    }
}

controller


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.time.LocalDate;

/**
 * @Author: liyue
 * @Date: 2023/04/26/13:43
 * @Description:
 */
@RestController
public class MinioController {

    @Autowired
    private MinioSaveService minioSaveService;

    @RequestMapping("/listBuckets")
    public ResultDO listBuckets() {
        try {
            return ResultDO.buildSuccessResult(minioSaveService.listBuckets());
        } catch (Exception e) {
            return ResultDO.buildFailResult("查看所有桶失败", e.getMessage());
        }
    }

    @RequestMapping("/listObjects")
    public ResultDO listObjects(String bucket, String path) {
        try {
            return ResultDO.buildSuccessResult(minioSaveService.listObjects(bucket, path));
        } catch (Exception e) {
            e.printStackTrace();
            return ResultDO.buildFailResult("查看文件列表失败", e.getMessage());
        }
    }

    @RequestMapping("/upload")
    public ResultDO upload(@RequestParam("file") MultipartFile[] files, String bucket, String minioPath) {
        try {
            String url = null;
            for (MultipartFile file : files) {
                if (!file.isEmpty()) {
                    url = minioSaveService.uploadFile(file, bucket, minioPath);
                }
            }
            return ResultDO.buildSuccessResult(url);
        } catch (Exception e) {
            return ResultDO.buildFailResult("文件上传minio失败,bucket:" + bucket + ",minioPath:" + minioPath, e.getMessage());
        }
    }

    public static void main(String[] args) {
        System.out.println(LocalDate.now().getYear());
    }

    @RequestMapping("/uploadTmp")
    public ResultDO uploadTmp(@RequestParam("file") MultipartFile[] files) {
        try {
            String url = null;
            for (MultipartFile file : files) {
                if (!file.isEmpty()) {
                    url = minioSaveService.uploadFile(file, "tmp", String.valueOf(LocalDate.now().getYear()));
                }
            }
            return ResultDO.buildSuccessResult(url);
        } catch (Exception e) {
            return ResultDO.buildFailResult("文件上传minio失败,bucket:" + "tmp" + ",minioPath:" + LocalDate.now().getYear(), e.getMessage());
        }
    }

    @RequestMapping("/delete")
    public ResultDO delete(String bucket, String objectName) {
        try {
            return ResultDO.buildSuccessResult(minioSaveService.deleteFile(bucket, objectName));
        } catch (Exception e) {
            if (e.getMessage().contains("The specified key does not exist")) {
                return ResultDO.buildFailResult("删除失败", "文件不存在");
            }
            return ResultDO.buildFailResult("minio文件删除失败,bucket:" + bucket + ",objectName:" + objectName, e.getMessage());
        }
    }

    @RequestMapping("/deleteByUrl")
    public ResultDO deleteByUrl(String url) {
        try {
            return ResultDO.buildSuccessResult(minioSaveService.deleteByUrl(url));
        } catch (Exception e) {
            if (e.getMessage().contains("The specified key does not exist")) {
                return ResultDO.buildFailResult("删除失败", "文件不存在");
            }
            return ResultDO.buildFailResult("minio文件删除失败,url:" + url, e.getMessage());
        }
    }

    @RequestMapping("/uploadModule")
    public ResultDO uploadModule(@RequestParam("file") MultipartFile[] files) {
        try {
            String url = null;
            for (MultipartFile file : files) {
                if (!file.isEmpty()) {
                    url = minioSaveService.uploadFile(file, "flm", "module-center/software-package");
                }
            }
            return ResultDO.buildSuccessResult(url);
        } catch (Exception e) {
            return ResultDO.buildFailResult("文件上传minio失败", e.getMessage());
        }
    }

}

您可能感兴趣的与本文相关的镜像

Seed-Coder-8B-Base

Seed-Coder-8B-Base

文本生成
Seed-Coder

Seed-Coder是一个功能强大、透明、参数高效的 8B 级开源代码模型系列，包括基础变体、指导变体和推理变体，由字节团队开源

轻松搭建自己的图片服务器：Minio安装与使用指南
凛鼕将至的博客
12-29 2384
在现代社交媒体和数字化时代，图片的存储和分享变得越来越重要。为了更好地管理和控制自己的图片资源，搭建自己的图片服务器成为了一个不错的选择。而Minio作为一个开源的对象存储服务器，提供了可靠的存储和访问解决方案。本文将介绍如何轻松地搭建和使用Minio图片服务器。首先，我们将讨论Minio的基本概念和特点，然后详细介绍Minio的安装和配置过程，最后演示如何上传、访问和管理图片资源。通过阅读本指南，您将能够快速上手Minio，并且仅需几步操作就能搭建一个稳定可靠的图片服务器。
Springboot集成minio上传文件
人无远虑,必有近忧.
12-18 3137
文章目录1. minio的安装配置2. springboot配置pom.xml请注意版本号：8.2.1版本过高或者过低都可能会报错3. yml 配置文件4. MinioConfig 配置类5. MinioUtils 工具类6. ObjectWriteResponse 上传后返回的对象region() 方法可以获取上传后的服务端图片对应的完整访问路径 1. minio的安装配置 官方网址：https://docs.min.io/docs/minio-quickstart-guide.html 本人
MinIO文件服务器，从安装到使用
热门推荐
小蜜蜂1010的博客
05-21 3万+
mino安装以及封装上传下载工具类，提供上传接口，数据表设计，上传异常处理，minio配置
在Java开发中，MinIO的用途
最新发布
Filotimo_的博客
12-10 339
摘要：MinIO是一个基于Go语言开发的开源高性能对象存储服务，兼容Amazon S3接口。它适用于海量数据存储、备份恢复、云计算环境和数据分析等场景。在Java开发中，通过添加MinIO客户端依赖，可以轻松实现连接服务器、创建存储桶、上传下载文件等基本操作。示例代码展示了如何建立连接、检查存储桶是否存在、上传本地文件到MinIO以及从MinIO下载文件到本地的完整流程。MinIO为开发者提供了简单高效的对象存储解决方案。
SpringBoot整合Minio的详细步骤
qq_43108153的博客
03-10 5936
SpringBoot整合Minio详细步骤
SpringBoot2 整合MinIO中间件，实现文件便捷管理
【积累】，是一个长期持续的过程。
07-27 2436
MinIO是一个开源的对象存储服务。适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。MinIO是一个非常轻量的服务,可以很简单的和其他应用的结合，类似NodeJS,Redis或者MySQL。...
中间件——MinIO：部署篇
qq_42117917的博客
07-14 9159
MinIO的集群部署篇
Minio 文件对象存储 中间件
weixin_57392053的博客
01-11 2360
MinIO 是一个开源的对象存储服务器，它允许你使用 AWS S3 兼容的 API 存储和检索任意类型的数据。MinIO 提供了一个简单而强大的对象存储解决方案。本文包含Minio基本的概念以及基本操作，例如Spring Boot整合Minio和工具类的编写等
Vue2中的文件处理：MinIO集成案例研究与应用策略
[Vue2中的文件处理：MinIO集成案例研究与应用策略](https://img-blog.csdnimg.cn/20210719135637186.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01...
构建数据处理API：Minio与ActiveMQ集成与数据存储解决方案
ActiveMQ是一个开源的消息代理，用作中间件来实现实时通信。在项目中，ActiveMQ被用作消息总线，它触发数据处理。关于ActiveMQ的集成与使用，可以总结如下： - 消息队列：ActiveMQ提供了消息队列功能，允许应用...
【云服务集成案例分析】：Minio与AWS、Azure和Google Cloud的无缝对接
![【云服务集成案例分析】：Minio与AWS、Azure和Google Cloud的无缝对接]...通过分析Minio的基础知识及其与AWS、Azur
SpringBoot2 整合MinIO中间件，实现文件便捷管理.docx
07-04
MinIO使用按对象的嵌入式擦除编码保护数据，该编码以汇编代码编写，可提供最高的性能。MinIO使用Reed-Solomon代码将对象划分为n/2个数据和n / 2个奇偶校验块-尽管可以将它们配置为任何所需的冗余级别。 这意味着在12个驱动器设置中，将一个对象分片为6个数据和6个奇偶校验块。即使丢失了多达5个(（n/2）–1)个驱动器（无论是奇偶校验还是数据），仍然可以从其余驱动器可靠地重建数据。MinIO的实现可确保即使丢失或无法使用多个设备，也可以读取对象或写入新对象。最后，MinIO的擦除代码位于对象级别，并且可以一次修复一个对象。
中间件-安装Minio-集成使用（ubantu-docker）
sv
02-11 1223
v /home/minio/config:/root/.minio：这个参数将宿主机的目录//home/minio/config挂载到容器的/root/.minio目录。-e "MINIO_ROOT_USER=minioadmin"：设置环境变量MINIO_ROOT_USER，这是访问MinIO服务的用户名称，这里设置为minioadmin。-v /home/minio/data:/data：这个参数将宿主机的目录//home/minio/data挂载到容器的/data目录。
你可需要的对象存储中间件《Minio使用》
我是香菜
12-05 2221
minio 使用
【愚公系列】2022年05月 .NET架构班 071-分布式中间件 Minio的使用
愚公智库
05-27 1万+
文章目录一、MinIO的基本概念二、MinIO的基本使用1.前提准备2.具体使用2.1 启动Minio2.2 上传单个文件2.3 批量上传文件2.4 下载单个文件2.5 批量下载文件 一、MinIO的基本概念 Minio是一个基于Apache License v2.0开源的分布式对象存储服务。它兼容亚马逊S3云存储服务接口，异常符合于存储大容量非构造化的数据，比如图片、视频、日记文献、备份数据和容器/杜撰机镜像等，而一个工具文献能够是任性巨细，从几kb到最大5T不等。且Minio十足笨重，可与使用顺序绳捆
关于外网java后端服务访问内网minio中间件，因连接minio超时，启动失败问题
Good good study,day day up
04-17 2063
注：服务器情况：2台服务器，内网服务器包含（activemq、minio、nginx、redis、mysql、后端java服务）。外网服务器只有后端java服务，访问内网的中间件（内网服务器开放了部分指定端口） 问题背景：因断电导致服务器宕机，需服务重启。内网java服务重启成功，外网java服务重启失败。错误信息，minio连接超时。
检查minio服务启动日志
u011197085的博客
02-27 4503
命令配合一些参数来实现。）选项后跟数字，指定你想查看的最近日志行数。例如，如果你想实时跟踪日志但只关心最新的几条，你可以同时使用。显示的是从旧到新的日志顺序。如果你只想查看最新的日志条目，可以使用。这些选项可以根据你的需要组合使用，以便更有效地查找和查看。：如果你想查看某个特定时间段的日志，可以使用。：如果你只对最近的几条日志感兴趣，可以使用。：如果你想实时查看日志，可以使用。的服务的最新日志，你可以使用。希望这些信息对你有帮助！
黑马Minio（对象存储服务MinIO）
weixin_50458070的博客
04-23 2531
MinIO
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值