golang的反射
需要反射的 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
b := Book{}
//c:pair
var c Reader
//c:pair
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