断点续传结合MinIO在业务中的体现

叁歲伎倆 2024-02-17 09:52 8阅读 0赞

> 本文讲解了断点续传结合MinIO在后端的实现，并在业务中进行了简单体现。
> 
> 前置内容：
> 
>  *  MinIO ：[手摸手带你SpringBoot集成MinIO入门-CSDN博客][SpringBoot_MinIO_-CSDN]
>  *  分块处理：[后端视频大文件分片处理-CSDN博客][-CSDN]**目录**

**目录**

一、什么是断点续传？

二、准备工作

1.准备工作

2. 编写接口、服务类

总结

--------------------

演示demo： [六花i/breakpoint-transmission\_minio\_demo (gitee.com)][i_breakpoint-transmission_minio_demo _gitee.com]

## **一、什么是断点续传？** ##

通常视频文件都比较大，所以对于视频等文件上传的需求要满足大文件的上传需求。HTTP协议本身对上传文件大小没有限制，但是客户的网络环境之类、电脑硬件环境等参差不齐，如果一个大文件快上传完了，但是突然断网了，没有上传完成，需要客户重新上传，那么用户体验就非常差。所以对于大文件上传的最基本要求就是断点续传。

**简单点说，断点续传就是解决用户上传视频等大文件时遇到网络波动情况下，避免重复下载的解决方案。**

> 流程如下：
> 
> 1.  前端上传文件前，请求媒资接口层检查文件是否存在
>     
>      *  若存在，则不再上传
>      *  若不存在，则开始上传，首先对视频文件进行分块
> 2.  前端分块进行上传，上传前首先检查分块是否已经存在
>     
>      *  若分块已存在，则不再上传
>      *  若分块不存在，则开始上传分块
> 3.  前端请求媒资管理接口层，请求上传分块
> 4.  接口层请求服务层上传分块
> 5.  服务端将分块信息上传到MinIO
> 6.  前端将分块上传完毕，请求接口层合并分块
> 7.  接口层请求服务层合并分块
> 8.  服务层根据文件信息找到MinIO中的分块文件，下载到本地临时目录，将所有分块下载完毕后开始合并
> 9.  合并完成后，将合并后的文件上传至MinIO

![a0b0bb25e967456fbd5446c29cbcabc7.png][]

## 二、准备工作 ##

### 1.准备工作 ###

**创建项目（必做）**：[手摸手带你SpringBoot集成MinIO入门-CSDN博客][SpringBoot_MinIO_-CSDN]

**在上面的基础上添加依赖：**

<dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.5.3.1</version>
            </dependency>
            <dependency>
                <groupId>com.mysql</groupId>
                <artifactId>mysql-connector-j</artifactId>
                <version>8.0.32</version>
            </dependency>

**统一结果返回类：**

@Data
    public class RestResponse<T> {
        /**
         * 相应编码 0为正常 -1为错误
         */
        private int code;
        /**
         * 响应提示信息
         */
        private String msg;
        /**
         * 响应内容
         */
        private T result;
    
        public RestResponse(int code, String msg) {
            this.code = code;
            this.msg = msg;
        }
    
        public RestResponse() {
            this(0, "success");
        }
    
        /**
         * 错误信息的封装
         */
        public static <T> RestResponse<T> validfail() {
            RestResponse<T> response = new RestResponse<>();
            response.setCode(-1);
            return response;
        }
    
        public static <T> RestResponse<T> validfail(String msg) {
            RestResponse<T> response = new RestResponse<>();
            response.setCode(-1);
            response.setMsg(msg);
            return response;
        }
    
        public static <T> RestResponse<T> validfail(String msg, T result) {
            RestResponse<T> response = new RestResponse<>();
            response.setCode(-1);
            response.setMsg(msg);
            response.setResult(result);
            return response;
        }
    
        /**
         * 正常信息的封装
         */
        public static <T> RestResponse<T> success() {
            return new RestResponse<>();
        }
    
        public static <T> RestResponse<T> success(T result) {
            RestResponse<T> response = new RestResponse<>();
            response.setResult(result);
            return response;
        }
    
        public static <T> RestResponse<T> success(String msg, T result) {
            RestResponse<T> response = new RestResponse<>();
            response.setMsg(msg);
            response.setResult(result);
            return response;
        }
    }

