Spring Boot 大文件上传(断点上传)、服务端分片下载、客户端分片下载（断点下载）

已于 2022-07-15 14:46:51 修改
阅读量1.7k 收藏 20
点赞数 2
分类专栏： 案例 文章标签： java servlet 前端
于 2022-07-15 14:34:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34125999/article/details/125804077
版权

1 大文件上传（支持断点续传）

1.1 前端

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>upload</title>
    <link rel="stylesheet" type="text/css" href="webuploader.css">
    <script src="jquery.js"></script>
    <script src="webuploader.js"></script>

    <style>

        #upload-container {
            width: 500px;
            height: 500px;
            background: lightskyblue;
            padding-bottom: 10px;
        }
    </style>


</head>
<body>
<div id="upload-container">
    <span>文件拖拽上传</span>
</div>
<div id="upload-list"></div>


<button id="picker" style="margin-top: 50px">点击上传</button>
</body>
<script>
    $('#upload-container').click(function (event) {
        $("#picker").find('input').click();
    });
    //初始化上传组件
    const uploader = WebUploader.create({
        auto: true,
        swf: 'Uploader.swf', //swf文件路径
        server: 'http://localhost:9000/upload', //上传接口
        dnd: '#upload-container',
        pick: '#picker',  //内部根据当前运行创建
        multiple: true,     //选择多个
        chunked: true,      //开启分片
        threads: 20,        //并发数
        method: 'POST',
        fileSizeLimit: 1024 * 1024 * 1024 * 100, // 文件总大小为100G
        fileSingleSizeLimit: 1024 * 1024 * 1024 * 5,  //单个文件大小最大为1G
        fileVal: 'upload'
    });
    //入队之前触发事件
    uploader.on("beforeFileQueued", function (file) {
        console.log(file); //获取文件后缀
    });
    //入队触发事件
    uploader.on('fileQueued', function (file) {
        //选中文件要做的事
        console.log(file.ext);
        console.log(file.size);
        console.log(file.name);
        const html = '<div class="upload-item"><span>文件名：' + file.name + '</span><span data-file_id="' + file.id + '"class="btn-delete">删除</span><span data-file_id="' + file.id + '"class="btn-retry">重试</span><div class="percentage ' + file.id + '" style="width: 0%;"></div></div>';
        $('#upload-list').append(html);
        uploader.md5File(file)  //给文件定义唯一的md5值，当再次上传相同文件时，就不用传了  大文件秒传实际上是没传，直接拷贝之前文件地址
            //显示进度
            .progress(function (percentage) {
                console.log('Percentage:', percentage);
            })
            //完成
            .then(function (val) {
                console.log('md5 result', val);
            });
    });
</script>
</html>

