Springboot整合Minio对象存储超级详细讲解以及配置搭建

最新推荐文章于 2024-07-15 16:31:18 发布
最新推荐文章于 2024-07-15 16:31:18 发布
阅读量1.5k 收藏 6
点赞数 4
文章标签： spring boot 后端 java
WW_jkg
本文链接：https://blog.csdn.net/qq_41324075/article/details/139088460
版权

windows环境下搭建minio步骤

1.从minio官网进行查看详细信息

	地址：https://min.io/
	里面有详细的配置信息
	搭建成功之后如下如所示：用户名密码默认情况下为 username：minioadmin password：minioadmin

在这里插入图片描述

2.搭建成功之后的访问

	地址：服务ip 端口9000
	http//127.0.0.1:9000 用户名密码为默认：minioadmin 
	创建桶时候要注意桶的名称

在这里插入图片描述

springboot整合和minio的步骤如下

1.pom坐标的指定

<dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.2.2</version>
        </dependency>
        <!-- Hutool -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.18</version>
        </dependency>

2.配置文件的设置如下

package com.java.javamethod.conf;

import io.minio.MinioClient;
import lombok.SneakyThrows;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;

/**
 * Minio配置类
 * @Author ww
 * @Date 2024/5/21 10:06
 * @Version 1.0
 */


@Configuration
@EnableConfigurationProperties(MinioProperties.class)
@ConditionalOnProperty(value = "oss.name", havingValue = "minio")
public class MinioConfiguration {

    @Resource
    private MinioProperties ossProperties;

    @Bean
    @SneakyThrows
    public MinioClient minioClient() {
        return MinioClient.builder()
                .endpoint(ossProperties.getEndpoint())
                .credentials(ossProperties.getAccessKey(), ossProperties.getSecretKey())
                .build();
    }

}

package com.java.javamethod.conf;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import java.util.List;

/**
 * @Author ww
 * @Date 2024/5/21 10:08
 * @Version 1.0
 */
@Data
@ConfigurationProperties(prefix = MinioProperties.PREFIX)
public class MinioProperties {

    /**
     * 配置前缀
     */
    public static final String PREFIX = "oss";

    /**
     * 对象存储名称
     */
    private String name;

    /**
     * 对象存储服务的URL
     */
    private String endpoint;

    /**
     * Access key 账户ID
     */
    private String accessKey;

    /**
     * Secret key 密码
     */
    private String secretKey;

    /**
     * 默认的存储桶名称
     */
    private String bucketName = "qditwei";

    /**
     * 可上传的文件后缀名
     */
    private List<String> fileExt;

}

3.minio工具类的封装

package com.java.javamethod.service;

import com.java.javamethod.domain.OssFile;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.util.List;

/**
 * @Author ww
 * @Date 2024/5/21 10:54
 * @Version 1.0
 */
public interface OssTemplate {

    /**
     * 存储桶是否存在
     *
     * @param bucketName 存储桶名称
     * @return boolean
     */
    boolean bucketExists(String bucketName);


    /**
     * 获取文件信息
     *
     * @param fileName 存储桶文件名称
     * @return InputStream
     */
    OssFile getOssInfo(String fileName);

    /**
     * 上传文件
     *
     * @param folderName 上传的文件夹名称
     * @param fileName   上传文件名
     * @param file       上传文件类
     * @return BladeFile
     */
    OssFile upLoadFile(String folderName, String fileName, MultipartFile file);

    /**
     * 上传文件
     *
     * @param folderName 上传的文件夹名称
     * @param fileName   存储桶对象名称
     * @param suffix     文件后缀名
     * @param stream     文件流
     * @return BladeFile
     */
    OssFile upLoadFile(String folderName, String fileName, String suffix, InputStream stream);

    /**
     * 删除文件
     *
     * @param fileName 存储桶对象名称
     */
    boolean removeFile(String fileName);

    /**
     * 批量删除文件
     *
     * @param fileNames 存储桶对象名称集合
     */
    boolean removeFiles(List<String> fileNames);

    /**
     * @Description: 下载文件
     * @Param response: 响应
     * @Param fileName: 文件名
     * @Param filePath: 文件路径
     * @return: void
     */
    void downloadFile(HttpServletResponse response, String fileName, String filePath);
}



