十五、反射

7.1 反射的使用场景

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

17.3 反射基本介绍

17.3.1 基本介绍

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

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

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

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

5、示意图

17.3.2 反射的应用场景

17.3.4 反射中重要的函数和概念

• reflect.TypeOf(变量名)，获取变量的类型，返回reflect..Type类型
• reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型reflect.Value是一个结构体，通过reflect.Value，可以获取到关于该变量的很多信息
• 变量、interface{}和reflect.Value是可以相互转换的，这点在实际开发中，会经常用到

17.4 入门案例

1、请编写一个案例，演示对(基本数据类型、interface{}、reflect.Value)进行反射的基本操作。

package main
import (
	"fmt"
	"reflect"
)

// 专门演示反射
func reflectTest01(b interface{}) {
	//通过反射获取传入懂得变量的 type  kins=d 值
	// 1、先获取到reflect.Type
	rTyp := reflect.TypeOf(b)
	fmt.Println("rTyp=", rTyp)

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

	n2 := 2 + rVal.Int()
	fmt.Println("n2=", n2)
	fmt.Printf("rVal=%v type=%T\n", rVal, rVal)

	// 下面我们将rVal  转成interface{}
	iV := rVal.Interface()
	// 将interface通过断言转成需要的类型

	num2 := iV.(int)
	fmt.Println("num2=", num2)

}

	
func main() {
	// 1、先定义一个int
	var num int = 100
	reflectTest01(num)
}

2、请编写一个案例，演示对(基本结构体、interface{}、reflect.Value)进行反射的基本操作。

package main
import (
	"fmt"
	"reflect"
)

// 专门演示对  结构体反射
func reflectTest02(b interface{}) {
	// 1、先获取到reflect.Type
	rTyp := reflect.TypeOf(b)
	fmt.Println("rType=", rTyp)

	//2、获取到reflect.Value
	rVal := reflect.ValueOf(b)
	
	//获取  变量对应的Kind
	//1、rVal.Kind()  ==>
	kind1 := rVal.Kind()
	//2、rTyp.Kind()  ==>
	kind2 := rTyp.Kind()
	fmt.Printf("Kind1=%v  kind2 =%v\n", kind1, kind2)

	// 3、下面将rVal转成interface{}
	iV := rVal.Interface()
	fmt.Printf("iV=%v iv type=%T\n", iV, iV)

	// 4、将interface{}，通过断言转成需要的类型
	// 这里使用了一个简单的类型断言
	stu, ok := iV.(Student)
	if ok {
		fmt.Printf("stu.Name=%v\n", stu.Name)
	}
}
// 定义一个结构体
type Student struct {
	Name string
	Age int
}	

func main() {
	// 1、定义一个student的实例
	stu := Student{
		Name : "tom",
		Age : 20,
	}
	reflectTest02(stu)
}

17.5 反射注意事项

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

2、Type是类型，Kind是类别，Type和Kind可能是相同的，也可能是不同的，比如：

var num int = 10 num的 Type是int，Kind也是int

var stu Student stu的 Type是包名.Student，Kind是struct

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

变量<-------->interface{}<------->reflect.Value

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

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

package main
import (
	"fmt"
	"reflect"
)
func reflect01 (b interface{}){
	//2、获取到reflect.Value
	rVal := reflect.ValueOf(b)
	// 看看rVal的Kind是
	fmt.Printf("rVal kind=%v\n", rVal.Kind())
	//3、rVal
	// Elem返回v持有的接口保管的值的Value封装，
	// 或者v持有的指针指向的值的Value封装
	rVal.Elem().SetInt(20)
}
func main() {
	var num int = 10
	reflect01(&num)
	fmt.Println("num=", num)   //输出20

	// 你可以这样理解rVal.Elem()
	// num := 9
	// ptr *int = &num
	// num2 := *ptr  //类似rVal.Elem()
}

6、reflect.Value.Elem()应该如何理解？

//你可以这样理解rVal.Elem()
// num := 9
// ptr *int = &num
// num2 := *ptr    //类似rVal.Elem()

17.6 反射最佳实践

1、使用反射来遍历结构体的字段，调用结构体的方法，并获取结构体标签的

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) //4
	//变量结构体的所有字段
	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)
	
	//var params []reflect.Value
	//方法的排序默认是按照 函数名的排序（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()) //返回结果, 返回的结果是 []reflect.Value*/

}
func main() {
	//创建了一个Monster实例
	var a Monster = Monster{
		Name:  "黄鼠狼精",
		Age:   400,
		Score: 30.8,
	}
	//将Monster实例传递给TestStruct函数
	TestStruct(a)	
}

2、使用反射的方式来获取结构体的tag标签，遍历字段的值，修改字段值，调用结构体方法(要求：通过传递地址的方式完成)

3、定义了两个函数test1和test2，定义了一个嗯适配器用作统一接口处理

4、使用反射操作任意结构体类型

5、使用反射创建并操作结构体