基础杂项：Cookie/Session、gcflags、数据结构与 DHCP

package main

import (
    "fmt"
    "net/http"
)

// 步骤1：设置 Cookie
func setCookieHandler(w http.ResponseWriter, r *http.Request) {
    // 步骤2：创建 Cookie
    cookie := &http.Cookie{
        Name:     "session_id",
        Value:    "abc123",
        Path:     "/",
        MaxAge:   3600,
        HttpOnly: true,
        Secure:   true,
    }
    // 步骤3：通过 Set-Cookie 响应头发送给浏览器
    http.SetCookie(w, cookie)
    fmt.Fprintf(w, "Cookie 已设置")
}

// 步骤4：读取 Cookie
func getCookieHandler(w http.ResponseWriter, r *http.Request) {
    // 步骤5：从请求中读取 Cookie
    cookie, err := r.Cookie("session_id")
    if err != nil {
        fmt.Fprintf(w, "Cookie 不存在")
        return
    }
    fmt.Fprintf(w, "Cookie 值: %s", cookie.Value)
}

// 步骤6：模拟 Session 存储
var sessionStore = map[string]map[string]interface{}{}

func loginHandler(w http.ResponseWriter, r *http.Request) {
    // 步骤7：创建 Session
    sessionID := "abc123"
    sessionStore[sessionID] = map[string]interface{}{
        "user_id": 1,
        "name":    "Alice",
    }
    // 步骤8：通过 Cookie 关联 SessionID
    http.SetCookie(w, &http.Cookie{
        Name:     "session_id",
        Value:    sessionID,
        Path:     "/",
        HttpOnly: true,
    })
    fmt.Fprintf(w, "登录成功")
}

func main() {
    http.HandleFunc("/set", setCookieHandler)
    http.HandleFunc("/get", getCookieHandler)
    http.HandleFunc("/login", loginHandler)
    http.ListenAndServe(":8080", nil)
}

package main

import (
    "fmt"
    "time"

    "github.com/golang-jwt/jwt/v5"
)

// 步骤1：定义 JWT 密钥
var secretKey = []byte("my-secret-key")

// 步骤2：生成 JWT Token
func generateToken(userID string) (string, error) {
    // 步骤3：创建 Claims（载荷）
    claims := jwt.MapClaims{
        "user_id": userID,
        "exp":     time.Now().Add(24 * time.Hour).Unix(),
        "iat":     time.Now().Unix(),
    }
    // 步骤4：创建 Token，指定签名算法
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    // 步骤5：签名并返回完整字符串
    return token.SignedString(secretKey)
}

// 步骤6：验证 JWT Token
func parseToken(tokenString string) (string, error) {
    // 步骤7：解析并验证签名
    token, err := jwt.Parse(tokenString, func(t *jwt.Token) (interface{}, error) {
        return secretKey, nil
    })
    if err != nil || !token.Valid {
        return "", fmt.Errorf("invalid token")
    }
    // 步骤8：提取 Claims
    claims := token.Claims.(jwt.MapClaims)
    userID := claims["user_id"].(string)
    return userID, nil
}

func main() {
    // 步骤9：生成 Token
    token, _ := generateToken("user123")
    fmt.Printf("Token: %s\n", token)

    // 步骤10：验证 Token
    userID, err := parseToken(token)
    if err != nil {
        fmt.Printf("验证失败: %v\n", err)
        return
    }
    fmt.Printf("用户ID: %s\n", userID)

    // 步骤11：验证过期 Token
    expiredToken, _ := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
        "user_id": "user123",
        "exp":     time.Now().Add(-1 * time.Hour).Unix(),
    }).SignedString(secretKey)
    _, err = parseToken(expiredToken)
    fmt.Printf("过期Token验证: %v\n", err)
}

# 步骤1：逃逸分析 — 查看变量是否逃逸到堆
go build -gcflags="-m" main.go

# 输出示例:
# ./main.go:10:9: &x escapes to heap
# ./main.go:12:13: ... argument does not escape

# 步骤2：更详细的逃逸分析（两个 -m）
go build -gcflags="-m -m" main.go

# 步骤3：禁用优化 — 便于调试（配合 gdb/dlv）
go build -gcflags="-N" main.go

# 步骤4：禁用内联 — 便于断点调试
go build -gcflags="-l" main.go

# 步骤5：组合使用 — 禁用优化和内联
go build -gcflags="-N -l" main.go

# 步骤6：打印汇编 — 查看机器指令
go build -gcflags="-S" main.go

