开端之前

在开端剖析原理之前，有必要问一下自己一个问题:

反射是什么?以及其效果是什么?

不论在哪种言语中，咱们所说到的反射功用，均指开发者能够在运行时经过调用反射库来获取到来获取到指定目标类型信息，一般类型信息中会包括目标的字段/办法等信息。而且，反射库一般会供给办法的调用, 以及字段赋值等功用。

使用反射能够帮助咱们防止写大量重复的代码, 因而反射功用常见用于ORM结构, 以及序列化何反序列化结构，除此之外在Java中反射还被应用到了AOP等功用中。

了解完反射的功用之后，咱们再引申一个问题:

假设你开发了一种言语, 该怎么为开发者供给反射的功用?

首先，咱们知道反射的中心的功用有:

  • 类型信息获取
  • 目标字段拜访/赋值
  • 办法调用

因而实践作为言语的开发者(假设)，咱们要解决的问题有:

  • 怎么存储并获取到目标类型信息?
  • 怎么定位到目标字段的内存地址?

注: 只需知道了目标字段的内存地址配合上类型信息，咱们便能够完成赋值与拜访的操作。

  • 怎么定位到办法的内存地址?

注：代码在内存中也是数据，因而只需要定位到代码地点的地址，便可解决办法调用的问题

剖析

从何处获取类型信息

假如你了解Go的reflect(反射)库, 相信你或多或少的听过反射三原则, 即:

  • 从interface{}能够反射出反射目标
  • 从反射目标中能够获取到interface{}
  • 要修正反射目标, 其值必须可设置

依据以上三原则不难看出interface{}是完成反射功用的基石, 那么这是为什么呢?

要回答这个问题，咱们了解interface{}的本质是什么。

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

在Runtime中使用结构体来表示interface{}, 其结构如下所示:

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

该结构体只要两个字段, 分别是:

  • typ 变量的类型信息, 这一过程在编译过程便可确定下来
  • word 指向变量数据的指针, 这一过程在运行时进行确定

接下来咱们经过反编译下文的代码, 来观察当把一个变量转化成interface{}的时候都发生了什么:

package main
import "fmt"
func main() {
	s := 1024
	var a interface{} = &s
	fmt.Println(a)
}

执行以下指令, 获取汇编代码

go tool compile -N -S .\main.go

以下代码即为将字符串赋值给interface{}类型的变量a的对应汇编代码

0x0057 00087 (.\main.go:7)      MOVQ    "".&s+104(SP), AX
0x005c 00092 (.\main.go:7)      MOVQ    AX, ""..autotmp_9+88(SP)
0x0061 00097 (.\main.go:7)      LEAQ    type.*int(SB), CX
0x0068 00104 (.\main.go:7)      MOVQ    CX, "".a+144(SP)
0x0070 00112 (.\main.go:7)      MOVQ    AX, "".a+152(SP)

相信即便你不了解汇编，但至少也发现了, 以上代码做了如下操作:

  • 获取变量s的地址, 保存到AX寄存器, 并往a+144的地址写入数据
  • 获取变量s的类型信息(type.*int)，保存到CX寄存器, 并往a+152的地址写入数据

注：感兴趣的读者能够把取地址的操作去掉，再看看有什么不同

此外, 咱们还能够经过指针数据类型转化来获取到interface{}中的数据来旁边面验证一下。

注: unsafe.Pointer 能够转化成恣意类型的指针

type EmptyInterface struct {
	typ  unsafe.Pointer
	word unsafe.Pointer
}
func getWordPtr(i interface{})  unsafe.Pointer {
	eface := *(*EmptyInterface)(unsafe.Pointer(&i))
	return eface.word
}
func Test_GetWordPtr(t *testing.T) {
	str := "Hello, KeSan"
	strPtr := &str
	//此处由编译器做了类型转化 *string -> interface{}
	wordPtr := getWordPtr(strPtr)
	t.Logf("String Ptr: %p",  strPtr)
	t.Logf("Word Ptr: %p", wordPtr)
}

输入如下所示:

Go reflect 反射原理

因而，不难推出reflect.TypeOf的完成实践上便是获取interface{}中type信息，并回来给开发人员。其代码如下所示:


func TypeOf(i interface{}) Type {
	eface := *(*emptyInterface)(unsafe.Pointer(&i))
	return toType(eface.typ)
}
// 将 *rtype 转成接口类型的Type
func toType(t *rtype) Type {
	if t == nil {
		return nil
	}
	return t
}

