【SpringBoot】SpringBoot 集成 Minio、OSS

已于 2023-02-02 11:28:24 修改
阅读量1.1k 收藏 6
点赞数
分类专栏： SpringBoot 课外趣学 文章标签： spring boot java kotlin
于 2022-08-31 16:42:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sco5282/article/details/126607799
版权

1、Minio

MinIO 是一款基于 Go 语言发开的高性能、分布式的对象存储系统。简单来说：就是可以存视频、图片 等。

通过 github 下载 Minio 服务端：

  • https://github.com/minio/minio

启动 Minio 服务端：

  • 在 minio.exe 目录下打开命令行，执行 minio.exe server 保存路径。如：minio.exe server D:\profession\behindEnd\minio\data。那么，上传的文件将会保存在：D:\profession\behindEnd\minio\data 下

启动后，通过 http://127.0.0.1:9000 访问，账号/密码：minioadmin
在这里插入图片描述
可以创建一个 bucket。

SpringBoot 集成 Minio：

1、添加依赖：

<!--minio-->
<dependency>
	<groupId>io.minio</groupId>
	<artifactId>minio</artifactId>
	<version>8.0.3</version>
</dependency>
<dependency>
	<groupId>org.jetbrains.kotlin</groupId>
	<artifactId>kotlin-stdlib</artifactId>
	<version>1.3.50</version>
</dependency>

2、添加配置：

spring:
  servlet:
    multipart:
      enabled: true
      max-file-size: 10MB       # 单个文件上传的最大上限
      max-request-size: 10MB    # 一次请求总大小上限

minio:
  endpoint: http://127.0.0.1:9000
  accessKey: minioadmin
  secretKey: minioadmin
  bucketName: test

3、代码：

配置类：

@Data
@Component
@ConfigurationProperties(prefix = "minio")
public class MinioClientConfig {

    private String endPoint;
    private String accessKey;
    private String secretKey;
    private String bucketName;

    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder().endpoint(endPoint).credentials(accessKey, secretKey).build();
    }

}

工具类：

@Component
public class MinioUtil {

    @Autowired
    private MinioClientConfig minioClientConfig;

    @Autowired
    private MinioClient minioClient;

