SpringBoot整合Minio及常见问题解决

已于 2024-03-28 10:33:28 修改
阅读量978 收藏 12
点赞数 4
文章标签： spring boot 后端 java
于 2024-03-28 10:29:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53253335/article/details/137103386
版权

SpringBoot整合Minio需要使用到Minio服务的相关配置，所以需要安装Minio。推荐使用Docker安装

1，Docker安装Minio
①目标服务器

在使用Docker之前，必须有一台服务器才行。

如果有服务器的话，直接使用连接工具连接该服务器即可；
如果没有服务器，可以通过使用VMWare安装Lunix的驱动镜像来模拟一个服务器；
    教程链接：https://blog.csdn.net/weixin_61536532/article/details/129778310
②安装docker

连接上服务器之后，需要先安装docker

教程链接：https://www.cnblogs.com/Liyuting/p/17022739.html
③docker安装minio
# 拉取镜像（最新版的minio）：
docker pull minio/minio
# 检查已安装的镜像
docker images
# 创建存放配置文件的目录
mkdir -p /home/minio/config
# 创建存放上传文件的目录
mkdir -p /home/minio/data
# 多行启动，复制粘贴后，按回车
docker run -p 9000:9000 -p 9090:9090 \
     --net=host \
     --name minio \
     -d --restart=always \
     -e "MINIO_ACCESS_KEY=minioadmin" \
     -e "MINIO_SECRET_KEY=minioadmin" \
     -v /home/minio/data:/data \
     -v /home/minio/config:/root/.minio \
     minio/minio server \
     /data --console-address ":9090" -address ":9000"
④访问测试
地址：http://你的服务器ip:9090/login
用户和密码都是：minioadmin
2，创建Bucket

在这里插入图片描述
在这里插入图片描述

创建访问密钥

在这里插入图片描述
在这里插入图片描述

设置bucket的访问权限

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3，SpringBoot整合Minio
①引入依赖
<--web-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<--lombox-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.20</version>
</dependency>
<--minio-->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.2.2</version>
</dependency>
<--lang3-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.11</version>
</dependency>
②添加minio配置
//在配置文件application.yml文件中添加
minio:
  endpoint: http: 你的服务器ip:9000 # minio的api接口（注意并不是minio的服务地址）
  accessKey: admin  # 替换为前面创建的accessKey
  secretKey: 12345678 # 替换为前面创建的secretKey
  bucketName: test # 替换为前面创建的bucket
③定义读取配置类
@Data
@Component
@ConfigurationProperties(prefix = "minio")
public class MinioTemplate implements Serializable {

    @Serial
    private static final long serialVersionUID = 1L;

    /**
     * 访问地址
     */
    private String endpoint;

    /**
     * accessKey类似于用户ID，用于唯一标识你的账户
     */
    private String accessKey;

    /**
     * secretKey是你账户的密码
     */
    private String secretKey;

    /**
     * 默认存储桶
     */
    private String bucketName;
}
③创建Controller接口

@Slf4j
@RestController
@RequestMapping("/minio")
@RequiredArgsConstructor
public class MinioController {

    private final MinioTemplate minioTemplate;
    private final MinioUtils minioUtils;
    

    /**
     * 文件上传
     *
     * @param file
     */
    @PostMapping("/upload")
    public String upload(@RequestParam("file") MultipartFile file) {
        try {
            //文件名
            String fileName = file.getOriginalFilename();
            String newFileName = System.currentTimeMillis() + "." + StringUtils.substringAfterLast(fileName, ".");
            //类型
            String contentType = file.getContentType();
            minioUtils.uploadFile(minioTemplate.getBucketName(), file, newFileName, contentType);
            return "上传成功" + newFileName;
        } catch (Exception e) {
            log.error("上传失败" + e);
            return "上传失败";
        }
    }

    /**
     * 删除
     *
     * @param fileName
     */
    @DeleteMapping("/")
    public void delete(@RequestParam("fileName") String fileName) {
        minioUtils.removeFile(minioTemplate.getBucketName(), fileName);
    }

