2021 springboot整合Minio yml

最新推荐文章于 2024-06-17 16:36:13 发布
最新推荐文章于 2024-06-17 16:36:13 发布
阅读量1.5k 收藏 9
点赞数 4
分类专栏： springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ayunnuo/article/details/112978128
版权

spring boot Minio

springboot集成文件上传到服务器本地进行加密后存储到 Minio

  1. application.yml配置信息
#文件上传路径配置
yunnuo:
  profile: D:/tsms/uploadPath
#minio配置
minio:
  endpoint: http://localhost:9000 #默认端口9000
  accesskey: minioadmin #默认用户名
  secretkey: minioadmin #默认密码
  bucketName: backfile #桶名
  1. pom文件依赖

    <!-- https://mvnrepository.com/artifact/io.minio/minio -->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>7.1.0</version>
        </dependency>
	 <!-- lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

minio集成

  1. MinioProp.java 实体类
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
  * @ClassName:  MinioConfig
  * @Description: (与yml配置文件信息关联)
  * @author 云诺
  * @date 2021/1/4 18:14
  *

 */
@Component
@ConfigurationProperties(prefix = "minio")
public class MinioProp {
    /**
     连接地址
     */
    private String endpoint;
    /**
     * 用户名
     */
    private String accesskey;
    /**
     * 密码
     */
    private String secretkey;
    /**
     * 桶名
     */
    private String bucketName;

    @Override
    public String toString() {
        return "MinioProp{" +
                "endpoint='" + endpoint + '\'' +
                ", accesskey='" + accesskey + '\'' +
                ", secretkey='" + secretkey + '\'' +
                ", bucketName='" + bucketName + '\'' +
                '}';
    }

    public String getEndpoint() {
        return endpoint;
    }

    public void setEndpoint(String endpoint) {
        this.endpoint = endpoint;
    }

    public String getAccesskey() {
        return accesskey;
    }

    public void setAccesskey(String accesskey) {
        this.accesskey = accesskey;
    }

    public String getSecretkey() {
        return secretkey;
    }

    public void setSecretkey(String secretkey) {
        this.secretkey = secretkey;
    }

    public String getBucketName() {
        return bucketName;
    }

    public void setBucketName(String bucketName) {
        this.bucketName = bucketName;
    }
}
  1. MinioConfig 配置类
package com.tsms.common.config.minio;

import io.minio.MinioClient;
import io.minio.errors.InvalidEndpointException;
import io.minio.errors.InvalidPortException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
  * @ClassName: MinioConfig
  * @Description: (minio配置工具)
  * @author 云诺
  * @date 2021/1/4 18:14
  *

 */
@Configuration
@EnableConfigurationProperties(MinioProp.class)
@Slf4j
public class MinioConfig {

    @Autowired
    private MinioProp minioProp;

    /**
     * 获取MinioClient
     */
    @Bean
    public MinioClient minioClient()  {
        try {
            log.info("minioClient create start");
           MinioClient minioClient = MinioClient.builder().endpoint(minioProp.getEndpoint()).credentials(minioProp.getAccesskey(), minioProp.getSecretkey())
                    .build();
            log.info("minioClient create end");
            return minioClient;
        } catch (Exception e) {
            log.error("连接MinIO服务器异常：{}", e);
            return null;
        }
    }

}
  1. MinioUtils 工具类
import com.alibaba.fastjson.JSONObject;
import com.dpms.business.minio.MinioProp;
import com.dpms.common.utils.StringUtils;
import io.minio.*;
import io.minio.errors.*;
import io.minio.messages.Bucket;
import io.minio.messages.Item;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;


import javax.annotation.PostConstruct;
import java.io.*;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.List;

/**
 * @author 云诺
 * @ClassName: MinioUtils
 * @Description: (minio工具类)
 * @date 2021/1/4 18:07
 */
@Component
@Slf4j
public class MinioUtils {

    @Autowired
    private MinioProp minioProp;

    private MinioClient minioClient;

    @PostConstruct
    private MinioClient client() {
        try {
            log.info("minioClient create start");
            minioClient = MinioClient.builder().endpoint(minioProp.getEndpoint()).credentials(minioProp.getAccesskey(), minioProp.getSecretkey())
                    .build();
            log.info("minioClient create end");
            createBucket();
        } catch (Exception e) {
            log.error("连接MinIO服务器异常：{}", e);
        }
        return minioClient;
    }


