一.反射的引入以及基本介绍

1.看两个问题

(1).对于结构体的序列化和反序列化，看一段代码

package main

import(
    "fmt"    
    "encoding/josn"
)

type Monster struct {
    Name string `json:"monsterName"`
    Age int `json:"monsterAge"`
    Sal flotat64 `json:"monsterSal"`
    Sex string `json:"monsterSex"`
}

func main() {
    m := Monster {
        Name : "狗子"，
        Age : 12,
        Sal : 22.33,
        Sex : "公",
    }
    data, _ := json.Marsha1(m)
    fmt.Println("json results: ", string(data))
}

输出结果：

        json results: {"monsterName": "狗子"， Age: 12, Sal : 22.33, Sex : "公"}

思考：

        为什么序列化后，key-val的key值是结构体Tag的值，而不是字段的名称，比如：不是Name而是"monsterName ": "狗子"

引出反射

2.使用反射机制，编写函数的适配器，桥连接

要求如下：

(1).定义了两个匿名函数

test1 = func(v1 int, v2 int) {
    t.Log(v1, v2)
}

test2 = func(v1 int, v2 int, s string) {
    t.Log(v1, v2, s)
}

(2).定义一个适配器函数用作统一处理接口，其大致结构如下：

bridge := func(call interface{}, args ...interface{}){
    //内容
}

//实现调研test1对应的函数
bridge(test1, 1, 2)
//实现调研test2对应的函数
bridge(test2, 1, 2, "test2")

3.反射的基本介绍 

(1).反射可以在运行时动态获取变量的各种信息,比如变量的类型（type ) ，类别(kind)

(2).如果是结构体变量，还可以获取到结构体本身的信息(包括结构体的字段、方法）

(3).通过反射，可以修改变量的值，可以调用关联的方法

(4).使用反射，需要加import ("refect")

(5).示意图,如下:

 

4.反射的应用场景 

(1).不知道接口调用哪个函数，根据传入参数在运行时确定调用的具体接口，这种需要对函数或方法反射：例如以下这种桥接模式：

bridge(funcPtr interface{}, args ...interface{})

第一个参数 funcPtr 以接口的形式传入函数指针，函数参数 args 以可变参数的形式传入，bridge函数中可以用反射来动态执行funcPtr

(2).对结构体序列化,如果结构体有指定的Tag,也会使用到反射生成对应的字符串

package main

import(
    "fmt"    
    "encoding/josn"
)

type Monster struct {
    Name string `json:"monsterName"`
    Age int `json:"monsterAge"`
    Sal flotat64 `json:"monsterSal"`
    Sex string `json:"monsterSex"`
}

func main() {
    m := Monster {
        Name : "狗子"，
        Age : 12,
        Sal : 22.33,
        Sex : "公",
    }
    data, _ := json.Marsha1(m)
    fmt.Println("json results: ", string(data))
}

5.反射重要的函数和概念 

(1).reflect.TypeOf(变量名),获取变量的类型，返回 reflect.Type类型 )

(2).reflect.ValueOf(变最名)，获取变量的值，返回 reflectValue 类型,reflectValue 是一个结构体类型。 【看文档】 ，通过reflect.Value，可以获取到关于该变量的很多信息

(3). 变量,interface{},reflect.Value是可以相互转换的，这点在实际开发中，会经常使用到,示意图如下:

 

二.反射的快速入门

1.案例

(1).演示对（基本数据类型、 interface{}、 reflect.Value）进行反射的基本操作代码演示

(2).演示对（结构体类型、 interface{}、 reflect.Value ）进行反射的基本操作

代码如下:

package main

import (
    "fmt"
    "reflect"
)

