Go Gin文件流式上传下载实战 | 避免内存溢出的高性能方案

package main

import (
    "os"
    "io"
    "github.com/gin-gonic/gin"
    "net/http"
)

func main() {
    r := gin.Default()

    // 流式文件上传接口
    r.POST("/upload/stream", func(c *gin.Context) {
        // 1. 解析 multipart 表单，不将文件加载到内存
        err := c.Request.ParseMultipartForm(32 << 20) // 32 MB 是表单其他字段的内存限制，文件会通过流处理
        if err != nil {
            c.JSON(http.StatusBadRequest, gin.H{
                "code":    400,
                "message": "解析表单失败：" + err.Error(),
            })
            return
        }

        // 2. 获取文件流，"file" 对应前端表单的 name 属性
        fileStream, handler, err := c.Request.FormFile("file")
        if err != nil {
            c.JSON(http.StatusBadRequest, gin.H{
                "code":    400,
                "message": "获取文件流失败：" + err.Error(),
            })
            return
        }
        defer fileStream.Close() // 确保文件流最终关闭，避免资源泄漏

        // 3. 创建目标文件，准备写入
        destPath := "./uploads/stream_" + handler.Filename
        destFile, err := os.Create(destPath)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{
                "code":    500,
                "message": "创建目标文件失败：" + err.Error(),
            })
            return
        }
        defer destFile.Close() // 确保目标文件最终关闭

        // 4. 流式拷贝：将文件流边读边写入到目标文件，缓冲区默认 32 KB
        _, err = io.Copy(destFile, fileStream)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{
                "code":    500,
                "message": "文件写入失败：" + err.Error(),
            })
            return
        }

        // 5. 响应成功信息
        c.JSON(http.StatusOK, gin.H{
            "code":    200,
            "message": "流式上传成功",
            "data": gin.H{
                "filePath": destPath,
                "fileName": handler.Filename,
                "fileSize": handler.Size,
            },
        })
    })

    // 启动服务
    _ = r.Run(":8080")
}

package main

import (
    "os"
    "github.com/gin-gonic/gin"
    "net/http"
)

func main() {
    r := gin.Default()

    // 流式文件下载接口，fileName 为要下载的文件名
    r.GET("/download/stream/:fileName", func(c *gin.Context) {
        // 1. 获取要下载的文件名
        fileName := c.Param("fileName")
        if fileName == "" {
            c.JSON(http.StatusBadRequest, gin.H{
                "code":    400,
                "message": "文件名不能为空",
            })
            return
        }

        // 2. 打开要下载的文件，获取文件流
        filePath := "./uploads/" + fileName
        srcFile, err := os.Open(filePath)
        if err != nil {
            c.JSON(http.StatusNotFound, gin.H{
                "code":    404,
                "message": "文件不存在：" + err.Error(),
            })
            return
        }
        defer srcFile.Close()

        // 3. 获取文件信息，用于设置响应头
        fileInfo, err := srcFile.Stat()
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{
                "code":    500,
                "message": "获取文件信息失败：" + err.Error(),
            })
            return
        }

        // 4. 设置响应头，告诉客户端这是下载文件
        c.Header("Content-Type", "application/octet-stream")
        c.Header("Content-Disposition", "attachment; filename="+fileName) // 指定下载后的文件名
        c.Header("Content-Length", string(rune(fileInfo.Size()))) // 设置文件大小

        // 5. 流式响应文件数据
        c.Status(http.StatusOK)
        if err := c.Stream(func(w io.Writer) bool {
            // 循环读取文件数据并写入响应流
            buffer := make([]byte, 32<<10) // 32 KB 缓冲区
            n, err := srcFile.Read(buffer)
            if err != nil && err != io.EOF {
                // 读取错误时返回 false，终止流
                return false
            }
            // 写入响应流
            _, _ = w.Write(buffer[:n])
            // 读取到 EOF 时返回 false，终止流
            return err != io.EOF
        }); err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{
                "code":    500,
                "message": "下载失败：" + err.Error(),
            })
            return
        }
    })

    _ = r.Run(":8080")
}