**YML配置：**

spring:
      # 配置文件上传大小限制
      servlet:
        multipart:
          max-file-size: 200MB
          max-request-size: 200MB
    
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:msql://localhost:8080/demo1?useUnicode=true&characterEncoding=utf8
        username: root
        password: root
    
    mybatis-plus:
      configuration:
        map-underscore-to-camel-case: true
    
    minio:
      accessKey: 填你的
      secretKey: 填你的
      bucket: test
      endpoint: http://你的ip:端口
      readPath: http://你的ip:端口

**创建表、实体类和对应mapper（请自行创建）：**

![f705498ab25c4e2e92dc2e7ae448e9d7.png][]

### 2. 编写接口、服务类 ###

**定义Controller层接口 ：**

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.multipart.MultipartFile;
    
    import java.io.IOException;
    
    @RestController
    public class BigFilesController {
    
        @Autowired
        private MediaFileService mediaFileService;
    
        /**
         * 文件检查
         * @param fileMd5
         * @return
         */
        @PostMapping("/upload/checkfile")
        public RestResponse<Boolean> checkFile(@RequestParam("fileMd5") String fileMd5) {
            return mediaFileService.checkFile(fileMd5);
        }
    
    
        /**
         * 分片检查
         * @param fileMd5
         * @param chunk
         * @return
         */
        @PostMapping("/upload/checkchunk")
        public RestResponse<Boolean> checkChunk(@RequestParam("fileMd5") String fileMd5, @RequestParam("chunk") int chunk) {
            return mediaFileService.checkChunk(fileMd5, chunk);
        }
    
        /**
         * 上传分片
         * @param file
         * @param fileMd5
         * @param chunk
         * @return
         */
        @PostMapping("/upload/uploadchunk")
        public RestResponse uploadChunk(@RequestParam("file") MultipartFile file, @RequestParam("fileMd5") String fileMd5, @RequestParam("chunk") int chunk) throws IOException {
            return mediaFileService.uploadChunk(fileMd5, chunk, file.getBytes());
        }
    
        /**
         * 合并分片
         * @param fileMd5
         * @param fileName
         * @param chunkTotal
         * @return
         */
        @PostMapping("/upload/mergechunks")
        public RestResponse mergeChunks(@RequestParam("fileMd5") String fileMd5, @RequestParam("fileName") String fileName, @RequestParam("chunkTotal") int chunkTotal) {
            return null;
        }
    }

**编写service层服务 ：**

import com.baomidou.mybatisplus.extension.service.IService;
    public interface MediaFileService extends IService<MediaFiles> {
        /**
         * 检查文件是否存在
         *
         * @param fileMd5 文件的md5
         * @return
         */
        RestResponse checkFile(String fileMd5);
    
        /**
         * 检查分块是否存在
         * @param fileMd5       文件的MD5
         * @param chunkIndex    分块序号
         * @return
         */
        RestResponse checkChunk(String fileMd5, int chunkIndex);
    
        /**
         * 上传分片
         * @param fileMd5
         * @param chunk
         * @param bytes
         * @return
         */
        RestResponse uploadChunk(String fileMd5, int chunk, byte[] bytes);
    
        /**
         * 合并分块
         * @param companyId
         * @param fileMd5
         * @param chunkTotal
         * @param uploadFileParamsDto
         * @return
         */
        RestResponse mergeChunks(Long companyId, String fileMd5, int chunkTotal, UploadFileParamsDto uploadFileParamsDto);
    }

