基于SpringBoot和WebUploader实现大文件分片上传.断点续传.秒传

已于 2022-06-15 21:33:08 修改
阅读量491 收藏 5
点赞数
分类专栏： spring 文章标签： spring boot java 前端
于 2022-06-15 21:32:12 首次发布
原文链接：https://blog.csdn.net/fly910905/article/details/114284285
版权

参考地址

什么是分片上传？

我们文件项目中涉及到文件上传的业务，如果文件上传过大，一下子网络断开了，还要重新上传，那不就G了，严重降低客户的使用效率和使用体验感。这个时候，我们可以 把文件分成一块一块的，每次上传一块，中途网络断开了我们还能够从上传了的最后一块的下一块开始继续上传，这样就能够保证客户的使用体验。

使用场景

  • 网络环境不好的情况下
  • 大文件上传的情况下

什么是WebUploader？

WebUploader是由Baidu WebFE(FEX)团队开发的一个简单的以HTML5为主，FLASH为辅的现代文件上传组件。在现代的浏览器里面能充分发挥HTML5的优势，同时又不摒弃主流IE浏览器，沿用原来的FLASH运行时，兼容IE6+，iOS 6+, android 4+。两套运行时，同样的调用方式，可供用户任意选用。

采用大文件分片并发上传，极大的提高了文件上传效率。

WebUploader地址
github源码地址
在这里插入图片描述

前端上传的html代码

<html>
<head>
    <meta charset="utf-8">
    <title>BigFile-WebUploader</title>
    <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css">
    <link rel="stylesheet" href="css/webuploader.css">
 
    <script type="text/javascript" src="http://cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
    <script type="text/javascript" src="https://cdn.bootcss.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
    <script type="text/javascript" src="js/webuploader.js"></script>
</head>
<body>
<div id="uploader" class="wu-example">
    <div id="thelist" class="uploader-list"></div>
    <div class="btns">
        <div id="picker">选择大文件</div>
        <button id="ctlBtn" class="btn btn-default">开始上传</button>
        <button id="stopBtn" class="btn btn-default">暂停</button>
        <button id="restart" class="btn btn-default">开始</button>
    </div>
