Go 反射

反射（Reflection）是 Go 语言中一项强大但需要谨慎使用的特性。它允许程序在运行时检查类型信息、操作变量的值和方法。反射是构建灵活框架、序列化库、ORM 等工具的基础，但由于性能开销和类型安全问题，应该谨慎使用。

什么是反射？

反射是程序在运行时检查自身结构的能力。通过反射，你可以：

• 获取变量的类型信息
• 检查结构体的字段和方法
• 动态调用方法
• 修改变量的值（如果可寻址）

Go 的反射机制由 reflect 包提供，核心是两个类型：reflect.Type 和 reflect.Value。

反射三法则

理解 Go 反射的关键是掌握三条基本法则。这三条法则定义了接口值和反射对象之间的关系：

法则一：从接口值可反射出反射对象

第一条法则描述了如何从普通的接口值获取反射对象。通过 reflect.TypeOf 和 reflect.ValueOf 函数，可以从接口值中提取类型信息和值信息：

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.14
    
    // 从接口值获取反射对象
    t := reflect.TypeOf(x)    // 反射类型对象
    v := reflect.ValueOf(x)   // 反射值对象
    
    fmt.Printf("类型: %v\n", t)      // float64
    fmt.Printf("值: %v\n", v)        // 3.14
    fmt.Printf("种类: %v\n", v.Kind()) // float64
}

理解要点：当你调用 reflect.TypeOf(x) 时，x 首先被存储到一个空接口中，然后作为参数传递。反射从该空接口中解包出类型信息。

法则二：从反射对象可反射出接口值

第二条法则描述了反向过程：从反射对象恢复出接口值。使用 Value.Interface() 方法可以将反射值转换回接口值：

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.14
    
    // 接口值 -> 反射对象
    v := reflect.ValueOf(x)
    
    // 反射对象 -> 接口值
    y := v.Interface().(float64)
    
    fmt.Printf("值: %v\n", y)         // 3.14
    fmt.Printf("类型: %T\n", y)        // float64
}

理解要点：反射对象和接口值可以相互转换。Interface() 方法返回一个 interface{} 类型，需要类型断言来获取具体类型的值。

// 使用 fmt.Printf 的 %v 动词可以直接打印反射值
v := reflect.ValueOf(42)
fmt.Printf("值: %v\n", v)  // 42（无需调用 Interface()）

法则三：要修改反射对象，值必须可设置

第三条法则是最微妙也是最容易出错的。只有当反射对象持有的值是"可设置"的，才能修改它：

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.14
    
    // 错误：直接传递值，不可设置
    v := reflect.ValueOf(x)
    fmt.Println("可设置:", v.CanSet())  // false
    // v.SetFloat(7.1)  // panic: reflect: call of reflect.Value.SetFloat on unexported field
    
    // 正确：传递指针，然后使用 Elem 获取指向的值
    p := reflect.ValueOf(&x)
    v = p.Elem()
    fmt.Println("可设置:", v.CanSet())  // true
    v.SetFloat(7.1)  // 成功修改
    fmt.Println("x =", x)  // x = 7.1
}

可设置性的本质：

反射对象是否可设置，取决于它所表示的原始值的"可寻址性"：

// 可设置的情况
var x int
v := reflect.ValueOf(&x).Elem()  // 通过指针获取，可设置

// 不可设置的情况
v := reflect.ValueOf(42)         // 字面量，不可设置
v := reflect.ValueOf(x)          // 值传递，是副本，不可设置

// map 元素不可设置
m := map[string]int{"a": 1}
v := reflect.ValueOf(m).MapIndex(reflect.ValueOf("a"))
v.SetInt(2)  // panic: map 元素不可寻址

为什么需要可设置性？ Go 是值传递语言。当你将值传递给函数时，函数获得的是副本。如果反射允许修改这个副本，那对原始值没有任何影响，这会令人困惑。只有通过指针，反射才能修改原始值。

三法则的完整示例

package main

import (
    "fmt"
    "reflect"
)

