spring boot集成minio，最新版

最新推荐文章于 2024-06-30 18:53:16 发布
最新推荐文章于 2024-06-30 18:53:16 发布
阅读量878 收藏 5
点赞数 1
文章标签： spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/songshijunssss/article/details/111165578
版权

demo地址：https://github.com/songshijun1995/minio-demo

  1. 使用docker安装minio
docker run -d -p 9000:9000 -e "MINIO_ACCESS_KEY=admin" -e "MINIO_SECRET_KEY=12345678" minio/minio server /data

启动成功后浏览器访问ip:9000
image.png

如果配置nginx代理了ip和端口号可以直接访问域名加/minio
image.png

进入后点击右下角的+，创建一个桶
image.png
然后修改桶的权限为读写（点击三个点，然后选择Edit policy）
image.png
image.png
没安装过docker的可以看我以前的文章，详见

  1. 直接用spring boot官方脚手架创建项目，引入依赖
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.0.3</version>
</dependency>

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.4</version>
</dependency>
  1. 配置yml
server:
  port: 8080
  servlet:
    context-path: /

spring:
  application:
    name: minio-demo

minio:
  endpoint: http://129.28.158.207:9000
  accessKey: admin
  secretKey: 123456
  filHost: http://file.songshijun.top

logging:
  level:
    ROOT: info
    com.minio: debug
  pattern:
    file: '%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{50} - %msg%n'
  file:
    name: ${logging.file.path}/${spring.application.name}.log
    path: /home/logs/${spring.application.name}
    max-size: 10MB
    max-history: 30

4.新建MinioProp类和MinioConfig类，分别加载minio账号密码以及初始MinioClient

package com.minio.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Data
@Component
@ConfigurationProperties(prefix = "minio")
public class MinioProp {
    /**
     * 连接地址
     */
    private String endpoint;
    /**
     * 用户名
     */
    private String accessKey;
    /**
     * 密码
     */
    private String secretKey;
    /**
     * 域名
     */
    private String filHost;
}

package com.minio.config;

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(MinioProp.class)
public class MinioConfig {

    @Autowired
    private MinioProp minioProp;

    /**
     * 获取MinioClient
     */
    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder()
                        .endpoint(minioProp.getEndpoint())
                        .credentials(minioProp.getAccessKey(), minioProp.getSecretKey())
                        .build();
    }

}

package com.minio.dto.response;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class FileUploadResponse {
    private String urlHttp;

    private String urlPath;
}

5.新建工具类MinioUtil，用来封装上传和删除文件等方法

package com.minio.utils;

import com.minio.config.MinioProp;
import com.minio.dto.response.FileUploadResponse;
import io.minio.*;
import io.minio.errors.*;
import io.minio.messages.Bucket;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.Random;

@Slf4j
@Component
public class MinioUtil {

    @Autowired
    private MinioProp minioProp;

    @Autowired
    private MinioClient client;

    /**
     * 创建bucket
     */
    public void createBucket(String bucketName) throws Exception {
        if (!client.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
            client.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        }
    }

    /**
     * 上传文件
     */
    public FileUploadResponse uploadFile(MultipartFile file, String bucketName) throws Exception {
        //判断文件是否为空
        if (null == file || 0 == file.getSize()) {
            return null;
        }
        //判断存储桶是否存在  不存在则创建
        createBucket(bucketName);
        //文件名
        String originalFilename = file.getOriginalFilename();
        //新的文件名 = 存储桶文件名_时间戳.后缀名
        assert originalFilename != null;
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String fileName = bucketName + "_" +
                System.currentTimeMillis() + "_" + format.format(new Date()) + "_" + new Random().nextInt(1000) +
                originalFilename.substring(originalFilename.lastIndexOf("."));
        //开始上传
        client.putObject(
                PutObjectArgs.builder().bucket(bucketName).object(fileName).stream(
                        file.getInputStream(), file.getSize(), -1)
                        .contentType(file.getContentType())
                        .build());
        String url = minioProp.getEndpoint() + "/" + bucketName + "/" + fileName;
        String urlHost = minioProp.getFilHost() + "/" + bucketName + "/" + fileName;
        log.info("上传文件成功url ：[{}], urlHost ：[{}]", url, urlHost);
        return new FileUploadResponse(url, urlHost);
    }