</div>
</body>
<!--业务js文件-->
<script>
    var $btn = $('#ctlBtn');
    var $thelist = $('#thelist');
    var startDate;
    // HOOK 这个必须要再uploader实例化前面
    WebUploader.Uploader.register({
        // 在文件发送之前执行
        'before-send-file': 'beforeSendFile',
        // 在文件分片（如果没有启用分片，整个文件被当成一个分片）后，上传之前执行
        'before-send': 'beforeSend',
        // 在文件所有分片都上传完后，且服务端没有错误返回后执行
        "after-send-file": "afterSendFile"
    }, {
        beforeSendFile: function (file) {
            startDate = new Date();
            console.log("开始上传时间" + startDate)
            console.log("beforeSendFile");
            // Deferred对象在钩子回掉函数中经常要用到，用来处理需要等待的异步操作。
            var deferred = WebUploader.Deferred();
            //1、计算文件的唯一标记MD5，用于断点续传
            uploader.md5File(file, 0, 3 * 1024 * 1024).progress(function (percentage) {
                // 上传进度
                console.log('上传进度:', percentage);
                getProgressBar(file, percentage, "MD5", "MD5");
            }).then(function (val) { // 完成
                console.log('File MD5 Result:', val);
                file.md5 = val;
                file.uid = WebUploader.Base.guid();
                // 判断文件是否上传过，是否存在分片，断点续传
                $.ajax({
                    type: "POST",
                    url: "bigfile/check",
                    async: false,
                    data: {
                        fileMd5: val
                    },
                    success: function (data) {
                        var resultCode = data.resultCode;
                        // 秒传
                        if(resultCode == -1){
                            // 文件已经上传过,忽略上传过程，直接标识上传成功；
                            uploader.skipFile(file);
                            file.pass = true;
                        }else{
                            //文件没有上传过，下标为0
                            //文件上传中断过，返回当前已经上传到的下标
                            file.indexcode = resultCode;
                        }
                    }, error: function () {
 
                    }
                });
                //获取文件信息后进入下一步
                deferred.resolve();
            });
            return deferred.promise();
        },
        beforeSend: function (block) {
            //获取已经上传过的下标
            var indexchunk = block.file.indexcode;
            var deferred = WebUploader.Deferred();
            if (indexchunk > 0) {
                if (block.chunk > indexchunk) {
                    //分块不存在，重新发送该分块内容
                    deferred.resolve();
                } else {
                    //分块存在，跳过
                    deferred.reject();
                }
            } else {
                //分块不存在，重新发送该分块内容
                deferred.resolve();
            }
            //返回Deferred的Promise对象。
            return deferred.promise();
        }
        , afterSendFile: function (file) {
            //如果所有分块上传成功，则通知后台合并分块
            $.ajax({
                type: "POST",
                url: "bigfile/merge",
                data: {
                    fileName: file.name,
                    fileMd5: file.md5
                },
                success: function (data) {
 
                }, error: function () {
 
                }
            });
        }
    });
 
    // 实例化
    var uploader = WebUploader.create({
        pick: {
            id: '#picker',
            label: '点击选择文件'
        },
        duplicate: true,//去重， 根据文件名字、文件大小和最后修改时间来生成hash Key
        swf: 'js/Uploader.swf',
        chunked: true,
        chunkSize: 10 * 1024 * 1024, // 10M 每个分片的大小限制
        threads: 3,
        server: 'bigfile/upload',
        auto: true,
        // 禁掉全局的拖拽功能。这样不会出现图片拖进页面的时候，把图片打开。
        disableGlobalDnd: true,
        fileNumLimit: 1024,
        fileSizeLimit: 50 * 1024 * 1024 * 1024,//50G 验证文件总大小是否超出限制, 超出则不允许加入队列
        fileSingleSizeLimit: 10 * 1024 * 1024 * 1024 //10G 验证单个文件大小是否超出限制, 超出则不允许加入队列
    });
 
    // 当有文件被添加进队列的时候
    uploader.on('fileQueued', function (file) {
        $thelist.append('<div id="' + file.id + '" class="item">' +
            '<h4 class="info">' + file.name + '</h4>' +
            '<p class="state">等待上传...</p>' +
            '</div>');
        $("#stopBtn").click(function () {
            uploader.stop(true);
        });
        $("#restart").click(function () {
            uploader.upload(file);
        });
    });
 
    //当某个文件的分块在发送前触发，主要用来询问是否要添加附带参数，大文件在开起分片上传的前提下此事件可能会触发多次。
    uploader.onUploadBeforeSend = function (obj, data) {
        //console.log("onUploadBeforeSend");
        var file = obj.file;
        data.md5 = file.md5 || '';
        data.uid = file.uid;
    };
    // 上传中
    uploader.on('uploadProgress', function (file, percentage) {
        getProgressBar(file, percentage, "FILE", "上传进度");
    });
    // 上传返回结果
    uploader.on('uploadSuccess', function (file) {
        var endDate = new Date();
        console.log("文件上传耗时:" + (endDate - startDate) / 1000 + "s")
        var text = '已上传';
        if (file.pass) {
            text = "文件妙传功能，文件已上传。"
        }
        $('#' + file.id).find('p.state').text(text);
    });
    uploader.on('uploadError', function (file) {
        $('#' + file.id).find('p.state').text('上传出错');
    });
    uploader.on('uploadComplete', function (file) {
        // 隐藏进度条
        fadeOutProgress(file, 'MD5');
        fadeOutProgress(file, 'FILE');
    });
    // 文件上传
    $btn.on('click', function () {
        uploader.upload();
    });
 
    /**
     *  生成进度条封装方法
     * @param file 文件
     * @param percentage 进度值
     * @param id_Prefix id前缀
     * @param titleName 标题名
     */
    function getProgressBar(file, percentage, id_Prefix, titleName) {
        var $li = $('#' + file.id), $percent = $li.find('#' + id_Prefix + '-progress-bar');
        // 避免重复创建
        if (!$percent.length) {
            $percent = $('<div id="' + id_Prefix + '-progress" class="progress progress-striped active">' +
                '<div id="' + id_Prefix + '-progress-bar" class="progress-bar" role="progressbar" style="width: 0%">' +
                '</div>' +
                '</div>'
            ).appendTo($li).find('#' + id_Prefix + '-progress-bar');
        }
        var progressPercentage = parseInt(percentage * 100) + '%';
        $percent.css('width', progressPercentage);
        $percent.html(titleName + ':' + progressPercentage);
    }
 
 
    /**
     * 隐藏进度条
     * @param file 文件对象
     * @param id_Prefix id前缀
     */
    function fadeOutProgress(file, id_Prefix) {
        $('#' + file.id).find('#' + id_Prefix + '-progress').fadeOut();
    }
