深度解密Go语言之反射

原标题:深度解密Go语言之反射

反射和 Interface 息息相关,而 Interface 是我们上一篇文章的内容。在开始正文前,和大家说点题外话。

上一篇关于 Interface 的文章发出后,获得了很多的关注和阅读。比如,登上了 GoCN 的每日新闻第一条:

可能是编辑者觉得这篇文章称不上“深度解密”,把标题给小小地改动了下,哈哈~~

在博客园登上了 48 小时阅读排行榜:

在开发者头条 APP (类似于今日头条,不过内容都是技术相关的,还挺有意思的)上收获了 150 收藏,并被推荐到首页最显眼的 banner 位置,阅读量达到了 1w 多,只是不知道这个数字是否是真实的,有点难以相信。

很多同学在后台向我反映文章太长了,不利于阅读,建议拆分一下。我非常理解,读屏时代,大家需要快速地读完全文,拿到收益。而码农桃花源的文章都非常长,读者很难在短时间内读完,并且获得相应的收益。

首先非常感谢大家的建议!其实我的想法是这样的:大家都在说,现在是一个信息严重过载的时代,信息多得看不完,不免产生很多焦虑。但是,我想说,优质的信息真有那么多吗?在我看来,文章的水平都是参差不齐,很多毫无内容和价值,大家把时间浪费在这些信息上面是很不值得的。因为你读了这些文章,就没有了读其他好的文章的精力。

所以,码农桃花源想做一个优质信息源,提供优质的内容。每一篇文章都是有深度,有内容,有收获。一篇文章,我一般得花费 2 周左右,算是半月更,和那些日更的没法比。当然,只是在数量上没法比。而这个时代,最不缺的就是数量。

另外,文章长也算是我的一个特色。我完全可以拆分成上、中、下等等,但我希望一次性交付给我的读者所有有价值的内容。这样,你可以集中一个小时或是更长时间,精读完一篇文章。

微信公众号阅读文章有时不是太方便,这里推荐大家用微信读书,直接搜索公众号名字就可以看到公众号所有的文章了,很方便。这个功能出来很久了,我也是不久前才知道,推荐给大家。

闲话结束,今天要讲的内容是反射,进入正题。下面是文章的提纲:

什么是反射为什么要用反射反射是如何实现的types 和 interface反射的基本函数反射的三大定律反射相关函数的使用代码样例未导出成员反射的实际应用json 序列化DeepEqual 的作用及原理总结参考资料

直接看维基百科上的定义:

在计算机科学中,反射是指计算机程序在运行时(Run time)可以访问、检测和修改它本身状态或行为的一种能力。用比喻来说,反射就是程序在运行的时候能够“观察”并且修改自己的行为。

在计算机科学中,反射是指计算机程序在运行时(Run time)可以访问、检测和修改它本身状态或行为的一种能力。用比喻来说,反射就是程序在运行的时候能够“观察”并且修改自己的行为。

那我就要问个问题了:不用反射就不能在运行时访问、检测和修改它本身的状态和行为吗?

问题的回答,其实要首先理解什么叫访问、检测和修改它本身状态或行为,它的本质是什么?

实际上,它的本质是程序在运行期探知对象的类型信息和内存结构,不用反射能行吗?可以的!使用汇编语言,直接和内层打交道,什么信息不能获取?但是,当编程迁移到高级语言上来之后,就不行了!就只能通过 反射来达到此项技能。

不同语言的反射模型不尽相同,有些语言还不支持反射。《Go 语言圣经》中是这样定义反射的:

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

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

需要反射的 2 个常见场景:

在讲反射的原理以及如何用之前,还是说几点不使用反射的理由:

上一篇文章讲到了 interface,它是 Go 语言实现抽象的一个非常强大的工具。当向接口变量赋予一个实体类型的时候,接口会存储实体的类型信息,反射就是通过接口的类型信息实现的,反射建立在类型的基础上。

Go 语言在 reflect 包里定义了各种类型,实现了反射的各种函数,通过它们可以在运行时检测类型的信息、改变类型的值。

types 和 interface

Go 语言中,每个变量都有一个静态类型,在编译阶段就确定了的,比如 int,float64,[]int等等。注意,这个类型是声明时候的类型,不是底层数据类型。

Go 官方博客里就举了一个例子:

尽管 i,j 的底层类型都是 int,但我们知道,他们是不同的静态类型,除非进行类型转换,否则,i 和 j 不能同时出现在等号两侧。j 的静态类型就是 MyInt

