go中的关键字-reflect 反射

1. 什么是反射

　　Golang提供了一种机制，在编译时不知道类型的情况下，可更新变量、运行时查看值、调用方法以及直接对他们的布局进行操作的机制，称为反射。

2. 反射的使用

2.1 获取变量内部信息

　　reflect提供了两种类型来进行访问接口变量的内容：

　　类型reflect.ValueOf() 的作用是：获取输入参数接口中的数据的值，如果为空则返回0 <- 注意是0。
　　类型reflect.TypeOf() 动态获取输入参数接口中的值的类型，如果为空则返回nil <- 注意是nil。

　　看示例：

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var name string = "编程菜菜"

    //TypeOf会返回目标数据的类型，比如int/float/struct/指针等
    reflectType := reflect.TypeOf(name)

    //valueOf会返回目标数据的值，比如上文的“编程菜菜”
    reflectValue := reflect.ValueOf(name)

    fmt.Println("type:", reflectType)
    fmt.Println("value:", reflectValue)
}

　　输出结果：

type:  string
value:  编程菜菜

　　在以上操作发生的时候，反射将“接口类型的变量”转为了“反射的接口类型的变量”，比如上文实际上返回的是reflect.Value和reflect.Type的接口对象。

2.2 struct的反射

package main

import (
    "fmt"
    "reflect"
)

type Student struct {
    Id   int
    Name string
}

func (s Student) Hello(){
    fmt.Println("我是一个学生")
}