    /**
     * 获取全部bucket
     *
     * @return
     */
    public List<Bucket> getAllBuckets() throws Exception {
        return client.listBuckets();
    }

    /**
     * 根据bucketName获取信息
     *
     * @param bucketName bucket名称
     */
    public Optional<Bucket> getBucket(String bucketName) throws IOException, InvalidKeyException, NoSuchAlgorithmException, InsufficientDataException, InvalidResponseException, InternalException, ErrorResponseException, ServerException, XmlParserException {
        return client.listBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
    }

    /**
     * 根据bucketName删除信息
     *
     * @param bucketName bucket名称
     */
    public void removeBucket(String bucketName) throws Exception {
        client.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /**
     * 获取⽂件外链
     *
     * @param bucketName bucket名称
     * @param objectName ⽂件名称
     * @param expires    过期时间 <=7
     * @return url
     */
    public String getObjectURL(String bucketName, String objectName, Integer expires) throws Exception {
        return client.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().bucket(bucketName).object(objectName).expiry(expires).build());
    }

    /**
     * 获取⽂件
     *
     * @param bucketName bucket名称
     * @param objectName ⽂件名称
     * @return ⼆进制流
     */
    public InputStream getObject(String bucketName, String objectName) throws Exception {
        return client.getObject(GetObjectArgs.builder().bucket(bucketName).object(objectName).build());
    }

    /**
     * 上传⽂件
     *
     * @param bucketName bucket名称
     * @param objectName ⽂件名称
     * @param stream     ⽂件流
     * @throws Exception https://docs.minio.io/cn/java-client-api-reference.html#putObject
     */
    public void putObject(String bucketName, String objectName, InputStream stream) throws
            Exception {
        client.putObject(PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(stream, stream.available(), -1).contentType(objectName.substring(objectName.lastIndexOf("."))).build());
    }

    /**
     * 上传⽂件
     *
     * @param bucketName  bucket名称
     * @param objectName  ⽂件名称
     * @param stream      ⽂件流
     * @param size        ⼤⼩
     * @param contextType 类型
     * @throws Exception https://docs.minio.io/cn/java-client-api-reference.html#putObject
     */
    public void putObject(String bucketName, String objectName, InputStream stream, long
            size, String contextType) throws Exception {
        client.putObject(PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(stream, size, -1).contentType(contextType).build());
    }

    /**
     * 获取⽂件信息
     *
     * @param bucketName bucket名称
     * @param objectName ⽂件名称
     * @throws Exception https://docs.minio.io/cn/java-client-api-reference.html#statObject
     */
    public StatObjectResponse getObjectInfo(String bucketName, String objectName) throws Exception {
        return client.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
    }

    /**
     * 删除⽂件
     *
     * @param bucketName bucket名称
     * @param objectName ⽂件名称
     * @throws Exception https://docs.minio.io/cn/java-client-apireference.html#removeObject
     */
    public void removeObject(String bucketName, String objectName) throws Exception {
        client.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
    }
}

6.新建MinioController

package com.minio.controller;

