SpringBoot 整合 MinIO 实现视频的分片上传/断点续传（亲测可行）

最新推荐文章于 2024-09-20 15:26:14 发布
最新推荐文章于 2024-09-20 15:26:14 发布
阅读量505 收藏 3
点赞数
文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cyufeng/article/details/131865021
版权

1、前言

之前做了一个慕课网上的仿短视频开发，里面有很多比较粗糙的实现，比如视频上传部分是直接由前端上传云服务，没考虑到客户的网络环境质量等问题，如果一个视频快上传完了，但是网断了没有上传完成需要客户重新上传，这对于用户体验是极差的。

那么我们对于视频文件的上传可以采取断点续传，上传过程中，如果出现网络异常或程序崩溃导致文件上传失败时，将从断点记录处继续上传未上传完成的部分，断点续传依赖于MD5和分片上传，对于本demo分片上传的流程如图
在这里插入图片描述
通过文件唯一标识MD5，在数据库中查询此前是否创建过该SysUploadTask，如果存在，直接返回TaskInfo；如果不存在，通过amazonS3获取到UploadId并新建一个SysUploadTask返回。

前端将文件分好片后，通过服务器得到每一片的一个预地址，然后由前端直接向minio服务器发起真正的上传请求，避免上传时占用应用服务器的带宽，影响系统稳定。最后再向后端服务器发起合并请求。

2、数据库结构

在这里插入图片描述

3、后端实现

3.1、根据MD5获取是否存在相同文件

Controller层

/**
 * 查询是否上传过，若存在，返回TaskInfoDTO
 * @param identifier 文件md5
 * @return
 */
@GetMapping("/{identifier}")
public GraceJSONResult taskInfo (@PathVariable("identifier") String identifier) {
    return GraceJSONResult.ok(sysUploadTaskService.getTaskInfo(identifier));
}

Service层

/**
 * 查询是否上传过，若存在，返回TaskInfoDTO
 * @param identifier
 * @return
 */
public TaskInfoDTO getTaskInfo(String identifier) {
    SysUploadTask task = getByIdentifier(identifier);
    if (task == null) {
        return null;
    }
    TaskInfoDTO result = new TaskInfoDTO().setFinished(true).setTaskRecord(TaskRecordDTO.convertFromEntity(task)).setPath(getPath(task.getBucketName(), task.getObjectKey()));

    boolean doesObjectExist = amazonS3.doesObjectExist(task.getBucketName(), task.getObjectKey());
    if (!doesObjectExist) {
        // 未上传完，返回已上传的分片
        ListPartsRequest listPartsRequest = new ListPartsRequest(task.getBucketName(), task.getObjectKey(), task.getUploadId());
        PartListing partListing = amazonS3.listParts(listPartsRequest);
        result.setFinished(false).getTaskRecord().setExitPartList(partListing.getParts());
    }
    return result;
}

3.2、初始化一个上传任务

Controller层

/**
 * 创建一个上传任务
 * @return
 */
@PostMapping
public GraceJSONResult initTask (@Valid @RequestBody InitTaskParam param) {
    return GraceJSONResult.ok(sysUploadTaskService.initTask(param));
}

Service层

/**
 * 初始化一个任务
 */