    /**
     * @Title: createBucket
     * @Description: (创建bucket)
     * @author 云诺
     * [bucketName] 桶名
     */
    public void createBucket(String bucketName) {
        try {
            if (!client().bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            }
        } catch (Exception e) {
            log.error("创建桶失败:{}", e);
        }
    }


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


    /**
     * 判断文件是否存在
     *
     * @param bucketName 存储桶
     * @param objectName 对象
     * @return true：存在
     */
    public  boolean doesObjectExist(String bucketName, String objectName) {
        boolean exist = true;
        try {
            minioClient
                    .statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
        } catch (Exception e) {
            exist = false;
        }
        return exist;
    }


    /**
     * 判断文件夹是否存在
     *
     * @param bucketName 存储桶
     * @param objectName 文件夹名称（去掉/）
     * @return true：存在
     */
    public  boolean doesFolderExist(String bucketName, 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;
    }


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

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

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

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


    /**
     * @Title: uploadFile
     * @Description: (获取上传文件信息上传文件)
     * @author 云诺
     * [file 上传文件（MultipartFile）, bucketName 桶名]
     */
    public JSONObject uploadFile(MultipartFile file, String bucketName) throws Exception {
        JSONObject res = new JSONObject();
        res.put("code", 0);
        //判断文件是否为空
        if (null == file || 0 == file.getSize()) {
            res.put("msg", "上传文件不能为空");
            return res;
        }
        //判断存储桶是否存在  不存在则创建
        createBucket(bucketName);
        //文件名
        String originalFilename = file.getOriginalFilename();
        //新的文件名 = 存储桶文件名_时间戳.后缀名
        String fileName = bucketName + "_" +
                System.currentTimeMillis() +
                originalFilename.substring(originalFilename.lastIndexOf("."));
        //开始上传
        putObjectbyStream(bucketName, fileName, file.getInputStream());
        res.put("code", 1);
        res.put("fileName", fileName);
        res.put("msg", minioProp.getEndpoint() + "/" + bucketName + "/" + fileName);
        return res;
    }

    /**
     * @param filepath   文件路径，bucketName 桶名 Uuid UUID
     * @param uuid       文件UUID
     * @param bucketName com.alibaba.fastjson.JSONObject
     * @Title: uploadFile
     * @Description: 获取文件路径上传文件
     * @Title: uploadFile
     * @Description:
     */
    public JSONObject uploadFile(String filepath, String uuid, String bucketName) throws Exception {
//        MultipartFile file = null;
        File oldFile = new File(filepath);
        FileInputStream fileInputStream = new FileInputStream(oldFile);
//        file = new MockMultipartFile(oldFile.getName(), oldFile.getName(), fileInputStream);
        JSONObject res = new JSONObject();
        res.put("code", 0);
        //判断文件是否为空
        if (StringUtils.isNull(oldFile)) {
            res.put("msg", "上传文件不能为空");
            return res;
        }
        //判断存储桶是否存在  不存在则创建
        createBucket(bucketName);
        //文件名
        String originalFilename = oldFile.getName();
        //新的文件名 = 存储桶文件名_时间戳_UUID.后缀名
        String fileName = bucketName + "_" +
                System.currentTimeMillis() + "_" + uuid +
                originalFilename.substring(originalFilename.lastIndexOf("."));
        //开始上传
        putObjectbyStream(bucketName, fileName, fileInputStream);
        res.put("code", 1);
        res.put("fileName", fileName);
        res.put("msg", minioProp.getEndpoint() + "/" + bucketName + "/" + fileName);
        return res;
    }

