开发者

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)
    }
    

    输入如下所示:

    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-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 反射原理的资料请关注我们其它相关文章!

    0

    上一篇:

    下一篇:

    精彩评论

    暂无评论...
    验证码 换一张
    取 消

    最新开发

    开发排行榜