AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

springboot集成MinIO

2024-06-25 68
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： springboot集成MinIO

安装参考

https://blog.csdn.net/qq_29752857/article/details/130337394

一、依赖

    <!--minio-->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.5.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.squareup.okhttp3/okhttp -->
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>4.10.0</version>
        </dependency>
        <!-- lombok需要安装插件 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

二、配置文件

spring:
  # 配置文件上传大小限制
  servlet:
    multipart:
      max-file-size: 200MB
      max-request-size: 200MB
minio:
  endpoint: http://127.0.0.1:9000
  accessKey: root
  secretKey: rootroot
  bucketName: project1
import io.minio.MinioClient;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
 
@Data
@Component
public class MinIoClientConfig {
    @Value("${minio.endpoint}")
    private String endpoint;
    @Value("${minio.accessKey}")
    private String accessKey;
    @Value("${minio.secretKey}")
    private String secretKey;
 
    /**
     * 注入minio 客户端
     *
     * @return
     */
    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder()
                .endpoint(endpoint)
                .credentials(accessKey, secretKey)
                .build();
    }
}

三、操作工具类

  
import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import io.minio.messages.Item;
import lombok.SneakyThrows;
import org.apache.commons.compress.utils.IOUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
 
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.*;
import java.util.stream.Collectors;
 
/**
 * @description： minio工具类
 * @version：3.0
 */
@Component
public class MinioUtil {
    @Autowired
    private MinioClient minioClient;
 
    @Value("${minio.bucketName}")
    private String bucketName;
 
