文件传输 断点续传

于 2024-06-24 00:22:17 发布
阅读量303 收藏 3
点赞数 3
分类专栏： Java SpringBoot SpringCloud 文章标签： java springboot springcloud
如有问题，欢迎指正！
本文链接：https://blog.csdn.net/weixin_45247019/article/details/139890533
版权

什么是断点续传

简单来说断点续传指的是文件在上传或下载的过程中，由于网络差断开了，那么下次上传或下载时应该从断点处开始。

怎么实现

  1. 前端对文件进行分块
  2. 前端使用多线程一块一块上传，上传前给服务端发一个消息检验该分块是否上传，如果已上传则不再上传。
  3. 等所有分块上传完毕，服务端合并所有分块，校验文件的完整性。（
    因为分块全部上传到了服务器，服务器将所有分块按顺序进行合并，就是写每个分块文件内容按顺序依次写入一个文件中。）
  4. 前端给服务传一个md5值，服务端合并文件后计算合并后的文件的md5是否一样，一样说明完整，否则不完整，需要重新上传。

此外针对文件上传一半不传了，之前上传到的minio 分块文件需要清理

  1. 在数据库中记录minio存储的文件信息的文件表
  2. 文件开始上传时写入文件表，状态为上传中，上传成功更新状态为上传完成
  3. 当一个文件传了一半不在上传了说明该文件没有上传完成，会有定时任务去查询文件表中的记录，如果文件未上传完成则删除minio 中没有上传成功的文件目录。

需要注意的是 minio 合并 每一分块文件最少是5MB 否则会报错，此外上传分块的文件如果大于1MB，SpringBoot不允许 默认是1MB 因此通过以下配置修改为50MB。

#文件上传大小默认1M 改为50M
spring:
  servlet:
    multipart:
      max-file-size: 50MB
      maxrequest-size: 50MB

大文件分块 合并 本地单元测试

package com.jhj.media;

import io.minio.ComposeObjectArgs;
import io.minio.ComposeSource;
import io.minio.MinioClient;
import io.minio.UploadObjectArgs;
import io.minio.errors.*;
import org.apache.commons.codec.digest.DigestUtils;
import org.junit.jupiter.api.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author jhj
 * @version 1.0.0
 * @ClassName BigFileTest.java
 * @Description TODO
 * @createTime 2024年06月23日 00:35:00
 */
public class BigFileTest {
    MinioClient minioClient = MinioClient
            .builder()
            .endpoint("http://192.168.56.200:49160")
            .credentials("minio", "12345678")
            .build();

    //分块测试
    @Test
    public void testChunk() throws IOException {
        //源文件
        File sourceFile = new File("G:\\1.mp4");
        //分块文件存储路径
        String chunkFilePath = "G:\\chunk\\";
        //分块文件大小
        int chunkSize = 1024 * 1024 * 5;
        //分块文件的个数
        int chunkNum = (int) Math.ceil(sourceFile.length() * 1.0 / chunkSize);
        //使用流对源文件读数据，向分块文件中写数据
        RandomAccessFile raf_r = new RandomAccessFile(sourceFile, "r");
        //缓存区 临时存文件数据的
        byte[] bytes = new byte[1024];
        for (int i = 0; i < chunkNum; i++) {
            File chunkFile = new File(chunkFilePath + i);
            //分块文件的写入流
            RandomAccessFile raf_rw = new RandomAccessFile(chunkFile, "rw");
            int len = -1;
            while ((len = raf_r.read(bytes)) != -1) {
                raf_rw.write(bytes, 0, len);
                if (chunkFile.length() >= chunkSize) {
                    break;
                }
            }
            raf_rw.close();
        }
        raf_r.close();
    }

