反射

反射

反射来自元编程，指通过类型检查变量本身数据结构的方式，只有部分编程语言支持反射。反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。

Go 语言提供了一种机制在运行时更新变量和检查它们的值、调用它们的方法，但是在编译时并不知道这些变量的具体类型，这称为反射机制。

在什么情况下需要反射

  1. 不能明确接口调用哪个函数，需要根据传入的参数在运行时决定。
  2. 不能明确传入函数的参数类型，需要在运行时处理任意对象。

类型

反射构建在类型系统之上，Go是静态类型语言，每一个变量都有静态类型，在编译时就确定下来了。

比如

1
2
3
4
type MyInt int

var i int
var j MyInt

i和j的底层类型都是int，但i的静态类型是int，j的静态类型是MyInt，这两个是不同类型，是不能直接赋值的，需要类型强制转换。

动态类型

1
2
3
4
5
var A interface{} // 静态类型interface{}
A = 10            // 静态类型为interface{}  动态为int
A = "String"      // 静态类型为interface{}  动态为string
var M *int
A = M             // A的值可以改变

掌握reflect包的以下函数：

  1. reflect.ValueOf({}interface) reflect.Value：获取某个变量的值，但值是通过reflect.Value对象描述的。
  2. reflect.TypeOf({}interface) reflect.Type：获取某个变量的静态类型，但值是通过reflect.Type对象描述的，是可以直接使用Println打印的。
  3. reflect.Value.Kind() Kind：获取变量值的底层类型（类别），注意不是类型，是Int、Float，还是Struct，还是Slice，具体见此。
  4. reflect.Value.Type() reflect.Type：获取变量值的类型，效果等同于reflect.TypeOf。

再解释下Kind和Type的区别

1
2
3
type MyInt int
var x MyInt = 7
v := reflect.ValueOf(x)

v.Kind()得到的是Int，而Type得到是MyInt。

反射原理

反射的意思是在运行时，能够动态知道给定数据对象的类型和结构，并有机会修改它！
现在一个数据对象，如何判断它是什么结构？
数据interface中保存有结构数据，只要想办法拿到该数据对应的内存地址，然后把该数据转成interface，通过查看interface中的类型结构，就可以知道该数据的结构了

反射三原则

  • 从interface{}可以反射出反射对象
    • 将 Go 语言的 interface{} 变量转换成反射对象。执行 reflect.ValueOf(1) 时，由于 reflect.TypeOf、reflect.ValueOf 两个方法的入参都是 interface{} 类型，所以在方法执行的过程中发生了类型转换。使用 reflect.TypeOf 和 reflect.ValueOf 能够获取 Go 语言中的变量对应的反射对象。一旦获取了反射对象，我们就能得到跟当前类型相关数据和操作，并可以使用这些运行时获取的结构执行方法。
  • 从反射对象中可以获取到interface{}
    • 既然能够将接口类型的变量转换成反射对象，那么一定需要其他方法将反射对象还原成接口类型的变量，reflect 中的 reflect.Value.Interface 就能完成这项工作：不是所有的变量都需要类型转换这一过程。如果变量本身就是 interface{} 类型的，那么它不需要类型转换，因为类型转换这一过程一般都是隐式的，所以我不太需要关心它，只有在我们需要将反射对象转换回基本类型时才需要显式的转换操作。
  • 要修改反射对象, 其值必须可设置
    • Go 语言的函数调用都是传值的，所以得到的反射对象跟最开始的变量没有任何关系，那么直接修改反射对象无法改变原始变量，程序为了防止错误就会崩溃。先获取指针对应的 reflect.Value，再通过 reflect.Value.Elem 方法得到可以被设置的变量

interface{}本质上Go提供的一种数据类型, 与其他数据类型不同的是, interface{}会为我们提供变量的类型信息以及变量所在的内存地址。

通过反射修改原对象

  • 原理：
    • 因为给Go的函数、方法传递的都是形参的副本，同样的，反射一个对象时，形参被保存为一个接口对象并作为参数传递（复制），该接口变量是non-settable的，返回的Value也是non-settable的，对它调用Set方法会出现错误；
    • Value的CanSet方法用于测试一个Value的Settablity性质，它有点像unaddressability，但是更加严格，描述的是一个反射对象能够修改创造它的那个实际存储的值的能力。settability由反射对象是否保存原始项而决定。
    • 如果想通过反射来修改对象，必须先把该对象的指针传给reflect.ValueOf(&x)，这样得到的Value对象内部就保存了原对象指针的副本，只有找到该指针指向的值才能修改原始对象，通过Elem()方法就可以获得一个保存了原对象的Value对象，此时的Value对象就是settable的；