import com.minio.dto.response.FileUploadResponse;
import com.minio.utils.MinioUtil;
import io.minio.errors.MinioException;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.util.Arrays;

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

    @Autowired
    private MinioUtil minioUtil;

    /**
     * 上传文件
     */
    @PostMapping("/upload")
    public FileUploadResponse upload(@RequestParam(name = "file", required = false) MultipartFile file, @RequestParam(required = false) String bucketName) {
        FileUploadResponse response = null;
        if (StringUtils.isBlank(bucketName)) {
            bucketName = "salt";
        }
        try {
            response = minioUtil.uploadFile(file, bucketName);
        } catch (Exception e) {
            log.error("上传失败 : [{}]", Arrays.asList(e.getStackTrace()));
        }
        return response;
    }

    /**
     * 删除文件
     */
    @DeleteMapping("/delete/{objectName}")
    public void delete(@PathVariable("objectName") String objectName, @RequestParam(required = false) String bucketName) throws Exception {
        if (StringUtils.isBlank(bucketName)) {
            bucketName = "salt";
        }
        minioUtil.removeObject(bucketName, objectName);
        System.out.println("删除成功");
    }

    /**
     * 下载文件到本地
     */
    @GetMapping("/download/{objectName}")
    public ResponseEntity<byte[]> downloadToLocal(@PathVariable("objectName") String objectName, HttpServletResponse response) throws Exception {
        ResponseEntity<byte[]> responseEntity = null;
        InputStream stream = null;
        ByteArrayOutputStream output = null;
        try {
            // 获取"myobject"的输入流。
            stream = minioUtil.getObject("salt", objectName);
            if (stream == null) {
                System.out.println("文件不存在");
            }
            //用于转换byte
            output = new ByteArrayOutputStream();
            byte[] buffer = new byte[4096];
            int n = 0;
            while (-1 != (n = stream.read(buffer))) {
                output.write(buffer, 0, n);
            }
            byte[] bytes = output.toByteArray();

            //设置header
            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.add("Accept-Ranges", "bytes");
            httpHeaders.add("Content-Length", bytes.length + "");
//            objectName = new String(objectName.getBytes("UTF-8"), "ISO8859-1");
            //把文件名按UTF-8取出并按ISO8859-1编码，保证弹出窗口中的文件名中文不乱码，中文不要太多，最多支持17个中文，因为header有150个字节限制。
            httpHeaders.add("Content-disposition", "attachment; filename=" + objectName);
            httpHeaders.add("Content-Type", "text/plain;charset=utf-8");
//            httpHeaders.add("Content-Type", "image/jpeg");
            responseEntity = new ResponseEntity<byte[]>(bytes, httpHeaders, HttpStatus.CREATED);

        } catch (MinioException e) {
            e.printStackTrace();
        } finally {
            if (stream != null) {
                stream.close();
            }
            if (output != null) {
                output.close();
            }
        }
        return responseEntity;
    }

    /**
     * 在浏览器预览图片
     */
    @GetMapping("/preViewPicture/{objectName}")
    public void preViewPicture(@PathVariable("objectName") String objectName, HttpServletResponse response) throws Exception {
        response.setContentType("image/jpeg");
        try (ServletOutputStream out = response.getOutputStream()) {
            InputStream stream = minioUtil.getObject("salt", objectName);
            ByteArrayOutputStream output = new ByteArrayOutputStream();
            byte[] buffer = new byte[4096];
            int n = 0;
            while (-1 != (n = stream.read(buffer))) {
                output.write(buffer, 0, n);
            }
            byte[] bytes = output.toByteArray();
            out.write(bytes);
            out.flush();
        }
    }
}

7.启动项目用postman测试上传文件
image.png
image.png
image.png

