Go语言Web表单处理与数据绑定：模块化实现策略解析

package main

import (
    "fmt"
    "net/http"
    "net/url" // 引入url包
    "time"

    "github.com/gorilla/schema" // 引入gorilla/schema
)

// UserForm 定义了用户注册表单的结构
type UserForm struct {
    Username  string    `schema:"username,required"`
    Email     string    `schema:"email,required"`
    Password  string    `schema:"password,required"`
    Age       int       `schema:"age"`
    CreatedAt time.Time `schema:"created_at"` // 示例，通常由后端生成
}

func main() {
    // 模拟一个HTTP POST请求的表单数据
    formData := url.Values{
        "username": {"john_doe"},
        "email":    {"john.doe@example.com"},
        "password": {"secure_password123"},
        "age":      {"30"},
        // "created_at" 通常不由表单直接提供
    }

    var userForm UserForm
    decoder := schema.NewDecoder()

    // 忽略未知字段，避免因表单提交了结构体中不存在的字段而报错
    decoder.IgnoreUnknownKeys(true) 

    // 设置时间解析格式，如果需要从字符串解析时间
    // decoder.RegisterConverter(time.Time{}, func(s string) reflect.Value {
    //  t, err := time.Parse("2006-01-02", s) // 假设日期格式为 YYYY-MM-DD
    //  if err != nil {
    //      return reflect.ValueOf(time.Time{})
    //  }
    //  return reflect.ValueOf(t)
    // })

    // 将表单数据解码到UserForm结构体
    err := decoder.Decode(&userForm, formData)
    if err != nil {
        fmt.Printf("解码表单数据失败: %v\n", err)
        return
    }

    fmt.Printf("成功解码表单数据:\n")
    fmt.Printf("  用户名: %s\n", userForm.Username)
    fmt.Printf("  邮箱: %s\n", userForm.Email)
    fmt.Printf("  年龄: %d\n", userForm.Age)
    fmt.Printf("  密码: %s (出于安全考虑，实际应用中不应直接打印密码)\n", userForm.Password)

    // 模拟一个HTTP请求处理器中的使用场景
    http.HandleFunc("/register", func(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPost {
            http.Error(w, "只接受POST请求", http.StatusMethodNotAllowed)
            return
        }

        err := r.ParseForm() // 解析HTTP请求体中的表单数据
        if err != nil {
            http.Error(w, "解析表单失败", http.StatusBadRequest)
            return
        }

        var registerForm UserForm
        // 使用同一个decoder实例
        err = decoder.Decode(&registerForm, r.PostForm)
        if err != nil {
            http.Error(w, fmt.Sprintf("绑定表单数据失败: %v", err), http.StatusBadRequest)
            return
        }

        fmt.Fprintf(w, "注册成功，用户信息: %+v\n", registerForm)
        // 在此处可以进行数据验证、持久化等操作
    })

    fmt.Println("服务器在 :8080 启动，访问 http://localhost:8080/register (POST请求)")
    // http.ListenAndServe(":8080", nil) // 实际运行时取消注释
}

package main

import (
    "database/sql"
    "fmt"
    "log"
    "time"

    _ "github.com/mattn/go-sqlite3" // 引入SQLite驱动
    "github.com/jmoiron/sqlx"      // 引入sqlx
)

// User 定义了数据库中的用户模型
type User struct {
    ID        int       `db:"id"`
    Username  string    `db:"username"`
    Email     string    `db:"email"`
    Password  string    `db:"password"` // 实际应用中应存储哈希值
    Age       int       `db:"age"`
    CreatedAt time.Time `db:"created_at"`
}

func main() {
    // 连接到SQLite数据库（如果文件不存在则创建）
    db, err := sqlx.Connect("sqlite3", "users.db")
    if err != nil {
        log.Fatalf("连接数据库失败: %v", err)
    }
    defer db.Close()

    // 创建users表（如果不存在）
    schema := `CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        username TEXT NOT NULL UNIQUE,
        email TEXT NOT NULL UNIQUE,
        password TEXT NOT NULL,
        age INTEGER,
        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
    );`
    _, err = db.Exec(schema)
    if err != nil {
        log.Fatalf("创建表失败: %v", err)
    }
    fmt.Println("数据库表已准备就绪。")

    // 1. 插入新用户
    newUser := User{
        Username: "alice_smith",
        Email:    "alice@example.com",
        Password: "hashed_password_alice",
        Age:      25,
        // CreatedAt 字段通常由数据库自动填充或在Go代码中设置
    }

    // 使用NamedExec进行插入，它会根据结构体字段名和db标签自动映射
    insertQuery := `INSERT INTO users (username, email, password, age) VALUES (:username, :email, :password, :age)`
    result, err := db.NamedExec(insertQuery, newUser)
    if err != nil {
        fmt.Printf("插入用户失败: %v\n", err)
    } else {
        id, _ := result.LastInsertId()
        fmt.Printf("成功插入用户 %s，ID: %d\n", newUser.Username, id)
    }

    // 2. 查询单个用户
    var fetchedUser User
    queryUser := `SELECT id, username, email, password, age, created_at FROM users WHERE username = ?`
    err = db.Get(&fetchedUser, queryUser, "alice_smith")
    if err != nil {
        if err == sql.ErrNoRows {
            fmt.Println("未找到用户alice_smith")
        } else {
            fmt.Printf("查询用户失败: %v\n", err)
        }
    } else {
        fmt.Printf("查询到用户: %+v\n", fetchedUser)
    }

    // 3. 查询多个用户
    var users []User
    queryAllUsers := `SELECT id, username, email, password, age, created_at FROM users`
    err = db.Select(&users, queryAllUsers)
    if err != nil {
        fmt.Printf("查询所有用户失败: %v\n", err)
    } else {
        fmt.Println("所有用户:")
        for _, u := range users {
            fmt.Printf("  - %+v\n", u)
        }
    }
}

// 假设 userForm 已经通过 gorilla/schema 绑定了数据
// 进行自定义验证
if userForm.Username == "" {
    return fmt.Errorf("用户名不能为空")
}
if !strings.Contains(userForm.Email, "@") {
    return fmt.Errorf("邮箱格式不正确")
}
if userForm.Age < 18 {
    return fmt.Errorf("年龄必须大于18岁")
}
// ... 更多验证逻辑