反射主要与 interface{} 类型相关。前面一篇关于 interface 相关的文章已经探讨过 interface 的底层结构,这里再来复习一下。

其中 itab由具体类型 _type以及 interfacetype组成。 _type表示具体类型,而 interfacetype则表示具体类型实现的接口类型。

实际上,iface 描述的是非空接口,它包含方法;与之相对的是 eface,描述的是空接口,不包含任何方法,Go 语言里有的类型都 “实现了”空接口。

相比 ifaceeface就比较简单了。只维护了一个 _type字段,表示空接口所承载的具体的实体类型。 data描述了具体的值。

还是用 Go 官方关于反射的博客里的例子,当然,我会用图形来详细解释,结合两者来看会更清楚。顺便提一下,搞技术的不要害怕英文资料,要想成为技术专家,读英文原始资料是技术提高的一条必经之路。

先明确一点:接口变量可以存储任何实现了接口定义的所有方法的变量。

Go 语言中最常见的就是 ReaderWriter接口:

接下来,就是接口之间的各种转换和赋值了:

首先声明 r的类型是 io.Reader,注意,这是 r的静态类型,此时它的动态类型为 nil,并且它的动态值也是 nil

之后, r=tty这一语句,将 r的动态类型变成 *os.File,动态值则变成非空,表示打开的文件对象。这时,r 可以用 <value,type>对来表示为: <tty, *os.File>

注意看上图,此时虽然 fun所指向的函数只有一个 Read函数,其实 *os.File还包含 Write函数,也就是说 *os.File其实还实现了 io.Writer接口。因此下面的断言语句可以执行:

之所以用断言,而不能直接赋值,是因为 r的静态类型是 io.Reader,并没有实现 io.Writer接口。断言能否成功,看 r的动态类型是否符合要求。

这样,w 也可以表示成 <tty, *os.File>,仅管它和 w一样,但是 w 可调用的函数取决于它的静态类型 io.Writer,也就是说它只能有这样的调用形式: w.Write()w的内存形式如下图:

w相比,仅仅是 fun对应的函数变了: Read->Write

最后,再来一个赋值:

由于 empty是一个空接口,因此所有的类型都实现了它,w 可以直接赋给它,不需要执行断言操作。

从上面的三张图可以看到,interface 包含三部分信息: _type是类型信息, *data指向实际类型的实际值, itab包含实际类型的信息,包括大小、包路径,还包含绑定在类型上的各种方法(图上没有画出方法),补充一下关于 os.File 结构体的图:

这一节的最后,复习一下上一篇关于 interface 的文章,提到的一个技巧,这里再展示一下:

先参考源码,分别定义一个 “伪装”的 iface 和 eface 结构体。

接着,将接口变量占据的内存内容强制解释成上面定义的类型,再打印出来:

运行结果:

r,w,empty的动态类型和动态值都一样。不再详细解释了,结合前面的图可以看得非常清晰。

反射的基本函数

reflect 包里定义了一个接口和一个结构体,即 reflect.Typereflect.Value,它们提供很多函数来获取存储在接口里的类型信息。

reflect.Type主要提供关于类型相关的信息,所以它和 _type关联比较紧密; reflect.Value则结合 _typedata两者,因此程序员可以获取甚至改变类型的值。

reflect 包中提供了两个基础的关于反射的函数来获取上述的接口和结构体:

TypeOf函数用来提取一个接口中值的类型信息。由于它的输入参数是一个空的 interface{},调用此函数时,实参会先被转化为 interface{}类型。这样,实参的类型信息、方法集、值信息都存储到 interface{}变量里了。

看下源码:

这里的 emptyInterface和上面提到的 eface是一回事(字段名略有差异,字段是相同的),且在不同的源码包:前者在 reflect包,后者在 runtime包。 eface.typ就是动态类型。

至于 toType函数,只是做了一个类型转换:

注意,返回值 Type实际上是一个接口,定义了很多方法,用来获取类型相关的各种信息,而 *rtype实现了 Type接口。

可见 Type定义了非常多的方法,通过它们可以获取类型的一切信息,大家一定要完整的过一遍上面所有的方法。

注意到 Type方法集的倒数第二个方法 common返回的 rtype类型,它和上一篇文章讲到的 _type是一回事,而且源代码里也注释了:两边要保持同步:

所有的类型都会包含 rtype这个字段,表示各种类型的公共信息;另外,不同类型包含自己的一些独特的部分。