func main() {
    type Person struct {
        Name string
        Age  int
    }
    
    p := Person{Name: "张三", Age: 25}
    
    // 法则一：接口值 -> 反射对象
    v := reflect.ValueOf(&p).Elem()
    t := v.Type()
    
    fmt.Println("=== 法则一：获取反射对象 ===")
    fmt.Printf("类型: %v\n", t)
    fmt.Printf("字段数: %d\n", v.NumField())
    
    // 法则二：反射对象 -> 接口值
    fmt.Println("\n=== 法则二：恢复接口值 ===")
    restored := v.Interface().(Person)
    fmt.Printf("恢复的值: %+v\n", restored)
    
    // 法则三：修改可设置的反射对象
    fmt.Println("\n=== 法则三：修改值 ===")
    fmt.Printf("修改前: %+v\n", p)
    fmt.Printf("可设置: %v\n", v.CanSet())
    
    nameField := v.FieldByName("Name")
    if nameField.CanSet() {
        nameField.SetString("李四")
    }
    
    ageField := v.FieldByName("Age")
    if ageField.CanSet() {
        ageField.SetInt(30)
    }
    
    fmt.Printf("修改后: %+v\n", p)
}

反射的基本概念

类型与值

在 Go 中，每个变量都有两个属性：静态类型和动态值。静态类型在编译时确定，动态值在运行时确定。

var x int = 42
// 静态类型: int
// 动态值: 42

反射让你可以在运行时访问这两个属性。

reflect.Type 和 reflect.Value

reflect 包的两个核心类型：

• reflect.Type：表示 Go 语言中的类型，是一个接口类型
• reflect.Value：表示 Go 语言中的值，是一个结构体类型

package main

import (
    "fmt"
    "reflect"
)

func main() {
    x := 42
    
    // 获取 Type
    t := reflect.TypeOf(x)
    fmt.Printf("类型: %v\n", t)        // int
    fmt.Printf("类型名: %v\n", t.Name()) // int
    fmt.Printf("类型种类: %v\n", t.Kind()) // int
    
    // 获取 Value
    v := reflect.ValueOf(x)
    fmt.Printf("值: %v\n", v)          // 42
    fmt.Printf("类型: %v\n", v.Type()) // int
    fmt.Printf("种类: %v\n", v.Kind()) // int
}

Kind 和 Type 的区别

Type 表示完整的类型定义，Kind 表示底层的类型种类：

package main

import (
    "fmt"
    "reflect"
)

type MyInt int

type Person struct {
    Name string
    Age  int
}

func main() {
    var x MyInt = 42
    
    t := reflect.TypeOf(x)
    fmt.Printf("Type: %v\n", t)     // main.MyInt
    fmt.Printf("Kind: %v\n", t.Kind()) // int
    
    p := Person{Name: "张三", Age: 25}
    pt := reflect.TypeOf(p)
    fmt.Printf("Type: %v\n", pt)       // main.Person
    fmt.Printf("Kind: %v\n", pt.Kind()) // struct
}

Kind 的种类

reflect.Kind 是一个枚举类型，表示所有可能的类型种类：

type Kind uint

const (
    Invalid Kind = iota
    Bool
    Int
    Int8
    Int16
    Int32
    Int64
    Uint
    Uint8
    Uint16
    Uint32
    Uint64
    Uintptr
    Float32
    Float64
    Complex64
    Complex128
    Array
    Chan
    Func
    Interface
    Map
    Pointer
    Slice
    String
    Struct
    UnsafePointer
)

reflect.Type 详解

获取类型信息

package main

import (
    "fmt"
    "reflect"
)

func main() {
    type User struct {
        Name string
        Age  int
    }
    
    u := User{Name: "张三", Age: 25}
    t := reflect.TypeOf(u)
    
    // 基本信息
    fmt.Printf("类型名: %s\n", t.Name())     // User
    fmt.Printf("包路径: %s\n", t.PkgPath())  // main
    fmt.Printf("种类: %v\n", t.Kind())       // struct
    fmt.Printf("大小: %d 字节\n", t.Size())  // 结构体大小
    
    // 对于指针类型
    pu := &u
    pt := reflect.TypeOf(pu)
    fmt.Printf("指针种类: %v\n", pt.Kind())    // ptr
    fmt.Printf("指向类型: %v\n", pt.Elem())    // main.User
}

结构体字段

使用反射遍历结构体的字段信息：

package main

import (
    "fmt"
    "reflect"
)

type User struct {
    Name    string `json:"name" validate:"required"`
    Age     int    `json:"age" validate:"min=0,max=150"`
    Email   string `json:"email"`
    address string // 未导出字段
}

