基于SpringBoot和Vue实现分片上传系统

    async calculateHash(fileChunks) {
      return new Promise(resolve => {
        const spark = new sparkMD5.ArrayBuffer()
        const chunks = []
        const CHUNK_SIZE = this.CHUNK_SIZE
        fileChunks.forEach((chunk, index) => {
          if (index === 0 || index === fileChunks.length - 1) {
            // 1. 第一个和最后一个切片的内容全部参与计算
            chunks.push(chunk.file)
          } else {
            // 2. 中间剩余的切片我们分别在前面、后面和中间取2个字节参与计算
            // 前面的2字节
            chunks.push(chunk.file.slice(0, 2))
            // 中间的2字节
            chunks.push(chunk.file.slice(CHUNK_SIZE / 2, CHUNK_SIZE / 2 + 2))
            // 后面的2字节
            chunks.push(chunk.file.slice(CHUNK_SIZE - 2, CHUNK_SIZE))
          }
        })
        const reader = new FileReader()
        reader.readAsArrayBuffer(new Blob(chunks))
        reader.onload = (e) => {
          spark.append(e.target.result)
          resolve(spark.end())
        }
      })
    }

    async uploadCheck() {
      let r;
      await axios.get('/api/file//uploadCheck?fileMd5=' + this.key).then(res => {
        r = res.data.flag;
        this.existCheck=[];
        //存在部分分片则返回存在的文件信息
        if (r == false){
          this.existCheck=res.data.data;
        }
      })
      return r;
    }

    /**
     * 文件整体的查重校验
     * @param fileMd5
     * @return
     */
    @GetMapping("/uploadCheck")
    public Result uploadCheck(String fileMd5,HttpServletRequest httpServletRequest){
        String user = JwtUtil.getId(httpServletRequest.getHeader("token"));
        if (fileService.uploadCheck(fileMd5,user)){
            return new Result(true,true);
        }else {
            //查找文件是否有分片上传过到系统中
            Integer arr[] = fileService.existCheck(fileMd5);
            return new Result(false,arr);
        }
    }

    @Override
    public Boolean uploadCheck(String fileMd5, String userId) {
        //判断文件是否存在
        MyFile myFile = fileMapper.getFileByMd5(fileMd5);
        //如果文件存在直接给用户插入数据记录即可
        if (myFile != null) {
            MyFile newMyFile = new MyFile();
            newMyFile.setId(userId + DateTimeUtil.getTimeStamp());
            newMyFile.setFileName(myFile.getFileName());
            newMyFile.setUser(userId);
            newMyFile.setFileMd5(fileMd5);
            newMyFile.setFileSize(myFile.getFileSize());
            newMyFile.setTime(LocalDateTime.parse(DateTimeUtil.getDateTime(), DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
            Integer num = fileMapper.insert(newMyFile);
            if (num == 1) {
                return true;
            }
        }
        return false;
    }

      const formDatas = data.map(({chunk, fileHash, index, filename, chunkSize}) => {
        const formData = new FormData()
        // 切片文件
        formData.append('file', chunk)
        // 大文件hash
        formData.append('fileMd5', fileHash)
        //切片的索引
        formData.append('currentIndex', index)
        // 大文件的文件名
        formData.append('fileName', filename)
        // 分片大小
        formData.append('chunkCount', chunkSize)
        return formData
      })
      let index = 0;
      const max = 6; // 并发请求数量
      const taskPool = []// 请求队列
      let t = this.existCheck.length;
      while (index < formDatas.length) {
        //出现重复的切片，跳过
        if (this.existCheck.includes(index)){
          index++;
          continue;
        }
        const task = axios.post('/api/file/uploadBySlice', formDatas[index])
        //splice方法会删除数组中第一个匹配的元素,参数搭配使用findIndex可以找到第一个匹配的元素的索引
        task.then(() => {
          taskPool.splice(taskPool.findIndex((item) => item === task))
          t=t+1;
          this.percentage = Math.floor((t / formDatas.length * 100) * (1.0))-1
        })
        taskPool.push(task);
        if (taskPool.length === max) {
          // 当请求队列中的请求数达到最大并行请求数的时候，得等之前的请求完成再循环下一个
          await Promise.race(taskPool)
        }
        index++
      }
      await Promise.all(taskPool)
    }

    /**
     * 上传分片、文件
     *
     * @param file
     * @param fileMd5
     * @param currentIndex
     * @return
     */
    @Override
    public Integer uploadFile(MultipartFile file, String fileMd5, Integer currentIndex) {
        //在redis中查询该分片是否已经存在
        if (redisTemplate.opsForSet().isMember(fileMd5, currentIndex)) {
            return currentIndex;
        }
        // 生成分片的临时路径
        String filePath = tempPath + fileMd5 + "_" + currentIndex + ".tmp";
        //保存文件分片到本地的目标路径
        File targetFile = new File(filePath);
        try {
            RandomAccessFile raf = new RandomAccessFile(targetFile, "rw");
            byte[] data = file.getBytes();
            raf.write(data);
            raf.close();
            //在redis中保存该分片的索引
            redisTemplate.opsForSet().add(fileMd5, currentIndex);
            return currentIndex;
        } catch (IOException e) {
            // 处理异常
            throw new ServiceException("文件上传失败");
        }
    }

    //发起文件合并请求
    merge() {
      axios.get('/api/file/merge' + '?fileMd5=' + this.key + '&fileName=' + this.filename + '&chunkCount=' + this.fileChunks.length).then((resp) => {
        if (resp.data.flag == true) {
          this.$message({
            message: '文件上传成功',
            type: 'success'
          });
          this.percentage = 100;
          this.query();
          this.uploadRefresh=false;
        }
      })
    }

    /**
     * 合并分片文件
     *
     * @param fileName
     * @param chunkCount
     * @return
     */
    @Override
    public String mergeTmpFiles(String fileMd5, String fileName, Integer chunkCount, String userId) throws IOException {
        //记录本次合并的字节数
        long count = 0;
        //获取分片索引号的起始地址
        int start = 0 ;
        String countKey = fileMd5+"-count";
        if (!redisTemplate.hasKey(countKey)) {
            redisTemplate.opsForHash().put(countKey, "count", "0");
        }else {
            start = Integer.parseInt(redisTemplate.opsForHash().get(countKey, "count").toString());
            start++;
        }
        //记录分片文件的总大小
        for (int i = start; i < chunkCount; i++) {
            //读取分片文件
            String filePath = tempPath + fileMd5 + "_" + i + ".tmp";
            File file = new File(filePath);
            if (!file.exists()) {
                //需要排除redis造成的异常情况
                redisTemplate.opsForSet().remove(fileMd5, i);
                log.info("缺失索引编号", i);
                throw new ServiceException("文件分片缺失");
            } else {
                count += file.length();
            }
            //使用缓冲流读取到内存中
            byte[] data = new byte[(int) file.length()];
            FileInputStream inputStream = new FileInputStream(file);
            inputStream.read(data);
            inputStream.close();
            //保存文件到文件夹中
            file = new File(endPath + fileMd5 + "." + getFileExtension(fileName));
            FileOutputStream outputStream = new FileOutputStream(file, true);
            outputStream.write(data);
            outputStream.close();
            //删除碎片文件
            File temp = new File(filePath);
            temp.delete();
            //记录合并进度
            redisTemplate.opsForHash().put(countKey, "count", i);
        }
        //记录文件保存数据
        MyFile myFile = new MyFile();
        myFile.setId(userId + DateTimeUtil.getTimeStamp());
        myFile.setFileName(fileName);
        myFile.setUser(userId);
        myFile.setFileMd5(fileMd5);
        File file = new File(endPath + fileMd5 + "." + getFileExtension(fileName));
        myFile.setFileSize(file.length());
        myFile.setTime(LocalDateTime.parse(DateTimeUtil.getDateTime(), DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        fileMapper.insert(myFile);
        //删除各类缓存数据
        redisTemplate.delete(countKey);
        redisTemplate.delete(fileMd5);
        //返回处理结果
        return fileName + "  此次合并:" + count + "字节";
    }