Java

前言

在文件相对比较小的情况下，可以直接把文件转化为字节流上传到服务器，但在文件比较大的情况下，用普通的方式进行上传，这可不是一个好的办法，毕竟很少有人会忍受，当文件上传到一半中断后，继续上传却只能重头开始上传，这种让人不爽的体验。那有没有比较好的上传体验，答案有的，就是下边要介绍的几种上传方式

详细教程

秒传

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的插件，进行分片。因本这里主要介绍服务端代码实现。
    b、后端用两种方式实现文件写入，一种是用RandomAccessFile。
    另一种是使用MappedByteBuffer。

    后端进行写入操作的核心代码

    a、RandomAccessFile实现方式

    ```java @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) { 

    1.   RandomAccessFile accessTmpFile = null;  
    2.   try {  
    3.       String uploadDirPath = filePathUtil.getPath(param);  
    4.       File tmpFile = super.createTmpFile(param);  
    5.       accessTmpFile = new RandomAccessFile(tmpFile, "rw");  
    6.       //这个必须与前端设定的值一致  
    7.       long chunkSize = Objects.isNull(param.getChunkSize()) ? defaultChunkSize * 1024 * 1024  
    8.           : param.getChunkSize();  
    9.       long offset = chunkSize * param.getChunk();  
    10.       //定位到该分片的偏移量  
    11.       accessTmpFile.seek(offset);  
    12.       //写入该分片数据  
    13.       accessTmpFile.write(param.getFile().getBytes());  
    14.       boolean isOk = super.checkAndSetUploadProgress(param, uploadDirPath);  
    15.       return isOk;  
    16.   } catch (IOException e) {  
    17.       log.error(e.getMessage(), e);  
    18.   } finally {  
    19.       FileUtil.close(accessTmpFile);  
    20.   }  
    21.   return false;

    }

} 

  1. <a name="jwM1q"></a>
  2. #### b、`MappedByteBuffer`实现方式
  3. ```java
  4. @UploadMode(mode = UploadModeEnum.MAPPED_BYTEBUFFER)  
  5. @Slf4j  
  6. public class MappedByteBufferUploadStrategy extends SliceUploadTemplate {  
  8.     @Autowired  
  9.     private FilePathUtil filePathUtil;  
  11.     @Value("${upload.chunkSize}")  
  12.     private long defaultChunkSize;  
  14.     @Override  
  15.     public boolean upload(FileUploadRequestDTO param) {  
  17.         RandomAccessFile tempRaf = null;  
  18.         FileChannel fileChannel = null;  
  19.         MappedByteBuffer mappedByteBuffer = null;  
  20.         try {  
  21.             String uploadDirPath = filePathUtil.getPath(param);  
  22.             File tmpFile = super.createTmpFile(param);  
  23.             tempRaf = new RandomAccessFile(tmpFile, "rw");  
  24.             fileChannel = tempRaf.getChannel();  
  26.             long chunkSize = Objects.isNull(param.getChunkSize()) ? defaultChunkSize * 1024 * 1024  
  27.                 : param.getChunkSize();  
  28.             //写入该分片数据  
  29.             long offset = chunkSize * param.getChunk();  
  30.             byte[] fileData = param.getFile().getBytes();  
  31.             mappedByteBuffer = fileChannel  
  32.                 .map(FileChannel.MapMode.READ_WRITE, offset, fileData.length);  
  33.             mappedByteBuffer.put(fileData);  
  34.             boolean isOk = super.checkAndSetUploadProgress(param, uploadDirPath);  
  35.             return isOk;  
  37.         } catch (IOException e) {  
  38.             log.error(e.getMessage(), e);  
  39.         } finally {  
  41.             FileUtil.freedMappedByteBuffer(mappedByteBuffer);  
  42.             FileUtil.close(fileChannel);  
  43.             FileUtil.close(tempRaf);  
  45.         }  
  47.         return false;  
  48.     }  
  50. }

