Golang -- Reflect

反射的基本概念

反射(Reflection)是程序在运行时检查自身结构的能力，特别是类型信息，Go语言的反射是通过 reflect包实现，它允许程序操作任意类型的变量。

反射原理详解

1. 类型系统基础

Go的反射建立在类型系统之上，核心是reflect.Type 和 reflect.Value 两个类型：

reflect.Type: 表示Go的类型信息
reflect.Value: 存储运行时的值和类型信息

2. 底层类型结构

在Go运行时中，每个接口变量都由两部分组成：

1
2
3
4


type iface struct {
  tab *itab   // 类型信息
  data unsafe.Pointer // 实际数据指针
}

reflect 包就是通过操作这些底层结构来实现反射的。

3. 反射三大定律

1. 反射可以从接口值到反射对象

1
2
3


var x float64 = 3.4
v := reflect.ValueOf(x) // 接口值 -> 反射对象
fmt.Println(v.Kind()) // float64

2. 反射可以从反射对象到接口值

1
2


y := v.Interface().(float64)
fmt.Println(y)  // 3.4

3. 要修改反射对象，其值必须可设置

1
2
3
4


var x float64 = 3.4
var p = reflect.ValueOf(&x) // 获取指针的value
var v = p.Elem()            // 获取指针指向的值
v.SetFloat(7.2)             // 修改值

反射的核心功能

1. 类型检查和转换

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


func checkType(v any) {
	t := reflect.TypeOf(v) // 获取 v 的类型
	switch t.Kind() {
	case reflect.Float32, reflect.Float64:
		fmt.Println("float")
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		fmt.Println("int")
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		fmt.Println("uint")
	case reflect.String:
		fmt.Println("string")
	case reflect.Bool:
		fmt.Println("bool")
	case reflect.Ptr:
		fmt.Println("ptr")
	case reflect.Struct:
		fmt.Println("struct")
	case reflect.Array:
		fmt.Println("array")
	case reflect.Slice:
		fmt.Println("slice")
	case reflect.Map:
		fmt.Println("map")
	case reflect.Chan:
		fmt.Println("channel")
	case reflect.Func:
		fmt.Println("func")
	case reflect.Interface:
		fmt.Println("interface")

	default:
		fmt.Println("unknown")
	}
}

2. 动态调用方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31



type Person struct {
  name string
}

func(p Person)Print(str string){
  fmt.Printf("%s, %s", str, p.name)
}


func main() {
  var m = Person{
    name: "Mike",
  }

  str := "Hello"

  callMethod(m, "Print", str) // 输出："Hello, Mike" 
}

func callMethod(obj interface{}, methodName string, args ...any) {
	v := reflect.ValueOf(obj)
	method := v.MethodByName(methodName)

	in := make([]reflect.Value, len(args))
	for i, arg := range args {
		in[i] = reflect.ValueOf(arg)
	}

	method.Call(in)
}

3. 结构体操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


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

func main(){
  var user = User{
    Name: "John Doe",
    Age: 42,
  }
}

// inspectStruct 操作结构体
func inspectStruct(u interface{}) {
  t := reflect.TypeOf(u)
  v := reflect.ValueOf(u)

  for i := 0; i < v.NumField(); i ++ {
    // 获取字段类型
    field := t.Field(i)

    // 获取字段值
    value := v.Field(i)
    fmt.Printf("%s = %v\n", field.Name, value.Interface())

    // 获取tag
    tag := field.Tag.Get("json")  
    fmt.Println("JSON tag is:", tag)  
  }
}

反射的高级应用

1. 通用函数包装器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// TimeTrack 通用函数包装
func TimeTrack(fn interface{}, args ...any) (res []any) {
  // 获取 fn 的值
	m := reflect.ValueOf(fn)
  // 判断值类型是否是 func
	if m.Kind() != reflect.Func {
		panic("fn must be a function")
	}

	// 组装参数
	in := make([]reflect.Value, len(args))
	for i, arg := range args {
		in[i] = reflect.ValueOf(arg)
	}

	out := m.Call(in)

  // 组装返回值
	res = make([]any, len(out))
	for i, arg := range out {
		res[i] = arg
	}
	return
}

2. 动态创建对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


func createInstance(t reflect.Type) any {
  
  if t.Kind() == reflect.Ptr {
    // 当前是指针类型
    return reflect.New(t.Elem()).Interface()
  }

  // 非指针类型，返回类型零值
  return reflect.Zero(t).Interface()
}

3. 深拷贝

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


func deepCopy(src interface{}) interface{} {
    if src == nil {
        return nil
    }
    
    srcVal := reflect.ValueOf(src)
    if srcVal.Kind() == reflect.Ptr {
        if srcVal.IsNil() {
            return nil
        }
        srcVal = srcVal.Elem()
    }
    
    dstVal := reflect.New(srcVal.Type()).Elem()
    copyRecursive(srcVal, dstVal)
    
    return dstVal.Interface()
}

func copyRecursive(src, dst reflect.Value) {
    switch src.Kind() {
    case reflect.Ptr:
        if src.IsNil() {
            return
        }
        dst.Set(reflect.New(src.Type().Elem()))
        copyRecursive(src.Elem(), dst.Elem())
    case reflect.Interface:
        if src.IsNil() {
            return
        }
        originalValue := src.Elem()
        copyValue := reflect.New(originalValue.Type()).Elem()
        copyRecursive(originalValue, copyValue)
        dst.Set(copyValue)
    case reflect.Struct:
        for i := 0; i < src.NumField(); i++ {
            copyRecursive(src.Field(i), dst.Field(i))
        }
    case reflect.Slice:
        if src.IsNil() {
            return
        }
        dst.Set(reflect.MakeSlice(src.Type(), src.Len(), src.Cap()))
        for i := 0; i < src.Len(); i++ {
            copyRecursive(src.Index(i), dst.Index(i))
        }
    case reflect.Map:
        if src.IsNil() {
            return
        }
        dst.Set(reflect.MakeMap(src.Type()))
        for _, key := range src.MapKeys() {
            originalValue := src.MapIndex(key)
            copyValue := reflect.New(originalValue.Type()).Elem()
            copyRecursive(originalValue, copyValue)
            dst.SetMapIndex(key, copyValue)
        }
    default:
        dst.Set(src)
    }
}

反射的性能考量

反射虽然强大，但会带来性能开销

反射操作比直接代码慢： 反射方法调用比直接调用慢 50 - 100倍
编译时检查缺失： 反射错误通常在运行时才发现
代码可读性降低： 反射代码通常更难理解

优化建议

缓存反射结果（如 reflect.Type 和 reflect.Method）
避免在热点代码中使用反射
考虑代码生成作为替代方案

实际应用场景

JSON/XML 序列化或反序列化
ORM框架实现
依赖注入容器
RPC框架
测试框架中的断言或mock
配置文件解析
插件系统实现

总结

Go的反射是一个强大的工具，但应该谨慎使用，它最适合以下场景：

需要处理位置类型的通用代码
需要高度灵活性的框架开发
需要运行时类型检查的场景

记住反射的三大定律，并始终考虑是否有更简单，更高效的非反射解决方案，当确定使用反射时，确保封装好反射代码，避免将反射代码复杂性扩散到整个代码库中