GO语言基础：反射

反射是 Go 语言中一个非常强大的特性，它允许程序在运行时检查、修改和操作变量本身的结构。下面我会从基本概念、API 使用和注意事项三个方面，为你详细解释 Go 中的反射。

---

1. 反射的基本概念

反射（reflection） 是指程序在运行时可以访问、检测和修改它自身状态或行为的能力。在 Go 中，反射主要建立在两个核心类型上：

• reflect.Type：表示一个 Go 类型的静态表示。通过它你可以获取类型的名称、种类（kind）、字段、方法等信息。
• reflect.Value：表示一个 Go 值的动态表示。通过它你可以读取、设置值的具体内容，或者调用方法。

简单来说，反射让你在写代码时还不知道变量具体类型的情况下，能够"看穿"它的内部结构。

为什么需要反射？

• 通用处理：当你需要处理任意类型的变量时（比如序列化库、ORM、测试工具），反射可以让你不依赖具体类型。
• 动态调用：根据字符串名称调用方法或访问字段。
• 标签解析 ：解析结构体字段的 tag（比如 JSON、ORM 的标签）。

---

2. 反射 API 的使用

Go 的反射功能由标准库 reflect 提供。下面通过一些常见场景来介绍如何使用它。

获取类型信息（reflect.Type）

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    t := reflect.TypeOf(x)          // 获取 x 的类型
    fmt.Println("type:", t.Name())   // float64
    fmt.Println("kind:", t.Kind())   // float64
    fmt.Println("string:", t.String()) // float64
}

• reflect.TypeOf() 接收一个 interface{} 类型的参数，返回其动态类型的 reflect.Type。
• Kind() 返回底层的基本种类（如 reflect.Float64、reflect.Slice 等），而 Name() 返回类型的具体名称（比如自定义结构体的名字）。

获取值信息（reflect.Value）

func main() {
    var x float64 = 3.4
    v := reflect.ValueOf(x)
    fmt.Println("value:", v.Float()) // 3.4
    fmt.Println("type:", v.Type())   // float64
    fmt.Println("kind:", v.Kind())   // float64
}

• reflect.ValueOf() 返回 reflect.Value，它包含了实际的值。
• 通过 Float()、Int()、String() 等方法可以获取具体类型的值（需要确保底层类型匹配）。

修改值（设置值）

要修改一个值，必须传递可寻址的变量（比如指针），并使用 Elem() 方法获取指针指向的值。

func main() {
    var x float64 = 3.4
    v := reflect.ValueOf(&x)         // 传入指针
    v = v.Elem()                      // 获取指针指向的值
    v.SetFloat(7.1)                    // 修改值
    fmt.Println("x 的新值:", x)       // 7.1
}

• Elem() 用于获取指针或接口指向的实际值。
• SetFloat()、SetInt() 等用于设置值。必须保证可设置（CanSet() 返回 true）。

遍历结构体字段

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    p := Person{Name: "Alice", Age: 30}
    v := reflect.ValueOf(p)
    t := v.Type()

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

• NumField() 返回结构体字段数量。
• Field(i) 返回第 i 个字段的 reflect.Value。
• Type().Field(i) 返回该字段的 reflect.StructField，其中包含字段名、类型、标签等信息。
• Interface() 将 reflect.Value 还原为 interface{}。

调用方法

type MyStruct struct{}

func (m MyStruct) Hello(name string) string {
    return "Hello, " + name
}

func main() {
    m := MyStruct{}
    v := reflect.ValueOf(m)

    method := v.MethodByName("Hello") // 获取方法
    args := []reflect.Value{reflect.ValueOf("World")}
    result := method.Call(args)       // 调用方法
    fmt.Println(result[0].String())   // Hello, World
}

• MethodByName 根据方法名获取方法。
• Call 传入参数切片（每个参数需包装为 reflect.Value），返回结果切片。

---

3. 反射的注意事项

反射虽然强大，但使用不当会带来一些问题和风险。

1. 性能开销

反射涉及动态类型检查、内存分配等操作，比直接调用慢得多。通常比正常代码慢一到两个数量级。因此，在性能敏感的代码中（如高频调用的函数）应避免使用反射。

2. 类型安全降低

反射绕过了编译时的类型检查，许多错误只能在运行时暴露（例如调用不存在的方法、类型断言失败等）。这可能导致程序在运行时崩溃。

v := reflect.ValueOf("hello")
v.SetInt(123) // 运行时 panic: 调用 reflect.Value.SetInt 于 string 值

3. 代码可读性下降

反射代码往往晦涩难懂，增加了维护成本。如果可能，优先考虑使用接口、类型断言或代码生成等替代方案。

4. 不可寻址的值

尝试修改一个不可寻址的值（如通过函数传递的副本）会导致 panic。必须先检查 CanSet()。

5. 对未导出字段的限制

反射可以读取未导出（私有）字段的值，但不能修改它们。如果尝试修改，即使值是可寻址的，也会 panic。

type T struct {
    unexported int
}

t := T{unexported: 10}
v := reflect.ValueOf(&t).Elem()
field := v.FieldByName("unexported")
fmt.Println(field.Int()) // 可以读取
field.SetInt(20)         // panic: reflect.Value.SetInt using value obtained using unexported field

6. 与接口和空接口的交互

• reflect.TypeOf 和 reflect.ValueOf 的参数都是 interface{} 类型，当传入具体值时会发生装箱（分配内存）。
• 从 reflect.Value 还原为 interface{} 使用 Interface() 方法。

7. 慎用反射的场景

• 定义通用库（如序列化、ORM）时，反射是必要的，但要尽量缓存结果（如解析过的类型信息）。
• 业务逻辑中尽量避免反射，优先使用具体类型或接口。

---

4. 简单示例：打印任意变量的信息

func PrintInfo(v interface{}) {
    val := reflect.ValueOf(v)
    typ := val.Type()

    fmt.Printf("类型: %v\n", typ)
    fmt.Printf("种类: %v\n", val.Kind())

    if val.Kind() == reflect.Struct {
        for i := 0; i < val.NumField(); i++ {
            field := val.Field(i)
            fmt.Printf("  字段 %d: %s = %v\n", i, typ.Field(i).Name, field.Interface())
        }
    }
}

---

总结

• 反射 让程序在运行时检视和修改变量，主要基于 reflect.Type 和 reflect.Value。
• 常用操作：获取类型/值、修改值、遍历字段、调用方法、解析标签。
• 注意事项：性能差、类型不安全、代码难懂、对未导出字段限制、需检查可寻址性。
• 反射是 Go 语言提供的强大工具，但应谨慎使用，只在必要时采用。