Go_反射

反射

反射的应用场景举例

1. 对结构体序列化时，若结构体有指定Tag，也会使用到反射生成对应的字符串。
2. 不知道接口调用哪个函数，根据传入参数在运行时确定调用的具体接口，这种需要对函数或方法反射。
3. 使用反射机制，编写函数的适配器，桥连接
   

反射的基本介绍

• 反射可以在运行时动态获取变量的各种信息，比如变量的类型(type)，类别(kind)
• 如果是结构体变量，还可以获取到结构体本身的信息（包括结构体的字段、方法）
• 通过反射，可以修改变量的值，可以调用关联的方法
• 使用反射，需要 import (“reflect”)
• 反射的原理图
  
• reflect.TypeOf(变量名)，获取变量的类型，返回reflect.Type类型
• reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型。如果reflect.Value是一个结构体类型，通过reflect.Value，可以获取到关于该变量的很多信息
• 变量、interface{}、和reflect.Value是可以相互转换的。这在实际开发中，经常用到
  

反射快速入门

案例：

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

package main
import (
	"fmt"
	"reflect"
)
//专门演示反射
func reflectTest01(b interface{}){
	//通过反射获取传入变量的 type, kind, 值
	//先获取到 reflect.Type
	rTyp := reflect.TypeOf(b)
	fmt.Println("rType=", rTyp)

	//获取到reflect.Value
	rVal := reflect.ValueOf(b)
	n2 := 2 + rVal.Int()
	fmt.Println("n2=", n2)
	fmt.Printf("rVal=%v  rVal type=%T\n", rVal, rVal)
	//下面将rVal 转成 interface{}
	iV := rVal.Interface()
	//将 interface{} 通过断言转成需要的类型
	num2 := iV.(int)
	fmt.Println("num2=", num2)
}

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

2. 编写一个程序，演示对结构体类型、interface{}、reflect.Value进行反射的基本操作

package main
import (
	"fmt"
	"reflect"
)
type Student struct{
	Name string
	Age int
}

func reflectTest02(b interface{}){
	rTyp:=reflect.TypeOf(b)
	fmt.Println("rType=", rTyp)
	rVal:=reflect.ValueOf(b)
	iv := rVal.Interface()
	//可以使用switch语句来完善断言，使其更加灵活
	stu, ok := iv.(Student)
	if ok{
		fmt.Printf("stu.Name=%v\n", stu.Name)
	}
}


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

反射使用注意事项

• reflect.Value.Kind：获取变量的类别，返回的是一个常量
  
• Type是类型，Kind是类别，Type和Kind可能是相同的，也可能是不同的
• 使用反射的方式来获取变量的值（并返回对应的类型），要求数据类型匹配，比如 x 是 int，那么就应该使用 reflect.Value(x).Int()，而不能使用其他的，否则报panic
• 通过反射来修改变量
  

反射最佳实践

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

package main
import (
	"fmt"
	"reflect"
)
//声明一个结构体
type Monster struct{
	Name string `json:"name"`
	Age int `json:"age"`
	Score float32
	Sex string
}
//方法,显示s的值
func (s Monster)Print(){
	fmt.Println("--------start--------")
	fmt.Println(s)
	fmt.Println("---------end---------")
}
//方法，返回两个数的和
func (s Monster)GetSum(n1, n2 int)int{
	return n1 + n2
}
//方法 接收四个值给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{}){
	typ := reflect.TypeOf(a)
	val := reflect.ValueOf(a)
	//获取到 a 对应的类别
	kd := val.Kind()
	if kd != reflect.Struct{
		fmt.Println("expect struct")
		return
	}
	//获取该结构体有几个字段
	num := val.NumField()
	fmt.Printf("struct has %d fields\n", num)
	//遍历结构体的所有字段
	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.Println("struct 有", numOfMethod,"个方法")
	//方法的排序：默认按照函数名的排序，按ASCII码
	val.Method(1).Call(nil)//val.Method(1):获取结构体第二个方法
	//调用结构体第一个方法
	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，返回的结果也是
	fmt.Println("res=", res[0].Int())  //
}

func main(){
	var a Monster = Monster{
		Name: "黄鼠狼精",
		Age: 400,
		Score:54.6,
	}
	//将monster实例传给TestStruct()
	TestStruct(a)
}

2. 修改结构体字段值（需要传地址）
   关键函数：

• func (v Value) NumField() int（返回v持有的结构体类型值的字段数，如果v的Kind不是Struct会panic）
• func (v Value) Elem() Value
• val.Elem().Field(0).SetString(“孙悟空”)

package main
import (
	"fmt"
	"reflect"
)
type Monster struct{
	Name string
	Age int
	Score float64
}

func TestStruct(a interface{}){
	//typ := reflect.TypeOf(a)
	val := reflect.ValueOf(a)
	kd := val.Kind()
	if kd != reflect.Ptr && val.Elem().Kind() == reflect.Struct{
		fmt.Println("expect struct")
		return
	}
	num := val.Elem().NumField()
	val.Elem().Field(0).SetString("孙悟空")
	for i := 0; i < num; i++{
		fmt.Printf("%d%v\n", i, val.Elem().Field(i).Kind())
	}
	fmt.Printf("struct has %d fields\n", num)
}
func main(){
	var a Monster = Monster{
		Name : "黄鼠狼精",
		Age : 400,
		Score : 65.9,
	}
	TestStruct(&a)
	fmt.Println(a)
}

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

package test 
import (
	"testing"
	"reflect"
)
func TestReflectFunc(t *testing.T){
	call1 := func(v1 int, v2 int){
		t.Log(v1, v2)
	}
	call2 := func(v1 int, v2 int, s string){
		t.Log(v1, v2, s)
	}
	var (
		function reflect.Value
		inValue []reflect.Value
		n int
	)
	bridge := func(call interface{}, args ...interface{}){
		n = len(args)
		inValue = make([]reflect.Value, n)
		for i := 0; i < n; i++{
			inValue[i] = reflect.ValueOf(args[i])
		}
		function = reflect.ValueOf(call)
		function.Call(inValue)
	}
	bridge(call1, 1, 2)
	bridge(call2, 1, 2, "test2")
}

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

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

package test
import (
	"reflect"
	"testing"
)

type user struct{
	UserId string
	Name string
}
func TestReflectStruct(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.FieldByName("UserId").SetString("12345678")
	elem.FieldByName("Name").SetString("nickname")
	t.Log("model model.Name", model, model.Name)
}