如何将MinIO封装为SpringBoot-Starter？

最新推荐文章于 2024-05-14 14:31:50 发布
最新推荐文章于 2024-05-14 14:31:50 发布
阅读量656 收藏 4
点赞数 4
文章标签： spring boot java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingyyf24/article/details/125811941
版权

如何将MinIO封装为SpringBoot-Starter？

1、需求分析

由于MinIo可能会在多个微服务中被调用，而原生的MinIo API使用需要进行端点、账号、密码等初始化，在每个微服务中都进行相同的初始化步骤显然会让代码显得冗余，由此我们想到可以将这些初始化的工作，及相应的上传、下载等业务进行封装。

我们可以将上述功能封装为一个工具类，或者，将其封装成一个springboot的起步依赖，这样只需要在每个需要该功能的微服务中引入对应的起步依赖即可。

2、原生MinIO使用

2.1、使用docker启动

docker run -p 9000:9000 --name minio -d --restart=always -e "MINIO_ACCESS_KEY=minio" -e "MINIO_SECRET_KEY=minio123" -v /home/data:/data -v /home/config:/root/.minio minio/minio server /data

2.2、控制台登录

浏览器访问 http://host:port/9000访问MinIO控制台，初始账号密码均为minio

2.3、java代码操作MinIO（SpringBoot项目）

2.3.1、导入对应的pom依赖
<dependencies>
    <dependency>
        <groupId>io.minio</groupId>
        <artifactId>minio</artifactId>
        <version>7.1.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
</dependencies>
2.3.2、测试代码
package com.minioTest;

import io.minio.MinioClient;
import io.minio.PutObjectArgs;

import java.io.FileInputStream;

public class MinIOTest {