# 步骤7：查看所有可用 flags
go tool compile -help

# 步骤8：对指定包使用 gcflags（不影响依赖）
go build -gcflags="-m" ./myapp/...

# 步骤9：使用 go test 配合 gcflags
go test -gcflags="-m" ./...

package main

import "fmt"

// 步骤1：返回局部变量地址 — 会逃逸到堆
func newInt() *int {
    x := 42
    // 步骤2：返回局部变量地址，x 逃逸到堆
    return &x
}

// 步骤3：interface 参数 — 会逃逸
func printAny(v interface{}) {
    fmt.Println(v)
}

// 步骤4：大切片 — 可能逃逸
func makeSlice() []int {
    // 步骤5：容量足够大时逃逸到堆
    s := make([]int, 1000)
    return s
}

func main() {
    // 步骤6：调用函数
    p := newInt()
    fmt.Println(*p)

    // 步骤7：传入 interface{}
    printAny(42)

    // 步骤8：创建切片
    s := makeSlice()
    fmt.Println(len(s))
}

package main

import "fmt"

// 步骤1：定义单链表节点
type ListNode struct {
    Val  int
    Next *ListNode
}

// 步骤2：链表反转 — 迭代法
func reverseList(head *ListNode) *ListNode {
    var prev *ListNode
    curr := head
    // 步骤3：逐个翻转指针方向
    for curr != nil {
        next := curr.Next
        curr.Next = prev
        prev = curr
        curr = next
    }
    return prev
}

// 步骤4：定义二叉树节点
type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

// 步骤5：前序遍历 — 根-左-右
func preorderTraversal(root *TreeNode) {
    if root == nil {
        return
    }
    fmt.Printf("%d ", root.Val)
    preorderTraversal(root.Left)
    preorderTraversal(root.Right)
}

// 步骤6：中序遍历 — 左-根-右（BST 中序遍历是有序序列）
func inorderTraversal(root *TreeNode) {
    if root == nil {
        return
    }
    inorderTraversal(root.Left)
    fmt.Printf("%d ", root.Val)
    inorderTraversal(root.Right)
}

// 步骤7：后序遍历 — 左-右-根
func postorderTraversal(root *TreeNode) {
    if root == nil {
        return
    }
    postorderTraversal(root.Left)
    postorderTraversal(root.Right)
    fmt.Printf("%d ", root.Val)
}

// 步骤8：LRU 缓存简化实现思路
// 使用双向链表 +哈希表，链表头是最近访问，链表尾是最久未访问
// 访问时移到头部，淘汰时删除尾部

func main() {
    // 步骤9：构建链表 1->2->3->4
    head := &ListNode{Val: 1}
    head.Next = &ListNode{Val: 2}
    head.Next.Next = &ListNode{Val: 3}
    head.Next.Next.Next = &ListNode{Val: 4}

    fmt.Print("反转前: ")
    for p := head; p != nil; p = p.Next {
        fmt.Printf("%d ", p.Val)
    }
    fmt.Println()

    // 步骤10：反转链表
    newHead := reverseList(head)
    fmt.Print("反转后: ")
    for p := newHead; p != nil; p = p.Next {
        fmt.Printf("%d ", p.Val)
    }
    fmt.Println()

    // 步骤11：构建二叉树
    //       1
    //      / \
    //     2   3
    //    / \
    //   4   5
    root := &TreeNode{Val: 1}
    root.Left = &TreeNode{Val: 2, Left: &TreeNode{Val: 4}, Right: &TreeNode{Val: 5}}
    root.Right = &TreeNode{Val: 3}

    fmt.Print("前序遍历: ")
    preorderTraversal(root)
    fmt.Println()

    fmt.Print("中序遍历: ")
    inorderTraversal(root)
    fmt.Println()

    fmt.Print("后序遍历: ")
    postorderTraversal(root)
    fmt.Println()
}

# 步骤1：查看当前 DHCP 租约信息（Linux）
cat /var/lib/dhcp/dhclient.leases

# 步骤2：手动释放并重新获取 IP（Linux）
sudo dhclient -r        # 释放当前 IP
sudo dhclient           # 重新获取 IP

# 步骤3：抓包查看 DHCP 四步交互
sudo tcpdump -i eth0 port 67 or port 68 -n

# 步骤4：macOS 查看 DHCP 租约信息
ipconfig getpacket en0

# 步骤5：macOS 续租 DHCP 租约
sudo ipconfig set en0 BOOTP
sudo ipconfig set en0 DHCP

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "strconv"
    "strings"
)

