关于java:Spring-Boot-分片上传断点续传大文件上传秒传应有尽有建议收藏

文件上传是一个陈词滥调的话题了，在文件绝对比拟小的状况下，能够间接把文件转化为字节流上传到服务器，但在文件比拟大的状况下，用一般的形式进行上传，这可不是一个好的方法，毕竟很少有人会忍耐，当文件上传到一半中断后，持续上传却只能重头开始上传，这种让人不爽的体验。那有没有比拟好的上传体验呢，答案有的，就是下边要介绍的几种上传形式。

分片上传，就是将所要上传的文件，依照肯定的大小，将整个文件分隔成多个数据块（咱们称之为 Part）来进行别离上传，上传完之后再由服务端对所有上传的文件进行汇总整合成原始的文件。

大文件上传
网络环境环境不好，存在须要重传危险的场景

断点续传是在下载或上传时，将下载或上传工作（一个文件或一个压缩包）人为的划分为几个局部，每一个局部采纳一个线程进行上传或下载，如果碰到网络故障，能够从曾经上传或下载的局部开始持续上传或者下载未实现的局部，而没有必要从头开始上传或者下载。

本文的断点续传次要是针对断点上传场景。

断点续传能够看成是分片上传的一个衍生，因而能够应用分片上传的场景，都能够应用断点续传。

在分片上传的过程中，如果因为零碎解体或者网络中断等异样因素导致上传中断，这时候客户端须要记录上传的进度。在之后反对再次上传时，能够持续从上次上传中断的中央进行持续上传。

为了防止客户端在上传之后的进度数据被删除而导致从新开始从头上传的问题，服务端也能够提供相应的接口便于客户端对曾经上传的分片数据进行查问，从而使客户端晓得曾经上传的分片数据，从而从下一个分片数据开始持续上传。

整体的过程如下：

前端将文件装置百分比进行计算, 每次上传文件的百分之一 (文件分片), 给文件分片做上序号
后端将前端每次上传的文件, 放入到缓存目录
期待前端将全副的文件内容都上传完毕后, 发送一个合并申请
后端应用 RandomAccessFile 进多线程读取所有的分片文件, 一个线程一个分片
后端每个线程依照序号将分片的文件写入到指标文件中
在上传文件的过程中产生断网了或者手动暂停了, 下次上传的时候发送续传申请, 让后端删除最初一个分片
前端从新发送上次的文件分片

计划一，惯例步骤

将须要上传的文件依照肯定的宰割规定，宰割成雷同大小的数据块；
初始化一个分片上传工作，返回本次分片上传惟一标识；
依照肯定的策略（串行或并行）发送各个分片数据块；
发送实现后，服务端依据判断数据上传是否残缺，如果残缺，则进行数据块合成失去原始文件。

计划二、本文实现的步骤

前端（客户端）须要依据固定大小对文件进行分片，申请后端（服务端）时要带上分片序号和大小。
服务端创立 conf 文件用来记录分块地位，conf 文件长度为总分片数，每上传一个分块即向 conf 文件中写入一个 127，那么没上传的地位就是默认的 0, 已上传的就是 Byte.MAX_VALUE 127（这步是实现断点续传和秒传的外围步骤）
服务器依照申请数据中给的分片序号和每片分块大小（分片大小是固定且一样的）算出开始地位，与读取到的文件片段数据，写入文件。

整体的实现流程如下：

前端的 File 对象是非凡类型的 Blob，且能够用在任意的 Blob 类型的上下文中。

就是说可能解决 Blob 对象的办法也能解决 File 对象。在 Blob 的办法里有有一个 Slice 办法能够帮实现切片。

举荐一个开源收费的 Spring Boot 最全教程：

https://github.com/javastacks/spring-boot-best-practice

外围代码：

fileMD5 (files) {
  // 计算文件 md5
  return new  Promise((resolve,reject) => {const fileReader = new FileReader();
    const piece = Math.ceil(files.size / this.pieceSize);
    const nextPiece = () => {
      let start = currentPieces * this.pieceSize;
      let end = start * this.pieceSize >= files.size ? files.size : start + this.pieceSize;
      fileReader.readAsArrayBuffer(files.slice(start,end));
    };

    let currentPieces = 0;
    fileReader.onload = (event) => {
      let e = window.event || event;
      this.spark.append(e.target.result);
      currentPieces++
      if (currentPieces < piece) {nextPiece()
      } else {resolve({fileName: files.name, fileMd5: this.spark.end()})
      }
    }
    // fileReader.onerror = (err => { reject(err) })
    nextPiece()})
}

