1. 反射介绍

回顾一下变量的组成：

  • 类型信息：预先定义好的元信息
  • 值信息：程序运行过程中可动态变化的

一句话介绍： 反射的作用就是把类型元数据暴露给用户使用。

反射是指在程序运行期间对程序本身进行访问和修改的能力。程序在编译时，变量被转换为内存地址，变量名不会被编译器写入到可执行部分。在运行程序时，程序无法获取自身的信息。

支持反射的语言可以在程序编译期间将变量的反射信息，如字段名称、类型信息、结构体信息等整合到可执行文件中，并给程序提供接口访问反射信息，这样就可以在程序运行期间获取类型的反射信息，并且有能力修改它们。

Go 程序在运行期间使用 reflect 包访问程序的反射信息。

在类型断言章节中我们介绍了空接口，空接口可以存储任意类型的变量，那我们如何知道这个空接口保存的数据是什么呢？反射就是在运行时动态的获取一个变量的类型信息和值信息。

反射是把双刃剑

反射是一个强大并富有表现力的工具，能让我们写出更灵活的代码。但是反射不应该被滥用，原因有以下三个：

  1. 基于反射的代码是极其脆弱的，反射中的类型错误会在真正运行的时候才会引发 panic，那很可能是在代码写完的很长时间之后。
  2. 大量使用反射的代码通常难以理解。
  3. 反射的性能低下，基于反射实现的代码通常比正常代码运行速度慢一到两个数量级。

2. Reflect 包

在 Go 语言的反射机制中，任何接口值都由是「一个具体类型」和「具体类型的值」两部分组成的。

在 Go 语言中反射的相关功能由内置的 reflect 包提供，任意接口值在反射中都可以理解为由 reflect.Type 和 reflect.Value 两部分组成，并且 reflect 包提供了 reflect.TypeOf 和 reflect.ValueOf 两个函数来获取任意对象的 Value 和 Type。

2.1 TypeOf

2.1.1 快速了解

在 Go 语言中，使用 reflect.TypeOf() 函数可以获得任意值的类型对象（reflect.Type），程序通过类型对象可以访问任意值的类型信息。

在反射中关于类型还划分为两种：「类型（Type）」和「种类（Kind）」。因为在 Go 语言中我们可以使用 type 关键字构造很多自定义类型，而「种类（Kind）」就是指底层的类型。在反射中，当需要区分指针、结构体等大品种的类型时，就会用到「种类（Kind）」。

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
package main

import (
    "fmt"
    "reflect"
)

func reflectType(x interface{}) {
    v := reflect.TypeOf(x)
    fmt.Printf("type:%v, name:%v, kind:%v\n", v, v.Name(), v.Kind())
}

type Cat struct{}

func main() {
    var a float32 = 3.14
    reflectType(a)    // type:float32, name:float32, kind:float32
    var b int64 = 100
    reflectType(b)    // type:int64, name:int64, kind:int64
    var c Cat
    reflectType(c)    // type:main.Cat, name:Cat, kind:struct
    var d []int
    reflectType(d)    // type:[]int, name:, kind:slice
    var e []string
    reflectType(e)    // type:[]string, name:, kind:slice
}

注意：
Go 语言的反射中像数组、切片、Map、指针等类型的变量，它们的 .Name() 都是返回 空。

2.1.2 原理实现

TypeOf 接收一个空接口类型的参数，并返回一个 reflect.Type 类型的返回值。

1
2
3
4
func TypeOf(i interface{}) Type {
    eface := *(*emptyInterface)(unsafe.Pointer(&i))
    return toType(eface.typ)
}

这个返回值是一个非空接口，它提供了一系列的方法供用户获取类型各方面的信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Type 接口定义了一系列用于描述类型信息的方法
type Type interface {
    Align() int     // 返回类型的对齐边界值，通常用于内存对齐相关的操作
    FieldAlign() int     // 返回类型中字段的对齐边界值，有助于处理结构体中字段的内存布局
    Method(index int) Method     // index：方法在类型中的索引，返回对应索引的方法
    MethodByName(name string) (Method, bool)     // name：要查找的方法名，返回找到的方法以及是否找到该方法的布尔值
    NumMethod() int     // 返回类型所包含的方法数量
    Name() string     // 返回类型的名称
    PkgPath() string     // 返回类型所属包的路径
    Size() uintptr     // 返回类型所占用的字节大小
    String() string     // 返回类型的字符串表示形式，通常用于调试和打印输出
    Kind() Kind     // 返回类型的种类，例如是结构体、接口、指针等
    Implements(u Type) bool     // u：要判断是否实现的接口类型，判断当前类型是否实现了给定的接口类型 u
    AssignableTo(u Type) bool     // u：目标接口类型，判断当前类型的值是否可以赋值给给定的接口类型 u
    ConvertibleTo(u Type) bool     // u：目标接口类型，判断当前类型是否可以转换为给定的接口类型 u
    Comparable() bool     // 判断当前类型的值是否支持比较操作
    // many others......      
}