// 步骤1：定义资源模型
type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

// 步骤2：模拟数据库
var users = map[int]User{
    1: {ID: 1, Name: "Alice"},
    2: {ID: 2, Name: "Bob"},
}
var nextID = 3

// 步骤3：RESTful 路由分发
func userHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    path := strings.TrimPrefix(r.URL.Path, "/users")
    path = strings.Trim(path, "/")

    // 步骤4：无路径参数 — 操作集合
    if path == "" {
        switch r.Method {
        case "GET":
            // 步骤5：查询所有用户
            list := make([]User, 0, len(users))
            for _, u := range users {
                list = append(list, u)
            }
            json.NewEncoder(w).Encode(list)
        case "POST":
            // 步骤6：创建用户
            var u User
            json.NewDecoder(r.Body).Decode(&u)
            u.ID = nextID
            nextID++
            users[u.ID] = u
            w.WriteHeader(http.StatusCreated)
            json.NewEncoder(w).Encode(u)
        default:
            w.WriteHeader(http.StatusMethodNotAllowed)
        }
        return
    }

    // 步骤7：有路径参数 — 操作单个资源
    id, err := strconv.Atoi(path)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        return
    }
    user, exists := users[id]
    if !exists {
        w.WriteHeader(http.StatusNotFound)
        return
    }
    switch r.Method {
    case "GET":
        // 步骤8：查询单个用户
        json.NewEncoder(w).Encode(user)
    case "PUT":
        // 步骤9：更新用户
        var u User
        json.NewDecoder(r.Body).Decode(&u)
        u.ID = id
        users[id] = u
        json.NewEncoder(w).Encode(u)
    case "DELETE":
        // 步骤10：删除用户
        delete(users, id)
        w.WriteHeader(http.StatusNoContent)
    default:
        w.WriteHeader(http.StatusMethodNotAllowed)
    }
}

func main() {
    // 步骤11：注册路由
    http.HandleFunc("/users", userHandler)
    http.HandleFunc("/users/", userHandler)
    fmt.Println("RESTful API server running on :8080")
    http.ListenAndServe(":8080", nil)
}

package main

import (
    "fmt"
    "unicode"
)

// 步骤1：用 iota 给四个朝向自动编号
const (
    Left = iota // 0
    Top         // 1
    Right       // 2
    Bottom      // 3
)

// 步骤2：move 解析指令串，返回最终坐标 (x, y) 与朝向 z
// 支持 数字(重复次数)、括号嵌套、L/R(转向)、F/B(前进/后退)
func move(cmd string, x0, y0, z0 int) (x, y, z int) {
    x, y, z = x0, y0, z0
    repeat := 0
    repeatCmd := ""
    for _, s := range cmd {
        switch {
        case unicode.IsNumber(s):
            // 步骤3：解析重复次数（支持多位数字）
            repeat = repeat*10 + (int(s) - '0')
        case s == ')':
            // 步骤4：遇到 ) 把括号内指令重复执行 repeat 次
            for i := 0; i < repeat; i++ {
                x, y, z = move(repeatCmd, x, y, z)
            }
            repeat = 0
            repeatCmd = ""
        case repeat > 0 && s != '(' && s != ')':
            // 步骤5：括号内容暂存，等 ) 时整体重放
            repeatCmd += string(s)
        case s == 'L':
            z = (z + 1) % 4 // 左转：刻度 +1
        case s == 'R':
            z = (z - 1 + 4) % 4 // 右转：刻度 -1（加 4 防负）
        case s == 'F':
            // 步骤6：前进，按当前朝向更新 x 或 y
            switch {
            case z == Left || z == Right:
                x = x - z + 1
            case z == Top || z == Bottom:
                y = y - z + 2
            }
        case s == 'B':
            // 步骤7：后退，方向与 F 相反
            switch {
            case z == Left || z == Right:
                x = x + z - 1
            case z == Top || z == Bottom:
                y = y + z - 2
            }
        }
    }
    return
}

func main() {
    fmt.Println(move("R2(LF)", 0, 0, Top)) // 解析右转后重复左转+前进
}

package main

import (
    "fmt"
    "reflect"
)

type User struct {
    Name string
    Age  int
}

