第47课 - 表单处理与验证

学习目标

理解 Go Web 应用中处理 HTML 表单的基本流程
掌握使用 net/http 标准库解析和验证表单数据的方法
学会处理包含文件上传的多部分表单
能够编写结构化的表单验证逻辑
了解表单处理中的常见安全问题

核心概念

在 Web 开发中，表单是用户与服务器交互的主要方式。Go 语言通过标准库提供了强大的表单处理能力，整个流程可以分为三个关键步骤：

1. 表单解析

当用户提交表单时，数据会通过 HTTP 请求发送到服务器。Go 的 request 对象提供了多种方法来获取这些数据：

r.FormValue("field")：获取单个表单字段的值
r.PostFormValue("field")：只获取 POST 方法的表单字段
r.ParseForm()：解析所有表单数据到 r.Form 字典
r.ParseMultipartForm(maxMemory)：解析包含文件上传的多部分表单

2. 数据验证

表单数据必须经过严格验证才能使用，常见的验证包括：

必填字段检查
数据类型和格式验证（如邮箱、电话）
长度限制
自定义业务规则验证

3. 安全处理

永远不要信任用户输入！必须对表单数据进行清理，防止：

SQL 注入（使用参数化查询）
XSS 攻击（输出时转义）
CSRF 攻击（使用令牌验证）

代码示例

下面是一个完整的表单处理示例，包含基本表单和文件上传功能：

package main

import (
    "fmt"
    "html/template"
    "net/http"
    "path/filepath"
    "strconv"
    "strings"
)

// UserForm 结构体用于存储和验证用户表单数据
type UserForm struct {
    Name    string
    Email   string
    Age     int
    Avatar  string
    Errors  map[string]string
}

// NewUserForm 创建新的表单实例
func NewUserForm() *UserForm {
    return &UserForm{
        Errors: make(map[string]string),
    }
}

// Validate 验证表单数据
func (uf *UserForm) Validate() bool {
    uf.Errors = make(map[string]string)
    
    // 验证姓名（必填，长度2-50）
    if strings.TrimSpace(uf.Name) == "" {
        uf.Errors["Name"] = "姓名不能为空"
    } else if len(uf.Name) < 2 || len(uf.Name) > 50 {
        uf.Errors["Name"] = "姓名长度必须在2-50个字符之间"
    }
    
    // 验证邮箱（必填，简单格式检查）
    if strings.TrimSpace(uf.Email) == "" {
        uf.Errors["Email"] = "邮箱不能为空"
    } else if !strings.Contains(uf.Email, "@") || !strings.Contains(uf.Email, ".") {
        uf.Errors["Email"] = "请输入有效的邮箱地址"
    }
    
    // 验证年龄（必填，数字，范围1-150）
    if uf.Age == 0 {
        uf.Errors["Age"] = "年龄不能为空"
    } else if uf.Age < 1 || uf.Age > 150 {
        uf.Errors["Age"] = "年龄必须在1-150之间"
    }
    
    return len(uf.Errors) == 0
}

// Handler 处理表单提交
func formHandler(w http.ResponseWriter, r *http.Request) {
    form := NewUserForm()
    
    // 根据请求方法处理
    switch r.Method {
    case "GET":
        // 显示表单页面
        tmpl, _ := template.ParseFiles("form.html")
        tmpl.Execute(w, form)
        
    case "POST":
        // 解析基本表单数据
        err := r.ParseForm()
        if err != nil {
            http.Error(w, "解析表单失败", http.StatusBadRequest)
            return
        }
        
        // 填充表单数据
        form.Name = r.FormValue("name")
        form.Email = r.FormValue("email")
        
        // 处理年龄转换
        ageStr := r.FormValue("age")
        if ageStr != "" {
            age, err := strconv.Atoi(ageStr)
            if err != nil {
                form.Errors["Age"] = "年龄必须是数字"
            } else {
                form.Age = age
            }
        }
        
        // 处理文件上传（多部分表单）
        err = r.ParseMultipartForm(10 << 20) // 限制10MB
        if err == nil && r.MultipartForm.File["avatar"] != nil {
            // 获取上传的文件
            file, handler, err := r.FormFile("avatar")
            if err != nil {
                form.Errors["Avatar"] = "文件上传失败"
            } else {
                defer file.Close()
                
                // 验证文件类型
                allowedTypes := map[string]bool{
                    ".jpg":  true,
                    ".jpeg": true,
                    ".png":  true,
                    ".gif":  true,
                }
                
                ext := strings.ToLower(filepath.Ext(handler.Filename))
                if !allowedTypes[ext] {
                    form.Errors["Avatar"] = "只允许上传 JPG、PNG、GIF 图片"
                } else {
                    // 生成安全的文件名
                    safeFilename := fmt.Sprintf("%d%s", 
                        time.Now().UnixNano(), ext)
                    form.Avatar = safeFilename
                    
                    // 注意：实际应用中需要将文件保存到安全位置
                    // dst, err := os.Create(filepath.Join("uploads", safeFilename))
                    // if err == nil {
                    //     io.Copy(dst, file)
                    // }
                }
            }
        }
        
        // 验证表单
        if form.Validate() {
            // 验证通过，处理数据
            fmt.Fprintf(w, "表单提交成功！<br>")
            fmt.Fprintf(w, "姓名: %s<br>", template.HTMLEscapeString(form.Name))
            fmt.Fprintf(w, "邮箱: %s<br>", template.HTMLEscapeString(form.Email))
            fmt.Fprintf(w, "年龄: %d<br>", form.Age)
            if form.Avatar != "" {
                fmt.Fprintf(w, "头像文件: %s<br>", template.HTMLEscapeString(form.Avatar))
            }
        } else {
            // 验证失败，重新显示表单
            tmpl, _ := template.ParseFiles("form.html")
            tmpl.Execute(w, form)
        }
        
    default:
        http.Error(w, "不支持的方法", http.StatusMethodNotAllowed)
    }
}