当然如果咱们是 vue 我的项目的话还有更好的抉择，咱们能够应用一些开源的框架，本文举荐应用 vue-simple-uploader 实现文件分片上传、断点续传及秒传。

当然咱们也能够采纳百度提供的 webuploader 的插件，进行分片。

操作形式也特地简略，间接依照官网文档给出的操作进行即可。

后端用两种形式实现文件写入：

RandomAccessFile
MappedByteBuffer

在向下学习之前，咱们先简略理解一下这两个类的应用

RandomAccessFile

Java 除了 File 类之外，还提供了专门解决文件的类，即 RandomAccessFile（随机拜访文件）类。

该类是 Java 语言中性能最为丰盛的文件拜访类，它提供了泛滥的文件拜访办法。RandomAccessFile 类反对“随机拜访”形式，这里“随机”是指能够跳转到文件的任意地位处读写数据。在拜访一个文件的时候，不用把文件从头读到尾，而是心愿像拜访一个数据库一样“得心应手”地拜访一个文件的某个局部，这时应用 RandomAccessFile 类就是最佳抉择。

RandomAccessFile 对象类有个地位指示器，指向以后读写处的地位，以后读写 n 个字节后，文件指示器将指向这 n 个字节前面的下一个字节处。

刚关上文件时，文件指示器指向文件的结尾处，能够挪动文件指示器到新的地位，随后的读写操作将从新的地位开始。

RandomAccessFile 类在数据等长记录格式文件的随机（绝对程序而言）读取时有很大的劣势，但该类仅限于操作文件，不能拜访其余的 I / O 设施，如网络、内存映像等。

RandomAccessFile 类的构造方法如下所示：

// 创立随机存储文件流，文件属性由参数 File 对象指定
RandomAccessFile(File file , String mode)

// 创立随机存储文件流，文件名由参数 name 指定
RandomAccessFile(String name , String mode)

这两个构造方法均波及到一个 String 类型的参数 mode，它决定随机存储文件流的操作模式，其中 mode 值及对应的含意如下：

“r”：以只读的形式关上，调用该对象的任何 write（写）办法都会导致 IOException 异样
“rw”：以读、写形式关上，反对文件的读取或写入。若文件不存在，则创立之。
“rws”：以读、写形式关上，与“rw”不同的是，还要对文件内容的每次更新都同步更新到潜在的存储设备中去。这里的“s”示意 synchronous（同步）的意思
“rwd”：以读、写形式关上，与“rw”不同的是，还要对文件内容的每次更新都同步更新到潜在的存储设备中去。应用“rwd”模式仅要求将文件的内容更新到存储设备中，而应用“rws”模式除了更新文件的内容，还要更新文件的元数据（metadata），因而至多要求 1 次低级别的 I / O 操作

import java.io.RandomAccessFile;
import java.nio.charset.StandardCharsets;
public class RandomFileTest {
    private static final String filePath = "C:\\Users\\NineSun\\Desktop\\employee.txt";

    public static void main(String[] args) throws Exception {Employee e1 = new Employee("zhangsan", 23);
        Employee e2 = new Employee("lisi", 24);
        Employee e3 = new Employee("wangwu", 25);
        RandomAccessFile ra = new RandomAccessFile(filePath, "rw");
        ra.write(e1.name.getBytes(StandardCharsets.UTF_8));// 避免写入文件乱码
        ra.writeInt(e1.age);
        ra.write(e2.name.getBytes());
        ra.writeInt(e2.age);
        ra.write(e3.name.getBytes());
        ra.writeInt(e3.age);
        ra.close();
        RandomAccessFile raf = new RandomAccessFile(filePath, "r");
        int len = 8;
        raf.skipBytes(12);// 跳过第一个员工的信息，其姓名 8 字节，年龄 4 字节
        System.out.println("第二个员工信息：");
        String str = "";
        for (int i = 0; i < len; i++) {str = str + (char) raf.readByte();}
        System.out.println("name:" + str);
        System.out.println("age:" + raf.readInt());
        System.out.println("第一个员工信息：");
        raf.seek(0);// 将文件指针挪动到文件开始地位
        str = "";
        for (int i = 0; i < len; i++) {str = str + (char) raf.readByte();}
        System.out.println("name:" + str);
        System.out.println("age:" + raf.readInt());
        System.out.println("第三个员工信息：");
        raf.skipBytes(12);// 跳过第二个员工的信息
        str = "";
        for (int i = 0; i < len; i++) {str = str + (char) raf.readByte();}
        System.out.println("name:" + str);
        System.out.println("age:" + raf.readInt());
        raf.close();}
}