songshijunssss
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
02-SpringBoot集成MinIo
彼岸舞的博客
08-23 3727
添加依赖 <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> </dependency> <dependency> <groupId>commons-file...
Spring Boot整合MinIO
微赚淘客开发者博客
01-24 429
在我们深入研究整合过程之前，让我们先来了解一下MinIO。是一个高性能、分布式的对象存储服务，兼容Amazon S3 API。它可以轻松地部署在本地服务器或云上，提供强大的对象存储能力，适用于各种应用场景，包括图片存储、备份、日志存储等。通过以上简单的步骤，我们成功地将Spring Boot与MinIO整合在一起，为我们的应用程序提供了强大的对象存储能力。希望这篇文章对你在项目中使用MinIO时有所帮助。
springboot整合minio最新版
qq_43842093的博客
12-11 4273
第一步：查找minio最新依赖，通过maven查询网站查询,这搜索框输入minio， 也可以查看MinIO官网https://docs.min.io/docs/java-client-quickstart-guide.html 如下: 点击minio进入查看maven依赖，可以看到最新版为8.3.4 <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactI
springboot整合最新版minio和minio的安装（完整教程，新人必看）
m0_63251896的博客
03-14 3901
springboot整合最新版minio和minio的安装（完整教程，新人必看） ​ 概述：这种东西，多写点，方便以后自己使用 第一步：docker安装配置minio 第一步：拉取镜像 docker pull minio/minio 第二步：创建用于存储MinIO数据的卷 MinIO需要一个用于持久化存储的卷。创建一个目录，并使用docker volume create命令创建一个Docker卷： mkdir ~/minio-storage # 在用户主目录下创建一个用于存储的目录 docker v
SpringBoot整合Minio
最新发布
上善若泪
06-30 1217
文章目录1 Minio1.1 概述1.2 应用场景1.3 Minio实现分片上传的主要步骤1.4 Centos7安装Minio1.5 搭建springboot 环境1.5.1 pom.xml1.5.2 创建容器桶1.5.3 编写配置文件1.5.4 常量类1.5.5 创建Minio的配置类1.5.5 创建Minio的工具类1.5.6 创建Ajax请求工具类1.5.7 创建Minio文件操作接口层 1 Minio 1.1 概述 Minio 官网地址：https://min.io/ 文档地址：https://do
SpringBoot整合MinIO
qq_63431773的博客
10-30 467
MinIO是一个开源的对象存储服务器，它兼容Amazon S3服务接口，并具有高性能和可扩展性。MinIO支持在私有云环境中搭建自己的对象存储服务，同时也可以与公共云服务进行集成。
SpringBoot 整合 Minio
qq_45735705的博客
08-03 526
MinIO 是一个基于 Go 实现的高性能、兼容 S3 协议的对象存储。它采用 GNU AGPL v3 开源协议，项目地址是 https://github.com/minio/minio。它适合存储海量的非结构化的数据，例如说图片、音频、视频等常见文件，备份数据、容器、虚拟机镜像等等，小到 1 KB，大到 5 TB 都可以支持。
Springboot整合minio
梦M的博客
02-06 596
springboot整合minio
Spring Boot 集成 MinIO（分布式对象存储系统）
09-27
内容概要：首先带着读者安装MinIO，并帮助读者通过 Spring Boot 框架一步步完成 MinIO 集成，快速上手分布式对象存储系统。在手写MinIO 工具类的过程中会摘取整体框架中的核心逻辑，简化代码实现过程，保留核心功能...
Spring boot整合MinIO客户端实现文件管理
06-27
MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和...Spring boot整合MinIO客户端实现文件管理
java spring boot集成minio文件上传下载
05-19
资源内容为java操作minio文件上传下载，也涉及到加密操作，主要是minio的SSE-C模式，具体内容在Sprintboot01ApplicationTests.MinioTest()中。 包含以下内容： //1.测试数据上传 testUploadString(); //2.测试数据...
spring-boot-starter-minio:用于Spring Boot的Minio启动器
05-07
Spring Boot Starter Minio Spring Boot Starter，它可以连接到Minio存储桶，以保存，获取和删除对象。 入门者还为执行器嵌入了指标和运行状况检查。 快速开始 只需将依赖项添加到现有的Spring Boot项目中即可。 ...
minio 安装步骤以及springboot 如何集成minio
08-07
将MinIO集成到SpringBoot应用中，可以方便地管理和使用对象存储服务。下面我们将详细探讨MinIO的安装过程以及如何在SpringBoot应用中进行集成。 ### MinIO的安装步骤 1. **下载MinIO**: 首先，你需要从MinIO的官方...
Springboot整合MinIO
普通人一枚
04-24 1184
Springboot整合MinIO
springboot整合minio及工具类
点点的博客
03-02 1018
简单工具整合 springboot+minio
SpringBoot整合minio服务（超详细）
热门推荐
yueyue763184的博客
06-10 1万+
创建一个名为public的存储桶（名字可自定义），上传文件。在application.yml文件中编写相关配置。http://ip:9000/存储桶名/文件名。开发中上传接口用得较多，其他接口可自行测试。可以将存储桶的访问权限设置为public.# npm下载element-ui。// 引入ElementUI。
springboot整合minio（实现文件的上传和下载超详细入门）
2301_78646673的博客
11-05 9007
目前可用于文件存储的网络服务选择也有不少，比如阿里云OSS、七牛云、腾讯云等等，可是收费都有点小贵。为了省钱，很多公司使用MinIO做为文件服务器。官网：https://www.minio.org.cn/MinIO是一个开源的分布式对象存储服务器，支持S3协议并且可以在多节点上实现数据的高可用和容错。它采用Go语言开发，拥有轻量级、高性能、易部署等特点，并且可以自由选择底层存储介质。它基于Apache License 开源协议，兼容Amazon S3云存储接口。
spring boot整合minio
weixin_46424243的博客
12-10 233
minio整合springboot以及使用POI导出模板
spring boot 集成minio实现文件批量上传
04-22
可以使用Minio Java客户端来实现Spring Boot与Minio的集成，下面是一个基本的步骤： 1.引入Minio Java客户端的依赖： ``` <groupId>io.minio <artifactId>minio <version>7.0.2 ``` 2.配置Minio的连接信息：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值