大规格文件的上传优化思路详解
在开发过程中，收到这样一个问题反馈，在网站上传 100 mb 以上的文件经常失败，重试也要等老半天，这就难为需要上传大规格文件的用户了。那么应该怎么做才能快速上传，就算失败了再次发送也能从上次中断的地方继续上传呢？下文为你揭晓答案~
温馨提示：配合 demo 源码一起阅读效果更佳
整体思路
第一步是结合项目背景，调研比较优化的解决方案。
文件上传失败是老生常谈的问题，常用方案是将一个大文件切片成多个小文件，并行请求接口进行上传，所有请求得到响应后，在服务器端合并所有的分片文件。当分片上传失败，可以在重新上传时进行判断，只上传上次失败的部分，减少用户的等待时间，缓解服务器压力。这就是分片上传文件。
大文件上传
那么如何实现大文件分片上传呢？
流程图如下：
分为以下步骤实现：
1. 文件 md5 加密
md5 是文件的唯一标识，可以利用文件的 md5 查询文件的上传状态。
根据文件的修改时间、文件名称、最后修改时间等信息，通过 生成文件的 md5。需要注意的是，大规格文件需要分片读取文件，将读取的文件内容添加到 的 hash 计算中，直到文件读取完毕，最后返回最终的 hash 码到 callback 回调函数里面。这里可以根据需要添加文件读取的进度条。
实现方法如下：
// 修改时间+文件名称+最后修改时间-->md5
md5file (file) {
return new promise((resolve, reject) => {
let blobslice =
file.prototype.slice ||
file.prototype.mozslice ||
file.prototype.webkitslice
let chunksize = file.size / 100
let chunks = 100
let currentchunk = 0
let spark = new sparkmd5.arraybuffer()
let filereader = new filereader()
filereader.onload = function (e) {
console.log('read chunk nr', currentchunk + 1, 'of', chunks)
spark.append(e.target.result) // append array buffer
currentchunk++
if (currentchunk < chunks) {
loadnext()
} else {
let cur = +new date()
console.log('finished loading')
// alert(spark.end() + '---' + (cur - pre)); // compute hash
let result = spark.end()
resolve(result)
}
}
filereader.onerror = function (err) {
console.warn('oops, something went wrong.')
reject(err)
}
function loadnext () {
let start = currentchunk * chunksize
let end =
start + chunksize >= file.size ? file.size : start + chunksize
filereader.readasarraybuffer(blobslice.call(file, start, end))
}
loadnext()
})
}
2. 查询文件状态
前端得到文件的 md5 后，从后台查询是否存在名称为 md5 的文件夹，如果存在，列出文件夹下所有文件，得到已上传的切片列表，如果不存在，则已上传的切片列表为空。
// 校验文件的md5
checkfilemd5 (file, filename, filemd5value, onerror) {
const filesize = file.size
const { chunksize, uploadprogress } = this
this.chunks = math.ceil(filesize / chunksize)
return new promise(async (resolve, reject) => {
const params = {
filename: filename,
filemd5value: filemd5value,
}
const { ok, data } = await services.checkfile(params)
if (ok) {
this.hasuploaded = data.chunklist.length
uploadprogress(file)
resolve(data)
} else {
reject(ok)
onerror()
}
})
}
3. 文件分片
文件上传优化的核心就是文件分片，blob 对象中的 slice 方法可以对文件进行切割，file 对象是继承 blob 对象的，因此 file 对象也有 slice 方法。
定义每一个分片文件的大小变量为 chunksize，通过文件大小 filesize 和分片大小 chunksize 得到分片数量 chunks，使用 for 循环和 file.slice() 方法对文件进行分片，序号为 0 - n，和已上传的切片列表做比对，得到所有未上传的分片，push 到请求列表 requestlist。
async checkanduploadchunk (file, filemd5value, chunklist) {
let { chunks, upload } = this
const requestlist = []
for (let i = 0; i < chunks; i++) {
let exit = chunklist.indexof(i + '') > -1
// 如果已经存在, 则不用再上传当前块
if (!exit) {
requestlist.push(upload(i, filemd5value, file))
}
}
console.log({ requestlist })
const result =
requestlist.length > 0
? await promise.all(requestlist)
.then(result => {
console.log({ result })
return result.every(i => i.ok)
})
.catch(err => {
return err
})
: true
console.log({ result })
return result === true
}
4. 上传分片
调用 promise.all 并发上传所有的切片，将切片序号、切片文件、文件 md5 传给后台。
后台接收到上传请求后，首先查看名称为文件 md5 的文件夹是否存在，不存在则创建文件夹，然后通过 fs-extra 的 rename 方法，将切片从临时路径移动切片文件夹中，结果如下：
当全部分片上传成功，通知服务端进行合并，当有一个分片上传失败时，提示“上传失败”。在重新上传时，通过文件 md5 得到文件的上传状态，当服务器已经有该 md5 对应的切片时，代表该切片已经上传过，无需再次上传，当服务器找不到该 md5 对应的切片时，代表该切片需要上传，用户只需上传这部分切片，就可以完整上传整个文件，这就是文件的断点续传。
// 上传chunk
upload (i, filemd5value, file) {
const { uploadprogress, chunks } = this
return new promise((resolve, reject) => {
let { chunksize } = this
// 构造一个表单，formdata是html5新增的
let end =
(i + 1) * chunksize >= file.size ? file.size : (i + 1) * chunksize
let form = new formdata()
form.append('data', file.slice(i * chunksize, end)) // file对象的slice方法用于切出文件的一部分
form.append('total', chunks) // 总片数
form.append('index', i) // 当前是第几片
form.append('filemd5value', filemd5value)
services
.uploadlarge(form)
.then(data => {
if (data.ok) {
this.hasuploaded++
uploadprogress(file)
}
console.log({ data })
resolve(data)
})
.catch(err => {
reject(err)
})
})
}
5. 上传进度
虽然分片批量上传比大文件单次上传会快很多，也还是有一段加载时间，这时应该加上上传进度的提示，实时显示文件上传进度。
原生 javascript 的 xmlhttprequest 有提供 progress 事件，这个事件会返回文件已上传的大小和总大小。项目使用 对 ajax 进行封装，可以在 config 中增加 onuploadprogress 方法，监听文件上传进度。
const config = {
onuploadprogress: progressevent => {
var complete = (progressevent.loaded / progressevent.total * 100 | 0) + '%'
}
}
services.uploadchunk(form, config)
6. 合并分片
上传完所有文件分片后，前端主动通知服务端进行合并，服务端接受到这个请求时主动合并切片，通过文件 md5 在服务器的文件上传路径中找到同名文件夹。从上文可知，文件分片是按照分片序号命名的，而分片上传接口是异步的，无法保证服务器接收到的切片是按照请求顺序拼接。所以应该在合并文件夹里的分片文件前，根据文件名进行排序，然后再通过 concat-files 合并分片文件，得到用户上传的文件。至此大文件上传就完成了。
node 端代码：
// 合并文件
exports.merge = {
validate: {
query: {
filename: joi.string()
.trim()
.required()
.description('文件名称'),
md5: joi.string()
.trim()
.required()
.description('文件md5'),
size: joi.string()
.trim()
.required()
.description('文件大小'),
},
},
permission: {
roles: ['user'],
},
async handler (ctx) {
const { filename, md5, size } = ctx.request.query
let { name, base: filename, ext } = path.parse(filename)
const newfilename = randomfilename(name, ext)
await mergefiles(path.join(uploaddir, md5), uploaddir, newfilename, size)
.then(async () => {
const file = {
key: newfilename,
name: filename,
mime_type: mime.gettype(`${uploaddir}/${newfilename}`),
ext,
path: `${uploaddir}/${newfilename}`,
provider: 'oss',
size,
owner: ctx.state.user.id,
}
const key = encodeuricomponent(file.key)
.replace(/%/g, '')
.slice(-100)
file.url = await uploadlocalfiletooss(file.path, key)
file.url = getfileurl(file)
const f = await file.create(omit(file, 'path'))
const files = []
files.push(f)
ctx.body = invokemap(files, 'tojson')
})
.catch(() => {
throw boom.baddata('大文件分片合并失败，请稍候重试~')
})
},
}
总结
本文讲述了大规格文件上传优化的一些做法，总结为以下 4 点：
- ob.slice 将文件切片，并发上传多个切片，所有切片上传后告知服务器合并，实现大文件分片上传；
- 原生 xmlhttprequest 的 onprogress 对切片上传进度的监听，实时获取文件上传进度；
- spark-md5 根据文件内容算出文件 md5，得到文件唯一标识，与文件上传状态绑定；
- 分片上传前通过文件 md5 查询已上传切片列表，上传时只上传未上传过的切片，实现断点续传。
参照 demo 源码 可快速上手上述功能
到此这篇关于大规格文件的上传优化思路详解的文章就介绍到这了,更多相关大文件上传优化内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！