class Employee {
    String name;
    int age;
    final static int LEN = 8;

    public Employee(String name, int age) {if (name.length() > LEN) {name = name.substring(0, 8);
        } else {while (name.length() < LEN) {name = name + "\u0000";}
            this.name = name;
            this.age = age;
        }
    }
}

MappedByteBuffer

java io 操作中通常采纳 BufferedReader，BufferedInputStream 等带缓冲的 IO 类解决大文件，不过 java nio 中引入了一种基于 MappedByteBuffer 操作大文件的形式，其读写性能极高

为了节约文章篇幅，上面我只展现外围代码，残缺代码能够在文末进行下载

RandomAccessFile 实现形式

@UploadMode(mode = UploadModeEnum.RANDOM_ACCESS)
@Slf4j
public class RandomAccessUploadStrategy extends SliceUploadTemplate {

  @Autowired
  private FilePathUtil filePathUtil;

  @Value("${upload.chunkSize}")
  private long defaultChunkSize;

  @Override
  public boolean upload(FileUploadRequestDTO param) {
    RandomAccessFile accessTmpFile = null;
    try {String uploadDirPath = filePathUtil.getPath(param);
      File tmpFile = super.createTmpFile(param);
      accessTmpFile = new RandomAccessFile(tmpFile, "rw");
      // 这个必须与前端设定的值统一
      long chunkSize = Objects.isNull(param.getChunkSize()) ? defaultChunkSize * 1024 * 1024
          : param.getChunkSize();
      long offset = chunkSize * param.getChunk();
      // 定位到该分片的偏移量
      accessTmpFile.seek(offset);
      // 写入该分片数据
      accessTmpFile.write(param.getFile().getBytes());
      boolean isOk = super.checkAndSetUploadProgress(param, uploadDirPath);
      return isOk;
    } catch (IOException e) {log.error(e.getMessage(), e);
    } finally {FileUtil.close(accessTmpFile);
    }
    return false;
  }
}

MappedByteBuffer 实现形式

@UploadMode(mode = UploadModeEnum.MAPPED_BYTEBUFFER)
@Slf4j
public class MappedByteBufferUploadStrategy extends SliceUploadTemplate {

  @Autowired
  private FilePathUtil filePathUtil;

  @Value("${upload.chunkSize}")
  private long defaultChunkSize;

  @Override
  public boolean upload(FileUploadRequestDTO param) {

    RandomAccessFile tempRaf = null;
    FileChannel fileChannel = null;
    MappedByteBuffer mappedByteBuffer = null;
    try {String uploadDirPath = filePathUtil.getPath(param);
      File tmpFile = super.createTmpFile(param);
      tempRaf = new RandomAccessFile(tmpFile, "rw");
      fileChannel = tempRaf.getChannel();

      long chunkSize = Objects.isNull(param.getChunkSize()) ? defaultChunkSize * 1024 * 1024
          : param.getChunkSize();
      // 写入该分片数据
      long offset = chunkSize * param.getChunk();
      byte[] fileData = param.getFile().getBytes();
      mappedByteBuffer = fileChannel
          .map(FileChannel.MapMode.READ_WRITE, offset, fileData.length);
      mappedByteBuffer.put(fileData);
      boolean isOk = super.checkAndSetUploadProgress(param, uploadDirPath);
      return isOk;
    } catch (IOException e) {log.error(e.getMessage(), e);
    } finally {FileUtil.freedMappedByteBuffer(mappedByteBuffer);
      FileUtil.close(fileChannel);
      FileUtil.close(tempRaf);

    }

    return false;
  }
}

文件操作外围模板类代码

@Slf4j
public abstract class SliceUploadTemplate implements SliceUploadStrategy {public abstract boolean upload(FileUploadRequestDTO param);

  protected File createTmpFile(FileUploadRequestDTO param) {FilePathUtil filePathUtil = SpringContextHolder.getBean(FilePathUtil.class);
    param.setPath(FileUtil.withoutHeadAndTailDiagonal(param.getPath()));
    String fileName = param.getFile().getOriginalFilename();
    String uploadDirPath = filePathUtil.getPath(param);
    String tempFileName = fileName + "_tmp";
    File tmpDir = new File(uploadDirPath);
    File tmpFile = new File(uploadDirPath, tempFileName);
    if (!tmpDir.exists()) {tmpDir.mkdirs();
    }
    return tmpFile;
  }

