golang的反射

大熊的饲养员

已于 2022-07-31 09:51:44 修改

阅读量1.2k

点赞数 2

分类专栏： go的学习文章标签： go 后端 vscode golang

于 2022-04-22 11:41:52 首次发布

本文链接：https://blog.csdn.net/m0_51530927/article/details/124270120

版权

go的学习专栏收录该内容

44 篇文章 3 订阅

订阅专栏

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

有时你需要编写一个函数，但是并不知道传给你的参数类型是什么，可能是没约定好；也可能是传入的类型很多，这些类型并不能统一表示。这时反射就会用的上了。

有时候需要根据某些条件决定调用哪个函数，比如根据用户的输入来决定。这时就需要对函数和函数的参数进行反射，在运行期间动态地执行函数。

但是对于反射，还是有几点不太建议使用反射的理由：

与反射相关的代码，经常是难以阅读的。在软件工程中，代码可读性也是一个非常重要的指标。

Go 语言作为一门静态语言，编码过程中，编译器能提前发现一些类型错误，但是对于反射代码是无能为力的。所以包含反射相关的代码，很可能会运行很久，才会出错，这时候经常是直接 panic，可能会造成严重的后果。

反射对性能影响还是比较大的，比正常代码运行速度慢一到两个数量级。所以，对于一个项目中处于运行效率关键位置的代码，尽量避免使用反射特性。

一、变量的内置pair结构详解

所谓反射主要就是通过变量找到pair对（type和value），其中type包括static type和concrete type。看一下代码吧~

package main

import "fmt"

type Reader interface {
	ReadBook()
}
type Writer interface {
	WritBook()
}

//具体类型
type Book struct {
}

func (this *Book) ReadBook() {
	fmt.Println("Read a Book")
}
func (this *Book) WritBook() {
	fmt.Println("Writer a book")
}
func main() {
	//b:pair<type:Book,value:book{}地址>
	b := Book{}
	//c:pair<type:,value:>
	var c Reader
	//c:pair<type:Book,value:book{}地址>
	c = &b
	c.ReadBook() //显然c变成了Book类型
	var w Reader
	w = c //此处的断言成功，因为w c具体的type是一致的
	w.ReadBook()

}

二、reflect包

先看个导图吧，reflect包包含了两种方法valueof和typeof。其中valueof用来获取输入参数接口中的数据的值，如果接口为空则返回0；typeof用来动态获取输入参数接口中的值的类型，如果接口为空则返回nil。

好了我们来用代码演示一下吧~

package main

import (
	"fmt"
	"reflect"
)

type User struct {
	ID   int
	Name string //注意要大写否则会报错reflect.Value.Interface: cannot return value obtained from unexporte.
	Age  int
}

func DofiledAndMethod(input interface{}) {
	//获取input的type
	inputType := reflect.TypeOf(input)
	fmt.Println(inputType.Name())
	//获取input的value
	inputValue := reflect.ValueOf(input)
	fmt.Println(inputValue)
	//获取每一个字段type和value
	//1，获取interface的reflect.Type，通过Type获取NumField，进行遍历
	//2.得到每个field的数据类型
	//3.通过field有一个Interface（）方法得到对应的value
	for i := 0; i < inputType.NumField(); i++ {
		field := inputType.Field(i)
		value := inputValue.Field(i).Interface()
		fmt.Printf("%s:%v=%v\n", field.Name, field.Type, value)
	}
	//获取里面的方法
	for i := 0; i < inputType.NumMethod(); i++ {
		method := inputType.Method(i)
		fmt.Printf("%s:%v\n", method.Name, method.Type)
	}
}
func main() {
	user := User{1, "yjy", 12}
	DofiledAndMethod(user)
}

要注意struct中的属性首字母命名要大写！否则会出现reflect.Value.Interface: cannot return value obtained from unexporte.错误

三、反射解析结构体标签

先看一段代码

package main

import (
	"fmt"
	"reflect"
)

type User struct {
	Name string `info:"name" doc:"我的名字"` //注意这里的单引号不要用回车旁边的，否则会报错的，
	//用数字1旁边的，虽然我笔记本没有，，，我就在网上复制了一下单引号
	Sex string `info:"sex"`
}

