springboot大文件上传、分片上传、断点续传、秒传的实现

对于大文件的处理,无论是用户端还是服务端,如果一次性进行读取发送、接收都是不可取,很容易导致内存问题。所以对于大文件上传,采用切块分段上传,从上传的效率来看,利用多线程并发上传能够达到最大效率。

本文是基于 springboot + vue 实现的文件上传,本文主要介绍服务端实现文件上传的步骤及代码实现,vue的实现步骤及实现请移步本人的另一篇文章

vue 大文件分片上传 - 断点续传、并发上传

上传分步:

本人分析上传总共分为:

  • 检查文件是否已上传,如已上传可实现秒传
  • 创建临时文件(._tmp)和上传的配置文件(.conf)
  • 使用RandomAccessFile获取临时文件
  • 调用RandomAccessFile的getChannel()方法,打开文件通道 FileChannel
  • 获取当前是第几个分块,计算文件的最后偏移量
  • 获取当前文件分块的字节数组,用于获取文件字节长度
  • 使用文件通道FileChannel类的 map()方法创建直接字节缓冲器 MappedByteBuffer
  • 将分块的字节数组放入到当前位置的缓冲区内 mappedByteBuffer.put(byte[] b)
  • 释放缓冲区
  • 检查文件是否全部完成上传,如上传完成将临时文件名为正式文件名

直接上代码

public class FlieChunkUtils {
 
    /**
     * 分块上传
     * 第一步:获取RandomAccessFile,随机访问文件类的对象
     * 第二步:调用RandomAccessFile的getChannel()方法,打开文件通道 FileChannel
     * 第三步:获取当前是第几个分块,计算文件的最后偏移量
     * 第四步:获取当前文件分块的字节数组,用于获取文件字节长度
     * 第五步:使用文件通道FileChannel类的 map()方法创建直接字节缓冲器  MappedByteBuffer
     * 第六步:将分块的字节数组放入到当前位置的缓冲区内  mappedByteBuffer.put(byte[] b);
     * 第七步:释放缓冲区
     * 第八步:检查文件是否全部完成上传
     *
     * @param param
     * @return
     * @throws Exception
     */
    public static ApiResult uploadByMappedByteBuffer(MultipartFileParam param) throws Exception {
        if (param.getIdentifier() == null || "".equals(param.getIdentifier())) {
            param.setIdentifier(UUID.randomUUID().toString());
        }
        // 判断是否上传
        if (ObjectUtil.isEmpty(param.getFile())) {
            return checkUploadStatus(param);
        }
        // 文件名称
        String fileName = getFileName(param);
        // 临时文件名称
        String tempFileName = param.getIdentifier() + fileName.substring(fileName.lastIndexOf(".")) + "_tmp";
        // 获取文件路径
        String filePath = getUploadPath(param);
        // 创建文件夹
        FileUploadUtils.getAbsoluteFile(filePath, fileName);
        // 创建临时文件
        File tempFile = new File(filePath, tempFileName);
        //第一步 获取RandomAccessFile,随机访问文件类的对象
        RandomAccessFile raf = RandomAccessFileUitls.getModelRW(tempFile);
        //第二步 调用RandomAccessFile的getChannel()方法,打开文件通道 FileChannel
        FileChannel fileChannel = raf.getChannel();
        //第三步 获取当前是第几个分块,计算文件的最后偏移量
        long offset = (param.getChunkNumber() - 1) * param.getChunkSize();
        //第四步 获取当前文件分块的字节数组,用于获取文件字节长度
        byte[] fileData = param.getFile().getBytes();
        //第五步 使用文件通道FileChannel类的 map()方法创建直接字节缓冲器  MappedByteBuffer
        MappedByteBuffer mappedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, offset, fileData.length);
        //第六步 将分块的字节数组放入到当前位置的缓冲区内  mappedByteBuffer.put(byte[] b)
        mappedByteBuffer.put(fileData);
        //第七步 释放缓冲区
        freeMappedByteBuffer(mappedByteBuffer);
        fileChannel.close();
        raf.close();
        //第八步 检查文件是否全部完成上传
        ApiResult result = ApiResult.success();
        boolean isComplete = checkUploadStatus(param, fileName, filePath);
        if (isComplete) {
            // 完成后,临时文件名为正式文件名
            renameFile(tempFile, fileName);
            result.put("endUpload", true);
        }
 