func main() {
    u := User{Name: "张三", Age: 25, Email: "[email protected]"}
    t := reflect.TypeOf(u)
    
    // 遍历所有字段
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        fmt.Printf("字段 %d:\n", i)
        fmt.Printf("  名称: %s\n", field.Name)
        fmt.Printf("  类型: %v\n", field.Type)
        fmt.Printf("  标签: %s\n", field.Tag)
        fmt.Printf("  索引: %v\n", field.Index)
        fmt.Printf("  匿名: %v\n", field.Anonymous)
        fmt.Printf("  导出: %v\n", field.PkgPath == "")
        
        // 获取特定标签
        jsonTag := field.Tag.Get("json")
        validateTag := field.Tag.Get("validate")
        fmt.Printf("  JSON标签: %s\n", jsonTag)
        fmt.Printf("  验证标签: %s\n", validateTag)
    }
    
    // 通过名称获取字段
    if field, ok := t.FieldByName("Name"); ok {
        fmt.Printf("\n通过名称获取: %s, 类型: %v\n", field.Name, field.Type)
    }
    
    // 通过索引获取字段
    field := t.FieldByIndex([]int{0})
    fmt.Printf("通过索引获取: %s\n", field.Name)
}

结构体方法

使用反射获取类型的方法信息：

package main

import (
    "fmt"
    "reflect"
)

type User struct {
    Name string
}

func (u User) GetName() string {
    return u.Name
}

func (u *User) SetName(name string) {
    u.Name = name
}

func (u User) Greeting(greet string) string {
    return greet + ", " + u.Name
}

func main() {
    u := User{Name: "张三"}
    t := reflect.TypeOf(u)
    
    // 遍历方法（只能获取导出的方法）
    for i := 0; i < t.NumMethod(); i++ {
        method := t.Method(i)
        fmt.Printf("方法 %d:\n", i)
        fmt.Printf("  名称: %s\n", method.Name)
        fmt.Printf("  类型: %v\n", method.Type)
        fmt.Printf("  包路径: %s\n", method.PkgPath)
    }
    
    // 通过名称获取方法
    if method, ok := t.MethodByName("GetName"); ok {
        fmt.Printf("\nGetName 方法: %v\n", method.Type)
    }
    
    // 指针类型的方法集
    pt := reflect.TypeOf(&u)
    fmt.Printf("\n值类型方法数: %d\n", t.NumMethod())   // 2 (GetName, Greeting)
    fmt.Printf("指针类型方法数: %d\n", pt.NumMethod()) // 3 (GetName, SetName, Greeting)
}

函数类型

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 函数类型
    fn := func(a int, b string) (int, error) {
        return a + len(b), nil
    }
    
    t := reflect.TypeOf(fn)
    
    fmt.Printf("种类: %v\n", t.Kind())          // func
    fmt.Printf("是否可变参数: %v\n", t.IsVariadic()) // false
    fmt.Printf("参数数量: %d\n", t.NumIn())     // 2
    fmt.Printf("返回值数量: %d\n", t.NumOut())  // 2
    
    // 遍历参数类型
    for i := 0; i < t.NumIn(); i++ {
        fmt.Printf("参数 %d: %v\n", i, t.In(i))
    }
    
    // 遍历返回值类型
    for i := 0; i < t.NumOut(); i++ {
        fmt.Printf("返回值 %d: %v\n", i, t.Out(i))
    }
}

reflect.Value 详解

获取和设置值

package main

import (
    "fmt"
    "reflect"
)

func main() {
    x := 42
    
    // 获取 Value（注意：这里传的是值副本）
    v := reflect.ValueOf(x)
    fmt.Printf("值: %v\n", v)
    fmt.Printf("类型: %v\n", v.Type())
    fmt.Printf("种类: %v\n", v.Kind())
    fmt.Printf("能否取地址: %v\n", v.CanAddr())     // false
    fmt.Printf("能否设置: %v\n", v.CanSet())        // false
    
    // 要修改值，必须传入指针
    pv := reflect.ValueOf(&x)
    fmt.Printf("指针种类: %v\n", pv.Kind())         // ptr
    
    // 获取指针指向的值
    elem := pv.Elem()
    fmt.Printf("指向的值: %v\n", elem)
    fmt.Printf("能否取地址: %v\n", elem.CanAddr())  // true
    fmt.Printf("能否设置: %v\n", elem.CanSet())     // true
    
    // 设置新值
    elem.SetInt(100)
    fmt.Printf("修改后的 x: %d\n", x)  // 100
}