    /**
     * @param bucketName com.alibaba.fastjson.JSONObject
     * @Title: uploadFile
     * @Description: 获取文件路径上传文件
     * *@param filepath 文件路径，bucketName 桶名
     */
    public JSONObject uploadFile(String filepath, String bucketName) throws Exception {
//        MultipartFile file = null;
        File oldFile = new File(filepath);
        FileInputStream fileInputStream = new FileInputStream(oldFile);
//        file = new MockMultipartFile(oldFile.getName(), oldFile.getName(), ContentType.APPLICATION_OCTET_STREAM.toString(), fileInputStream);
        JSONObject res = new JSONObject();
        res.put("code", 0);
        //判断文件是否为空
        if (StringUtils.isNull(oldFile)) {
            res.put("msg", "上传文件不能为空");
            return res;
        }
        //判断存储桶是否存在  不存在则创建
        createBucket(bucketName);
        //文件名
        String originalFilename = oldFile.getName();
        //新的文件名 = 存储桶文件名_时间戳_UUID.后缀名
        String fileName = bucketName + "_" +
                System.currentTimeMillis() +
                originalFilename.substring(originalFilename.lastIndexOf("."));
        //开始上传
        putObjectbyStream(bucketName, fileName, fileInputStream);
        res.put("code", 1);
        res.put("fileName", fileName);
        res.put("msg", minioProp.getEndpoint() + "/" + bucketName + "/" + fileName);
        return res;
    }

    /**
     * @Title: getAllBuckets
     * @Description: (获取全部bucket)
     * []
     */
    public List<Bucket> getAllBuckets() throws Exception {
        return client().listBuckets();
    }

    /**
     * @param bucketName bucket名称
     * @Title: removeBucket
     * @Description: (根据bucketName删除信息)
     * [bucketName] 桶名
     */
    public void removeBucket(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /**
     * @param bucketName bucket名称
     * @param objectName ⽂件名称
     * @param expires    过期时间 <=7
     * @return url
     * @Title: getObjectURL
     * @Description: (获取 ⽂ 件外链)
     * [bucketName 桶名, objectName 文件名, expires 时间<=7]
     */
    public String getObjectUrl(String bucketName, String objectName, Integer expires) throws Exception {
        return client().presignedGetObject(bucketName, objectName, expires);
    }

    /**
     * @param bucketName bucket名称
     * @param objectName ⽂件名称
     * @return ⼆进制流
     * @Title: getObject
     * @Description: (获取文件)
     * [bucketName 桶名, objectName 文件名]
     */
    public InputStream getObject(String bucketName, String objectName) throws Exception {
        return client().getObject(bucketName, objectName);
    }

    /**
     * @param bucketName bucket名称
     * @param objectName ⽂件名称
     * @param stream     ⽂件流
     * @throws Exception https://docs.minio.io/cn/java-client-api-reference.html#putObject
     * @Title: putObject
     * @Description: (上传文件)
     * [bucketName 桶名, objectName 文件名, stream ⽂件流]
     */
    public void putObject(String bucketName, String objectName, InputStream stream) throws
            Exception {
      putObjectbyStream(bucketName,objectName,stream);
    }

    /**
     * 上传⽂件
     *
     * @param bucketName  bucket名称
     * @param objectName  ⽂件名称
     * @param stream      ⽂件流
     * @param size        ⼤⼩
     * @param contextType 类型
     * @throws Exception https://docs.minio.io/cn/java-client-api-reference.html#putObject
     * @Title: putObject
     * @Description: $(文件流上传文件)
     * [bucketName, objectName, stream, size, contextType]
     */
    public void putObject(String bucketName, String objectName, InputStream stream, long
            size, String contextType) throws Exception {
        putObjectbyStream(bucketName,objectName,stream);
    }

    /**
     * @param bucketName bucket名称
     * @param objectName ⽂件名称
     * @throws Exception https://docs.minio.io/cn/java-client-api-reference.html#statObject
     * @Title: getObjectInfo
     * @Description: (获取文件信息)
     * [bucketName, objectName]
     */
    public ObjectStat getObjectInfo(String bucketName, String objectName) throws Exception {
        return client().statObject(bucketName, objectName);
    }

    /**
     * @param bucketName bucket名称
     * @param objectName ⽂件名称
     * @throws Exception https://docs.minio.io/cn/java-client-apireference.html#removeObject
     * @Title: removeObject
     * @Description: (删除文件)
     * [bucketName, objectName]
     */
    public void removeObject(String bucketName, String objectName) throws Exception {
        client().removeObject(bucketName, objectName);
    }
}
  1. controller测试

 	@Autowired
    private MinioProp minioProp;
    @Autowired
    private MinioUtils minioUtils;