func main() {
    // 步骤1：创建一个结构体变量
    u := User{Name: "Alice", Age: 30}

    // 步骤2：通过reflect.TypeOf获取类型信息
    t := reflect.TypeOf(u)
    fmt.Println("类型名:", t.Name())   // User
    fmt.Println("种类:", t.Kind())      // struct

    // 步骤3：遍历结构体字段
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        fmt.Printf("字段%d: %s, 类型=%s\n", i, field.Name, field.Type)
    }

    // 步骤4：通过reflect.ValueOf获取值信息
    v := reflect.ValueOf(u)
    fmt.Println("Name字段值:", v.FieldByName("Name").String())
    fmt.Println("Age字段值:", v.FieldByName("Age").Int())
}

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.14

    // 步骤1：reflect.TypeOf接收interface，返回Type
    t := reflect.TypeOf(x)
    // 步骤2：reflect.ValueOf接收interface，返回Value
    v := reflect.ValueOf(x)

    fmt.Println("类型:", t)        // float64
    fmt.Println("值:", v)          // 3.14
    fmt.Println("类型Kind:", t.Kind())  // float64
    fmt.Println("值Kind:", v.Kind())   // float64
}

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.14

    // 步骤1：获取reflect.Value
    v := reflect.ValueOf(x)

    // 步骤2：通过Interface方法转回interface
    y := v.Interface().(float64)

    fmt.Println("还原后的值:", y)   // 3.14
    fmt.Printf("还原后的类型: %T\n", y)  // float64
}

package main

import (
    "fmt"
    "reflect"
)

func main() {
    x := 42

    // 步骤1：传入指针，反射拿到的是指针的Value
    v := reflect.ValueOf(&x)

    // 步骤2：Elem解引用，得到指向x的可寻址Value
    elem := v.Elem()

    // 步骤3：检查是否可寻址
    fmt.Println("可寻址:", elem.CanSet())  // true

    // 步骤4：修改值
    elem.SetInt(100)
    fmt.Println("修改后x =", x)  // 100
}

package main

import (
    "fmt"
    "reflect"
)

func main() {
    x := 42

    // 步骤1：直接传值（发生拷贝）
    v := reflect.ValueOf(x)

    // 步骤2：不可寻址，无法Set
    fmt.Println("可寻址:", v.CanSet())  // false

    // 步骤3：下面这行会panic: reflect: reflect.Value.SetInt using unaddressable value
    // v.SetInt(100)
    _ = v
    fmt.Println("x =", x)
}

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

// 场景1：JSON序列化（encoding/json内部用反射）
type Product struct {
    Name  string `json:"name"`
    Price int    `json:"price"`
}

// 场景2：通用结构体转Map（ORM映射常用）
func structToMap(obj interface{}) map[string]interface{} {
    // 步骤1：获取类型和值
    t := reflect.TypeOf(obj)
    v := reflect.ValueOf(obj)

    // 步骤2：只处理结构体
    if t.Kind() != reflect.Struct {
        return nil
    }

    // 步骤3：遍历字段，提取名和值
    result := make(map[string]interface{})
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        // 步骤4：读取json tag，没有则用字段名
        name := field.Tag.Get("json")
        if name == "" {
            name = field.Name
        }
        result[name] = v.Field(i).Interface()
    }
    return result
}

func main() {
    p := Product{Name: "手机", Price: 4999}

    // 步骤5：JSON序列化（底层反射）
    data, _ := json.Marshal(p)
    fmt.Println("JSON:", string(data))

    // 步骤6：结构体转Map
    m := structToMap(p)
    fmt.Println("Map:", m)
}

package main

import (
    "fmt"
    "reflect"
    "sync"
    "time"
)

type Config struct {
    Host string
    Port int
}

// 直接赋值：最快
func directSet(c *Config) {
    c.Host = "localhost"
    c.Port = 8080
}

// 反射赋值：慢得多
func reflectSet(c *Config, t reflect.Type) {
    v := reflect.ValueOf(c).Elem()
    v.FieldByName("Host").SetString("localhost")
    v.FieldByName("Port").SetInt(8080)
}

func main() {
    const N = 1000000

    // 步骤1：测试直接赋值
    c1 := &Config{}
    start := time.Now()
    for i := 0; i < N; i++ {
        directSet(c1)
    }
    directDuration := time.Since(start)

    // 步骤2：测试反射赋值（带优化：缓存Type）
    c2 := &Config{}
    t := reflect.TypeOf(*c2) // 预先缓存Type，避免重复计算
    start = time.Now()
    for i := 0; i < N; i++ {
        reflectSet(c2, t)
    }
    reflectDuration := time.Since(start)

    fmt.Printf("直接赋值: %v\n", directDuration)
    fmt.Printf("反射赋值: %v\n", reflectDuration)
    fmt.Printf("反射慢 %.1f 倍\n", float64(reflectDuration)/float64(directDuration))
}

