手摸手带你SpringBoot集成MinIO入门

编程语言 2023-12-17 20:45:19 阅读次数: 0

本文章简单介绍了MinIO的基础使用，方便大家快速入门上手MinIO。

一、MinIO是什么？

MinIO基于Apache License v2.0开源协议的对象存储服务，可以做为云存储的解决方案用来保存海量的图片，视频，文档。由于采用Golang实现，服务端可以工作在Windows,Linux, OS X和FreeBSD上。配置简单，基本是复制可执行程序，单行命令可以运行起来。 

MinIO兼容亚马逊S3（ Simple Storage Service简单存储服务） 云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。

基本概念

  • bucket – 类比于文件系统的目录

  • Object – 类比文件系统的文件

  • Keys – 类比文件名

官网文档：http://docs.minio.org.cn/docs/

MinIO的特点

  • 数据保护

    Minio使用Minio Erasure Code（纠删码）来防止硬件故障。即便损坏一半以上的driver，但是仍然可以从中恢复。

  • 高性能

    作为高性能对象存储，在标准硬件条件下它能达到55GB/s的读、35GB/s的写速率

  • 可扩容

    不同MinIO集群可以组成联邦，并形成一个全局的命名空间，并跨越多个数据中心

  • SDK支持

    基于Minio轻量的特点，它得到类似Java、Python或Go等语言的sdk支持

  • 有操作页面

    面向用户友好的简单操作界面，非常方便的管理Bucket及里面的文件资源

  • 功能简单

    这一设计原则让MinIO不容易出错、更快启动

  • 丰富的API

    支持文件资源的分享连接及分享链接的过期策略、存储桶操作、文件列表访问及文件上传下载的基本功能等。

  • 文件变化主动通知

    存储桶（Bucket）如果发生改变,比如上传对象和删除对象，可以使用存储桶事件通知机制进行监控，并通过以下方式发布出去:AMQP、MQTT、Elasticsearch、Redis、NATS、MySQL、Kafka、Webhooks等。

 二、MinIO安装

本文使用Linux+Docker的形式安装MinIO，安装步骤请看：Docker安装MinIO详细步骤_怪 咖@的博客-CSDN博客

 三、集成SpringBoot快速入门

创建项目，demo演示项目：MinIO-Demo: MinIo的demo，简单展示了minio的使用。 (gitee.com)

1.导入pom依赖

spring依赖请自己导入

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>7.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.28</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
        </dependency>

2.yml配置

spring:
  # 配置文件上传大小限制
  servlet:
    multipart:
      max-file-size: 200MB
      max-request-size: 200MB
minio:
  accessKey: minioadmin
  secretKey: minioadmin
  #填写你的桶名称
  bucket: xxx
  endpoint: http://你的IP:9090
  readPath: http://你的IP:9090

 一般一个服务使用一个桶bucket，

3.编写配置类

MinIOConfigProperties:

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;
}

MinIOConfig :

import io.minio.MinioClient;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Data
@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();
    }
}

 4.MinIO操作工具类



import com.rikka.config.MinIOConfigProperties;
import io.minio.*;
import io.minio.messages.DeleteObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
 
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Component
@EnableConfigurationProperties(MinIOConfigProperties.class)
@Slf4j
public class MinIOUtil {
 
    @Autowired
    private MinIOConfigProperties minIOConfigProperties;
 
    @Autowired
    private MinioClient minioClient;
 
    private final static String separator = "/";

