reflect使用

reflect概述

反射是一种检查存储在 接口变量中的<值,类型>对 的机制，借助go反射包提供的reflect.TypeOf和reflect.ValueOf可以方便的访问到一个接口值的reflect.Type和reflect.Value部分，从而可进一步得到 这个接口的结构类型和对其进行值的修改操作。

反射的使用

1. 获取接口对象的字段,类型和方法信息

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func (p Person)SetName(name string){
}
func (p Person)SetAge(age int){
    p.Age = age
}

func Info(o interface{}) {
    t := reflect.TypeOf(o)         //获取接口的类型
    fmt.Println("Type:", t.Name()) //t.Name() 获取接口的名称

    if t.Kind() != reflect.Struct { //通过Kind()来判断反射出的类型是否为需要的类型
        fmt.Println("err: type invalid!")
        return
    }

    v := reflect.ValueOf(o) //获取接口的值类型
    fmt.Println("Fields:")

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

    for i := 0; i < t.NumField(); i++ { //NumField取出这个接口所有的字段数量
        f := t.Field(i)                                   //取得结构体的第i个字段
        val := v.Field(i).Interface()                     //取得字段的值
        fmt.Printf("%6s: %v = %v\n", f.Name, f.Type, val) //第i个字段的名称,类型,值
    }

    for i := 0; i < t.NumMethod(); i++ {
        m := t.Method(i)
        fmt.Printf("%6s: %v\n", m.Name, m.Type) //获取方法的名称和类型
    }
}

func main() {
    inputs := Person{"sbd", 12}
    inputs.SetAge(11)
    Info(inputs)
}

result:

Type: Person
Fields:
  Name: string = sbd
   Age: int = 12
SetAge: func(main.Person, int)
SetName: func(main.Person, string)

interface的reflect.Type是User,不是*User, 因此

func (p *Person)SetName(name string){
}

不会被反射出来

1. 获取接口对象的类型名称，通过refelct.TypeOf()获取接口对象的类型,并通过Name()方法获取接口的名称。
2. 获取对象中所有字段的名称,类型和值,通过reflect.ValueOf()获取接口对象的值类型取得字段的名称和类型,然后通过v.Field(i).Interface()取得第i个字段的值。
3. 还可以通过NumMethod()循环获取接口对象所有方法的名称和类型。

2. 反射接口对象中的匿名或嵌入字段信息
   先再添加一个Manager结构,User作为它的匿名字段

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

type Manage struct{
    Person
    Title string
}


func Info(m interface{}) {
    t := reflect.TypeOf(m)
    fmt.Println("Type:", t.Name())

    //t := refelct.TypeOf(m)将Manager的字段类型取出来,在反射中对象字段是通过索引取到的，所以可通过t.Field(0)
    fmt.Printf("%#v\n", t.Field(0))

    fmt.Printf("%+v\n", t.FieldByIndex([]int{0,1}))
}

func main() {
    inputs := Manage{Person{"xudong", 18}, "yuwen"}
    Info(inputs)

}

1.给FieldByIndex()传入一个int型的slice索引,如FieldByIndex([]int{0,0})即取得User结构体中的Id字段。
2.通过FieldByName("Id")也可以取得User结构体中Id字段。

3. 通过反射修改对象
   上面通过reflect.TypeOf和reflect.ValueOf已经可以得到接口对象的类型,字段和方法等属性了，怎么通过反射来修改对象的字段值？

func main() {
        x := 100
    v := reflect.ValueOf(&x)
    v.Elem().SetInt(200)
    fmt.Println(x)
}
200

要修改变量x的值，首先就要通过reflect.ValueOf来获取x的值类型,refelct.ValueOf返回的值类型是变量x一份值拷贝,要修改变量x就要传递x的地址,从而返回x的地址对象,才可以进行对x变量值对修改操作。在得到x变量的地址值类型之后先调用Elem()返回地址指针指向的值的Value封装。然后通过Set方法进行修改赋值。

通过反射可以很容易的修改变量的值，怎么来修改结构体中的字段值？

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func SetInfo(o interface{}) {
    v := reflect.ValueOf(o)

    if v.Kind() == reflect.Ptr && !v.Elem().CanSet() { //判断是否为指针类型 元素是否可以修改
        fmt.Println("cannot set")
        return
    } else {
        v = v.Elem() //实际取得的对象
    }

    //判断字段是否存在
    f := v.FieldByName("Name")
    if !f.IsValid() {
        fmt.Println("wuxiao")
        return
    }

    //设置字段
    if f := v.FieldByName("Name"); f.Kind() == reflect.String {
        f.SetString("BY")
    }
}

func main() {
    inputs := Person{"sbd", 12}
    SetInfo(&inputs)

    fmt.Printf("%+v", inputs)
}

要成功修改结构体中的某个字段,主要进行以下操作：

1. 首先要反射出这个字段的地址值类型;
2. 判断反射返回类型是否为reflect.Ptr指针类型（通过指针才能操作对象地址中的值)同时还要判断这个元素是否可以修改;
3. 通过FieldByName的返回值判断字段是否存在
4. 通过Kind()和Set来修改字段的值

4. 通过反射“动态”调用方法
   现在已经可以通过反射获取并修改接口对象的字段，类型等信息了，那怎么通过反射“动态”调用接口对象等方法？

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func (p Person) GetInfo(v Person) (name string, age int) {
    return p.Name, p.Age
}

func SetInfo(o interface{}) {
    v := reflect.ValueOf(o)

    if v.Kind() != reflect.Struct {
        fmt.Println("not struct")
        return
    }

    //判断字段是否存在
    mv := v.MethodByName("GetInfo")
    if !mv.IsValid() {
        fmt.Println("wuxiao")
        return
    }

    args := []reflect.Value{reflect.ValueOf(o)} //初始化传入等参数，传入等类型只能是[]reflect.Value类型
    res := mv.Call(args)
    fmt.Println(res[0], res[1])

}

func main() {
    inputs := Person{"sbd", 12}
    SetInfo(inputs)
}

通过MethodByName先获取对象的Hello方法,然后准备要传入的参数,这里传入的参数必须是[]refelct.Value类型,传入的参数值必须强制转换为反射值类型refelct.Value。
最后通过调用Call方法就可以实现通过反射”动态”调用对象的方法。

http://researchlab.github.io/2016/02/17/go-reflect-summarize/