Go基础11：反射机制

概述

反射可以在运行时动态获取变量的各种信息,比如变量的类型(type)，类别(kind)，如果是结构体变量，还可以获取到结构体本身的信息(包括结构体的字段、方法)，通过反射，可以修改变量的值，可以调用关联的方法。

应用场景

1. 不知道接口调用那个函数，根据传入参数在运行时确定调用的具体接口，这种需要对函数或方法反射。
2. 对结构体序列化时，如果结构体有指定 Tag，也会使用到反射生成对应的字符串。

reflect 包

Go 语言中的反射是由 reflect 包提供支持的，它定义了两个重要的类型 Type 和 Value 任意接口值在反射中都可以理解为由 reflect.Type 和 reflect.Value 两部分组成，并且 reflect 包提供了 reflect.TypeOf 和 reflect.ValueOf 两个函数来获取任意对象的 Value 和 Type。

对基本数据类型进行反射的操作：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var num int = 100

	// 获取到 reflect.Type
	rType := reflect.TypeOf(num)
	fmt.Println(rType)        // int
	fmt.Println(rType.Kind()) // int

	// 获取到 reflect.Value
	rVal := reflect.ValueOf(num)
	fmt.Println(rVal) // 100

	// n1 := 2 + rVal // error，rVal 返回的是 reflect.Value 类型
	n1 := 2 + rVal.Int()
	fmt.Println(n1) // 102

	// 将 rVal 转成 Interface{}
	iV := rVal.Interface()
	// 将 interface{} 通过断言转成需要的类型
	n2 := 2 + iV.(int)
	fmt.Println(n2) // 102
}

对结构体类型进行反射的操作：

package main

import (
	"fmt"
	"reflect"
)

type Student struct {
	Name string
	Age  int
}

func main() {
	stu := Student{
		Name: "aa",
		Age:  18,
	}

	rType := reflect.TypeOf(stu)
	fmt.Println(rType)        // main.Student
	fmt.Println(rType.Kind()) // struct

	rVal := reflect.ValueOf(stu)
	fmt.Println(rVal) // {aa 18}

	// 将 rVal 转成 interface{}
	iV := rVal.Interface()
	fmt.Printf("iV=%v iV type=%T \n", iV, iV) // iV={aa 18} iV type=main.Student

	// 将 interface{} 通过断言转成需要的类型
	stu, ok := iV.(Student)
	if ok {
		fmt.Println(stu.Name) // a
	}
}

通过反射的来修改变量的操作：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var num int = 100

	// 传入地址
	rVal := reflect.ValueOf(&num)

	fmt.Println(num)  // 100
	fmt.Println(rVal) // 0xc000016098

	rVal.Elem().SetInt(200)

	fmt.Println(num)  // 100
	fmt.Println(rVal) // 0xc000016098
}

使用小结：

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

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

应用实例

package main

import (
	"fmt"
	"reflect"
)

// 定义了一个 Monster 结构体
type Monster struct {
	Name  string  `json:"name"`
	Age   int     `json:"monster_age"`
	Score float32 `json:"成绩"`
	Sex   string
}

// 方法，返回两个数的和
func (s Monster) GetSum(n1, n2 int) int {
	return n1 + n2
}

// 方法，接收四个值，给 s 赋值
func (s Monster) Set(name string, age int, score float32, sex string) {
	s.Name = name
	s.Age = age
	s.Score = score
	s.Sex = sex
}

// 方法，显示 s的值
func (s Monster) Print() {
	fmt.Println("---start~----")
	fmt.Println(s)
	fmt.Println("---end~----")
}

func TestStruct(a interface{}) {

	// 获取 reflect.Type 类型
	typ := reflect.TypeOf(a)
	// 获取 reflect.Value 类型
	val := reflect.ValueOf(a)
	// 获取到 a 对应的类别
	kd := val.Kind()

	// 如果传入的不是 struct，就退出
	if kd != reflect.Struct {
		fmt.Println("expect struct")
		return
	}

	// 获取到该结构体有几个字段
	num := val.NumField()
	fmt.Printf("struct has %d fields\n", num) // struct has 4 fields

	// 变量结构体的所有字段
	for i := 0; i < num; i++ {
		fmt.Printf("Field %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)
		}
	}

	// 获取到该结构体有多少个方法
	numOfMethod := val.NumMethod()
	fmt.Printf("struct has %d methods\n", numOfMethod) // struct has 3 methods

	// 方法的排序默认是按照函数名的排序（ASCII码）
	val.Method(1).Call(nil) // 获取到第二个方法。调用它

	// 调用结构体的第 1 个方法 Method(0)
	var params []reflect.Value // 声明了 []reflect.Value
	params = append(params, reflect.ValueOf(10))
	params = append(params, reflect.ValueOf(40))
	res := val.Method(0).Call(params) // 传入的参数是 []reflect.Value，返回 []reflect.Value
	fmt.Println("res=", res[0].Int()) // res= 50
}

func main() {

	// 创建了一个 Monster 实例
	var a Monster = Monster{
		Name: "黄鼠狼精",
		Age:
		400,
		Score: 30.8,
	}

	// 将 Monster 实例传递给 TestStruct 函数
	TestStruct(a)
}