devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用Spring Boot实现大文件断点续传及文件校验_springboot整合文件断点续传

作者：花生_TL007 | 2024-05-03 05:53:40

赞

踩

springboot整合文件断点续传

一、简介

随着互联网的快速发展，大文件的传输成为了互联网应用的重要组成部分。然而，由于网络不稳定等因素的影响，大文件的传输经常会出现中断的情况，这时要重新传输，导致传输效率低下。

为了解决这个问题，可以实现大文件的断点续传功能。断点续传功能可以在传输中断后继续传输，而不需要从头开始传输。这样可以大大提高传输的效率。

Spring Boot是一个快速开发的Java Web开发框架，可以帮助我们快速搭建一个Web应用程序。在Spring Boot中，我们可以很容易地实现大文件的断点续传功能。

本文将介绍如何使用Spring Boot实现大文件的断点续传功能。

二、Spring Boot实现大文件断点续传的原理

实现大文件的断点续传功能，需要在客户端和服务端都进行相应的实现。

实现示例1

服务端如何将一个大视频文件做切分，分段响应给客户端，让浏览器可以渐进式地播放。

Spring Boot实现HTTP分片下载断点续传，从而实现H5页面的大视频播放问题，实现渐进式播放，每次只播放需要播放的内容就可以了，不需要加载整个文件到内存中。

文件的断点续传、文件多线程并发下载（迅雷就是这么玩的）等。

  1.   <dependencyManagement>
  2.     <dependencies>
  3.       <dependency>
  4.         <groupId>cn.hutool</groupId>
  5.         <artifactId>hutool-bom</artifactId>
  6.         <version>5.8.18</version>
  7.         <type>pom</type>
  8.         <scope>import</scope>
  9.       </dependency>
  10.     </dependencies>
  11.   </dependencyManagement>
  12.  
  13.   <dependencies>
  14.     <dependency>
  15.       <groupId>cn.hutool</groupId>
  16.       <artifactId>hutool-core</artifactId>
  17.     </dependency>
  18.  
  19.     <dependency>
  20.       <groupId>org.projectlombok</groupId>
  21.       <artifactId>lombok</artifactId>
  22.       <optional>true</optional>
  23.     </dependency>
  24.   </dependencies>

代码实现

