乐趣区

关于java:大文件上传秒传断点续传分片上传

jiezi

前言

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

具体教程

秒传

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

2、本文实现的秒传外围逻辑

  • a、利用 redis 的 set 办法寄存文件上传状态，其中 key 为文件上传的 md5，value 为是否上传实现的标记位，
  • b、当标记位 true 为上传曾经实现，此时如果有雷同文件上传，则进入秒传逻辑。如果标记位为 false，则阐明还没上传实现，此时须要在调用 set 的办法，保留块号文件记录的门路，其中 key 为上传文件 md5 加一个固定前缀，value 为块号文件记录门路

分片上传

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

2. 分片上传的场景

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

断点续传

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

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

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

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

4、实现流程步骤

  • a、计划一，惯例步骤
    将须要上传的文件依照肯定的宰割规定，宰割成雷同大小的数据块；
    初始化一个分片上传工作，返回本次分片上传惟一标识；
    依照肯定的策略（串行或并行）发送各个分片数据块；
    发送实现后，服务端依据判断数据上传是否残缺，如果残缺，则进行数据块合成失去原始文件。
  • b、计划二、本文实现的步骤
    前端（客户端）须要依据固定大小对文件进行分片，申请后端（服务端）时要带上分片序号和大小
    服务端创立 conf 文件用来记录分块地位，conf 文件长度为总分片数，每上传一个分块即向 conf 文件中写入一个 127，那么没上传的地位就是默认的 0, 已上传的就是 Byte.MAX_VALUE 127（这步是实现断点续传和秒传的外围步骤）
    服务器依照申请数据中给的分片序号和每片分块大小（分片大小是固定且一样的）算出开始地位，与读取到的文件片段数据，写入文件。

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

  • a、前端采纳百度提供的 webuploader 的插件，进行分片。因本文次要介绍服务端代码实现，webuploader 如何进行分片，具体实现能够查看如下链接:
    http://fex.baidu.com/webuploa…
  • b、后端用两种形式实现文件写入，一种是用 RandomAccessFile，如果对 RandomAccessFile 不相熟的敌人，能够查看如下链接:
    https://blog.csdn.net/dimudan…
    另一种是应用 MappedByteBuffer，对 MappedByteBuffer 不相熟的敌人，能够查看如下链接进行理解:
    https://www.jianshu.com/p/f90…

后端进行写入操作的外围代码

  • a、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;  
}  

}

  • b、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;  
}  

}

  • c、文件操作外围模板类代码

    @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;  
}  
}

    总结

在实现分片上传的过程，须要前端和后端配合，比方前后端的上传块号的文件大小，前后端必须得要统一，否则上传就会有问题。其次文件相干操作失常都是要搭建一个文件服务器的，比方应用 fastdfs、hdfs 等。

本示例代码在电脑配置为 4 核内存 8G 状况下，上传 24G 大小的文件，上传工夫须要 30 多分钟，次要工夫消耗在前端的 md5 值计算，后端写入的速度还是比拟快。如果项目组感觉自建文件服务器太破费工夫，且我的项目的需要仅仅只是上传下载，那么举荐应用阿里的 oss 服务器，其介绍能够查看官网:

https://help.aliyun.com/produ…

阿里的 oss 它实质是一个对象存储服务器，而非文件服务器，因而如果有波及到大量删除或者批改文件的需要，oss 可能就不是一个好的抉择。

文末提供一个 oss 表单上传的链接 demo，通过 oss 表单上传，能够间接从前端把文件上传到 oss 服务器，把上传的压力都推给 oss 服务器:

https://www.cnblogs.com/osste…

起源：已赋值（作者 - 小度爷）

退出移动版