  @Override
  public FileUploadDTO sliceUpload(FileUploadRequestDTO param) {boolean isOk = this.upload(param);
    if (isOk) {File tmpFile = this.createTmpFile(param);
      FileUploadDTO fileUploadDTO = this.saveAndFileUploadDTO(param.getFile().getOriginalFilename(), tmpFile);
      return fileUploadDTO;
    }
    String md5 = FileMD5Util.getFileMD5(param.getFile());

    Map<Integer, String> map = new HashMap<>();
    map.put(param.getChunk(), md5);
    return FileUploadDTO.builder().chunkMd5Info(map).build();}

  /**
   * 查看并批改文件上传进度
   */
  public boolean checkAndSetUploadProgress(FileUploadRequestDTO param, String uploadDirPath) {String fileName = param.getFile().getOriginalFilename();
    File confFile = new File(uploadDirPath, fileName + ".conf");
    byte isComplete = 0;
    RandomAccessFile accessConfFile = null;
    try {accessConfFile = new RandomAccessFile(confFile, "rw");
      // 把该分段标记为 true 示意实现
      System.out.println("set part" + param.getChunk() + "complete");
      // 创立 conf 文件文件长度为总分片数，每上传一个分块即向 conf 文件中写入一个 127，那么没上传的地位就是默认 0, 已上传的就是 Byte.MAX_VALUE 127
      accessConfFile.setLength(param.getChunks());
      accessConfFile.seek(param.getChunk());
      accessConfFile.write(Byte.MAX_VALUE);

      //completeList 查看是否全副实现, 如果数组里是否全部都是 127(全副分片都胜利上传)
      byte[] completeList = FileUtils.readFileToByteArray(confFile);
      isComplete = Byte.MAX_VALUE;
      for (int i = 0; i < completeList.length && isComplete == Byte.MAX_VALUE; i++) {
        // 与运算, 如果有局部没有实现则 isComplete 不是 Byte.MAX_VALUE
        isComplete = (byte) (isComplete & completeList[i]);
        System.out.println("check part" + i + "complete?:" + completeList[i]);
      }

    } catch (IOException e) {log.error(e.getMessage(), e);
    } finally {FileUtil.close(accessConfFile);
    }
    boolean isOk = setUploadProgress2Redis(param, uploadDirPath, fileName, confFile, isComplete);
    return isOk;
  }

  /**
   * 把上传进度信息存进 redis
   */
  private boolean setUploadProgress2Redis(FileUploadRequestDTO param, String uploadDirPath,
      String fileName, File confFile, byte isComplete) {RedisUtil redisUtil = SpringContextHolder.getBean(RedisUtil.class);
    if (isComplete == Byte.MAX_VALUE) {redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), "true");
      redisUtil.del(FileConstant.FILE_MD5_KEY + param.getMd5());
      confFile.delete();
      return true;
    } else {if (!redisUtil.hHasKey(FileConstant.FILE_UPLOAD_STATUS, param.getMd5())) {redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), "false");
        redisUtil.set(FileConstant.FILE_MD5_KEY + param.getMd5(),
            uploadDirPath + FileConstant.FILE_SEPARATORCHAR + fileName + ".conf");
      }

      return false;
    }
  }

  /**
   * 保留文件操作
   */
  public FileUploadDTO saveAndFileUploadDTO(String fileName, File tmpFile) {

    FileUploadDTO fileUploadDTO = null;

    try {fileUploadDTO = renameFile(tmpFile, fileName);
      if (fileUploadDTO.isUploadComplete()) {
        System.out
            .println("upload complete !!" + fileUploadDTO.isUploadComplete() + "name=" + fileName);
        //TODO 保留文件信息到数据库

      }

    } catch (Exception e) {log.error(e.getMessage(), e);
    } finally { }
    return fileUploadDTO;
  }

  /**
   * 文件重命名
   *
   * @param toBeRenamed 将要批改名字的文件
   * @param toFileNewName 新的名字
   */
  private FileUploadDTO renameFile(File toBeRenamed, String toFileNewName) {
    // 查看要重命名的文件是否存在，是否是文件
    FileUploadDTO fileUploadDTO = new FileUploadDTO();
    if (!toBeRenamed.exists() || toBeRenamed.isDirectory()) {log.info("File does not exist: {}", toBeRenamed.getName());
      fileUploadDTO.setUploadComplete(false);
      return fileUploadDTO;
    }
    String ext = FileUtil.getExtension(toFileNewName);
    String p = toBeRenamed.getParent();
    String filePath = p + FileConstant.FILE_SEPARATORCHAR + toFileNewName;
    File newFile = new File(filePath);
    // 批改文件名
    boolean uploadFlag = toBeRenamed.renameTo(newFile);

    fileUploadDTO.setMtime(DateUtil.getCurrentTimeStamp());
    fileUploadDTO.setUploadComplete(uploadFlag);
    fileUploadDTO.setPath(filePath);
    fileUploadDTO.setSize(newFile.length());
    fileUploadDTO.setFileExt(ext);
    fileUploadDTO.setFileId(toFileNewName);

    return fileUploadDTO;
  }

}

