一杯可乐、

一杯可乐、

关注
发信
关注(28)粉丝(399)

【SpringBoot】优雅实现超大文件上传

前言

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

秒传

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如何进行分片，具体实现可以查看如下链接:

b、后端用两种方式实现文件写入，一种是用RandomAccessFile，如果对RandomAccessFile不熟悉的朋友，可以查看如下链接:

另一种是使用MappedByteBuffer，对MappedByteBuffer不熟悉的朋友，可以查看如下链接进行了解:

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

a、RandomAccessFile实现方式

@UploadMode(mode=UploadModeEnum.RANDOM_ACCESS)
@Slf4j
publicclassRandomAccessUploadStrategyextendsSliceUploadTemplate{

    @Autowired
    privateFilePathUtilfilePathUtil;

    @Value("${upload.chunkSize}")
    privatelongdefaultChunkSize;

    @Override
    publicbooleanupload(FileUploadRequestDTOparam){
        RandomAccessFileaccessTmpFile=null;
        try{
            StringuploadDirPath=filePathUtil.getPath(param);
            FiletmpFile=super.createTmpFile(param);
            accessTmpFile=newRandomAccessFile(tmpFile,"rw");
            //这个必须与前端设定的值一致
            longchunkSize=Objects.isNull(param.getChunkSize())?defaultChunkSize\*1024\*1024
            :param.getChunkSize();
            longoffset=chunkSize\*param.getChunk();
            //定位到该分片的偏移量
            accessTmpFile.seek(offset);
            //写入该分片数据
            accessTmpFile.write(param.getFile().getBytes());
            booleanisOk=super.checkAndSetUploadProgress(param,uploadDirPath);
            returnisOk;
        }catch(IOExceptione){
            log.error(e.getMessage(),e);
        }finally{
            FileUtil.close(accessTmpFile);
        }
        returnfalse;
    }

}

b、MappedByteBuffer实现方式

@UploadMode(mode=UploadModeEnum.MAPPED_BYTEBUFFER)
@Slf4j
publicclassMappedByteBufferUploadStrategyextendsSliceUploadTemplate{

    @Autowired
    privateFilePathUtilfilePathUtil;

    @Value("${upload.chunkSize}")
    privatelongdefaultChunkSize;

    @Override
    publicbooleanupload(FileUploadRequestDTOparam){

        RandomAccessFiletempRaf=null;
        FileChannelfileChannel=null;
        MappedByteBuffermappedByteBuffer=null;
        try{
            StringuploadDirPath=filePathUtil.getPath(param);
            FiletmpFile=super.createTmpFile(param);
            tempRaf=newRandomAccessFile(tmpFile,"rw");
            fileChannel=tempRaf.getChannel();

            longchunkSize=Objects.isNull(param.getChunkSize())?defaultChunkSize\*1024\*1024
            :param.getChunkSize();
            //写入该分片数据
            longoffset=chunkSize\*param.getChunk();
            byte\[\]fileData=param.getFile().getBytes();
            mappedByteBuffer=fileChannel
            .map(FileChannel.MapMode.READ_WRITE,offset,fileData.length);
            mappedByteBuffer.put(fileData);
            booleanisOk=super.checkAndSetUploadProgress(param,uploadDirPath);
            returnisOk;

        }catch(IOExceptione){
            log.error(e.getMessage(),e);
        }finally{

            FileUtil.freedMappedByteBuffer(mappedByteBuffer);
            FileUtil.close(fileChannel);
            FileUtil.close(tempRaf);

        }

        returnfalse;
    }

}

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

