首先明確答案：處理Golang文件上傳需解析多部分錶單、驗證文件類型與大小、安全保存文件。 1. 使用r.ParseMultipartForm(10

Handling file uploads in a Golang web service is straightforward using the standard net/http package. Here's how to do it securely and efficiently.

Set up a file upload endpoint

Start by creating a simple HTTP handler that accepts multipart form data. Use r.ParseMultipartForm() to parse incoming files and form values.

 func uploadHandler(w http.ResponseWriter, r *http.Request) {
    // Limit request size (eg, 10 MB)
    r.ParseMultipartForm(10 << 20)

    file, handler, err := r.FormFile("file")
    if err != nil {
        http.Error(w, "Error retrieving file", http.StatusBadRequest)
        return
    }
    defer file.Close()

    // Print file info (optional)
    fmt.Fprintf(w, "Uploaded File: %s\n", handler.Filename)
    fmt.Fprintf(w, "File Size: %d bytes\n", handler.Size)
    fmt.Fprintf(w, "MIME Header: %v\n", handler.Header)
}

Register this handler with your router:

 http.HandleFunc("/upload", uploadHandler)
http.ListenAndServe(":8080", nil)

Save the uploaded file to disk

After retrieving the file, copy it to a desired location on the server.

 func uploadHandler(w http.ResponseWriter, r *http.Request) {
    r.ParseMultipartForm(10 << 20)

    file, handler, err := r.FormFile("file")
    if err != nil {
        http.Error(w, "Error retrieving file", http.StatusBadRequest)
        return
    }
    defer file.Close()

    // Create destination file
    dst, err := os.Create("./uploads/" handler.Filename)
    if err != nil {
        http.Error(w, "Unable to create file", http.StatusInternalServerError)
        return
    }
    defer dst.Close()

    // Copy uploaded file to destination
    if _, err := io.Copy(dst, file); err != nil {
        http.Error(w, "Unable to save file", http.StatusInternalServerError)
        return
    }

    fmt.Fprintf(w, "File uploaded successfully: %s\n", handler.Filename)
}

Make sure the ./uploads directory exists or create it programmatically.

Validate file type and size

Always validate files before saving to avoid security risks.

• Check file size using handler.Size
• Verify file type by inspecting the first few bytes (not just the extension)

 // Limit file size
if handler.Size > 10<<20 {
    http.Error(w, "File too large", http.StatusBadRequest)
    return
}

// Check MIME type
buffer := make([]byte, 512)
_, err = file.Read(buffer)
if err != nil {
    http.Error(w, "Error reading file", http.StatusInternalServerError)
    return
}

// Reset file offset for io.Copy
file.Seek(0, 0)

fileType := http.DetectContentType(buffer)
allowedTypes := map[string]bool{
    "image/jpeg": true,
    "image/png": true,
    "application/pdf": true,
}

if !allowedTypes[fileType] {
    http.Error(w, "File type not allowed", http.StatusBadRequest)
    return
}

Additional best practices

• Use random filenames to prevent overwrites and path traversal
• Run the service with minimal file system permissions
• Consider storing files outside the web root or using cloud storage (eg, AWS S3)
• Sanitize filenames if keeping original names

 // Generate a safe filename
filename := uuid.New().String() filepath.Ext(handler.Filename)
dst, err := os.Create("./uploads/" filename)

Use os.MkdirAll() to ensure the upload directory exists:

 if err := os.MkdirAll("./uploads", os.ModePerm); err != nil {
    log.Fatal(err)
}

Basically, handle file uploads by parsing multipart forms, validating content, and saving safely. It's not complex but easy to get wrong without proper checks.

以上是如何處理Golang Web服務(wù)中的文件上傳的詳細內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！