上传接口

@PostMapping(value = "/upload")
@ResponseBody
public Result<FileUploadDTO> upload(FileUploadRequestDTO fileUploadRequestDTO) throws IOException {boolean isMultipart = ServletFileUpload.isMultipartContent(request);
    FileUploadDTO fileUploadDTO = null;
    if (isMultipart) {StopWatch stopWatch = new StopWatch();
      stopWatch.start("upload");
      if (fileUploadRequestDTO.getChunk() != null && fileUploadRequestDTO.getChunks() > 0) {fileUploadDTO = fileService.sliceUpload(fileUploadRequestDTO);
      } else {fileUploadDTO = fileService.upload(fileUploadRequestDTO);
      }
      stopWatch.stop();
      log.info("{}",stopWatch.prettyPrint());

      return new Result<FileUploadDTO>().setData(fileUploadDTO);
    }

    throw new BizException("上传失败", 406);
}

艰深的说，你把要上传的货色上传，服务器会先做 MD5 校验，如果服务器上有一样的货色，它就间接给你个新地址，其实你下载的都是服务器上的同一个文件，想要不秒传，其实只有让 MD5 扭转，就是对文件自身做一下批改（改名字不行），例如一个文本文件，你多加几个字，MD5 就变了，就不会秒传了。

利用 redis 的 set 办法寄存文件上传状态，其中 key 为文件上传的 md5，value 为是否上传实现的标记位，当标记位 true 为上传曾经实现，此时如果有雷同文件上传，则进入秒传逻辑。

如果标记位为 false，则阐明还没上传实现，此时须要在调用 set 的办法，保留块号文件记录的门路，其中，key 为上传文件 md5 加一个固定前缀，value 为块号文件记录门路

4.3 外围代码

private boolean setUploadProgress2Redis(FileUploadRequestDTO param, String uploadDirPath,
      String fileName, File confFile, byte isComplete) {RedisUtil redisUtil = SpringContextHolder.getBean(RedisUtil.class);
    if (isComplete == Byte.MAX_VALUE) {redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), "true");
      redisUtil.del(FileConstant.FILE_MD5_KEY + param.getMd5());
      confFile.delete();
      return true;
    } else {if (!redisUtil.hHasKey(FileConstant.FILE_UPLOAD_STATUS, param.getMd5())) {redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), "false");
        redisUtil.set(FileConstant.FILE_MD5_KEY + param.getMd5(),
            uploadDirPath + FileConstant.FILE_SEPARATORCHAR + fileName + ".conf");
      }

      return false;
    }
}

在实现分片上传的过程，须要前端和后端配合，比方前后端的上传块号的文件大小，前后端必须得要统一，否则上传就会有问题。

其次文件相干操作失常都是要搭建一个文件服务器的，比方应用 fastdfs、hdfs 等。

版权申明：本文为 CSDN 博主「ZNineSun」的原创文章，遵循 CC 4.0 BY-SA 版权协定，转载请附上原文出处链接及本申明。原文链接：https://blog.csdn.net/zhiyikeji/article/details/128242775

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿 (2022 最新版)

2. 劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4. 别再写满屏的爆爆爆炸类了，试试装璜器模式，这才是优雅的形式！！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！

关于java:Spring-Boot-分片上传断点续传大文件上传秒传应有尽有建议收藏

1、分片上传

1.1 什么是分片上传

1.2 分片上传的场景

2 断点续传

2.1 什么是断点续传

2.2 利用场景

2.3 实现断点续传的外围逻辑

2.4 实现流程步骤

3、分片上传 / 断点上传代码实现

3.1 前端实现

3.2 后端写入文件

3.3 进行写入操作的外围代码

4、秒传

4.1 什么是秒传

4.2 实现的秒传外围逻辑

5、总结