@Slf4j
publicabstractclassSliceUploadTemplateimplementsSliceUploadStrategy{

    publicabstractbooleanupload(FileUploadRequestDTOparam);

    protectedFilecreateTmpFile(FileUploadRequestDTOparam){

        FilePathUtilfilePathUtil=SpringContextHolder.getBean(FilePathUtil.class);
        param.setPath(FileUtil.withoutHeadAndTailDiagonal(param.getPath()));
        StringfileName=param.getFile().getOriginalFilename();
        StringuploadDirPath=filePathUtil.getPath(param);
        StringtempFileName=fileName+"_tmp";
        FiletmpDir=newFile(uploadDirPath);
        FiletmpFile=newFile(uploadDirPath,tempFileName);
        if(!tmpDir.exists()){
            tmpDir.mkdirs();
        }
        returntmpFile;
    }

    @Override
    publicFileUploadDTOsliceUpload(FileUploadRequestDTOparam){

        booleanisOk=this.upload(param);
        if(isOk){
            FiletmpFile=this.createTmpFile(param);
            FileUploadDTOfileUploadDTO=this.saveAndFileUploadDTO(param.getFile().getOriginalFilename(),tmpFile);
            returnfileUploadDTO;
        }
        Stringmd5=FileMD5Util.getFileMD5(param.getFile());

        Map\<Integer,String\>map=newHashMap\<\>();
        map.put(param.getChunk(),md5);
        returnFileUploadDTO.builder().chunkMd5Info(map).build();
    }

    /**
*检查并修改文件上传进度
*/
    publicbooleancheckAndSetUploadProgress(FileUploadRequestDTOparam,StringuploadDirPath){

        StringfileName=param.getFile().getOriginalFilename();
        FileconfFile=newFile(uploadDirPath,fileName+".conf");
        byteisComplete=0;
        RandomAccessFileaccessConfFile=null;
        try{
            accessConfFile=newRandomAccessFile(confFile,"rw");
            //把该分段标记为true表示完成
            System.out.println("setpart"+param.getChunk()+"complete");
            //创建conf文件文件长度为总分片数，每上传一个分块即向conf文件中写入一个127，那么没上传的位置就是默认0,已上传的就是Byte.MAX_VALUE127
            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(inti=0;i\<completeList.length\&\&isComplete==Byte.MAX_VALUE;i++){
                //与运算,如果有部分没有完成则isComplete不是Byte.MAX_VALUE
                isComplete=(byte)(isComplete\&completeList\[i\]);
                System.out.println("checkpart"+i+"complete?:"+completeList\[i\]);
            }

        }catch(IOExceptione){
            log.error(e.getMessage(),e);
        }finally{
            FileUtil.close(accessConfFile);
        }
        booleanisOk=setUploadProgress2Redis(param,uploadDirPath,fileName,confFile,isComplete);
        returnisOk;
    }

    /**
*把上传进度信息存进redis
*/
    privatebooleansetUploadProgress2Redis(FileUploadRequestDTOparam,StringuploadDirPath,
                                          StringfileName,FileconfFile,byteisComplete){

        RedisUtilredisUtil=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();
            returntrue;
        }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");
            }

            returnfalse;
        }
    }
    /**
*保存文件操作
*/
    publicFileUploadDTOsaveAndFileUploadDTO(StringfileName,FiletmpFile){

        FileUploadDTOfileUploadDTO=null;

        try{

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

            }

        }catch(Exceptione){
            log.error(e.getMessage(),e);
        }finally{

        }
        returnfileUploadDTO;
    }
    /**
*文件重命名
*
*@paramtoBeRenamed将要修改名字的文件
*@paramtoFileNewName新的名字
*/
    privateFileUploadDTOrenameFile(FiletoBeRenamed,StringtoFileNewName){
        //检查要重命名的文件是否存在，是否是文件
        FileUploadDTOfileUploadDTO=newFileUploadDTO();
        if(!toBeRenamed.exists()\|\|toBeRenamed.isDirectory()){
            log.info("Filedoesnotexist:{}",toBeRenamed.getName());
            fileUploadDTO.setUploadComplete(false);
            returnfileUploadDTO;
        }
        Stringext=FileUtil.getExtension(toFileNewName);
        Stringp=toBeRenamed.getParent();
        StringfilePath=p+FileConstant.FILE_SEPARATORCHAR+toFileNewName;
        FilenewFile=newFile(filePath);
        //修改文件名
        booleanuploadFlag=toBeRenamed.renameTo(newFile);

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

        returnfileUploadDTO;
    }
}

总结

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

03-21 10:42
Powered by LMLPHP ©2024 一杯可乐、 0.002061