使用MinIO文件存储系统【完成视频断点续传】业务逻辑

这篇具有很好参考价值的文章主要介绍了使用MinIO文件存储系统【完成视频断点续传】业务逻辑。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

视频上传

接口一:检查该视频/媒资文件是否已经上传完成

接口二:检查视频分块是否已经在minio中已经存在

接口三:上传分块文件到minio中(已经上传的分块会在接口二进行校验)

接口四:合并上传的分块文件保存文件合并后的文件信息


视频上传

视频上传流程图

minio 视频文件,在线教育项目,java,javascript,minio

接口一:检查该视频/媒资文件是否已经上传完成

首先:前端计算上传视频的MD5传递给后端,后端接收到MD5值之后,通过MD5到媒资管理表中查询是否存在该文件信息,如果存在并且从媒资管理表中获取这个文件存放在minio的位置,通过位置到minio分布式文件系统中查询文件是否存在,如果mysql媒资信息表和minio中的媒资文件都存在返回true,无需进行后续上传,如果不存在返回前端false用来。

controller层

    @ApiOperation(value = "文件上传前检查文件")
    @PostMapping("/upload/checkfile")
    public RestResponse<Boolean> checkfile(@RequestParam("fileMd5") String fileMd5) throws Exception {
        RestResponse<Boolean> booleanRestResponse = mediaFilesService.checkFile(fileMd5);
        return booleanRestResponse;
    }

 service层

接口:

    public RestResponse<Boolean> checkFile(String fileMd5);