//演示反射
func reflectTest(b interface{})  {
    //通过反射获取传入值的type,kind,值
    //1.先获取到reflect.Type
    rTyp := reflect.TypeOf(b)
    fmt.Println("rTyp=", rTyp) //rTyp= int

    //2.获取reflect.ValueOf()
    rVal := reflect.ValueOf(b)

    //运算
    n := 12 + rVal.Int()
    n2 := rVal.Float() // panic
    fmt.Println("n=", n) // n=112
    fmt.Println("n2=", n2) // panic: reflect: call of reflect.Value.Float on int Value

    fmt.Printf("rVal=%v, rVal type=%T\n", rVal, rVal)//rVal=100, rVal type=reflect.Value

    //下面将rVal转成interface{}
    iV := rVal.Interface()
    //将interface{}通过类型断言转成需要的类型
    num := iV.(int) //使用类型断言
    fmt.Println("num=", num)

    //3.获取变量对应的Kind(Kind代表Type类型值表示的具体分类。零值表示非法分类。)
    //rVal.Kind()
    kind := rVal.Kind()
    //rTyp.Kind()
    kind2 := rTyp.Kind()
    fmt.Printf("kind = %v, kind2 = %v\n", kind, kind2)
}
//演示结构体的反射
func reflectTest2(b interface{})  {
    //通过反射获取传入值的type,kind,值
    //1.先获取到reflect.Type
    rTyp := reflect.TypeOf(b)
    fmt.Println("rTyp=", rTyp)

    //2.获取reflect.ValueOf()
    rVal := reflect.ValueOf(b)

    //下面将rVal转成interface{}
    iV := rVal.Interface()
    fmt.Printf("iV=%v, iV type=%T\n", iV, iV)
    //将interface{}通过类型断言转成需要的类型
    //使用一个简单的带检测的类型断言, 还可以使用switch封装成一个方法来判断
    stu, ok := iV.(Student)
    if ok {
        fmt.Printf("stu.Name=%v, stu.Age=%v\n", stu.Name, stu.Age)
    }

    //3.获取变量对应的Kind(Kind代表Type类型值表示的具体分类。零值表示非法分类。)
    //rVal.Kind()
    kind := rVal.Kind()
    //rTyp.Kind()
    kind2 := rTyp.Kind()
    fmt.Printf("kind = %v, kind2 = %v\n", kind, kind2)
}

type Student struct {
    Name string
    Age int 
}

func main() {
    //编写一个案例
    //演示对(基本数据类型,interface{},reflect.Value)进行反射的基本操作
    //1.先定义一个int
    var num int = 100
    reflectTest(num)

    //2.定义一个Student实例
    stu := Student{
        Name : "tom",
        Age : 12,
    }
    reflectTest2(stu)
}

2.注意事项和细节

(1).reflect.Value.Kind ，获取变量的类别，返回的是一个常量

(2).Type和Kind的区别

Type是类型， Kind 是类别， Type 和 Kind 可能是相同的，也可能是不同的

比如： var num int = 10 , num 的Type是 int , Kind 也是 int

比如：var stu Student, stu的Type是pkg1.Student,Kind是 struct

(3).通过反射可以在让变量在 interface{}和 Reflect.value 之间相互转换，看下是如何在代码中体现

变量＜===＞ interface{} <===> reflect.Value

    //通过反射获取传入值的type,kind,值
    //1.先获取到reflect.Type
    rTyp := reflect.TypeOf(b)
    fmt.Println("rTyp=", rTyp)

    //2.获取reflect.ValueOf()
    rVal := reflect.ValueOf(b)

    //下面将rVal转成interface{}
    iV := rVal.Interface()
    fmt.Printf("iV=%v, iV type=%T\n", iV, iV)
    //将interface{}通过类型断言转成需要的类型
    //使用一个简单的带检测的类型断言, 还可以使用switch封装成一个方法来判断
    stu, ok := iV.(Student)
    if ok {
        fmt.Printf("stu.Name=%v, stu.Age=%v\n", stu.Name, stu.Age)
    }