1.2 后端

    /**
     * 上传文件
     */
    public void upload(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //获取ServletFileUpload
        ServletFileUpload servletFileUpload = getServletFileUpload();
        List<FileItem> items = servletFileUpload.parseRequest(request);
        //获取文件信息
        UploadFileInfoDto uploadFileInfoDto = getFileDataDto(items);
        //写临时文件
        writeTempFile(items, uploadFileInfoDto);
        //判断是否合并
        mergeFile(uploadFileInfoDto);
        //返回结果
        response.setCharacterEncoding(UTF_8);
        response.getWriter().write("上传成功");
    }

    private void mergeFile(UploadFileInfoDto uploadFileInfoDto) throws IOException, InterruptedException {
        Integer currentChunk = uploadFileInfoDto.getCurrentChunk();
        Integer chunks = uploadFileInfoDto.getChunks();
        //如果当前分片等于总分片那么合并文件
        if (currentChunk != null && chunks != null && currentChunk.equals(chunks - 1)) {
            File tempFile = new File(uploadPath, uploadFileInfoDto.getFileName());
            try (BufferedOutputStream os = new BufferedOutputStream(new FileOutputStream(tempFile))) {
                for (int i = 0; i < chunks; i++) {
                    File file = new File(uploadPath, i + "_" + uploadFileInfoDto.getFileName());
                    //并发情况 需要判断所有  因为可能最后一个分片传完，之前有的还没传完
                    while (!file.exists()) {
                        //不存在休眠100毫秒后在从新判断
                        Thread.sleep(100);
                    }
                    //分片存在  读入数组中
                    byte[] bytes = FileUtils.readFileToByteArray(file);
                    os.write(bytes);
                    os.flush();
                    file.delete();
                }
                os.flush();
            }
        }

    }

    private void writeTempFile(List<FileItem> items, UploadFileInfoDto uploadFileInfoDto) throws Exception {
        //取出文件基本信息后
        for (FileItem item : items) {
            if (!item.isFormField()) {
                //有分片需要临时目录
                String tempFileName = uploadFileInfoDto.getFileName();
                if (StringUtils.isNotBlank(tempFileName)) {
                    if (uploadFileInfoDto.getCurrentChunk() != null) {
                        tempFileName = uploadFileInfoDto.getCurrentChunk() + "_" + uploadFileInfoDto.getFileName();
                    }
                    //判断文件是否存在
                    File tempFile = new File(uploadPath, tempFileName);
                    //断点续传  判断文件是否存在，若存在则不传
                    if (!tempFile.exists()) {
                        item.write(tempFile);
                    }
                }
            }
        }
    }

    private UploadFileInfoDto getFileDataDto(List<FileItem> items) throws UnsupportedEncodingException {

        UploadFileInfoDto rs = new UploadFileInfoDto();
        for (FileItem item : items) {
            if (item.isFormField()) {
                //获取分片数赋值给遍量
                if ("chunk".equals(item.getFieldName())) {
                    rs.setCurrentChunk(Integer.parseInt(item.getString(UTF_8)));
                }
                if ("chunks".equals(item.getFieldName())) {
                    rs.setChunks(Integer.parseInt(item.getString(UTF_8)));
                }
                if ("name".equals(item.getFieldName())) {
                    rs.setFileName(item.getString(UTF_8));
                }
            }
        }
        return rs;
    }


    /**
     * 获取ServletFileUpload： High level API for processing file uploads
     */
    private ServletFileUpload getServletFileUpload() {
        //设置缓冲区大小  先读到内存里在从内存写
        DiskFileItemFactory factory = new DiskFileItemFactory();
        factory.setSizeThreshold(1024);
        factory.setRepository(new File(uploadPath));
        //解析
        ServletFileUpload upload = new ServletFileUpload(factory);
        //设置单个大小与最大大小
        upload.setFileSizeMax(5 * 1024 * 1024 * 1024L);
        upload.setSizeMax(100 * 1024 * 1024 * 1024L);
        return upload;

    }

1.3 测试

在这里插入图片描述
在这里插入图片描述

2 文件下载

2.1 HTTP Range 信息

Range 请求头： Range: bytes=start-end

Range: bytes=10- //：从第10个字节开始到最后一个字节的数据
Range：bytes=20-39 //：从第20个字节到第39个字节之间的数据

Content-Range 响应头 ：

#表示服务器返回了前（0-10）个字节的数据，总共3000字节的数据。
Content-Range:bytes 0-10/3000

Content-Length 资源的长度：

#表示服务器响应了11个字节的数据
Content-Length:11