</script>
</html>

后端代码

import org.springframework.web.multipart.MultipartFile;
 
 
public class MultipartFileParam {
    // 用户id
    private String uid;
    //任务ID
    private String id;
    //总分片数量
    private int chunks;
    //当前为第几块分片
    private int chunk;
    //当前分片大小
    private long size = 0L;
    //文件名
    private String name;
    //分片对象
    private MultipartFile file;
    // MD5
    private String md5;
 
    public String getUid() {
        return uid;
    }
 
    public void setUid(String uid) {
        this.uid = uid;
    }
 
    public String getId() {
        return id;
    }
 
    public void setId(String id) {
        this.id = id;
    }
 
    public int getChunks() {
        return chunks;
    }
 
    public void setChunks(int chunks) {
        this.chunks = chunks;
    }
 
    public int getChunk() {
        return chunk;
    }
 
    public void setChunk(int chunk) {
        this.chunk = chunk;
    }
 
    public long getSize() {
        return size;
    }
 
    public void setSize(long size) {
        this.size = size;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public MultipartFile getFile() {
        return file;
    }
 
    public void setFile(MultipartFile file) {
        this.file = file;
    }
 
    public String getMd5() {
        return md5;
    }
 
    public void setMd5(String md5) {
        this.md5 = md5;
    }
 
    @Override
    public String toString() {
        return "MultipartFileParam{" +
                "uid='" + uid + '\'' +
                ", id='" + id + '\'' +
                ", chunks=" + chunks +
                ", chunk=" + chunk +
                ", size=" + size +
                ", name='" + name + '\'' +
                ", file=" + file +
                ", md5='" + md5 + '\'' +
                '}';
    }
}

public class JsonResult<T> {
    private int resultCode;
    private String resultMsg;
    private Object resultData;
 
    public JsonResult() {
    }
 
    public JsonResult(int resultCode, String resultMsg, Object resultData) {
        this.resultCode = resultCode;
        this.resultMsg = resultMsg;
        this.resultData = resultData;
    }
 
    public int getResultCode() {
        return this.resultCode;
    }
 
    public void setResultCode(int resultCode) {
        this.resultCode = resultCode;
    }
 
    public String getResultMsg() {
        return this.resultMsg;
    }
 
    public void setResultMsg(String resultMsg) {
        this.resultMsg = resultMsg;
    }
 
    public Object getResultData() {
        return this.resultData;
    }
 
    public void setResultData(Object resultData) {
        this.resultData = resultData;
    }
}

contrller

import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.io.FileUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;
import java.util.*;
 
/**
 * @Title: 大文件上传
 * @ClassName: com.lovecyy.file.up.example3.controller.BreakPointController.java
 * @Description: 断点续传.秒传.分块上传
 *
 * @Copyright 2020-2021  - Powered By 研发中心
 */
@Controller
@RequestMapping(value = "/bigfile")
public class BigFileController {
 
    private Logger logger = LoggerFactory.getLogger(BigFileController.class);
 
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
 
    @Value("${breakpoint.upload.dir}")
    private String fileStorePath;
 