ResourceController

  1. package com.example.insurance.controller;
  2.  
  3. import javax.servlet.http.HttpServletRequest;
  4. import javax.servlet.http.HttpServletResponse;
  5.  
  6. import java.io.IOException;
  7. import java.nio.file.Files;
  8. import java.nio.file.Path;
  9. import java.nio.file.Paths;
  10. import java.util.List;
  11.  
  12. import com.example.insurance.common.ContentRange;
  13. import com.example.insurance.common.MediaContentUtil;
  14. import com.example.insurance.common.NioUtils;
  15. import lombok.extern.slf4j.Slf4j;
  16. import org.springframework.http.HttpHeaders;
  17. import org.springframework.http.HttpRange;
  18. import org.springframework.http.HttpStatus;
  19. import org.springframework.util.CollectionUtils;
  20. import org.springframework.util.StopWatch;
  21. import org.springframework.web.bind.annotation.GetMapping;
  22. import org.springframework.web.bind.annotation.PathVariable;
  23. import org.springframework.web.bind.annotation.RequestHeader;
  24. import org.springframework.web.bind.annotation.RequestMapping;
  25. import org.springframework.web.bind.annotation.RestController;
  26.  
  27. /**
  28.  * 内容资源控制器
  29.  */
  30. @SuppressWarnings("unused")
  31. @Slf4j
  32. @RestController("resourceController")
  33. @RequestMapping(path = "/resource")
  34. public class ResourceController {
  35.  
  36.     /**
  37.      * 获取文件内容
  38.      *
  39.      * @param fileName 内容文件名称
  40.      * @param response 响应对象
  41.      */
  42.     @GetMapping("/media/{fileName}")
  43.     public void getMedia(@PathVariable String fileName, HttpServletRequest request, HttpServletResponse response,
  44.                          @RequestHeader HttpHeaders headers) {
  45. //        printRequestInfo(fileName, request, headers);
  46.  
  47.         String filePath = MediaContentUtil.filePath();
  48.         try {
  49.             this.download(fileName, filePath, request, response, headers);
  50.         } catch (Exception e) {
  51.             log.error("getMedia error, fileName={}", fileName, e);
  52.         }
  53.     }
  54.  
  55.     /**
  56.      * 获取封面内容
  57.      *
  58.      * @param fileName 内容封面名称
  59.      * @param response 响应对象
  60.      */
  61.     @GetMapping("/cover/{fileName}")
  62.     public void getCover(@PathVariable String fileName, HttpServletRequest request, HttpServletResponse response,
  63.                          @RequestHeader HttpHeaders headers) {
  64. //        printRequestInfo(fileName, request, headers);
  65.  
  66.         String filePath = MediaContentUtil.filePath();
  67.         try {
  68.             this.download(fileName, filePath, request, response, headers);
  69.         } catch (Exception e) {
  70.             log.error("getCover error, fileName={}", fileName, e);
  71.         }
  72.     }
  73.  
  74.  
  75.     // ======= internal =======
  76.  
  77.     private static void printRequestInfo(String fileName, HttpServletRequest request, HttpHeaders headers) {
  78.         String requestUri = request.getRequestURI();
  79.         String queryString = request.getQueryString();
  80.         log.debug("file={}, url={}?{}", fileName, requestUri, queryString);
  81.         log.info("headers={}", headers);
  82.     }
  83.  
  84.     /**
  85.      * 设置请求响应状态、头信息、内容类型与长度 等。
  86.      * <pre>
  87.      * <a href="https://www.rfc-editor.org/rfc/rfc7233">
  88.      *     HTTP/1.1 Range Requests</a>
  89.      * 2. Range Units
  90.      * 4. Responses to a Range Request
  91.      *
  92.      * <a href="https://www.rfc-editor.org/rfc/rfc2616.html">
  93.      *     HTTP/1.1</a>
  94.      * 10.2.7 206 Partial Content
  95.      * 14.5 Accept-Ranges
  96.      * 14.13 Content-Length
  97.      * 14.16 Content-Range
  98.      * 14.17 Content-Type
  99.      * 19.5.1 Content-Disposition
  100.      * 15.5 Content-Disposition Issues
  101.      *
  102.      * <a href="https://www.rfc-editor.org/rfc/rfc2183">
  103.      *     Content-Disposition</a>
  104.      * 2. The Content-Disposition Header Field
  105.      * 2.1 The Inline Disposition Type
  106.      * 2.3 The Filename Parameter
  107.      * </pre>
  108.      *
  109.      * @param response     请求响应对象
  110.      * @param fileName     请求的文件名称
  111.      * @param contentType  内容类型
  112.      * @param contentRange 内容范围对象
  113.      */
  114.     private static void setResponse(
  115.             HttpServletResponse response, String fileName, String contentType,
  116.             ContentRange contentRange) {
  117.         // http状态码要为206：表示获取部分内容
  118.         response.setStatus(HttpStatus.PARTIAL_CONTENT.value());
  119.         // 支持断点续传，获取部分字节内容
  120.         // Accept-Ranges：bytes，表示支持Range请求
  121.         response.setHeader(HttpHeaders.ACCEPT_RANGES, ContentRange.BYTES_STRING);
  122.         // inline表示浏览器直接使用，attachment表示下载，fileName表示下载的文件名
  123.         response.setHeader(HttpHeaders.CONTENT_DISPOSITION,
  124.                 "inline;filename=" + MediaContentUtil.encode(fileName));
  125.         // Content-Range，格式为：[要下载的开始位置]-[结束位置]/[文件总大小]
  126.         // Content-Range: bytes 0-10/3103，格式为bytes 开始-结束/全部
  127.         response.setHeader(HttpHeaders.CONTENT_RANGE, contentRange.toContentRange());
  128.  
  129.         response.setContentType(contentType);
  130.         // Content-Length: 11，本次内容的大小
  131.         response.setContentLengthLong(contentRange.applyAsContentLength());
  132.     }
  133.  
  134.     /**
  135.      * <a href="https://www.jianshu.com/p/08db5ba3bc95">
  136.      *     Spring Boot 处理 HTTP Headers</a>
  137.      */
  138.     private void download(
  139.             String fileName, String path, HttpServletRequest request, HttpServletResponse response,
  140.             HttpHeaders headers)
  141.             throws IOException {
  142.         Path filePath = Paths.get(path + fileName);
  143.         if (!Files.exists(filePath)) {
  144.             log.warn("file not exist, filePath={}", filePath);
  145.             return;
  146.         }
  147.         long fileLength = Files.size(filePath);
  148. //        long fileLength2 = filePath.toFile().length() - 1;
  149. //        // fileLength=1184856, fileLength2=1184855
  150. //        log.info("fileLength={}, fileLength2={}", fileLength, fileLength2);
  151.  
  152.         // 内容范围
  153.         ContentRange contentRange = applyAsContentRange(headers, fileLength, request);
  154.  
  155.         // 要下载的长度
  156.         long contentLength = contentRange.applyAsContentLength();
  157.         log.debug("contentRange={}, contentLength={}", contentRange, contentLength);
  158.  
  159.         // 文件类型
  160.         String contentType = request.getServletContext().getMimeType(fileName);
  161.         // mimeType=video/mp4, CONTENT_TYPE=null
  162.         log.debug("mimeType={}, CONTENT_TYPE={}", contentType, request.getContentType());
  163.  
  164.         setResponse(response, fileName, contentType, contentRange);
  165.  
  166.         // 耗时指标统计
  167.         StopWatch stopWatch = new StopWatch("downloadFile");
  168.         stopWatch.start(fileName);
  169.         try {
  170.             // case-1.参考网上他人的实现
  171. //            if (fileLength >= Integer.MAX_VALUE) {
  172. //                NioUtils.copy(filePath, response, contentRange);
  173. //            } else {
  174. //                NioUtils.copyByChannelAndBuffer(filePath, response, contentRange);
  175. //            }
  176.  
  177.             // case-2.使用现成API
  178.             NioUtils.copyByBio(filePath, response, contentRange);
  179. //            NioUtils.copyByNio(filePath, response, contentRange);
  180.  
  181.             // case-3.视频分段渐进式播放
  182. //            if (contentType.startsWith("video")) {
  183. //                NioUtils.copyForBufferSize(filePath, response, contentRange);
  184. //            } else {
  185. //                // 图片、PDF等文件
  186. //                NioUtils.copyByBio(filePath, response, contentRange);
  187. //            }
  188.         } finally {
  189.             stopWatch.stop();
  190.             log.info("download file, fileName={}, time={} ms", fileName, stopWatch.getTotalTimeMillis());
  191.         }
  192.     }
  193.  
  194.     private static ContentRange applyAsContentRange(
  195.             HttpHeaders headers, long fileLength, HttpServletRequest request) {
  196.         /*
  197.          * 3.1. Range - HTTP/1.1 Range Requests
  198.          * https://www.rfc-editor.org/rfc/rfc7233#section-3.1
  199.          * Range: "bytes" "=" first-byte-pos "-" [ last-byte-pos ]
  200.          *
  201.          * For example:
  202.          * bytes=0-
  203.          * bytes=0-499
  204.          */
  205.         // Range：告知服务端，客户端下载该文件想要从指定的位置开始下载
  206.         List<HttpRange> httpRanges = headers.getRange();
  207.  
  208.         String range = request.getHeader(HttpHeaders.RANGE);
  209.         // httpRanges=[], range=null
  210.         // httpRanges=[448135688-], range=bytes=448135688-
  211.         log.debug("httpRanges={}, range={}", httpRanges, range);
  212.  
  213.         // 开始下载位置
  214.         long firstBytePos;
  215.         // 结束下载位置
  216.         long lastBytePos;
  217.         if (CollectionUtils.isEmpty(httpRanges)) {
  218.             firstBytePos = 0;
  219.             lastBytePos = fileLength - 1;
  220.         } else {
  221.             HttpRange httpRange = httpRanges.get(0);
  222.             firstBytePos = httpRange.getRangeStart(fileLength);
  223.             lastBytePos = httpRange.getRangeEnd(fileLength);
  224.         }
  225.         return new ContentRange(firstBytePos, lastBytePos, fileLength);
  226.     }
  227. }
  228.