package main

import (
    "fmt"
    "sync"
)

// 方式一：共享变量 + mutex
func sharedVariableCounter() int {
    var (
        counter int
        mu      sync.Mutex
        wg      sync.WaitGroup
    )

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            // 步骤1：加锁保护共享变量
            mu.Lock()
            counter++
            mu.Unlock()
        }()
    }
    wg.Wait()
    return counter
}

// 方式二：CSP模型，用channel通信
func cspCounter() int {
    ch := make(chan int, 1000)
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            // 步骤2：通过channel发送数据，无需锁
            ch <- 1
        }()
    }

    // 步骤3：单独的goroutine负责汇总
    go func() {
        wg.Wait()
        close(ch)
    }()

    // 步骤4：主goroutine从channel读取并累加
    counter := 0
    for n := range ch {
        counter += n
    }
    return counter
}

func main() {
    fmt.Println("共享变量计数:", sharedVariableCounter())
    fmt.Println("CSP计数:", cspCounter())
}

package main

import (
    "fmt"
    "time"
)

// 反面教材：通过共享内存通信
type BadCounter struct {
    count int
}

func (c *BadCounter) increment() {
    // 步骤1：直接操作共享变量，没有保护——数据竞争！
    c.count++
}

// Go 风格：通过通信共享内存
func goodCounter() <-chan int {
    // 步骤2：channel作为唯一的数据载体
    ch := make(chan int)

    // 步骤3：一个goroutine独占count，其他人通过channel请求
    go func() {
        count := 0
        for {
            // 步骤4：通过channel接收"操作指令"
            op := <-ch
            if op == 1 {
                count++
            }
            // 步骤5：count只有这个goroutine能碰，无竞争
        }
    }()

    return ch
}

// 更实用的例子：通过channel传递数据所有权
func processData() {
    // 步骤6：生产者goroutine产生数据
    producer := func(out chan<- int) {
        for i := 0; i < 5; i++ {
            // 步骤7：数据放入channel后，所有权转移
            out <- i
        }
        close(out)
    }

    // 步骤8：消费者goroutine接收数据
    consumer := func(in <-chan int) {
        for n := range in {
            // 步骤9：消费者独占数据，无需锁
            fmt.Println("处理:", n)
        }
    }

    ch := make(chan int)
    go producer(ch)
    consumer(ch)
}

func main() {
    processData()
    time.Sleep(time.Millisecond * 100)
}

package main

import "fmt"

// 模拟拉链法解决hash冲突（简化版）
type Bucket struct {
    key   string
    value string
    next  *Bucket
}

type SimpleMap struct {
    buckets []*Bucket
    size    int
}

func NewSimpleMap(size int) *SimpleMap {
    return &SimpleMap{
        buckets: make([]*Bucket, size),
        size:     size,
    }
}

// 简单hash函数
func (m *SimpleMap) hash(key string) int {
    sum := 0
    // 步骤1：累加字符ASCII值
    for _, c := range key {
        sum += int(c)
    }
    // 步骤2：取模得到bucket索引
    return sum % m.size
}

func (m *SimpleMap) Set(key, value string) {
    // 步骤3：计算hash位置
    idx := m.hash(key)
    bucket := m.buckets[idx]

    // 步骤4：检查链表是否已存在该key
    for b := bucket; b != nil; b = b.next {
        if b.key == key {
            b.value = value
            return
        }
    }

    // 步骤5：不存在则头插法添加到链表（拉链法）
    newBucket := &Bucket{key: key, value: value, next: bucket}
    m.buckets[idx] = newBucket
}

func (m *SimpleMap) Get(key string) (string, bool) {
    // 步骤6：计算hash位置
    idx := m.hash(key)
    // 步骤7：遍历链表查找
    for b := m.buckets[idx]; b != nil; b = b.next {
        if b.key == key {
            return b.value, true
        }
    }
    return "", false
}

func main() {
    m := NewSimpleMap(4)
    m.Set("name", "Alice")
    m.Set("eman", "Bob") // 故意制造冲突（字母和相同）
    m.Set("age", "30")

    fmt.Println(m.Get("name"))
    fmt.Println(m.Get("eman"))
    fmt.Println(m.Get("age"))
}

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "strconv"
    "sync"
)

type Item struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

var (
    store   = make(map[int]Item)
    nextID  = 1
    storeMu sync.Mutex
)

