springboot集成minio

已于 2024-08-19 15:11:36 修改
阅读量99 收藏
点赞数 2
文章标签： spring boot 后端 java
于 2024-08-19 11:16:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40400735/article/details/141317895
版权

pom.xml

<dependency>
    <groupId>org.jetbrains.kotlin</groupId>
    <artifactId>kotlin-stdlib</artifactId>
    <version>1.8.0</version> <!-- 确保使用与项目中一致的版本 -->
</dependency>
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.12.0</version>
</dependency>
<!-- minio文件存储服务 -->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.5.11</version>
    <exclusions>
        <exclusion>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
        </exclusion>
        <exclusion>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-stdlib</artifactId>
        </exclusion>
    </exclusions>
</dependency>

application.yml

minio:
  accessKey: minio账号
  secretKey: minio密码
  bucket: 桶名称（自定义）
  endpoint: http://ip:9000
  #readPath: http://ip:9001

MinioTemplate.java

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

/**
 * Description: MinIO属性配置类
 */
@Data
@Component
@ConfigurationProperties(prefix = "minio")  //自动注入属性前缀为minio的配置
public class MinioTemplate implements Serializable {
    private String accessKey; // 访问key
    private String secretKey; // 秘钥
    private String bucket;    // 桶
    private String endpoint;  // 地域节点
    private String readPath;  // 读取路径
}

MinioConfig.java

import io.minio.MinioClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * MinIO配置类
 */
@Configuration
public class MinioConfig {
    @Autowired
    private MinioTemplate minioTemplate;

    // 注册MinIO实例
    @Bean
    public MinioClient buildMinioClient(){
        return MinioClient
                .builder()
                .credentials(minioTemplate.getAccessKey(), minioTemplate.getSecretKey())
                .endpoint(minioTemplate.getEndpoint())
                .build();
    }
}

MinioUtil.java

import cn.hutool.core.util.StrUtil;
import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Item;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FileUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLDecoder;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

/**
 * minio文件上传工具类
 */
@Slf4j
@Component
public class MinioUtil {
    @Autowired
    private MinioClient minioClient;

    @Autowired
    private MinioTemplate minioTemplate;

    private final static String separator = "/";

