大文件分片传输

前言

平时开发避免不了文件上传问题，而文件上传最大的问题则是大文件上传，这种问题，无论是前端仍是服务端都或许会碰到，下面就以 minio 为例，介绍较大文件传递过程中的问题

大文件传输

很多人都想，无论文件多大，一次性将文件传递完毕，那样不是很省事么，为什么会发生这么多问题呢?

这就跟文件传输手法与传输中碰到的问题有关了

大文件传输碰到问题中最常见的有两种手法，文件流传输、分片传输

文件流传输是最多的，传递大文件常用手法，其便是持续分片传输的结果，只不过是分批次读取文件信息传给服务器，外面很难察觉到，也很难做更改，即时即便传递不小文件也不会什么问题，但仍然无法满足复杂多变的运用场景，例如：用户传递一个4k蓝光视频，几十GB，单个文件传递，一旦出现网络动摇失利，则需求重新传递，这是很耗时的，假如能够保存有前面传递的部分资源，下次上传后，持续之前的上传则会好很多，最终在兼并文件即可

分片传输 这个操作本身文件流操作中都在运用，这儿介绍的不是这个，有时候客户端或许会一次性读取出文件(文本)的信息(或许只有几十几百兆，关于客户端来说不算过多)，然后打算将信息直接传递给服务器，显然这个是比较占用内存的，即便客户端不在意，可是服务端一起接收多个人上传，那么关于内存来说无疑是一个灾难，因而这种状况很多人也会选用分片传输来传输给服务器，以节约内存，还有一些状况是客户端直接传递给文件服务器，因而能够直接将内容分片传递给文件服务器(实践上能够还直接转化为文件传输)

分片传输核心操作：分片、传输、兼并

分片传输信息

关于文本、buffer 的分片不需多说，相信直接点类里面简单翻阅一下就知道怎样分片的了，这儿首要介绍用的最多的大文件文件的分片操作，这儿运用 fs 来操作，也是用的最多的 fs文档，很多组件api，都是运用的它做的一些文件操作

分片

直接经过 fs 的操作，获取指定区间的信息，其中 open 是打开文件获取文件句柄，read 则运用文件句柄读取文件信息，然后依据参数构成的重载能够找到获取指定片段的函数，咱们就直接运用下面的即可

import { open, read } from 'fs';
//chunkSize 64MB
//路径、文件巨细、偏移量，块巨细
export function readChunkFile(path: string, size: number, offset = 0, chunkSize = 64 * 1024 * 1024): Promise<ChunkFileInfo> {
    return new Promise((resolve, reject) => {
        let buffer1 = Buffer.alloc(chunkSize); //buffer的长度，然后读取指定长度buffer
        // let fullPath = join(__dirname, `../../${path}`)
        let fullPath = join(process.cwd(), path) //这两个都行
        open(fullPath, function(err: any, fd: number) {
            if (err) {
                reject('打开文件失利')
                return
            }
            //fd文件句柄、buffer自己创建的，offset在buffer中的偏移量，chunksize块巨细，position块巨细
            //第3个和第5个最简单记错，第三个一般为0，第5个为读取的实践文件偏移位置
            read(fd, buffer1, 0, chunkSize, offset, function(err: NodeJS.ErrnoException, bytesRead: number, buffer: Buffer) {
                if (err) {
                    reject('获取文件失利')
                }
                console.log(bytesRead, buffer)
                resolve({
                    offset, //偏移量
                    size, //总巨细
                    chunkSize, //设置块巨细 
                    readSize: bytesRead, //实践读取巨细
                    buffer,
                    isCompleted: offset + chunkSize >= size, //文件读取完毕(或许size传递不对，多判别一下即可)
                })
            })
        })	
    })
}

经过上面的办法咱们能够直接读取文件巨细，但似乎分片时多次调用用着有点怪异啰嗦，咱们改装一下