    /**
     * 获取文件信息
     *
     * @param fileName
     * @return
     */
    @GetMapping("/info")
    public String getFileStatusInfo(@RequestParam("fileName") String fileName) {
        return minioUtils.getFileStatusInfo(minioTemplate.getBucketName(), fileName);
    }

    /**
     * 获取文件外链
     *
     * @param fileName
     * @return
     */
    @GetMapping("/url")
    public String getPresignedObjectUrl(@RequestParam("fileName") String fileName) {
        return minioUtils.getPresignedObjectUrl(minioTemplate.getBucketName(), fileName);
    }

    /**
     * 文件下载
     *
     * @param fileName
     * @param response
     */
    @GetMapping("/download")
    public void download(@RequestParam("fileName") String fileName, HttpServletResponse response) {
        try {
            InputStream fileInputStream = minioUtils.getObject(minioTemplate.getBucketName(), fileName);
            response.setHeader("Content-Disposition", "attachment;filename=" + fileName);
            response.setContentType("application/force-download");
            response.setCharacterEncoding("UTF-8");
            IOUtils.copy(fileInputStream, response.getOutputStream());
        } catch (Exception e) {
            log.error("下载失败");
        }
    }
④创建minio的操作方法工具类
/**
 * MinIO工具类
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class MinioUtils {

    private MinioClient minioClient = null;

    @PostConstruct
    public void init() {
        if (minioClient == null) {
            minioClient = MinioClient.builder()
                    .endpoint(minioTemplate.getEndpoint())
                    .credentials(minioTemplate.getAccessKey(), minioTemplate.getSecretKey())
                    .build();
        }
    }

    /**
     * 判断Bucket是否存在，true：存在，false：不存在
     *
     * @param bucketName 桶名
     */
    @SneakyThrows(Exception.class)
    public boolean bucketExists(String bucketName) {
        return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
    }

    /**
     * 获得Bucket的策略
     *
     * @param bucketName 桶名
     */
    @SneakyThrows(Exception.class)
    public String getBucketPolicy(String bucketName) {
        return minioClient.getBucketPolicy(GetBucketPolicyArgs
                .builder()
                .bucket(bucketName)
                .build());
    }

    /**
     * 获得所有Bucket列表
     */
    @SneakyThrows(Exception.class)
    public List<Bucket> getAllBuckets() {
        return minioClient.listBuckets();
    }

    /**
     * 根据bucketName获取其相关信息
     *
     * @param bucketName 桶名
     */
    @SneakyThrows(Exception.class)
    public Optional<Bucket> getBucket(String bucketName) {
        return getAllBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
    }

    /**
     * 根据bucketName删除Bucket，true：删除成功； false：删除失败，文件或已不存在
     *
     * @param bucketName 桶名
     */
    @SneakyThrows(Exception.class)
    public void removeBucket(String bucketName) {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /**
     * 判断文件是否存在
     *
     * @param bucketName 桶名
     * @param objectName 文件对象名
     */
    public boolean isObjectExist(String bucketName, String objectName) {
        boolean exist = true;
        try {
            minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
        } catch (Exception e) {
            log.error("[Minio工具类]>>>> 判断文件是否存在, 异常：", e);
            exist = false;
        }
        return exist;
    }

    /**
     * 判断文件夹是否存在
     *
     * @param bucketName 桶名
     * @param objectName 文件对象名
     */
    public boolean isFolderExist(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) {
            log.error("[Minio工具类]>>>> 判断文件夹是否存在，异常：", e);
            exist = false;
        }
        return exist;
    }