    /**
     * @Description:判断bucket是否存在，不存在则创建
     * @Author: zzc
     * @Date: 2022-08-31 15:33
     * @param name:
     * @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();
        }
    }

    /**
     * @Description:创建存储bucket
     * @Author: zzc
     * @Date: 2022-08-31 15:33
     * @param name:
     * @return: java.lang.Boolean
     **/
    public Boolean makeBucket(String name) {
        try {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(name).build());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 删除存储bucket
     * @param name 存储bucket名称
     * @return Boolean
     */
    public Boolean removeBucket(String name) {
        try {
            minioClient.removeBucket(RemoveBucketArgs.builder()
                    .bucket(name)
                    .build());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    public String upload(MultipartFile file) {
        return upload(Arrays.asList(file)).get(0);
    }

    /**
     * @Description:批量上传文件
     * @Author: zzc
     * @Date: 2022-08-31 15:43
     * @param multipartFile:
     * @return: java.util.List<java.lang.String>
     **/
    public List<String> upload(List<MultipartFile> multipartFile) {
        List<String> urls = new ArrayList<>(multipartFile.size());
        for (MultipartFile file : multipartFile) {
            String fileName = file.getOriginalFilename();
            String[] split = fileName.split("\\.");
            if (split.length > 1) {
                fileName = split[0] + "_" + System.currentTimeMillis() + "." + split[1];
            } else {
                fileName = fileName + System.currentTimeMillis();
            }
            InputStream in = null;
            try {
                in = file.getInputStream();
                minioClient.putObject(PutObjectArgs.builder()
                        .bucket(minioClientConfig.getBucketName())
                        .object(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();
                    }
                }
            }
            urls.add(minioClientConfig.getEndPoint() + "/" + minioClientConfig.getBucketName() + "/" + fileName);
        }
        return urls;
    }

    /**
     * @Description:下载文件
     * @Author: zzc
     * @Date: 2022-08-31 15:46
     * @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(minioClientConfig.getBucketName()).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;
    }

    /**
     * @Description:查看bucketName里面的文件对象
     * @Author: zzc
     * @Date: 2022-08-31 15:48
     * @param bucketName:
     * @return: java.util.List<com.zzc.hardcore.vo.ObjectItemVo> 存储bucket内文件对象信息
     **/
    public List<ObjectItemVo> listObjects(String bucketName) {
        Iterable<Result<Item>> results = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).build());
        List<ObjectItemVo> objectItems = new ArrayList<>();
        try {
            for (Result<Item> result : results) {
                Item item = result.get();
                ObjectItemVo objectItem = new ObjectItemVo();
                objectItem.setObjectName(item.objectName());
                objectItem.setSize(item.size());
                objectItems.add(objectItem);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return objectItems;
    }

    /**
     * @Description:批量删除文件对象
     * @Author: zzc
     * @Date: 2022-08-31 15:49
     * @param bucketName:
     * @param objects: 对象名称集合
     * @return: java.lang.Iterable<io.minio.Result<io.minio.messages.DeleteError>>
     **/
    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;
    }

}

@Data
public class ObjectItemVo {
    private String objectName;
    private Long size;
}

4、接口测试

@RestController
@RequestMapping("/minio")
public class MinioController {

    @Autowired
    private MinioUtil minioUtil;

    @PostMapping("/upload")
    public String upload(@RequestParam("file") MultipartFile file) {
        return minioUtil.upload(file);
    }

    @PostMapping("/download")
    public ResponseEntity<byte[]> download() {
        return minioUtil.download("微信图片_20211002143943_1661932958068.jpg");
    }

}

2、OSS

引入依赖：

<dependency>
	<groupId>com.aliyun.oss</groupId>
	<artifactId>aliyun-sdk-oss</artifactId>
	<version>3.11.2</version>
</dependency>

配置文件

oss:
  aliyun:
    # 在控制台 创建完 bucket 后，会自动生成的
    endPoint:  ''
    # 注册后会有
    accessKeyId: ''
    # 注册后会有
    accessKeySecret: ''
    # 自己在控制台创建
    bucketName: ''

配置类：

@Data
@Component
@ConfigurationProperties(prefix = "oss.aliyun")
public class OssConfig implements InitializingBean {

    // 创建了bucket之后，oss会根据选择的区域自动分配endpoint
    private String endPoint;

    // accessKeyId
    private String accessKeyId;

    // accessKeySecret
    private String accessKeySecret;

    // bucket名称
    private String bucketName;

    public static String END_POINT;
    public static String ACCESS_KEY_ID;
    public static String ACCESS_KEY_SECRET;
    public static String BUCKET_NAME;

    @Override
    public void afterPropertiesSet() {
        END_POINT = endPoint;
        ACCESS_KEY_ID = accessKeyId;
        ACCESS_KEY_SECRET = accessKeySecret;
        BUCKET_NAME = bucketName;
    }

}

工具类：

public class OssUtil {

    /**
     * 操作OSS对象
     */
    private static OSSClient ossClient = null;

    static {
        initOssClient(OssConfig.END_POINT, OssConfig.ACCESS_KEY_ID, OssConfig.ACCESS_KEY_SECRET);
    }

    /**
     * 初始化
     *
     * @author zzc
     * @date 2023/2/1 14:40
     * @param: endPoint
     * @param: accessKeyId
     * @param: accessKeySecret
     **/
    private static void initOssClient(String endPoint, String accessKeyId, String accessKeySecret) {
        if (Objects.isNull(ossClient)) {
            ossClient = new OSSClient(endPoint, new DefaultCredentialProvider(accessKeyId, accessKeySecret), new ClientConfiguration());
        }
    }

    /**
     * 上产文件
     *
     * @author zzc
     * @date 2023/2/1 15:12
     * @param: file
     * @param: fileDir
     * @return: java.lang.String
     **/
    public static String upload(MultipartFile file, String fileDir) {
        // 1,判断bucketName是否存在
        if (!ossClient.doesBucketExist(OssConfig.BUCKET_NAME)) {
            ossClient.createBucket(OssConfig.BUCKET_NAME);
        }
        // 2.获取文件名称
        String fileName = getFileName(file);
        StringBuilder fileUrl = new StringBuilder();
        if (StringUtils.isNotBlank(fileDir)) {
            fileDir = fileDir.endsWith("/") ? fileDir : fileDir.concat("/");
            fileUrl.append(fileDir);
        }
        fileUrl.append(fileName);
        // 3.获取文件访问路径
        String filePath = getFilePath(fileUrl.toString());
        // 4.上传到OSS服务器
        try {
            PutObjectResult result = ossClient.putObject(OssConfig.BUCKET_NAME, fileUrl.toString(), file.getInputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
        return filePath;
    }

    /**
     * 删除文件
     *
     * @author zzc
     * @date 2023/2/1 15:14
     * @param: fileName
     * @return: boolean
     **/
    public static boolean delete(String fileName) {
        try {
            if (!ossClient.doesBucketExist(OssConfig.BUCKET_NAME)) {
                return false;
            }
            ossClient.deleteObject(OssConfig.BUCKET_NAME, fileName);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    private static String getFilePath(String fileUrl) {
        return "https://" + OssConfig.BUCKET_NAME + "." + OssConfig.END_POINT + "/" + fileUrl;
    }

    private static String getFileName(MultipartFile file) {
        String orgName = file.getOriginalFilename();
        if (StringUtils.isBlank(orgName)) {
            orgName = file.getName();
        }
        // 对文件类型检查
        /*try {
            FileTypeFilter.fileTypeFilter(file);
        } catch (Exception e) {
            e.printStackTrace();
        }*/
        orgName = getFileName(orgName);
        return !orgName.contains(".") ? System.currentTimeMillis() + "" : System.currentTimeMillis() + orgName.substring(orgName.lastIndexOf("."));
    }
    
    public static String getFileName(String fileName){
	    //判断是否带有盘符信息
	    // Check for Unix-style path
	    int unixSep = fileName.lastIndexOf('/');
	    // Check for Windows-style path
	    int winSep = fileName.lastIndexOf('\\');
	    // Cut off at latest possible point
	    int pos = (winSep > unixSep ? winSep : unixSep);
	    if (pos != -1)  {
	        // Any sort of path separator found...
	        fileName = fileName.substring(pos + 1);
	    }
	    //替换上传文件名字的特殊字符
	    fileName = fileName.replace("=","").replace(",","").replace("&","")
	            .replace("#", "").replace("“", "").replace("”", "");
	    //替换上传文件名字中的空格
	    fileName=fileName.replaceAll("\\s","");
	    return fileName;
	}

}

测试：

@RestController
@RequestMapping("/oss")
public class OssController {

    @PostMapping("/upload")
    public String uploadOssFile(@RequestParam("file") MultipartFile file, @RequestParam("filePath") String filePath) {
        return OssUtil.upload(file, filePath);
    }
}
sco5282
关注
专栏目录
【微服务】springboot整合minio详解
congge_study的博客
12-18 1万+
springboot整合MinIO使用详解
springboot整合minio全网最详细的教程
m0_67402235的博客
08-02 1384
对象存储服务OSS（ObjectStorageService）是一种海量、安全、低成本、高可靠的云存储服务，适合存放任意类型的文件。容量和处理能力弹性扩展，多种存储类型供选择，全面优化存储成本。
minio文件服务器_SpringBoot集成MinIO文件存储功能
weixin_39636164的博客
11-30 576
SpringBoot集成MinIO文件存储功能文件服务器是一个应用必要的组件之一。最早我搞过FTP，然后又用过FastDFS，接私活的时候我用MongoDB也凑合凑合。现如今时代不同了，开始流行起了OSS。协议：CC BY-SA 4.0 https://creativecommons.org/licenses/by-sa/4.0/版权声明：本文为原创文章，遵循 CC 4.0 BY-SA ...
SpringBoot-集成Minio
孟孟的博客
10-24 8484
Minio 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。Minio是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL。
SpringBoot整合Minio及阿里云OSS（配置文件无缝切换）
最新发布
陌殇殇的博客
09-06 922
minio的安装配置，SpringBoot整合Minio对象存储及阿里云OSS对象存储，实现通过配置yml类型进行无缝切换
SpringBoot集成MinIO
路在何方
06-29 2812
对象存储服务OSS（Object Storage Service）是一种海量、安全、低成本、高可靠的云存储服务，适合存放任意类型的文件。容量和处理能力弹性扩展，多种存储类型供选择，全面优化存储成本。今天我这里主要讲解SpringBoot如何集成MinIO。
SpringBoot整合Minio
水蓝
04-16 469
创建一个Bucket, Bucket名字要在配置文件上使用, 然后设置权限为可见。访问 xxx.xxx.xxx.xxx:9090， 服务器地址+端口号。前提：已经在本地启动或服务器部署。来部署Minio, 拉取。创建Minio容器并运行。编写相关配置文件的代码。
SpringBoot + minio实现文件切片极速上传技术源码（敢说全网整合完整度前三）
06-02
Minio是一款开源的对象存储服务器，它可以运行在多种操作系统上，包括Linux、Windows和MacOS等。它提供了一种简单、可扩展、高可用的对象存储解决方案，支持多种数据格式，包括对象、块和文件等。 以下是Minio的...
springboot整合minio8实现文件存储服务（最新版）
weixin_43241706的博客
03-31 6470
近期在构建公司技术服务平台，在搭建完一些基础技术服务之后，考虑到项目过程中使用到很多文件存储功能，所以在平台上面提供统一的文件存储服务。 一开始计划直接使用阿里云OSS服务（想法简单了），后来与CTO讨论后，决定使用MinIO来完成该服务。然后开始学习MinIO相关知识，各种查看中英文版文档，现在最新的中文文档版本还是MinIO7的，所以查看了官网的英文版文档： [https://docs.min.io/docs] 梳理下过程，将基础功能整理如下： 1. MinIO安装（docker单机） 前提需要了解do
minio（文件服务存储服务OSS）的安装与使用
busy_world的博客
08-14 1292
MinIO是一个高性能的开源对象存储服务，它与Amazon S3 API兼容，适合存储大量的非结构化数据，例如图片、视频、日志文件等。MinIO具备分布式架构，支持多节点部署，提供高可用的存储服务，并支持数据加密、访问控制和版本管理等功能。MinIO支持多种部署方式，包括单机部署和分布式部署，适合不同的业务需求和规模。此外，MinIO还提供了客户端工具MinIO Client (mc)和Java SDK等，方便用户进行数据管理和集成到应用程序中。
OSS对比MinIO
中国移不动的博客
04-23 1441
代码运行成功后，编译工具中将显示列举的文件详情，例如 exampledir/exampleobject.txt。代码运行成功后，将删除 exampledir 目录下的 exampleobject.txt 文件。存储空间是OSS的全局命名空间，相当于数据的容器，可以存储若干文件。代码运行成功后，exampledir 目录下将上传 exampleobject.txt 文件。代码运行成功后，将创建名为 examplebucket 的存储空间。以下代码用于通过流式上传的方式将文件上传到OSS。
【工具篇】Spring Boot 整合 Minio OSS 存储服务
csp732171109的博客
04-25 1309
写在最前 Docker安装MinIO Spring Boot 整合 Minio Demo 地址：mingyue-springboot-minio 1.添加依赖 <!-- minio 依赖 --> <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <version>8.3.9</version
SpringBoot 整合Minio
b哥救救我
08-28 381
官网下载地址：https://www.minio.org.cn/download.shtml#/windows下载后：运行minio在cmd窗口命令行运行minio.exe ，D:\minioServer\fileAddr 这个是文件要存放的位置结果如下：启动成功后，访问：127.0.0.1:9000/minio，可以进入到minio的控制台以上就安装成功了。
springboot项目集成minio
08-21
要在Spring Boot项目中集成Minio，您可以按照以下步骤进行操作： 1. 首先，创建一个Spring Boot项目并引入Minio的依赖。在您的项目的pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <version>7.0.2</version> </dependency> ``` 2. 接下来，您需要编写Minio的配置文件。您可以在配置文件中指定Minio的连接信息（如端口、Access Key和Secret Key等）。 3. 当您完成配置文件的编写后，您可以启动Minio服务。您可以使用以下命令启动Minio服务： ```bash bash run.sh ``` 4. 您可以使用以下命令查看Minio的日志： ```bash tail -f /root/logs/minio/minio.log ``` 5. 最后，您可以在您的Spring Boot项目中使用Minio的API进行文件存储和检索操作。您可以参考Minio的官方文档以了解更多关于如何使用Minio的API的信息。 需要注意的是，以上步骤仅是简述了在Linux单节点上部署Minio的过程，具体的部署方式和配置可能会因环境而异。您可以根据您的实际情况进行相应的调整。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [SpringBoot整合minio服务（超详细）](https://blog.csdn.net/yueyue763184/article/details/131147025)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [springboot集成Minio](https://blog.csdn.net/AYANBAO/article/details/130031830)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值