package com.java.javamethod.util;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.text.StrPool;
import cn.hutool.core.util.ObjectUtil;
import com.java.javamethod.conf.MinioProperties;
import com.java.javamethod.domain.OssFile;
import com.java.javamethod.service.OssTemplate;
import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.DeleteObject;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.InputStream;
import java.net.URLEncoder;
import java.util.List;
import java.util.stream.Stream;

/**
 * @Author ww
 * @Date 2024/5/21 10:52
 * @Version 1.0
 */

@Slf4j
@Service
public class MinioTemplate implements OssTemplate {

    /**
     * MinIO客户端
     */
    @Resource
    private MinioClient client;

    /**
     * 配置类
     */
    @Resource
    private MinioProperties ossProperties;

    /**
     * 格式化时间
     */
    private static final String DATE_FORMAT = "yyyyMMdd";

    /**
     * 字符集
     */
    private static final String ENCODING = "UTF-8";

    /**
     * 存储桶是否存在
     *
     * @param bucketName 存储桶名称
     * @return boolean
     */
    @Override
    public boolean bucketExists(String bucketName) {
        try {
            return client.bucketExists(BucketExistsArgs.builder().bucket(getBucketName(bucketName)).build());
        } catch (Exception e) {
            log.error("minio bucketExists Exception:{}", e);
        }
        return false;
    }

    /**
     * @Description: 创建 存储桶
     * @Param bucketName: 存储桶名称
     */
    public void makeBucket(String bucketName) {
        try {
            if (!client.bucketExists(BucketExistsArgs.builder().bucket(getBucketName(bucketName)).build())) {
                client.makeBucket(MakeBucketArgs.builder().bucket(getBucketName(bucketName)).build());
                log.info("minio makeBucket success bucketName:{}", bucketName);
            }
        } catch (Exception e) {
            log.error("minio makeBucket Exception:{}", e);
        }
    }

    /**
     * 获取文件信息
     *
     * @param fileName 存储桶文件名称
     * @return InputStream
     */
    @Override
    public OssFile getOssInfo(String fileName) {
        try {
            StatObjectResponse stat = client.statObject(
                    StatObjectArgs.builder().bucket(getBucketName(ossProperties.getBucketName())).object(fileName)
                            .build());
            OssFile ossFile = new OssFile();
            ossFile.setName(ObjectUtil.isEmpty(stat.object()) ? fileName : stat.object());
            ossFile.setFilePath(ossFile.getName());
            ossFile.setDomain(getOssHost(ossProperties.getBucketName()));
            ossFile.setHash(String.valueOf(stat.hashCode()));
            ossFile.setSize(stat.size());
            ossFile.setPutTime(DateUtil.date(stat.lastModified().toLocalDateTime()));
            ossFile.setContentType(stat.contentType());
            return ossFile;
        } catch (Exception e) {
            log.error("minio getOssInfo Exception:{}", e);
        }
        return null;
    }

    /**
     * 上传文件
     *
     * @param folderName 上传的文件夹名称
     * @param fileName   上传文件名
     * @param file       上传文件类
     * @return BladeFile
     */
    @Override
    @SneakyThrows
    public OssFile upLoadFile(String folderName, String fileName, MultipartFile file) throws RuntimeException {
        if (file == null || file.isEmpty()) {
            throw new RuntimeException("文件不能为空");
        }
        // 文件大小
        if (file.getSize() > 5 * 1024 * 1024) {
            throw new RuntimeException("文件大小不能超过5M");
        }
        String suffix = getFileExtension(file.getOriginalFilename());
        // 文件后缀判断
        /*if (!CollUtil.contains(ossProperties.getFileExt(), suffix)) {
            String error = String.format("文件类型错误,目前支持[%s]等文件类型",
                    String.join(",", ossProperties.getFileExt()));
            throw new RuntimeException(error);
        }*/
        try {
            return upLoadFile(folderName, fileName, suffix, file.getInputStream());
        } catch (Exception e) {
            log.error("minio upLoadFile Exception:{}", e);
            throw new RuntimeException("文件上传失败,请重新上传或联系管理员");
        }
    }

    /**
     * 获取文件后缀名
     *
     * @param fullName 文件全名
     * @return {String}
     */
    public static String getFileExtension(String fullName) {
        Assert.notNull(fullName, "minio file fullName is null.");
        String fileName = new File(fullName).getName();
        int dotIndex = fileName.lastIndexOf('.');
        return (dotIndex == -1) ? "" : fileName.substring(dotIndex + 1);
    }