NioUtils

  1. package com.example.insurance.common;
  2.  
  3. import javax.servlet.http.HttpServletResponse;
  4. import java.io.BufferedOutputStream;
  5. import java.io.InputStream;
  6. import java.io.OutputStream;
  7. import java.io.RandomAccessFile;
  8. import java.nio.MappedByteBuffer;
  9. import java.nio.channels.Channels;
  10. import java.nio.channels.FileChannel;
  11. import java.nio.file.Path;
  12. import java.nio.file.StandardOpenOption;
  13.  
  14. import cn.hutool.core.io.IORuntimeException;
  15. import cn.hutool.core.io.IoUtil;
  16. import cn.hutool.core.io.NioUtil;
  17. import cn.hutool.core.io.StreamProgress;
  18. import cn.hutool.core.io.unit.DataSize;
  19. import lombok.extern.slf4j.Slf4j;
  20. import org.apache.catalina.connector.ClientAbortException;
  21.  
  22. /**
  23.  * NIO相关工具封装，主要针对Channel读写、拷贝等封装
  24.  */
  25. @Slf4j
  26. public final class NioUtils {
  27.  
  28.     /**
  29.      * 缓冲区大小 16KB
  30.      *
  31.      * @see NioUtil#DEFAULT_BUFFER_SIZE
  32.      * @see NioUtil#DEFAULT_LARGE_BUFFER_SIZE
  33.      */
  34. //    private static final int BUFFER_SIZE = NioUtil.DEFAULT_MIDDLE_BUFFER_SIZE;
  35.     private static final int BUFFER_SIZE = (int) DataSize.ofKilobytes(16L).toBytes();
  36.  
  37.     /**
  38.      * <pre>
  39.      * <a href="https://blog.csdn.net/qq_32099833/article/details/109703883">
  40.      *     Java后端实现视频分段渐进式播放</a>
  41.      * 服务端如何将一个大的视频文件做切分，分段响应给客户端，让浏览器可以渐进式地播放。
  42.      * 文件的断点续传、文件多线程并发下载（迅雷就是这么玩的）等。
  43.      *
  44.      * <a href="https://blog.csdn.net/qq_32099833/article/details/109630499">
  45.      *     大文件分片上传前后端实现</a>
  46.      * </pre>
  47.      */
  48.     public static void copyForBufferSize(
  49.             Path filePath, HttpServletResponse response, ContentRange contentRange) {
  50.         String fileName = filePath.getFileName().toString();
  51.  
  52.         RandomAccessFile randomAccessFile = null;
  53.         OutputStream outputStream = null;
  54.         try {
  55.             // 随机读文件
  56.             randomAccessFile = new RandomAccessFile(filePath.toFile(), "r");
  57.             // 移动访问指针到指定位置
  58.             randomAccessFile.seek(contentRange.getStart());
  59.  
  60.             // 注意：缓冲区大小 2MB，视频加载正常；1MB时有部分视频加载失败
  61.             int bufferSize = BUFFER_SIZE;
  62.  
  63.             //获取响应的输出流
  64.             outputStream = new BufferedOutputStream(response.getOutputStream(), bufferSize);
  65.  
  66.             // 每次请求只返回1MB的视频流
  67.             byte[] buffer = new byte[bufferSize];
  68.             int len = randomAccessFile.read(buffer);
  69.             //设置此次相应返回的数据长度
  70.             response.setContentLength(len);
  71.             // 将这1MB的视频流响应给客户端
  72.             outputStream.write(buffer, 0, len);
  73.  
  74.             log.info("file download complete, fileName={}, contentRange={}",
  75.                     fileName, contentRange.toContentRange());
  76.         } catch (ClientAbortException | IORuntimeException e) {
  77.             // 捕获此异常表示用户停止下载
  78.             log.warn("client stop file download, fileName={}", fileName);
  79.         } catch (Exception e) {
  80.             log.error("file download error, fileName={}", fileName, e);
  81.         } finally {
  82.             IoUtil.close(outputStream);
  83.             IoUtil.close(randomAccessFile);
  84.         }
  85.     }
  86.  
  87.     /**
  88.      * 拷贝流，拷贝后关闭流。
  89.      *
  90.      * @param filePath     源文件路径
  91.      * @param response     请求响应
  92.      * @param contentRange 内容范围
  93.      */
  94.     public static void copyByBio(
  95.             Path filePath, HttpServletResponse response, ContentRange contentRange) {
  96.         String fileName = filePath.getFileName().toString();
  97.  
  98.         InputStream inputStream = null;
  99.         OutputStream outputStream = null;
  100.         try {
  101.             RandomAccessFile randomAccessFile = new RandomAccessFile(filePath.toFile(), "r");
  102.             randomAccessFile.seek(contentRange.getStart());
  103.  
  104.             inputStream = Channels.newInputStream(randomAccessFile.getChannel());
  105.             outputStream = new BufferedOutputStream(response.getOutputStream(), BUFFER_SIZE);
  106.  
  107.             StreamProgress streamProgress = new StreamProgressImpl(fileName);
  108.  
  109.             long transmitted = IoUtil.copy(inputStream, outputStream, BUFFER_SIZE, streamProgress);
  110.             log.info("file download complete, fileName={}, transmitted={}", fileName, transmitted);
  111.         } catch (ClientAbortException | IORuntimeException e) {
  112.             // 捕获此异常表示用户停止下载
  113.             log.warn("client stop file download, fileName={}", fileName);
  114.         } catch (Exception e) {
  115.             log.error("file download error, fileName={}", fileName, e);
  116.         } finally {
  117.             IoUtil.close(outputStream);
  118.             IoUtil.close(inputStream);
  119.         }
  120.     }
  121.  
  122.     /**
  123.      * 拷贝流，拷贝后关闭流。
  124.      * <pre>
  125.      * <a href="https://www.cnblogs.com/czwbig/p/10035631.html">
  126.      *     Java NIO 学习笔记（一）----概述，Channel/Buffer</a>
  127.      * </pre>
  128.      *
  129.      * @param filePath     源文件路径
  130.      * @param response     请求响应
  131.      * @param contentRange 内容范围
  132.      */
  133.     public static void copyByNio(
  134.             Path filePath, HttpServletResponse response, ContentRange contentRange) {
  135.         String fileName = filePath.getFileName().toString();
  136.  
  137.         InputStream inputStream = null;
  138.         OutputStream outputStream = null;
  139.         try {
  140.             RandomAccessFile randomAccessFile = new RandomAccessFile(filePath.toFile(), "r");
  141.             randomAccessFile.seek(contentRange.getStart());
  142.  
  143.             inputStream = Channels.newInputStream(randomAccessFile.getChannel());
  144.             outputStream = new BufferedOutputStream(response.getOutputStream(), BUFFER_SIZE);
  145.  
  146.             StreamProgress streamProgress = new StreamProgressImpl(fileName);
  147.  
  148.             long transmitted = NioUtil.copyByNIO(inputStream, outputStream,
  149.                     BUFFER_SIZE, streamProgress);
  150.             log.info("file download complete, fileName={}, transmitted={}", fileName, transmitted);
  151.         } catch (ClientAbortException | IORuntimeException e) {
  152.             // 捕获此异常表示用户停止下载
  153.             log.warn("client stop file download, fileName={}", fileName);
  154.         } catch (Exception e) {
  155.             log.error("file download error, fileName={}", fileName, e);
  156.         } finally {
  157.             IoUtil.close(outputStream);
  158.             IoUtil.close(inputStream);
  159.         }
  160.     }
  161.  
  162.     /**
  163.      * <pre>
  164.      * <a href="https://blog.csdn.net/lovequanquqn/article/details/104562945">
  165.      *     SpringBoot Java实现Http方式分片下载断点续传+实现H5大视频渐进式播放</a>
  166.      * SpringBoot 实现Http分片下载断点续传，从而实现H5页面的大视频播放问题，实现渐进式播放，每次只播放需要播放的内容就可以了，不需要加载整个文件到内存中。
  167.      * 二、Http分片下载断点续传实现
  168.      * 四、缓存文件定时删除任务
  169.      * </pre>
  170.      */
  171.     public static void copy(Path filePath, HttpServletResponse response, ContentRange contentRange) {
  172.         String fileName = filePath.getFileName().toString();
  173.         // 要下载的长度
  174.         long contentLength = contentRange.applyAsContentLength();
  175.  
  176.         BufferedOutputStream outputStream = null;
  177.         RandomAccessFile randomAccessFile = null;
  178.         // 已传送数据大小
  179.         long transmitted = 0;
  180.         try {
  181.             randomAccessFile = new RandomAccessFile(filePath.toFile(), "r");
  182.             randomAccessFile.seek(contentRange.getStart());
  183.             outputStream = new BufferedOutputStream(response.getOutputStream(), BUFFER_SIZE);
  184.             // 把数据读取到缓冲区中
  185.             byte[] buffer = new byte[BUFFER_SIZE];
  186.  
  187.             int len = BUFFER_SIZE;
  188.             //warning：判断是否到了最后不足4096（buffer的length）个byte这个逻辑（(transmitted + len) <= contentLength）要放前面
  189.             //不然会会先读取randomAccessFile，造成后面读取位置出错;
  190.             while ((transmitted + len) <= contentLength && (len = randomAccessFile.read(buffer)) != -1) {
  191.                 outputStream.write(buffer, 0, len);
  192.                 transmitted += len;
  193.  
  194.                 log.info("fileName={}, transmitted={}", fileName, transmitted);
  195.             }
  196.             //处理不足buffer.length部分
  197.             if (transmitted < contentLength) {
  198.                 len = randomAccessFile.read(buffer, 0, (int) (contentLength - transmitted));
  199.                 outputStream.write(buffer, 0, len);
  200.                 transmitted += len;
  201.  
  202.                 log.info("fileName={}, transmitted={}", fileName, transmitted);
  203.             }
  204.  
  205.             log.info("file download complete, fileName={}, transmitted={}", fileName, transmitted);
  206.         } catch (ClientAbortException e) {
  207.             // 捕获此异常表示用户停止下载
  208.             log.warn("client stop file download, fileName={}, transmitted={}", fileName, transmitted);
  209.         } catch (Exception e) {
  210.             log.error("file download error, fileName={}, transmitted={}", fileName, transmitted, e);
  211.         } finally {
  212.             IoUtil.close(outputStream);
  213.             IoUtil.close(randomAccessFile);
  214.         }
  215.     }
  216.  
  217.     /**
  218.      * 通过数据传输通道和缓冲区读取文件数据。
  219.      * <pre>
  220.      * 当文件长度超过{@link Integer#MAX_VALUE}时，
  221.      * 使用{@link FileChannel#map(FileChannel.MapMode, long, long)}报如下异常。
  222.      * java.lang.IllegalArgumentException: Size exceeds Integer.MAX_VALUE
  223.      *   at sun.nio.ch.FileChannelImpl.map(FileChannelImpl.java:863)
  224.      *   at com.example.insurance.controller.ResourceController.download(ResourceController.java:200)
  225.      * </pre>
  226.      *
  227.      * @param filePath     源文件路径
  228.      * @param response     请求响应
  229.      * @param contentRange 内容范围
  230.      */
  231.     public static void copyByChannelAndBuffer(
  232.             Path filePath, HttpServletResponse response, ContentRange contentRange) {
  233.         String fileName = filePath.getFileName().toString();
  234.         // 要下载的长度
  235.         long contentLength = contentRange.applyAsContentLength();
  236.  
  237.         BufferedOutputStream outputStream = null;
  238.         FileChannel inChannel = null;
  239.         // 已传送数据大小
  240.         long transmitted = 0;
  241.         long firstBytePos = contentRange.getStart();
  242.         long fileLength = contentRange.getLength();
  243.         try {
  244.             inChannel = FileChannel.open(filePath, StandardOpenOption.READ, StandardOpenOption.WRITE);
  245.             // 建立直接缓冲区
  246.             MappedByteBuffer inMap = inChannel.map(FileChannel.MapMode.READ_ONLY, firstBytePos, fileLength);
  247.             outputStream = new BufferedOutputStream(response.getOutputStream(), BUFFER_SIZE);
  248.             // 把数据读取到缓冲区中
  249.             byte[] buffer = new byte[BUFFER_SIZE];
  250.  
  251.             int len = BUFFER_SIZE;
  252.             // warning：判断是否到了最后不足4096（buffer的length）个byte这个逻辑（(transmitted + len) <= contentLength）要放前面
  253.             // 不然会会先读取file，造成后面读取位置出错
  254.             while ((transmitted + len) <= contentLength) {
  255.                 inMap.get(buffer);
  256.                 outputStream.write(buffer, 0, len);
  257.                 transmitted += len;
  258.  
  259.                 log.info("fileName={}, transmitted={}", fileName, transmitted);
  260.             }
  261.             // 处理不足buffer.length部分
  262.             if (transmitted < contentLength) {
  263.                 len = (int) (contentLength - transmitted);
  264.                 buffer = new byte[len];
  265.                 inMap.get(buffer);
  266.                 outputStream.write(buffer, 0, len);
  267.                 transmitted += len;
  268.  
  269.                 log.info("fileName={}, transmitted={}", fileName, transmitted);
  270.             }
  271.  
  272.             log.info("file download complete, fileName={}, transmitted={}", fileName, transmitted);
  273.         } catch (ClientAbortException e) {
  274.             // 捕获此异常表示用户停止下载
  275.             log.warn("client stop file download, fileName={}, transmitted={}", fileName, transmitted);
  276.         } catch (Exception e) {
  277.             log.error("file download error, fileName={}, transmitted={}", fileName, transmitted, e);
  278.         } finally {
  279.             IoUtil.close(outputStream);
  280.             IoUtil.close(inChannel);
  281.         }
  282.     }
  283.  
  284. }
  285.