func main() {
    // 步骤1：注册路由处理函数
    http.HandleFunc("/items", itemsHandler)
    http.HandleFunc("/items/", itemHandler)

    fmt.Println("服务器启动在 :8080")
    http.ListenAndServe(":8080", nil)
}

// 处理 /items 路径的GET和POST
func itemsHandler(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case http.MethodGet:
        // 步骤2：GET方法——获取所有资源（安全且幂等）
        storeMu.Lock()
        items := make([]Item, 0, len(store))
        for _, item := range store {
            items = append(items, item)
        }
        storeMu.Unlock()
        json.NewEncoder(w).Encode(items)

    case http.MethodPost:
        // 步骤3：POST方法——创建新资源（不幂等，每次调用创建新的）
        var item Item
        if err := json.NewDecoder(r.Body).Decode(&item); err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }
        storeMu.Lock()
        item.ID = nextID
        nextID++
        store[item.ID] = item
        storeMu.Unlock()
        w.WriteHeader(http.StatusCreated)
        json.NewEncoder(w).Encode(item)

    default:
        // 步骤4：不支持的方法返回405
        w.Header().Set("Allow", "GET, POST")
        http.Error(w, "方法不允许", http.StatusMethodNotAllowed)
    }
}

// 处理 /items/{id} 路径的PUT、DELETE、PATCH
func itemHandler(w http.ResponseWriter, r *http.Request) {
    // 步骤5：从URL解析资源ID
    idStr := r.URL.Path[len("/items/"):]
    id, err := strconv.Atoi(idStr)
    if err != nil {
        http.Error(w, "无效ID", http.StatusBadRequest)
        return
    }

    switch r.Method {
    case http.MethodPut:
        // 步骤6：PUT方法——整体更新（幂等，重复执行结果相同）
        var item Item
        if err := json.NewDecoder(r.Body).Decode(&item); err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }
        item.ID = id
        storeMu.Lock()
        store[id] = item // 直接替换，无论是否存在
        storeMu.Unlock()
        json.NewEncoder(w).Encode(item)

    case http.MethodDelete:
        // 步骤7：DELETE方法——删除资源（幂等，删一次和删十次结果一样）
        storeMu.Lock()
        delete(store, id)
        storeMu.Unlock()
        w.WriteHeader(http.StatusNoContent)

    case http.MethodPatch:
        // 步骤8：PATCH方法——部分更新（不幂等，依赖当前状态）
        var patch map[string]interface{}
        if err := json.NewDecoder(r.Body).Decode(&patch); err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }
        storeMu.Lock()
        item, exists := store[id]
        storeMu.Unlock()
        if !exists {
            http.Error(w, "资源不存在", http.StatusNotFound)
            return
        }
        // 步骤9：只更新提供的字段
        if name, ok := patch["name"].(string); ok {
            item.Name = name
        }
        storeMu.Lock()
        store[id] = item
        storeMu.Unlock()
        json.NewEncoder(w).Encode(item)

    default:
        w.Header().Set("Allow", "PUT, DELETE, PATCH")
        http.Error(w, "方法不允许", http.StatusMethodNotAllowed)
    }
}

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

// ---- Model 层：数据 + 业务（这里简化，把持久化也放进来） ----
type User struct {
	ID   int64  `json:"id"`
	Name string `json:"name"`
}

// UserModel 负责数据访问，不碰 HTTP
type UserModel struct{}

func (UserModel) GetByID(id int64) (*User, error) {
	// 步骤1：真实项目里这里查数据库；示例直接返回
	return &User{ID: id, Name: "Alice"}, nil
}

// ---- Controller 层：接收请求、调用 Model、返回响应 ----
type UserController struct {
	model UserModel
}

func (c *UserController) GetUser(ctx *gin.Context) {
	// 步骤2：Controller 解析参数（Gin 已绑定路由参数）
	id := ctx.GetInt64("id")

	// 步骤3：调用 Model 拿数据，Controller 不写业务细节
	u, err := c.model.GetByID(id)
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	// 步骤4：Controller 选择"View"——在前后端分离里就是序列化 JSON
	ctx.JSON(http.StatusOK, u) // Gin 帮你把 u 渲染成 JSON 响应
}

func main() {
	r := gin.Default()
	ctrl := &UserController{model: UserModel{}}

	// 步骤5：路由把请求交给 Controller，Gin 在这里扮演"分发 + 渲染"的角色
	r.GET("/user/:id", ctrl.GetUser)
	r.Run(":8080")
}

x := 42
v := reflect.ValueOf(x)
v.SetInt(100)