        result.put("filePath", FileUploadUtils.getPathFileName(filePath, fileName));
        result.put("fileName", param.getFile().getOriginalFilename());
        return result;
    }
 
    /**
     * 检查文件是否上传
     *
     * @param param
     * @return
     * @throws Exception
     */
    public static ApiResult checkUploadStatus(MultipartFileParam param) throws Exception {
        String fileName = getFileName(param);
        // 校验conf文件
        File confFile = checkConfFile(fileName, getUploadPath(param));
        // 获取完成列表
        byte[] completeStatusList = FileUtils.readFileToByteArray(confFile);
        List<String> uploadeds = new ArrayList<>();
        for (int i = 0; i < completeStatusList.length; i++) {
            if (completeStatusList[i] == Byte.MAX_VALUE) {
                uploadeds.add(i + 1 + "");
            }
        }
        ApiResult<Void> success = ApiResult.success();
        success.put("uploaded", uploadeds);
        success.put("skipUpload", completeStatusList.length > 0 && completeStatusList.length == uploadeds.size());
        // 新文件
        if (ObjectUtil.isEmpty(completeStatusList)) {
            success.put("chunk", false);
            return success;
        }
        if (completeStatusList.length < param.getChunkNumber()) {
            success.put("chunk", false);
            return success;
        }
        byte b = completeStatusList[param.getChunkNumber() - 1];
        if (b != Byte.MAX_VALUE) {
            success.put("chunk", false);
            return success;
        }
        success.put("filePath", FileUploadUtils.getPathFileName(getUploadPath(param), fileName));
        success.put("chunk", true);
        return success;
    }
 
    /**
     * 文件下载
     *
     * @param filePath 文件地址
     * @param request
     * @param response
     * @throws IOException
     */
    public static void download(String filePath, HttpServletRequest request, HttpServletResponse response) throws IOException {
        // 初始化 response
        response.reset();
        // 获取文件
        File file = new File(getDownloadPath(filePath));
        long fileLength = file.length();
        //获取从那个字节开始读取文件
        String rangeString = request.getHeader("Range");
        long range = 0;
        if (StrUtil.isNotBlank(rangeString)) {
            range = Long.valueOf(rangeString.substring(rangeString.indexOf("=") + 1, rangeString.indexOf("-")));
        }
        if (range >= fileLength) {
            throw new CustomException("文件读取长度过长");
        }
        long byteLength = 1024 * 1024;
        if (range + byteLength > fileLength) {
            byteLength = fileLength;
        }
        // 随机读文件RandomAccessFile
        RandomAccessFile randomAccessFile = new RandomAccessFile(file, "r");
        try {
            // 移动访问指针到指定位置
            randomAccessFile.seek(range);
            // 每次请求只返回1MB的视频流
            byte[] bytes = new byte[(int) byteLength];
            int len = randomAccessFile.read(bytes);
            //获取响应的输出流
            OutputStream outputStream = response.getOutputStream();
            //返回码需要为206,代表只处理了部分请求,响应了部分数据
            response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);
            //设置此次相应返回的数据长度
            response.setContentLength(len);
            //设置此次相应返回的数据范围
            response.setHeader("Content-Range", "bytes " + range + "-" + len + "/" + fileLength);
            // 将这1MB的视频流响应给客户端
            outputStream.write(bytes, 0, len);
            outputStream.close();
            //randomAccessFile.close();
            System.out.println("返回数据区间:【" + range + "-" + (range + len) + "】");
        } finally {
            randomAccessFile.close();
        }
    }
 
    /**
     * 文件重命名
     *
     * @param toBeRenamed   将要修改名字的文件
     * @param toFileNewName 新的名字
     * @return
     */
    private static boolean renameFile(File toBeRenamed, String toFileNewName) {
        //检查要重命名的文件是否存在,是否是文件
        if (!toBeRenamed.exists() || toBeRenamed.isDirectory()) {
            return false;
        }
        String p = toBeRenamed.getParent();
        File newFile = new File(p + File.separatorChar + toFileNewName);
        //修改文件名
        return toBeRenamed.renameTo(newFile);
    }
 
    /**
     * 检查文件上传进度
     *
     * @return
     */
    private static boolean checkUploadStatus(MultipartFileParam param, String fileName, String filePath) throws Exception {
        // 校验conf文件
        File confFile = checkConfFile(fileName, filePath);
        // 读取conf
        RandomAccessFile confAccessFile = new RandomAccessFile(confFile, "rw");
        //设置文件长度
        if (confAccessFile.length() != param.getTotalChunks()) {
            confAccessFile.setLength(param.getTotalChunks());
        }
        //设置起始偏移量
        confAccessFile.seek(param.getChunkNumber() - 1);
        //将指定的一个字节写入文件中 127,
        confAccessFile.write(Byte.MAX_VALUE);
        byte[] completeStatusList = FileUtils.readFileToByteArray(confFile);
        byte isComplete = Byte.MAX_VALUE;
        //这一段逻辑有点复杂,看的时候思考了好久,创建conf文件文件长度为总分片数,每上传一个分块即向conf文件中写入一个127,那么没上传的位置就是默认的0,已上传的就是Byte.MAX_VALUE 127
        for (int i = 0; i < completeStatusList.length && isComplete == Byte.MAX_VALUE; i++) {
            // 按位与运算,将&两边的数转为二进制进行比较,有一个为0结果为0,全为1结果为1  eg.3&5  即 0000 0011 & 0000 0101 = 0000 0001   因此,3&5的值得1。
            isComplete = (byte) (isComplete & completeStatusList[i]);
        }
        if (isComplete == Byte.MAX_VALUE) {
            //如果全部文件上传完成,删除conf文件
            // FileUtils.deleteFile(confFile.getPath());
            return true;
        }
        return false;
    }
 
 
    /**
     * 在MappedByteBuffer释放后再对它进行读操作的话就会引发jvm crash,在并发情况下很容易发生
     * 正在释放时另一个线程正开始读取,于是crash就发生了。所以为了系统稳定性释放前一般需要检 查是否还有线程在读或写
     *
     * @param mappedByteBuffer
     */
    private static void freeMappedByteBuffer(final MappedByteBuffer mappedByteBuffer) {
        try {
            if (mappedByteBuffer == null) {
                return;
            }
            mappedByteBuffer.force();
            AccessController.doPrivileged(new PrivilegedAction<Object>() {
                @Override
                public Object run() {
                    try {
                        Method getCleanerMethod = mappedByteBuffer.getClass().getMethod("cleaner", new Class[0]);
                        //可以访问private的权限
                        getCleanerMethod.setAccessible(true);
                        //在具有指定参数的 方法对象上调用此 方法对象表示的底层方法
                        sun.misc.Cleaner cleaner = (sun.misc.Cleaner) getCleanerMethod.invoke(mappedByteBuffer,
                                new Object[0]);
                        cleaner.clean();
                    } catch (Exception e) {
                        log.error("clean MappedByteBuffer error!!!", e);
                    }
                    return null;
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    private static String getFileName(MultipartFileParam param) {
        String extension;
        if (ObjectUtil.isNotEmpty(param.getFile())) {
            // return param.getFile().getOriginalFilename();
            String filename = param.getFile().getOriginalFilename();
            extension = filename.substring(filename.lastIndexOf("."));
            //return  FileUploadUtils.extractFilename(param.getFile());
        } else {
            extension = param.getFilename().substring(param.getFilename().lastIndexOf("."));
            //return DateUtils.datePath() + "/" + IdUtil.fastUUID() + extension;
        }
        return param.getIdentifier() + extension;
    }
 
    private static String getUploadPath(MultipartFileParam param) {
        return FileUploadUtils.getDefaultBaseDir() + "/" + param.getObjectType();
    }
 
    private static String getDownloadPath(String filePath) {
        // 本地资源路径
        String localPath = WhspConfig.getProfile();
        // 数据库资源地址
        String loadPath = localPath + StrUtil.subAfter(filePath, Constants.RESOURCE_PREFIX, false);
        return loadPath;
    }
 
    private static File checkConfFile(String fileName, String filePath) throws Exception {
        File confFile = FileUploadUtils.getAbsoluteFile(filePath, fileName + ".conf");
        if (!confFile.exists()) {
            confFile.createNewFile();
        }
        return confFile;
    }
}

到此这篇关于springboot大文件上传、分片上传、断点续传、秒传的实现的文章就介绍到这了,更多相关springboot大文件上传内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • SpringBoot 中大文件(分片上传)断点续传与极速秒传功能的实现

    1.创建SpringBoot项目 本项目采用springboot + mybatis-plus +jquery +thymeleaf组成 2.项目流程图 3.在pom中添加以下依赖 <!--lombok依赖--> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optio

  • springboot大文件上传、分片上传、断点续传、秒传的实现

    对于大文件的处理,无论是用户端还是服务端,如果一次性进行读取发送.接收都是不可取,很容易导致内存问题.所以对于大文件上传,采用切块分段上传,从上传的效率来看,利用多线程并发上传能够达到最大效率. 本文是基于 springboot + vue 实现的文件上传,本文主要介绍服务端实现文件上传的步骤及代码实现,vue的实现步骤及实现请移步本人的另一篇文章 vue 大文件分片上传 - 断点续传.并发上传 上传分步: 本人分析上传总共分为: 检查文件是否已上传,如已上传可实现秒传 创建临时文件(._tmp

  • React+Node实现大文件分片上传、断点续传秒传思路

    目录 1.整体思路 2.实现步骤 2.1 文件切片加密 2.2 查询上传文件状态 2.3 秒传 2.4 上传分片.断点续传 2.5 合成分片还原完整文件 3.总结 4.后续扩展与思考 5.源码 1.整体思路 将文件切成多个小的文件: 将切片并行上传: 所有切片上传完成后,服务器端进行切片合成: 当分片上传失败,可以在重新上传时进行判断,只上传上次失败的部分实现断点续传: 当切片合成为完整的文件,通知客户端上传成功: 已经传到服务器的完整文件,则不需要重新上传到服务器,实现秒传功能: 2.实现步骤

  • golang gin框架实现大文件的流式上传功能

    目录 upload.html gin_stream_upload_file.go 一般来说,通过c.Request.FormFile()获取文件的时候,所有内容都全部读到了内存.如果是个巨大的文件,则可能内存会爆掉:且,有的时候我们需要一边上传一边处理.以下的代码实现了大文件流式上传.还非常不完美,但是可以作为参考: upload.html <!DOCTYPE html> <html lang="en"> <head> <meta charse

  • 关于SpringBoot大文件RestTemplate下载解决方案

    近期基于项目上使用到的RestTemplate下载文件流,遇到1G以上的大文件,下载需要3-4分钟,因为调用API接口没有做分片与多线程, 文件流全部采用同步方式加载,性能很慢.最近结合网上案例及自己总结,写了一个分片下载tuling/fileServer项目: 1.包含同步下载文件流在浏览器加载输出相关代码: 2.包含分片多线程下载分片文件及合并文件相关代码: 另外在DownloadThread项目中使用代码完成了一个远程RestUrl请求去获取一个远端资源大文件进行多线程分片下载 到本地的一

  • SpringBoot文件分片上传的示例代码

    目录 背景 文件MD5计算 文件分片切割 文件分片接收 检查分片 保存分片 合并分片 云文件分片上传 阿里云OSS 华为云OBS Minio 背景 最近好几个项目在运行过程中客户都提出文件上传大小的限制能否设置的大一些,用户经常需要上传好几个G的资料文件,如图纸,视频等,并且需要在上传大文件过程中进行优化实时展现进度条,进行技术评估后针对框架文件上传进行扩展升级,扩展接口支持大文件分片上传处理,减少服务器瞬时的内存压力,同一个文件上传失败后可以从成功上传分片位置进行断点续传,文件上传成功后再次上

  • vue 大文件分片上传(断点续传、并发上传、秒传)

    对于大文件的处理,无论是用户端还是服务端,如果一次性进行读取发送.接收都是不可取,很容易导致内存问题.所以对于大文件上传,采用切块分段上传,从上传的效率来看,利用多线程并发上传能够达到最大效率. 本文是基于 springboot + vue 实现的文件上传,本文主要介绍vue实现文件上传的步骤及代码实现,服务端(springboot)的实现步骤及实现请移步本人的另一篇文章: springboot 大文件上传.分片上传.断点续传.秒传 上传分步: 本人分析上传总共分为: MD5读取文件,获取文件的

  • .NET Core Web APi大文件分片上传研究实现

    前言 前两天发表利用FormData进行文件上传,然后有人问要是大文件几个G上传怎么搞,常见的不就是分片再搞下断点续传,动动手差不多也能搞出来,只不过要深入的话,考虑的东西还是很多.由于断点续传之前写个几篇,这里试试利用FormData来进行分片上传. .NET Core Web APi文件分片上传 这里我们依然是使用FormData来上传,只不过在上传之前对文件进行分片处理,如下HTML代码 <div class="form-horizontal" style="ma

  • Java实现浏览器端大文件分片上传

    目录 背景介绍 项目介绍 需要知识点 启动项目 项目示范 核心讲解 核心原理 功能分析 分块上传 秒传功能 断点续传 总结 参考文献 背景介绍   Breakpoint-http,是不是觉得这个名字有点low,break point断点.这是一个大文件上传的一种实现.因为本来很久没写过前端了,本来想自己好好写一番js,可惜因为种种原因而作罢了.该项目是基于一款百度开源的前端上传控件:WebUploader(百度开源的东西文档一如既往的差,哈哈.或者是我理解能力差).   Breakpoint-h

  • Java超详细大文件分片上传代码

    目录 Java 大文件分片上传 首先是交互的控制器 上传文件分片参数接收 大文件分片上传服务类实现 文件分片上传定义公共服务类接口 文件分片上传文件操作接口实现类 OSS阿里云对象存储分片上传实现 京东云对象存储实现 腾讯云对象存储分片上传 分片上传前端代码实现 Java 大文件分片上传 原理:前端通过js读取文件,并将大文件按照指定大小拆分成多个分片,并且计算每个分片的MD5值.前端将每个分片分别上传到后端,后端在接收到文件之后验证当前分片的MD5值是否与上传的MD5一致,待所有分片上传完成之

随机推荐