ContentRange

  1. package com.example.insurance.common;
  2.  
  3. import lombok.AllArgsConstructor;
  4. import lombok.Getter;
  5.  
  6. /**
  7.  * 内容范围对象
  8.  * <pre>
  9.  * <a href="https://www.rfc-editor.org/rfc/rfc7233#section-4.2">
  10.  *     4.2. Content-Range - HTTP/1.1 Range Requests</a>
  11.  * Content-Range: "bytes" first-byte-pos "-" last-byte-pos  "/" complete-length
  12.  *
  13.  * For example:
  14.  * Content-Range: bytes 0-499/1234
  15.  * </pre>
  16.  *
  17.  * @see org.apache.catalina.servlets.DefaultServlet.Range
  18.  */
  19. @Getter
  20. @AllArgsConstructor
  21. public class ContentRange {
  22.  
  23.     /**
  24.      * 第一个字节的位置
  25.      */
  26.     private final long start;
  27.     /**
  28.      * 最后一个字节的位置
  29.      */
  30.     private long end;
  31.     /**
  32.      * 内容完整的长度/总长度
  33.      */
  34.     private final long length;
  35.  
  36.     public static final String BYTES_STRING = "bytes";
  37.  
  38.     /**
  39.      * 组装内容范围的响应头。
  40.      * <pre>
  41.      * <a href="https://www.rfc-editor.org/rfc/rfc7233#section-4.2">
  42.      *     4.2. Content-Range - HTTP/1.1 Range Requests</a>
  43.      * Content-Range: "bytes" first-byte-pos "-" last-byte-pos  "/" complete-length
  44.      *
  45.      * For example:
  46.      * Content-Range: bytes 0-499/1234
  47.      * </pre>
  48.      *
  49.      * @return 内容范围的响应头
  50.      */
  51.     public String toContentRange() {
  52.         return BYTES_STRING + ' ' + start + '-' + end + '/' + length;
  53. //        return "bytes " + start + "-" + end + "/" + length;
  54.     }
  55.  
  56.     /**
  57.      * 计算内容完整的长度/总长度。
  58.      *
  59.      * @return 内容完整的长度/总长度
  60.      */
  61.     public long applyAsContentLength() {
  62.         return end - start + 1;
  63.     }
  64.  
  65.     /**
  66.      * Validate range.
  67.      *
  68.      * @return true if the range is valid, otherwise false
  69.      */
  70.     public boolean validate() {
  71.         if (end >= length) {
  72.             end = length - 1;
  73.         }
  74.         return (start >= 0) && (end >= 0) && (start <= end) && (length > 0);
  75.     }
  76.  
  77.     @Override
  78.     public String toString() {
  79.         return "firstBytePos=" + start +
  80.                 ", lastBytePos=" + end +
  81.                 ", fileLength=" + length;
  82.     }
  83. }
  84.