基本类型操作

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 整数
    i := 42
    vi := reflect.ValueOf(&i).Elem()
    vi.SetInt(100)
    fmt.Printf("int: %v\n", i)
    
    // 浮点数
    f := 3.14
    vf := reflect.ValueOf(&f).Elem()
    vf.SetFloat(2.718)
    fmt.Printf("float: %v\n", f)
    
    // 字符串
    s := "hello"
    vs := reflect.ValueOf(&s).Elem()
    vs.SetString("world")
    fmt.Printf("string: %v\n", s)
    
    // 布尔值
    b := true
    vb := reflect.ValueOf(&b).Elem()
    vb.SetBool(false)
    fmt.Printf("bool: %v\n", b)
    
    // 使用通用接口
    setAnyValue(&i, int64(200))
    fmt.Printf("setAnyValue 后: %v\n", i)
}

// 通用的设置值函数
func setAnyValue(ptr interface{}, newValue interface{}) {
    v := reflect.ValueOf(ptr).Elem()
    n := reflect.ValueOf(newValue)
    
    // 类型转换后设置
    if n.Type().ConvertibleTo(v.Type()) {
        v.Set(n.Convert(v.Type()))
    }
}

接口值处理

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var i interface{} = "hello"
    
    v := reflect.ValueOf(&i).Elem()
    
    fmt.Printf("Kind: %v\n", v.Kind())        // interface
    fmt.Printf("类型: %v\n", v.Type())         // interface {}
    
    // 获取接口包含的具体值
    elem := v.Elem()
    if elem.IsValid() {
        fmt.Printf("具体类型: %v\n", elem.Type())  // string
        fmt.Printf("具体值: %v\n", elem)          // hello
    }
    
    // 设置接口值为新的值
    v.Set(reflect.ValueOf("world"))
    fmt.Printf("修改后: %v\n", i)  // world
    
    // 设置为 nil
    v.Set(reflect.Zero(v.Type()))
    fmt.Printf("设置为 nil: %v\n", i)  // <nil>
}

切片操作

package main

import (
    "fmt"
    "reflect"
)

func main() {
    s := []int{1, 2, 3, 4, 5}
    v := reflect.ValueOf(&s).Elem()
    
    fmt.Printf("长度: %d\n", v.Len())
    fmt.Printf("容量: %d\n", v.Cap())
    
    // 获取元素
    for i := 0; i < v.Len(); i++ {
        elem := v.Index(i)
        fmt.Printf("s[%d] = %v\n", i, elem.Int())
    }
    
    // 修改元素
    v.Index(0).SetInt(100)
    fmt.Printf("修改后: %v\n", s)
    
    // 切片操作
    slice := v.Slice(1, 3)
    fmt.Printf("slice(1,3): %v\n", slice)  // [2 3]
    
    // 追加元素
    newSlice := reflect.Append(v, reflect.ValueOf(6))
    v.Set(newSlice)
    fmt.Printf("追加后: %v\n", s)
    
    // 创建新切片
    sliceType := reflect.SliceOf(reflect.TypeOf(0))
    newSlice = reflect.MakeSlice(sliceType, 3, 5)
    fmt.Printf("新切片: %v (len=%d, cap=%d)\n", 
        newSlice, newSlice.Len(), newSlice.Cap())
}

映射操作

package main

import (
    "fmt"
    "reflect"
)

func main() {
    m := map[string]int{"a": 1, "b": 2}
    v := reflect.ValueOf(&m).Elem()
    
    // 获取值
    key := reflect.ValueOf("a")
    val := v.MapIndex(key)
    if val.IsValid() {
        fmt.Printf("m[\"a\"] = %v\n", val.Int())
    }
    
    // 设置值
    v.SetMapIndex(reflect.ValueOf("c"), reflect.ValueOf(3))
    fmt.Printf("设置后: %v\n", m)
    
    // 删除值
    v.SetMapIndex(reflect.ValueOf("a"), reflect.Value{})
    fmt.Printf("删除后: %v\n", m)
    
    // 遍历
    iter := v.MapRange()
    for iter.Next() {
        fmt.Printf("  %v: %v\n", iter.Key(), iter.Value())
    }
    
    // 创建新 map
    mapType := reflect.MapOf(reflect.TypeOf(""), reflect.TypeOf(0))
    newMap := reflect.MakeMap(mapType)
    newMap.SetMapIndex(reflect.ValueOf("x"), reflect.ValueOf(1))
    fmt.Printf("新 map: %v\n", newMap)
}

结构体字段操作

package main

import (
    "fmt"
    "reflect"
)

