Golang-反射

先看一个问题，反射的使用场景

　　

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

　　

反射的基本介绍

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

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

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

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

　　5)示意图

　　

反射的应用场景

　　

 　　

反射重要的函数和概念

　　

　　　3) 变量、interface{} 和 reflect.Value 是可以相互转换的，这点在实际开发中，会经常使用到。画出示意图

　　　　     

反射的快速入门

　　快速入门说明

　　请编写一个案例，演示对(基本数据类型、interface{}、reflect.Value)进行反射的基本操作代码演示，见下面的表格：

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

package main 
import (
	"reflect"
	"fmt"
)
	
//专门演示反射
func reflectTest01(b interface{}) {

	//通过反射获取的传入的变量的 type , kind, 值
	//1. 先获取到 reflect.Type 
	rTyp := reflect.TypeOf(b) 
	fmt.Println("rType=", rTyp)

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

	n2 := 2 + rVal.Int() 
	fmt.Println("n2=", n2)

	fmt.Printf("rVal=%v rVal type=%T
", rVal, rVal)

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

}

//专门演示反射[对结构体的反射] 
func reflectTest02(b interface{}) {

	//通过反射获取的传入的变量的 type , kind,  值
	//1. 先获取到 reflect.Type
	rTyp := reflect.TypeOf(b) fmt.Println("rType=", rTyp)

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

	//下面我们将 rVal 转成 interface{} 
	iV := rVal.Interface()
	fmt.Printf("iv=%v iv type=%T 
", iV, iV)
	//将 interface{} 通过断言转成需要的类型
	//这里，我们就简单使用了一带检测的类型断言.
	//同学们可以使用 swtich  的断言形式来做的更加的灵活
	stu, ok := iV.(Student) 
	if ok {
		fmt.Printf("stu.Name=%v
", stu.Name)
	}

}

type Student struct { 
	Name string 
	Age int
}
type Monster struct { Name string Age int
}


func main() {

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

	//1. 先定义一个 int
	// var num int = 100
	// reflectTest01(num)

	//2. 定义一个 Student 的实例
	stu := Student{ 
		Name : "tom", 
		Age : 20,
	}
	reflectTest02(stu)

}

　　

反射的注意事项和细节

 

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

 

　　　　

　　2)Type 和 Kind  的区别

　　Type 是类型, Kind 是类别， Type 和 Kind 可能是相同的，也可能是不同的. 比如: var num int = 10    num 的 Type 是 int , Kind 也 是 int

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

 

　　　

 

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

 　　

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

　　　　

反射课堂练习

1)给你一个变量    var v float64 = 1.2 , 请使用反射来得到它的 reflect.Value, 然后获取对应的 Type, Kind 和值，并将 reflect.Value 转换成 interface{}  ,  再将 interface{} 转换成 float64. [不说：]

2)看段代码，判断是否正确，为什么

package main 
import (
    "fmt" 
    "reflect"
)
func main() {
    var str string = "tom"  //ok
    fs := reflect.ValueOf(str) //ok fs -> string 
    fs.SetString("jack") //error
    fmt.Printf("%v
", str)
}

　　修改如下

 反射最佳实践

　　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
", num) //4
	//变量结构体的所有字段
	for i := 0; i < num; i++ {
		fmt.Printf("Field %d:  值为=%v
", i, val.Field(i))
		//获取到 struct 标签, 注意需要通过 reflect.Type 来获取 tag 标签的值
		tagVal := typ.Field(i).Tag.Get("json")
		//如果该字段于 tag 标签就显示，否则就不显示
		if tagVal != "" {
			fmt.Printf("Field %d: tag 为=%v
", i, tagVal)
		}
	}

	//获取到该结构体有多少个方法
	numOfMethod :=  val.NumMethod() 
	fmt.Printf("struct has %d methods
", 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)使用反射创建并操作结构体