对于一个settable的Value反射对象，如 d := reflect.ValueOf(&x).Elem()：

  • d.CanAddr()方法：判断它是否可被取地址
  • d.CanSet()方法：判断它是否可被取地址并可被修改

通过一个settable的Value反射对象来访问、修改其对应的变量的方式：

  • 方式1：通过把反射对象转换回原对象类型的指针，然后直接修改该指针
    • px := d.Addr().Interface().(*int)
    • 第一步是调用Addr()方法，它返回一个Value，里面保存了指向变量的指针。
    • 然后是在Value上调用Interface()方法，也就是返回一个interface{}，里面通用包含指向变量的指针。
    • 最后，如果知道变量的类型，可以使用类型的断言机制将得到的interface{}类型的接口强制环为普通的类型指针。这样就可以通过这个普通指针来更新变量了
  • 方式2：可直接通过Set()方法来修改
    • d.Set(reflect.ValueOf(4))
    • SetInt、SetUint、SetString和SetFloat等方法：d.SetInt(3)，注意：虽然如SetInt()等方法只要参数变量的底层数据类型是有符号整数就可以工作，但不能是一个引用interface{}类型的reflect.Value
  • 小结：Value反射对象为了修改它们所表示的东西必须要有这些东西的地址
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import (
	"fmt"
	"reflect"
)

func main() {

	var x float64 = 3.4
	p := reflect.ValueOf(&x) // 注意这里：把x地址传进去了！
	fmt.Println(p.Type())    //*float64
	fmt.Println(p.CanSet())  //false 这里的p只是指针，仍然是non-settable的
	v := p.Elem()            //此时的v保存了x
	fmt.Println(v.CanSet())  //true
	v.SetFloat(7.1)
	fmt.Println(v.Interface()) //7.1
	fmt.Println(x)             //7.1

}

虽然反射可以越过Go语言的导出规则的限制读取结构体中未导出的成员，但不能修改这些未导出的成员。因为一个struct中只有被导出的字段才是settable的。

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

import (
	"fmt"
	"reflect"
)

func main() {

	type T struct {
		A int
		B string
	}
	t := T{23, "skidoo"}
	s := reflect.ValueOf(&t).Elem()
	typeOfT := s.Type() // 把s.Type()返回的Type对象复制给typeofT，typeofT也是一个反射。
	for i := 0; i < s.NumField(); i++ {
		f := s.Field(i) // 迭代s的各个域，注意每个域仍然是反射。
		fmt.Printf("%d: %s %s = %v\n", i,
			typeOfT.Field(i).Name, f.Type(), f.Interface()) // 提取了每个域的名字
	}
	// 0: A int = 23
	// 1: B string = skidoo

	s.Field(0).SetInt(77) // s.Field(0).Set(reflect.ValueOf(77))
	s.Field(1).SetString("Sunset Strip")
	fmt.Println("t is now", t) // t is now {77 Sunset Strip}

}

如何实现字符串和byte切片的零拷贝

1
2
3
4
5
6
func string2bytes(s string) []byte {
	return *(*[]byte)(unsafe.Pointer(&s))
}
func bytes2string(b []byte) string{
	return *(*string)(unsafe.Pointer(&b))
}

原理上是利用指针的强转

反射慢的原因

  • 发生堆逃逸 （比如ValueOf函数很简单，先将i主动逃逸到堆上，然后将 i 通过unpackEface函数转换成Value。）
    • 逃逸到堆意味着将值拷贝一份到堆上，这也是反射慢的主要原因。
  • 涉及到内存分配以及后续的GC；
  • reflect实现里面有大量的枚举，也就是for循环，比如类型之类的。

建议

  • 可以只使用reflect.TypeOf的话，就不要使用reflect.ValueOf
  • 可以使用断言代替的话，就不要使用反射
  • 如果有可能应当避免使用反射
分享到 评论