    @Test
    public void testMerge() throws IOException {
        //分块路径
        String chunkFilePath = "G:\\chunk\\";
        File chunkFolder = new File(chunkFilePath);
        //源文件
        File sourceFile = new File("G:\\1.mp4");
        //合并后的文件
        File mergeFile = new File("G:\\2.mp4");
        //取出所有的分块文件
        File[] files = chunkFolder.listFiles();
        //将数组转为list
        List<File> fileList = Arrays.asList(files);
        Collections.sort(fileList, new Comparator<File>() {
            @Override
            public int compare(File o1, File o2) {
                return Integer.parseInt(o1.getName()) -
                        Integer.parseInt(o2.getName());
            }
        });
        RandomAccessFile raf_rw = new RandomAccessFile(mergeFile, "rw");
        byte[] bytes = new byte[1024];
        for (File file : fileList) {
            //读
            RandomAccessFile raf_r = new RandomAccessFile(file, "r");
            int len = -1;
            while ((len = raf_r.read(bytes)) != -1) {
                raf_rw.write(bytes, 0, len);
            }
            raf_r.close();
        }
        raf_rw.close();

        //合并文件完成，进行校验，判断有没有丢包
        String s = DigestUtils.md5Hex(new FileInputStream(mergeFile));
        String s1 = DigestUtils.md5Hex(new FileInputStream(sourceFile));
        if (s.equals(s1)) {
            System.out.println("合并成功");
        }
    }

    //将分块文件上传到minio
    @Test
    public void uploadChunk() throws IOException, ServerException, InsufficientDataException, ErrorResponseException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        for (int i = 0; i <= 254; i++) {
            minioClient.uploadObject(
                    UploadObjectArgs.builder()
                            .bucket("testbucket")
                            .filename("G:/chunk/" + i)//指定本地文件路径
                            .object("chunk/" + i) //桶下路径
                            .build()
            );
            System.out.println("上传分块" + i + "成功");
        }
    }

    //调用minio 接口合并分块
    @Test
    public void testMergeFile() throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        //指定分块信息
        List<ComposeSource> sources = Stream.iterate(0, i -> ++i).limit(255).map(i -> {
            return ComposeSource.builder().bucket("testbucket").object("chunk/" + i).build();
        }).collect(Collectors.toList());

        //合并信息 minio默认合并大小为5M
        ComposeObjectArgs testbucket = ComposeObjectArgs.builder().bucket("testbucket")
                .object("merge01.mp4")
                .sources(sources)
                .build();
        //合并文件
        minioClient.composeObject(testbucket);
    }

}

按照业务要求 前端分块 检查分块是否上传 上传分块 合并分块 检验完整性 清除分块 service 实现断点续传

保证文件只被上传一次利用 加密流的md5作为唯一值

package com.jhj.media.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.j256.simplemagic.ContentInfo;
import com.j256.simplemagic.ContentInfoUtil;
import com.jhj.base.exception.UltimateException;
import com.jhj.base.model.PageParams;
import com.jhj.base.model.PageResult;
import com.jhj.base.model.RestResponse;
import com.jhj.media.mapper.MediaFilesMapper;
import com.jhj.media.model.dto.QueryMediaParamsDto;
import com.jhj.media.model.dto.UploadFileParamsDto;
import com.jhj.media.model.dto.UploadFileResultDto;
import com.jhj.media.model.po.MediaFiles;
import com.jhj.media.service.MediaFileService;
import io.minio.*;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.compress.utils.IOUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.*;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author jhj
 * @version 1.0
 * @description TODO
 * @date 2022/9/10 8:58
 */
@Service
@Slf4j
public class MediaFileServiceImpl implements MediaFileService {
    @Autowired
    MediaFilesMapper mediaFilesMapper;

    @Autowired
    MinioClient minioClient;

    @Autowired
    @Lazy
    MediaFileService currentProxy;

    //存储普通文件
    @Value("${minio.bucket.files}")
    private String bucket_mediafiles;

    //存储视频
    @Value("${minio.bucket.videofiles}")
    private String bucket_video;


    @Override
    public PageResult<MediaFiles> queryMediaFiels(Long companyId, PageParams pageParams, QueryMediaParamsDto queryMediaParamsDto) {

        //构建查询条件对象
        LambdaQueryWrapper<MediaFiles> queryWrapper = new LambdaQueryWrapper<>();

        //分页对象
        Page<MediaFiles> page = new Page<>(pageParams.getPageNo(), pageParams.getPageSize());
        // 查询数据内容获得结果
        Page<MediaFiles> pageResult = mediaFilesMapper.selectPage(page, queryWrapper);
        // 获取数据列表
        List<MediaFiles> list = pageResult.getRecords();
        // 获取数据总数
        long total = pageResult.getTotal();
        // 构建结果集
        PageResult<MediaFiles> mediaListResult = new PageResult<>(list, total, pageParams.getPageNo(), pageParams.getPageSize());
        return mediaListResult;

    }