type User struct {
    Name string
    Age  int
}

func main() {
    u := User{Name: "张三", Age: 25}
    v := reflect.ValueOf(&u).Elem()
    
    // 通过名称获取字段
    nameField := v.FieldByName("Name")
    fmt.Printf("Name: %v\n", nameField.String())
    
    // 通过索引获取字段
    ageField := v.Field(1)
    fmt.Printf("Age: %v\n", ageField.Int())
    
    // 修改字段
    nameField.SetString("李四")
    ageField.SetInt(30)
    fmt.Printf("修改后: %+v\n", u)
    
    // 遍历所有字段
    t := v.Type()
    for i := 0; i < v.NumField(); i++ {
        field := t.Field(i)
        value := v.Field(i)
        fmt.Printf("%s: %v\n", field.Name, value.Interface())
    }
}

方法调用

package main

import (
    "fmt"
    "reflect"
)

type Calculator struct{}

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

func (c Calculator) Multiply(a, b int) int {
    return a * b
}

func main() {
    c := Calculator{}
    v := reflect.ValueOf(c)
    
    // 调用 Add 方法
    addMethod := v.MethodByName("Add")
    args := []reflect.Value{
        reflect.ValueOf(10),
        reflect.ValueOf(20),
    }
    results := addMethod.Call(args)
    fmt.Printf("Add(10, 20) = %v\n", results[0].Int())
    
    // 调用 Multiply 方法
    mulMethod := v.MethodByName("Multiply")
    results = mulMethod.Call(args)
    fmt.Printf("Multiply(10, 20) = %v\n", results[0].Int())
    
    // 通用的方法调用
    callMethod(c, "Add", 5, 3)
    callMethod(c, "Multiply", 5, 3)
}

func callMethod(obj interface{}, name string, args ...interface{}) {
    v := reflect.ValueOf(obj)
    method := v.MethodByName(name)
    
    // 准备参数
    values := make([]reflect.Value, len(args))
    for i, arg := range args {
        values[i] = reflect.ValueOf(arg)
    }
    
    // 调用方法
    results := method.Call(values)
    if len(results) > 0 {
        fmt.Printf("%s 结果: %v\n", name, results[0].Interface())
    }
}

反射的实际应用

通用打印函数

package main

import (
    "fmt"
    "reflect"
)

func PrintAny(v interface{}) {
    val := reflect.ValueOf(v)
    
    switch val.Kind() {
    case reflect.Invalid:
        fmt.Println("nil")
    case reflect.Bool:
        fmt.Println(val.Bool())
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        fmt.Println(val.Int())
    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
        fmt.Println(val.Uint())
    case reflect.Float32, reflect.Float64:
        fmt.Println(val.Float())
    case reflect.String:
        fmt.Println(val.String())
    case reflect.Array, reflect.Slice:
        fmt.Printf("[")
        for i := 0; i < val.Len(); i++ {
            if i > 0 {
                fmt.Printf(", ")
            }
            PrintAny(val.Index(i).Interface())
        }
        fmt.Printf("]")
    case reflect.Map:
        fmt.Printf("{")
        iter := val.MapRange()
        first := true
        for iter.Next() {
            if !first {
                fmt.Printf(", ")
            }
            first = false
            PrintAny(iter.Key().Interface())
            fmt.Printf(": ")
            PrintAny(iter.Value().Interface())
        }
        fmt.Printf("}")
    case reflect.Struct:
        fmt.Printf("{")
        t := val.Type()
        for i := 0; i < val.NumField(); i++ {
            if i > 0 {
                fmt.Printf(", ")
            }
            fmt.Printf("%s: ", t.Field(i).Name)
            PrintAny(val.Field(i).Interface())
        }
        fmt.Printf("}")
    case reflect.Ptr:
        if val.IsNil() {
            fmt.Println("nil")
        } else {
            PrintAny(val.Elem().Interface())
        }
    default:
        fmt.Printf("%v", v)
    }
}

func main() {
    PrintAny(42)
    PrintAny("hello")
    PrintAny([]int{1, 2, 3})
    PrintAny(map[string]int{"a": 1, "b": 2})
    
    type Person struct {
        Name string
        Age  int
    }
    PrintAny(Person{Name: "张三", Age: 25})
}

结构体字段复制

package main

import (
    "fmt"
    "reflect"
)