实现类:

    /**
     * 通过md5值在数据库判断该文件是否存在
     * @param fileMd5 文件的md5
     * @return
     */
    @Override
    public RestResponse<Boolean> checkFile(String fileMd5) {
        MediaFiles mediaFiles = baseMapper.selectById(fileMd5);
        //说明在数据库中已经存在
        if (mediaFiles!=null){
            //检查在minio中是否存在
            //桶
            String bucket = mediaFiles.getBucket();
            //存储目录
            String filePath = mediaFiles.getFilePath();
            //文件流
            InputStream stream = null;
            try {
                stream = minioClient.getObject(GetObjectArgs.builder().bucket(bucket).object(filePath).build());
                if (stream!=null){
                    //return 文件已经存在
                    return RestResponse.success(true);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return RestResponse.success(false);
    }

接口二:检查视频分块是否已经在minio中已经存在

首先接收前端上传媒资文件所生成的md5和分块序号,通过文件的md5值和文件每一块的序号组成在minio中存储分块文件的位置,获取该位置的分块文件是否存在,如果存在返回true(说明该分块文件已经在此前完成过上传,无需再次上传),如果不存在返回false,说明该分块文件还未上传,重新上传这一块文件。

controller层(控制层)

    @ApiOperation(value = "分块文件上传前的检测")
    @PostMapping("/upload/checkchunk")
    public RestResponse<Boolean> checkchunk(@RequestParam("fileMd5") String fileMd5, @RequestParam("chunk") int chunk) throws Exception {
        RestResponse<Boolean> booleanRestResponse = mediaFilesService.checkChunk(fileMd5,chunk);
        return booleanRestResponse;
    }

 service层(业务逻辑层)

接口:

    public RestResponse<Boolean> checkChunk(String fileMd5, int chunkIndex);

接口实现类:

 /**
     * 检查分块是否已经存在
     * @param fileMd5  文件的md5
     * @param chunkIndex  分块序号
     * @return
     */
    @Override
    public RestResponse<Boolean> checkChunk(String fileMd5, int chunkIndex) {
        //获取所在的桶
        String bucket = BUCKET_VIDEO;
        //分块文件的路径
        String chunkFileFolderPath = getChunkFileFolderPath(fileMd5) + chunkIndex;

        //文件流
        InputStream inputStream = null;
        try {
            inputStream = minioClient.getObject(GetObjectArgs.builder().bucket(bucket).object(chunkFileFolderPath).build());
        } catch (Exception e) {
            e.printStackTrace();
            log.debug("分块不存在");
        }
        if (inputStream !=null){
            return RestResponse.success(true);
        }
        return RestResponse.success(false);
    }

接口三:上传分块文件到minio中(已经上传的分块会在接口二进行校验)

接收前端传来的分割好的5M文件和这个文件的分割序号以及完整文件的md5值,将文件在本地转储一下,进行上传,如果是用户原先上传一半停止了上传或者由于网络波动导致上传中断,下一次上传原先文件时会在接口二中判断原先文件的哪几块已经存在minio中,存在的分块无需再次上传,不存在的分块走上传分块文件接口进行上传分块文件。

controller层(控制层)

    @ApiOperation(value = "上传分块文件")
    @PostMapping("/upload/uploadchunk")
    public RestResponse uploadchunk(@RequestParam("file") MultipartFile file, @RequestParam("fileMd5") String fileMd5, @RequestParam("chunk") int chunk) throws Exception {
        System.out.println(fileMd5);
        System.out.println("分块文件序号:"+chunk);
        //创建临时文件
        File tempFile = File.createTempFile("minio", "temp");
        //上传的文件拷贝到临时文件
        file.transferTo(tempFile);
        //文件路径
        String absolutePath = tempFile.getAbsolutePath();

        RestResponse restResponse = mediaFilesService.uploadChunk(fileMd5, chunk, absolutePath);
        return restResponse;
    }

service(业务逻辑层)

接口:

    /**
     * @description 上传分块
     * @param fileMd5  文件md5
     * @param chunk  分块序号
     * @param  localfChunkFilePath 本地文件路径
     */
    public RestResponse uploadChunk(String fileMd5,int chunk,String localfChunkFilePath);

实现类:

@Override
    public RestResponse uploadChunk(String fileMd5, int chunk, String localfChunkFilePath) {
        //得到分块文件的路径
        String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
        //
        String chunkFilePath = chunkFileFolderPath + chunk;
        //得到文件类型
        String mimeType = getMimeType(null);
        //上传分块文件到minio
        boolean flag = false;
        try {
            flag = addMediaFilesToMinIO(localfChunkFilePath, mimeType, BUCKET_VIDEO, chunkFilePath);
        } catch (Exception e) {
            log.debug("上传分块文件:{},失败:{}",chunkFilePath,e.getMessage());
        }
        if (!flag){
            return RestResponse.validfail(false,"上传分块文件失败");
        }

        return RestResponse.success(true);
    }

上传文件的方法

    /**
     * @description 将文件写入minIO
     * @param localFilePath  文件地址
     * @param bucket  桶
     * @param objectName 对象名称
     */
    public boolean addMediaFilesToMinIO(String localFilePath,String mimeType,String bucket, String objectName) {
        try {
            UploadObjectArgs testbucket = UploadObjectArgs.builder()
                    .bucket(bucket)
                    .object(objectName)
                    .filename(localFilePath)
                    .contentType(mimeType)
                    .build();
            minioClient.uploadObject(testbucket);
            log.info("上传文件到minio成功,bucket:{},objectName:{}",bucket,objectName);
            System.out.println("上传成功");
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            log.error("上传文件到minio出错,bucket:{},objectName:{},错误原因:{}",bucket,objectName,e.getMessage(),e);
            XueChengPlusException.cast("上传文件到文件系统失败");
        }
        return false;
    }

接口四:合并上传的分块文件保存文件合并后的文件信息

当前端按照5M将文件切分好依次上传所有之后,会请求接口四(合并文件),后端接收原文件的md5值和上传文件的名称和分块总数,在业务层进行处理,

1:首先会通过md5值获取在minio中存储该文件的分块位置目录

2:通过接收到分块总数和存储分块的位置得到所有分块文件的存储的具体位置存放到集合中

3:通过位置路径调用minio的合并api,将文件合并。

4:将合并好的文件临时下载到本地获得合并文件的md5值和前端上传文件的md5进行比较

5:删除临时本地的临时文件,如果校验通过存储该文件的相关信息到mysql媒资表中

6:就是将minio中存储的分块文件给删除。

controller层

    @ApiOperation(value = "合并文件")
    @PostMapping("/upload/mergechunks")
    public RestResponse mergechunks(@RequestParam("fileMd5") String fileMd5, @RequestParam("fileName") String fileName, @RequestParam("chunkTotal") int chunkTotal) throws Exception {
        System.out.println(fileMd5);
        System.out.println(chunkTotal);
        Long companyId = 1232141425L;
        UploadFileParamsDto uploadFileParamsDto = new UploadFileParamsDto();
        uploadFileParamsDto.setFileType("001002");
        uploadFileParamsDto.setTags("课程视频");
        uploadFileParamsDto.setRemark("");
        uploadFileParamsDto.setFilename(fileName);
        return mediaFilesService.mergechunks(companyId,fileMd5,chunkTotal,uploadFileParamsDto);
    }

业务层

接口

    /**
     * @description 合并分块
     * @param companyId  机构id
     * @param fileMd5  文件md5
     * @param chunkTotal 分块总和
     * @param uploadFileParamsDto 文件信息
     */
    public RestResponse mergechunks(Long companyId,String fileMd5,int chunkTotal,UploadFileParamsDto uploadFileParamsDto);

实现类:

    @Override
    public RestResponse mergechunks(Long companyId, String fileMd5, int chunkTotal, UploadFileParamsDto uploadFileParamsDto) {
        //=====获取分块文件路径=====
        String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
        //组成将分块文件路径组成 List<ComposeSource>
        List<ComposeSource> sourceObjectList = Stream.iterate(0, i -> ++i)
                .limit(chunkTotal)
                .map(i -> ComposeSource.builder()
                        .bucket(BUCKET_VIDEO)
                        .object(chunkFileFolderPath.concat(Integer.toString(i)))
                        .build())
                .collect(Collectors.toList());
        //=====合并=====
        //文件名称
        String fileName = uploadFileParamsDto.getFilename();
        //文件扩展名
        String extName = fileName.substring(fileName.lastIndexOf("."));
        //合并文件路径
        String mergeFilePath = getFilePathByMd5(fileMd5, extName);
        try {
            //合并文件
            ObjectWriteResponse response = minioClient.composeObject(
                    ComposeObjectArgs.builder()
                            .bucket(BUCKET_VIDEO)
                            .object(mergeFilePath)
                            .sources(sourceObjectList)
                            .build());
            log.info("合并文件成功:{}",mergeFilePath);
        } catch (Exception e) {
            log.info("合并文件失败,fileMd5:{},异常:{}",fileMd5,e.getMessage(),e);
            return RestResponse.validfail(false, "合并文件失败。");
        }

        // ====验证md5====
        File minioFile = downloadFileFromMinIO(BUCKET_VIDEO,mergeFilePath);
        if(minioFile == null){
            log.debug("下载合并后文件失败,mergeFilePath:{}",mergeFilePath);
            return RestResponse.validfail(false, "下载合并后文件失败。");
        }

        try (InputStream newFileInputStream = new FileInputStream(minioFile)) {
            //minio上文件的md5值
            String md5Hex = DigestUtils.md5Hex(newFileInputStream);
            //比较md5值,不一致则说明文件不完整
            if(!fileMd5.equals(md5Hex)){
                return RestResponse.validfail(false, "文件合并校验失败,最终上传失败。");
            }
            //文件大小
            uploadFileParamsDto.setFileSize(minioFile.length());
        }catch (Exception e){
            log.debug("校验文件失败,fileMd5:{},异常:{}",fileMd5,e.getMessage(),e);
            return RestResponse.validfail(false, "文件合并校验失败,最终上传失败。");
        }finally {
            if(minioFile!=null){
                minioFile.delete();
            }
        }

        //文件入库
        currentProxy.addMediaFilesToDb(companyId,fileMd5,uploadFileParamsDto,BUCKET_VIDEO,mergeFilePath);
        //=====清除分块文件=====
        clearChunkFiles(chunkFileFolderPath,chunkTotal);
        return RestResponse.success(true);
    }

下载合并文件的方法

    /**
     * 从minio下载文件
     * @param bucket 桶
     * @param objectName 对象名称
     * @return 下载后的文件
     */
    public File downloadFileFromMinIO(String bucket,String objectName){
        //临时文件
        File minioFile = null;
        FileOutputStream outputStream = null;
        try{
            InputStream stream = minioClient.getObject(GetObjectArgs.builder()
                    .bucket(bucket)
                    .object(objectName)
                    .build());
            //创建临时文件
            minioFile=File.createTempFile("minio", ".merge");
            outputStream = new FileOutputStream(minioFile);
            IOUtils.copy(stream,outputStream);
            return minioFile;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

清楚分块文件的方法文章来源地址https://www.toymoban.com/news/detail-579564.html

 /**
     * 清除分块文件
     * @param chunkFileFolderPath 分块文件路径
     * @param chunkTotal 分块文件总数
     */
    /**
     * 清除分块文件
     * @param chunkFileFolderPath 分块文件路径
     * @param chunkTotal 分块文件总数
     */
    private void clearChunkFiles(String chunkFileFolderPath,int chunkTotal){

        try {
            List<DeleteObject> deleteObjects = Stream.iterate(0, i -> ++i)
                    .limit(chunkTotal)
                    .map(i -> new DeleteObject(chunkFileFolderPath.concat(Integer.toString(i))))
                    .collect(Collectors.toList());

            RemoveObjectsArgs removeObjectsArgs = RemoveObjectsArgs.builder().bucket(BUCKET_VIDEO).objects(deleteObjects).build();
            Iterable<Result<DeleteError>> results = minioClient.removeObjects(removeObjectsArgs);
            results.forEach(r->{
                DeleteError deleteError = null;
                try {
                    deleteError = r.get();
                } catch (Exception e) {
                    e.printStackTrace();
                    log.error("清楚分块文件失败,objectname:{}",deleteError.objectName(),e);
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
            log.error("清楚分块文件失败,chunkFileFolderPath:{}",chunkFileFolderPath,e);
        }
    }

到了这里,关于使用MinIO文件存储系统【完成视频断点续传】业务逻辑的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • SpringBoot整合minio实现断点续传、分片上传(附源码)

    在Web开发中,大文件的上传是必不可少的功能之一。本文将介绍如何使用SpringBoot整合minio实现一个简单的大文件上传网站。 项目下载 gitee:https://gitee.com/wusupweilgy/springboot-vue.git 前端:vue2、element-ui组件、axios 后端:springboot、minio、mybatis-plus、redis 断点续传 分片上传 前端显示

    2024年02月04日
    浏览(52)
  • Spring Boot实现HTTP大文件断点续传分片下载-大视频分段渐进式播放

    服务端如何将一个大视频文件做切分,分段响应给客户端,让浏览器可以渐进式地播放。 Spring Boot实现HTTP分片下载断点续传,从而实现H5页面的大视频播放问题,实现渐进式播放,每次只播放需要播放的内容就可以了,不需要加载整个文件到内存中。 文件的断点续传、文件多

    2024年02月14日
    浏览(74)
  • Spring Boot整合Minio实现上传凭证、分片上传、秒传和断点续传

    Spring Boot整合Minio后,前端的文件上传有两种方式: 文件上传到后端,由后端保存到Minio 这种方式好处是完全由后端集中管理,可以很好的做到、身份验证、权限控制、文件与处理等,并且可以做一些额外的业务逻辑,比如生成缩略图、提取元数据等。 缺点也很明显: 延迟时

    2024年02月04日
    浏览(48)
  • Spring-Boot实现HTTP大文件断点续传分片下载-大视频分段渐进式播放

    服务端如何将一个大视频文件做切分,分段响应给客户端,让浏览器可以渐进式地播放。 Spring Boot实现HTTP分片下载断点续传,从而实现H5页面的大视频播放问题,实现渐进式播放,每次只播放需要播放的内容就可以了,不需要加载整个文件到内存中。 文件的断点续传、文件多

    2024年02月11日
    浏览(55)
  • 对视频进行分块,断点续传

     分块测试 将视频分块成1mb一份的文件  将分块的视频重新合并

    2024年02月20日
    浏览(31)
  • Java文件断点续传

    断点续传实现思路:将大文件均分成几块后,每个线程分别处理一块数据的读取和写入。每次写入都要更新记录的日志文件,断网或暂定后重新开始传输时,根据日志文件的信息,可以接着读取写入数据,不用重头开始传输。

    2024年02月12日
    浏览(41)
  • Java实现文件断点续传

    文件断点续传代码 测试代码

    2024年03月09日
    浏览(41)
  • 前端文件上传(文件上传,分片上传,断点续传)

    普通文件上传 思路: 首先获取用户选择的文件对象,并将其添加到一个 FormData 对象中。然后,使用 axios 的 post 方法将 FormData 对象发送到服务器。在 then 和 catch 中,我们分别处理上传成功和失败的情况,并输出相应的信息。 需要注意,在使用 axios 进行文件上传时,必须将

    2024年02月22日
    浏览(42)
  • 1. 大文件上传如何断点续传

    文件分片 - 将文件分割成多个小块,以便于上传和管理。 计算文件以及分片文件的Hash值 - 生成唯一标识符 - 通过计算文件及其分片的Hash值来创建一个唯一的标识符。 上传分片 - 根据标识符判断分片文件上传状态 - 避免重复上传。 如果上传中断,下次上传时根据标识符跳过

    2024年04月22日
    浏览(33)
  • 【项目实战】大文件断点续传,搞起

    今天给大家分享的又是一篇实战文章,也是最近私活里遇到的,万能的互联网给了我办法,分享一下。 最近接到一个新的需求,需要上传 2G 左右的视频文件,用测试环境的 OSS 试了一下,上传需要十几分钟,再考虑到公司的资源问题,果断放弃该方案。 一提到大文件上传,

    2024年02月12日
    浏览(48)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包