**service实现类：**

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    import com.google.errorprone.annotations.Var;
    import io.minio.*;
    import io.minio.errors.*;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.tomcat.util.http.fileupload.IOUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.util.DigestUtils;
    
    import java.io.*;
    import java.nio.file.Files;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.util.List;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    @Service
    @Slf4j
    public class MediaFileServiceImpl extends ServiceImpl<MediaFilesMapper, MediaFiles> implements MediaFileService {
    
        @Autowired
        private MinioClient minioClient;
    
        @Autowired
        private MediaFilesMapper mediaFilesMapper;
    
        @Autowired
        private MinIOConfigProperties minIOConfigProperties;
    
        @Autowired
        private MinIOUtil minIOUtil;
    
        /**
         * 首先判断数据库中是否存在该文件,其次判断minio的bucket中是否存在该文件
         * @param fileMd5 文件的md5
         * @return
         */
        @Override
        public RestResponse<Boolean> checkFile(String fileMd5) {
            MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
            // 数据库中不存在，则直接返回false 表示不存在
            if (mediaFiles == null) {
                return RestResponse.success(false);
            }
            // 若数据库中存在，根据数据库中的文件信息，则继续判断bucket中是否存在
            try {
                InputStream inputStream = minioClient.getObject(GetObjectArgs
                        .builder()
                        .bucket(mediaFiles.getBucket())
                        .object(mediaFiles.getFilePath())
                        .build());
                if (inputStream == null) {
                    return RestResponse.success(false);
                }
            } catch (Exception e) {
                return RestResponse.success(false);
            }
            return RestResponse.success(true);
        }
    
        /**
         * 分块是否存在，只需要判断minio对应的目录下是否存在分块文件
         * @param fileMd5       文件的MD5
         * @param chunkIndex    分块序号
         * @return
         */
        @Override
        public RestResponse<Boolean> checkChunk(String fileMd5, int chunkIndex) {
            // 获取分块目录
            String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
            String chunkFilePath = chunkFileFolderPath + chunkIndex;
            try {
                // 判断分块是否存在
                InputStream inputStream = minioClient.getObject(GetObjectArgs
                        .builder()
                        .bucket(minIOConfigProperties.getBucket())
                        .object(chunkFilePath)
                        .build());
                // 不存在返回false
                if (inputStream == null) {
                    return RestResponse.success(false);
                }
            } catch (Exception e) {
                // 出异常也返回false
                return RestResponse.success(false);
            }
            // 否则返回true
            return RestResponse.success();
        }
    
        /**
         * 上传分片
         * @param fileMd5
         * @param chunk
         * @param bytes
         * @return
         */
        public RestResponse uploadChunk(String fileMd5, int chunk, byte[] bytes) {
            // 分块文件路径
            String chunkFilePath = getChunkFileFolderPath(fileMd5) + chunk;
            try {
                minIOUtil.upload(minIOConfigProperties.getBucket(), null, chunkFilePath);
                return RestResponse.success(true);
            } catch (Exception e) {
                log.debug("上传分块文件：{}失败：{}", chunkFilePath, e.getMessage());
            }
            return RestResponse.validfail("上传文件失败", false);
        }
    
        /**
         * 合并分块
         * @param companyId
         * @param fileMd5 前端先对完整视频的流进行md5处理
         * @param chunkTotal
         * @param uploadFileParamsDto
         * @return
         * @throws IOException
         */
        @Override
        public RestResponse mergeChunks(Long companyId, String fileMd5, int chunkTotal, UploadFileParamsDto uploadFileParamsDto) throws IOException {
    
            //分块文件所在目录
            String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
            //找到分快文件调用minio的sdk合并
            List<ComposeSource> sources = Stream.iterate(0, i -> i++).limit(chunkTotal).map(i -> ComposeSource
                    .builder()
                    .bucket(minIOConfigProperties.getBucket())
                    .object(chunkFileFolderPath + i).build()).collect(Collectors.toList());
    
            // 合并后文件的名
            String fileName = uploadFileParamsDto.getFileName();
            String extension = fileName.substring(fileName.lastIndexOf("."));
            String objectName = getFilePathByMd5(fileMd5, extension);
            //指定合并后的objectName等信息
            ComposeObjectArgs composeObjectArgs = ComposeObjectArgs.builder()
                    .bucket(minIOConfigProperties.getBucket())
                    .object(objectName)
                    .sources(sources)
                    .build();
    
            //合并文件,单个分片文件大小必须为5m
            try {
                minioClient.composeObject(composeObjectArgs);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("合并文件出错了，bucket:{},objectName:{},错误信息:{}",minIOConfigProperties.getBucket(), objectName, e.getMessage());
                return RestResponse.validfail("合并文件出错！");
            }
    
            //下载文件，用于比较md5
            File file = File.createTempFile("minio", ".merge");
            file= downloadFileFromMinio(file, minIOConfigProperties.getBucket(), objectName);
    
            // 对文件进行校验，通过MD5值比较
            FileInputStream mergeInputStream = new FileInputStream(file);
            String mergeMd5 = DigestUtils.md5DigestAsHex(mergeInputStream);
            if (!fileMd5.equals(mergeMd5)) {
                log.error("合并文件校验失败");
                return RestResponse.validfail("合并文件校验失败");
            }
            file.delete();
            // 将文件信息写入数据库
            MediaFiles mediaFiles = new MediaFiles();
            mediaFiles.setId(fileMd5);
            mediaFiles.setBucket(minIOConfigProperties.getBucket());
            mediaFiles.setFilePath(objectName);
            int insert = mediaFilesMapper.insert(mediaFiles);
            if (insert == 0) {
                return RestResponse.validfail();
            }
            return RestResponse.success();
        }
    
        /**
         * 从Minio中下载文件
         * @param file          目标文件
         * @param bucket        桶
         * @param objectName    桶内文件路径
         * @return
         */
        private File downloadFileFromMinio(File file, String bucket, String objectName) {
            try (FileOutputStream fileOutputStream = new FileOutputStream(file);
                 InputStream inputStream = minioClient.getObject(GetObjectArgs
                         .builder()
                         .bucket(bucket)
                         .object(objectName)
                         .build())) {
                IOUtils.copy(inputStream, fileOutputStream);
                return file;
            } catch (Exception e) {
                log.error("下载文件出错");
            }
            return null;
        }
        /**
         * minio存储路径以md5密文前两个数字做目录
         * @param fileMd5
         * @return
         */
        private String getChunkFileFolderPath(String fileMd5) {
            return fileMd5.substring(0, 1) + "/" + fileMd5.substring(1, 2) + "/" + fileMd5 + "/" + "chunk" + "/";
        }
    
        /**
         * 合并后完整视频路径
         * @param fileMd5
         * @param fileExt
         * @return
         */
        private String getFilePathByMd5(String fileMd5, String fileExt) {
            return fileMd5.substring(0, 1) + "/" + fileMd5.substring(1, 2) + "/" + fileMd5 + "/" + fileMd5 + fileExt;
        }
    }

## 总结 ##

了解更多可以查看这篇文章：[后端视频大文件分片处理-CSDNzhe][-CSDN]

在我看来**，****断点续传的重点不是合并，反而是对文件和分片是否存在的检查，因为这个检查才体现了断点续传的理念。**

> **值得注意的是：**
> 
> 1.  **在整个流程中，前端负责了对大文件流的md5加密****并发送给后端，还对****大文件进行了分片处理****。**
> 2.  **使用minio提供的sdk合并的话，****分片文件必须为5m大小****。否则只能自行用临时文件的方式合并。**

[SpringBoot_MinIO_-CSDN]: https://blog.csdn.net/weixin_58403235/article/details/134563289?spm=1001.2014.3001.5501
[-CSDN]: https://blog.csdn.net/weixin_58403235/article/details/134583836?spm=1001.2014.3001.5501
[i_breakpoint-transmission_minio_demo _gitee.com]: https://gitee.com/sixII-flowers/breakpoint-transmission_minio_demo
[a0b0bb25e967456fbd5446c29cbcabc7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/9df56b64752f40f2b8b7d7bb6f814d94.png
[f705498ab25c4e2e92dc2e7ae448e9d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/9cff0372dba34ab783ab0fab8b741684.png