1. 反射简介
1.1 反射是什么？
Go语言提供了一种机制在运行时更新和检查变量的值、调用变量的方法和变量支持的内在操作，但是在编译时并不知道这些变量的具体类型，这种机制被称为反射。反射也可以让我们将类型本身作为第一类的值类型处理。
反射是指在程序运行期对程序本身进行访问和修改的能力，程序在编译时变量被转换为内存地址，变量名不会被编译器写入到可执行部分，在运行程序时程序无法获取自身的信息。
举个例子
平时我们定义变量都是正射
将变量a定义成一个int类型
现在我并不知道变量a是什么类型，但是我可以通过反射也知晓变量a是什么来历！是什么类型！
- type FanOne struct {
- name string
- }
- func main(){
- var a int = 1
- var d FanOne
- fmt.Println(reflect.TypeOf(a)) // int
- // 这里就拿到了a的类型！注意是类型！不是类别！虽然这个类型和类别是一样的
- // 后面会说说类型(Type)和类别(Kind)的区别
- fmt.Println(reflect.ValueOf(a).Kind()) //int
- //这样就拿到了a的类别，是通过a的值来判断类别
- fmt.Println(reflect.TypeOf(d)) //main.FanOne
- //类型是main.FanOne 是在main里面定义的FanOne
- fmt.Println(reflect.ValueOf(d).Kind()) //struct
- //类别是struct
- // 输出 d 的类型名称和种类，类型名称就是 FanOne
- //而 FanOne 属于一种结构体类别，因此类别为 struct
- }
所以这个类别和类型有时候相同，有时候不同。
1.2 为什么需要反射？
在开发当中，当我们对于某一个函数进行值的处理的时候，但是为了保证这个函数能接受更多类型的值，因为go是强类型的语言，虽然interface可以接受所有的数据类型，但是在处理数据的时候，要对不同类型进行不同的处理的时候就会显得代码十分冗余，于是我们可以使用反射来进行对传入参数的判断与处理。
详细见例题
2. reflect包
2.1 基本反射
- reflect.TypeOf() //获取变量的类型，返回reflect.Type类型
- reflect.ValueOf() //获取变量的值，返回reflect.Value类型
- reflect.Value.Kind() //获取变量的类别，返回一个常量
- reflect.Value.Interface() //转换成interface{}类型
2.2 反射与指针
Go语言程序中对指针获取反射对象时，可以通过 reflect.Elem() 方法获取这个指针指向的元素类型，这个获取过程被称为取元素，等效于对指针类型变量做了一个*操作
- reflect.ValueOf(xxx).Elem()
2.3 反射与对象
可以通过reflect.new(xxx)或是reflect.zero(xxx)来进行反射，创建原始类型的对象
- func CreatePrimitiveObjects(t reflect.Type) reflect.Value {
- return reflect.Zero(t)
- }
也可以使用
来进行创建原始对象。
2.4 反射与函数
如果反射值对象（reflect.Value）中值的类型为函数时，可以通过reflect.Value调用该函数。使用反射调用函数时，需要将参数使用反射值对象的切片[]reflect.Value构造后传入Call()方法中，调用完成时，函数的返回值通过[]reflect.Value返回。
在反射中 函数 和 方法 的类型（Type）都是 reflect.Func，如果要调用函数的话，可以通过 Value 的 Call() 方法，例如：
- package main
-
- import (
- "fmt"
- "reflect"
- )
-
- func FanOne() string {
- return "一键三连"
- }
-
- func FanOneWoW(a string) string {
- return fmt.Sprintf("%s要给FanOne一键三连噢~",a)
- }
-
- func main() {
- FanOneNotArgs := reflect.ValueOf(FanOne).Call([]reflect.Value{}) //无参数
- FanOneHaveArgs := reflect.ValueOf(FanOneWoW).Call([]reflect.Value{reflect.ValueOf("我")}) //有参数
- fmt.Println(FanOneNotArgs[0])
- fmt.Println(FanOneHaveArgs[0])
- }
-
2.5 反射例子
填写fn函数使得输出为
要求不使用任何的switch 或是 if 或是其他选择语句。
- func fn(callback interface{}, bytes []byte) {
- //coding
- }
- type aaa struct {
- Name string `json:"name"`
- Age int `json:"age"`
- }
- func Test(t *testing.T) {
- fn(func(a []*aaa) string {
- aaas := a
- for i, item := range aaas {
- fmt.Println(i, item)
- }
- fmt.Println("12312312, ", aaas)
- return "xxxx"
- }, []byte("[{\"name\":\"111\",\"age\":1}, {\"name\":\"gsjk\",\"age\":2}]"))
-
- fn(func(a []aaa) string {
- aaas := a
- for i, item := range aaas {
- fmt.Println(i, item)
- }
-
- fmt.Println("12312312, ", aaas[0])
- return "xxxx"
- }, []byte("[{\"name\":\"111\",\"age\":1}, {\"name\":\"gsjk\",\"age\":2}]"))
-
- fn(func(a *aaa) string {
- fmt.Println("12312312, ", a)
- aaas := a
- fmt.Println("12312312, ", aaas)
- return "xxxx"
- }, []byte("{\"name\":\"gsjk\",\"age\":2}"))
-
- fn(func(a string) string {
- fmt.Println("12312312, ", a)
- aaas := a
- fmt.Println("12312312, ", aaas)
- return "xxxx"
- }, []byte("\"sss\""))
-
- fn(func(a int) string {
- fmt.Println("-----------, ", a)
- aaas := a
- fmt.Println("-----------, ", aaas)
- return "xxxx"
- }, []byte("123"))
- }
（1）首先是test的知识：
名称一定要有_test，不然好像会报错，我就是这样。
- go test xxx_test.go
- go test -v xxx_test.go
（2）其次是了解这个fn()里面的匿名函数
单独拿出来
- func(a []*aaa) string {
- aaas := a
- for i, item := range aaas {
- fmt.Println(i, item)
- }
- fmt.Println("12312312, ", aaas)
- return "xxxx"
- }, []byte("[{\"name\":\"111\",\"age\":1}, {\"name\":\"gsjk\",\"age\":2}]"))
可以看到这是一个*aaa类型的数组。那么我们任务就是反射出fn这个函数里面的匿名函数，然后调用反射出来的这个匿名函数，并将参数传入其中。
以下都是用第一个作为例子
（3）那么我们先ValueOf和TypeOf这个interface{}，然后再看这个匿名函数各种的值
- func fn(callback interface{}, bytes []byte) {
- v := reflect.ValueOf(callback) //0xbaff40
- t := reflect.TypeOf(callback) //func([]*main.aaa) string
- }
我们可以看到入参的函数的Type是func([]*main.aaa) string 所以我们可以用
- paramsValue := t.In(0) //[]*main.aaa
拿到匿名函数的传入参数
（4）重点！！
我们拿到的这个paramsValue只是[]*main.aaa名称，这个值是reflect.type 类型的！！、
我们要的是[]*main.aaa这个类型，而不是要这个名称！
所以我们要创建这个类型的对象，然后转成相应的类型
- val := reflect.New(paramsValue)
- newT := val.Interface()
- fmt.Printf("valValue:%v , valType: %T \n",val,val) //valValue:&[] , valType: reflect.Value
- fmt.Printf("newTValue:%v , newTType: %T \n",newT,newT)//newTValue:&[] , newTType: *[]*main.aaa
我们要创建这样一个类别的对象，虽然go并不是面向对象的编程，但是这里可以这样理解。
为什么要这个类型呢？
因为后面把bytes切片反序列化成这个类型的变量，传入这个匿名函数中！
- if v.IsValid() { //function valid or not
- _ = json.Unmarshal(bytes, newT) //byte to json
- }
那么问题又来了，传入的值的类型是[]*main.aaa 但是我们拿到了*[]*main.aaa这个类型，很明显是不对的。
- fmt.Printf("调用 callback 结束 callback ret = %s \n", v.Call([]reflect.Value{reflect.ValueOf(newT)}))
- fmt.Printf("*************************\n")
报错了！类型不对！
那么我们就要进行去*操作。在反射中，并不是直接加*去除！下面这样在反射中是不行的。
- package main
-
- import (
- "fmt"
- "reflect"
- )
-
- func main(){
- var a int = 1
- var b *int = &a
- var c **int = &b
- fmt.Println(a, *b, c)
- fmt.Println(reflect.TypeOf(a))
- fmt.Println(reflect.TypeOf(*b))
- fmt.Println(reflect.TypeOf(b))
- }
那么我们可以用reflect.Elem() 将这个去除*
- fmt.Printf("调用 callback 结束 callback ret = %s \n", v.Call([]reflect.Value{reflect.ValueOf(newT).Elem()}))
- fmt.Printf("*************************\n")
大功告成了！
3. 总结
以前我是很少使用反射的，基本在项目中就没用过，但是暑期实习的时候，第一个任务就是写反射接口，那么就疯狂补这方面的知识，反射对于我来说，确实有点难理解，花了我两天时间才做出来。
原来我的想法是用if判断类型的，或是断言然后用switch判断类型的，但是这样实用性不高，换了一个名称的话就要改代码了。比如现在是结构体aaa，换成bbb就不管用了。
现在这种的话，直接将这个类型的反射成一个对象，然后再对这个对象进行赋值操作，就更加灵活！
学到了！
实习很痛苦！但是学到了很多新知识！还有好多大佬带！还有工资拿！也舒服！
以上就是Golang语言学习拿捏Go反射示例教程的详细内容，更多关于Go反射教程的资料请关注w3xue其它相关文章！
经验首页