    @Override
    //为什么不在这里加事务 是因为防止minio 网络连接时间长而导致数据库连接超时 占用数据库事务资源
    public UploadFileResultDto uploadFile(Long companyId, UploadFileParamsDto uploadFileParamsDto, String localFilePath) {
        //文件名
        String filename = uploadFileParamsDto.getFilename();
        //拿到扩展名
        String extension = filename.substring(filename.lastIndexOf("."));
        //拿到mimeType
        String mimeType = getMimeType(extension);
        //文件的md5
        String fileMd5 = getFileMd5(new File(localFilePath));
        //目录
        String defaultFolderPath = getDefaultFolderPath();
        String objectName = defaultFolderPath + fileMd5 + extension;
        //将文件上传Minio
        boolean result = addMediaFilesToMinio(localFilePath, mimeType, bucket_mediafiles, objectName);
        if(!result){
            UltimateException.cast("上传文件失败");
        }

        //将文件信息保存到数据库
        MediaFiles mediaFiles = currentProxy.addMediaFilesToDb(companyId, fileMd5, uploadFileParamsDto, bucket_mediafiles, objectName);
        if(mediaFiles==null){
            UltimateException.cast("文件上传后，保存信息失败");
        }

        //返回对象
        UploadFileResultDto uploadFileResultDto = new UploadFileResultDto();
        BeanUtils.copyProperties(mediaFiles,uploadFileResultDto);
        return uploadFileResultDto;
    }

    //根据扩展名获取mimeType
    private String getMimeType(String extension) {
        if (extension == null) {
            extension = "";
        }
        ContentInfo extensionMatch = ContentInfoUtil.findExtensionMatch(extension);
        String mimeType = MediaType.APPLICATION_OCTET_STREAM_VALUE; //通用mimeType
        if (extensionMatch != null) {
            mimeType = extensionMatch.getMimeType();
        }
        return mimeType;
    }

    /**
     * 将文件上传到minio
     * @param localFilePath 本地路径
     * @param mimeType 媒体类型
     * @param bucket 桶
     * @param objectName 文件名
     * @return
     */
    private boolean addMediaFilesToMinio(String localFilePath, String mimeType, String bucket, String objectName) {
        try {
            minioClient.uploadObject(
                    UploadObjectArgs.builder()
                    .bucket(bucket)
                    .filename(localFilePath)
                    .object(objectName)
                    .contentType(mimeType)
                    .bucket(bucket).build()
            );
            log.debug("上传文件到minio成功，bucket:{},objectName:{}",bucket,objectName);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            log.error("上传文件出错，bucket:{},objectName:{},错误信息：{}",bucket,objectName,e.getMessage());
        }
        return false;
    }
    
    private String getDefaultFolderPath(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String folder = sdf.format(new Date()).replace("-", "/") + "/";
        return folder;
    }