//只需求代开一次文件操作即可，然后每次读取完毕文件后，都回调一次办法给外面
//且该回调返回一个 promise，便利外面上传完毕后，直接次序往后读取
export function uploadByFileHandle(path: string, chunkCallback: (err: Error | null, info: ChunkInfo | null) => Promise<boolean>,offset?: number , chunkSize?: number) {
    // let fullPath = join(__dirname, `../../${path}`)
    let fullPath = join(process.cwd(), path) //这两个都行
    open(fullPath, async function (err: NodeJS.ErrnoException, fd: number) {
        if (err) {
            chunkCallback(err, null)
            return
        }
        const file = fstatSync(fd)
        const size = file.size
        chunkSize = chunkSize ? chunkSize : 64 * 1024 * 1024 //64MB
        function readFile(offset: number) {
            const readSize = offset + chunkSize > size ? size - offset : chunkSize
            const buffer = Buffer.alloc(readSize); //buffer的长度，然后读取指定长度buffer
            read(fd, buffer, 0, readSize, offset, async function (err: NodeJS.ErrnoException, bytesRead: number, buffer: Buffer) {
                if (err) {
                    chunkCallback(err, null)
                    return
                }
                const nextoffset = offset + chunkSize
                let isCompleted = nextoffset >= size //文件读取完毕(或许size传递不对，多判别一下即可)
                let result = await chunkCallback(null, {
                        offset,
                        totolSize: size,
                        size: bytesRead,
                        buffer,
                        isCompleted,
                })
                if (!result) return
                buffer = null
                //完毕了就不持续读取了
                if (!isCompleted) {
                    readFile(nextoffset)
                }
            })
        }
        readFile(offset ? offset : 0)
    })
}

传输、兼并

//保存上传的结果
const filenames = []
uploadByFileHandle('public/4.mp4', async (err: Error, chunk: ChunkInfo) => {
    if (err) {
      resolve(ResponseData.ok('上传失利'))
      return false
    }
    // let str = chunk.buffer.toString('utf-8')//假如是一串文本能够打印试试
    try {
      const filename = new Date().getTime().toString()
      //上传，每次上传后，保存一下咱们上传成功后的标识，这儿为filename
      await this.minioService.putFile(filename, chunk.buffer)
      filenames.push(filename)
    } catch(err) {
      return false
    }
    if (chunk.isCompleted) {
      //传输完结后走这儿，咱们经过compostObject直接对文件进行兼并操作
      const filename = new Date().getTime().toString()
      await this.minioService.compostObject(filename, filenames)
      console.log('成功了')
      resolve(ResponseData.ok('好了'))
    }
    return true
  }, 10 * 1024 * 1024)

上面传输兼并均以 minio 为例，关于兼并办法或许不太会用，这边直接走兼并的办法即可，兼并完毕后记得删去

async compostObject(filename: string, sourceList: string[]) {
    let desOptions = new CopyDestinationOptions({
        Bucket: envConfig.minioBucketName,
        Object: filename
    })
    const sources = sourceList.map( function (filename) {
        return new CopySourceOptions({
            Bucket: envConfig.minioBucketName,
            Object: filename
        })
    })
    console.log(sourceList)
    //需求注意的是，这个兼并操作挺慢的，假如网络或许文件服务器效率不够高，是会兼并超时的
    //需求改动文件服务器默认超时时间，至于他的超时时间我也不知道是多久
    //反正我兼并十几G的文件时分片好几百个就简单失利，几十个就没事，一两个g的上千个也没失利
    await this.client.composeObject(desOptions, sources)
    await this.client.removeObjects(
        envConfig.minioBucketName,
        sourceList
    )
    return filename
}

处理断开续传问题

上面分片、上传、兼并都有了，没有看到断开续传的处理呀

实践上已经有了，上面咱们保存的 filenames 便是前面上传的结果，假如还想实现断开续传，那么除了保存filename，能够保存一下 chunksize、offset、isCompleted等信息，这样传递到了哪里都知道了(最终一个offset+size便是下一个偏移了)，下次咱们直接传递偏移，持续上传即可，这样就处理好续传问题了

ps：实践运用中咱们能够依据状况确认是否需求兼并文件，有时候文件不兼并，而是涣散，并不一定是坏事，咱们能够保存对应的id合集就行了，实践用的时候依据id来获取指定片段即可，例如：某一个电影，若干巨细，就给他分红好多视频，当获取的时候，让他依据播放时间片获取不同资源内容即可，你还能够在某一段开头或许结束给他额外插播一段广告视频也不是不可哈