public TaskInfoDTO initTask(InitTaskParam param) {

    Date currentDate = new Date();
    String bucketName = minioProperties.getBucketName();
    String fileName = param.getFileName();
    String suffix = fileName.substring(fileName.lastIndexOf(".")+1, fileName.length());
    String key = StrUtil.format("{}/{}.{}", DateUtil.format(currentDate, "YYYY-MM-dd"), IdUtil.randomUUID(), suffix);
    String contentType = MediaTypeFactory.getMediaType(key).orElse(MediaType.APPLICATION_OCTET_STREAM).toString();
    ObjectMetadata objectMetadata = new ObjectMetadata();
    objectMetadata.setContentType(contentType);
    InitiateMultipartUploadResult initiateMultipartUploadResult = amazonS3
            .initiateMultipartUpload(new InitiateMultipartUploadRequest(bucketName, key).withObjectMetadata(objectMetadata));
    String uploadId = initiateMultipartUploadResult.getUploadId();

    SysUploadTask task = new SysUploadTask();
    int chunkNum = (int) Math.ceil(param.getTotalSize() * 1.0 / param.getChunkSize());
    task.setBucketName(minioProperties.getBucketName())
            .setChunkNum(chunkNum)
            .setChunkSize(param.getChunkSize())
            .setTotalSize(param.getTotalSize())
            .setFileIdentifier(param.getIdentifier())
            .setFileName(fileName)
            .setObjectKey(key)
            .setUploadId(uploadId);
    sysUploadTaskMapper.insert(task);
    return new TaskInfoDTO().setFinished(false).setTaskRecord(TaskRecordDTO.convertFromEntity(task)).setPath(getPath(bucketName, key));
}

3.3、获取每个分片的预签名上传地址

Controller层

/**
 * 获取每个分片的预签名上传地址
 * @param identifier
 * @param partNumber
 * @return
 */
@GetMapping("/{identifier}/{partNumber}")
public GraceJSONResult preSignUploadUrl (@PathVariable("identifier") String identifier, @PathVariable("partNumber") Integer partNumber) {
    SysUploadTask task = sysUploadTaskService.getByIdentifier(identifier);
    if (task == null) {
        return GraceJSONResult.error("分片任务不存在");
    }
    Map<String, String> params = new HashMap<>();
    params.put("partNumber", partNumber.toString());
    params.put("uploadId", task.getUploadId());
    return GraceJSONResult.ok(sysUploadTaskService.genPreSignUploadUrl(task.getBucketName(), task.getObjectKey(), params));
}

Service层

/**
 * 生成预签名上传url
 * @param bucket 桶名
 * @param objectKey 对象的key
 * @param params 额外的参数
 * @return
 */
public String genPreSignUploadUrl(String bucket, String objectKey, Map<String, String> params) {
    Date currentDate = new Date();
    Date expireDate = DateUtil.offsetMillisecond(currentDate, PRE_SIGN_URL_EXPIRE.intValue());
    GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucket, objectKey)
            .withExpiration(expireDate).withMethod(HttpMethod.PUT);
    if (params != null) {
        params.forEach((key, val) -> request.addRequestParameter(key, val));
    }
    URL preSignedUrl = amazonS3.generatePresignedUrl(request);
    return preSignedUrl.toString();
}

3.4、合并分片

Controller层

/**
 * 合并分片
 * @param identifier
 * @return
 */
@PostMapping("/merge/{identifier}")
public GraceJSONResult merge (@PathVariable("identifier") String identifier) {
    sysUploadTaskService.merge(identifier);
    return GraceJSONResult.ok();
}

Service层

/**
 * 合并分片
 * @param identifier
 */
public void merge(String identifier) {
    SysUploadTask task = getByIdentifier(identifier);
    if (task == null) {
        throw new RuntimeException("分片任务不存");
    }

    ListPartsRequest listPartsRequest = new ListPartsRequest(task.getBucketName(), task.getObjectKey(), task.getUploadId());
    PartListing partListing = amazonS3.listParts(listPartsRequest);
    List<PartSummary> parts = partListing.getParts();
    if (!task.getChunkNum().equals(parts.size())) {
        // 已上传分块数量与记录中的数量不对应，不能合并分块
        throw new RuntimeException("分片缺失，请重新上传");
    }
    CompleteMultipartUploadRequest completeMultipartUploadRequest = new CompleteMultipartUploadRequest()
            .withUploadId(task.getUploadId())
            .withKey(task.getObjectKey())
            .withBucketName(task.getBucketName())
            .withPartETags(parts.stream().map(partSummary -> new PartETag(partSummary.getPartNumber(), partSummary.getETag())).collect(Collectors.toList()));
    CompleteMultipartUploadResult result = amazonS3.completeMultipartUpload(completeMultipartUploadRequest);
}

