GolangWeb多文件上传与批量处理方法

multipart/form-data

multipart/form-data

enctype="multipart/form-data"

multiple

name

r.ParseMultipartForm()

package main

import (
    "fmt"
    "io"
    "log"
    "mime/multipart"
    "net/http"
    "os"
    "path/filepath"
    "sync"
    "time"
)

const maxUploadSize = 20 << 20 // 20 MB，这里我习惯性地把单个文件大小限制放宽一点，但总请求体大小仍需注意

func uploadHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "只支持POST请求", http.StatusMethodNotAllowed)
        return
    }

    // 解析multipart表单，将文件数据加载到内存或磁盘。
    // 这里的maxUploadSize是整个请求体的最大内存占用，超出部分会写入临时文件。
    // 我通常会给一个相对宽松的值，但具体要根据实际业务场景来定。
    err := r.ParseMultipartForm(maxUploadSize)
    if err != nil {
        http.Error(w, fmt.Sprintf("解析请求失败: %v", err), http.StatusBadRequest)
        return
    }

    // 从表单中获取所有名为"files"的文件
    files := r.MultipartForm.File["files"]
    if len(files) == 0 {
        http.Error(w, "没有文件被上传", http.StatusBadRequest)
        return
    }

    uploadDir := "./uploads" // 定义上传文件存放的目录
    if _, err := os.Stat(uploadDir); os.IsNotExist(err) {
        err = os.Mkdir(uploadDir, 0755) // 如果目录不存在就创建
        if err != nil {
            http.Error(w, fmt.Sprintf("创建上传目录失败: %v", err), http.StatusInternalServerError)
            return
        }
    }

    var uploadedPaths []string
    var uploadErrors []error
    var wg sync.WaitGroup
    var mu sync.Mutex // 保护uploadedPaths和uploadErrors的并发写入

    // 我个人比较喜欢用goroutine来处理每个文件的上传，这样效率会高很多，尤其是在I/O密集型任务中。
    for _, fileHeader := range files {
        wg.Add(1)
        go func(fh *multipart.FileHeader) {
            defer wg.Done()

            // 对单个文件大小进行校验，这很重要，防止恶意上传过大文件
            if fh.Size > maxUploadSize {
                mu.Lock()
                uploadErrors = append(uploadErrors, fmt.Errorf("文件 '%s' 过大 (限制 %d MB)", fh.Filename, maxUploadSize/1024/1024))
                mu.Unlock()
                return
            }

            src, err := fh.Open() // 打开上传的文件
            if err != nil {
                mu.Lock()
                uploadErrors = append(uploadErrors, fmt.Errorf("打开文件 '%s' 失败: %w", fh.Filename, err))
                mu.Unlock()
                return
            }
            defer src.Close() // 确保文件句柄关闭

            // 文件名处理：我通常会加上时间戳或者UUID，并用filepath.Base()确保安全，防止路径遍历攻击。
            filename := filepath.Base(fh.Filename)
            newFileName := fmt.Sprintf("%d-%s", time.Now().UnixNano(), filename)
            filePath := filepath.Join(uploadDir, newFileName)

            dst, err := os.Create(filePath) // 创建目标文件
            if err != nil {
                mu.Lock()
                uploadErrors = append(uploadErrors, fmt.Errorf("创建文件 '%s' 失败: %w", filePath, err))
                mu.Unlock()
                return
            }
            defer dst.Close()

            if _, err := io.Copy(dst, src); err != nil { // 将上传文件内容拷贝到目标文件
                mu.Lock()
                uploadErrors = append(uploadErrors, fmt.Errorf("保存文件 '%s' 失败: %w", fh.Filename, err))
                mu.Unlock()
                return
            }
            log.Printf("文件 '%s' 成功上传到 '%s'", fh.Filename, filePath)

            mu.Lock()
            uploadedPaths = append(uploadedPaths, filePath)
            mu.Unlock()
        }(fileHeader)
    }

    wg.Wait() // 等待所有文件上传goroutine完成

    // 处理上传过程中可能出现的错误
    if len(uploadErrors) > 0 {
        errMsg := "部分文件上传失败:\n"
        for _, err := range uploadErrors {
            errMsg += "- " + err.Error() + "\n"
        }
        http.Error(w, errMsg, http.StatusInternalServerError)
        return
    }

    // 批量处理：这里只是一个占位符，实际业务逻辑会更复杂
    // 比如，你可以将uploadedPaths发送到一个消息队列，或者启动一个新的goroutine池进行图片处理、文件分析等。
    log.Printf("所有文件上传完成，共 %d 个。准备进行批量处理...", len(uploadedPaths))
    // 假设这里调用一个批处理函数
    batchProcessFiles(uploadedPaths)

    fmt.Fprintf(w, "成功上传 %d 个文件，并已触发批量处理。", len(uploadedPaths))
}

// 这是一个模拟的批处理函数
func batchProcessFiles(paths []string) {
    log.Println("开始批量处理文件...")
    for _, p := range paths {
        log.Printf("处理文件: %s (这里可以进行图片压缩、病毒扫描、元数据提取等操作)", p)
        // 模拟处理时间
        time.Sleep(100 * time.Millisecond)
    }
    log.Println("批量处理完成。")
}

func main() {
    http.HandleFunc("/upload", uploadHandler)
    log.Println("服务器启动，监听 :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

/*
前端HTML示例 (保存为 index.html):
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>多文件上传</title>
</head>
<body>
    <h1>上传多个文件</h1>
    <form action="/upload" method="post" enctype="multipart/form-data">
        <input type="file" name="files" multiple>
        <br><br>
        <input type="submit" value="上传">
    </form>
</body>
</html>
*/

http://localhost:8080/index.html

http://localhost:8080/upload

defer file.Close()

r.ParseMultipartForm()

sync.WaitGroup

sync.Mutex

io.Copy

ParseMultipartForm