// CopyStruct 将 src 中与 dst 同名同类型的字段复制到 dst
func CopyStruct(dst, src interface{}) error {
    dstValue := reflect.ValueOf(dst).Elem()
    srcValue := reflect.ValueOf(src)
    
    if srcValue.Kind() == reflect.Ptr {
        srcValue = srcValue.Elem()
    }
    
    if dstValue.Kind() != reflect.Struct || srcValue.Kind() != reflect.Struct {
        return fmt.Errorf("参数必须是结构体")
    }
    
    dstType := dstValue.Type()
    
    for i := 0; i < dstType.NumField(); i++ {
        field := dstType.Field(i)
        
        // 查找 src 中同名字段
        srcField := srcValue.FieldByName(field.Name)
        if !srcField.IsValid() {
            continue
        }
        
        // 类型必须匹配
        if srcField.Type() != field.Type {
            continue
        }
        
        // 复制值
        dstField := dstValue.Field(i)
        if dstField.CanSet() {
            dstField.Set(srcField)
        }
    }
    
    return nil
}

type User struct {
    Name  string
    Age   int
    Email string
}

type UserDTO struct {
    Name string
    Age  int
    City string
}

func main() {
    user := User{Name: "张三", Age: 25, Email: "[email protected]"}
    var dto UserDTO
    
    CopyStruct(&dto, user)
    fmt.Printf("DTO: %+v\n", dto)  // {Name:张三 Age:25 City:}
}

验证器实现

package main

import (
    "fmt"
    "reflect"
    "regexp"
    "strconv"
    "strings"
)

// Validate 验证结构体字段
func Validate(s interface{}) []error {
    var errors []error
    v := reflect.ValueOf(s)
    
    if v.Kind() == reflect.Ptr {
        v = v.Elem()
    }
    
    if v.Kind() != reflect.Struct {
        return []error{fmt.Errorf("参数必须是结构体")}
    }
    
    t := v.Type()
    
    for i := 0; i < v.NumField(); i++ {
        field := t.Field(i)
        value := v.Field(i)
        
        // 获取验证标签
        tag := field.Tag.Get("validate")
        if tag == "" {
            continue
        }
        
        // 解析并执行验证规则
        rules := strings.Split(tag, ",")
        for _, rule := range rules {
            if err := validateField(field.Name, value, rule); err != nil {
                errors = append(errors, err)
            }
        }
    }
    
    return errors
}

func validateField(name string, value reflect.Value, rule string) error {
    parts := strings.Split(rule, "=")
    ruleName := parts[0]
    ruleValue := ""
    if len(parts) > 1 {
        ruleValue = parts[1]
    }
    
    switch ruleName {
    case "required":
        if isZero(value) {
            return fmt.Errorf("%s 是必填字段", name)
        }
    case "min":
        min, _ := strconv.Atoi(ruleValue)
        if value.Kind() == reflect.String && len(value.String()) < min {
            return fmt.Errorf("%s 长度不能小于 %d", name, min)
        }
        if isNumeric(value.Kind()) && value.Int() < int64(min) {
            return fmt.Errorf("%s 不能小于 %d", name, min)
        }
    case "max":
        max, _ := strconv.Atoi(ruleValue)
        if value.Kind() == reflect.String && len(value.String()) > max {
            return fmt.Errorf("%s 长度不能大于 %d", name, max)
        }
        if isNumeric(value.Kind()) && value.Int() > int64(max) {
            return fmt.Errorf("%s 不能大于 %d", name, max)
        }
    case "email":
        emailRegex := regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
        if !emailRegex.MatchString(value.String()) {
            return fmt.Errorf("%s 不是有效的邮箱地址", name)
        }
    }
    
    return nil
}

func isZero(v reflect.Value) bool {
    return v.IsZero()
}

func isNumeric(k reflect.Kind) bool {
    return k >= reflect.Int && k <= reflect.Int64
}

type User struct {
    Name  string `validate:"required,min=2,max=20"`
    Email string `validate:"required,email"`
    Age   int    `validate:"min=0,max=150"`
}

func main() {
    // 有效数据
    user1 := User{Name: "张三", Email: "[email protected]", Age: 25}
    if errs := Validate(user1); len(errs) > 0 {
        fmt.Println("验证错误:")
        for _, err := range errs {
            fmt.Printf("  - %v\n", err)
        }
    } else {
        fmt.Println("验证通过")
    }
    
    // 无效数据
    user2 := User{Name: "A", Email: "invalid-email", Age: -1}
    if errs := Validate(user2); len(errs) > 0 {
        fmt.Println("\n验证错误:")
        for _, err := range errs {
            fmt.Printf("  - %v\n", err)
        }
    }
}

