Go语言Web表单处理：模块化方法与推荐库实践

package main

import (
    "fmt"
    "net/http"
    "github.com/gorilla/schema" // 导入gorilla/schema库
)

// UserForm 定义了预期从表单接收的数据结构
type UserForm struct {
    Username string `schema:"username,required"` // required表示该字段为必需
    Email    string `schema:"email,required"`
    Age      int    `schema:"age"`
    IsAdmin  bool   `schema:"isAdmin"`
}

func handler(w http.ResponseWriter, r *http.Request) {
    // 确保只处理POST请求
    if r.Method != http.MethodPost {
        http.Error(w, "Only POST method is allowed", http.StatusMethodNotAllowed)
        return
    }

    // 解析HTTP请求中的表单数据
    err := r.ParseForm()
    if err != nil {
        http.Error(w, "Failed to parse form data", http.StatusInternalServerError)
        return
    }

    var userForm UserForm
    decoder := schema.NewDecoder()
    // 配置解码器，忽略表单中存在但结构体中未定义的字段，避免报错
    decoder.IgnoreUnknownKeys(true)

    // 将解析后的表单数据解码到UserForm结构体中
    err = decoder.Decode(&userForm, r.PostForm)
    if err != nil {
        http.Error(w, fmt.Sprintf("Failed to decode form data: %v", err), http.StatusBadRequest)
        return
    }

    // 此时 userForm 结构体已填充表单数据，可进行后续处理
    fmt.Fprintf(w, "Received User Data:\n")
    fmt.Fprintf(w, "  Username: %s\n", userForm.Username)
    fmt.Fprintf(w, "  Email: %s\n", userForm.Email)
    fmt.Fprintf(w, "  Age: %d\n", userForm.Age)
    fmt.Fprintf(w, "  IsAdmin: %t\n", userForm.IsAdmin)

    // 后续可进行数据验证和业务逻辑处理
}

func main() {
    http.HandleFunc("/submit", handler)
    fmt.Println("Server listening on :8080, submit form via POST to /submit")
    http.ListenAndServe(":8080", nil)
}

package main

import (
    "fmt"
    "github.com/go-playground/validator/v10" // 导入验证库
)

// UserFormValidated 定义了带有验证规则的结构体
type UserFormValidated struct {
    Username string `validate:"required,min=3,max=32"` // 必需，长度3-32
    Email    string `validate:"required,email"`        // 必需，有效邮箱格式
    Age      int    `validate:"gte=18,lte=100"`        // 年龄在18到100之间
}

func main() {
    // 创建一个新的验证器实例
    validate := validator.New()

    // 示例1：有效用户数据
    validUser := UserFormValidated{
        Username: "testuser",
        Email:    "test@example.com",
        Age:      25,
    }

    err := validate.Struct(validUser)
    if err != nil {
        fmt.Println("Validation errors for valid user (should not happen):", err)
    } else {
        fmt.Println("Valid user data is valid.")
    }

    fmt.Println("--------------------")

    // 示例2：无效用户数据
    invalidUser := UserFormValidated{
        Username: "ab",            // 用户名太短
        Email:    "invalid-email", // 邮箱格式错误
        Age:      10,              // 年龄太小
    }

    err = validate.Struct(invalidUser)
    if err != nil {
        fmt.Println("Validation errors for invalid user:")
        // 遍历并打印所有验证错误
        for _, err := range err.(validator.ValidationErrors) {
            fmt.Printf("  Field: %s, Tag: %s, Value: '%v', Param: %s\n",
                err.Field(), err.Tag(), err.Value(), err.Param())
        }
    } else {
        fmt.Println("Invalid user data is valid (should not happen).")
    }
}

package main

import (
    "fmt"
    "log"

    "github.com/jmoiron/sqlx" // 导入sqlx库
    _ "github.com/mattn/go-sqlite3" // 导入SQLite驱动，通常用于开发和测试
)

// User 定义了与数据库表结构对应的结构体
type User struct {
    ID       int    `db:"id"`       // `db` tag用于指定数据库列名
    Username string `db:"username"`
    Email    string `db:"email"`
        Age      int    `db:"age"`
}

func main() {
    // 连接数据库
    // ":memory:" 表示使用内存数据库，数据不会持久化
    db, err := sqlx.Connect("sqlite3", ":memory:")
    if err != nil {
        log.Fatalf("Failed to connect to database: %v", err)
    }
    defer db.Close() // 确保在函数结束时关闭数据库连接

    // 创建用户表
    schema := `CREATE TABLE users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        username TEXT NOT NULL UNIQUE,
        email TEXT NOT NULL,
        age INTEGER
    );`
    db.MustExec(schema) // MustExec在执行失败时会panic

    // 插入数据
    tx := db.MustBegin() // 开始一个事务
    tx.MustExec("INSERT INTO users (username, email, age) VALUES (?, ?, ?)", "alice", "alice@example.com", 30)
    tx.MustExec("INSERT INTO users (username, email, age) VALUES (?, ?, ?)", "bob", "bob@example.com", 25)
    tx.Commit() // 提交事务

    // 查询所有用户并映射到结构体切片
    var users []User
    err = db.Select(&users, "SELECT id, username, email, age FROM users")
    if err != nil {
        log.Fatalf("Failed to select users: %v", err)
    }

    fmt.Println("All users:")
    for _, user := range users {
        fmt.Printf("  ID: %d, Username: %s, Email: %s, Age: %d\n", user.ID, user.Username, user.Email, user.Age)
    }

    // 查询单个用户
    var singleUser User
    err = db.Get(&singleUser, "SELECT id, username, email, age FROM users WHERE username = ?", "alice")
    if err != nil {
        log.Fatalf("Failed to get user: %v", err)
    }
    fmt.Printf("\nSingle user (Alice): ID: %d, Username: %s, Email: %s, Age: %d\n",
        singleUser.ID, singleUser.Username, singleUser.Email, singleUser.Age)
}