 	@PostMapping("/uploadFile")
    @ResponseBody
    public List<FileUploadLog> uploadFile(@RequestParam(value = "files", required = true) MultipartFile[] files) {
     for (MultipartFile file : files) {
     minioUtils.upload(file,minioProp.getBucketName);
     }  
}
小诺大人
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring boot 整合 minio存储 【使用篇】
sumMStar的博客
02-28 1051
D:\MineFile\zuoye\xm\minioFile文件夹执行，并且增加额外端口’9999‘通过父组件导入子组件，注册子组件，引用子组件弹出。修改访问权限为public就行。打开你正在使用的bucket。注入客户端配置放入bean。重新访问链接，应该就能查看。来到minio控制台。
MinIO文件服务器，从安装到使用
热门推荐
小蜜蜂1010的博客
05-21 2万+
mino安装以及封装上传下载工具类，提供上传接口，数据表设计，上传异常处理，minio配置
Minio 文件加密 上传 下载 预览
最新发布
weixin_43465127的博客
06-17 303
在标准的服务流程里，对文件的管理操作主要包括上传、下载和预览等功能。一般而言，当文件被上传到MinIO服务器时，为了保障数据的安全性，会对其进行加密处理。相应地，在用户请求下载文件时，系统首先会对密文进行解密，确保用户能够获取到原始的未加密文件内容。MinIO 不支持传统的文件系统加密方法（同时其不对国内提供文件夹加密），因为它是一个对象存储服务。但是，MinIO 提供了数据加密功能，可以在服务器端加密所有对象数据（提供了文件对称加密工具包SymmetricCrypto）// 必须16个字符。
minio分布式文件存储
weixin_42383680的博客
10-04 3410
基本介绍什么是MinIOMinIO 是一款基于 Go 语言的高性能、可扩展、云原生支持、操作简单、开源的分布式对象存储产品。基于 Apache License v2.0 开源协议，虽然轻量，却拥有着不错的性能。它兼容亚马逊S3云存储服务接口。可以很简单的和其他应用结合使用，例如 NodeJS、Redis、MySQL 等。MinIO特点。
SpringBoot整合minio服务（超详细）
yueyue763184的博客
06-10 1万+
创建一个名为public的存储桶（名字可自定义），上传文件。在application.yml文件中编写相关配置。http://ip:9000/存储桶名/文件名。开发中上传接口用得较多，其他接口可自行测试。可以将存储桶的访问权限设置为public.# npm下载element-ui。// 引入ElementUI。
java集成minio文件系统
一朵纯洁的小白花的博客
08-11 2361
接口，单个对象最大可达5TB，适合存储海量图片、视频、日志文件、备份数据和容器/虚拟机镜像等。MinIO 是高性能的对象存储，是为海量数据存储、上文讲解了minio如何部署，本文演示如何使用。语言实现，，客户端与存储服务器之间采用。的，它完全兼容Amazon。......
SpringBoot整合minio
03-31
**SpringBoot整合MinIO详解** 在现代Web应用开发中，数据存储和文件管理是一个不可或缺的部分。SpringBoot作为Java领域的一款轻量级框架，为开发者提供了快速构建应用的便利。而MinIO是一款开源的对象存储服务器，...
Minio对象存储及Springboot整合Minio分片上传文章-代码
02-23
在本文中，我们将深入探讨如何将Minio与Spring Boot应用程序整合，并实现分片上传功能。 首先，我们需要在项目中引入Minio的Java SDK依赖。在Maven的pom.xml文件中添加以下依赖： ```xml <groupId>io.minio ...
SpringBoot 整合 MinIo demo
06-15
接下来，我们需要在SpringBoot的`application.yml`或`application.properties`文件中配置MinIO的相关信息，包括服务器地址、端口、访问密钥和秘密密钥。例如： ```yaml minio: url: http://localhost:9000 access...
springboot集成minio完成自己的分布式文件系统
02-28
SpringBoot集成MinIO是构建分布式文件系统的常见方法，尤其对于Java开发者来说，这是一个高效且经济的解决方案。MinIO是一款开源的对象存储服务器，它兼容Amazon S3 API，可以提供高性能、高可用性和安全性。通过将...
minio 安装步骤以及springboot 如何集成minio
08-07
2. **配置属性**: 在`application.properties`或`application.yml`中配置MinIO服务器的URL、访问密钥和秘密密钥： ```properties minio.url=http://your_minio_server_url minio.access-key=your_access_key ...
文件上传下载加密，解密，支持图片，压缩包等任何格式
11-23
文件上传时进行加密，下载时进行对应解密，支持各种各个文件得加密解密，解密后文件可以正常使用，包括图片，压缩包，word文档等等！！附带上传方法，以及以流方式下载的方法
Springboot整合MinIO
普通人一枚
04-24 1160
Springboot整合MinIO
SpringBoot整合Minio的详细步骤
qq_43108153的博客
03-10 3141
SpringBoot整合Minio详细步骤
如何在springboot项目中使用minio上传下载删除文件
Snowprincev的博客
11-24 739
在ruoyi中使用minio上传下载删除文件
springboot项目中使用minio进行对象存储
m0_67391907的博客
08-02 814
这就意味着MinIO的客户能够自动的、无限制、自由免费使用和集成MinIO、自由的创新和创造、自由的去修改、自由的再次发行新的版本和软件.确实,MinIO强有力的支持和驱动了很多世界500强的企业。minio利用了web缩放器的来之不易的知识，为对象存储带来了简单的存储缩放模型，在MinIO,扩展从单个群集开始，该群集可以与其他MinIO群集联合以创建全局名称空间,并在需要时可以跨越多个不同的数据中心。返回的url就是文件上传后的url，访问url就能看到上传的图片。...
Spring Boot 整合 minio（一步到位）
大家好，我是云村的王子
04-30 800
按照这个步骤来，宝贝保你一步到位 一、minio版本安装：这里我安装的新版本 新版本安装 # docker 下载镜像 docker pull minio/minio # 安装镜像 docker run \ --name minio \ -p 9000:9000 \ -p 9090:9090 \ -d --restart=always \ -e "MINIO_ROOT_USER=min...
SpringBoot 分片上传、断点续传、秒传、直传Minio
m0_46493080的博客
12-13 4768
最近在学习，在SpringBoot上进行分片上传、断点续传、直接上传到Minio服务器上，中间也遇到的不少坑、2.4.2、方法上参数写着注解说明、这个参数是用到了、没写则是没有用到，直接传NULL即可。Mono 返回的格式和消息编码可以看、2.5.1、MESSAGE("msg", "api消息编码含义"),CODE("code", "api消息编码"),COUNT("count", "总记录数");DATA("data", "api结果"),// api消息编码。
Spring Boot 整合 Minio(分布式存储服务)
Xin Adn Meng
11-08 795
Spring Boot 整合 Minio
springboot 整合minio
08-18
整合Minio到Spring Boot可以通过以下几个步骤完成： 1. 首先，需要在pom.xml文件中添加Minio的依赖项。你可以使用以下代码片段添加依赖项： ```xml <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <version>8.4.3</version> </dependency> ``` 2. 接下来，在application.yml（或application.properties）文件中配置Minio的连接信息。你需要提供Minio服务端的地址、访问密钥和存储桶名称。以下是一个示例： ```yaml minio: url: 129.0.0.1:9000 access-key: minioadmin secret-key: minioadmin bucket-name: ding_server ``` 3. 最后，在你的代码中使用Minio客户端库进行操作。你可以根据需要使用Minio的API来上传、下载和管理对象。以下是一个使用Minio客户端库的示例： ```java import io.minio.MinioClient; import io.minio.errors.MinioException; // 创建Minio客户端 MinioClient minioClient = new MinioClient("http://localhost:9000", "minioadmin", "minioadmin"); // 上传对象到Minio存储桶 minioClient.putObject("your-bucket-name", "your-object-name", "/path/to/your-file"); // 下载对象从Minio存储桶 minioClient.getObject("your-bucket-name", "your-object-name", "/path/to/save/downloaded-file"); // 列出Minio存储桶中的所有对象 Iterable<Result<Item>> results = minioClient.listObjects("your-bucket-name"); for (Result<Item> result : results) { Item item = result.get(); System.out.println(item.objectName()); } // 删除Minio存储桶中的对象 minioClient.removeObject("your-bucket-name", "your-object-name"); ``` 以上就是在Spring Boot中整合Minio的基本步骤。你可以根据具体需求进行进一步的操作和配置。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [springboot整合minio](https://blog.csdn.net/qq_36090537/article/details/128100423)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}}] [.reference_item style="max-width: 50%"] - *3* [SpringBoot整合Minio](https://blog.csdn.net/weixin_46573014/article/details/128476327)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小诺大人

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

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

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

打赏作者

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

抵扣说明：

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

余额充值