深拷贝实现

package main

import (
    "fmt"
    "reflect"
)

// DeepCopy 深拷贝任意值
func DeepCopy(v interface{}) interface{} {
    if v == nil {
        return nil
    }
    
    val := reflect.ValueOf(v)
    
    // 处理指针
    if val.Kind() == reflect.Ptr {
        if val.IsNil() {
            return nil
        }
        val = val.Elem()
    }
    
    switch val.Kind() {
    case reflect.Struct:
        newStruct := reflect.New(val.Type()).Elem()
        for i := 0; i < val.NumField(); i++ {
            field := val.Field(i)
            if field.CanInterface() {
                newField := newStruct.Field(i)
                if newField.CanSet() {
                    copied := DeepCopy(field.Interface())
                    if copied != nil {
                        newField.Set(reflect.ValueOf(copied))
                    }
                }
            }
        }
        return newStruct.Interface()
        
    case reflect.Slice:
        if val.IsNil() {
            return nil
        }
        newSlice := reflect.MakeSlice(val.Type(), val.Len(), val.Cap())
        for i := 0; i < val.Len(); i++ {
            copied := DeepCopy(val.Index(i).Interface())
            if copied != nil {
                newSlice.Index(i).Set(reflect.ValueOf(copied))
            }
        }
        return newSlice.Interface()
        
    case reflect.Map:
        if val.IsNil() {
            return nil
        }
        newMap := reflect.MakeMap(val.Type())
        iter := val.MapRange()
        for iter.Next() {
            keyCopy := DeepCopy(iter.Key().Interface())
            valCopy := DeepCopy(iter.Value().Interface())
            if keyCopy != nil && valCopy != nil {
                newMap.SetMapIndex(reflect.ValueOf(keyCopy), reflect.ValueOf(valCopy))
            }
        }
        return newMap.Interface()
        
    default:
        // 基本类型直接返回
        return v
    }
}

type Person struct {
    Name    string
    Friends []string
}

func main() {
    p1 := Person{
        Name:    "张三",
        Friends: []string{"李四", "王五"},
    }
    
    p2 := DeepCopy(p1).(Person)
    
    // 修改 p2 不影响 p1
    p2.Name = "赵六"
    p2.Friends[0] = "钱七"
    
    fmt.Printf("p1: %+v\n", p1)  // Name:张三, Friends:[李四 王五]
    fmt.Printf("p2: %+v\n", p2)  // Name:赵六, Friends:[钱七 王五]
}

反射的性能考量

性能测试

package main

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

type User struct {
    Name string
    Age  int
}

// 直接访问
func directAccess(u *User, name string, age int) {
    u.Name = name
    u.Age = age
}

// 反射访问
func reflectAccess(u *User, name string, age int) {
    v := reflect.ValueOf(u).Elem()
    v.FieldByName("Name").SetString(name)
    v.Field(1).SetInt(int64(age))
}

func main() {
    u := &User{}
    iterations := 10000000
    
    // 直接访问
    start := time.Now()
    for i := 0; i < iterations; i++ {
        directAccess(u, "张三", 25)
    }
    directTime := time.Since(start)
    
    // 反射访问
    start = time.Now()
    for i := 0; i < iterations; i++ {
        reflectAccess(u, "张三", 25)
    }
    reflectTime := time.Since(start)
    
    fmt.Printf("直接访问: %v\n", directTime)
    fmt.Printf("反射访问: %v\n", reflectTime)
    fmt.Printf("性能差异: %.2f 倍\n", float64(reflectTime)/float64(directTime))
}

性能优化建议

1. 缓存反射结果

package main

import (
    "reflect"
    "sync"
)

// 缓存字段索引
var fieldIndexCache = make(map[reflect.Type]map[string]int)
var fieldIndexMutex sync.RWMutex

func GetFieldIndex(t reflect.Type, name string) (int, bool) {
    fieldIndexMutex.RLock()
    if m, ok := fieldIndexCache[t]; ok {
        idx, found := m[name]
        fieldIndexMutex.RUnlock()
        return idx, found
    }
    fieldIndexMutex.RUnlock()
    
    // 构建缓存
    fieldIndexMutex.Lock()
    defer fieldIndexMutex.Unlock()
    
    m := make(map[string]int)
    for i := 0; i < t.NumField(); i++ {
        m[t.Field(i).Name] = i
    }
    fieldIndexCache[t] = m
    
    idx, found := m[name]
    return idx, found
}