func main() {
    s := Student{Id: 1, Name: "编程菜菜"}
    
    t := reflect.TypeOf(s)  // 获取目标对象
    
    fmt.Println("类型的名称是: ", t.Name())   // .Name()可以获取去这个类型的名称

    v := reflect.ValueOf(s)   // 获取目标对象的值类型
    
    for i := 0; i < t.NumField(); i++ {   // .NumField()来获取其包含的字段的总数目
        
        key := t.Field(i)  // 从0开始获取Student所包含的key

        value := v.Field(i).Interface()   // 通过interface方法来获取key所对应的值

        fmt.Printf("第%d个字段是：%s:%v = %v 
", i+1, key.Name, key.Type, value)
    }

    for i:=0;i<t.NumMethod(); i++ {   // 通过.NumMethod()来获取Student里头的方法
        m := t.Method(i)
        fmt.Printf("第%d个方法是：%s:%v
", i+1, m.Name, m.Type)
    }
}

这个类型的名称是: Student
第1个字段是：Id:int = 1 
第2个字段是：Name:string = 编程菜菜
第1个方法是：Hello:func(main.Student)

2.3 判断传入的类型是否是我们想要的类型

package main

import (
    "reflect"
    "fmt"
)

type Student struct {
    Id   int
    Name string
}

func main() {
    s := Student{Id: 1, Name: "编程菜菜"}
    t := reflect.TypeOf(s)

    // 通过.Kind()来判断对比的值是否是struct类型
    if k := t.Kind(); k == reflect.Struct {
        fmt.Println("yes")
    }

    num := 1;
    numType := reflect.TypeOf(num)
    if k := numType.Kind(); k == reflect.Int {
        fmt.Println("yes")
    }
}

yes
yes

2.4 通过反射修改内容

package main

import (
    "reflect"
    "fmt"
)

type Student struct {
    Id   int
    Name string
}

func main() {
    s := &Student{Id: 1, Name: "编程菜菜"}

    v := reflect.ValueOf(s)

    if v.Kind() != reflect.Ptr {   // 修改值必须是指针类型否则不可行
        fmt.Println("不是指针类型，没法进行修改操作")
        return
    }

    v = v.Elem()    // 获取指针所指向的元素

    name := v.FieldByName("Name")   // 获取目标key的Value的封装

    if name.Kind() == reflect.String {
        name.SetString("小学生")
    }

    fmt.Printf("%#v 
", *s)

    test := 888   // 如果是整型的话
    testV := reflect.ValueOf(&test)
    testV.Elem().SetInt(666)
    fmt.Println(test)
}

　　输出结果：

main.Student{Id:1, Name:"小学生"} 
666

2.5 通过反射调用方法

package main

import (
    "fmt"
    "reflect"
)

type Student struct {
    Id   int
    Name string
}

func (s Student) EchoName(name string){
    fmt.Println("我的名字是：", name)
}

func main() {
    s := Student{Id: 1, Name: "咖啡色的羊驼"}

    v := reflect.ValueOf(s)

    // 获取方法控制权
    // 官方解释：返回v的名为name的方法的已绑定（到v的持有值的）状态的函数形式的Value封装
    mv := v.MethodByName("EchoName")
   
    args := []reflect.Value{reflect.ValueOf("编程菜菜")}   // 拼凑参数

    mv.Call(args)   // 调用函数
}

我的名字是： 编程菜菜

　　使用规则：

1. 使用反射时需要先确定要操作的值是否是期望的类型，是否是可以进行“赋值”操作的，否则reflect包将会毫不留情的产生一个panic。

2. 反射主要与Golang的interface类型相关，只有interface类型才有反射一说。看下TypeOf和ValueOf，会发现其实传入参数的时候已经被转为接口类型了。

3. reflect有关的部分源码分析

 1 // 部分源代码
 2 func TypeOf(i interface{}) Type {
 3     eface := *(*emptyInterface)(unsafe.Pointer(&i))
 4     return toType(eface.typ)
 5 }
 6 
 7 func ValueOf(i interface{}) Value {
 8     if i == nil {
 9         return Value{}
10     }
11     escapes(i)
12 
13     return unpackEface(i)
14 }

　　TypeOf函数动态获取输入参数接口中的值的类型，如果接口为空则返回nil。

　　转换为emptyinterface，emptyInterface是interface {}值的标头。

// emptyInterface is the header for an interface{} value.
// emptyInterface是interface {}值的标头。
type emptyInterface struct {
        typ  *rtype
        word unsafe.Pointer
}

rtype结构体，实现了Type接口

　　size: 存储这个类型的一个值所需要的字节数（值占用的字节数）

　　algin: 这个类型的一个变量在内存中的对齐后的所用的字节数 （变量占的字节数）

　　FieldAlign: 这种类型的变量如果是struct中的字段，那么它对齐后所用的字节数

// rtype是大多数值的通用实现。
//它嵌入在其他结构类型中。
//
// rtype必须与../runtime/type.go:/^type._type保持同步。
type rtype struct { 
        size       uintptr
        ptrdata    uintptr  // 类型中可以包含指针的字节数
        hash       uint32   // hash of type; avoids computation in hash tables
        tflag      tflag       // 类型的哈希； 避免在哈希表中进行计算
        align      uint8     // 变量与此类型的对齐
        fieldAlign uint8    // 结构域与该类型的对齐
        kind       uint8     // C的枚举
        alg        *typeAlg // 算法表
        gcdata     *byte    // 垃圾收集数据
        str        nameOff   // 字符串形式
        ptrToThis  typeOff  // 指向此类型的指针的类型，可以为零
} 

Value

　　Value描述对象的值信息，并不是所有的方法对任何的类型都有意义，特定的方法只适用于特定的类型。

type Value struct {
        // typ包含由值表示的值的类型。
        typ *rtype
       
        // 指针值的数据；如果设置了flagIndir，则为数据的指针。
         //在设置flagIndir或typ.pointers（）为true时有效。
        ptr unsafe.Pointer
       
        // 标志保存有关该值的元数据。
        //最低位是标志位：
        //-flagStickyRO：通过未导出的未嵌入字段获取，因此为只读
        //-flagEmbedRO：通过未导出的嵌入式字段获取，因此为只读
        //-flagIndir：val保存指向数据的指针
        //-flagAddr：v.CanAddr为true（表示flagIndir）
        //-flagMethod：v是方法值。
        //接下来的五位给出值的种类。
        //重复typ.Kind（），方法值除外。
        //其余的23+位给出方法值的方法编号。
        //如果flag.kind（）！= Func，则代码可以假定flagMethod未设置。
        //如果是ifaceIndir（typ），则代码可以假定设置了flagIndir。
        flag
       
       //方法值代表一个经过咖喱的方法调用像r.Read为某些接收者r。 typ + val + flag位描述接收者r，但标志的Kind位表示Func（方法是函数），并且标志的高位给出方法号在r的类型的方法表中。
}

总结

• 涉及到内存分配以及后续的GC
• reflect实现里面有大量的枚举，也就是for循环，比如类型之类的