    /**
     * 上传文件
     *
     * @param folderName 上传的文件夹名称
     * @param fileName   存储桶对象名称
     * @param suffix     文件后缀名
     * @param stream     文件流
     * @return BladeFile
     */
    @Override
    public OssFile upLoadFile(String folderName, String fileName, String suffix, InputStream stream) {
        try {
            return upLoadFile(ossProperties.getBucketName(), folderName, fileName, suffix, stream,
                    "application/octet" + "-stream");
        } catch (Exception e) {
            log.error("minio upLoadFile Exception:{}", e);
        }
        return null;
    }

    /**
     * @Description: 上传文件
     * @Param bucketName: 存储桶名称
     * @Param folderName: 上传的文件夹名称
     * @Param fileName: 上传文件名
     * @Param suffix: 文件后缀名
     * @Param stream: 文件流
     * @Param contentType: 文件类型
     */
    @SneakyThrows
    public OssFile upLoadFile(String bucketName, String folderName, String fileName, String suffix, InputStream stream,
                              String contentType) {
        if (!bucketExists(bucketName)) {
            log.info("minio bucketName is not creat");
            makeBucket(bucketName);
        }
        OssFile file = new OssFile();
        String originalName = fileName;
        String filePath = getFilePath(folderName, fileName, suffix);
        client.putObject(PutObjectArgs.builder().bucket(getBucketName(bucketName)).object(filePath)
                .stream(stream, stream.available(), -1).contentType(contentType).build());
        file.setOriginalName(originalName);
        file.setName(filePath);
        file.setDomain(getOssHost(bucketName));
        file.setFilePath(filePath);
        stream.close();
        log.info("minio upLoadFile success, filePath:{}", filePath);
        return file;
    }

    /**
     * 删除文件
     *
     * @param fileName 存储桶对象名称
     */
    @Override
    public boolean removeFile(String fileName) {
        try {
            client.removeObject(
                    RemoveObjectArgs.builder().bucket(getBucketName(ossProperties.getBucketName())).object(fileName)
                            .build());
            log.info("minio removeFile success, fileName:{}", fileName);
            return true;
        } catch (Exception e) {
            log.error("minio removeFile fail, fileName:{}, Exception:{}", fileName, e);
        }
        return false;
    }

    /**
     * 批量删除文件
     *
     * @param fileNames 存储桶对象名称集合
     */
    @Override
    public boolean removeFiles(List<String> fileNames) {
        try {
            Stream<DeleteObject> stream = fileNames.stream().map(DeleteObject::new);
            client.removeObjects(RemoveObjectsArgs.builder().bucket(getBucketName(ossProperties.getBucketName()))
                    .objects(stream::iterator).build());
            log.info("minio removeFiles success, fileNames:{}", fileNames);
            return true;
        } catch (Exception e) {
            log.error("minio removeFiles fail, fileNames:{}, Exception:{}", fileNames, e);
        }
        return false;
    }

    /**
     * @Description: 下载文件
     * @Param response: 响应
     * @Param fileName: 文件名
     * @Param filePath: 文件路径
     */
    @Override
    public void downloadFile(HttpServletResponse response, String fileName, String filePath) {
        GetObjectResponse is = null;
        try {
            GetObjectArgs getObjectArgs =
                    GetObjectArgs.builder().bucket(ossProperties.getBucketName()).object(filePath)
                            .build();
            is = client.getObject(getObjectArgs);
            // 设置文件ContentType类型，这样设置，会自动判断下载文件类型
            response.setContentType("application/x-msdownload");
            response.setCharacterEncoding(ENCODING);
            // 设置文件头：最后一个参数是设置下载的文件名并编码为UTF-8
            response.setHeader("Content-Disposition", "attachment;fileName=" + URLEncoder.encode(fileName, ENCODING));
            IoUtil.copy(is, response.getOutputStream());
            log.info("minio downloadFile success, filePath:{}", filePath);
        } catch (Exception e) {
            log.error("minio downloadFile Exception:{}", e);
        } finally {
            IoUtil.close(is);
        }
    }

