Go语言Web开发：表单处理与数据持久化的模块化实践

go get github.com/gorilla/schema

package main

import (
    "fmt"
    "log"
    "net/http"

    "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"`
}

var decoder = schema.NewDecoder()

func registerHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.ServeFile(w, r, "register.html") // 假设存在一个register.html文件
        return
    }

    // 解析表单数据
    err := r.ParseForm()
    if err != nil {
        http.Error(w, "无法解析表单数据", http.StatusBadRequest)
        return
    }

    var userForm UserForm
    // 解码表单数据到结构体
    err = decoder.Decode(&userForm, r.PostForm)
    if err != nil {
        http.Error(w, fmt.Sprintf("表单数据解码失败: %v", err), http.StatusBadRequest)
        return
    }

    // 至此，userForm 结构体已填充了表单数据
    // 接下来通常会进行数据验证
    if userForm.Age < 18 {
        http.Error(w, "用户必须年满18岁", http.StatusBadRequest)
        return
    }

    // 如果通过验证，则处理业务逻辑（例如保存到数据库）
    fmt.Fprintf(w, "用户 %s (%s) 注册成功！年龄: %d\n", userForm.Username, userForm.Email, userForm.Age)
}

func main() {
    http.HandleFunc("/register", registerHandler)
    log.Println("服务器正在监听 :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

go get github.com/jmoiron/sqlx
go get github.com/mattn/go-sqlite3 // 示例使用SQLite

package main

import (
    "fmt"
    "log"

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

// User 定义了数据库中用户的结构
type User struct {
    ID       int    `db:"id"`       // db标签用于映射数据库列名
    Username string `db:"username"`
    Email    string `db:"email"`
}

func main() {
    // 连接到SQLite数据库
    db, err := sqlx.Connect("sqlite3", "file:user.db?cache=shared&mode=rwc")
    if err != nil {
        log.Fatalf("无法连接到数据库: %v", err)
    }
    defer db.Close()

    // 创建用户表（如果不存在）
    schema := `CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        username TEXT NOT NULL UNIQUE,
        email TEXT NOT NULL UNIQUE
    );`
    db.MustExec(schema)

    // 插入一条记录
    _, err = db.Exec("INSERT INTO users (username, email) VALUES (?, ?)", "alice", "alice@example.com")
    if err != nil {
        log.Printf("插入用户失败 (可能已存在): %v", err)
    }

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

    // 插入更多记录
    usersToInsert := []User{
        {Username: "bob", Email: "bob@example.com"},
        {Username: "charlie", Email: "charlie@example.com"},
    }
    for _, u := range usersToInsert {
        _, err = db.Exec("INSERT INTO users (username, email) VALUES (?, ?)", u.Username, u.Email)
        if err != nil {
            log.Printf("插入用户失败 (可能已存在): %v", err)
        }
    }

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

    // 使用命名参数执行更新
    updateUser := User{ID: user.ID, Username: "alice_updated", Email: "alice_new@example.com"}
    _, err = db.NamedExec("UPDATE users SET username = :username, email = :email WHERE id = :id", updateUser)
    if err != nil {
        log.Fatalf("更新用户失败: %v", err)
    }
    fmt.Printf("\n用户ID %d 已更新为: %s, %s\n", updateUser.ID, updateUser.Username, updateUser.Email)
}