golang学习笔记016--反射

1.反射的基本概念

1.1 基本介绍

● 反射可以在运行时动态获取变量的各种信息，比如变量的类型type，类别kind
● 如果是结构体变量，还可以获取到结构体本身的信息（包括结构体的字段、方法）
● 通过反射，可以修改变量的值，可以调用关联的方法
● 使用反射，需要 import reflect
● 示意图

1.2 反射的应用场景

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

1.3 反射重要的函数和概念

1. reflect.TypeOf(变量)，获取变量的类型，返回reflect.Type类型
2. reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型，reflect.Value是一个结构体，通过reflect.Value可以获取到关于该变量的很多信息
   
3. 变量、interface{}和reflect.Value是可以相互转换的
   

2.快速入门案例

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

对基本数据类型，interface()，reflect.Value进行反射操作

	package main
	
	import (
		"fmt"
		"reflect"
	)
	
	//专门演示反射
	func reflectTest01(b interface{}) {
		//1.先获取到reflect.Type
		rType := reflect.TypeOf(b)
		fmt.Println("rType=", rType) //rType= int
	
		//获取reflect.Value
		rVal := reflect.ValueOf(b)
		fmt.Printf("rVal=%v rVal type=%T\n", rVal, rVal) //rVal=100 rVal type=reflect.Value
		//n:=10+rVal//这是错误的，类型不一致
		n := 10 + rVal.Int() //必须对reflect.Value转换
		fmt.Println("n=", n) //n= 110
	}
	
	func main() {
		//先定义一个int
		var num int = 100
		reflectTest01(num)
	}

2.2对结构体进行反射操作

	package main
	
	import (
		"fmt"
		"reflect"
	)
	
	//专门演示反射怕[结构体]
	func reflectTest02(b interface{}) {
		//1.先获取到reflect.Type
		rType := reflect.TypeOf(b)
		fmt.Println("rType=", rType) //rType= main.Student
	
		//获取reflect.Value
		rVal := reflect.ValueOf(b)
		fmt.Printf("rVal=%v rVal type=%T\n", rVal, rVal) //rVal={张三 20} rVal type=reflect.Value
		//获取kind  kind范围大于type   比如：kind：struct  type：student
		k1 := rType.Kind()
		k2 := rVal.Kind()
		fmt.Println(k1, k2) //struct struct
		//将rVal转成interface{}
		iV := rVal.Interface()
		fmt.Printf("iV=%v IV type=%T\n", iV, iV) //iV={张三 20} IV type=main.Student
		//iV虽然是main.Student，但是不能用iV.Name获取到Name的值，因为反射是运行时，iV.Name编译报错
		//要获取Name,必须加断言
		stu, ok := iV.(Student)
		if ok {
			fmt.Println("name:", stu.Name) //name: 张三
		}
	
	}
	
	type Student struct {
		Name string
		Age  int
	}
	
	func main() {
	
		stu := Student{
			Name: "张三",
			Age:  20,
		}
		reflectTest02(stu)
	}

3.反射注意事项

1. reflect.Value.Kind，获取变量的类别，返回的是一个常量
   
2. Type和Kind的区别
   Kind返回大于Type
   Type时类型，kind是类别，Type和Kind可能是相同的，也可能是不同的
   比如：var num int=10，Type是int，kind也是int
   比如 var stu Student ，Type是pkg.Student ，Kind是struct
3. 通过反射可以让变量在interface{}和Reflect.Value之间相互转换
4. 使用反射的方法来获取变量的值，要求数据类型匹配，比如x是int，那么就应该使用reflect.Value(x).Int()，而不能使用其他的
   
5. 通过反射来修改变量，当使用SetXXX时需要通过对应的指针类型来完成，这样才能改变传入的值，同时需要使用reflect.Value.Elem()方法
   
6. reflect.Value.Elem()如何理解

	//比如上图代码
	var num = 20
	var n *int=&num
	*n=110

4.反射最佳实践

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

	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)
	}