    /**
     * 获取文件外链
     *
     * @param bucketName bucket名称
     * @param fileName   文件名称
     * @param expires    过期时间
     * @return url
     */
    public String getPresignedObjectUrl(String bucketName, String fileName, Integer expires) {
        String link = "";
        try {
            link = client.getPresignedObjectUrl(
                    GetPresignedObjectUrlArgs.builder().method(Method.GET).bucket(getBucketName(bucketName))
                            .object(fileName).expiry(expires).build());
        } catch (Exception e) {
            log.error("minio getPresignedObjectUrl is fail, fileName:{}", fileName);
        }
        return link;
    }

    /**
     * 根据规则生成存储桶名称规则
     *
     * @param bucketName 存储桶名称
     * @return String
     */
    private String getBucketName(String bucketName) {
        return bucketName;
    }

    /**
     * 根据规则生成文件路径
     *
     * @param folderName       上传的文件夹名称
     * @param originalFilename 原始文件名
     * @param suffix           文件后缀名
     * @return string 上传的文件夹名称/yyyyMMdd/原始文件名_时间戳.文件后缀名
     */
    private String getFilePath(String folderName, String originalFilename, String suffix) {
        return StrPool.SLASH + String.join(StrPool.SLASH, folderName, DateUtil.date().toString(DATE_FORMAT),
                originalFilename) + StrPool.C_UNDERLINE + DateUtil.current() + StrPool.DOT + suffix;
    }

    /**
     * 获取域名
     *
     * @param bucketName 存储桶名称
     * @return String
     */
    public String getOssHost(String bucketName) {
        return ossProperties.getEndpoint() + StrPool.SLASH + getBucketName(bucketName);
    }

}

4.swagger功能的验证

package com.java.javamethod.controller;

import com.java.javamethod.domain.OssFile;
import com.java.javamethod.util.MinioTemplate;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;


import javax.annotation.Resource;

/**
 * @Author ww
 * @Date 2024/5/21 10:23
 * @Version 1.0
 */
@RestController
@Api(tags = "文件控制器", description = "文件管理控制器")
public class FileController {
    @Resource
    MinioTemplate minioTemplate;

    @PostMapping("/upload")
    @ApiImplicitParams(value = {
            @ApiImplicitParam(name = "folderName", value = "文件路径", required = true, dataType = "String"),
            @ApiImplicitParam(name = "fileName", value = "文件名", required = true, dataType = "String")
    })   // 注意seagger上传文件时候一定要加@RequestPart否则可能没法进行上传文件
    public OssFile upload(String folderName, String fileName,@RequestPart MultipartFile file) {
        return minioTemplate.upLoadFile( folderName, fileName, file);
    }

}

在这里插入图片描述

在这里插入图片描述

