核心思路:
把大文件拆解成一个个的小文件,分别上传到服务端。所有小文件都上传成功后,在服务端把小文件合并成大文件。
大文件上传可能会存在的问题: 假设用户选择了一个 2GB 的文件,前端直接一个 POST FormData 传上去,可能会遇到以下问题:
所以,需要把大文件拆成一个一个的小文件,每次传递一个小文件,每次传输只需要一两秒,即使当前小文件失败,也可以重新上传,不会耽误太多时间,尽量避免网络问题导致前功尽弃。
服务端需要记录已经上传文件的 hash 信息 file_object 表,和未完成上传的任务的信息 upload_task 表。
分块 按照一定大小(比如 2M),将大文件分割成一个个的小文件,并对每个小文件取 Hash, 最后再对所有的 Hash 取一次 Hash , 用来表示整个文件的 Hash.
初始化上传任务
先请求服务端 init 接口,带上请求参数:file_name, file_size, file_hash, chunk_size。
file_hash 判断之前是否有人传递过这个文件。服务端需要将之前传递过的文件 hash 存储到数据库中。然后根据 hash 判断文件是否被传递过。
上传文件
前端收到新的 upload_task 信息后,对每个分割后的小文件,都执行上传操作,upload_id, index, chunk(二进制数据) 这里需要注意控制并发,建立一个请求池,控制每次上传不超过 3 个,
服务端需要对每个 chunk 进行校验:- 校验 upload_id 是否存在,是否属于当前用户,并且状态不是 complete/aborted. - 校验 index 是否在 [0, chunk_total-1] 这个范围。- 流式的把接受到的 chunk 内容写入到 一个临时文件夹内 tmp 内,并命名为 ${upload_Id}/${index}.part.tmp。 (临时记录文件名字) - 等当前 chunk 全部成功接收完后,再将当前的 chunk 名字改为 ${upload_id}/${index}.part 。(防止某个 chunk 上传到一半网络终端,那这个chunk 数据是不全的,需要舍弃。) - 向前端返回数据,表示当前 chunk 已经上传成功。
验收,调用 complete 接口。
当前端把所有文件都上传完成后,把 upload_id 传递到服务端,
此时服务端需要:- 抢占: UPDATE upload_task SET status = 'merging' WHERE upload_id = ? AND status = 'uploading'
如果 RowsAffected = 0 说明其它用户正在合并,直接向前端返回“处理中” - 从 0 到 chunk.length - 1 检查,看所有小 chunk , .part 文件是否存在,大小是否正确。如果缺失, 将缺失的序列号返回给前端,前端需要重新传递。- 合并所有 chunk, - 算出合合并后文件的 hash, 和前端传递过来的 hash 比对,如果不一致,删掉合并结果,并将状态改为 failed,同时返回前端信息。- 如果算出的文件 hash 和前端传递过来的 hash 一致, 则落库:file_object 表中对应数据改为 completed, 可以删掉刚才的临时 chunk 文件,
注意:
import { useRef, useState } from "react"
import { computeFileHash } from "@src/pages/_layout/UploadFile/-components/customDemo/utils/fileHash.ts"
import { GET, POST } from "@src/request"
import { xhrRequestWithRetry } from "@src/request/UploadFile"
import { limitPromise } from "@src/utils/utils.ts"
const CHUNK_SIZE = 5 * 1024 * 1024
type UploadStatus =
| "idle"
| "hashing"
| "uploading"
| "paused"
| "merging"
| "done"
| "error"
type InitData = {
upload_id: string
chunk_size: number
chunk_total: number
uploaded: number[]
finished: boolean
path: string
}
export const useCustomUploadFile = () => {
const [onProgress, setOnProgress] = useState<number>(0)
const [status, setStatus] = useState<UploadStatus>("idle") // 默认状态是闲置状态
const fileRef = useRef<File | null>(null)
const uploadIdRef = useRef<string>("")
const chunkSizeRef = useRef(CHUNK_SIZE)
const totalRef = useRef<number>(0)
const abortRef = useRef<AbortController | null>(null)
const pausedRef = useRef<boolean>(false) // 暂停
const loadedRef = useRef<number[]>([]) // 已经上传切片的进度
/**
* 通用的,计算当前所有切片,已经上传的字节数,并更新上传进度
* */
const reportProgress = () => {
const file = fileRef.current
if (!file) return
const sum = loadedRef.current.reduce((a, b) => a + b, 0)
const uploadPercent = Math.round((sum / file.size) * 94) // 上传阶段占总进度的 94%,hash 阶段占 5% ,留 1% 最后设置。
setOnProgress(Math.min(99, uploadPercent + 5))
}
/**
* 在断点续传场景中,根据已经上传的分片序号,计算已经上传的字节数,并更新上传进度
* param uploaded: 已经上传的分片序号
* return: 上传结果
*/
const syncLoadedFromUploaded = (uploaded: number[]) => {
const file = fileRef.current
if (!file) return
const chunkSize = chunkSizeRef.current
const doneSet = new Set(uploaded ?? []) // 对 uploaded 去重,doneSet 里面存储的是已经上传 分片的 index
loadedRef.current = Array.from({ length: totalRef.current }, (_, index) => {
// 计算已经上传的分片进度
if (!doneSet.has(index)) return 0
const start = index * chunkSize
return Math.min(chunkSize, file.size - start)
})
reportProgress()
}
/**
* 上传切片
* param uploaded: 已经上传的分片序号
* return: 上传结果
*/
const runUpload = async (uploaded: number[]) => {
const file = fileRef.current
const uploadId = uploadIdRef.current
if (!file || !uploadId) return
setStatus("uploading")
pausedRef.current = false
abortRef.current?.abort() // 如果之前有任务没有中断,先中断之前的上传任务
abortRef.current = new AbortController()
const signal = abortRef.current.signal
const chunkSize = chunkSizeRef.current
const total = totalRef.current
syncLoadedFromUploaded(uploaded) // 计算当前进度, 正常情况下,刚开始的 uploaded 是[]
const doneSet = new Set(uploaded ?? []) // 对 uploaded 去重,doneSet 里面存储的是已经上传 分片的 index
const pending = Array.from({ length: total }, (_, i) => i).filter(
(i) => !doneSet.has(i)
) // 过滤掉已经上传的分片, 避免重复上传
if (pending.length > 0) {
const taskArray = pending.map((index) => {
// 构造需要上传的分片 Promise 数组
return () => {
if (pausedRef.current || signal.aborted) {
return Promise.reject(new Error("请求已取消"))
}
const startIndex = index * chunkSize // 计算某个分片的开始字节位置
const blob = file.slice(startIndex, startIndex + chunkSize) // 从整个文件字节中,截取当前分片需要上传的 blob 字节
const queryParams = new URLSearchParams({
// 构造请求参数
upload_id: uploadId,
index: String(index),
})
return xhrRequestWithRetry({
url: `/upload/chunk?${queryParams}`,
method: "POST",
headers: { "Content-Type": "application/octet-stream" },
body: blob,
retryNum: 3,
retryDelaySecond: 2, // 2s 后重试
signal,
onProgress: (percent) => {
const bytes = (blob.size * percent) / 100 // 计算当前分片已经上传的字节数
if (bytes > loadedRef.current[index]) {
loadedRef.current[index] = bytes // 更新已经上传的字节数
reportProgress() // 更新上传进度
}
},
})
}
})
const result = await limitPromise(taskArray, 3) // 限制并发上传数量为 3
if (pausedRef.current || signal.aborted) {
// 如果暂停或被中断,则设置状态为暂停
setStatus("paused")
return
}
if (result.some((item) => item instanceof Error || item.code !== 0)) {
// 如果上传中有错误,则设置状态为错误
setStatus("error")
return
}
}
setStatus("merging") // 设置状态为正在合并中
const done = await POST<{ path: string }>("/upload/complete", {
// 上传完成后,调用 complete 接口,告知服务端可以合并文件,完成上传
upload_id: uploadId,
})
if (done.code !== 0) {
// 如果合并文件失败,则设置状态为错误
setStatus("error")
return
}
setOnProgress(100) // 设置上传进度为 100%
setStatus("done") // 设置状态为完成
}
/**
*
* 处理文件 Hash 计算,
* 初始化上传任务,调用 init 接口
* 如果文件已经上传过,则直接返回,实现秒传
* 如果文件未上传过,则调用上传 Chunk 接口,上传分片
*
* param file: 文件
* */
const handleFileChange = async (file: File | undefined) => {
if (!file) return // 如果文件不存在,则返回
abortRef.current?.abort()
fileRef.current = file
pausedRef.current = false
setOnProgress(0)
setStatus("hashing")
/**
* 计算文件的 SHA-256 的十六进制字符串
* 使用 webworker 计算hash ,避免页面卡死
* 每个分片哈希 安顺序拼接后,再哈希一次,算法需要和后端一致
*/
const { fileHash } = await computeFileHash(file, CHUNK_SIZE, (value) => {
setOnProgress(Math.round(value * 5)) // 计算 hash 时,只占整个进度的 %5
})
/**
* 初始化上传
* 先调用 init 接口,查看当前文件是否已经上传过。
* 如果已经上传过,则直接返回,实现秒传
* 如果未上传过,则走后面分片上传逻辑
*/
const initRes = await POST<InitData>("/upload/init", {
file_name: file.name,
file_size: file.size,
file_hash: fileHash,
})
if (initRes.code !== 0) {
setStatus("error")
return
}
if (initRes.data.finished) {
setOnProgress(100) // 秒传
setStatus("done")
return
}
uploadIdRef.current = initRes.data.upload_id
chunkSizeRef.current = initRes.data.chunk_size
totalRef.current = initRes.data.chunk_total
await runUpload(initRes.data.uploaded ?? [])
}
/**
* 暂停上传
*/
const handlePause = () => {
if (status !== "uploading") return
pausedRef.current = true
abortRef.current?.abort()
setStatus("paused")
}
/**
* 暂停后恢复上传
* */
const handleResume = async () => {
if (!uploadIdRef.current || !fileRef.current) return
// 查询之前某个上传任务的最新状态
const statusRes = await GET<InitData>(
`/upload/status?upload_id=${encodeURIComponent(uploadIdRef.current)}`
)
if (statusRes.code !== 0) {
setStatus("error")
return
}
await runUpload(statusRes.data.uploaded ?? [])
}
/**
* 取消上传
* */
const handleAbortUpload = async () => {
pausedRef.current = true
abortRef.current?.abort()
const res = await POST("/upload/abort", {
upload_id: uploadIdRef.current,
})
if (res.code !== 0) {
setStatus("error")
return
}
console.log("取消任务成功")
uploadIdRef.current = ""
fileRef.current = null
pausedRef.current = false
loadedRef.current = []
setStatus("idle")
setOnProgress(0)
}
return {
handleFileChange,
onProgress,
handlePause,
handleResume,
status,
handleAbortUpload,
}
}export interface FileHashResult {
fileHash: string
chunkHash: string[]
}
/**
* 使用 webworker 计算hash ,避免页面卡死
* 每个分片哈希 安顺序拼接后,再哈希一次,算法需要和后端一致
* */
export const computeFileHash = (
file: File,
chunkSize: number,
onProgress?: (val: number) => void
): Promise<FileHashResult> => {
return new Promise((resolve, reject) => {
const worker = new Worker(new URL("./hashWorker.ts", import.meta.url), {
type: "module",
})
worker.onmessage = (event: MessageEvent) => {
// 监听 worker 的返回消息
const data = event.data // 获取 worker 返回的消息
if (data.type === "progress") {
onProgress?.(data.value) // 更新分割进度
return
}
worker.terminate() // 终止 worker
resolve({
fileHash: data.fileHash, // 文件的 SHA-256 的十六进制字符串
chunkHash: data.chunkHash, // 所有的分片的 hash
})
}
worker.onerror = (event: ErrorEvent) => {
// 错误处理
worker.terminate()
reject(new Error(event.message || "文件哈希值计算失败"))
}
worker.postMessage({
// 发送消息,告诉 worker,要分割的文件和 分割大小
file,
chunkSize,
})
})
}/// <reference lib="webworker" /> // 告诉编译器,这里是 webworker 环境
/**
* 把任意二进制数据算成 SHA-256 的十六进制字符串
* */
export const sha256Hex = async (data: BufferSource) => {
const digest = await crypto.subtle.digest("SHA-256", data) // 将 data 做 SHA-256 转换,返回 32 字节的ArrayBuffer
return Array.from(new Uint8Array(digest)) // 将 ArrayBuffer 转换为 Uint8Array,然后转换为字节数组
.map((byte) => byte.toString(16).padStart(2, "0")) // 将字节数组转换为十六进制字符串,每个字节转换为 2 位,不足 2 位的前面补 0
.join("") // 将字节数组转换为十六进制字符串,每个字节转换为 2 位,不足 2 位的前面补 0
} // 返回 SHA-256 的十六进制字符串
self.onmessage = async (event: MessageEvent<{ file: File; chunkSize: number }>) => {
const { file, chunkSize } = event.data // worker 获取 要分割的文件和 分割大小
const total = Math.ceil(file.size / chunkSize) // 计算分割数量
const chunkHashes: string[] = [] // 声明变量,存储分割后的 SHA-256 的十六进制字符串
for (let index = 0; index < total; index++) {
// 开始分割
const buffer = await file
.slice(index * chunkSize, (index + 1) * chunkSize)
.arrayBuffer() // 分割文件,返回 ArrayBuffer
chunkHashes.push(await sha256Hex(buffer)) // 计算分割后的 SHA-256 的十六进制字符串
self.postMessage({
// 发送消息,告诉主线程,分割进度
type: "progress",
value: (index + 1) / total, // 分割进度
})
}
const fileHash = await sha256Hex(new TextEncoder().encode(chunkHashes.join(""))) // 将所有的分片的 hash 合并后,再计算文件的 SHA-256 的十六进制字符串
self.postMessage({
type: "done",
fileHash: fileHash,
chunkHashes: chunkHashes, // 发送消息,告诉主线程,所有的分片的 hash
})
}import { useCustomUploadFile } from './hooks.tsx'
import { Progress, Button } from 'antd'
export const CustomUploadFile = () => {
const { status, handleFileChange, onProgress, handlePause, handleResume, handleAbortUpload } =
useCustomUploadFile()
return (
<div className="my-10 min-h-25 border border-solid border-#000">
<input
className={'border border-solid border-[#ccc]'}
type="file"
placeholder={'sss'}
onChange={(event) => handleFileChange(event.target.files?.[0])}
/>
<div className={'w-[80%] mx-auto'}>
<Progress percent={onProgress} />
</div>
{status === 'uploading' && (
<Button type="primary" onClick={handlePause}>
暂停
</Button>
)}
{status === 'paused' && (
<Button type="primary" onClick={handleResume}>
继续
</Button>
)}
{['uploading', 'paused'].includes(status) && <Button onClick={handleAbortUpload}>取消上传</Button>}
{status}
</div>
)
}
数据库:
package model
import "time"
const (
UploadStatusUploading uint8 = 1
UploadStatusFailed uint8 = 2
UploadStatusCompleted uint8 = 3
UploadStatusAborted uint8 = 4 // 用户已取消
)
type UploadTask struct {
BaseModel
UploadId string `json:"upload_id" gorm:"column:upload_id;type:varchar(64);not null;default:'';uniqueIndex"`
UserId uint `json:"user_id" gorm:"column:user_id;type:int unsigned;not null; default:0;index"`
FileName string `json:"file_name" gorm:"column:file_name;type:varchar(255);not null;default:''"`
FileSize int64 `json:"file_size" gorm:"column:file_size;type:bigint unsigned;not null;default:0"`
FileHash string `json:"file_hash" gorm:"column:file_hash;type:char(64);not null;default:'';index"`
FileId uint `json:"file_id" gorm:"column:file_id;type:int unsigned;not null;default:0"`
ChunkSize int64 `json:"chunk_size" gorm:"column:chunk_size;type:int unsigned;not null; default:0"`
ChunkTotal int `json:"chunk_total" gorm:"column:chunk_total;type:int unsigned;not null;default:0"`
Status uint8 `json:"status" gorm:"column:status;type:tinyint unsigned;not null;default:1"`
ExpiredAt time.Time `json:"expired_at" gorm:"column:expired_at"`
}
func (UploadTask) TableName() string {
return "upload_task"
}
type FileObject struct {
BaseModel
Hash string `json:"hash" gorm:"column:hash;type:char(64);not null;default:'';uniqueIndex"`
Size int64 `json:"size" gorm:"column:size;type:bigint unsigned;not null;default:0"`
Ext string `json:"ext" gorm:"column:ext;type:varchar(255);not null;default;''"`
Mime string `json:"mime" gorm:"column:mime;type:varchar(120);not null;default:''"`
StoragePath string `json:"storage_path" gorm:"column:storage_path;type:varchar(255);not null;default:''"`
RefCount uint `json:"ref_count" gorm:"column:ref_count;type:int unsigned;not null;default:0"`
}
func (FileObject) TableName() string {
return "file_object"
}
// router
{
Prefix: "upload",
Routes: []RouteDef{
GET("status", "查询上传进度", AuthLogin, uploadCtrl.Status),
POST("init", "初始化上传任务", AuthLogin, uploadCtrl.Init),
//POST("uploadFile", "上传文件", AuthLogin, uploadCtrl.UploadFile),
POST("chunk", "上传分片", AuthLogin, uploadCtrl.Chunk),
POST("complete", "合并文件分片", AuthLogin, uploadCtrl.Complete),
POST("abort", "取消上传任务", AuthLogin, uploadCtrl.UploadAbort),
},
},
package controller
import (
"GinAdmin/internal/pkg/errors"
"GinAdmin/internal/service"
"net/http"
"strconv"
"github.com/gin-gonic/gin"
)
const maxChunkSize = 5 * 1024 * 1024 // 最大分片大小
type UploadController struct {
Api
uploadService *service.UploadService
}
func NewUploadController() *UploadController {
return &UploadController{
uploadService: service.NewUploadService(),
}
}
func (ctl *UploadController) Init(c *gin.Context) {
var req struct {
FileName string `json:"file_name"`
FileSize int64 `json:"file_size"`
FileHash string `json:"file_hash"`
}
if err := c.ShouldBindJSON(&req); err != nil { // 校验参数
ctl.Fail(c, errors.InvalidParameter, "参数错误")
return
}
// 调用服务层,初始化上传任务
result, err := ctl.uploadService.Init(ctl.GetCurrentUserID(c), req.FileName, req.FileSize, req.FileHash)
if err != nil {
ctl.Err(c, err)
return
}
ctl.Success(c, result)
}
func (ctl *UploadController) Chunk(c *gin.Context) {
uploadId := c.Query("upload_id") // 获取上传 ID
index, err := strconv.Atoi(c.Query("index")) // 把 url 中的 index 参数,字符串转换成整数。
if err != nil {
ctl.Fail(c, errors.InvalidParameter, "分片序号错误")
return
}
uid := ctl.GetCurrentUserID(c) // 获取当前用户 ID
task, err := ctl.uploadService.LoadTask(uploadId, uid) // 加载上传任务,查看当前数据库中是否存在上传任务
if err != nil {
ctl.Err(c, err)
return
}
if index < 0 || index >= task.ChunkTotal { // 校验分片序号是否超出范围
ctl.Fail(c, errors.InvalidParameter, "分片序号超出范围")
return
}
body := http.MaxBytesReader(c.Writer, c.Request.Body, maxChunkSize) // 限制上传文件的大小
defer body.Close()
if err := ctl.uploadService.SaveChunk(uploadId, index, body); err != nil { // 保存分片
ctl.Err(c, err)
return
}
ctl.Success(c, gin.H{
"index": index,
})
}
func (ctl *UploadController) Complete(c *gin.Context) {
var req struct { // 声明变量,用来接收请求参数
UploadId string `json:"upload_id"`
}
if err := c.ShouldBindJSON(&req); err != nil || req.UploadId == "" { // 校验请求参数
ctl.Fail(c, errors.InvalidParameter, "参数错误")
return
}
path, err := ctl.uploadService.MergeChunks(req.UploadId, ctl.GetCurrentUserID(c)) // 合并分片
if err != nil {
ctl.Err(c, err)
return
}
ctl.Success(c, gin.H{"path": path})
}
func (ctl *UploadController) Status(c *gin.Context) {
result, err := ctl.uploadService.Status(c.Query("upload_id"), ctl.GetCurrentUserID(c))
if err != nil {
ctl.Err(c, err)
return
}
ctl.Success(c, result)
}
func (ctl *UploadController) UploadAbort(c *gin.Context) {
var req struct {
UploadId string `json:"upload_id"`
}
if err := c.ShouldBindJSON(&req); err != nil || req.UploadId == "" {
ctl.Fail(c, errors.InvalidParameter, "参数错误")
return
}
if err := ctl.uploadService.UploadAbort(req.UploadId, ctl.GetCurrentUserID(c)); err != nil {
ctl.Err(c, err)
return
}
ctl.Success(c, nil)
}
package service
import (
"GinAdmin/config"
"GinAdmin/data"
"GinAdmin/internal/model"
"GinAdmin/internal/pkg/errors"
"crypto/sha256"
"encoding/hex"
stdErrors "errors"
"fmt"
"io"
"net/http"
"os"
"path/filepath"
"sort"
"strconv"
"strings"
"time"
"github.com/google/uuid"
"gorm.io/gorm"
)
var allowedExt = map[string]string{
".png": "image/png",
".jpg": "image/jpeg",
".jpeg": "image/jpeg",
".gif": "image/gif",
".pdf": "application/pdf",
".txt": "text/plain",
".js": "text/plain",
".mov": "video/quicktime",
}
const ChunkSize int64 = 5 * 1024 * 1024
const uploadTaskTTL = 7 * 24 * time.Hour // 未完成上传任务保留 7 天
type InitResult struct {
UploadId string `json:"upload_id"`
ChunkSize int64 `json:"chunk_size"`
ChunkTotal int `json:"chunk_total"`
Uploaded []int `json:"uploaded"`
Finished bool `json:"finished"`
Path string `json:"path"`
}
type UploadService struct{}
func NewUploadService() *UploadService {
return &UploadService{}
}
// Init 初始化上传任务
func (s *UploadService) Init(userId uint, fileName string, fileSize int64, fileHash string) (*InitResult, error) {
name := filepath.Base(fileName) // 获取文件名
ext := strings.ToLower(filepath.Ext(name)) // 获取文件扩展名
if _, ok := allowedExt[ext]; !ok || fileSize <= 0 || len(fileHash) != 64 { // 校验参数,看上传的文件是否支持
return nil, errors.NewBusinessError(errors.InvalidParameter, "参数错误")
}
var object model.FileObject // 声明变量,用来查询数据库中是否已经存在该文件
err1 := data.GetDB().Where("hash = ?", fileHash).First(&object).Error // 查询 FileObject 表中是否存在 hash值为 fileHash 的数据
if err1 == nil { // 如果查到数据,说明此文件之前已经被上传过,则更新该文件的引用计数
if err := data.GetDB().Model(&model.FileObject{}).Where("id = ?", object.ID).Update("ref_count", gorm.Expr("ref_count + 1")).Error; err != nil { // 更新该文件的引用计数
return nil, fmt.Errorf("更新引用计数失败 %w", err)
}
return &InitResult{ // 返回结果,返回文件的存储路径
Finished: true,
Path: object.StoragePath,
Uploaded: []int{},
}, nil
}
if !stdErrors.Is(err1, gorm.ErrRecordNotFound) { // 如果不是因为记录不存在这个错误,说明程序出错了,返回错误信息。
return nil, fmt.Errorf("查询文件失败 %w", err1)
}
var task model.UploadTask // 声明变量,用来查询数据库中是否存在该文件的上传任务
err := data.GetDB().Where(
"user_id = ? AND file_hash = ? AND file_size = ? AND status = ? AND expired_at > ?",
userId, fileHash, fileSize, model.UploadStatusUploading, time.Now()).First(&task).Error // 查询数据库中是否存在符合这些参数条件的任务,并且把查到的结果写入声明的 task 变量里面
if err == nil { // 如果查到数据,说明该文件的上传任务已经存在,则返回上传任务的结果
return s.taskResult(&task)
}
if !stdErrors.Is(err, gorm.ErrRecordNotFound) { // 如果不是因为记录不存在这个错误,说明程序出错了,返回错误信息。
return nil, fmt.Errorf("查询上传任务失败 %w", err)
}
// 如果查不到数据,说明该文件的上传任务不存在,则按照新文件上传逻辑执行。
chunkTotal := int((fileSize + ChunkSize - 1) / ChunkSize) // 计算文件被分片的总数
uploadId := uuid.NewString() // 生成一个唯一的上传 ID
dir := filepath.Join(storageBase(), "uploadFiles", "tmp", uploadId) // 拼接服务端最终保存文件的路径
if err := os.MkdirAll(dir, 0o755); err != nil { // 创建目标文件夹,用来存放上传文件的位置
return nil, fmt.Errorf("创建文件夹失败 %w", err)
}
task = model.UploadTask{ // 创建一个变量,用来存储上传文件的信息
UploadId: uploadId,
UserId: userId,
FileName: filepath.Base(fileName),
FileSize: fileSize,
FileHash: fileHash,
ChunkSize: ChunkSize,
ChunkTotal: chunkTotal,
Status: model.UploadStatusUploading,
ExpiredAt: time.Now().Add(uploadTaskTTL),
}
if err := data.GetDB().Create(&task).Error; err != nil { // 创建一个 sql, 将上传文件的信息写入数据库
os.RemoveAll(dir) // 如果创建失败,则删除目标文件夹
return nil, fmt.Errorf("创建上传任务失败 %w", err)
}
return s.taskResult(&task) // 返回上传任务的结果
}
func (s *UploadService) SaveChunk(uploadId string, index int, src io.Reader) error {
if _, err := uuid.Parse(uploadId); err != nil || index < 0 { // 校验请求参数
return errors.NewBusinessError(errors.InvalidParameter, "参数错误")
}
dir := filepath.Join(storageBase(), "uploadFiles", "tmp", uploadId) // 拼接分片保存位置目录
if err := os.MkdirAll(dir, 0o755); err != nil { // 创建分片保存位置目录
return fmt.Errorf("创建目录失败 %w", err)
}
final := filepath.Join(dir, fmt.Sprintf("%d.part", index)) // 拼接分片文件的最终名字
tmp := final + ".tmp" // 分片文件的临时名字,仅供保存临时分片文件时使用。
dst, err := os.Create(tmp) // 创建分片文件,并打开,准备向其中写入文件。
if err != nil {
return fmt.Errorf("创建分片失败 %w", err)
}
if _, err := io.Copy(dst, src); err != nil { // 将分片内容写入刚才创建的分片文件
dst.Close() // 关闭分片文件
os.Remove(tmp) // 删除临时分片文件
return fmt.Errorf("分片文件写入失败 %w", err)
}
if err != dst.Sync() { // 对文件调用 fsync。os.File 的写入先进内核页缓存,Sync 会把这些脏页强制落盘,并等待写完。只有返回 nil 才说明数据确实到了磁盘。
dst.Close() // 关闭分片文件
os.Remove(tmp) // 删除临时分片文件
return fmt.Errorf("分片刷盘失败 %w", err)
}
if err := dst.Close(); err != nil { // 关闭分片文件
os.Remove(tmp) // 删除临时分片文件
return fmt.Errorf("关闭分片文件失败 %w", err)
}
return os.Rename(tmp, final) // 分片内容写入完之后改名
}
func (s *UploadService) MergeChunks(uploadId string, userId uint) (string, error) {
if _, err := uuid.Parse(uploadId); err != nil { // 校验请求参数
return "", errors.NewBusinessError(errors.InvalidParameter, "参数错误")
}
task, err := s.LoadTask(uploadId, userId) // 加载上传任务,查看请求合并的 uploadId 任务ID 在数据库中是否存在对应的上传任务
if err != nil {
return "", err
}
chunkDir := filepath.Join(storageBase(), "uploadFiles", "tmp", uploadId) // 拼接保存分片的文件夹路径
for i := 0; i < task.ChunkTotal; i++ { // 遍历分片,查看分片是否存在
// os.Stat 用来获取目录的元信息,如果文件不存在,则返回错误。常用来判断某个目录/文件是否存在。
if _, err := os.Stat(filepath.Join(chunkDir, fmt.Sprintf("%d.part", i))); err != nil { // 检查分片是否存在
return "", errors.NewBusinessError(errors.InvalidParameter, fmt.Sprintf("缺少第%d个分片", i))
}
}
filename := task.FileName
first, err := os.Open(filepath.Join(chunkDir, "0.part")) // 打开第一个分片,准备读取分片内容
if err != nil {
return "", errors.NewBusinessError(errors.InvalidParameter, "缺少分片")
}
head := make([]byte, 512) // 创建一个切片,用来存储文件头
n, err := io.ReadFull(first, head) // 读取文件头,并存储到 head 切片中
first.Close() // 关闭分片文件
if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF { // 如果读取文件头失败,则返回错误
return "", fmt.Errorf("读取文件头失败 %w", err)
}
if err := checkUploadType(filename, head[:n]); err != nil { // 检查文件类型是否支持
return "", err
}
ext := strings.ToLower(filepath.Ext(filename)) // 获取文件扩展名
staging := filepath.Join(storageBase(), "uploadFiles", "tmp", uploadId+".merging") // 拼接合并分片的临时文件路径
dst, err := os.Create(staging) // 创建合并分片的临时文件(最终文件的临时文件),并打开,准备向其中写入文件。
if err != nil {
return "", fmt.Errorf("创建文件失败 %w", err)
}
sums := make([]string, 0, task.ChunkTotal) // 创建一个切片,用来存储分片的 SHA256 值
for i := 0; i < task.ChunkTotal; i++ { // 遍历分片,读取分片内容
part, err := os.Open(filepath.Join(chunkDir, fmt.Sprintf("%d.part", i)))
if err != nil {
dst.Close()
os.Remove(staging)
return "", errors.NewBusinessError(errors.InvalidParameter, "缺少分片")
}
h := sha256.New() // 创建一个 SHA256 哈希对象
_, err = io.Copy(io.MultiWriter(dst, h), part) // 将分片内容写入合并分片的临时文件,并计算 SHA256 值 (把 part 的值,写入 dst 和 h 中)
sums = append(sums, hex.EncodeToString(h.Sum(nil))) // 将 SHA256 值添加到 sums 切片中
part.Close()
if err != nil {
dst.Close()
os.Remove(staging)
return "", fmt.Errorf("合并分片失败 %w", err)
}
} // 遍历完所有分片,所有分片的值都写入到合并分片的临时文件中,计算并存储所有分片的 SHA256 值
if err := dst.Close(); err != nil { // 关闭合并分片的临时文件
os.Remove(staging)
return "", fmt.Errorf("关闭文件失败 %w", err)
}
gotSum := sha256.Sum256([]byte(strings.Join(sums, ""))) // 计算所有分片的 SHA256 值
got := hex.EncodeToString(gotSum[:]) // 将 SHA256 值转换为字符串
if !strings.EqualFold(got, task.FileHash) { // 比较计算出的 SHA256 值与数据库中存储的 SHA256 值是否一致
// 如果不一样,则删除合并分片的临时文件,并更新上传任务状态为 failed
os.Remove(staging)
data.GetDB().Model(&model.UploadTask{}).Where("upload_id = ?", uploadId).
Update("status", model.UploadStatusFailed)
return "", errors.NewBusinessError(errors.InvalidParameter, "文件校验失败")
}
// 如果一样,则继续执行,创建最终文件
name := strings.TrimSuffix(filepath.Base(filename), ext) + uuid.NewString() + ext // 拼接最终文件的文件名
rel := filepath.Join("uploadFiles", name)
abs := filepath.Join(storageBase(), rel)
if err := os.MkdirAll(filepath.Dir(abs), 0o755); err != nil { // 创建最终文件的保存目录
os.Remove(staging)
return "", fmt.Errorf("创建目录失败 %w", err)
}
if err := os.Rename(staging, abs); err != nil { // 将合并分片的临时文件按照需求重命名为最终文件
os.Remove(staging)
return "", fmt.Errorf("保存文件失败 %w", err)
}
//--------------------------------
obj := model.FileObject{ // 创建一个变量,用来存储文件对象
Hash: got,
Size: task.FileSize,
Ext: ext,
Mime: allowedExt[ext],
StoragePath: filepath.ToSlash(rel),
RefCount: 1,
}
if err := data.GetDB().Create(&obj).Error; err != nil { // 创建一个 sql, 将文件对象写入数据库
var existing model.FileObject
if err2 := data.GetDB().Where("hash = ?", got).First(&existing).Error; err2 != nil { // 查询数据库中是否存在符合这些参数条件的文件对象,并且把查到的结果写入声明的 existing 变量里面
return "", fmt.Errorf("保存文件记录失败 %w", err)
}
os.Remove(abs)
data.GetDB().Model(&existing).Update("ref_count", gorm.Expr("ref_count + 1")) // 更新文件对象的引用计数
obj = existing
}
// 更新上传任务状态为 completed,并设置文件对象ID
if err := data.GetDB().
Model(&model.UploadTask{}).
Where("upload_id = ?", uploadId).
Updates(map[string]any{
"status": model.UploadStatusCompleted,
"file_id": obj.ID,
}).Error; err != nil {
return "", fmt.Errorf("更新任务状态失败 %w", err)
}
os.RemoveAll(chunkDir) // 删除所有的临时分片文件
return obj.StoragePath, nil
}
// LoadTask
/*
查询数据库中符合要求的 task 数据
每次保存 分片之前都需要查一遍,用以区分不同用户上传的文件。
确保当前上传任务存在,并且状态为 uploading, 确保上传任务没有过期。
避免不同用户上传的文件出现混乱。
*/
func (s *UploadService) LoadTask(uploadId string, userId uint) (*model.UploadTask, error) {
if _, err := uuid.Parse(uploadId); err != nil {
return nil, errors.NewBusinessError(errors.InvalidParameter, "参数错误")
}
var task model.UploadTask // 声明变量,用来存储查询到的上传任务
if err := data.GetDB().Where("upload_id = ?", uploadId).First(&task).Error; err != nil { // 查询数据库中是否存在符合这些参数条件的任务,并且把查到的结果写入声明的 task 变量里面
return nil, errors.NewBusinessError(errors.InvalidParameter, "上传任务不存在")
}
if task.UserId != userId || task.Status != model.UploadStatusUploading {
return nil, errors.NewBusinessError(errors.InvalidParameter, "权限不足")
}
return &task, nil
}
// taskResult
/*
taskResult 会扫描磁盘目录 uploadFiles/tmp{uploadId} 目录下,已经上传的分片序号
组装成 InitResult 结构体,返回给前端。
*/
func (s *UploadService) taskResult(task *model.UploadTask) (*InitResult, error) {
uploaded, err := uploadedIndexes(task.UploadId) // 查询已经上传的分片序号
if err != nil {
return nil, err
}
return &InitResult{
UploadId: task.UploadId,
ChunkSize: task.ChunkSize,
ChunkTotal: task.ChunkTotal,
Uploaded: uploaded,
Finished: task.Status == model.UploadStatusCompleted,
}, nil
}
// uploadedIndexes
/*
查已上传的分片序号
忽略 .part.tmp 的文件,因为这些文件是写了一半, 不算一个完整的切片,不算在内。
*/
func uploadedIndexes(uploadId string) ([]int, error) {
dir := filepath.Join(storageBase(), "uploadFiles", "tmp", uploadId)
entries, err := os.ReadDir(dir)
if err != nil {
if os.IsNotExist(err) {
return []int{}, nil
}
return nil, fmt.Errorf("读取分片目录失败 %w", err)
}
indexes := make([]int, 0)
for _, entry := range entries {
name := entry.Name()
// .part.tmp 的文件是写了一半, 不算一个完整的切片,不算在内
if entry.IsDir() || !strings.HasSuffix(name, ".part") {
continue
}
index, err := strconv.Atoi(strings.TrimSuffix(name, ".part"))
if err != nil || index < 0 {
continue
}
indexes = append(indexes, index)
}
sort.Ints(indexes)
return indexes, nil
}
func (s *UploadService) Status(uploadId string, userId uint) (*InitResult, error) {
task, err := s.LoadTask(uploadId, userId)
if err != nil {
return nil, err
}
return s.taskResult(task)
}
// 检查上传的文件是否支持
func checkUploadType(filename string, head []byte) error {
ext := strings.ToLower(filepath.Ext(filename))
if _, ok := allowedExt[ext]; !ok {
return errors.NewBusinessError(errors.InvalidParameter, "不支持该文件类型")
}
if len(head) == 0 {
return errors.NewBusinessError(errors.InvalidParameter, "该文件内容为空")
}
// 单独处理 .mov 文件,因为 .mov 文件的文件头在第 4 到第8 字节,标准库识别不了
if ext == ".mov" {
if len(head) < 8 || string(head[4:8]) != "ftyp" {
return errors.NewBusinessError(errors.InvalidParameter, "文件内容与文件类型不符合")
}
return nil
}
kind := http.DetectContentType(head) // 根据文件内容的开头的几个字节,去判断文件类型,比较靠谱
if i := strings.Index(kind, ";"); i >= 0 {
kind = kind[:i]
}
if kind != allowedExt[ext] {
return errors.NewBusinessError(errors.InvalidParameter, "文件内容与文件类型不符合")
}
return nil
}
// UploadAbort 用户取消上传任务
func (s *UploadService) UploadAbort(uploadId string, userId uint) error {
if _, err := uuid.Parse(uploadId); err != nil {
return errors.NewBusinessError(errors.InvalidParameter, "参数错误")
}
var task model.UploadTask
if err := data.GetDB().Where("upload_id = ?", uploadId).First(&task).Error; err != nil {
return errors.NewBusinessError(errors.InvalidParameter, "上传任务不存在")
}
if task.UserId != userId {
return errors.NewBusinessError(errors.InvalidParameter, "权限不足")
}
if task.Status == model.UploadStatusCompleted {
return errors.NewBusinessError(errors.InvalidParameter, "任务已完成,无需取消")
}
base := storageBase()
_ = os.RemoveAll(filepath.Join(base, "uploadFiles", "tmp", uploadId))
_ = os.RemoveAll(filepath.Join(base, "uploadFiles", "tmp", uploadId+".merging"))
if task.Status != model.UploadStatusAborted {
if err := data.GetDB().Model(&model.UploadTask{}).Where("Upload_id = ?", uploadId).Update("status", model.UploadStatusAborted).Error; err != nil {
return fmt.Errorf("更新任务状态失败 %w", err)
}
}
return nil
}
// storageBase 上传文件根目录;Vercel 上只有临时目录可写
func storageBase() string {
if os.Getenv("VERCEL") != "" {
return os.TempDir()
}
return config.GetConfig().BasePath
}