比如下面的 arrayTypechanType都包含 rytpe,而前者还包含 slice,len 等和数组相关的信息;后者则包含 dir表示通道方向的信息。

注意到, Type接口实现了 String()函数,满足 fmt.Stringer接口,因此使用 fmt.Println打印的时候,输出的是 String()的结果。另外, fmt.Printf()函数,如果使用 %T来作为格式参数,输出的是 reflect.TypeOf的结果,也就是动态类型。例如:

讲完了 TypeOf函数,再来看一下 ValueOf函数。返回值 reflect.Value表示 interface{}里存储的实际变量,它能提供实际变量的各种信息。相关的方法常常是需要结合类型信息和值信息。例如,如果要提取一个结构体的字段信息,那就需要用到 _type (具体到这里是指 structType) 类型持有的关于结构体的字段信息、偏移信息,以及 *data所指向的内容 —— 结构体的实际值。

源码如下:

从源码看,比较简单:将先将 i转换成 *emptyInterface类型, 再将它的 typ字段和 word字段以及一个标志位字段组装成一个 Value结构体,而这就是 ValueOf函数的返回值,它包含类型结构体指针、真实数据的地址、标志位。

Value 结构体定义了很多方法,通过这些方法可以直接操作 Value 字段 ptr 所指向的实际数据:

Value字段还有很多其他的方法。例如:

不一一列举了,反正是非常多。可以去 src/reflect/value.go去看看源码,搜索 func(vValue)就能看到。

另外,通过 Type()方法和 Interface()方法可以打通 interfaceTypeValue三者。Type() 方法也可以返回变量的类型信息,与 reflect.TypeOf() 函数等价。Interface() 方法可以将 Value 还原成原来的 interface。

这里引用老钱《快学Go语言第十五课——反射》的一张图:

总结一下: TypeOf()函数返回一个接口,这个接口定义了一系列方法,利用这些方法可以获取关于类型的所有信息; ValueOf()函数返回一个结构体变量,包含类型信息以及实际值。

用一张图来串一下:

上图中, rtye实现了 Type接口,是所有类型的公共部分。emptyface 结构体和 eface 其实是一个东西,而 rtype 其实和 _type 是一个东西,只是一些字段稍微有点差别,比如 emptyface 的 word 字段和 eface 的 data 字段名称不同,但是数据型是一样的。

反射的三大定律

根据 Go 官方关于反射的博客,反射有三大定律:

  1. Reflection goes from interface value to reflection object.
  2. Reflection goes from reflection object to interface value.
  3. To modify a reflection object, the value must be settable.

第一条是最基本的:反射是一种检测存储在 interface中的类型和值机制。这可以通过 TypeOf函数和 ValueOf函数得到。

第二条实际上和第一条是相反的机制,它将 ValueOf的返回值通过 Interface()函数反向转变成 interface变量。

前两条就是说 接口型变量反射类型对象可以相互转化,反射类型对象实际上就是指的前面说的 reflect.Typereflect.Value

第三条不太好懂:如果需要操作一个反射变量,那么它必须是可设置的。反射变量可设置的本质是它存储了原变量本身,这样对反射变量的操作,就会反映到原变量本身;反之,如果反射变量不能代表原变量,那么操作了反射变量,不会对原变量产生任何影响,这会给使用者带来疑惑。所以第二种情况在语言层面是不被允许的。

举一个经典例子:

执行上面的代码会产生 panic,原因是反射变量 v不能代表 x本身,为什么?因为调用 reflect.ValueOf(x)这一行代码的时候,传入的参数在函数内部只是一个拷贝,是值传递,所以 v代表的只是 x的一个拷贝,因此对 v进行操作是被禁止的。

可设置是反射变量 Value的一个性质,但不是所有的 Value都是可被设置的。

就像在一般的函数里那样,当我们想改变传入的变量时,使用指针就可以解决了。

输出是这样的:

p还不是代表 xp.Elem()才真正代表 x,这样就可以真正操作 x了:

关于第三条,记住一句话:如果想要操作原变量,反射变量 Value必须要 hold 住原变量的地址才行。

反射相关函数的使用 代码样例

网络上各种博客文章里使用反射的样例代码非常多,读过这篇文章后,基本没有看不懂的,哈哈!不过,我这里还是举一个例子,并讲解一番:

代码运行结果:

代码主要做的事情是:找出传入的参数为 Slice,并且 Slice 的元素为结构体,如果其中有一个字段名是 Name或者是 标签名称为 Name,并且还有一个字段名是 Handsome的情形。如果找到,并且字段名称为 Name的实际值是 qcrao的话,就把另一个字段 Handsome的值置为 true。