StreamProgressImpl

  1. package com.example.insurance.common;
  2.  
  3. import cn.hutool.core.io.StreamProgress;
  4. import lombok.AllArgsConstructor;
  5. import lombok.extern.slf4j.Slf4j;
  6.  
  7. /**
  8.  * 数据流进度条
  9.  */
  10. @Slf4j
  11. @AllArgsConstructor
  12. public class StreamProgressImpl implements StreamProgress {
  13.  
  14.     private final String fileName;
  15.  
  16.     @Override
  17.     public void start() {
  18.         log.info("start progress {}", fileName);
  19.     }
  20.  
  21.     @Override
  22.     public void progress(long total, long progressSize) {
  23.         log.debug("progress {}, total={}, progressSize={}", fileName, total, progressSize);
  24.     }
  25.  
  26.     @Override
  27.     public void finish() {
  28.         log.info("finish progress {}", fileName);
  29.     }
  30. }
  31.

MediaContentUtil

  1. package com.example.insurance.common;
  2.  
  3. import java.net.URLDecoder;
  4. import java.net.URLEncoder;
  5. import java.nio.charset.StandardCharsets;
  6.  
  7. /**
  8.  * 文件内容辅助方法集
  9.  */
  10. public final class MediaContentUtil {
  11.  
  12.     public static String filePath() {
  13.         String osName = System.getProperty("os.name");
  14.         String filePath = "/data/files/";
  15.         if (osName.startsWith("Windows")) {
  16.             filePath = "D:\" + filePath;
  17.         }
  18. //        else if (osName.startsWith("Linux")) {
  19. //            filePath = MediaContentConstant.FILE_PATH;
  20. //        }
  21.         else if (osName.startsWith("Mac") || osName.startsWith("Linux")) {
  22.             filePath = "/home/admin" + filePath;
  23.         }
  24.         return filePath;
  25.     }
  27.     public static String encode(String fileName) {
  28.         return URLEncoder.encode(fileName, StandardCharsets.UTF_8);
  29.     }
  31.     public static String decode(String fileName) {
  32.         return URLDecoder.decode(fileName, StandardCharsets.UTF_8);
  33.     }
  34. }