2.2 代码

 public void download(HttpServletRequest request, HttpServletResponse response) throws IOException {

        //获取文件
        File file = new File(downloadFile);
        //获取下载文件信息
        DownloadFileInfoDto downloadFileInfoDto = getDownloadFileInfoDto(file.length(), request, response);
        //设置响应头
        setResponse(response, file.getName(), downloadFileInfoDto);
        //下载文件
        try (InputStream is = new BufferedInputStream(new FileInputStream(file));
             OutputStream os = new BufferedOutputStream(response.getOutputStream())) {
            //跳过已经读取文件
            is.skip(downloadFileInfoDto.getPos());
            byte[] buffer = new byte[1024];
            long sum = 0;
            //读取
            while (sum < downloadFileInfoDto.getRangeLength()) {
                int length = is.read(buffer, 0, (downloadFileInfoDto.getRangeLength() - sum) <= buffer.length ? (int) (downloadFileInfoDto.getRangeLength() - sum) : buffer.length);
                sum = sum + length;
                os.write(buffer, 0, length);
            }
        }

    }


    /**
     * 有两个map，我要去判断里面相同键的值一致不一致，除了双重for循环，有没有别的好办法
     */

    private DownloadFileInfoDto getDownloadFileInfoDto(long fSize, HttpServletRequest request, HttpServletResponse response) {
        long pos = 0;
        long last = fSize - 1;
        //前端需要分片下载
        if (request.getHeader("Range") != null) {
            response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);
            String numRange = request.getHeader("Range").replace("bytes=", "");
            String[] strRange = numRange.split("-");
            if (strRange.length == 2) {
                pos = Long.parseLong(strRange[0].trim());
                last = Long.parseLong(strRange[1].trim());
                //若结束字节超出文件大小 取文件大小
                if (last > fSize - 1) {
                    last = fSize - 1;
                }
            } else {
                //若只给一个长度  开始位置一直到结束
                pos = Long.parseLong(numRange.replace("-", "").trim());
            }
        }
        long rangeLength = last - pos + 1;
        String contentRange = "bytes " + pos + "-" + last + "/" + fSize;
        return new DownloadFileInfoDto(fSize, pos, last, rangeLength, contentRange);
    }


    /**
     * 设置响应头
     */
    private void setResponse(HttpServletResponse response, String fileName, DownloadFileInfoDto downloadFileInfoDto) throws UnsupportedEncodingException {
        response.setCharacterEncoding(UTF_8);
        response.setContentType("application/x-download");
        response.addHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, UTF_8));
        //支持分片下载
        response.setHeader("Accept-Range", "bytes");
        response.setHeader("fSize", String.valueOf(downloadFileInfoDto.getFSize()));
        response.setHeader("fName", fileName);
        //range响应头
        response.setHeader("Content-Range", downloadFileInfoDto.getContentRange());
        response.setHeader("Content-Length", String.valueOf(downloadFileInfoDto.getRangeLength()));
    }

2.3 测试

在这里插入图片描述

3 分片下载