    /**
     * 根据文件前置查询文件
     *
     * @param bucketName 存储桶
     * @param prefix     前缀
     * @param recursive  是否使用递归查询
     * @return MinioItem 列表
     */
    @SneakyThrows(Exception.class)
    public List<Item> getAllObjectsByPrefix(String bucketName,
                                            String prefix,
                                            boolean recursive) {
        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 bucketName 存储桶
     * @param objectName 文件名
     * @return 二进制流
     */
    @SneakyThrows(Exception.class)
    public InputStream getObject(String bucketName, String objectName) {
        return minioClient.getObject(
                GetObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build());
    }

    /**
     * 断点下载
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     * @param offset     起始字节的位置
     * @param length     要读取的长度
     * @return 二进制流
     */
    @SneakyThrows(Exception.class)
    public InputStream getObject(String bucketName, String objectName, long offset, long length) {
        return minioClient.getObject(
                GetObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .offset(offset)
                        .length(length)
                        .build());
    }

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

    private final MinioTemplate minioTemplate;

    /**
     * 使用MultipartFile进行文件上传
     *
     * @param bucketName  存储桶
     * @param file        文件名
     * @param objectName  对象名
     * @param contentType 类型
     * @return
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse uploadFile(String bucketName, MultipartFile file, String objectName, String contentType) {
        InputStream inputStream = file.getInputStream();
        PutObjectArgs args = PutObjectArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                .contentType(contentType)
                .stream(inputStream, inputStream.available(), -1)
                .build();
        return minioClient.putObject(args);
    }

    /**
     * 图片上传
     *
     * @param bucketName
     * @param imageBase64
     * @param imageName
     * @return
     */
    public ObjectWriteResponse uploadImage(String bucketName, String imageBase64, String imageName) {
        if (!StringUtils.isEmpty(imageBase64)) {
            InputStream in = base64ToInputStream(imageBase64);
            String newName = System.currentTimeMillis() + "_" + imageName + ".jpg";
            String year = String.valueOf(new Date().getYear());
            String month = String.valueOf(new Date().getMonth());
            return uploadFile(bucketName, year + "/" + month + "/" + newName, in);

        }
        return null;
    }

    public static InputStream base64ToInputStream(String base64) {
        ByteArrayInputStream stream = null;
        try {
//            byte[] bytes = new BASE64Decoder().decodeBuffer(base64.trim());
            byte[] bytes = Base64.getDecoder().decode(base64.trim());
            stream = new ByteArrayInputStream(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return stream;
    }


    /**
     * 上传本地文件
     *
     * @param bucketName 存储桶
     * @param objectName 对象名称
     * @param fileName   本地文件路径
     * @return
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse uploadFile(String bucketName, String objectName, String fileName) {
        return minioClient.uploadObject(
                UploadObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .filename(fileName)
                        .build());
    }

    /**
     * 通过流上传文件
     *
     * @param bucketName  存储桶
     * @param objectName  文件对象
     * @param inputStream 文件流
     * @return
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse uploadFile(String bucketName, String objectName, InputStream inputStream) {
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .stream(inputStream, inputStream.available(), -1)
                        .build());
    }

    /**
     * 创建文件夹或目录
     *
     * @param bucketName 存储桶
     * @param objectName 目录路径
     * @return
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse createDir(String bucketName, String objectName) {
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .stream(new ByteArrayInputStream(new byte[]{}), 0, -1)
                        .build());
    }

    /**
     * 获取文件信息, 如果抛出异常则说明文件不存在
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     * @return
     */
    @SneakyThrows(Exception.class)
    public String getFileStatusInfo(String bucketName, String objectName) {
        return minioClient.statObject(
                StatObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build()).toString();
    }

    /**
     * 拷贝文件
     *
     * @param bucketName    存储桶
     * @param objectName    文件名
     * @param srcBucketName 目标存储桶
     * @param srcObjectName 目标文件名
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse copyFile(String bucketName, String objectName, String srcBucketName, String srcObjectName) {
        return minioClient.copyObject(
                CopyObjectArgs.builder()
                        .source(CopySource.builder().bucket(bucketName).object(objectName).build())
                        .bucket(srcBucketName)
                        .object(srcObjectName)
                        .build());
    }

    /**
     * 删除文件
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     */
    @SneakyThrows(Exception.class)
    public void removeFile(String bucketName, String objectName) {
        minioClient.removeObject(
                RemoveObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build());
    }

    /**
     * 批量删除文件
     *
     * @param bucketName 存储桶
     * @param keys       需要删除的文件列表
     * @return
     */
    public void removeFiles(String bucketName, List<String> keys) {
        List<DeleteObject> objects = new LinkedList<>();
        keys.forEach(s -> {
            objects.add(new DeleteObject(s));
            try {
                removeFile(bucketName, s);
            } catch (Exception e) {
                log.error("[Minio工具类]>>>> 批量删除文件，异常：", e);
            }
        });
    }

    /**
     * 获取文件外链
     *
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @param expires    过期时间 <=7 秒 （外链有效时间（单位：秒））
     * @return url
     */
    @SneakyThrows(Exception.class)
    public String getPresignedObjectUrl(String bucketName, String objectName, Integer expires) {
        GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder().expiry(expires).bucket(bucketName).object(objectName).build();
        return minioClient.getPresignedObjectUrl(args);
    }

    /**
     * 获得文件外链
     *
     * @param bucketName
     * @param objectName
     * @return url
     */
    @SneakyThrows(Exception.class)
    public String getPresignedObjectUrl(String bucketName, String objectName) {
        GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                .method(Method.GET).build();
        return minioClient.getPresignedObjectUrl(args);
    }

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

启动项目，测试接口即可

4，常见问题解决
①上传失败：Non-XML response from server.
①将桶的权限设置为public；
②如果修改权限之后还是报这个异常，需要注意，minio的api端口和服务端口是分开来的，配置文件中设置的是api的端口。前面使用docker安装完minio后，访问minio的端口是9090，这个是minio的服务端口，而api端口是另一个端口9000，将配置文件中的端口更换为9000；
②异常：java.lang.NoSuchFieldError: Companion
//将minio的依赖删除，添加以下几个依赖
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.9.0</version>
</dependency>
<dependency>
    <groupId>org.jetbrains.kotlin</groupId>
    <artifactId>kotlin-stdlib</artifactId>
    <version>1.3.70</version>
</dependency>
 <dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.3.4</version>
    <exclusions>
    	<exclusion>
    		<groupId>com.squareup.okhttp3</groupId>
    		<artifactId>okhttp</artifactId>
    	</exclusion>
    	<exclusion>
    		<groupId>org.jetbrains.kotlin</groupId>
    		<artifactId>kotlin-stdlib</artifactId>
    	</exclusion>
    </exclusions>
</dependency>

重新编译后，启动测试即可

参考文章链接：

https://blog.csdn.net/weixin_61536532/article/details/129778310

https://www.cnblogs.com/Liyuting/p/17022739.html

Docker 搭建 Minio 容器 (完整详细版)_docker minio-CSDN博客

手把手教你SpringBoot轻松整合Minio实现文件上传下载-腾讯云开发者社区-腾讯云 (tencent.com)

橘五
关注
  • 4
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Minio对象存储及Springboot整合Minio分片上传文章-代码
02-23
Minio是一款开源的对象存储服务，它致力于为开发者提供简单、高性能、高可用的云存储解决方案。Minio的设计灵感来源于Amazon S3，适用于存储大量的非结构化数据，如图片、视频、文档等。在本文中，我们将深入探讨...
SpringBoot整合minio
03-31
**SpringBoot整合MinIO详解** 在现代Web应用开发中，数据存储和文件管理是一个不可或缺的部分。SpringBoot作为Java领域的一款轻量级框架，为开发者提供了快速构建应用的便利。而MinIO是一款开源的对象存储服务器，...
MinIO集成Spring完成分片上传、秒传、断点续传-version-8.5.3
eagles_on的博客
08-04 1491
在要实现minio分片上传功能时，发现MinioClient 中的方法有变化，之后在阅读大佬的代码之后，自己根据新版的MinioClient整合的分片上传，主要就是为了懒人一步到位。
springboot整合最新版minio和minio的安装（完整教程，新人必看）
m0_63251896的博客
03-14 3285
springboot整合最新版minio和minio的安装（完整教程，新人必看） ​ 概述：这种东西，多写点，方便以后自己使用 第一步：docker安装配置minio 第一步：拉取镜像 docker pull minio/minio 第二步：创建用于存储MinIO数据的卷 MinIO需要一个用于持久化存储的卷。创建一个目录，并使用docker volume create命令创建一个Docker卷： mkdir ~/minio-storage # 在用户主目录下创建一个用于存储的目录 docker v
Springboot整合Minio对象存储超级详细讲解以及配置搭建
最新发布
软件Java开发工程师
05-21 1098
springboot整合minio
SpringBoot整合Minio的详细步骤
qq_43108153的博客
03-10 3212
SpringBoot整合Minio详细步骤
SpringBoot集成MinIO碰到的坑
qq_39400568的博客
07-04 710
SpringBoot集成MinIO碰到的坑
io.minio.errors.ErrorResponseException: The request signature we calculated does not match the signa
顾染尘
09-20 507
minion出现资源异常，实际是密码不对，我的是springboot配置文件里面配置的minion密码，用户名，密码之前修改过而代码忘记同步更新出现的异常。密码更新之后重新部署启动就可以正常使用minion了。
springboot minio项目配置https后minio无法访问问题，minio配置https
俗语的博客
05-06 1951
2 证书必须是paivate.key 和public.crt .pem文件直接改成.crt即可。1 将证书放到/root/.minio/certs目录内。3 修改application.yml配置文件。endpoint: 域名:端口。
解决springboot启动时minio报错的问题（注入bean时报错）
dj_xyp的博客
11-08 8081
解决springboot启动的时候minio注入bean报错的问题
SpringBoot 整合 MinIo demo
06-15
**SpringBoot 整合 MinIo 知识点详解** 在现代Web开发中，文件存储是不可或缺的一部分，而SpringBoot作为Java领域广泛使用的轻量级框架，提供了与多种存储服务集成的能力，其中包括MinIO。MinIO是一款开源的对象...
minio 安装步骤以及springboot 如何集成minio
08-07
将MinIO集成到SpringBoot应用中，可以方便地管理和使用对象存储服务。下面我们将详细探讨MinIO的安装过程以及如何在SpringBoot应用中进行集成。 ### MinIO的安装步骤 1. **下载MinIO**: 首先，你需要从MinIO的官方...
SpringBoot(31) 整合MinIO实现文件上传与下载
08-17
整合SpringBoot和MinIO，我们需要以下步骤： 1. **添加依赖**：在SpringBoot的`pom.xml`文件中，添加MinIO的客户端SDK依赖。当前版本可能为`io.minio:minio:latest.release`。同时，确保SpringBoot的相关依赖也已...
springboot集成minio
zero_wsh的博客
05-06 211
springboot快速集成minio
SpringBoot-集成Minio
孟孟的博客
10-24 7421
Minio 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。Minio是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL。
二.minio整合springboot、文件上传下载、增删改查bucket和object
yuguang的博客
08-06 2805
1.效果展示 1.1windows中minio运行 1.2minio管理页面 1.3制作图片服务
minio的安装和springboot集成minio
qq_47614329的博客
04-25 3166
minio的安装和springboot集成minio
SpringBoot集成Minio实战详解
weixin_46242847的博客
02-06 2359
本博客旨在快速使用sringBoot集成MinIo,具有很强的使用性和参考意义，可减少初学者的学习成本，快速提高技术。
Java实现Minio桶存储配额等一系列权限配置
qq_36250202的博客
08-29 5129
Minio实现创建桶、桶存储配置（存储大小、生命周期）、策略配置、用户权限配置，获取桶已使用存储空间及配置总存储空间。Minio JavaAPI没有实现相关桶的一系列权限配置，所以自行研发了一套。2.MInio接口实现 MinioTemplateService。3.接口实现类 MinioTemplateServiceImpl。1.需要传的参数封装为实体类。............
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
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值