    /**
     * description: 判断bucket是否存在，不存在则创建
     *
     * @return: void
     */
    public void existBucket(String name) {
        try {
            boolean exists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(name).build());
            if (!exists) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(name).build());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 创建存储bucket
     *
     * @param bucketName 存储bucket名称
     * @return Boolean
     */
    public Boolean makeBucket(String bucketName) {
        try {
            minioClient.makeBucket(MakeBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
 
    /**
     * 删除存储bucket
     *
     * @param bucketName 存储bucket名称
     * @return Boolean
     */
    public Boolean removeBucket(String bucketName) {
        try {
            minioClient.removeBucket(RemoveBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
 
    /**
     * description: 上传文件     *
     * @param multipartFile
     * @return: java.lang.String
     */
    public List<String> upload(MultipartFile[] multipartFile) {
        return upload(multipartFile, bucketName,"");
    }
    /**
     * description: 上传文件     *
     * @param multipartFile
     * @return: java.lang.String
     */
    public List<String> upload(MultipartFile[] multipartFile,String filePath) {
        return upload(multipartFile, bucketName,filePath);
    }
    /**
     * description: 上传文件
     *
     * @param multipartFile
     * @return: java.lang.String
     */
    public List<String> upload(MultipartFile[] multipartFile, String bucketName,String filePath) {
        List<String> names = new ArrayList<>(multipartFile.length);
        for (MultipartFile file : multipartFile) {
            String fileName = file.getOriginalFilename();
            String[] split = fileName.split("\\.");
            if (split.length > 1) {
                StringBuilder filenameTem = new StringBuilder();
                for (int i = 0; i < split.length; i++) {
                    if (i != split.length - 1) {
                        filenameTem.append(split[i]);
                    } else {
                        filenameTem.append("_" + System.currentTimeMillis() + "." + split[split.length - 1]);
                    }
                }
                fileName = filenameTem.toString();
            } else {
                fileName = fileName + System.currentTimeMillis();
            }
            InputStream in = null;
            try {
                in = file.getInputStream();
                minioClient.putObject(PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(filePath+fileName)
                        .stream(in, in.available(), -1)
                        .contentType(file.getContentType())
                        .build()
                );
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            names.add(fileName);
        }
        return names;
    }
 
    /**
     * description: 下载文件
     *
     * @param fileName
     * @return: org.springframework.http.ResponseEntity<byte [ ]>
     */
    public ResponseEntity<byte[]> download(String fileName) {
        ResponseEntity<byte[]> responseEntity = null;
        InputStream in = null;
        ByteArrayOutputStream out = null;
        try {
            in = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileName).build());
            out = new ByteArrayOutputStream();
            IOUtils.copy(in, out);
            //封装返回值
            byte[] bytes = out.toByteArray();
            HttpHeaders headers = new HttpHeaders();
            try {
                headers.add("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            headers.setContentLength(bytes.length);
            headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
            headers.setAccessControlExposeHeaders(Arrays.asList("*"));
            responseEntity = new ResponseEntity<byte[]>(bytes, headers, HttpStatus.OK);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (out != null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return responseEntity;
    }
 
    /**
     * 查看文件对象
     *
     * @param bucketName 存储bucket名称
     * @return 存储bucket内文件对象信息
     */
    public List<HashMap<String,Object>> listObjects(String bucketName) {
        Iterable<Result<Item>> results = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).build());
        List<HashMap<String,Object>> objectItems = new ArrayList<>();
        try {
            for (Result<Item> result : results) {
                Item item = result.get();
                HashMap<String,Object> objectItem = new HashMap<>();
                objectItem.put("name",item.objectName());
                objectItem.put("size",item.size());
                objectItems.add(objectItem);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return objectItems;
    }
 
    /**
     * 批量删除文件对象
     *
     * @param bucketName 存储bucket名称
     * @param objects    对象名称集合
     */
    public Iterable<Result<DeleteError>> removeObjects(String bucketName, List<String> objects) {
        List<DeleteObject> dos = objects.stream().map(e -> new DeleteObject(e)).collect(Collectors.toList());
        Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(dos).build());
        return results;
    }
 
    /**
     * 判断桶是否存在
     */
    @SneakyThrows(Exception.class)
    public boolean bucketExists(String bucketName) {
        return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
    }
 
 
    /**
     * 创建桶
     *
     * @param bucketName 获取全部的桶  minioClient.listBuckets();
     */
    @SneakyThrows(Exception.class)
    public void createBucket(String bucketName) {
        if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        }
    }
 
 
    /**
     * 根据bucketName获取信息
     *
     * @param bucketName bucket名称
     */
    @SneakyThrows(Exception.class)
    public Optional<Bucket> getBucket(String bucketName) {
        return minioClient.listBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
    }
 
 
    /**
     * 获取文件流
     *
     * @param bucketName bucket名称
     * @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 fileName   本地文件路径
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse putObject(String bucketName, String objectName, String fileName) {
        if (!bucketExists(bucketName)) {
            createBucket(bucketName);
        }
        return minioClient.uploadObject(UploadObjectArgs.builder().bucket(bucketName).object(objectName).filename(fileName).build());
    }
 
    /**
     * 通过流上传文件
     *
     * @param bucketName  存储桶
     * @param objectName  文件对象
     * @param inputStream 文件流
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse putObject(String bucketName, String objectName, InputStream inputStream) {
        if (!bucketExists(bucketName)) {
            createBucket(bucketName);
        }
        return minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(inputStream, inputStream.available(), -1).build());
    }
    /**
     * 获取文件外链
     * @param objectName 文件名称
     * @return url
     */
    @SneakyThrows(Exception.class)
    public String getUploadObjectUrl(String objectName) {
        return getUploadObjectUrl(objectName,60*60);
    }
 
    /**
     * 获取文件外链
     * @param objectName 文件名称
     * @param expires    过期时间
     * @return url
     */
    @SneakyThrows(Exception.class)
    public String getUploadObjectUrl(String objectName, Integer expires) {
        return getUploadObjectUrl(bucketName,objectName,expires);
    }
    /**
     * 获取文件外链
     *
     * @param bucketName bucket名称
     * @param objectName 文件名称
     * @param expires    过期时间
     * @return url
     */
    @SneakyThrows(Exception.class)
    public String getUploadObjectUrl(String bucketName, String objectName, Integer expires) {
        return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                .method(Method.PUT).bucket(bucketName)
                .object(objectName).expiry(expires).build());
    }
 
    /**
     * 下载文件
     * bucketName:桶名
     *
     * @param fileName: 文件名
     */
    @SneakyThrows(Exception.class)
    public void download(String bucketName, String fileName, HttpServletResponse response) {
        // 获取对象的元数据
        StatObjectResponse stat = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(fileName).build());
        response.setContentType(stat.contentType());
        response.setCharacterEncoding("UTF-8");
        response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
        InputStream is = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileName).build());
        IOUtils.copy(is, response.getOutputStream());
        is.close();
    }
}

四、测试代码

@RestController
@Slf4j
public class MinioController {
 
    @Autowired
    private MinioUtil minioUtil;
    @Value("${minio.endpoint}")
    private String address;
    @Value("${minio.bucketName}")
    private String bucketName;
 
    @PostMapping("/upload")
    public String upload(MultipartFile file,String filePath) {
        List<String> upload = minioUtil.upload(new MultipartFile[]{file},filePath);
        return address + "/" + bucketName + "/" +filePath+ upload.get(0);
    }
 
    @PostMapping("/uploadList")
    public List<String> uploadList(MultipartFile[] file) {
        List<String> upload = minioUtil.upload(file);
        upload = upload.stream().map(it -> address + "/" + bucketName + "/" + it).collect(Collectors.toList());
 
        return upload;
    }
 
    @GetMapping("/getUrl")
    public String get(String objectName) {
        return minioUtil.getUploadObjectUrl(objectName);
 
    }
    @GetMapping("/down")
    public ResponseEntity<byte[]> down(String objectName) {
        return minioUtil.download(objectName);
    }
 
 
}

文章标签：
Java
关键词：
Spring Boot MinIO
集成minio
Spring Boot集成minio
集成springboot
好奇的菜鸟
目录
相关文章
智物科技库
|
3月前
|
XML Java API
SpringBoot 整合 Minio
本文介绍了如何在服务器上安装并配置Minio服务，包括Minio的依赖、配置类以及基本操作。首先，通过Maven添加Minio依赖；接着，在`yml`文件中配置Minio的连接信息；然后，创建`MinIoClientConfig`类将MinioClient注入到Spring容器中；最后，定义`OSSFileService`接口及其实现类`OssFileServiceImpl`，实现文件上传、获取文件URL、临时访问URL和删除文件等操作。
智物科技库
97 2
游客zi3qmblbcdexu
|
3月前
|
Java Maven Docker
gitlab-ci 集成 k3s 部署spring boot 应用
gitlab-ci 集成 k3s 部署spring boot 应用
游客zi3qmblbcdexu
72 1
大数据文摘
|
1月前
|
XML Java API
Spring Boot集成MinIO
本文介绍了如何在Spring Boot项目中集成MinIO，一个高性能的分布式对象存储服务。主要步骤包括：引入MinIO依赖、配置MinIO属性、创建MinIO配置类和服务类、使用服务类实现文件上传和下载功能，以及运行应用进行测试。通过这些步骤，可以轻松地在项目中使用MinIO的对象存储功能。
大数据文摘
61 5
一位隐者
|
2月前
|
消息中间件 Java Kafka
什么是Apache Kafka？如何将其与Spring Boot集成？
什么是Apache Kafka？如何将其与Spring Boot集成？
一位隐者
73 5
wljslmz
|
2月前
|
消息中间件 Java Kafka
Spring Boot 与 Apache Kafka 集成详解：构建高效消息驱动应用
Spring Boot 与 Apache Kafka 集成详解：构建高效消息驱动应用
wljslmz
57 1
运营研究坊
|
3月前
|
XML Java Kotlin
springboot + minio + kkfile实现文件预览
本文介绍了如何在容器中安装和启动kkfileviewer，并通过Spring Boot集成MinIO实现文件上传与预览功能。首先，通过下载kkfileviewer源码并构建Docker镜像来部署文件预览服务。接着，在Spring Boot项目中添加MinIO依赖，配置MinIO客户端，并实现文件上传与获取预览链接的接口。最后，通过测试验证文件上传和预览功能的正确性。
运营研究坊
153 4
springboot + minio + kkfile实现文件预览
潇洒洒
|
2月前
|
存储 前端开发 JavaScript
SpringBoot结合Minio实现文件切片极速上传
【10月更文挑战第21天】
潇洒洒
146 6
潇洒洒
|
2月前
|
XML Java 数据库连接
SpringBoot集成Flowable：打造强大的工作流管理系统
在企业级应用开发中，工作流管理是一个核心组件，它能够帮助我们定义、执行和管理业务流程。Flowable是一个开源的工作流和业务流程管理（BPM）平台，它提供了强大的工作流引擎和建模工具。结合SpringBoot，我们可以快速构建一个高效、灵活的工作流管理系统。本文将探讨如何将Flowable集成到SpringBoot应用中，并展示其强大的功能。
潇洒洒
355 1
最好zzz
|
2月前
|
存储 Java API
SpringBoot结合Minio实现文件切片上传：提升上传效率的秘诀
【10月更文挑战第29天】
最好zzz
232 3
nanshaws
|
3月前
|
存储 前端开发 Java
springboot整合最新版minio和minio的安装（完整教程，新人必看）
本文详细介绍了如何使用Docker安装配置最新版的MinIO，并展示了如何在Spring Boot应用中整合MinIO以及如何通过前端进行文件上传测试。
nanshaws
357 3
springboot整合最新版minio和minio的安装（完整教程，新人必看）

热门文章

最新文章

  • 1
    详解Spring Batch：在Spring Boot中实现高效批处理
  • 2
    Springboot通过SSE实现实时消息返回
  • 3
    使用 Spring Boot 执行数据库操作：全面指南
  • 4
    什么是JWT？如何使用Spring Boot Security实现它？
  • 5
    深入探索Spring Cloud与Spring Boot：构建微服务架构的实践经验
  • 6
    基于 SpringBoot 和 Vue 开发校园点餐订餐外卖跑腿Java源码
  • 7
    使用Spring Boot编写测试用例：实践与最佳实践
  • 8
    详解FreeMarker Template：在Spring Boot中实现动态内容生成
  • 9
    使用Qwen2.5+SpringBoot+SpringAI+SpringWebFlux的基于意图识别的多智能体架构方案
  • 10
    springboot java.lang.ClassNotFoundException: dm.jdbc.driver.DmDriver应该如何解决
  • 1
    MongoDB Atlas Vector Search与Amazon Bedrock集成已全面可用
    2647
  • 2
    Playwright安装与Python集成：探索跨浏览器测试的奇妙世界
    160
  • 3
    【MongoDB 专栏】MongoDB 与 Spring Boot 的集成实践
    265
  • 4
    LabVIEW风力涡轮机的雷电流测量系统中集成高速摄像机
    55
  • 5
    FFmpeg开发笔记（十七）Windows环境给FFmpeg集成字幕库libass
    174
  • 6
    sprinboot+vue集成neo4j图数据库
    187
  • 7
    RabbitMQ的springboot项目集成使用-01
    150
  • 8
    springboot集成ElasticSearch的具体操作（系统全文检索）
    99
  • 9
    基于RuoYi-Flowable-Plus的若依ruoyi-nbcio支持自定义业务表单流程的集成方法与步骤（二）
    390
  • 10
    基于RuoYi-Flowable-Plus的若依ruoyi-nbcio支持自定义业务表单流程的集成方法与步骤（一）
    339

    • 相关课程

    更多
  • 消息队列 RocketMQ 消息集成
  • 微服务+全栈在线教育实战项目演练（SpringCloud Alibaba+SpringBoot）
  • SpringBoot实战教程
  • SpringBoot快速掌握 - 核心技术
  • SpringBoot快速掌握 - 高级应用
  • Springboot项目云开发快速迁移

    • 相关电子书

    更多
  • 阿里邮箱—安全高效集成
  • 集成智能接入网关APP：优化企业级移动办公网络
  • 云效助力企业集成安全到DevOps中

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月