    private String getFileMd5(File file){
        try(FileInputStream fileInputStream=new FileInputStream(file)){
            String fileMd5 = DigestUtils.md5Hex(fileInputStream);
            return fileMd5;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将文件信息保存到数据库
     * @param companyId 机构id
     * @param fileMd5 md5
     * @param uploadFileParamsDto 文件信息
     * @param bucket 桶信息
     * @param objectName 路径
     * @return
     */
    @Transactional
    //事务只能用于public 方法 原理是Aop jdk cglib 两种方式 访问不了private
    //注意看是不是被代理对象调用 如果不是 则事务不会生效
    //同serive 调用同类的事务方法 事务是无法控制的 因为用的是this 并不是代理对象
    //注入进去的都是代理对象 this就是对象本身 解决办法 把service 在本类中进行注入
    public MediaFiles addMediaFilesToDb(Long companyId, String fileMd5, UploadFileParamsDto uploadFileParamsDto,String bucket,String objectName){
        MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
        if (mediaFiles == null){
            mediaFiles=new MediaFiles();
            BeanUtils.copyProperties(uploadFileParamsDto,mediaFiles);
            //文件id
            mediaFiles.setId(fileMd5);
            mediaFiles.setFileId(fileMd5);
            //机构id
            mediaFiles.setCompanyId(companyId);
            //桶
            mediaFiles.setBucket(bucket);
            //file_path
            mediaFiles.setFilePath(objectName);
            //url
            mediaFiles.setUrl("/"+bucket+"/"+objectName);
            //上传时间
            mediaFiles.setCreateDate(LocalDateTime.now());
            //状态
            mediaFiles.setStatus("1");
            //审核状态
            mediaFiles.setAuditStatus("002003");
            //插入数据库
            int insert = mediaFilesMapper.insert(mediaFiles);
            int i=1/0;
            if(insert<0){
                log.error("向数据库保存文件失败，bucket:{},objectName:{}",bucket,objectName);
                return null;
            }
            return mediaFiles;
        }
        return mediaFiles;
    }

    @Override
    public RestResponse<Boolean> checkFile(String fileMd5) {
        //先查询数据库
        MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
        //如果数据库存在再查询 minio
        if(mediaFiles!=null){
            String bucket = mediaFiles.getBucket();
            String filePath = mediaFiles.getFilePath();
            GetObjectArgs getObjectArgs = GetObjectArgs.builder()
                    .bucket(bucket)
                    .object(filePath)
                    .build();

            try {
                FilterInputStream inputStream = minioClient.getObject(getObjectArgs);
                if(inputStream!=null){
                    //文件已经存在了
                    return RestResponse.success(true);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return RestResponse.success(false);
    }

    @Override
    public RestResponse<Boolean> checkChunk(String fileMd5, int chunkIndex) {
        String chunkFileFolderPath = getChunkFileFolderPath(fileMd5)+chunkIndex;
        //md5前两位为两个目录，chunk存储分块文件
        GetObjectArgs getObjectArgs = GetObjectArgs.builder()
                .bucket(bucket_video)
                .object(chunkFileFolderPath)
                .build();
        try {
            FilterInputStream inputStream = minioClient.getObject(getObjectArgs);
            if(inputStream!=null){
                //文件已经存在了
                return RestResponse.success(true);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return RestResponse.success(false);
    }

    @Override
    public RestResponse uploadChunk(String fileMd5, int chunk, String localChunkFilePath) {
        String mimeType = getMimeType(null);
        boolean b = addMediaFilesToMinio(localChunkFilePath, mimeType, bucket_video, getChunkFileFolderPath(fileMd5) + chunk);
        if(!b){
            return RestResponse.validfail("上传分块文件失败",false);
        }
        return RestResponse.success(true);
    }

    @Override
    public RestResponse mergechunks(Long companyId, String fileMd5, int chunkTotal, UploadFileParamsDto uploadFileParamsDto) {
        // 找到分块文件调用minio的sdk进行文件合并
        // 分块文件所在目录
        String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
        // 找到所有的分块文件
        List<ComposeSource> sources = Stream.iterate(0, i -> ++i).limit(chunkTotal).map(i -> {
            return ComposeSource.builder().bucket(bucket_video).object(chunkFileFolderPath + i).build();
        }).collect(Collectors.toList());

        String filename = uploadFileParamsDto.getFilename();
        String extension = filename.substring(filename.lastIndexOf("."));
        //合并后的文件名
        String filePathByMd5 = getFilePathByMd5(fileMd5, extension);
        // 合并信息 minio默认合并大小为5M
        ComposeObjectArgs testbucket = ComposeObjectArgs.builder().bucket(bucket_video)
                .object(filePathByMd5) //合并后的文件
                .sources(sources)
                .build();
        //合并文件
        try {
            minioClient.composeObject(testbucket);
        } catch (Exception e) {
           e.printStackTrace();
           log.error("合并文件出错,bucket:{},onjectName:{},错误信息:{}",bucket_video,filePathByMd5,e.getMessage());
           return RestResponse.validfail("合并文件异常",false);
        }
        //校验合并后的和源文件是否一致，视频上传才成功
        File file = downloadFileFromMinIo(bucket_video, filePathByMd5);
        try(FileInputStream fileInputStream = new FileInputStream(file)){
            String mergeFile_md5 = DigestUtils.md5Hex(fileInputStream);
            //比较原始md5和合并后的
            if(!fileMd5.equals(mergeFile_md5)){
                log.error("校验合并文件md5值不一致，原始文件:{},合并文件:{}",fileMd5,mergeFile_md5);
                return RestResponse.validfail("文件校验失败",false);
            }
            //文件大小
            uploadFileParamsDto.setFileSize(file.length());
        }catch (Exception e){
            return RestResponse.validfail("文件校验失败",false);
        }
        //将文件信息入库
        MediaFiles mediaFiles = currentProxy.addMediaFilesToDb(companyId, fileMd5, uploadFileParamsDto, bucket_video, filePathByMd5);
        if(mediaFiles==null){
            return RestResponse.validfail("文件入库失败",false);
        }
        //清理分块文件
        clearChunkFiles(chunkFileFolderPath,chunkTotal);

        return RestResponse.success(true);
    }

    //得到分块目录
    private String getChunkFileFolderPath(String fileMd5){
        return fileMd5.substring(0,1)+"/"+fileMd5.substring(1,2)+"/"+fileMd5+"/"+"chunk"+"/";
    }

    //得到合并后的文件名
    private String getFilePathByMd5(String fileMd5,String fileExt){
        return fileMd5.substring(0,1)+"/"+fileMd5.substring(1,2)+"/"+fileMd5+"/"+fileMd5+fileExt;
    }

    //下载minio 文件
    public File downloadFileFromMinIo(String bucket,String objectName){
        File minioFile=null;
        FileOutputStream outputStream=null;
        try {
            InputStream inputStream = minioClient.getObject(GetObjectArgs.builder().bucket(bucket).object(objectName).build());
            minioFile=File.createTempFile("minio",".merge");
            outputStream = new FileOutputStream(minioFile);
            IOUtils.copy(inputStream,outputStream);
            return minioFile;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return minioFile;
    }

    //清除分块文件
    private void clearChunkFiles(String chunkFileFolderPath, int chunkTotal){
        Iterable<DeleteObject> objects=Stream.iterate(0,i->++i).limit(chunkTotal).map(i->{
            return new DeleteObject(chunkFileFolderPath+i);
        }).collect(Collectors.toList());
        RemoveObjectsArgs removeObjectArgs = RemoveObjectsArgs.builder().bucket(bucket_video).objects(objects).build();
        Iterable<Result<DeleteError>> results = minioClient.removeObjects(removeObjectArgs);
        //要想真正的删除
        results.forEach(f->{
            try {
                DeleteError deleteError = f.get();
            } catch (Exception e){
                e.printStackTrace();
            }
        });
    }
}

作者声明

如有问题，欢迎指正！
努力学习，努力爱你！
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
http大文件断点续传
09-15
http大文件断点续传，理论上传文件大小无限制。
QT学习之文件传输和断点续传
08-31
在这个"QT学习之文件传输和断点续传"的主题中，我们将深入探讨如何在QT环境中实现基于TCP的文件传输功能，并且特别关注断点续传技术。 首先，让我们了解TCP（Transmission Control Protocol）协议。TCP是一种面向...
断点续传文件
xixingzhe2的博客
09-10 230
  import java.io.BufferedOutputStream; import java.io.File; import java.io.IOException; import java.io.RandomAccessFile; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.Htt...
前端之实现大文件上传的解决方案———断点续传
最新发布
qq_53742640的博客
05-01 1673
断点续传是一种在网络传输中提高效率和可靠性的技术，特别适用于大文件的上传和下载。文件分片：将大文件分割成多个小块，这允许并行上传和从中断处恢复。并行上传：通过同时上传多个文件块，可以提高整体的上传速度。校验和记录：每个文件块在上传前后都进行校验，以确保数据的完整性。同时，记录已成功上传的块，为断点续传提供依据。请求恢复：当传输中断时，客户端使用记录的信息请求从最后成功上传的块继续上传。服务器支持：服务器端需要能够接收分片数据，验证块的完整性，并支持断点续传的逻辑。
大文件断点续传
weixin_33991727的博客
06-25 95
最近项目较为清闲，研究了下Html5新增的几个重要技术点，如操作文件系统、获取摄像头麦克风、本地图片预览、Ajax上传文件等。灵光一现，我有了一个“墨迹”的想法：通过浏览器获取影音数据并实时存储到本地磁盘上，再接着后台默默上传该文件，达到视频录像伪实时备份的目的。然而经过两三天的琢磨研究，有一问题怎么也未能解决：从UserMedia中如何获得视音频流？...
文件断点续传
单人影的博客
04-27 264
断点续传: 通常视频文件都比较大，所以对于媒资系统上传文件的需求要满足大文件的上传要求。http协议本身对上传文件大 小没有限制，但是客户的网络环境质量、电脑硬件环境等参差不齐，如果一个大文件快上传完了网断了，电断了没 有上传完成，需要客户重新上传，这是致命的，所以对于大文件上传的要求最基本的是断点续传. 流程: 上传前先把文件分块 一块一块的上传,上传中断后重新上传,...
C#文件断点续传实现方法
09-03
在C#编程中，文件断点续传是一种重要的文件传输技术，它允许程序在文件传输过程中因故中断后，从上次中断的位置继续传输，而无需重新开始整个过程。这对于大文件传输尤其有用，因为它可以节省时间和网络资源。下面将...
Springboot 断点续传大文件
07-01
曾经上传一部分：前端在上传每个模块之前，先请求后台，判断此模块是否已经上传过，如果已经上传过，则不需要再上传，否则上传。 注：启动以后直接访问http://localhost:9002/demo/largeUpload/open,如果本地运行...
文件上传断点续传协议
05-21
在编程时，由于需要上传大文件，于是我自己研发了一套断点续传协议，并在实际项目中得到应用，效果良好。这个协议不但支持大文件上传，而且支持断点续传、多用户同时上传一个文件速度加倍、文件秒传等等，基本完全...
HTML5实现文件断点续传的方法
12-14
目前比较常用的断点续传的方法有两种，一种是通过websocket接口进行文件上传，另一种是通过ajax，两种方法各有千秋，虽然websocket听起来比较高端些，但是除了用了不同的协议外其他的算法基本上都是很相似的，并且...
大文件断点续传功能
05-25
找了很久的断点续传功能。之前也试过百度的webuploader，但是效果并不理想（想研究的也可以试试），然后一直找，找了很久，直到找到这个后，才基本满足功能所需，可以实现大文件断点续传的需求。大文件断点续传的优势主要体现在：有时候突然断网，第二次上次可以接着上次断网的地方继续上传。我现在将其分享出来，供需要者使用，需要的可以下。保存的路径在resources中的stream-config.properties文件上，自己修改，自己折腾吧。
文件的断点续传
白永辉的专栏
03-01 5208
转自：http://apps.hi.baidu.com/share/detail/31497239 所谓的断点续传就是指：文件在传输过程式中被中断后，在重新传输时，可以从上次的断点处开始传输，这样就可节省时间，和其它资源。 实现关键在这里有两个关键点： 其一是检测本地已经下载的文件长度和断点值； 其二是在服务端调整文件指针到断点处 实现方法： 我们用一个简单的方法来实现断点续传的功能：
文件的简单断点续传
Chongchong's Home
12-28 442
文件的断点续传是指我们在下载时需要进行暂停或者网络断开等一系列事件所做的暂停操作,当我们再次进行操作的时候,将文件进行再次下载时，原先已经完成的部分就会连接上,继续下载Main方法代码:public class MainActivity extends AppCompatActivity { @BindView(R.id.tv) TextView tv; private Str
Linux 断点续传文件
多一份贡献,多一份环保
12-09 1227
在Linux系统上传与下载文件的时候，很容易断开，或者是大文件传输，如何在断开后继续传输不用重新开始，这里我们可以用到Linux的rsync 使用说明文件断点下载rsync -P --rsh=ssh root@192.168.0.11:/root/large.tar.gz /dounine/targe.tar.gz文件断点上传rsync -P --rsh=ssh /dounine/targe.tar
断点续传 文件服务器,文件服务器 断点续传
weixin_33914255的博客
08-05 151
回答Re求OSS大文件分块断点续传的实例&xff08;没有的话给个原理也好&xff09;用户断点续传是你的事。跟OSS没关系。OSS上传是你服务器与OSS的通信关系。你表达的我理解的是“用户本地与你服务器的断点续传”&xff0c;这个是...cevin2019-12-02 01:27:020 浏览量回答数 0回答请问大家，怎么实现 如何实现 断点续传方式 往ECS 云服务器...
断点续传
snpmyn
06-20 768
简介 通况Web服务器（如Apache）默启断点续传。故直通Web服务器提供文件下载，不必特配即可享断点续传。断点续传是发起HTTP请求时加RANGE头告知服务器客户端已下多少字节。待所有请求返回后把所得内容一块块拼接起来即完整资源。 测试 Linux测试服务器支持断点续传否 localhost [~]# wget -S http://httpd.apache.org/images/htt...
c#传输文件 断点续传
05-18
在 C# 中实现文件传输的断点续传功能，需要了解以下几个步骤： 1. 建立连接：使用 TCP 或 UDP 协议建立客户端与服务器之间的连接。 2. 发送文件信息：客户端向服务器发送文件名、大小、最后修改时间等信息。 3. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值