4、分片文件清理问题

视频上传一半不上传了，怎么清理碎片分片。

可以考虑在sys_upload_task表中新加一个status字段，表示是否合并分片，默认为false，merge请求结束后变更为true，通过一个定时任务定期清理为status为false的记录。另外MinIO自身对于临时上传的分片，会实施定时清理。

Cyufeng
关注
SpringBoot实现断点续传
人生就像一场戏
12-15 7433
大文件面临的问题 1. 上传速度慢 -- 应对: 分块上传 2. 上传文件到一半中断后，继续上传却只能重头开始上传 -- 应对: 断点续传 3. 相同文件未修改再次上传, 却只能重头开始上传 -- 应对: 秒传 分片上传 1、什么分片上传 分片上传，就是将所要上传的文件，按照一定的大小，将整个文件分隔成多个数据块（我们称之为Part）来进行分别上传，上传完之后再由服务端对所有上传的文件进行汇总整合成原始的文件 2、分片上传适用场景 ...
Minio对象存储及Springboot整合Minio分片上传文章-代码
02-23
在本文中，我们将深入探讨如何将Minio与Spring Boot应用程序整合，并实现分片上传功能。 首先，我们需要在项目中引入Minio的Java SDK依赖。在Maven的pom.xml文件中添加以下依赖： ```xml <groupId>io.minio</...
springboot断点续传或分片上传
02-21
springboot断点续传或分片上传
spring boot断点续传
Frinday的博客
05-28 781
@GetMapping("/download") public void download(@RequestParam String path, HttpServletRequest request, HttpServletResponse response) throws IOException { Path downloadFile = Paths.get(path); if (!Files.exists(downloadFile)) { response.setSta.
用SPRINGBOOT 实现断点续传 (HTTP)
最新发布
weixin_52050572的博客
09-20 1043
前端：vue2,vue3,vue-cli,webuploader,html5 后端：SpringBoot 数据库：MySQL,Oracle,SQL Server,达梦,人大金仓,国产化数据库 协议：HTTP WebServer：Tomcat,Resin 服务器：Linux,国产化系统 功能：大文件上传，断点续传，秒传，加密传输，加密存储，文件夹上传，文件夹层级结构 技术：支持第三方软件集成， 该说不说，最近这块好像挻火的，今天早上又有网友加我微信，也是想了解一下这块的技术和方案，也不知道这位老哥是从哪里找到
用SPRINGMVC 实现断点续传 (HTTP)
alisky119的博客
07-06 992
我们主要是做政府项目，客户也都是政府单位的，对用户体验要求比较高，要让他们感觉用的方便，对稳定性要求比较高，基本上一年365天都不希望你出问题，对安全性要求也比较高，涉密了，信创国产化，不能连外网的，都是内网。免费提供技术支持，电话支持，微信支持，QQ支持，远程一对一专业技术支持，可以说是全球唯一提供免费技术支持了，提供原理讲解，提供视频教程，这个也是全球唯一的。免费提供源码讲解服务，功能讲解，逻辑讲解，原理讲解，思路讲解，核心代码功能实现讲解，新业务功能扩展指导，免费提供编译指导，免费提供部署指导。
SpringBoot上传文件的断点续传实现
Android菜鸟的专栏
11-29 2011
百度SpringBoot上传文件的断点续传，千篇一律的都是分片，即把大文件分割成许多小文件，然后上传所有的小文件到服务器，服务器再把所有的小文件合并为一个大文件。这根本就不是断点续传。断点续传应该是传到哪里断了，下次就在那个断开的位置接着继续传，这代码一想也很简单啊，服务器通过输出流不停的写文件，如果被中断了链接了，则客户端下次上传之前先给服务器发送一个请求，让服务器告诉我们之前传到什么位置了，这样客户端就可以从指定的位置开始继续传了。 网上的做法都是分片，是因为SpringBoot会自动帮我们接收文件，存
SpringBoot 中大文件（分片上传）断点续传与极速秒传功能的实现
08-18
SpringBoot 中大文件（分片上传）断点续传与极速秒传功能的实现 在本文中，我们将探讨如何在 SpringBoot 框架中实现大文件（分片上传）断点续传与极速秒传功能。该功能能够帮助用户快速上传大文件，提高上传效率和...
springboot集成minio实现了分片上传功能源码+项目说明.zip
12-20
springboot集成minio实现了分片上传功能源码+项目说明.zip vue版本的：前端 后端 快速开始 后端 修改配置文件application.yml: minio: endpoint: accessKey: secretKey: bucketName: downloadUri: #配置...
MinIo最佳性能分片上传、断点续传方案
03-14
通过这个Demo，开发者可以快速理解和实现MinIO的大文件分片上传和断点续传方案，提升应用的上传性能和用户满意度。在实际项目中，可以根据具体需求调整分片策略和断点续传逻辑，以达到最优的上传体验。
基于minio webuploader实现的分片上传 断点续传
04-15
本项目将这两个技术结合，实现了基于MinIO的WebUploader分片上传与断点续传功能。 1. MinIO对象存储服务： MinIO是一款高性能、分布式、开源的对象存储系统。它支持S3 API，使得开发者可以轻松地部署和管理存储...
spring boot实现大文件断点续传
10-18
使用spring boot整合google的断点续传框架事项大文件断点续传功能
springboot断点续传
12-17
解决网络等外部因素导致大文件上传中途失败而引起的客户不友好的问题，分片断点上传大文件，springboot的框架
Springboot 断点续传大文件
07-01
本人测试上传3G多的文件，未发现问题，但是还有优化空间。 原理 曾经上传过：前端通过计算，拿到整个文件的md5,请求后台是否曾经已经上传过，如果曾经上传过，直接返回成功 曾经没有上传过：后台返回前端，表示从未上传过此文件，前端通过技术，将大文件分隔成无数个小文件，一一上传 曾经上传一部分：前端在上传每个模块之前，先请求后台，判断此模块是否已经上传过，如果已经上传过，则不需要再上传，否则上传。 注：启动以后直接访问http://localhost:9002/demo/largeUpload/open,如果本地运行需要修改maven私服地址 ，使用idea首先需要安装Lombok插件，压缩包包含数据库表脚本文件，数据库名称需要自己创建，使用mysql demo测试网站： http://118.89.41.69:9002/demo/largeUpload/open
spring boot + plupload实现大文件断点续传
10-18
使用plupload整合spring boot框架实现大文件断点续传功能，简单的使用了plupload API，最便捷实现断点续传功能。
SpringBoot+Minio实现文件断点续传
程序员阿药的博客
03-14 1118
断点续传的实现方式。
使用minio实现大文件断点续传(一)
康世行
12-23 970
拉取镜像新建映射目录开放对应端口启动镜像测试minio是否搭建成功访问管理页面账号密码miniominio@123上传图片访问图片。
用SpringBoot 实现断点续传 (HTTP)
weixin_45525177的博客
11-18 572
文件上传是一个老生常谈的话题了，在文件相对比较小的情况下，可以直接把文件转化为。
springboot实现minio分片上传和断点续传
05-31
在Spring Boot中实现MinIO文件服务器的分片上传和断点续传，可以使用MinIO Java SDK提供的API和Spring Boot提供的Multipart File上传功能。具体实现步骤如下： 1. 引入MinIO Java SDK和Spring Boot的依赖 ```xml <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <version>8.0.4</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> ``` 2. 配置MinIO客户端 在Spring Boot的配置文件中，配置MinIO客户端的连接信息。 ```yaml minio: endpoint: minio.example.com access-key: ACCESS_KEY secret-key: SECRET_KEY secure: false ``` 3. 初始化Multipart上传 在上传大文件之前，使用 `InitiateMultipartUpload` API 方法初始化一个Multipart上传会话，并获取一个上传ID。上传ID用于标识一个Multipart上传会话。 ```java import io.minio.MinioClient; import io.minio.errors.MinioException; import io.minio.messages.Part; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Service; import org.springframework.web.multipart.MultipartFile; import java.io.IOException; import java.util.ArrayList; import java.util.List; @Service public class MinioService { @Autowired private MinioClient minioClient; @Value("${minio.bucket-name}") private String bucketName; public String initiateMultipartUpload(String objectName) throws MinioException { String uploadId = minioClient.initiateMultipartUpload(bucketName, objectName).uploadId(); return uploadId; } } ``` 4. 上传文件块 将大文件分成多个小块，每个小块的大小可以根据需求自定义。使用 `UploadPart` API 方法将每个小块独立上传。上传时需要指定上传的文件名、块编号、块大小以及上传ID等信息。 ```java public class MinioService { // ... public List<Part> uploadParts(String objectName, String uploadId, MultipartFile file, int partSize) throws IOException, MinioException { List<Part> parts = new ArrayList<>(); int partNumber = 1; byte[] buffer = new byte[partSize]; while (true) { int bytesRead = file.getInputStream().read(buffer); if (bytesRead < 0) { break; } byte[] partData = new byte[bytesRead]; System.arraycopy(buffer, 0, partData, 0, bytesRead); Part part = minioClient.uploadPart( bucketName, objectName, partNumber, uploadId, partData, bytesRead); parts.add(part); partNumber++; } return parts; } } ``` 5. 完成Multipart上传 上传所有文件块后，使用 `CompleteMultipartUpload` API 方法将它们合并成一个完整的文件，最终得到上传的文件。 ```java public class MinioService { // ... public void completeMultipartUpload(String objectName, String uploadId, List<Part> parts) throws MinioException { minioClient.completeMultipartUpload(bucketName, objectName, uploadId, parts); } } ``` 6. 断点续传 如果上传中断，可以使用 `ListParts` API 方法获取已上传的文件块信息，然后从中断处继续上传。 ```java public class MinioService { // ... public List<Part> listParts(String objectName, String uploadId) throws MinioException { return minioClient.listParts(bucketName, objectName, uploadId).getParts(); } } ``` 使用Spring Boot的Multipart File上传功能上传文件时，需要在Controller中添加 `@RequestParam("file") MultipartFile file` 注解，自动将文件转换为MultipartFile类型。 ```java @RestController @RequestMapping("/file") public class FileController { @Autowired private MinioService minioService; @PostMapping("/upload") public void uploadFile(@RequestParam("file") MultipartFile file) throws IOException, MinioException { // 获取文件名和文件大小 String fileName = file.getOriginalFilename(); long fileSize = file.getSize(); // 定义块大小（5MB） int partSize = 5 * 1024 * 1024; // 初始化Multipart上传会话 String uploadId = minioService.initiateMultipartUpload(fileName); // 上传文件块 List<Part> parts = minioService.uploadParts(fileName, uploadId, file, partSize); // 完成Multipart上传 minioService.completeMultipartUpload(fileName, uploadId, parts); } @PostMapping("/resume") public void resumeUpload(@RequestParam("file") MultipartFile file, String objectName, String uploadId) throws IOException, MinioException { // 获取已上传的文件块信息 List<Part> parts = minioService.listParts(objectName, uploadId); // 上传文件块 parts = minioService.uploadParts(objectName, uploadId, file, partSize); // 完成Multipart上传 minioService.completeMultipartUpload(objectName, uploadId, parts); } } ``` 以上是使用Spring Boot实现MinIO文件服务器的分片上传和断点续传的基本步骤，具体实现还需要根据实际需求进行调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Cyufeng

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

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

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

打赏作者

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

抵扣说明：

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

余额充值