(4).使用反射的方式来获取变量的值 (并返回对应的类型),要求数据类型匹配，比如 x 是 int , 那么就应该使用reflect.VaIue (x).Int(),而不能使用其它的，否则报 panic

    //运算
    n := 12 + rVal.Int()
    n2 := rVal.Float() // panic
    fmt.Println("n=", n) // n=112
    fmt.Println("n2=", n2) // panic: reflect: call of reflect.Value.Float on int Value

 (5).通过反射的来修改变量，注意当使用SetXxx 方法来设置需要通过对应的指针类型来完成，这样才能改变传入的变量的值，同时需要使用到\reflect.Value.Elem()方法

package main

import (
    "fmt"
    "reflect"
)

func reflectTest(b interface{})  {
    //通过反射获取传入值的type,kind,值
    //1.先获取到reflect.Type
    rTyp := reflect.TypeOf(b)
    fmt.Println("rTyp=", rTyp) //rTyp= *int

    //2.获取reflect.ValueOf()
    rVal := reflect.ValueOf(b)
    //rVal当前的Kind值(是一个指针)
    fmt.Printf("rVal kind = %v\n", rVal)    //rVal kind = 0xc0000aa058
    //3.rVal: rval.Elem() 返回rVal具体指针指向的那个值
    //Elem返回v持有的接口保管的值的Value封装，或者v持有的指针指向的值的Value封装
    rVal.Elem().SetInt(20)
}
func main() {
    var num int = 100
    reflectTest(&num)
    fmt.Printf("num = %v\n", num)//num = 20
}

package main

import(
    "fmt"
    "reflect"
)

func main() {
    //看看下面是否正确
    var str string = "tom" //ok
    rf := reflect.ValueOf(str) //ok :rf => string
    rf.SetString("mary") //error
    fmt.Println("%v", str)
}

package main

import(
    "fmt"
    "reflect"
)

func main() {
    //正确写法
    var str string = "tom" //ok
    rf := reflect.ValueOf(&str) //ok :rf => string
    rf.Elem().SetString("mary") //ok: str => mary
    fmt.Println("%v", str)//mary
}

三.反射的实践

 (1).使用反射来遍历结构体的字段,调用结构体的方法,并获取结构体标签的值

  

package main

import(
    "fmt"
    "reflect"
)

//定义一个Monster的结构体方法
type Monster struct {
    Name string `json:"name"`
    Age int `json:"monster_age"`
    Score float32
    Sex string 
}
//方法:显示s的值
func (s Monster) Print()  {
    fmt.Println("---start---")
    fmt.Println(s)
    fmt.Println("---end---")
}
//方法:返回两个数的和
func (s Monster) GetSum(n1 int, n2 int) int  {
    return n1 + n2
}
//方法:接收4个值,给Monster赋值
func (s Monster) Set(name string, Age int, score float32, sex string)  {
    s.Name = name
    s.Age = Age
    s.Score = score
    s.Sex = sex
}

func TestStruct(a interface{})  {
    //获取reflect.Type 类型
    typ := reflect.TypeOf(a)
    //获取reflect.Value 类型
    val := reflect.ValueOf(a)
    //获取a对应的类别
    kind := val.Kind()
    //如果传入的a不是struct类别,就退出
    if kind != reflect.Struct {
        fmt.Println("except struct")
        return
    }
    //获取该结构体有几个字段
    num := val.NumField()
    fmt.Printf("struct has %d filed\n", num) // 4
    //遍历结构体所有字段
    for i := 0; i < num; i ++ {
        fmt.Printf("Filed %d 值为:%v\n", i , val.Field(i))
        //获取到struct标签,注意:需通过reflect.Type来获取tag标签的值
        tagVal := typ.Field(i).Tag.Get("json")
        //如果该字段存在tag标签就显示,否则就不显示
        if tagVal != "" {
            fmt.Printf("Field %d, tag = %v\n", i, tagVal)
        }
    }

    //获取该结构体有多少个方法
    numMethod := val.NumMethod()
    fmt.Printf("struct has %d method\n", numMethod) 
    //var parmas [] reflect.Value
    //方法的默认排序是按照函数名来排序的(ASCII码)
    val.Method(1).Call(nil) //获取到第二个方法,并调用它

    //调用结构体的第一个方法Method(0)
    var params []reflect.Value  //声明了 []reflect.Value
    params = append(params, reflect.ValueOf(10))
    params = append(params, reflect.ValueOf(20))
    res := val.Method(0).Call(params)   //传入的参数是 []reflect.Value,返回的是[]reflect.Value
    fmt.Printf("res = %v\n", res[0].Int())//返回结果,返回的是[]reflect.Value
}
func main()  {
    //定义一个Monster实例
    var s Monster = Monster{
        Name: "猫",
        Age : 12,
        Score : 10.11,
        Sex : "公的",
    }
    //将monster实例传递给TestStruct函数
    TestStruct(s)
}