func findTag(str *User) {//要注意这里不要写interface{}
	t := reflect.TypeOf(str).Elem()
	for i := 0; i < t.NumField(); i++ {
		taginfo := t.Field(i).Tag.Get("info")
		tagdoc := t.Field(i).Tag.Get("doc")
		fmt.Println("info=", taginfo, "doc=", tagdoc)
	}
}

func main() {
	var user User
	findTag(&user)
}

这里我想说的是标签的单引号不要用回车旁边的单引号，会报错，要用1旁边的单引号，由于我的笔记本在1处附近根本没有单引号，于是乎，我就粘贴了一下别人的单引号。

接下来第二个要注意的点是：在findTag函数的参数里不要给interface{}类型，因为vscode版本高会出现恐慌，而引起报错，这个恐慌具体原因，想要了解的小伙伴请看下边的链接吧~

https://blog.csdn.net/m0_51530927/article/details/124341655

四、反射的使用

1. 从relfect.Value中获取接口interface的信息

当执行reflect.ValueOf(interface)之后，就得到了一个类型为”relfect.Value”变量，可以通过它本身的Interface()方法获得接口变量的真实内容，然后可以通过类型判断进行转换，转换为原有真实类型。不过，我们可能是已知原有类型，也有可能是未知原有类型，因此，下面分两种情况进行说明。

已知原有类型：

已知类型后转换为其对应的类型的做法如下，直接通过Interface方法然后强制转换，如下：

realValue := value.Interface().(已知的类型)

说明

转换的时候，如果转换的类型不完全符合，则直接panic，类型要求非常严格！
转换的时候，要区分是指针还是指
也就是说反射可以将“反射类型对象”再重新转换为“接口类型变量”

未知原有类型：

很多情况下，我们可能并不知道其具体类型，那么这个时候，该如何做呢？需要我们进行遍历探测其Filed来得知，示例如下:

获取方法字段：
1. 先获取interface的reflect.Type，然后通过NumField进行遍历
2. 再通过reflect.Type的Field获取其Field
3. 最后通过Field的Interface()得到对应的value

通过反射，获取操作方法：
1. 先获取interface的reflect.Type，然后通过.NumMethod进行遍历
2. 再公国reflect.Type的Method获取其Method

package main

import (
	"fmt"
	"reflect"
)
type Person struct {
	Name string
	Age int
	Sex string
}
func (p Person)Say(msg string)  {
	fmt.Println("hello，",msg)
}
func (p Person)PrintInfo()  {
	fmt.Printf("姓名：%s,年龄：%d，性别：%s\n",p.Name,p.Age,p.Sex)
}
func main() {
	p1 := Person{"王二狗",30,"男"}
	DoFiledAndMethod(p1)
}
// 通过接口来获取任意参数
func DoFiledAndMethod(input interface{}) {
	getType := reflect.TypeOf(input) //先获取input的类型
	fmt.Println("get Type is :", getType.Name()) // Person
	fmt.Println("get Kind is : ", getType.Kind()) // struct
	getValue := reflect.ValueOf(input)
	fmt.Println("get all Fields is:", getValue) //{王二狗 30 男}
	// 获取方法字段
	// 1. 先获取interface的reflect.Type，然后通过NumField进行遍历
	// 2. 再通过reflect.Type的Field获取其Field
	// 3. 最后通过Field的Interface()得到对应的value
	for i := 0; i < getType.NumField(); i++ {
		field := getType.Field(i)
		value := getValue.Field(i).Interface() //获取第i个值
		fmt.Printf("字段名称:%s, 字段类型:%s, 字段数值:%v \n", field.Name, field.Type, value)
	}
	// 通过反射，操作方法
	// 1. 先获取interface的reflect.Type，然后通过.NumMethod进行遍历
	// 2. 再公国reflect.Type的Method获取其Method
	for i := 0; i < getType.NumMethod(); i++ {
		method := getType.Method(i)
		fmt.Printf("方法名称:%s, 方法类型:%v \n", method.Name, method.Type)
	}
}

运行结果：