3.1 CODE

  /**
     * 下载地址
     */
    @Value("${file.download-path}")
    private String downloadPath;


    /**
     * 分片下载每一片大小为5M
     */
    private static final Long PER_SLICE = 1024 * 1024 * 5L;


    /**
     * 定义分片下载线程池
     */
    private ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());


    /**
     * final string
     */
    private static final String RANGE = "Range";





	/**
     * 分片下载
     *
     * @param start 分片起始位置
     * @param end   分片结束位置
     * @param page  第几个分片, page=-1时是探测下载
     */
    private FileInfoDto sliceDownload(long start, long end, long page, String fName) throws IOException {

        //断点下载
        File file = new File(downloadPath, page + "-" + fName);
        //如果当前文件已经存在 并且不是探测任务 并且文件的长度等于分片的大小 那么不用下载当前文件
        if (file.exists() && page != -1 && file.length() == PER_SLICE) {
            return null;
        }
        //创建HttpClient
        HttpClient client = HttpClients.createDefault();
        HttpGet httpGet = new HttpGet("http://localhost:9000/download");
        httpGet.setHeader(RANGE, "bytes=" + start + "-" + end);
        HttpResponse httpResponse = client.execute(httpGet);
        String fSize = httpResponse.getFirstHeader("fSize").getValue();
        fName = URLDecoder.decode(httpResponse.getFirstHeader("fName").getValue(), UTF_8);
        HttpEntity entity = httpResponse.getEntity();
        //下载
        try (InputStream is = entity.getContent();
             FileOutputStream fos = new FileOutputStream(file)) {
            byte[] buffer = new byte[1024];
            int ch;
            while ((ch = is.read(buffer)) != -1) {
                fos.write(buffer, 0, ch);
            }
            fos.flush();
        }
        //判断是否是最后一个分片，如果是那么合并
        if (end - Long.parseLong(fSize) > 0) {
            mergeFile(fName, page);
        }

        return new FileInfoDto(Long.parseLong(fSize), fName);

    }

    private void mergeFile(String fName, long page) throws IOException {

        File file = new File(downloadPath, fName);

        try (BufferedOutputStream os = new BufferedOutputStream(new FileOutputStream(file))) {
            for (int i = 0; i <= page; i++) {
                File tempFile = new File(downloadPath, i + "-" + fName);
                //文件不存在或文件没写完
                while (!tempFile.exists() || (i != page && tempFile.length() < PER_SLICE)) {
                    Thread.sleep(100);
                }

                byte[] bytes = FileUtils.readFileToByteArray(tempFile);
                os.write(bytes);
                os.flush();
                tempFile.delete();
            }
            //删除探测文件
            File f = new File(downloadPath, "-1" + "-null");
            if (f.exists()) {
                f.delete();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    public void sliceDownload() throws IOException {

        //探测下载，获取文件相关信息
        FileInfoDto fileInfoDto = sliceDownload(1, 10, -1, null);
        //如果不为空，执行分片下载
        if (fileInfoDto != null) {
            //计算有多少分片
            long pages = fileInfoDto.getFileSize() / PER_SLICE;
            //适配最后一个分片
            for (long i = 0; i <= pages; i++) {
                long start = i * PER_SLICE;
                long end = (i + 1) * PER_SLICE - 1;
                executorService.execute(new SliceDownloadRunnable(start, end, i, fileInfoDto.getFileName()));
            }
        }
    }


    private class SliceDownloadRunnable implements Runnable {

        private final long start;
        private final long end;
        private final long page;
        private final String fName;

        private SliceDownloadRunnable(long start, long end, long page, String fName) {
            this.start = start;
            this.end = end;
            this.page = page;
            this.fName = fName;
        }


        @Override
        public void run() {
            try {
                sliceDownload(start, end, page, fName);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

3.2 测试

在这里插入图片描述
在这里插入图片描述

PS: Gitee 地址

https://gitee.com/zhurongsheng/spring-file
响彻天堂丶
关注
  • 2
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
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
Springboot实现分片上传，分片下载（断点下载）
明平姚的博客
12-08 2429
Springboot分片上传，断点续传，分片下载，断点下载
FileSizeLimitExceededException的maximum permitted size of 1048576 bytes问题
shareve的博客
12-06 8764
org.apache.tomcat.util.http.fileupload.FileUploadBase$FileSizeLimitExceededException: The field fileName exceeds its maximum permitted size of 1048576 bytes. Spring Boot默认文件上传大小为2M。 很多网上的答案是：
Java实战：Spring Boot 实现超大文件上传
oandy0的博客
03-10 1162
本文将详细介绍如何在 Spring Boot 应用程序中实现超大文件上传的功能。我们将深入探讨 HTTP 协议中的多部分文件上传以及如何使用 Spring Boot 中的 `MultipartFile` 和 `CommonsMultipartResolver` 类来支持超大文件上传。
SpringBoot Java实现Http方式分片下载断点续传+实现H5大视频渐进式播放
qq_40021015的博客
03-31 1435
一、功能目的 SpringBoot 实现Http分片下载断点续传，从而实现H5页面的大视频播放问题，实现渐进式播放，每次只播放需要播放的内容就可以了，不需要加载整个文件到内存中； 二、Http分片下载断点续传实现 package com.unnet.yjs.controller.api.v1; import com.unnet.yjs.annotation.HttpMethod; import com.unnet.yjs.base.ContainerProperties; import com.unnet
HTTP方式文件分片断点下载
xcbeyond|疯狂源自梦想，技术成就辉煌
05-11 8037
前言 在进行大文件或网络带宽不是很好的情况下，分片断点下载就会显得很有必要，目前各大下载工具，如：迅雷，都是很好的支持分片断点下载功能的。本文就通过http方式进行文件分片断点下载，进行实战说明。 HTTP之Range 在开始之前有必要了解一下相关概念及原理，即：HTTP之Range，才能更好的理解分片断点下载的原理。 什么是Range Range是一个H...
java大文件(百M以上)的上传下载方法
weixin_45525177的博客
09-17 3344
核心原理： 该项目核心就是文件分块上传。前后端要高度配合，需要双方约定好一些数据，才能完成大文件分块，我们在项目中要重点解决的以下问题。 *如何分片； *如何合成一个文件； *中断了从哪个分片开始。 如何分，利用强大的js库，来减轻我们的工作，市场上已经能有关于大文件分块的轮子，虽然程序员的天性曾迫使我重新造轮子。但是因为时间的关系还有工作的关系，我只能罢休了。最后我选择了百度的WebUploader来实现前端所需。 如何合，在合之前，我们还得先解决一个问题，我们如何区分分块所属那个...
Vue+SpringBoot实现文件的分片下载
Tz.的博客
06-18 1487
文件的分片下载顾名思义就是将文件分成一片一片，每次请求只下载一片，最后将文件进行整合下载，目的是为了防止文件大的情况,出现系统崩溃。SpringBoot后端实现文件的分片。
SWFUpload使用指南
yangdonghhm的专栏
11-29 252
装载自：http://www.cnblogs.com/2050/archive/2012/08/29/2662932.html SWFUpload是一个flash和js相结合而成的文件上传插件，其功能非常强大。以前在项目中用过几次，但它的配置参数太多了，用过后就忘记怎么用了，到以后要用时又得到官网上看它的文档，真是太烦了。所以索性就把它的用法记录下来，也方便英语拙计的同学查看，利人利己...
前端实现断点下载
cxz
06-10 1643
当下载一个很大的文件时，如果下载到一半暂停，如果继续下载呢？断点下载就是解决这个问题的。所谓断点下载就是可以一部分一部分的下载，不用一次性把文件数据全部拿到。If-Range 请求头字段用来使得 Range 头字段在一定条件下起作用If-None-Match：如果ETag不匹配If-Match：如果ETag匹配 HTTP HEAD方法（因为安全策略，浏览器中通过XMLHttpRequest只能获取部分头部信息）请求资源的头部信息, 并且这些头部与 HTTP GET 方法请求时返回的一致。 该请求方法的一个使
webuploader插件坑及使用心得
热门推荐
一路奔跑94的博客
06-21 3万+
我在目前的公司做的项目要么是原生写法去做项目，要么就是vue+webpack做项目，但是vue这部分只是用了模板template，vue其他的都没用。有一个项目需要做上传图片的功能，老大扔给我一个插件-webuploader。然后上次做的现在需要改进重做一遍，所以我重新搞了一遍，顺便把踩得坑分享下来。1.webuploader和其他插件使用一样，有个webuploader.css，webuploa...
SpringCloud大文件分片断点上传实现原理
08-19
主要介绍了SpringCloud大文件分片断点上传实现原理,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springboot大文件分片上传下载控制
05-31
上传前端进行文件分片处理，调用后台上传分片后合并； 下载前端根据后台返回的文件大小分片传range bytes=stat-end后台根据值传回相应的流，前端获取完成后进行组装输出
SpringBoot分片上传Excel大文件，支持断点续传，EasyExcel处理百万级数据
07-05
前端Excel大文件file slice分片，md5校验文件完整性并作文件标识记录写入数据库，支持断点续传。文件上传完毕后，使用EasyExcel读取文件流，处理Excel数据写入数据库中，可处理百万级数据。项目完整，连接数据库即可...
java大文件上传、秒传、断点续传、分片功能实现demo
11-09
java大文件上传、秒传、断点续传、分片功能实现demo （两个项目第一个spring boot+mysql实现，第二个springboot+redis实现）
springboot+vue实现超大文件分片极速上传与下载完整前后端源码
10-31
基于springboot与vue.js开发的前后端分离的超大文件分片上传下载系统，拥有简洁漂亮的界面，实现了G级别文件极速上传下载，断点续传以及秒传功能
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 971
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
最新发布
m0_46053885的博客
04-27 925
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 892
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
spring boot 大文件分片上传
06-10
Spring Boot 大文件分片上传可以通过以下步骤来实现： 1. 前端将大文件进行分片，并使用 FormData 将分片文件上传至后端。 2. 后端使用 Spring Boot 框架，并结合 Spring MVC 模块来编写文件上传接口。 3. 在文件...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

响彻天堂丶

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

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

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

打赏作者

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

抵扣说明：

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

余额充值