c、文件操作核心模板类代码

  1. @Slf4j  
  2. public abstract class SliceUploadTemplate implements SliceUploadStrategy {  
  4.     public abstract boolean upload(FileUploadRequestDTO param);  
  6.     protected File createTmpFile(FileUploadRequestDTO param) {  
  8.         FilePathUtil filePathUtil = SpringContextHolder.getBean(FilePathUtil.class);  
  9.         param.setPath(FileUtil.withoutHeadAndTailDiagonal(param.getPath()));  
  10.         String fileName = param.getFile().getOriginalFilename();  
  11.         String uploadDirPath = filePathUtil.getPath(param);  
  12.         String tempFileName = fileName + "_tmp";  
  13.         File tmpDir = new File(uploadDirPath);  
  14.         File tmpFile = new File(uploadDirPath, tempFileName);  
  15.         if (!tmpDir.exists()) {  
  16.             tmpDir.mkdirs();  
  17.         }  
  18.         return tmpFile;  
  19.     }  
  21.     @Override  
  22.     public FileUploadDTO sliceUpload(FileUploadRequestDTO param) {  
  24.         boolean isOk = this.upload(param);  
  25.         if (isOk) {  
  26.             File tmpFile = this.createTmpFile(param);  
  27.             FileUploadDTO fileUploadDTO = this.saveAndFileUploadDTO(param.getFile().getOriginalFilename(), tmpFile);  
  28.             return fileUploadDTO;  
  29.         }  
  30.         String md5 = FileMD5Util.getFileMD5(param.getFile());  
  32.         Map<Integer, String> map = new HashMap<>();  
  33.         map.put(param.getChunk(), md5);  
  34.         return FileUploadDTO.builder().chunkMd5Info(map).build();  
  35.     }  
  37.     /**  
  38.    * 检查并修改文件上传进度  
  39.    */  
  40.     public boolean checkAndSetUploadProgress(FileUploadRequestDTO param, String uploadDirPath) {  
  42.         String fileName = param.getFile().getOriginalFilename();  
  43.         File confFile = new File(uploadDirPath, fileName + ".conf");  
  44.         byte isComplete = 0;  
  45.         RandomAccessFile accessConfFile = null;  
  46.         try {  
  47.             accessConfFile = new RandomAccessFile(confFile, "rw");  
  48.             //把该分段标记为 true 表示完成  
  49.             System.out.println("set part " + param.getChunk() + " complete");  
  50.             //创建conf文件文件长度为总分片数，每上传一个分块即向conf文件中写入一个127，那么没上传的位置就是默认0,已上传的就是Byte.MAX_VALUE 127  
  51.             accessConfFile.setLength(param.getChunks());  
  52.             accessConfFile.seek(param.getChunk());  
  53.             accessConfFile.write(Byte.MAX_VALUE);  
  55.             //completeList 检查是否全部完成,如果数组里是否全部都是127(全部分片都成功上传)  
  56.             byte[] completeList = FileUtils.readFileToByteArray(confFile);  
  57.             isComplete = Byte.MAX_VALUE;  
  58.             for (int i = 0; i < completeList.length && isComplete == Byte.MAX_VALUE; i++) {  
  59.                 //与运算, 如果有部分没有完成则 isComplete 不是 Byte.MAX_VALUE  
  60.                 isComplete = (byte) (isComplete & completeList[i]);  
  61.                 System.out.println("check part " + i + " complete?:" + completeList[i]);  
  62.             }  
  64.         } catch (IOException e) {  
  65.             log.error(e.getMessage(), e);  
  66.         } finally {  
  67.             FileUtil.close(accessConfFile);  
  68.         }  
  69.         boolean isOk = setUploadProgress2Redis(param, uploadDirPath, fileName, confFile, isComplete);  
  70.         return isOk;  
  71.     }  
  73.     /**  
  74.    * 把上传进度信息存进redis  
  75.    */  
  76.     private boolean setUploadProgress2Redis(FileUploadRequestDTO param, String uploadDirPath,  
  77.                                             String fileName, File confFile, byte isComplete) {  
  79.         RedisUtil redisUtil = SpringContextHolder.getBean(RedisUtil.class);  
  80.         if (isComplete == Byte.MAX_VALUE) {  
  81.             redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), "true");  
  82.             redisUtil.del(FileConstant.FILE_MD5_KEY + param.getMd5());  
  83.             confFile.delete();  
  84.             return true;  
  85.         } else {  
  86.             if (!redisUtil.hHasKey(FileConstant.FILE_UPLOAD_STATUS, param.getMd5())) {  
  87.                 redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), "false");  
  88.                 redisUtil.set(FileConstant.FILE_MD5_KEY + param.getMd5(),  
  89.                               uploadDirPath + FileConstant.FILE_SEPARATORCHAR + fileName + ".conf");  
  90.             }  
  92.             return false;  
  93.         }  
  94.     }  
  95.     /**  
  96.    * 保存文件操作  
  97.    */  
  98.     public FileUploadDTO saveAndFileUploadDTO(String fileName, File tmpFile) {  
  100.         FileUploadDTO fileUploadDTO = null;  
  102.         try {  
  104.             fileUploadDTO = renameFile(tmpFile, fileName);  
  105.             if (fileUploadDTO.isUploadComplete()) {  
  106.                 System.out  
  107.                     .println("upload complete !!" + fileUploadDTO.isUploadComplete() + " name=" + fileName);  
  108.                 //TODO 保存文件信息到数据库  
  110.             }  
  112.         } catch (Exception e) {  
  113.             log.error(e.getMessage(), e);  
  114.         } finally {  
  116.         }  
  117.         return fileUploadDTO;  
  118.     }  
  119.     /**  
  120.    * 文件重命名  
  121.    *  
  122.    * @param toBeRenamed 将要修改名字的文件  
  123.    * @param toFileNewName 新的名字  
  124.    */  
  125.     private FileUploadDTO renameFile(File toBeRenamed, String toFileNewName) {  
  126.         //检查要重命名的文件是否存在，是否是文件  
  127.         FileUploadDTO fileUploadDTO = new FileUploadDTO();  
  128.         if (!toBeRenamed.exists() || toBeRenamed.isDirectory()) {  
  129.             log.info("File does not exist: {}", toBeRenamed.getName());  
  130.             fileUploadDTO.setUploadComplete(false);  
  131.             return fileUploadDTO;  
  132.         }  
  133.         String ext = FileUtil.getExtension(toFileNewName);  
  134.         String p = toBeRenamed.getParent();  
  135.         String filePath = p + FileConstant.FILE_SEPARATORCHAR + toFileNewName;  
  136.         File newFile = new File(filePath);  
  137.         //修改文件名  
  138.         boolean uploadFlag = toBeRenamed.renameTo(newFile);  
  140.         fileUploadDTO.setMtime(DateUtil.getCurrentTimeStamp());  
  141.         fileUploadDTO.setUploadComplete(uploadFlag);  
  142.         fileUploadDTO.setPath(filePath);  
  143.         fileUploadDTO.setSize(newFile.length());  
  144.         fileUploadDTO.setFileExt(ext);  
  145.         fileUploadDTO.setFileId(toFileNewName);  
  147.         return fileUploadDTO;  
  148.     }  
  149. }

总结

在实现分片上传的过程，需要前端和后端配合，比如前后端的上传块号的文件大小，前后端必须得要一致，否则上传就会有问题。其次文件相关操作正常都是要搭建一个文件服务器的，比如使用fastdfs、hdfs等。
本示例代码在电脑配置为4核内存8G情况下，上传24G大小的文件，上传时间需要30多分钟，主要时间耗费在前端的md5值计算，后端写入的速度还是比较快。如果项目组觉得自建文件服务器太花费时间，且项目的需求仅仅只是上传下载，那么推荐使用阿里的oss服务器，其介绍可以查看官网：https://help.aliyun.com/product/31815.html
阿里的oss它本质是一个对象存储服务器，而非文件服务器，因此如果有涉及到大量删除或者修改文件的需求，oss可能就不是一个好的选择。通过oss表单上传，可以直接从前端把文件上传到oss服务器，把上传的压力都推给oss服务器。