Go语言Web表单与数据绑定实践：模块化方案解析

package main

import (
    "fmt"
    "net/http"
    "net/url" // 导入url包
    "github.com/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"` // 这是一个可选字段
}

func main() {
    // 模拟一个HTTP POST请求的表单数据
    // 在实际应用中，这些数据会来自 http.Request.PostForm 或 http.Request.Form
    formData := url.Values{}
    formData.Set("username", "john_doe")
    formData.Set("email", "john.doe@example.com")
    formData.Set("password", "secure_password_123")
    formData.Set("age", "30")

    // 创建一个schema.Decoder
    decoder := schema.NewDecoder()
    // 配置解码器，例如，如果字段不存在则不报错
    decoder.IgnoreUnknownKeys(true)

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

    fmt.Printf("解析后的用户表单数据: %+v\n", userForm)

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

        // 解析POST表单数据
        err := r.ParseForm()
        if err != nil {
            http.Error(w, fmt.Sprintf("解析表单失败: %v", err), http.StatusBadRequest)
            return
        }

        var registerForm UserForm
        // 将请求中的表单数据解码到结构体
        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.Printf("HTTP请求处理：成功注册用户: %+v\n", registerForm)
    })

    fmt.Println("服务器在 :8080 启动")
    // http.ListenAndServe(":8080", nil) // 在实际应用中，会启动服务器
}

package main

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

// UserForm 定义了表单数据的结构，并添加了验证标签
type UserForm struct {
    Username string `schema:"username" validate:"required,min=3,max=30"`
    Email    string `schema:"email" validate:"required,email"`
    Password string `schema:"password" validate:"required,min=6"`
    Age      int    `schema:"age" validate:"omitempty,min=18,max=120"` // omitempty表示字段为空时跳过验证
}

var validate *validator.Validate

func init() {
    validate = validator.New()
}

func main() {
    formData := url.Values{}
    formData.Set("username", "jo") // 不符合min=3
    formData.Set("email", "invalid-email") // 不符合email格式
    formData.Set("password", "123") // 不符合min=6
    formData.Set("age", "15") // 不符合min=18

    decoder := schema.NewDecoder()
    var userForm UserForm
    err := decoder.Decode(&userForm, formData)
    if err != nil {
        fmt.Printf("解码失败: %v\n", err)
        return
    }

    fmt.Printf("解码后的数据: %+v\n", userForm)

    // 执行验证
    err = validate.Struct(userForm)
    if err != nil {
        fmt.Printf("验证失败:\n")
        for _, err := range err.(validator.ValidationErrors) {
            fmt.Printf("- 字段: %s, 错误: %s, 值: %v\n", err.Field(), err.Tag(), err.Value())
        }
    } else {
        fmt.Println("数据验证成功！")
    }

    // 尝试一个有效的数据
    validFormData := url.Values{}
    validFormData.Set("username", "valid_user")
    validFormData.Set("email", "valid@example.com")
    validFormData.Set("password", "strong_password")
    validFormData.Set("age", "25")

    var validUserForm UserForm
    _ = decoder.Decode(&validUserForm, validFormData) // 忽略解码错误以便演示验证

    fmt.Printf("\n解码后的有效数据: %+v\n", validUserForm)
    err = validate.Struct(validUserForm)
    if err != nil {
        fmt.Printf("验证失败: %v\n", err)
    } else {
        fmt.Println("有效数据验证成功！")
    }
}

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/mattn/go-sqlite3" // 导入SQLite驱动
    "github.com/jmoiron/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"`
}

func main() {
    // 连接到SQLite数据库（内存模式用于演示）
    db, err := sqlx.Connect("sqlite3", ":memory:")
    if err != nil {
        panic(fmt.Sprintf("无法连接到数据库: %v", err))
    }
    defer db.Close()

    // 创建用户表
    schema := `CREATE TABLE users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        username TEXT NOT NULL UNIQUE,
        email TEXT NOT NULL UNIQUE,
        password TEXT NOT NULL,
        age INTEGER
    );`
    db.MustExec(schema)

    // 插入数据
    user1 := User{Username: "alice", Email: "alice@example.com", Password: "pass", Age: 28}
    user2 := User{Username: "bob", Email: "bob@example.com", Password: "word", Age: 35}

    // 使用命名参数插入数据
    _, err = db.NamedExec(`INSERT INTO users (username, email, password, age) VALUES (:username, :email, :password, :age)`, user1)
    if err != nil {
        fmt.Printf("插入用户1失败: %v\n", err)
    }
    _, err = db.NamedExec(`INSERT INTO users (username, email, password, age) VALUES (:username, :email, :password, :age)`, user2)
    if err != nil {
        fmt.Printf("插入用户2失败: %v\n", err)
    }

    // 查询所有用户并扫描到结构体切片
    var users []User
    err = db.Select(&users, "SELECT id, username, email, password, age FROM users")
    if err != nil {
        fmt.Printf("查询所有用户失败: %v\n", err)
    }
    fmt.Println("所有用户:")
    for _, u := range users {
        fmt.Printf("  %+v\n", u)
    }

    // 查询单个用户并扫描到结构体
    var singleUser User
    err = db.Get(&singleUser, "SELECT id, username, email, password, age FROM users WHERE username=?", "alice")
    if err != nil {
        fmt.Printf("查询单个用户失败: %v\n", err)
    } else {
        fmt.Println("\n查询到的单个用户:")
        fmt.Printf("  %+v\n", singleUser)
    }
}