    /**
     * @Title: 判断文件是否上传过，是否存在分片，断点续传
     * @MethodName:  checkBigFile
     * @param fileMd5
     * @Return com.lovecyy.file.up.example3.vo.JsonResult
     * @Exception
     * @Description:
     *  文件已存在，下标为-1
     *  文件没有上传过，下标为零
     *  文件上传中断过，返回当前已经上传到的下标
     */
    @RequestMapping(value = "/check", method = RequestMethod.POST)
    @ResponseBody
    public JsonResult checkBigFile(String fileMd5) {
 
        JsonResult jr =  new JsonResult();
        // 秒传
        File mergeMd5Dir = new File(fileStorePath + "/" + "merge"+ "/" + fileMd5);
        if(mergeMd5Dir.exists()){
            mergeMd5Dir.mkdirs();
            jr.setResultCode(-1);//文件已存在，下标为-1
            return jr;
        }
 
        // 读取目录里的所有文件
        File dir = new File(fileStorePath + "/" + fileMd5);
        File[] childs = dir.listFiles();
        if(childs==null){
            jr.setResultCode(0);//文件没有上传过，下标为零
        }else{
            jr.setResultCode(childs.length-1);//文件上传中断过，返回当前已经上传到的下标
        }
        return  jr;
    }
    /**
     * 上传文件
     *
     * @param param
     * @param request
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "/upload", method = RequestMethod.POST)
    @ResponseBody
    public void filewebUpload(MultipartFileParam param, HttpServletRequest request) {
        boolean isMultipart = ServletFileUpload.isMultipartContent(request);
        // 文件名
        String fileName = param.getName();
        // 文件每次分片的下标
        int chunkIndex = param.getChunk();
        if (isMultipart) {
            File file = new File(fileStorePath + "/" + param.getMd5());
            if (!file.exists()) {
                file.mkdir();
            }
            File chunkFile = new File(
                    fileStorePath + "/" +  param.getMd5() + "/" + chunkIndex);
            try{
                FileUtils.copyInputStreamToFile(param.getFile().getInputStream(), chunkFile);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        logger.info("文件-:{}的小标-:{},上传成功",fileName,chunkIndex);
        return;
    }
 
    /**
     * 分片上传成功之后，合并文件
     * @param request
     * @return
     */
    @RequestMapping(value = "/merge", method = RequestMethod.POST)
    @ResponseBody
    public JsonResult filewebMerge(HttpServletRequest request) {
        FileChannel outChannel = null;
        try {
            String fileName = request.getParameter("fileName");
            String fileMd5 = request.getParameter("fileMd5");
            // 读取目录里的所有文件
            File dir = new File(fileStorePath + "/" + fileMd5);
            File[] childs = dir.listFiles();
            if(Objects.isNull(childs)|| childs.length==0){
                return null;
            }
            // 转成集合，便于排序
            List<File> fileList = new ArrayList<File>(Arrays.asList(childs));
            Collections.sort(fileList, new Comparator<File>() {
                @Override
                public int compare(File o1, File o2) {
                    if (Integer.parseInt(o1.getName()) < Integer.parseInt(o2.getName())) {
                        return -1;
                    }
                    return 1;
                }
            });
            // 合并后的文件
            File outputFile = new File(fileStorePath + "/" + "merge"+ "/" + fileMd5 + "/" + fileName);
            // 创建文件
            if(!outputFile.exists()){
                File mergeMd5Dir = new File(fileStorePath + "/" + "merge"+ "/" + fileMd5);
                if(!mergeMd5Dir.exists()){
                    mergeMd5Dir.mkdirs();
                }
                logger.info("创建文件");
                outputFile.createNewFile();
            }
            outChannel = new FileOutputStream(outputFile).getChannel();
            FileChannel inChannel = null;
            try {
                for (File file : fileList) {
                    inChannel = new FileInputStream(file).getChannel();
                    inChannel.transferTo(0, inChannel.size(), outChannel);
                    inChannel.close();
                    // 删除分片
                    file.delete();
                }
            }catch (Exception e){
                e.printStackTrace();
                //发生异常，文件合并失败 ，删除创建的文件
                outputFile.delete();
                dir.delete();//删除文件夹
            }finally {
                if(inChannel!=null){
                    inChannel.close();
                }
            }
            dir.delete(); //删除分片所在的文件夹
            // FIXME: 数据库操作, 记录文件存档位置
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(outChannel!=null){
                    outChannel.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return  null;
    }
}

配置文件

# Tomcat
server:
# 端口配置
  port: 8080
 
#开发环境
breakpoint:
  upload:
    # 文件上传的路径
    dir:  D:/workplace/uploads/

    #1024*1024=1 048 576,5M=5 242 880
    chunkSize: 5 242 880
北海冥鱼未眠
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
springboot整合plupload，实现文件批量上传、断点续传、秒传 源码
02-28
springboot2、plupload2.3.6整合，实现文件批量上传、断点续传、秒传，带进度条，idea、maven工程
springboot+webuploader 实现大文件切片上传，兼容IE8+,chrome等浏览器，附可运行代码
比胸罩更贴心的博客
11-09 3801
一、目标 主要解决在web端浏览器上传大文件问题，避免上传途中中断、卡死、jvm溢出等问题，支持进度条显示、秒传功能、多线程上传，兼容IE8+、chrome等主流浏览器 二、方案 前端借助百度提供的webuploader插件，对大文件计算MD5值并切成一个个小文件，多线程向后台上传；后台用springboot实现，根据MD5和接收的个数判断是否接收完毕，如果接收完毕进行后台合并操作。 三、前端部分...
bootstrap-fileinput分片上传
陈戏猿
04-10 1368
bootstrap-fileinput是基于bootstrap的文件上传插件，在5.0版本中新增了分片上传功能，注意，一定要大于等于5.0的版本才有分片上传的功能！对于需要上传大文件，但是NG网关又无法放开包大小限制的情况，就可以使用分片上传。 开启分片上传 使用分片上传功能需要在bootstrap-fileinput的初始化中加入以下配置： enableResumableUpload: true, resumableUploadOptions: { testUrl: "/site/test-file-c
plupload + SpringBoot 分块上传 + OSS分块上传记录
chuangtiliao4918的博客
05-25 935
最近重构项目前端用了 plupload 插件（后面贴上github地址），前端不愿改动，我想了几个方案， 一、plupload 分片上传到 SpringBoot 根目录，然后再用OSS分片上传，不推荐。 二、plupload 分片上传 直连 OSS分片上传。 三、前端直接上传。 第一种...
百度WebUploader中实现文件上传下载的三种解决方案(推荐)
Mr_Zang666的博客
05-24 1905
文件上传是一个老生常谈的话题了，在文件相对比较小的情况下，可以直接把文件转化为字节流上传到服务器，但在文件比较大的情况下，用普通的方式进行上传，这可不是一个好的办法，毕竟很少有人会忍受，当文件上传到一半中断后，继续上传却只能重头开始上传，这种让人不爽的体验。断点续传是在下载或上传时，将下载或上传任务（一个文件或一个压缩包）人为的划分为几个部分，每一个部分采用一个线程进行上传或下载，如果碰到网络故障，可以从已经上传或下载的部分开始继续上传或者下载未完成的部分，而没有必要从头开始上传或者下载。
SpringBoot WebUploader 分片上传
weixin_45525177的博客
05-28 222
这里只写后端的代码，基本的思想就是，前端将文件分片，然后每次访问上传接口的时候，向后端传入参数：当前为第几块文件，和分片总数 下面直接贴代码吧，一些难懂的我大部分都加上注释了： 上传文件实体类： 看得出来，实体类中已经有很多我们需要的功能了，还有实用的属性。如MD5秒传的信息。 首先是文件数据接收逻辑，负责接收控件上传的文件块数据，然后写到服务器的文件中。控件已经提供了块的索引，大小，MD5和长度信息，我们可以根据需要来灵活进行处理，也可以将文件块的数据保存到分布式存储系统中。 ..
Springboot+百度的WebUploader组件实现普通文件的批量上传
凡夫编程
03-13 1370
WebUploader是由Baidu WebFE(FEX)团队开发的一个简单的以HTML5为主，FLASH为辅的现代文件上传组件。可以充分发挥HTML5的优势，同时沿用原来的FLASH运行时，可以兼容IE6+。对于大文件，又实现了大文件分片并发上传，极大提高了文件的上传效率。WebUploader与其他上传组件相比最突出的功能特性就是可以实现大文件的分片上传，将一个大文件分割成多块，并发上传，极大地提高大文件的上传速度。当网络问题导致传输错误时，只需要重传出错分片，而不是整个文件。另外分片传输能够更加实时的
SpringBoot 中大文件（分片上传）断点续传与极速秒传功能的实现
08-18
SpringBoot 中大文件（分片上传）断点续传与极速秒传功能的实现 在本文中，我们将探讨如何在 SpringBoot 框架中实现大文件（分片上传）断点续传与极速秒传功能。该功能能够帮助用户快速上传大文件，提高上传效率和...
springboot+vue 大文件上传 包括断点续传 秒传 分片上传.zip
02-18
本项目"springboot+vue 大文件上传 包括断点续传 秒传 分片上传.zip"提供了一套完整的解决方案，针对大文件上传进行了优化，确保了上传的高效性和可靠性。 首先，我们来看SpringBoot的部分。SpringBoot是基于Spring...
Node + H5 实现大文件分片上传、断点续传.zip
03-03
在现代Web应用中，大文件上传和断点续传已经成为必不可少的功能，特别是在处理高清视频、大型文档等资源时。这个“Node + H5 实现大文件分片上传、断点续传.zip”压缩包文件提供了一个完整的解决方案，利用Node.js...
Spring Boot 利用WebUploader进行文件上传功能
08-27
本文的重点是给大家介绍在Spring Boot项目中利用WebUploader如何进行文件上传，本文通过示例代码给大家介绍，需要的朋友参考下吧
WebUploader文件秒传、断点继传.docx
05-31
对大文件可以先MD5判断服务器上是否已存在实现秒传功能，也可以对分片MD5验证服务器是否存在而实现断点续传。
分片上传附件
08-18
C# asp.net mvc 附件分片上传实例，供大家学习参考
php + webuploader实现超大文件上传分片上传断点续传(20g+)
10-15
php实现大文件上传分片上传断点续传, 本人测试2gb有效!!! 该项目核心就是文件分块上传。前后端要高度配合，需要双方约定好一些数据，才能完成大文件分块，我们在项目中要重点解决的以下问题。 * 如何分片； * 如何...
基于vue+elementui实现断点续传、分片上传、秒传.zip
最新发布
03-03
在现代Web应用开发中，文件上传是一个常见的功能需求，尤其对于大文件的处理，断点续传、分片上传和秒传技术变得尤为重要。本文将详细介绍如何使用Vue.js框架结合Element UI库来实现这些高级上传功能。 Vue.js是...
基于SpringBoot和WebUploader实现大文件分块上传.断点续传.秒传
weixin_45525177的博客
11-17 192
handler里面可以是同步过程，也可以是异步过程。通俗的说，你把要上传的东西上传，服务器会先做MD5校验，如果服务器上有一样的东西，它就直接给你个新地址，其实你下载的都是服务器上的同一个文件，想要不秒传，其实只要让MD5改变，就是对文件本身做一下修改（改名字不行），例如一个文本文件，你多加几个字，MD5就变了，就不会秒传了。分片上传，就是将所要上传的文件，按照一定的大小，将整个文件分隔成多个数据块（我们称之为Part）来进行分别上传，上传完之后再由服务端对所有上传的文件进行汇总整合成原始的文件。
Springboot+WebUploader优雅实现超大文件的分片上传(一)
凡夫编程
03-14 3506
在软件工程里，在处理“大”的时候一直是一个难点和难点，如并发大、数据量大、文件大，对硬件进行升级可以解决一些问题，但这并不最聪明的办法，而对于老板来说，这也不是成本最小的办法。作为开发人员来说，在面对类似极端的问题时，只可智取，不可硬刚，最大化利用好现有的资源，以更加优雅的办法来满足用户多样化的需求。今天的主题也是一个“大”的问题，就是大文件如何上传和下载？其实在解决这个问题之前，有一个问题是绕不过去的：什么才是大文件？几兆？几十兆？几百兆？这其实是一个极具争议的问题，在不同的业务场景下，对于大文件的“大”
Springboot+WebUploader优雅实现超大文件的分片上传(二)
凡夫编程
03-15 2504
在软件工程里，在处理“大”的时候一直是一个痛点和难点，如并发大、数据量大、文件大，对硬件进行升级可以解决一些问题，但这并不最聪明的办法，而对于老板来说，这也不是成本最小的办法。作为开发人员来说，在面对类似极端的问题时，只可智取，不可硬刚，最大化利用好手上现有的资源，以更加优雅的办法来满足用户多样化的需求才是王道。今天的主题也是一个“大”的问题，就是超大文件如何上传和下载？其实在解决这个问题之前，有一个问题是绕不过去的：什么才是大文件？什么是超大文件？几十兆？几百兆？还是几个G？这其实是一个极具争议的问题，在
springboot实现minio分片上传和断点续传
05-31
在Spring Boot中实现MinIO文件服务器的分片上传和断点续传，可以使用MinIO Java SDK提供的API和Spring Boot提供的Multipart File上传功能。具体实现步骤如下： 1. 引入MinIO Java SDK和Spring Boot的依赖 ```xml ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值