Go 反射：reflect 包与类型检查

Go 语言的反射机制允许程序在运行时检查类型信息并操作对象。虽然标准库文档通常将其描述为“强大但复杂”，但掌握核心规则后，反射实际上是一套逻辑严密的工具链，常用于编写通用库（如 JSON 解析、ORM 框架）或处理动态数据结构。

第一阶段：获取反射对象

反射的起点是将普通的 Go 变量转换为反射对象。reflect 包提供了两个核心入口：TypeOf 和 ValueOf。

1. 创建一个名为 main.go 的文件。
2. 导入 fmt 和 reflect 包。
3. 定义一个变量 x 并赋初值，例如 x := 3.14。
4. 调用 reflect.TypeOf(x) 获取变量的类型信息。
5. 调用 reflect.ValueOf(x) 获取变量的值信息。

package main

import (
    "fmt"
    "reflect"
)

func main() {
    x := 3.14
    t := reflect.TypeOf(x)
    v := reflect.ValueOf(x)

    fmt.Println("Type:", t)
    fmt.Println("Value:", v)
}

在此阶段，t 包含类型 float64，v 包含具体的数值 3.14。

第二阶段：区分 Kind 与 Type

Go 反射中存在容易混淆的一对概念：Type（类型）和 Kind（种类）。Type 是变量在源代码中声明的具体类型（如 User、int、[]string），而 Kind 是该类型归类的底层类别（如 struct、int、slice）。

1. 定义一个自定义结构体 User。
2. 实例化 u := User{Name: "Alice"}。
3. 获取 u 的反射类型 t := reflect.TypeOf(u)。
4. 打印 t.Name()，这会返回 User。
5. 打印 t.Kind()，这会返回 struct。

type User struct {
    Name string
}

func main() {
    u := User{Name: "Alice"}
    t := reflect.TypeOf(u)

    fmt.Println("Type Name:", t.Name()) // 输出: User
    fmt.Println("Kind:", t.Kind())      // 输出: struct
}

下表列出了常见的 Kind 常量及其含义：

第三阶段：修改变量值

反射不仅可以读取，还可以修改变量的值，但必须满足“可寻址”条件。这是初学者最容易踩坑的地方：直接传递变量副本是无法修改原值的。

1. 定义一个变量 num := 10。
2. 传递 num 的地址给 reflect.ValueOf，即 v := reflect.ValueOf(&num)。
3. 调用 v.Elem() 解引用，获取指针指向的值对象 elem。
4. 检查 elem.CanSet()，确保其可修改。
5. 调用 elem.SetInt(20) 修改值。

如果省略第 2 步直接传递 num，或者跳过第 3 步直接对 v 调用 SetInt，程序会引发 panic。

func main() {
    num := 10
    v := reflect.ValueOf(&num) // 必须传地址
    elem := v.Elem()           // 获取指针指向的元素

    if elem.CanSet() {
        elem.SetInt(20)
    }
    fmt.Println(num) // 输出: 20
}

下图描述了通过反射修改值的判断流程与步骤：

第四阶段：遍历结构体字段

在处理配置解析或数据库映射时，通常需要遍历结构体的字段。

1. 定义一个包含多个字段的 ServerConfig 结构体。
2. 实例化对象 s := ServerConfig{Host: "localhost", Port: 8080}。
3. 获取类型对象 t := reflect.TypeOf(s)。
4. 判断 t.Kind() 是否为 struct，防止程序在非结构体类型上崩溃。
5. 获取字段数量 n := t.NumField()。
6. 循环从 0 到 n-1。
7. 调用 t.Field(i) 获取每个字段的 reflect.StructField 信息。

type ServerConfig struct {
    Host string `json:"host"`
    Port int    `json:"port"`
}

func main() {
    s := ServerConfig{Host: "localhost", Port: 8080}
    t := reflect.TypeOf(s)

    if t.Kind() == reflect.Struct {
        for i := 0; i < t.NumField(); i++ {
            field := t.Field(i)
            fmt.Printf("字段名: %s, 类型: %v, Tag: %s\n",
                field.Name,
                field.Type,
                field.Tag.Get("json"),
            )
        }
    }
}

第五阶段：处理方法调用

反射可以动态调用结构体的方法，这在编写通用的控制器框架或事件分发器时非常有用。

1. 定义一个带方法的 Calculator 结构体。
2. 绑定方法 Add，接收两个 int 参数并返回 int。
3. 获取 Calculator 实例 c 的值对象 v := reflect.ValueOf(c)。
4. 通过方法名 MethodByName("Add") 获取方法对象 method。
5. 准备参数列表 []reflect.Value{reflect.ValueOf(10), reflect.ValueOf(20)}。
6. 调用 method.Call(args) 执行方法。
7. 处理返回结果数组，其中 results[0].Int() 即为返回值。

type Calculator struct{}

func (c Calculator) Add(a, b int) int {
    return a + b
}

func main() {
    c := Calculator{}
    v := reflect.ValueOf(c)
    method := v.MethodByName("Add")

    if method.IsValid() {
        args := []reflect.Value{
            reflect.ValueOf(10),
            reflect.ValueOf(20),
        }
        results := method.Call(args)
        fmt.Println("结果:", results[0].Int()) // 输出: 30
    }
}

通过以上步骤，你已经掌握了 Go 反射的核心用法：获取类型、区分 Kind、安全地修改值以及动态遍历结构体和调用方法。