让我们一起聊一聊反射

反射的引入

【1】反射可以做什么？

1) 反射可以在运行时动态获取变量的各种信息，比如变量的类型，类别等信息

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

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

4) 使用反射，需要import ("reflect")

【2】反射相关的函数

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

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

对基本数据类型反射

【1】反射相关的函数

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

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

【2】代码：

package main

import (
    "fmt"
    "reflect"
)

//利用一个函数，函数的参数定义为空接口：
//空接口没有任何方法,所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口。
func testReflect(i interface{})  {

    //1.调用TypeOf函数，返回reflect.Type类型数据：
    reType := reflect.TypeOf(i)
    fmt.Println("reType:",reType)
    fmt.Printf("reType的具体类型是：%T n",reType)
    //2.调用ValueOf函数，返回reflect.Value类型数据：
    reValue := reflect.ValueOf(i)
    fmt.Println("reValue",reValue)
    fmt.Printf("reValue的具体类型是：%T n",reValue)

    // num1 := 100
    //如果真想获取reValue的数值，要调用Int()方法：返回v持有的有符号整数
    num2 := 80 + reValue.Int()
    fmt.Println(num2)

    //reValue转成空接口：
    i2 := reValue.Interface()
    n := i2.(int)
    n2 := n + 30
    fmt.Println(n2)
}

func main()  {
    var num int = 100;
    testReflect(num)
}

对结构体类型反射

【1】反射相关的函数

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

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

【2】代码：

package main

import (
    "fmt"
    "reflect"
)

//利用一个函数，函数的参数定义为空接口：
//空接口没有任何方法,所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口。
func testReflect(i interface{})  {

    //1.调用TypeOf函数，返回reflect.Type类型数据：
    reType := reflect.TypeOf(i)
    fmt.Println("reType:",reType)
    fmt.Printf("reType的具体类型是：%T n",reType)
    //2.调用ValueOf函数，返回reflect.Value类型数据：
    reValue := reflect.ValueOf(i)
    fmt.Println("reValue",reValue)
    fmt.Printf("reValue的具体类型是：%T n",reValue)
    // num1 := 100
    //如果真想获取reValue的数值，要调用Int()方法：返回v持有的有符号整数
    num2 := 80 + reValue.Int()
    fmt.Println(num2)

    //reValue转成空接口：
    i2 := reValue.Interface()
    n := i2.(int)
    n2 := n + 30
    fmt.Println(n2)
}

func main()  {
    var num int = 100;
    testReflect(num)
}

获取变量的类别

【1】获取变量的类别：两种方式：

（1）reflect.Type.Kind()

（2）reflect.Value.Kind()

【2】Kind的值是常量值：

【3】代码：

package main

import (
    "fmt"
    "reflect"
)

type Student struct {
    Name string
    Age int
}

func testReflect(i interface{})  {
    reType := reflect.TypeOf(i)
    reValue := reflect.ValueOf(i)

    //获取变量的类别：
    //（1）reType.Kind()
    k1 := reType.Kind()
    fmt.Println(k1)

    //（2）reValue.Kind()
    k2 := reValue.Kind()
    fmt.Println(k2)

    //获取变量的类型：
    i2 := reValue.Interface()
    n,flag := i2.(Student)
    if flag == true {
        fmt.Printf("结构体的类型是：%T",n)
    }
}

func main()  {
    stu := Student{
        Name: "菜园子",
        Age: 18,
    }
    testReflect(stu)
}

【4】Type和 Kind 的区别

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

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

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

通过反射修改变量

修改基本数据类型的值：

package main

import (
    "fmt"
    "reflect"
)

func testReflect(i interface{})  {
    reValue := reflect.ValueOf(i)
    //通过SetInt()来改变值：
    reValue.Elem().SetInt(50)
}

func main()  {
    var num int = 100
    //传入指针地址
    testReflect(&num)
    fmt.Println(num)
}

通过反射操作结构体的属性和方法

【1】代码：（熟知API）

package main

import (
    "fmt"
    "reflect"
)

type Student struct {
    Name string
    Age int
}

//给结构体绑定方法：
func (s Student) Print()  {
    fmt.Println("调用了Print()方法")
    fmt.Println("学生的名字是：",s.Name)
}

func (s Student) GetSum(n1,n2 int) int{
    fmt.Println("调用了GetSum()方法")
    return n1 + n2
}

func (s Student) Set(name string,age int)  {
    s.Name = name
    s.Age = age
}

//定义函数操作结构体进行反射操作：
func TestStudentStruct(a interface{})  {
    //a转成reflect.Value类型：
    val := reflect.ValueOf(a)
    fmt.Println(val)

    //通过reflect.Value类型操作结构体内部的字段：
    n1 := val.NumField()
    fmt.Println(n1)
    //遍历-获取具体的字段：
    for i := 0; i < n1; i++ {
        fmt.Printf("第%d个字段的值是：%v n",i+1,val.Field(i))
    }

    //通过reflect.Value类型操作结构体内部的方法：
    n2 := val.NumMethod()
    fmt.Println(n2)

    //调用Print()方法：
    //调用方法，方法的首字母必须大写才能有对应的反射的访问权限
    //方法的顺序按照ASCII的顺序排列的，a,b,c,,,,,,索引：0,1,2，，，
    val.Method(1).Call(nil)

    //调用GetSum方法：
    //定义Value的切片：
    var params []reflect.Value
    params = append(params,reflect.ValueOf(10))
    params = append(params,reflect.ValueOf(20))
    result := val.Method(0).Call(params)
    fmt.Println("GetSum方法的返回值是：",result[0].Int())
}

func main()  {
    stu := Student{
        Name: "菜园子",
        Age: 19,
    }
    TestStudentStruct(stu)
}

通过反射修改变量

【1】代码：

package main

import (
    "fmt"
    "reflect"
)

type Student struct{
    Name string
    Age int
}

func (s Student) Print() {
    fmt.Println("调用了Print()方法")
    fmt.Println("学生的姓名是：",s.Name)
}

func (s Student) GetSum(n1,n2 int) int {
    fmt.Println("调用了GetSum()方法")
    return n1 + n2
}

func (s Student) Set(name string,age int)  {
    s.Name = name
    s.Age = age
}

func TestReflectStuct(a interface{})  {
    //a转成reflect.Value类型：
    val := reflect.ValueOf(a)
    fmt.Println(val)

    n := val.Elem().NumField()
    fmt.Println(n)

    //修改字段的值：
    val.Elem().Field(0).SetString("Idea")
}

func main()  {
    stu := Student {
        Name: "菜园子",
        Age: 19,
    }

    TestReflectStuct(&stu)

    fmt.Println(stu)
}

参考源码:golang-demo: golang学习