实现示例2

代码实现

（1）客户端需要实现以下功能：
  • 建立连接：客户端需要连接服务端，并建立连接。
  • 分块传输文件：客户端需要将文件分成若干块，并逐块传输。在传输中，每个块传输完成后，需要将已传输的位置发送给服务端，以便服务端记录传输位置。
  • 计算MD5值：在传输完成后，客户端需要计算文件的MD5值，以确保传输的完整性。
  • 与服务端比较MD5值：在计算出MD5值后，客户端需要将MD5值发送给服务端，并与服务端返回的MD5值比较，以确保传输的完整性。
（2）服务端需要实现以下功能：
  • 建立连接：服务端需要等待客户端连接，并建立连接。
  • 接收文件：服务端需要接收客户端传输的文件。在接收文件时，需要记录传输的位置，并在传输中断后继续接收文件。
  • 计算MD5值：在接收完成后，服务端需要计算文件的MD5值，以确保传输的完整性。
  • 返回MD5值：在计算出MD5值后，服务端需要将MD5值返回给客户端。
1.编写客户端代码

在客户端中，我们需要实现以下功能：

  • 建立连接：使用Java的Socket类建立与服务端的连接。
  • 分块传输文件：将文件分成若干块，并逐块传输。在传输中，每个块传输完成后，需要将已传输的位置发送给服务端，以便服务端记录传输位置。
  • 计算MD5值：在传输完成后，计算文件的MD5值，以确保传输的完整性。
  • 与服务端比较MD5值：将MD5值发送给服务端，并与服务端返回的MD5值比较，以确保传输的完整性。