再进一步咱们能够来看看类型信息中都包括了什么?

结构体rtype描绘了根底的类型信息，其字段如下所示:

type rtype struct {
	size       uintptr
	ptrdata    uintptr // number of bytes in the type that can contain pointers
	hash       uint32  // hash of type; avoids computation in hash tables
	tflag      tflag   // extra type information flags
	align      uint8   // alignment of variable with this type
	fieldAlign uint8   // alignment of struct field with this type
	kind       uint8   // enumeration for C
	// function for comparing objects of this type
	// (ptr to object A, ptr to object B) -> ==?
	equal     func(unsafe.Pointer, unsafe.Pointer) bool
	gcdata    *byte   // garbage collection data
	str       nameOff // string form
	ptrToThis typeOff // type for pointer to this type, may be zero
}

rtype结构体包括了Golang中所有数据类型的根底类型信息, 关于不同的数据类型其类型信息会有稍微的差异。

// 结构体的类型信息
type structType struct {
	rtype
	pkgPath name
	fields  []structField // sorted by offset
}
// channel 的类型信息
type chanType struct {
	rtype
	elem *rtype  // channel element type
	dir  uintptr // channel direction (ChanDir)
}

怎么完成赋值操作?

赋值操作的本质上是往对应的内存地址写入数据, 因而咱们有必要简略了解一下结构体在内存中的布局方式, 以一个最为简略坐标的结构体为例，其结构体如下所示:

type Coordinate struct {
    X int64
    Y int64
    Z int64
}

其在内存中的表现为一段巨细为24字节的连续内存，详细如下图所示

Go reflect 反射原理

因而，咱们实践上要做的便是获取到结构体的首地址之后，依据各个字段相对首字段的偏移地址计算出其在内存中地址。

实践上在Runtime供给的类型信息中，已经包括了各个字段的偏移以及类型信息，咱们能够详细的来看一下反射功用获取字段Field的完成。

func (v Value) Field(i int) Value {
	if v.kind() != Struct {
		panic(&ValueError{"reflect.Value.Field", v.kind()})
	}
	// 获取类型信息
	tt := (*structType)(unsafe.Pointer(v.typ))
	if uint(i) >= uint(len(tt.fields)) {
		panic("reflect: Field index out of range")
	}
	// 获取字段信息
	field := &tt.fields[i]
	typ := field.typ
	// 继承结构体的部分flag信息
	fl := v.flag&(flagStickyRO|flagIndir|flagAddr) | flag(typ.Kind())
	if !field.name.isExported() {
		if field.embedded() {
			fl |= flagEmbedRO
		} else {
			fl |= flagStickyRO
		}
	}
	// 依据偏移地址计 + 结构体的首地址 计算出 字段在内存中的地址, 并回来Value目标
	ptr := add(v.ptr, field.offset(), "same as non-reflect &v.field")
	return Value{typ, ptr, fl}
}

了解到怎么获取字段在内存中的地址之后，咱们再来看看赋值操作是怎么完成。

如以下代码SetInt所示, 本质上仍是一些指针的转化以及解引用。

func (v Value) SetInt(x int64) {
	v.mustBeAssignable()
	switch k := v.kind(); k {
	default:
		panic(&ValueError{"reflect.Value.SetInt", v.kind()})
	case Int:
		*(*int)(v.ptr) = int(x)
	case Int8:
		*(*int8)(v.ptr) = int8(x)
	case Int16:
		*(*int16)(v.ptr) = int16(x)
	case Int32:
		*(*int32)(v.ptr) = int32(x)
	case Int64:
		*(*int64)(v.ptr) = x
	}
}

那么，必定有同学会问，为啥你一直都在讲结构体啊，那字符串(string), 切片(slice), map呢?

实践上这些Go的内建的数据类型，在Runtime中的表现形式也是结构体, 咱们能够在reflect包中找到如下界说:

// 切片头
type SliceHeader struct {
	Data uintptr // 数组的指针地址
	Len  int     // 数组长度
	Cap  int     // 数组容量
}
// 字符串头
type StringHeader struct {
	Data uintptr // 字节数组的指针地址
	Len  int     // 字节数组的长度
}

因而，经过反射来操作切片和字符串本质上仍是操作结构体。

总结

  • interface{}是一种数据类型, 其存储了变量的类型信息与数据指针，其间类型信息是在编译期间确定下来的
  • Golang反射的原理便是从interface{}中获取到类型信息以及变量的指针，从而完成类型获取以及赋值的功用