程序并不关心传入的结构体到底是什么,只要它的字段名包含 NameHandsome,都是 handsome 函数要工作的对象。

注意一点, Adult结构体的标签 qson:"Name",中间是没有空格的,否则 Tag.Get("qson")识别不出来。

未导出成员

利用反射机制,对于结构体中未导出成员,可以读取,但不能修改其值。

注意,正常情况下,代码是不能读取结构体未导出成员的,但通过反射可以越过这层限制。另外,通过反射,结构体中可以被修改的成员只有是导出成员,也就是字段名的首字母是大写的。

一个可取地址的 reflect.Value 变量会记录一个结构体成员是否是未导出成员,如果是的话则拒绝修改操作。CanAddr 不能说明一个变量是否可以被修改。CanSet 则可以检查对应的 reflect.Value 是否可取地址并可被修改。

一个可取地址的 reflect.Value 变量会记录一个结构体成员是否是未导出成员,如果是的话则拒绝修改操作。CanAddr 不能说明一个变量是否可以被修改。CanSet 则可以检查对应的 reflect.Value 是否可取地址并可被修改。

执行结果:

上面的例子中,handsome 字段未导出,可以读取,但不能调用相关 set 方法,否则会 panic。反射用起来一定要小心,调用类型不匹配的方法,会导致各种 panic。

反射的实际应用

反射的实际应用非常广:IDE 中的代码自动补全功能、对象序列化(json 函数库)、fmt 相关函数的实现、ORM(全称是:Object Relational Mapping,对象关系映射)……

这里举 2 个例子:json 序列化和 DeepEqual 函数。

json 序列化

开发过 web 服务的同学,一定用过 json数据格式。 json是一种独立于语言的数据格式。最早用于浏览器和服务器之间的实时无状态的数据交换,并由此发展起来。

Go 语言中,主要提供 2 个函数用于序列化和反序列化:

两个函数的参数都包含 interface,具体实现的时候,都会用到反射相关的特性。

对于序列化和反序列化函数,均需要知道参数的所有字段,包括字段类型和值,再调用相关的 get 函数或者 set 函数进行实际的操作。

DeepEqual 的作用及原理

在测试函数中,经常会需要这样的函数:判断两个变量的实际内容完全一致。

例如:如何判断两个 slice 所有的元素完全相同;如何判断两个 map 的 key 和 value 完全相同等等。

上述问题,可以通过 DeepEqual函数实现。

DeepEqual函数的参数是两个 interface,实际上也就是可以输入任意类型,输出 true 或者 flase 表示输入的两个变量是否是“深度”相等。

先明白一点,如果是不同的类型,即使是底层类型相同,相应的值也相同,那么两者也不是“深度”相等。

上面的代码中,m, y 底层都是 int,而且值都是 1,但是两者静态类型不同,前者是 MyInt,后者是 YourInt,因此两者不是“深度”相等。

在源码里,有对 DeepEqual 函数的非常清楚地注释,列举了不同类型,DeepEqual 的比较情形,这里做一个总结:

类型 深度相等情形
Array 相同索引处的元素“深度”相等
Struct 相应字段,包含导出和不导出,“深度”相等
Func 只有两者都是 nil 时
Interface 两者存储的具体值“深度”相等
Map 1、都为 nil;2、非空、长度相等,指向同一个 map 实体对象,或者相应的 key 指向的 value “深度”相等
Pointer 1、使用 == 比较的结果相等;2、指向的实体“深度”相等
Slice 1、都为 nil;2、非空、长度相等,首元素指向同一个底层数组的相同元素,即 &x[0] == &y[0] 或者 相同索引处的元素“深度”相等
numbers, bools, strings, and channels 使用 == 比较的结果为真

一般情况下,DeepEqual 的实现只需要递归地调用 == 就可以比较两个变量是否是真的“深度”相等。

但是,有一些异常情况:比如 func 类型是不可比较的类型,只有在两个 func 类型都是 nil 的情况下,才是“深度”相等;float 类型,由于精度的原因,也是不能使用 == 比较的;包含 func 类型或者 float 类型的 struct, interface, array 等。

对于指针而言,当两个值相等的指针就是“深度”相等,因为两者指向的内容是相等的,即使两者指向的是 func 类型或者 float 类型,这种情况下不关心指针所指向的内容。