以下是客户端代码的实现：

  1. @RestController
  2. @RequestMapping("/file")
  3. public class FileController {
  4.     @PostMapping("/upload")
  5.     public ResponseEntity<?> uploadFile(
  6.             @RequestParam("file") MultipartFile file,
  7.             @RequestParam("fileName") String fileName,
  8.             @RequestParam("startPosition") long startPosition) {
  9.         try {            // 建立连接
  10.             Socket socket = new Socket("localhost", 8080);
  11.             OutputStream outputStream = socket.getOutputStream();
  12.             ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
  13.             // 分块传输文件
  14.             FileInputStream fileInputStream = (FileInputStream) file.getInputStream();
  15.             fileInputStream.skip(startPosition);
  16.             byte[] buffer = new byte[1024];
  17.             int len;
  18.             while ((len = fileInputStream.read(buffer)) != -1) {
  19.                 outputStream.write(buffer, 0, len);
  20.             }
  21.             // 计算MD5值
  22.             fileInputStream.getChannel().position(0);
  23.             String md5 = DigestUtils.md5Hex(fileInputStream);
  24.             // 与服务端比较MD5值
  25.             InputStream inputStream = socket.getInputStream();
  26.             ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
  27.             String serverMd5 = (String) objectInputStream.readObject();
  28.             if (!md5.equals(serverMd5)) {
  29.                 throw new RuntimeException("MD5值不匹配");
  30.             }
  31.             // 关闭连接
  32.             objectOutputStream.close();
  33.             outputStream.close();
  34.             socket.close();
  35.         } catch (Exception e) {
  36.             e.printStackTrace();
  37.             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(e.getMessage());
  38.         }
  39.         return ResponseEntity.ok().build();
  40.     }
  41. }
