Go语言反射机制详解

基本介绍

• 反射机制：允许程序在运行时检查并操作变量、类型和结构的信息，无需提前知晓具体定义
• 核心功能：动态获取类型信息、创建对象、调用函数、修改对象
• 使用包 ：reflect
• 性能注意：反射依赖运行时类型检查，存在性能开销，性能敏感场景慎用

---

reflect包核心组件

1. reflect.Type

• 作用：表示任意变量的类型信息

• 获取方式 ：reflect.TypeOf(i interface{}) Type

• 常用方法：

  方法名	功能描述	适用类型
  Kind()	获取类型对应的Kind	所有类型
  Elem()	获取容器元素的Type	数组/切片/指针/Map/Chan
  NumField()	获取结构体字段数量	结构体
  Field(i)	获取结构体第i个字段信息	结构体
  NumMethod()	获取绑定方法数量	所有类型
  Method(i)	获取第i个方法信息	所有类型
  NumIn()/In(i)	获取函数参数数量/第i个参数类型	函数
  NumOut()/Out(i)	获取返回值数量/第i个返回值类型	函数

• 字段信息结构体：

  type StructField struct {
      Name     string    // 字段名
      Type     Type      // 字段类型
      Tag      StructTag // 标签信息
      Offset   uintptr   // 字段偏移量
      Anonymous bool     // 是否为匿名字段
  }

2. reflect.Value

• 作用：表示任意变量的值

• 获取方式：

  func ValueOf(i interface{}) Value  // 获取值封装
  func New(typ Type) Value          // 创建新值

• 核心方法：

  方法名	功能描述
  Elem()	解引用指针/接口
  Field(i)	获取结构体第i个字段的值
  Call(in []Value)	调用函数
  Interface()	转换为interface{}类型
  SetXxx()系列	设置值（如SetInt, SetString等）

3. reflect.Kind

• 作用：表示基础类型分类（枚举）

• 常用值 ：

  const (
      Invalid Kind = iota  // 非法类型
      Bool                 // 布尔
      Int, Int8, Int16...  // 整型
      Float32, Float64     // 浮点型
      Array, Slice         // 数组/切片
      Map, Struct          // 映射/结构体
      Func, Ptr            // 函数/指针
      Interface            // 接口
      ...
  )

---

类型转换关系

转换方向	实现方式
具体类型 → interface{}	直接赋值
interface{} → Value	reflect.ValueOf()
Value → interface{}	Value.Interface()
interface{} → 具体类型	类型断言

示例代码：

func Reflect(iVal interface{}) {
    rVal := reflect.ValueOf(iVal)      // interface{} → Value
    iVal2 := rVal.Interface()          // Value → interface{}
    
    switch val := iVal2.(type) {       // interface{} → 具体类型
    case Student:
        fmt.Printf("Type=%T, Value=%v\n", val, val)
    case int:
        fmt.Printf("Type=%T, Value=%v\n", val, val)
    }
}

---

反射应用场景

1. 修改变量值

步骤：

1. 获取指针的Value封装
2. 通过Elem()解引用
3. 使用SetXxx()修改值

示例：

func Reflect(iVal interface{}) {
    rVal := reflect.ValueOf(iVal)
    if rVal.Elem().Kind() == reflect.Int {
        rVal.Elem().SetInt(20) // 修改值为20
    }
}

func main() {
    a := 10
    Reflect(&a) // 必须传指针
    fmt.Println(a) // 输出: 20
}

2. 访问结构体字段

步骤：

1. 获取结构体的Type和Value
2. 循环遍历字段
3. 获取字段信息和值

示例：

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

func Reflect(iVal interface{}) {
    rType := reflect.TypeOf(iVal)
    rVal := reflect.ValueOf(iVal)
    
    for i := 0; i < rType.NumField(); i++ {
        field := rType.Field(i)
        value := rVal.Field(i)
        fmt.Printf("字段名: %s, 标签: %s, 值: %v\n", 
            field.Name, field.Tag.Get("json"), value)
    }
}

// 输出: 字段名: Name, 标签: name, 值: Alice

3. 调用结构体方法

关键点：

• 值类型只能访问receiver为值的方法
• 指针类型可访问值/指针的receiver方法

示例：

func (s Student) GetName() { ... }
func (s *Student) SetAge(age int) { ... }

func Reflect(iVal interface{}) {
    rVal := reflect.ValueOf(iVal)
    rType := reflect.TypeOf(iVal)
    
    // 调用SetAge方法 (需传参)
    method := rVal.MethodByName("SetAge")
    method.Call([]reflect.Value{reflect.ValueOf(20)})
    
    // 调用无参方法
    rVal.Method(0).Call(nil)
}

4. 函数适配器

场景 ：动态调用不同参数的函数
示例：

func Bridge(f interface{}, args ...interface{}) {
    fVal := reflect.ValueOf(f)
    argVals := make([]reflect.Value, len(args))
    
    for i, arg := range args {
        argVals[i] = reflect.ValueOf(arg)
    }
    
    results := fVal.Call(argVals) // 执行函数
    fmt.Println(results[0].Int()) // 处理返回值
}

5. 创建任意类型变量

步骤：

1. 获取目标指针的类型信息
2. 通过reflect.New创建新值
3. 设置指针指向新值

示例：

func CreateObj(ptr interface{}) {
    pVal := reflect.ValueOf(ptr).Elem()  // 获取指针Value
    pType := pVal.Type().Elem()          // 获取指向的类型
    
    newVal := reflect.New(pType)         // 创建新变量
    pVal.Set(newVal)                     // 设置指针指向新值
}

func main() {
    var s *Student
    CreateObj(&s)  // s指向新创建的Student实例
}

---

总结

反射机制为Go提供了强大的动态编程能力，但需注意：

1. 明确操作对象的类型（通过Kind判断）
2. 修改值必须传递指针
3. 方法调用区分值/指针接收者
4. 优先使用标准库而非反射（如JSON序列化用encoding/json）

合理使用反射可增强代码灵活性，但需在性能和可维护性间权衡。