    /**
     * 创建桶
     *
     * @param bucketName 桶名称
     */
    @SneakyThrows
    public void createBucket(String bucketName) {
        if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).region("cn-beijing").build());
            log.info("create a new bucket.");
        }
    }

    /**
     * 删除桶
     *
     * @param bucketName 桶名称
     */
    @SneakyThrows
    public void removeBucket(String bucketName) {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /**
     * 获取文件信息
     *
     * @param bucketName 桶名称
     * @param objectName 文件名称
     * @return
     */
    @SneakyThrows
    public StatObjectResponse getObjectInfo(String bucketName, String objectName) {
        return minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
    }

    /**
     * 上传文件
     *
     * @param bucketName 桶名称
     * @param objectName 文件名
     * @param stream     流
     * @param fileSize   文件大小
     * @param type       文件类型
     * @throws Exception
     */
    public void putObject(String bucketName, String objectName, InputStream stream, Long fileSize, String type) throws Exception {
        minioClient.putObject(
                PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(
                                stream, fileSize, -1)
                        .contentType(type)
                        .build());
    }


    /**
     * 判断文件夹是否存在
     *
     * @param bucketName 桶名称
     * @param prefix     文件夹名字
     * @return
     */
    @SneakyThrows
    public Boolean folderExists(String bucketName, String prefix) {
        Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName)
                .prefix(prefix).recursive(false).build());
        for (Result<Item> result : results) {
            Item item = result.get();
            if (item.isDir()) {
                return true;
            }
        }
        return false;
    }

    /**
     * 创建文件夹
     *
     * @param bucketName 桶名称
     * @param path       路径
     */
    @SneakyThrows
    public void createFolder(String bucketName, String path) {
        minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(path)
                .stream(new ByteArrayInputStream(new byte[]{}), 0, -1).build());
    }

    /**
     * 获取文件在minio在服务器上的外链
     *
     * @param bucketName 桶名称
     * @param objectName 文件名
     * @return
     */
    @SneakyThrows
    public String getObjectUrl(String bucketName, String objectName) {
        return minioClient.getPresignedObjectUrl(
                GetPresignedObjectUrlArgs.builder()
                        .method(Method.GET)
                        .bucket(bucketName)
                        .object(objectName)
                        .build());
    }


    public String uploadFile(HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException {
        request.setCharacterEncoding("utf-8");
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;

        String bizPath = request.getParameter("biz");
        if (StrUtil.isEmpty(bizPath)) {
            bizPath = "";
        }

        // 获取上传的文件
        Iterator<String> names = multipartRequest.getFileNames();
        List<MultipartFile> files = new ArrayList<>();
        while (names.hasNext()) {
            String name = names.next();
            files.addAll(multipartRequest.getFiles(name));
        }
        List<String> filePaths = new ArrayList<>();
        for (MultipartFile multiFile : files) {
            filePaths.add(upload(multiFile, bizPath));
        }
        String file_url = String.join(",", filePaths);

        if (StrUtil.isNotEmpty(file_url)) {
            return file_url;
        }

        return null;
    }

    /**
     * 文件上传
     *
     * @param file
     * @param bizPath
     * @return
     */
    public String upload(MultipartFile file, String bizPath) {
        return upload(file, bizPath, null);
    }

    public String upload(File file, String bizPath, String customBucket) {
        MultipartFile multipartFile = fileToMultipartFile(file);
        return upload(multipartFile, bizPath, customBucket);
    }

    /**
     * 上传文件
     *
     * @param file
     * @return
     */
    public String upload(MultipartFile file, String bizPath, String customBucket) {
        String file_url = "";
        //过滤上传文件夹名特殊字符，防止攻击
        bizPath = filter(bizPath);
        // 过滤上传文件夹名特殊字符，防止攻击
        String newBucket = minioTemplate.getBucket();
        if (StrUtil.isNotEmpty(customBucket)) {
            newBucket = customBucket;
        }
        try {
            // 检查存储桶是否已经存在
            createBucket(newBucket);

            InputStream stream = file.getInputStream();

            // 获取文件名
            String orgName = file.getOriginalFilename();
            if ("".equals(orgName)) {
                orgName = file.getName();
            }
            // 年月日+时间戳
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
            String todayStr = sdf.format(new Date());
            String objectName = bizPath + separator + todayStr + separator + System.currentTimeMillis() + orgName.substring(orgName.lastIndexOf("."));
            // 使用putObject上传一个本地文件到存储桶中。
            if (objectName.startsWith(separator)) {
                objectName = objectName.substring(1);
            }
            PutObjectArgs objectArgs = PutObjectArgs.builder().object(objectName)
                    .bucket(newBucket)
                    .contentType("application/octet-stream")
                    .stream(stream, stream.available(), -1).build();
            minioClient.putObject(objectArgs);
            stream.close();
            file_url = minioTemplate.getEndpoint() + separator + newBucket + separator + objectName;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        return file_url;
    }


    /**
     * @param file
     * @param bizPath
     * @param fileName 指定文件名不变
     * @return
     */
    public String uploadPro(MultipartFile file, String bizPath, String fileName) {
        String file_url = "";
        //过滤上传文件夹名特殊字符，防止攻击
        bizPath = filter(bizPath);
        //过滤上传文件夹名特殊字符，防止攻击
        String newBucket = minioTemplate.getBucket();
        try {
            // 检查存储桶是否已经存在
            createBucket(newBucket);

            InputStream stream = file.getInputStream();
            // 原文件名+时间戳
            String objectName = bizPath + separator + fileName;
            // 使用putObject上传一个本地文件到存储桶中。
            if (objectName.startsWith(separator)) {
                objectName = objectName.substring(1);
            }
            PutObjectArgs objectArgs = PutObjectArgs.builder().object(objectName)
                    .bucket(newBucket)
                    .contentType("application/octet-stream")
                    .stream(stream, stream.available(), -1).build();
            minioClient.putObject(objectArgs);
            stream.close();
            file_url = minioTemplate.getEndpoint() + separator + newBucket + separator + objectName;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        return file_url;
    }

    public String upload(File file, String bizPath) {
        return upload(file, bizPath, null);
    }

    /**
     * 获取文件流
     *
     * @param bucketName
     * @param objectName
     * @return
     */
    public InputStream getMinioFile(String bucketName, String objectName) {
        InputStream inputStream = null;
        try {
            GetObjectArgs objectArgs = GetObjectArgs.builder().object(objectName)
                    .bucket(bucketName).build();
            inputStream = minioClient.getObject(objectArgs);
        } catch (Exception e) {
            log.info("文件获取失败" + e.getMessage());
        }
        return inputStream;
    }


    public void delete(String pathUrl) {
        String key = pathUrl.replace(minioTemplate.getEndpoint() + separator, "");
        int index = key.indexOf(separator);
        String bucket = key.substring(0, index);
        String filePath = key.substring(index + 1);
        // 删除Objects
        removeObject(bucket, filePath);
    }

    /**
     * 删除文件
     *
     * @param bucketName
     * @param objectName
     * @throws Exception
     */
    public void removeObject(String bucketName, String objectName) {
        try {
            RemoveObjectArgs objectArgs = RemoveObjectArgs.builder().object(objectName)
                    .bucket(bucketName).build();
            minioClient.removeObject(objectArgs);
        } catch (Exception e) {
            log.info("文件删除失败" + e.getMessage());
        }
    }

    /**
     * 获取文件外链
     *
     * @param bucketName
     * @param objectName
     * @param expires
     * @return
     */
    public String getObjectURL(String bucketName, String objectName, Integer expires) {
        try {
            GetPresignedObjectUrlArgs objectArgs = GetPresignedObjectUrlArgs.builder().object(objectName)
                    .bucket(bucketName)
                    .expiry(expires).build();
            String url = minioClient.getPresignedObjectUrl(objectArgs);
            return URLDecoder.decode(url, "UTF-8");
        } catch (Exception e) {
            log.info("文件路径获取失败" + e.getMessage());
        }
        return null;
    }

    /**
     * 上传文件到minio
     *
     * @param stream
     * @param relativePath
     * @return
     */
    public String upload(InputStream stream, String relativePath) throws Exception {
        if (minioClient.bucketExists(BucketExistsArgs.builder().bucket(minioTemplate.getBucket()).build())) {
            log.info("Bucket already exists.");
        } else {
            // 创建一个名为ota的存储桶
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(minioTemplate.getBucket()).build());
            log.info("create a new bucket.");
        }
        PutObjectArgs objectArgs = PutObjectArgs.builder().object(relativePath)
                .bucket(minioTemplate.getBucket())
                .contentType("application/octet-stream")
                .stream(stream, stream.available(), -1).build();
        minioClient.putObject(objectArgs);
        stream.close();
        return minioTemplate.getEndpoint() + separator + minioTemplate.getBucket() + separator + relativePath;
    }


    @SneakyThrows
    public MultipartFile fileToMultipartFile(File file) {
        byte[] bytes = FileUtils.readFileToByteArray(file);
        MultipartFile multipartFile = new MockMultipartFile(
                "file",
                file.getName(),
                "text/plain",
                bytes
        );
        return multipartFile;
    }

    public String filter(String str) throws PatternSyntaxException {
        // 清除掉所有特殊字符
        String regEx = "[`_《》~!@#$%^&*()+=|{}':;',\\[\\].<>?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？]";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(str);
        return m.replaceAll("").trim();
    }
}

CommonController .java

import com.linus.core.model.ApiResponse;
import com.linus.core.utils.FileUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Description: 文件上传
 * Author: lz
 * Date: 2024/8/14
 */
@Api(tags = "文件上传")
@RestController
@RequestMapping("/sys/common")
public class CommonController {
    @Autowired
    private FileUtil fileUtil;

    /**
     * 文件上传统一方法
     *
     * @param request
     * @param response
     * @return
     */
    @PostMapping(value = "/uploadFile")
    @ApiOperation(value = "文件上传统一方法", notes = "文件上传统一方法")
    public ApiResponse uploadFile(HttpServletRequest request, HttpServletResponse response) {
        try {
            String filePath = fileUtil.uploadFile(request, response);
            return ApiResponse.success(filePath);
        } catch (Exception ex) {
            return ApiResponse.failed("上传失败");
        }
    }

    /**
     * 文件删除
     *
     * @param pathUrl
     * @return
     */
    @PostMapping(value = "/deleteFile")
    @ApiOperation(value = "文件删除方法", notes = "文件删除方法")
    public ApiResponse deleteFile(@RequestParam String pathUrl) {
        try {
            fileUtil.deleteFile(pathUrl);
            return ApiResponse.success("删除成功！");
        } catch (Exception ex) {
            return ApiResponse.failed("删除失败！");
        }
    }
}
qq_40400735
关注
SpringBoot集成MinIO快速入门Demo
04-05
**SpringBoot集成MinIO快速入门** 在现代的Web开发中，数据存储是一个不可或缺的部分，而文件存储服务在很多场景下都是必要的。MinIO是一个高性能的对象存储服务器，它提供了与Amazon S3兼容的API，便于存储和检索...
springboot集成Minio
AYANBAO的博客
04-08 629
-address :9002 --console-address :9001 是配置端口，默认minio端口是9000，如果9000端口被占用了，那就加上这一串配置，端口号的冒号之前不需要特意写出ip，当然如果你的ip的动态变化的，而不是静态的话，前边的ip不用写上。而现在比较新的版本的minio，需要替换成MINIO_ROOT_USER和MINIO_ROOT_PASSWORD。MINIO_ACCESS_KEY 和MINIO_SECRET_KEY。在当前minio目录下，会出现一个minio目录。
Springboot集成Minio
HoJe的博客
03-11 522
本文主要是讲解SpringBoot如何集成Minio的Java SDK。有不懂的同学可以私信我，评论，看到了会一一答复的。我们下期再见。
springboot集成MinIO
一起coding，一起嗨。
04-24 1055
安装参考。
SpringBoot集成MinIO8.0
weixin_39311781的博客
09-26 397
基于SpringBoot2.7集成MinIO8.0
springboot集成minio客户端
技术控的笔记
04-18 4108
springboot集成minio客户端 文章目录springboot集成minio客户端1 配置文件桶权限2 引入minio客户端依赖3 配置文件修改4 定义minio配置类5 封装MinioClient6 HTTP接口实例7 总结 由于项目技术栈需要使用springboot框架，以下详细介绍spring boot如何集成minio客户端过程，使用intellij idea集成开发环境，maven进行项目管理。minio基础知识介绍及简单部署使用，可看下我的两外两篇文章： minio基础知识介绍 mini
SpringBoot 集成MinIO
热门推荐
赵先森
07-28 1万+
SpringBoot 集成MinIO 引入jar包 <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <version>7.0.2</version> </dependency> 配置 minio: endpoint: 172.28.43.29 port: 9000
springboot 集成minio
jiang51231的博客
01-21 746
springboot 集成minio
Springboot集成minio
weixin_48878207的博客
04-13 3984
下载客户端 https://dl.min.io/server/minio/release/windows-amd64/ 在exe所在文件夹新建bucket目录 新建桶，开启读写权限 Springboot集成（文末有完整版依赖） 引入依赖 <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3<
SpringBoot集成MinIO
路在何方
06-29 2792
对象存储服务OSS（Object Storage Service）是一种海量、安全、低成本、高可靠的云存储服务，适合存放任意类型的文件。容量和处理能力弹性扩展，多种存储类型供选择，全面优化存储成本。今天我这里主要讲解SpringBoot如何集成MinIO。
springboot集成minio实现了分片上传功能源码+项目说明.zip
12-20
springboot集成minio实现了分片上传功能源码+项目说明.zip vue版本的：前端 后端 快速开始 后端 修改配置文件application.yml: minio: endpoint: accessKey: secretKey: bucketName: downloadUri: #配置...
springboot集成minio完成自己的分布式文件系统
02-28
SpringBoot集成MinIO是构建分布式文件系统的常见方法，尤其对于Java开发者来说，这是一个高效且经济的解决方案。MinIO是一款开源的对象存储服务器，它兼容Amazon S3 API，可以提供高性能、高可用性和安全性。通过将...
springboot集成minio实现的文件服务组件(含Vue前端源码).zip
06-24
1. **SpringBoot集成MinIO** - **配置**: 首先，我们需要在SpringBoot的`application.properties`或`application.yml`文件中添加MinIO的相关配置，如访问地址、端口、用户名、密码等。 - **依赖**: 在项目中引入...
SpringBoot集成minio实现文件的上传，下载，获取列表，增加桶等的基本操作
06-27
SpringBoot集成minio实现文件的上传，下载，获取列表，增加桶等的基本操作 该项目是个人大作业项目源码，项目中的源码都是经过本地编译过可运行的，都经过严格调试，确保可以运行！！！评审分达到95分以上。资源项目...
Spring Boot-自动配置问题
Flying_Fish_roe的博客
09-16 1369
Spring Boot 的自动配置在简化开发的同时，也带来了不少问题，尤其是在复杂的企业级应用中，自动配置可能引发 Bean 冲突、性能问题或者不必要的依赖。不过，了解其工作机制以及常见的配置排除与调试手段，可以有效避免这些问题。
Spring Boot 集成 Redisson 实现消息队列
大橘的博客
09-10 788
【代码】Spring Boot基于Redisson的RBlockingQueue实现简单的消息队列，适用于简单队列应用。有普通队列与延迟队列实现。
Spring Boot-版本兼容性问题
Flying_Fish_roe的博客
09-14 1204
Spring Boot 作为一个高度集成的框架，其版本兼容性涉及到多个方面，包括与 Spring Framework、JDK、第三方库、Spring Cloud 及开发工具之间的兼容性问题。在实际项目开发中，版本不兼容是常见问题，容易导致功能异常、编译错误甚至系统崩溃。尽量使用 Spring Boot 官方推荐的依赖版本，避免手动管理依赖版本。定期检查和升级项目中的依赖库，并在升级前充分测试。使用 Spring Boot 和 Spring Cloud 的 BOM 管理依赖，以确保版本兼容性。
Spring Boot-应用启动问题
最新发布
Flying_Fish_roe的博客
09-16 1090
Spring Boot 应用启动失败通常表现为以下几种情况： - **应用启动卡顿或超时**：应用启动过程中长时间没有响应，最终超时或抛出异常。 - **启动过程中出现异常**：在控制台或日志文件中打印出详细的异常堆栈信息，提示某个模块加载失败。 - **端口冲突**：当应用启动时，提示无法绑定到特定端口，导致启动失败。 - **Bean 初始化失败**：启动过程中，Bean 初始化出现问题，抛出 `BeanCreationException`。 - **外部资源加载失败**：在启动过程中无法成功加载所需的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值