Go Web服务器中高效处理上传的Zip文件：避免磁盘I/O与获取文件大小

package main

import (
    "archive/zip"
    "bytes"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
    "strconv"
)

// uploadHandler 处理文件上传请求
func uploadHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }

    // 解析 multipart/form-data
    // r.ParseMultipartForm(32 << 20) // 32MB max memory for form data
    // 或者直接使用 FormFile，它会自动处理解析

    file, header, err := r.FormFile("fileTag") // "fileTag" 是表单中文件输入字段的name属性
    if err != nil {
        http.Error(w, fmt.Sprintf("Error retrieving file: %v", err), http.StatusBadRequest)
        return
    }
    defer file.Close() // 确保文件句柄被关闭

    fmt.Printf("Uploaded File: %s\n", header.Filename)
    fmt.Printf("File Size: %d bytes\n", header.Size) // header.Size 提供了文件大小，但对于 zip.NewReader 来说，我们还需要 io.ReaderAt 接口
    fmt.Printf("MIME Header: %+v\n", header.Header)

    // 后续步骤将处理如何获取适合 zip.NewReader 的 fileSize
    // ...
}

func main() {
    http.HandleFunc("/upload", uploadHandler)
    fmt.Println("Server started on :8080, upload at /upload")
    http.ListenAndServe(":8080", nil)
}

// ... 在 uploadHandler 函数中 ...

var fileSize int64
contentLengthStr := header.Header.Get("Content-Length")
if contentLengthStr != "" {
    parsedSize, err := strconv.ParseInt(contentLengthStr, 10, 64)
    if err == nil {
        fileSize = parsedSize
        fmt.Printf("File size from Content-Length header: %d bytes\n", fileSize)
    } else {
        fmt.Printf("Warning: Could not parse Content-Length header: %v\n", err)
    }
}

// 如果 Content-Length 不可用或解析失败，需要其他方法获取 fileSize
// ...

// ... 在 uploadHandler 函数中 ...

if fileSize == 0 { // 仅当之前未获取到 fileSize 时执行
    var buf bytes.Buffer
    n, err := buf.ReadFrom(file) // 读取所有文件内容到缓冲区
    if err != nil {
        http.Error(w, fmt.Sprintf("Error reading file into buffer: %v", err), http.StatusInternalServerError)
        return
    }
    fileSize = n
    fmt.Printf("File size from buffer read: %d bytes\n", fileSize)

    // 重要：原始的 'file' Reader 已经被消耗，现在需要从 'buf' 创建一个新的 ReaderAt
    // 由于 buf.ReadFrom 已经将所有内容读入内存，buf 本身就可以作为 io.ReaderAt (通过 bytes.NewReader)
    file = io.NopCloser(bytes.NewReader(buf.Bytes())) // 重新包装为 io.ReadCloser
    // 注意：这里将 file 变量重新赋值，以供后续 zip.NewReader 使用。
    // 但原始的 multipart.File 实际上已经实现了 io.ReaderAt，所以如果 fileSize 确定了，
    // 我们可以直接使用原始的 file 变量，而不需要重新包装。
    // 这里的重新赋值是为了演示如果原始 Reader 被消耗后如何处理。
}

// ... 在 uploadHandler 函数中 ...

if fileSize == 0 { // 仅当之前未获取到 fileSize 时执行
    switch f := file.(type) {
    case *bytes.Reader: // 如果之前通过 bytes.NewReader 重新包装过
        fileSize = f.Size()
        fmt.Printf("File size from bytes.Reader: %d bytes\n", fileSize)
    case *io.SectionReader:
        fileSize = f.Size()
        fmt.Printf("File size from io.SectionReader: %d bytes\n", fileSize)
    case *os.File:
        if stat, err := f.Stat(); err == nil {
            fileSize = stat.Size()
            fmt.Printf("File size from os.File stat: %d bytes\n", fileSize)
        } else {
            fmt.Printf("Warning: Could not stat os.File: %v\n", err)
        }
    default:
        // 如果以上类型都不匹配，可能需要回退到读取缓冲区的方法
        // 或者，如果 header.Size 足够可靠，可以直接使用 header.Size
        // 对于 multipart.File，header.Size 通常是可靠的。
        // 这里的类型断言更多是作为一种深入理解底层实现的方式。
        fmt.Println("Warning: Could not determine file size via type assertion. Falling back to header.Size or buffer read.")
        fileSize = header.Size // 回退到 header.Size
    }
}

if fileSize == 0 {
    http.Error(w, "Could not determine file size.", http.StatusInternalServerError)
    return
}

// ... 在 uploadHandler 函数中，确保 file 是 io.ReaderAt 且 fileSize 已确定 ...

// 将 multipart.File 转换为 io.ReaderAt。
// multipart.File 接口本身就包含了 ReadAt 方法，所以可以直接使用。
// 如果之前通过 bytes.NewReader 重新包装过，则 file 已经是 *bytes.Reader，它也实现了 io.ReaderAt。
readerAt, ok := file.(io.ReaderAt)
if !ok {
    http.Error(w, "File does not implement io.ReaderAt", http.StatusInternalServerError)
    return
}

zipReader, err := zip.NewReader(readerAt, fileSize)
if err != nil {
    http.Error(w, fmt.Sprintf("Error creating zip reader: %v", err), http.StatusInternalServerError)
    return
}

fmt.Fprintln(w, "Successfully processed zip file:")
for _, f := range zipReader.File {
    fmt.Printf("  Processing file in zip: %s (Size: %d bytes)\n", f.Name, f.UncompressedSize64)
    fmt.Fprintf(w, "  - %s (Size: %d bytes)\n", f.Name, f.UncompressedSize64)

    // 打开文件进行读取
    rc, err := f.Open()
    if err != nil {
        fmt.Printf("    Error opening file %s in zip: %v\n", f.Name, err)
        continue
    }
    defer rc.Close() // 确保每个内部文件读取器都被关闭

    // 读取文件内容（例如，打印到控制台或进一步处理）
    // content, err := io.ReadAll(rc)
    // if err != nil {
    //  fmt.Printf("    Error reading content of %s: %v\n", f.Name, err)
    //  continue
    // }
    // fmt.Printf("    Content of %s:\n%s\n", f.Name, string(content))
    // 示例：将文件内容写入响应，或保存到其他地方
    // _, err = io.Copy(w, rc)
    // if err != nil {
    //  fmt.Printf("    Error writing content of %s to response: %v\n", f.Name, err)
    // }
}

fmt.Fprintln(w, "Zip file processing complete.")
}