如果我们在 eggo 包中定义一个 Eggo 类型，然后在 main 包中使用这个类型，并且想通过反射看看这个类型有多少个可导出的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package eggo

type Eggo struct {
    Name string
}

func (e Eggo) A() {
    println("A")
}

func (e Eggo) B() {
    println("B")
}

func main() {
    a := eggo.Eggo{Name: "eggo"}
    t := reflect.TypeOf(a)
    //Eggo 2
    println(t.Name(), t.NumMethod())
}

从函数调用栈来看，main 函数的栈帧中有两个局部变量：Eggo 类型的 a 以及 reflect.Type 类型的 t，然后是返回值空间，最后是参数。

Go 语言中传参都是值拷贝，参数空间这里本来应该拷贝 a 的值过来，但是不能这么做，因为参数是空接口类型，它需要的是一个地址。如果拷贝 a 的地址过来也不行，因为按照传参值拷贝的语义，被调用函数使用的应该是 a 的拷贝。也就是说，无论它对参数做什么样的修改，都不应该作用到原变量 a 的身上。如果我们直接拷贝 a 的地址过来，就不符合这样的语义了。

那该拷贝什么呢？实际上编译阶段会增加一个临时变量作为 a 的拷贝，然后在参数空间这里使用这个临时变量的地址。现在 TypeOf 函数使用的就是 a 的拷贝，这样即符合传参值拷贝的语义，又满足了空接口类型的参数只能接受地址的需求。

所有参数为空接口的情况，都要像这样通过传递拷贝后变量的地址来实现传值的语义。

我们再回到 TypeOf 函数这里，eface := *(*emptyInterface)(unsafe.Pointer(&i)) 会把这个 runtime.eface 类型的参数转化成 reflect.emptyInterface 类型，并赋给变量 eface。

而这两个类型是一致的，转换后方便 reflect 包操作内部元素，因为 *rtpye 类型实现了 Type 接口，所以 TypeOf 函数接下来要做的就是把 eface.typ 包装成 reflect.Type 类型的返回值，到此 TypeOf 的任务就完成了。

1
2
3
4
5
6
7
8
9
type eface struct {
    _type *_type
    data unsafe.Pointer
}

type emptyInterface struct {
    typ *rtype
    word unsafe.Pointer
}

还记得非空接口的结构吗，itab 这里接口类型自然是 reflect.Type，动态类型是 *rtype，data 就等于 eface.typ，也就是反射变量的类型元数据地址，而这里 fun 对应的那些方法也不过是去它指向的类型元数据那里读取各种信息罢了。

我们再回到上面的那个例子，看看返回值究竟长什么样子：一个 reflect.Type 和 *rtype 组合对应的 itab 指针，一个 Eggo 类型元数据的地址。

所以我们通过 reflect.typeOf 拿到的就是这样一个非空接口变量，接下来通过 t 调用这些方法，就会去 Eggo 类型元数据这里查找相关信息。

搞定了反射获取类型信息的方式，接下来我们再来看看通过反射修改变量值是怎么回事。

2.2 ValueOf

方法 说明
Interface() interface {} 将值以 interface{} 类型返回，可以通过类型断言转换为指定类型
Int() int64 将值以 int 类型返回，所有有符号整型均可以此方式返回
Uint() uint64 将值以 uint 类型返回，所有无符号整型均可以此方式返回
Float() float64 将值以双精度（float64）类型返回，所有浮点数（float32、float64）均可以此方式返回
Bool() bool 将值以 bool 类型返回
Bytes() []bytes 将值以字节数组 []bytes 类型返回
String() string 将值以字符串类型返回