get Type is : Person
get Kind is :  struct
get all Fields is: {王二狗 30 男}
字段名称:Name, 字段类型:string, 字段数值:王二狗 
字段名称:Age, 字段类型:int, 字段数值:30 
字段名称:Sex, 字段类型:string, 字段数值:男 
方法名称:PrintInfo, 方法类型:func(main.Person) 
方法名称:Say, 方法类型:func(main.Person, string)

说明

通过运行结果可以得知获取未知类型的interface的具体变量及其类型的步骤为：

先获取interface的reflect.Type，然后通过NumField进行遍历
再通过reflect.Type的Field获取其Field
最后通过Field的Interface()得到对应的value

通过运行结果可以得知获取未知类型的interface的所属方法（函数）的步骤为：

先获取interface的reflect.Type，然后通过NumMethod进行遍历
再分别通过reflect.Type的Method获取对应的真实的方法（函数）
最后对结果取其Name和Type得知具体的方法名
也就是说反射可以将“反射类型对象”再重新转换为“接口类型变量”
struct 或者 struct 的嵌套都是一样的判断处理方式

如果是struct的话，可以使用Elem()

tag := t.Elem().Field(0).Tag //获取定义在struct里面的Tag属性
name := v.Elem().Field(0).String() //获取存储在第一个字段里面的值

2. 通过reflect.Value设置实际变量的值

reflect.Value是通过reflect.ValueOf(X)获得的，只有当X是指针的时候，才可以通过reflec.Value修改实际变量X的值，即：要修改反射类型的对象就一定要保证其值是“addressable”的。

这里需要一个方法：

func (v Value) Elem() Value

解释起来就是：Elem返回接口v包含的值或指针v指向的值。如果v的类型不是interface或ptr，它会恐慌。如果v为零，则返回零值。

package main

import (
	"fmt"
	"reflect"
)

func main() {

	var num float64 = 1.2345
	fmt.Println("old value of pointer:", num)

	// 通过reflect.ValueOf获取num中的reflect.Value，注意，参数必须是指针才能修改其值
	pointer := reflect.ValueOf(&num)
	newValue := pointer.Elem()

	fmt.Println("type of pointer:", newValue.Type())
	fmt.Println("settability of pointer:", newValue.CanSet())

	// 重新赋值
	newValue.SetFloat(77)
	fmt.Println("new value of pointer:", num)

}

运行结果：

old value of pointer: 1.2345
type of pointer: float64
settability of pointer: true
new value of pointer: 77

需要注意的是为什么出现panic: reflect: reflect.Value.SetFloat using unaddressable value和panic: reflect: call of reflect.Value.Elem on float64 Value呢？解释如下：

如果reflect.ValueOf的参数不是指针？
value := reflect.ValueOf(num)
value.SetFloat(6.28) //panic: reflect: reflect.Value.SetFloat using unaddressable value
fmt.Println(value.CanSet()) //false
value.Elem() //如果非指针，会直接panic，panic: reflect: call of reflect.Value.Elem on float64 Value

说明

需要传入的参数是* float64这个指针，然后可以通过pointer.Elem()去获取所指向的Value，注意一定要是指针。
如果传入的参数不是指针，而是变量，那么
通过Elem获取原始值对应的对象则直接panic
通过CanSet方法查询是否可以设置返回false
newValue.CantSet()表示是否可以重新设置其值，如果输出的是true则可修改，否则不能修改，修改完之后再进行打印发现真的已经修改了。
reflect.Value.Elem() 表示获取原始值对应的反射对象，只有原始对象才能修改，当前反射对象是不能修改的
也就是说如果要修改反射类型对象，其值必须是“addressable”【对应的要传入的是指针，同时要通过Elem方法获取原始值对应的反射对象】
struct 或者 struct 的嵌套都是一样的判断处理方式

3. 通过reflect.Value来进行方法的调用

在项目应用中，另外一个常用并且属于高级的用法，就是通过reflect来进行方法【函数】的调用。比如我们要做框架工程的时候，需要可以随意扩展方法，或者说用户可以自定义方法，那么我们通过什么手段来扩展让用户能够自定义呢？关键点在于用户的自定义方法是未可知的，因此我们可以通过reflect来搞定。

Call()方法：

func (Value) Call

如何通过反射来进行方法的调用？