    public static void main(String[] args) {

        FileInputStream fileInputStream = null;
        try {
            //1、根据文件地址创建文件输出流
            fileInputStream =  new FileInputStream("D:\\list.html");;

            //2.创建minio链接客户端
            MinioClient minioClient = MinioClient.builder().credentials("minio", "minio123").endpoint("http://192.168.200.130:9000").build();
            //2.上传
            PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                .object("list.html")//文件名
                .contentType("text/html")//文件类型
                .bucket("leadnews")//桶名词  与minio创建的名词一致
                .stream(fileInputStream, fileInputStream.available(), -1) //文件流
                .build();
            minioClient.putObject(putObjectArgs);
            System.out.println("http://192.168.200.130:9000/leadnews/ak47.jpg");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

}

3、将MinIO封装为springboot-starter

3.1、创建模块storage-file-starter，并导入相关依赖

minio、spring-boot-starter、spring-boot-configuration-processor、spring-boot-starter-actuator

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-autoconfigure</artifactId>
    </dependency>
    <dependency>
        <groupId>io.minio</groupId>
        <artifactId>minio</artifactId>
        <version>7.1.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
</dependencies>

3.2、配置类

  1. MinIOConfigProperties（配置信息）

    package com.storage.file.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import java.io.Serializable;

@Data
@ConfigurationProperties(prefix = "minio")  // 文件上传 配置前缀
public class MinIOConfigProperties implements Serializable {

    private String accessKey;
    private String secretKey;
    private String bucket;
    private String endpoint;
    private String readPath;
}

  2. MinIOConfig（minioClient的bean）

    package com.stprage.file.config;

import com.heima.file.service.FileStorageService;
import io.minio.MinioClient;
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;


@Configuration
@EnableConfigurationProperties({MinIOConfigProperties.class})
public class MinIOConfig {

   @Autowired
   private MinIOConfigProperties minIOConfigProperties;

    @Bean
    public MinioClient buildMinioClient(){
        return MinioClient
                .builder()
                .credentials(minIOConfigProperties.getAccessKey(), minIOConfigProperties.getSecretKey())
                .endpoint(minIOConfigProperties.getEndpoint())
                .build();
    }
}

3.3、封装service类

将功能封装至一个service类中，并在下一步骤对该service进行自动配置，其他微服务引入该依赖时便可自动注入该service

package com.storage.file.service.impl;


import com.storage.file.config.MinIOConfig;
import com.storage.file.config.MinIOConfigProperties;
import com.storage.file.service.FileStorageService;
import io.minio.GetObjectArgs;
import io.minio.MinioClient;
import io.minio.PutObjectArgs;
import io.minio.RemoveObjectArgs;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Import;
import org.springframework.util.StringUtils;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.Date;

@Slf4j
@Import(MinIOConfig.class)
public class MinIOFileStorageService{

    @Autowired
    private MinioClient minioClient;

    @Autowired
    private MinIOConfigProperties minIOConfigProperties;

    private final static String separator = "/";

    /**
     * @param dirPath
     * @param filename  yyyy/mm/dd/file.jpg
     * @return
     */
    public String builderFilePath(String dirPath,String filename) {
        StringBuilder stringBuilder = new StringBuilder(50);
        if(!StringUtils.isEmpty(dirPath)){
            stringBuilder.append(dirPath).append(separator);
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        String todayStr = sdf.format(new Date());
        stringBuilder.append(todayStr).append(separator);
        stringBuilder.append(filename);
        return stringBuilder.toString();
    }

    /**
     *  上传图片文件
     * @param prefix  文件前缀
     * @param filename  文件名
     * @param inputStream 文件流
     * @return  文件全路径
     */
    @Override
    public String uploadImgFile(String prefix, String filename,InputStream inputStream) {
        String filePath = builderFilePath(prefix, filename);
        try {
            PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                    .object(filePath)
                    .contentType("image/jpg")
                    .bucket(minIOConfigProperties.getBucket()).stream(inputStream,inputStream.available(),-1)
                    .build();
            minioClient.putObject(putObjectArgs);
            StringBuilder urlPath = new StringBuilder(minIOConfigProperties.getReadPath());
            urlPath.append(separator+minIOConfigProperties.getBucket());
            urlPath.append(separator);
            urlPath.append(filePath);
            return urlPath.toString();
        }catch (Exception ex){
            log.error("minio put file error.",ex);
            throw new RuntimeException("上传文件失败");
        }
    }

    /**
     *  上传html文件
     * @param prefix  文件前缀
     * @param filename   文件名
     * @param inputStream  文件流
     * @return  文件全路径
     */
    @Override
    public String uploadHtmlFile(String prefix, String filename,InputStream inputStream) {
        String filePath = builderFilePath(prefix, filename);
        try {
            PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                    .object(filePath)
                    .contentType("text/html")
                    .bucket(minIOConfigProperties.getBucket()).stream(inputStream,inputStream.available(),-1)
                    .build();
            minioClient.putObject(putObjectArgs);
            StringBuilder urlPath = new StringBuilder(minIOConfigProperties.getReadPath());
            urlPath.append(separator+minIOConfigProperties.getBucket());
            urlPath.append(separator);
            urlPath.append(filePath);
            return urlPath.toString();
        }catch (Exception ex){
            log.error("minio put file error.",ex);
            ex.printStackTrace();
            throw new RuntimeException("上传文件失败");
        }
    }

    /**
     * 删除文件
     * @param pathUrl  文件全路径
     */
    @Override
    public void delete(String pathUrl) {
        String key = pathUrl.replace(minIOConfigProperties.getEndpoint()+"/","");
        int index = key.indexOf(separator);
        String bucket = key.substring(0,index);
        String filePath = key.substring(index+1);
        // 删除Objects
        RemoveObjectArgs removeObjectArgs = RemoveObjectArgs.builder().bucket(bucket).object(filePath).build();
        try {
            minioClient.removeObject(removeObjectArgs);
        } catch (Exception e) {
            log.error("minio remove file error.  pathUrl:{}",pathUrl);
            e.printStackTrace();
        }
    }


    /**
     * 下载文件
     * @param pathUrl  文件全路径
     * @return  文件流
     *
     */
    @Override
    public byte[] downLoadFile(String pathUrl)  {
        String key = pathUrl.replace(minIOConfigProperties.getEndpoint()+"/","");
        int index = key.indexOf(separator);
        String bucket = key.substring(0,index);
        String filePath = key.substring(index+1);
        InputStream inputStream = null;
        try {
            inputStream = minioClient.getObject(GetObjectArgs.builder().bucket(minIOConfigProperties.getBucket()).object(filePath).build());
        } catch (Exception e) {
            log.error("minio down file error.  pathUrl:{}",pathUrl);
            e.printStackTrace();
        }

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buff = new byte[100];
        int rc = 0;
        while (true) {
            try {
                if (!((rc = inputStream.read(buff, 0, 100)) > 0)) break;
            } catch (IOException e) {
                e.printStackTrace();
            }
            byteArrayOutputStream.write(buff, 0, rc);
        }
        return byteArrayOutputStream.toByteArray();
    }
}

3.4、加入自动配置(关键)

在resources中新建META-INF/spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.heima.file.service.impl.MinIOFileStorageService

3.5、其他微服务使用

在其他微服务中映入该启动依赖，自动注入service便可使用封装好的相关功能。

4、思路总结

  1. 明确自动配置的bean

    需要将某个功能封装成springboot-starter项目，首先考虑需要对什么类进行自动配置，使其被spring容器管理。针对本项目，我们将通过minioAPI实现的相关功能封装进了MinIOFileStorageService类中，因此需要对其进行自动配置。所以，我们将该类加入到META-INF/spring.factories配置文件中。

  2. 解决自动配置bean的依赖问题

    针对本项目，MinIOFileStorageService类主要依赖于MinioClient类和MinIOConfigProperties类的自动注入。注意，该MinioClient并非原生的minio自带的类，而是进行过相关初始化的MinioClient，所以我们需要引入一个经@ConfigurationProperties(prefix = "minio")注解修饰的类来接收application.yml或者bootstrap.yml(nacos云端配置)中的针对minio的配置信息:

    minio:
  accessKey: minio
  secretKey: minio123
  bucket: leadnews
  endpoint: http://192.168.200.130:9000
  readPath: http://192.168.200.130:9000

    然后我们定义一个经@Configuration和@EnableConfigurationProperties({MinIOConfigProperties.class})修饰的配置类来注入配置信息，利用配置信息来进行MinioClient的初始化，并利用@bean注解进行bean注入。

    最后，我们在service类中，利用@import注解引入初始化好的MinioClient类即可。

kingyyf24
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
MinIO整合SpringBoot（封装Starter）
qq_46073180的博客
12-19 374
SpringBoot整合MinIO
spring-boot-starter-minio:用于Spring Boot的Minio启动器
05-07
Spring Boot Starter Minio Spring Boot Starter，它可以连接到Minio存储桶，以保存，获取和删除对象。 入门者还为执行器嵌入了指标和运行状况检查。 快速开始 只需将依赖项添加到现有的Spring Boot项目中即可。 玛文 < dependency> < groupId>com.jlefebure</ groupId> < artifactId>spring-boot-starter-minio</ artifactId> < version>1.1</ version> </ dependency> Gradle implementation ' com.jlefebure:spring-boot-starter-minio:1.1 ' 然后，将以下属性添加到application.pro
Minio 教程 - Spring Boot集成Minio
qq_33240556的博客
05-14 426
创建一个服务类来封装Minio的操作，如上传、下载、删除文件等。// 处理异常// 其他操作方法，如downloadFile, removeFile等。
手写Minio-starter 可直接封装导入项目使用
java全栈工程师
11-22 418
手写Minio-starter 可直接封装导入项目使用，minio，minio工具类，minio快速使用
Minio对象存储的spring-boot-starter，基于官方新版SDK（8.3.3）
qq_31277409的博客
10-29 1541
前言 新版Minio的SDK变得还是挺大的，网上很多都是旧版的资料，很多都不好用，所以自己去肝官方文档，然后基于最新的API，制作了spring-boot-starter，开箱即用。 地址 nau.minio.spring-boot-starter: minio springboot的starter (gitee.com) 示例 1.MinioService 中对官方sdk进行了高级封装，可以通过MinioService 获取上传链接（用于前...
基于Minio对象存储的SpringBoot快速启动器
GIS摆渡人
04-06 650
文章目录一.介绍二.核心三.使用1.框架依赖2.配合文件3.代码使用其他参考 一.介绍 基 于 Minio 对 象 存 储 的 Spring Boot 快 速 启 动 器，开 箱 即 用 项目名称 版本号 官网地址 minio 7.1.0 https://docs.min.io/docs/java-client-quickstart-guide spring-boot 2.3.7.RELEASE https://spring.io/projects/spring-boot hutoo
如何封装springboot的starter（第一天）
dinglong3637的博客
09-04 445
--为啥要封装starter --如何封装 --测试 为啥要封装starter springboot的starter开箱即用，只需要引入依赖，就可以帮你自动装配bean，这样可以让开发者不需要过多的关注框架的配置。 如何封装 新建SpringBoot项目，引入以下依赖包到pom.xml <dependency> <groupId>org.springfra...
将MinIO封装为starter
07-22
例如，可以提供一些常用的上传、下载和删除文件的方法，而无需开发人员自己编写复杂的操作代码,减少了在多个项目中重复配置的工作,将MinIO封装为starter后，可以更好地与Spring Boot框架和其他组件进行集成这样，...
minio 安装步骤以及springboot 如何集成minio
08-07
包含minio 安装步骤、springboot 如何集成minio，封装的minio 操作工具类，增加方法设置桶的权限
Java开发案例-springboot-10-整合MinIO实现文件上传与下载-源代码+文档.rar
最新发布
05-31
Java开发案例-springboot-10-整合MinIO实现文件上传与下载-源代码+文档.rar Java开发案例-springboot-10-整合MinIO实现文件上传与下载-源代码+文档.rar Java开发案例-springboot-10-整合MinIO实现文件上传与下载-源...
Minio对象存储及Springboot整合Minio分片上传文章-代码
02-23
Minio对象存储及Springboot整合Minio分片上传文章----代码
SpringBoot封装自己的Starter的实现方法
08-26
主要介绍了SpringBoot封装自己的Starter的实现方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
springboot 集成 minio 并提取为starter
qq_32234855的博客
06-15 1002
#####1. 先不管抽取stater的事儿，创建springboot项目集成minio把文件上传成功 抽取前的demo结构： pom: <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http
如何结合 Minio 实现一个简单的可嵌入的 Spring Boot Starter 文件服务
xxxzzzqqq_的博客
04-05 448
在上一篇文章中，Markdown 编辑器还没有实现图片上传的功能，要实现图片上传，那么后端服务就需要支持文件上传，文件上传是很多后端服务需要的功能，可以实现一个 Spring Boot Starter 来支持文件的相关功能，比如文件上传、预览、下载、删除等。开源组件版本。
spring-boot-starter ~ 封装 简要版
weixin_33347188的博客
07-12 943
自定义starter封装
minio spring boot starter封装组件，基于minio-java最新版
kangaroo的博客
09-24 2029
新封装了一个组件，是对官方minio-java sdk的一个简单封装，并提供了俩个方法，供前端直传文件使用。
minio spring boot 秒传、分片上传、断点续传文件实现
kangaroo的博客
02-27 1178
基于minio自定义封装组件，实现前端分片直传，秒传，断点续传。
SpringBoot使用分布式文件系统MinIO指南
qq_53679247的博客
05-09 1210
我们创建4个文件夹模拟分布式系统。肯定会覆盖以前上传的水箭龟照片的。内部的扩展名都有那些，如下。在此目录打开终端/命令行。记住命令行输出的地址。
minio怎么在springboot 配置yaml
07-27
要在Spring Boot中使用MinIO，您可以在`application.yml`或`application.properties`文件中进行配置。下面是一个示例`application.yml`文件的配置示例： ```yaml spring: application: name: YourApplicationName minio: endpoint: your_minio_endpoint access-key: your_minio_access_key secret-key: your_minio_secret_key secure: false # 如果您的MinIO实例是使用HTTP而不是HTTPS进行访问，请将此值设置为false ``` 在上面的配置中，您需要将以下值替换为您实际的MinIO配置信息： - `your_minio_endpoint`：MinIO服务器的端点URL。例如：`http://localhost:9000` - `your_minio_access_key`：MinIO访问密钥。 - `your_minio_secret_key`：MinIO密钥。 请确保将这些值替换为您自己的凭据和配置。一旦您完成了配置，您可以在您的Spring Boot应用程序中使用`@Autowired`注解来注入MinIO客户端，以便与MinIO进行交互。 ```java import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import io.minio.MinioClient; @Component public class YourComponent { @Autowired private MinioClient minioClient; // 在这里使用minioClient进行操作 } ``` 通过上述配置和注入MinIO客户端，您可以在Spring Boot应用程序中使用MinIO进行对象存储操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值