func GetFieldByCache(v reflect.Value, name string) reflect.Value {
    idx, ok := GetFieldIndex(v.Type(), name)
    if !ok {
        panic("field not found")
    }
    return v.Field(idx)
}

2. 避免在热路径使用反射

// 不推荐：在频繁调用的函数中使用反射
func processRequest(req interface{}) {
    v := reflect.ValueOf(req)
    // 反射操作...
}

// 推荐：使用具体类型
func processRequestTyped(req *Request) {
    // 直接访问字段
}

3. 只在必要时使用反射

// 如果类型已知，直接使用
func serializeInt(n int) []byte {
    return []byte(fmt.Sprintf("%d", n))
}

// 只有类型未知时才使用反射
func serialize(v interface{}) []byte {
    val := reflect.ValueOf(v)
    switch val.Kind() {
    case reflect.Int:
        return serializeInt(int(val.Int()))
    // ...
    }
    return nil
}

反射的注意事项

类型安全

反射绕过了编译时类型检查，可能导致运行时 panic：

func main() {
    var x int = 42
    v := reflect.ValueOf(&x).Elem()
    
    // 危险：类型不匹配会导致 panic
    // v.SetString("hello")  // panic: reflect: call of reflect.Value.SetString on int Value
    
    // 安全：先检查类型
    if v.Kind() == reflect.String {
        v.SetString("hello")
    }
}

未导出字段

反射可以读取但不能设置未导出字段：

type User struct {
    name string  // 未导出
    Age  int     // 导出
}

func main() {
    u := User{name: "张三", Age: 25}
    v := reflect.ValueOf(&u).Elem()
    
    // 可以读取
    nameField := v.FieldByName("name")
    fmt.Println(nameField.String())  // 张三
    
    // 不能设置
    fmt.Println(nameField.CanSet())  // false
    // nameField.SetString("李四")  // panic
}

可寻址性

只有可寻址的值才能修改：

func main() {
    // 不可寻址：直接传值
    v1 := reflect.ValueOf(42)
    fmt.Println(v1.CanAddr(), v1.CanSet())  // false false
    
    // 可寻址：传指针后 Elem
    x := 42
    v2 := reflect.ValueOf(&x).Elem()
    fmt.Println(v2.CanAddr(), v2.CanSet())  // true true
    
    // 不可寻址：map 元素
    m := map[string]int{"a": 1}
    v3 := reflect.ValueOf(m).MapIndex(reflect.ValueOf("a"))
    fmt.Println(v3.CanAddr(), v3.CanSet())  // false false
}

反射的适用场景

适合使用反射的场景

1. 框架和库的开发：ORM、序列化库、依赖注入框架
2. 工具函数：通用打印、深拷贝、结构体映射
3. 配置解析：动态解析配置到结构体
4. 测试工具：mock 框架、测试断言
5. 插件系统：动态加载和调用

不适合使用反射的场景

1. 业务逻辑：已知类型时的普通操作
2. 性能敏感代码：高频调用的路径
3. 简单任务：能用普通代码解决的简单问题
4. 团队协作：降低代码可读性和可维护性

小结

本章深入学习了 Go 的反射机制：

1. 基本概念：reflect.Type 和 reflect.Value
2. 类型信息：通过 reflect.TypeOf 获取类型信息
3. 值操作：通过 reflect.ValueOf 获取和修改值
4. 结构体操作：遍历字段和方法
5. 实际应用：验证器、深拷贝、结构体映射
6. 性能考量：反射的性能开销和优化方法
7. 注意事项：类型安全、未导出字段、可寻址性

反射是 Go 语言中强大的特性，但应该谨慎使用。正如 Go 的谚语所说：

"反射是一把双刃剑，强大的同时也带来了复杂性和性能开销。能不用就不用，非用不可时要小心使用。"

练习

1. 实现一个通用的结构体转 map 函数
2. 使用反射实现一个简单的依赖注入容器
3. 编写一个通用的 JSON 序列化器（不使用 encoding/json）
4. 实现一个结构体字段验证器，支持 required、min、max、email 等规则
5. 使用反射实现一个简单的 ORM，支持基本的 CRUD 操作

参考资源

• Go 反射官方文档
• Go 博客 - 反射法则
• Effective Go - 反射