本来可以用结构体对象.方法名称()直接调用的，但是如果要通过反射，那么首先要将方法注册，也就是MethodByName，然后通过反射调动mv.Call。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name string
	Age int
	Sex string
}

func (p Person)Say(msg string)  {
	fmt.Println("hello，",msg)
}
func (p Person)PrintInfo()  {
	fmt.Printf("姓名：%s,年龄：%d，性别：%s\n",p.Name,p.Age,p.Sex)
}

func (p Person) Test(i,j int,s string){
	fmt.Println(i,j,s)
}

func main() {
	p2 := Person{"Ruby",30,"男"}
	// 1. 要通过反射来调用起对应的方法，必须要先通过reflect.ValueOf(interface)来获取到reflect.Value，
	// 得到“反射类型对象”后才能做下一步处理
	getValue := reflect.ValueOf(p2)

	// 2.一定要指定参数为正确的方法名
	// 先看看没有参数的调用方法

	methodValue1 := getValue.MethodByName("PrintInfo")
	fmt.Printf("Kind : %s, Type : %s\n",methodValue1.Kind(),methodValue1.Type())
	methodValue1.Call(nil) //没有参数，直接写nil

	args1 := make([]reflect.Value, 0) //或者创建一个空的切片也可以
	methodValue1.Call(args1)

	// 有参数的方法调用
	methodValue2 := getValue.MethodByName("Say")
	fmt.Printf("Kind : %s, Type : %s\n",methodValue2.Kind(),methodValue2.Type())
	args2 := []reflect.Value{reflect.ValueOf("反射机制")}
	methodValue2.Call(args2)

	methodValue3 := getValue.MethodByName("Test")
	fmt.Printf("Kind : %s, Type : %s\n",methodValue3.Kind(),methodValue3.Type())
	args3 := []reflect.Value{reflect.ValueOf(100), reflect.ValueOf(200),reflect.ValueOf("Hello")}

	methodValue3.Call(args3)
}

运行结果：

Kind : func, Type : func()
姓名：Ruby,年龄：30，性别：男
姓名：Ruby,年龄：30，性别：男
Kind : func, Type : func(string)
hello， 反射机制
Kind : func, Type : func(int, int, string)
100 200 Hello

通过反射，调用函数。

首先我们要先确认一点，函数像普通的变量一样，之前的章节中我们在讲到函数的本质的时候，是可以把函数作为一种变量类型的，而且是引用类型。如果说Fun()是一个函数，那么f1 := Fun也是可以的，那么f1也是一个函数，如果直接调用f1()，那么运行的就是Fun()函数。

那么我们就先通过ValueOf()来获取函数的反射对象，可以判断它的Kind，是一个func，那么就可以执行Call()进行函数的调用。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	//函数的反射
	f1 := fun1
	value := reflect.ValueOf(f1)
	fmt.Printf("Kind : %s , Type : %s\n",value.Kind(),value.Type()) //Kind : func , Type : func()
	value2 := reflect.ValueOf(fun2)
	fmt.Printf("Kind : %s , Type : %s\n",value2.Kind(),value2.Type()) //Kind : func , Type : func(int, string)
	//通过反射调用函数
	value.Call(nil)
	value2.Call([]reflect.Value{reflect.ValueOf(100),reflect.ValueOf("hello")})
}

func fun1(){
	fmt.Println("我是函数fun1()，无参的。。")
}

func fun2(i int, s string){
	fmt.Println("我是函数fun2()，有参数。。",i,s)
}

说明

要通过反射来调用起对应的方法，必须要先通过reflect.ValueOf(interface)来获取到reflect.Value，得到“反射类型对象”后才能做下一步处理
reflect.Value.MethodByName这个MethodByName，需要指定准确真实的方法名字，如果错误将直接panic，MethodByName返回一个函数值对应的reflect.Value方法的名字。
[]reflect.Value，这个是最终需要调用的方法的参数，可以没有或者一个或者多个，根据实际参数来定。
reflect.Value的 Call 这个方法，这个方法将最终调用真实的方法，参数务必保持一致，如果reflect.Value.Kind不是一个方法，那么将直接panic。
本来可以用对象访问方法直接调用的，但是如果要通过反射，那么首先要将方法注册，也就是MethodByName，然后通过反射调用methodValue.Call