同样,对于指向相同 slice, map 的两个变量也是“深度”相等的,不关心 slice, map 具体的内容。

对于“有环”的类型,比如循环链表,比较两者是否“深度”相等的过程中,需要对已比较的内容作一个标记,一旦发现两个指针之前比较过,立即停止比较,并判定二者是深度相等的。这样做的原因是,及时停止比较,避免陷入无限循环。

来看源码:

首先查看两者是否有一个是 nil 的情况,这种情况下,只有两者都是 nil,函数才会返回 true。

接着,使用反射,获取x,y 的反射对象,并且立即比较两者的类型,根据前面的内容,这里实际上是动态类型,如果类型不同,直接返回 false。

最后,最核心的内容在子函数 deepValueEqual中。

代码比较长,思路却比较简单清晰:核心是一个 switch 语句,识别输入参数的不同类型,分别递归调用 deepValueEqual 函数,一直递归到最基本的数据类型,比较 int,string 等可以直接得出 true 或者 false,再一层层地返回,最终得到“深度”相等的比较结果。

实际上,各种类型的比较套路比较相似,这里就直接节选一个稍微复杂一点的 map类型的比较:

和前文总结的表格里,比较 map 是否相等的思路比较一致,也不需要多说什么。说明一点, visited是一个 map,记录递归过程中,比较过的“对”:

比较过程中,一旦发现比较的“对”,已经在 map 里出现过的话,直接判定“深度”比较结果的是 true

总结

Go 作为一门静态语言,相比 Python 等动态语言,在编写过程中灵活性会受到一定的限制。但是通过接口加反射实现了类似于动态语言的能力:可以在程序运行时动态地捕获甚至改变类型的信息和值。

Go 语言的反射实现的基础是类型,或者说是 interface,当我们使用反射特性时,实际上用到的就是存储在 interface 变量中的和类型相关的信息,也就是常说的 <type,value>对。

只有 interface 才有反射的说法。

反射在 reflect 包中实现,涉及到两个相关函数:

Type 是一个接口,定义了很多相关方法,用于获取类型信息。Value 则持有类型的具体值。Type、Value、Interface 三者间通过函数 TypeOf,ValueOf,Interface 进行相互转换。

最后温习一下反射三大定律:

  1. Reflection goes from interface value to reflection object.
  2. Reflection goes from reflection object to interface value.
  3. To modify a reflection object, the value must be settable.

翻译一下:

  1. 反射将接口变量转换成反射对象 Type 和 Value;
  2. 反射可以通过反射对象 Value 还原成原先的接口变量;
  3. 反射可以用来修改一个变量的值,前提是这个值可以被修改。

【维基百科中文】https://zh.wikipedia.org/wiki/%E5%8F%8D%E5%B0%84_(%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6)

【码洞老钱 反射】https://juejin.im/post/5c2040d76fb9a049c643d9bd

【Go官方博客 reflection】https://blog.golang.org/laws-of-reflection

【GCTT译文,不错】https://mp.weixin.qq.com/s/dkgJ_fA0smvpv69t5Nv-7A

【json库 源码分析】https://zhuanlan.zhihu.com/p/37165706

【reflect 代码例子和图比较好】https://blog.gopheracademy.com/advent-2018/interfaces-and-reflect/

【反射使用讲得不错】https://juejin.im/post/5a75a4fb5188257a82110544

【接口和反射的关系 ,english】https://blog.gopheracademy.com/advent-2018/interfaces-and-reflect/

【总结成知识点】http://www.cnblogs.com/susufufu/p/7653579.html

【Type Value】https://colobu.com/2016/07/09/dive-into-go-13/

【讲得比较清晰简单】https://www.lijiaocn.com/%E7%BC%96%E7%A8%8B/2017/11/06/golang-reflection.html

【DeepEqual】https://github.com/Chasiny/Blog/blob/master/blog/go/package/go-reflect-deepequal.md

【反射使用场景】https://yq.aliyun.com/articles/599584

5月26日,Go中国社区再次携手滴滴邀请晁岳攀老师于5月26日在北京举办《深入Go 并发编程》培训专场 火热报名中~~

时间:2019年5月26日 9:00-18:00

地址:北京市海淀区中关村软件园一期尚东数字山谷B区2号楼(黎明大厦)返回搜狐,查看更多

责任编辑:

声明:该文观点仅代表作者本人,搜狐号系信息发布平台,搜狐仅提供信息存储空间服务。
阅读 ()
免费获取
今日搜狐热点
今日推荐