    /**
     * 判断文件是否存在
     * @param bucketName
     * @return
     */
    public boolean existBucket(String bucketName, String objectName){
        // 若数据库中存在，根据数据库中的文件信息，则继续判断bucket中是否存在
        try {
            InputStream inputStream = minioClient.getObject(GetObjectArgs
                    .builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .build());
            if (inputStream == null) {
                return false;
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }
    /**
     * 判断bucket是否存在，不存在则创建, 默认为yml配置的 bucket
     */
    public String existBucket(String bucketName){
        if (StringUtils.isBlank(bucketName)) {
            bucketName = minIOConfigProperties.getBucket();
        }
        try {
            boolean exist = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            if(!exist){
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            }
        }catch (Exception e){
            log.error("minio exist Bucket error.",e);
            throw new RuntimeException("判断bucket是否存在，不存在则创建,失败");
        }
        return bucketName;
    }
 
 
    /**
     * 删除存储bucket
     * @param bucketName 存储bucket名称，必填
     * @return Boolean
     */
    public Boolean removeBucket(String bucketName) {
        try {
            minioClient.removeBucket(RemoveBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            log.error("minio remove Bucket error.",e);
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 将本地文件上传到minio
     * @param filePath      本地文件路径
     * @param bucket        桶
     * @param objectName    对象名称
     */
    private void uploadToMinio(String filePath, String bucket, String objectName) {
        String contentType = objectName.split("\\.")[1];
        try {
            minioClient.uploadObject(UploadObjectArgs
                    .builder()
                    .bucket(bucket)
                    .object(objectName)
                    .filename(filePath)
                    .contentType(contentType)
                    .build());
        } catch (Exception e) {
            log.error("上传到文件系统出错");
        }
    }

    /**
     * 文件上传(根据本地文件)，以日期为格式
     * @param bucketName
     * @param prefix 前缀
     * @param fileName 本地文件全路径 D:/xx/xx.text
     * @return
     */
    public String upload(String bucketName, String prefix, String fileName) {
        //判断并创建Bucket
        bucketName = existBucket(bucketName);
        String uuid = UUID.randomUUID().toString().replace("-","");
        DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
        String format = dateFormat.format(new Date());
        StringBuilder stringBuilder = new StringBuilder();
        if (StringUtils.isNotBlank(prefix)) {
            stringBuilder.append(prefix).append(separator);
        }
        String suffix = fileName.split("\\.")[1];
        stringBuilder.append(format).append(separator).append(uuid).append(suffix);
        try {
            // 上传到minio服务器
            minioClient.uploadObject(UploadObjectArgs.builder()
                    .bucket(bucketName)
                    .filename(fileName)
                    .object(stringBuilder.toString())
                    .build());
            return minIOConfigProperties.getReadPath() + separator + minIOConfigProperties.getBucket() +
                    separator +
                    stringBuilder.toString();
        } catch (Exception e) {
            log.error("minio put file error.",e);
            throw new RuntimeException("上传文件失败");
        }
    }
 
    /**
     * 文件上传(根据流),文件路径以日期为格式
     * @param bucketName
     * @param prefix 前缀
     * @param file
     * @return
     */
    public String upload(String bucketName, String prefix, MultipartFile file) {
        //判断并创建Bucket
        bucketName = existBucket(bucketName);
        String filePath = builderFilePath(prefix, file);
        try {
            InputStream inputStream = file.getInputStream();
            // 上传到minio服务器
            minioClient.putObject(PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(filePath)
                    .stream(inputStream, inputStream.available(), -1)
                    .build());
            return minIOConfigProperties.getReadPath() + separator + minIOConfigProperties.getBucket() +
                    separator +
                    filePath;
        } catch (Exception e) {
            log.error("minio put file error.",e);
            throw new RuntimeException("上传文件失败");
        }
    }
 
    /**
     *  上传图片文件
     * @param bucketName  bucket名称，为空时默认yml配置
     * @param prefix  文件前缀
     * @param multipartFile  文件
     * @return  文件全路径
     */
    public String uploadImgFile(String bucketName, String prefix, MultipartFile multipartFile) {
        //判断并创建Bucket
        bucketName = existBucket(bucketName);
        //构建文件存储路径
        String filePath = builderFilePath(prefix, multipartFile);
 
        try {
            InputStream inputStream = multipartFile.getInputStream();
            PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                    .object(filePath)
                    .contentType("image/jpg")
                    .bucket(bucketName)
                    .stream(inputStream,inputStream.available(),-1)
                    .build();
            minioClient.putObject(putObjectArgs);
            return minIOConfigProperties.getReadPath() + separator + minIOConfigProperties.getBucket() +
                    separator +
                    filePath;
        }catch (Exception ex){
            log.error("minio put image file error.",ex);
            throw new RuntimeException("上传文件失败");
        }
    }
 
    /**
     * 下载文件
     * @param bucketName 必填
     * @param pathUrl  文件全路径
     * @return  文件流
     */
    public byte[] downLoadFile(String bucketName, 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(bucketName).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();
    }

    /**
     *
     * @param bucketName
     * @param folderPath 分片文件路径
     * @param chunkTotal
     * @param fileName 合并后的文件名
     * @return
     */
    public boolean mergeChunkFiles(String fileMd5, String bucketName, String folderPath, int chunkTotal, String fileName) {
        List<ComposeSource> sources = Stream.iterate(0, i -> i++).limit(chunkTotal).map(i -> ComposeSource
                .builder()
                .bucket(minIOConfigProperties.getBucket())
                .object(folderPath + i).build()).collect(Collectors.toList());

        // 合并后文件的名
        String extension = fileName.substring(fileName.lastIndexOf("."));
        String objectName = getFilePathByMd5(fileMd5, extension);
        //指定合并后的objectName等信息
        ComposeObjectArgs composeObjectArgs = ComposeObjectArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                .sources(sources)
                .build();
        //合并文件,单个分片文件大小必须为5m
        try {
            minioClient.composeObject(composeObjectArgs);

        } catch (Exception e) {
            e.printStackTrace();
            log.error("合并文件出错了，bucket:{},objectName:{},错误信息:{}",minIOConfigProperties.getBucket(), objectName, e.getMessage());
            return false;
        }
        return true;
    }

    /**
     * 删除文件
     * @param bucketName 存储bucket名称，必填
     * @param pathUrl  文件全路径
     */
    public boolean deleteFile(String bucketName, 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(bucketName).object(filePath).build();
        try {
            minioClient.removeObject(removeObjectArgs);
        } catch (Exception e) {
            log.error("minio remove file error.  pathUrl:{}",pathUrl);
            e.printStackTrace();
            return false;
        }
        return true;
    }
 
    /**
     * 批量删除文件对象
     * @param bucketName 存储bucket名称，必填
     * @param objects 对象名称集合
     */
    public boolean removeObjects(String bucketName, List<String> objects) {
        Map<String,String > resultMap = new HashMap<>();
        List<DeleteObject> dos = objects.stream().map(e -> new DeleteObject(e)).collect(Collectors.toList());
        try {
            minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(dos).build());
 
        }catch (Exception e){
            log.error("minio remove file error.  objects:{}",objects);
            return false;
        }
        return true;
    }
 
    /**
     * 文件存储路径构建 yyyy/mm/dd/uuid.jpg
     * @param prefix
     * @param multipartFile
     * @return
     */
    public String builderFilePath(String prefix, MultipartFile multipartFile) {
        String filename = multipartFile.getOriginalFilename();
        assert filename != null;
        String suffix = filename.split("\\.")[1];
        String uuid = UUID.randomUUID().toString().replace("-","");
        StringBuilder stringBuilder = new StringBuilder(50);
        if(StringUtils.isNotBlank(prefix)){
            stringBuilder.append(prefix).append(separator);
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        String todayStr = sdf.format(new Date());
        stringBuilder.append(todayStr).append(separator).append(uuid);
        stringBuilder.append(".").append(suffix);
        return stringBuilder.toString();
    }

    /**
     * 合并后完整视频路径
     * @param fileMd5
     * @param fileExt
     * @return
     */
    private String getFilePathByMd5(String fileMd5, String fileExt) {
        return fileMd5.substring(0, 1) + "/" + fileMd5.substring(1, 2) + "/" + fileMd5 + "/" + fileMd5 + fileExt;
    }
}

 之后直接注入工具类，使用就行。

总结

以上就是今天要讲的内容啦，觉得有帮助的童靴麻烦点点关注啦！

猜你喜欢

转载自blog.csdn.net/weixin_58403235/article/details/134563289
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
[编程题]学英语
[codeforces 1288A] Deadline 约数+模
Python的web开发
Docker在Centos 7上的部署
python编码
解决Ubuntu16.04 fatal error: json/json.h: No such file or directory
mysql并发插入
rest接口如何适应jsonp的方案
linux 终端上网设置
高数——等号两边同时求导、积分的解释
每日归档
更多
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022