func main() {
    http.HandleFunc("/form", formHandler)
    
    fmt.Println("服务器启动在 http://localhost:8080/form")
    http.ListenAndServe(":8080", nil)
}

对应的 form.html 模板文件：

<!DOCTYPE html>
<html>
<head>
    <title>表单处理示例</title>
</head>
<body>
    <h1>用户信息表单</h1>
    
    {{if .Errors}}
    <div style="color: red;">
        <strong>表单验证失败：</strong>
        <ul>
            {{range $field, $message := .Errors}}
            <li>{{$field}}: {{$message}}</li>
            {{end}}
        </ul>
    </div>
    {{end}}
    
    <form method="POST" enctype="multipart/form-data">
        <label>姓名:</label>
        <input type="text" name="name" value="{{.Name}}" required>
        <br><br>
        
        <label>邮箱:</label>
        <input type="email" name="email" value="{{.Email}}" required>
        <br><br>
        
        <label>年龄:</label>
        <input type="number" name="age" value="{{.Age}}" min="1" max="150" required>
        <br><br>
        
        <label>头像:</label>
        <input type="file" name="avatar" accept="image/*">
        <br><br>
        
        <button type="submit">提交</button>
    </form>
</body>
</html>

实践练习

练习 1：基础表单处理（初级）

创建一个简单的联系人表单，包含：

姓名（必填）
电话号码（必填，11位数字）
留言（必填，最少10个字符）

要求：

使用 r.ParseForm() 解析数据
编写验证逻辑确保所有字段符合要求
验证成功显示成功消息，失败显示错误信息

练习 2：多字段验证（中级）

扩展上面的表单，添加以下字段和验证规则：

生日（日期格式：YYYY-MM-DD，不能是未来日期）
个人网站（可选，如果填写必须是有效的URL格式）
爱好（多选，至少选择1项，最多3项）

提示：可以使用 time.Parse 解析日期，使用正则表达式验证URL

练习 3：文件上传验证（高级）

实现一个头像上传功能：

只允许上传图片文件（jpg/png/gif）
文件大小限制为2MB
验证图片尺寸（宽度和高度都在100-1000像素之间）
将文件安全地保存到服务器（使用时间戳重命名）

提示：使用 image.DecodeConfig 获取图片尺寸，注意防止路径遍历攻击

常见错误

1. 忘记检查解析错误

// 错误：没有检查解析错误
r.ParseForm()
name := r.FormValue("name")

// 正确：先检查错误
if err := r.ParseForm(); err != nil {
    http.Error(w, "表单解析失败", http.StatusBadRequest)
    return
}

2. 直接使用用户输入

// 危险：直接使用用户输入（可能导致SQL注入或XSS）
query := fmt.Sprintf("SELECT * FROM users WHERE name='%s'", name)

// 安全：使用参数化查询
db.Query("SELECT * FROM users WHERE name=?", name)

3. 文件上传内存溢出

// 错误：没有限制上传大小，可能导致内存溢出
r.ParseMultipartForm(0) // 无限制

// 正确：设置合理的内存限制
r.ParseMultipartForm(10 << 20) // 10MB

4. 验证顺序错误

// 错误：先验证再解析（验证时数据可能为空）
if form.Name == "" {
    // 这里form.Name可能还没有赋值
}

// 正确：先解析再验证
r.ParseForm()
form.Name = r.FormValue("name")
if form.Name == "" {
    // 现在验证是正确的
}

5. 文件类型只检查扩展名

// 不安全：只检查扩展名，可能被绕过
ext := filepath.Ext(filename)
if ext == ".jpg" {
    // 用户可能将恶意文件重命名为.jpg
}

// 更安全：检查文件内容的魔术数字（Magic Numbers）

小结

在本课中，我们学习了：

表单处理流程：从接收请求、解析数据、验证到响应输出的完整流程
解析方法：ParseForm() 用于普通表单，ParseMultipartForm() 用于文件上传
验证策略：必填验证、格式验证、范围验证和自定义业务规则验证
安全考虑：始终对用户输入进行清理，防止注入和XSS攻击
文件处理：验证文件类型、大小，并安全地存储文件

记住关键原则：

永远不要信任用户输入：所有数据都必须验证
提前验证：在数据使用前完成所有验证
错误处理：为每个验证点提供清晰的错误信息
安全存储：对上传文件进行重命名和路径安全处理

掌握了这些表单处理技术后，你就可以构建安全、可靠的 Web 表单功能。在下一课中，我们将学习如何使用中间件来统一处理跨多个处理器的通用逻辑。

表单处理与验证