• E.Evan's 博客.
  • 前端相关
  • 算法题
  • 日常笔记
  • Chat With AI
  • 博客AI助手
Evan Wang
Evan Wang前端开发 · 个人学习手记

慢一点,也是在向前。

文章目录

获取 URL 中的参数将对象转换为 url 字符串类型限制输入框只能输入数字利用 CSS 实现点击放大缩小元素前端实现水印大文件上传

  1. 首页
  2. 日常笔记
  3. Utils
  4. 大文件上传
© 2026 Evan 的博客
用心记录,保持好奇。Made with simplicity.
旧版 Blog 链接
25873 字
约 65 分钟
更新于 2026/11/04

大文件上传

核心思路:
把大文件拆解成一个个的小文件,分别上传到服务端。所有小文件都上传成功后,在服务端把小文件合并成大文件。

大文件上传可能会存在的问题: 假设用户选择了一个 2GB 的文件,前端直接一个 POST FormData 传上去,可能会遇到以下问题:

  1. 传递到中间断网了,已经上传的文件全废。只能从 0 开始重新上传。
  2. 服务端内存被打爆。 如果文件过大,文件会在磁盘临时目录里有一份,然后在向磁盘中写入一份。
  3. 上传过程中各种超时都可能会导致失败, Nginx 超时、浏览器和网关连接超时...
  4. 进度条没发暂停,整个任务要么成功,要么失败。

所以,需要把大文件拆成一个一个的小文件,每次传递一个小文件,每次传输只需要一两秒,即使当前小文件失败,也可以重新上传,不会耽误太多时间,尽量避免网络问题导致前功尽弃。

大致思路:

服务端需要记录已经上传文件的 hash 信息 file_object 表,和未完成上传的任务的信息 upload_task 表。

  1. 分块 按照一定大小(比如 2M),将大文件分割成一个个的小文件,并对每个小文件取 Hash, 最后再对所有的 Hash 取一次 Hash , 用来表示整个文件的 Hash.

  2. 初始化上传任务 先请求服务端 init 接口,带上请求参数:file_name, file_size, file_hash, chunk_size。

    • 服务端用 file_hash 判断之前是否有人传递过这个文件。服务端需要将之前传递过的文件 hash 存储到数据库中。然后根据 hash 判断文件是否被传递过。
      • 如果有,说明文件已经完整上传。直接返回结果,前端直接当作文件已经上传完成,实现秒传。
      • 如果没有,再查询当前 hash 上传任务,是否有未完成的上传任务,如果有,说明之前有人传过一部分文件。服务端需要根据信息找到已经上传的最后一个小文件,把编号返回给前端,前端收到返回之后,可以从编号后一个小文件开始上传,,这就是断点续传。
      • 如果两个都没查到,那说明是新的大文件上传,服务端就新增一条 upload_task 记录,状态改为 pending,并将一些信息返回给前端,走正常上传流程。
  3. 上传文件 前端收到新的 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 已经上传成功。

  4. 验收,调用 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 文件,

注意:

  • 前端对文件分割的时候,可以放在 web worker 中去处理,防止卡死主线程。
  • 上传文件的时候,需要控制并发,创建一个请求池,保证每次最多只有 3 个请求同时上传。
  • 前端进度条要保证不能回退。如果某个 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
}