(2).使用反射的方式来获取结构体的 tag 标签，遍历字段的值，修改字段值，调用结构体方法（要求：通过传递地址的方式完成,在前面案例上修改即可）

反射的struct tag核心代码:

        tag := typ.Elem().Field(0).TagGet("json")

(3).定义两个函数test1和test2,定义一个适配器函数,用作统一接口处理

//定义两个函数
test1 = func(v1 int, v2 int) {
    t.Log(v1, v2)
}

test2 = func(v1 int, v2 int, s string) {
    t.Log(v1, v2, s)
}

//定义一个适配器函数,用作统一处理接口
bridge := func(call interface{}, args ...interface{}){
    //内容
}

//实现调研test1对应的函数
bridge(test1, 1, 2)
//实现调研test2对应的函数
bridge(test2, 1, 2, "test2")

(4).使用反射操作任意结构体类型

type User struct {
    UserId string
    Name string
}

func TestRelectStruct (t *testing.T) {
    var (
        model *User
        sv reflect.Value
    )
    model := &User{}
    sv = reflect.ValueOf(model)
    t.Log("reflect.ValueOf", sv.Kind().String())
    sv = sv.Elem()
    t.Log("reflect.ValueOf.Elem", sv.Kind().String())
    sv.FieldByName("UserId").SetString("123456")
    sv.FieldByName("Name").SetString("nickname")
    t.Log("model", model)
}

(5).使用反射创建并操作结构体

package test

import (
    "testing"
    "reflect"
)

type User struct {
    UserId string
    Name string
}

func TestRelectStruct (t *testing.T) {
    var (
        model *User
        st reflect.Type
        elem reflect.Value
    )

    st = reflect.TypeOf(model) //获取类型 *User
    t.Log("reflect.TypeOf", st.Kind().String()) // ptr
    st = st.Elem() //st指向的类型
    t.Log("reflect.TypeOf.Elem", st.Kind().String()) //struct
    elem = reflect.New(st) // New返回一个Value类型值,该值持有一个指向类型为typ的新申请的零值的指针
    t.Log("reflect.New", elem.Kind().String()) //ptr
    t.Log("reflect.New.Elem", elem.Elem().Kind().String()) //struct
    //model就是创建的User结构体变量(实例)
    model = elem.interface{}.("User") // model就是*User,它的指向和elem是一样的
    elem = elem.Elem() // 取得elem指向的值
    sv.FieldByName("UserId").SetString("123456")
    sv.FieldByName("Name").SetString("nickname")
    t.Log("model model.Name", model, model.Name)
}

实践

要求:

        (1).编写一个Cal结构体，有两个字段 Num ，和 Num2

        (2).方法 GetSub ( name string )

        (3).使用反射遍历Cal结构体所有的字段信息

        (4).使用反射机制完成对 GetSub 的调用，输出形式为: "mary 完成了减法运行, 9-5 = 4"

[上一节][go学习笔记.第十四章.协程和管道] 3.协程配合管道案例以及管道的注意事项和使用细节

[下一节][go学习笔记.第十五章.反射,常量] 2.常量