Go reflect 反射原理示例详解

目录

• 开始之前
• 分析
• 从何处获取类型信息
• 如何实现赋值操作?
• 总结

开始之前

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

反射是什么?以及其作用是什么?

不论在哪种语言中，我们所提到的反射功能，均指开发者可以在运行时通过调用反射库来获取到来获取到指javascript定对象类型信息，通常类型信息中会包含对象的字段/方法等信息。并且，反射库通常会提供方法的调用, 以及字段赋值等功能。

使用反射可以帮助我们避免写大量重复的代码, 因此反射功能常见用于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.www.devze.comgo

以下代码即为将字符串赋值给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
	//此处由编译器做了类型转换 *stri编程客栈ng -> interface{}
	wordPtr := getWordPtr(strPtr)
	t.Logf("String Ptr: %p",  strPtr)
	t.Logf("Word Ptr: %p", wordPtr)
}

输入如下所示:

因此，不难推出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字节的连续内存，具体如下图所示

因此，我们实际上要做的就是获取到结构体的首地址之后，根据各个字段相对首字段的偏移地址计算出其在内存中地址。

实际上在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-rephpflect &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  i开发者_Python教程nt     // 数组长度
	Cap  int     // 数组容量
}
// 字符串头
type StringHeader struct {
	Data uintptr // 字节数组的指针地址
	Len  int     // 字节数组的长度
}

因此，通过反射来操作切片和字符串本质上还是操作结构体。

总结

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

以上就是Go reflect 反射原理示例详解的详细内容，更多关于Go reflect 反射原理的资料请关注我们其它相关文章！