2.2.1 通过反射获取值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
func reflectValue(x interface{}) {
    v := reflect.ValueOf(x)
    k := v.Kind()
    switch k {
    case reflect.Int64:
        // v.Int()从反射中获取整型的原始值，然后通过int64()强制类型转换
        fmt.Printf("type is int64, value is %d\n", int64(v.Int()))
    case reflect.Float32:
        // v.Float()从反射中获取浮点型的原始值，然后通过float32()强制类型转换
        fmt.Printf("type is float32, value is %f\n", float32(v.Float()))
}
func main() {
    var a float32 = 3.14
    var b int64 = 100
    reflectValue(a)     // type is float32, value is 3.140000
    reflectValue(b)     // type is int64, value is 100
    // 将int类型的原始值转换为reflect.Value类型
    c := reflect.ValueOf(10)
    fmt.Printf("type c :%T\n", c)     // type c :reflect.Value
}

2.2.2 通过反射设置变量的值

想要在函数中通过反射修改变量的值，需要注意函数参数传递的是值拷贝，必须传递变量地址才能修改变量值。而反射中使用专有的 Elem() 方法来获取指针对应的值。

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
package main

import (
    "fmt"
    "reflect"
)

func reflectSetValue1(x interface{}) {
    v := reflect.ValueOf(x)
    if v.Kind() == reflect.Int64 {
        v.SetInt(200) //修改的是副本，reflect包会引发panic
    }
}
func reflectSetValue2(x interface{}) {
    v := reflect.ValueOf(x)
    // 反射中使用 Elem()方法获取指针对应的值
    if v.Elem().Kind() == reflect.Int64 {
        v.Elem().SetInt(200)
    }
}
func main() {
    var a int64 = 100
    // reflectSetValue1(a) //panic: reflect: reflect.Value.SetInt using unaddressable value
    reflectSetValue2(&a)
    fmt.Println(a)
}

2.2.3 isNil() 和 isValid()

  • isNil()
1
func (v Value) IsNil() bool

IsNil() 报告 v 持有的值是否为 nil。v 持有的值的分类必须是通道、函数、接口、映射、指针、切片之一；否则 IsNil 函数会导致 panic。

  • isValid()
1
func (v Value) IsValid() bool

IsValid() 返回 v 是否持有一个值。如果 v 是 Value 零值会返回假，此时 v 除了 IsValid、String、Kind 之外的方法都会导致 panic。

注意：

IsNil() 常被用于判断指针是否为空；IsValid() 常被用于判定返回值是否有效。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
func main() {
    // *int类型空指针
    var a *int
    fmt.Println("var a *int IsNil:", reflect.ValueOf(a).IsNil())
    
    // nil值
    fmt.Println("nil IsValid:", reflect.ValueOf(nil).IsValid())
    
    // 实例化一个匿名结构体
    b := struct{}{}
    // 尝试从结构体中查找"abc"字段
    fmt.Println("不存在的结构体成员:", reflect.ValueOf(b).FieldByName("abc").IsValid())
    // 尝试从结构体中查找"abc"方法
    fmt.Println("不存在的结构体方法:", reflect.ValueOf(b).MethodByName("abc").IsValid())
    
    // map
    c := map[string]int{}
    // 尝试从map中查找一个不存在的键
    fmt.Println("map中不存在的键：", reflect.ValueOf(c).MapIndex(reflect.ValueOf("娜扎")).IsValid())
}

2.2.4 原理实现

接着再来看看 Value 的具体结构长什么样子，reflect.value 是一个结构体类型。

第一个字段存储反射变量的类型元数据指针，第二个字段存储数据地址。第三个字段是一个未标识符，存储反射值的一些描述信息，例如是否为指针、是否为方法、是否只读等等。

1
2
3
4
5
type Value struct {
    typ *rtype
    ptr unsafe.Pointer
    flag
}

通常会用 reflect.ValueOf 来拿到一个 reflect.value。注意这个函数的参数也是空接口类型，所以和 TypeOf 参数处理方式一样。除此之外，ValueOf 函数会显式地把参数指向的变量逃逸到堆上来。

1
2
3
4
5
6
7
8
func ValueOf(i interface{}) Value {
    if i == nil {
        return vALUE{}
    }
    
    escapes(i)
    return unpackEface(i)
}

看一个例子，这里想通过反射修改一个 string 类型的变量 a。

1
2
3
4
5
6
func main() {
    a := "eggo"
    v := reflect.ValueOf(a)
    v.SetString("new eggo")
    println(a)
}

main 函数栈帧中有一个 string 类型的局部变量 a，还有一个 value 类型的局部变量 v。同 TypeOf 一样的是，编译阶段会增加一个临时变量作为 a 的拷贝。同 TypeOf 不一样的是，这个临时变量会被显示地逃逸到堆上，栈上只留它的地址。

后面是调用 ValueOf 函数的返回值空间以及参数空间。参数这里 data 指向 a 的拷贝，_typ 指向 string 类型元数据。ValueOf 的返回值，这里 typ 就等于参数的第一个字段，ptr 就等于参数的第二个字段。再把 flag 处理好，ValueOf 的任务就完成了，所以局部变量 v 就等于这个返回值。

接下来通过 v 调用 SetString 时，因为 ptr 指向 a 的拷贝而不是 a，而修改这样一个用户都不知道的临时变量没有任何意义，所以会发生 panic，提醒我们这里反射修改变量值是行不通的。

1
panic: reflect: reflect.Value.SetString using unaddressable value

若想修改成功，就要反射 a 的指针，这样 ValueOf 函数的参数指向的变量就是 a。所以 main 函数栈帧中局部变量 a 逃逸到堆上，栈上只留一个地址，然后是局部变量 v、返回值和参数，参数这里 _type 就指向 *string 类型元数据，而 data 指向 a。所以 ValueOf 的返回值就是下面这样的，然后它会赋值给局部变量 v。

接下来调用 v.Elem() 方法，会拿到 v.ptr 指向的变量 a，并把它包装成 reflect.Value 类型的返回值，返回值中类型是 string，地址指向堆上的 a，然后这个返回值被赋给 v。

此时再通过 v 调用 SetString 方法时，方法接收者作为第一个参数，字符串 * 值作为第二个参数，v.ptr 指向 a。

最后 println(a) 语句这里就会输出修改后的值，即 new eggo。

通过反射修改变量值的问题有点绕，不过只要理解传参只拷贝的语义，以及通过反射修改变量值要作用到原变量身上才有意义，理解起来就会相对容易些。

3. 结构体反射

任意值通过 reflect.TypeOf() 获得反射对象信息后，如果它的类型是结构体，可以通过反射值对象（reflect.Type）的 NumField() 和 Field() 方法获得结构体成员的详细信息。

reflect.Type 中与获取结构体成员相关的的方法如下表所示。

方法 说明
Field(i int) StructField 根据索引，返回索引对应的结构体字段的信息。
NumField() int 返回结构体成员字段数量。
FieldByName(name string) (StructField, bool) 根据给定字符串返回字符串对应的结构体字段的信息。
FieldByIndex(index []int) StructField 多层成员访问时，根据 []int 提供的每个结构体的字段索引，返回字段的信息。
FieldByNameFunc(match func(string) bool) (StructField,bool) 根据传入的匹配函数匹配需要的字段。
NumMethod() int 返回该类型的方法集中方法的数目
Method(int) Method 返回该类型方法集中的第 i 个方法
MethodByName(string)(Method, bool) 根据方法名返回该类型方法集中的方法

当我们使用反射得到一个结构体数据之后可以通过索引依次获取其字段信息，也可以通过字段名去获取指定的字段信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
type student struct {
    Name  string `json:"name"`
    Score int    `json:"score"`
}

func main() {
    stu1 := student{
        Name:  "张三",
        Score: 90,
    }

    t := reflect.TypeOf(stu1)
    fmt.Println(t.Name(), t.Kind())  //student struct
    // 通过for循环遍历结构体的所有字段信息
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        fmt.Printf("name:%s，index:%d，type:%v，json tag:%v\n", field.Name, field.Index, field.Type, field.Tag.Get("json"))
    }

    // 通过字段名获取指定结构体字段信息
    if scoreField, ok := t.FieldByName("Score"); ok {
        fmt.Printf("name:%s，index:%d，type:%v，json tag:%v\n", scoreField.Name, scoreField.Index, scoreField.Type, scoreField.Tag.Get("json"))
    }
}

接下来编写一个函数 printMethod(s interface{}) 来遍历打印 s 包含的方法。

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
type student struct {
    Name  string `json:"name"`
    Score int    `json:"score"`
}

// 给student添加两个方法 Study和Sleep(注意首字母大写)
func (s student) Study() string {
    msg := "好好学习，天天向上。"
    fmt.Println(msg)
    return msg
}

func (s student) Sleep() string {
    msg := "好好睡觉，快快长大。"
    fmt.Println(msg)
    return msg
}

func printMethod(x interface{}) {
    t := reflect.TypeOf(x)
    v := reflect.ValueOf(x)

    fmt.Println(t.NumMethod())
    for i := 0; i < v.NumMethod(); i++ {
        methodType := v.Method(i).Type()
        fmt.Printf("method name:%s\n", t.Method(i).Name)
        fmt.Printf("method:%s\n", methodType)
        // 通过反射调用方法传递的参数必须是 []reflect.Value 类型
        var args = []reflect.Value{}
        v.Method(i).Call(args)
    }
}

func main(){
    stu1 := student{
        Name:  "张三",
        Score: 90,
    }
    printMethod(stu1)
}