2.编写服务端代码

在服务端中，我们需要实现以下功能：

  • 建立连接：使用Java的ServerSocket类等待客户端连接，并建立连接。
  • 接收文件：接收客户端传输的文件。在接收文件时，需要记录传输的位置，并在传输中断后继续接收文件。
  • 计算MD5值：在接收完成后，计算文件的MD5值，以确保传输的完整性。
  • 返回MD5值：将MD5值返回给客户端。

以下是服务端代码的实现：

  1. @RestController
  2. @RequestMapping("/file")
  3. public class FileController {
  4.     private final String FILE_PATH = "/tmp/upload/";
  5.  
  6.     @PostMapping("/upload")
  7.     public ResponseEntity<?> uploadFile(HttpServletRequest request, @RequestParam("fileName") String fileName) {
  8.         try {
  9.             // 建立连接            
  10.             ServerSocket serverSocket = new ServerSocket(8080);
  11.             Socket socket = serverSocket.accept();
  12.             InputStream inputStream = socket.getInputStream();
  13.             ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
  14.             // 接收文件            
  15.             String filePath = FILE_PATH + fileName;
  16.             RandomAccessFile randomAccessFile = new RandomAccessFile(filePath, "rw");
  17.             long startPosition = randomAccessFile.length();
  18.             randomAccessFile.seek(startPosition);
  19.             byte[] buffer = new byte[1024];
  20.             int len;
  21.             while ((len = inputStream.read(buffer)) != -1) {
  22.                 randomAccessFile.write(buffer, 0, len);
  23.             }   // 计算MD5值        
  24.             FileInputStream fileInputStream = new FileInputStream(filePath);
  25.             String md5 = DigestUtils.md5Hex(fileInputStream);
  26.             // 返回MD5值        
  27.             OutputStream outputStream = socket.getOutputStream();
  28.             ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
  29.             objectOutputStream.writeObject(md5);        // 关闭连
  30.             objectInputStream.close();
  31.             inputStream.close();
  32.             randomAccessFile.close();
  33.             socket.close();
  34.             serverSocket.close();
  35.         } catch (Exception e) {
  36.             e.printStackTrace();
  37.             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(e.getMessage());
  38.         }
  39.         return ResponseEntity.ok().build();
  40.     }
  41. }
3. 编写前端代码

在前端中，我们需要实现以下功能：

  • 选择文件：提供一个文件选择框，让用户选择要上传的文件。
  • 分块上传：将文件分块上传到服务器。在上传过程中，需要记录上传的位置，并在上传中断后继续上传。

以下是前端代码的实现：

  1. <html>
  2. <head>
  3.     <meta charset="UTF-8">
  4.     <title>Spring Boot File Upload</title>
  5.     <script src="https://cdn.bootcss.com/jquery/3.3.1/jquery.min.js"></script>
  6. </head>
  7. <body><input type="file" id="file">
  8. <button onclick="upload()">Upload</button>
  9. <script>    var file;
  10. var startPosition = 0;
  11. $('#file').on('change', function () {
  12.     file = this.files[0];
  13. });
  14.  
  15. function upload() {
  16.     if (!file) {
  17.         alert('Please select a file!');
  18.         return;
  19.     }
  20.     var formData = new FormData();
  21.     formData.append('file', file);
  22.     formData.append('fileName', file.name);
  23.     formData.append('startPosition', startPosition);
  24.     $.ajax({
  25.         url: '/file/upload',
  26.         type: 'post',
  27.         data: formData,
  28.         cache: false,
  29.         processData: false,
  30.         contentType: false,
  31.         success: function () {
  32.             alert('Upload completed!');
  33.         },
  34.         error: function (xhr) {
  35.             alert(xhr.responseText);
  36.         },
  37.         xhr: function () {
  38.             var xhr = $.ajaxSettings.xhr();
  39.             xhr.upload.onprogress = function (e) {
  40.                 if (e.lengthComputable) {
  41.                     var percent = e.loaded / e.total * 100;
  42.                     console.log('Upload percent: ' + percent.toFixed(2) + '%');
  43.                 }
  44.             };
  45.             return xhr;
  46.         }
  47.     });
  48. }</script>
  49. </body>
  50. </html>

总结

本文介绍了如何使用Spring Boot实现大文件断点续传。在实现中，我们使用了Java的RandomAccessFile类来实现文件的分块上传和断点续传，使用了Spring Boot的RestController注解来实现Web服务的开发，使用了jQuery的Ajax函数来实现前端页面的开发。

在实际开发中，需要注意以下几点：

  • 上传文件的大小和分块的大小需要根据实际情况进行设置，以确保上传速度和服务器的稳定性。
  • 在上传过程中，需要对异常情况进行处理，以确保程序的健壮性。
  • 在上传完成后，需要对上传的文件进行校验，以确保传输的完整性。
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/528109
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号