QD_IT伟
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
分布式文件存储系统Minio实战
weixin_45625174的博客
10-02 2239
MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。MinIO是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL。官网地址中文官网地址。
Linux Minio 集群搭建（全网超详细篇）
Mi_RenYu的博客
01-12 3342
继上期单体搭建后，再写一篇集群搭建版。本环境为 Rocky9.3（与Centos7 相似）
分布式对象存储minio
最新发布
JineD的博客
07-15 3323
二是恢复还原，通过对数据结合校验码，通过数学计算，还原丢失或损坏的数据，可以在保证数据可靠的前提下，降低冗余，如单机硬盘存储中的 RAID技术，纠删码（Erasure Code）技术等。MinIO 采用的就是纠删码技术。冗余法最简单直接，即对存储的数据进行副本备份，当数据出现丢失，损坏，即可使用备份内容进行恢复，而副本备份的多少，决定了数据可靠性的高低。关于纠删码，简单来说就是可以通过数学计算，把丢失的数据进行还原，它可以将n份原始数据，增加m份数据，并能通过n+m份中的任意n份数据，还原为原始数据。
springboot项目中使用minio进行对象存储
m0_67391907的博客
08-02 848
这就意味着MinIO的客户能够自动的、无限制、自由免费使用和集成MinIO、自由的创新和创造、自由的去修改、自由的再次发行新的版本和软件.确实,MinIO强有力的支持和驱动了很多世界500强的企业。minio利用了web缩放器的来之不易的知识，为对象存储带来了简单的存储缩放模型，在MinIO,扩展从单个群集开始，该群集可以与其他MinIO群集联合以创建全局名称空间,并在需要时可以跨越多个不同的数据中心。返回的url就是文件上传后的url，访问url就能看到上传的图片。...
Docker-minio部署
梦想的边缘
11-14 1466
（1）Minio 外部挂载的配置文件(/mydata/minio/config)（2）存储上传文件的目录(/mydata/minio/data)访问地址：http://[部署服务器ip]:9090/login。默认账号密码为 admin / admin123456。用户名 ：密码 admin：admin123。创建文件目录，用来存放配置和上传文件目录。至此部署流程已全部完成，over！
Windows安装Minio(超详细)
热门推荐
小徐的博客
12-30 1万+
​ Minio是一个开源的、云原生的分布式对象存储系统，是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据。 ​
Spring Boot配置MinIO（实现文件上传、读取、下载、删除）
swj81192的博客
04-23 1528
Spring Boot配置MinIO（实现文件上传、读取、下载、删除）
SpringBoot-集成Minio
孟孟的博客
10-24 8035
Minio 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。Minio是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL。
SpringBoot配置MinIO（实现文件上传、读取、下载、删除）
weixin_44030143的博客
07-06 854
例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。由于MinIO是一个单独的服务器，需要单独部署，有关MinIO在Windows系统上的使用请查看以下博客。是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL。minio涉及到的方法有：判断存储桶是否存在，创建存储桶，上传文件，读取文件、下载文件，删除文件等操作。来源：blog.csdn.net/Angel_asp/article/*
SpringBoot 搭建基于 minio 的高性能存储服务
Java笔记虾
02-11 423
点击关注公众号，利用碎片时间学习什么是minio引用官网：MinIO是根据GNU Affero通用公共许可证v3.0发布的高性能对象存储。它与Amazon S3云存储服务兼容。使用MinI...
SpringBoot项目集成MinIO
qq_66452396的博客
07-12 1940
最近在学习MinIO，所以想让自己的SpringBoot项目集成MinIO,在网上查阅资料，并进行操作的过程中遇到一些问题，所以想把自己遇到的坑和完成步骤记录下来供自己和各位查阅。
Minio对象存储及Springboot整合Minio分片上传文章-代码
02-23
Minio是一款开源的对象存储服务，它致力于为开发者提供简单、高性能、高可用的云存储解决方案。Minio的设计灵感来源于Amazon S3，适用于存储大量的非结构化数据，如图片、视频、文档等。在本文中，我们将深入探讨...
SpringBoot整合minio
03-31
本文将详细介绍如何在SpringBoot项目中整合MinIO，帮助开发者实现高效、安全的文件存储功能。 **一、MinIO简介** MinIO是一款高性能、开源的对象存储系统，设计目标是提供简单、快速、安全的数据访问接口。它的...
springboot集成minio完成自己的分布式文件系统
02-28
SpringBoot是Spring框架的一个简化版，它旨在简化Spring应用的初始搭建以及开发过程。通过预设的配置，SpringBoot能够快速启动一个具备完整功能的应用。在SpringBoot项目中集成其他技术，如MinIO，通常只需要添加...
minio 安装步骤以及springboot 如何集成minio
08-07
下面我们将详细探讨MinIO的安装过程以及如何在SpringBoot应用中进行集成。 ### MinIO的安装步骤 1. **下载MinIO**: 首先，你需要从MinIO的官方网站下载适合你操作系统的MinIO服务器二进制文件。这通常是一个名为`...
【微服务】springboot整合minio详解
congge_study的博客
12-18 1万+
springboot整合MinIO使用详解
minio使用
lz13419607299的博客
07-15 1万+
minio文件服务器
SpringBoot整合Minio的详细步骤
qq_43108153的博客
03-10 3978
SpringBoot整合Minio详细步骤
spring boot 中使用minio
太子的博客
08-23 5594
spring boot 中使用minio
springboot整合minio配置
10-09
在 Spring Boot 中整合 Minio，需要加入以下 Maven 依赖： ```xml <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <version>8.0.6</version> </dependency> ``` 然后在 application.yml 中进行配置： ```yaml minio: url: http://localhost:9000 access-key: minioadmin secret-key: minioadmin ``` 最后在需要使用 Minio 的地方注入 `MinioClient` 即可： ```java @Autowired private MinioClient minioClient; ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

QD_IT伟

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

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

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

打赏作者

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

抵扣说明：

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

余额充值