Golang--反射

1、概念

反射可以做什么?

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

反射相关的函数

reflect.TypeOf(变量名)，获取变量的类型，返回reflect.Type类型（结构体类型）
reflect.ValueOf变量名)，获取变量的值，返回reflect.Value类型(reflect.Value是一个结构体类型),通过reflect.Value，可以获取到关于该变量的很多信息。

type Type interface {
    // Kind返回该接口的具体分类
    Kind() Kind
    // Name返回该类型在自身包内的类型名，如果是未命名类型会返回""
    Name() string
    // PkgPath返回类型的包路径，即明确指定包的import路径，如"encoding/base64"
    // 如果类型为内建类型(string, error)或未命名类型(*T, struct{}, []int)，会返回""
    PkgPath() string
    // 返回类型的字符串表示。该字符串可能会使用短包名（如用base64代替"encoding/base64"）
    // 也不保证每个类型的字符串表示不同。如果要比较两个类型是否相等，请直接用Type类型比较。
    String() string
    // 返回要保存一个该类型的值需要多少字节；类似unsafe.Sizeof
    Size() uintptr
    // 返回当从内存中申请一个该类型值时，会对齐的字节数
    Align() int
    // 返回当该类型作为结构体的字段时，会对齐的字节数
    FieldAlign() int
    // 如果该类型实现了u代表的接口，会返回真
    Implements(u Type) bool
    // 如果该类型的值可以直接赋值给u代表的类型，返回真
    AssignableTo(u Type) bool
    // 如该类型的值可以转换为u代表的类型，返回真
    ConvertibleTo(u Type) bool
    // 返回该类型的字位数。如果该类型的Kind不是Int、Uint、Float或Complex，会panic
    Bits() int
    // 返回array类型的长度，如非数组类型将panic
    Len() int
    // 返回该类型的元素类型，如果该类型的Kind不是Array、Chan、Map、Ptr或Slice，会panic
    Elem() Type
    // 返回map类型的键的类型。如非映射类型将panic
    Key() Type
    // 返回一个channel类型的方向，如非通道类型将会panic
    ChanDir() ChanDir
    // 返回struct类型的字段数（匿名字段算作一个字段），如非结构体类型将panic
    NumField() int
    // 返回struct类型的第i个字段的类型，如非结构体或者i不在[0, NumField())内将会panic
    Field(i int) StructField
    // 返回索引序列指定的嵌套字段的类型，
    // 等价于用索引中每个值链式调用本方法，如非结构体将会panic
    FieldByIndex(index []int) StructField
    // 返回该类型名为name的字段（会查找匿名字段及其子字段），
    // 布尔值说明是否找到，如非结构体将panic
    FieldByName(name string) (StructField, bool)
    // 返回该类型第一个字段名满足函数match的字段，布尔值说明是否找到，如非结构体将会panic
    FieldByNameFunc(match func(string) bool) (StructField, bool)
    // 如果函数类型的最后一个输入参数是"..."形式的参数，IsVariadic返回真
    // 如果这样，t.In(t.NumIn() - 1)返回参数的隐式的实际类型（声明类型的切片）
    // 如非函数类型将panic
    IsVariadic() bool
    // 返回func类型的参数个数，如果不是函数，将会panic
    NumIn() int
    // 返回func类型的第i个参数的类型，如非函数或者i不在[0, NumIn())内将会panic
    In(i int) Type
    // 返回func类型的返回值个数，如果不是函数，将会panic
    NumOut() int
    // 返回func类型的第i个返回值的类型，如非函数或者i不在[0, NumOut())内将会panic
    Out(i int) Type
    // 返回该类型的方法集中方法的数目
    // 匿名字段的方法会被计算；主体类型的方法会屏蔽匿名字段的同名方法；
    // 匿名字段导致的歧义方法会滤除
    NumMethod() int
    // 返回该类型方法集中的第i个方法，i不在[0, NumMethod())范围内时，将导致panic
    // 对非接口类型T或*T，返回值的Type字段和Func字段描述方法的未绑定函数状态
    // 对接口类型，返回值的Type字段描述方法的签名，Func字段为nil
    Method(int) Method
    // 根据方法名返回该类型方法集中的方法，使用一个布尔值说明是否发现该方法
    // 对非接口类型T或*T，返回值的Type字段和Func字段描述方法的未绑定函数状态
    // 对接口类型，返回值的Type字段描述方法的签名，Func字段为nil
    MethodByName(string) (Method, bool)
    // 内含隐藏或非导出方法
}

2、对基本数据类型反射

反射相关的函数

reflect.TypeOf(变量名)，获取变量的类型，返回reflect.Type类型（结构体类型）
reflect.ValueOf变量名)，获取变量的值，返回reflect.Value类型(reflect.Value是一个结构体类型),通过reflect.Value，可以获取到关于该变量的很多信息。

package main

import(
	"fmt"
	"reflect"
)

func testReflect(i interface{}){
	//1、调用TypeOf()函数，返回reflect.Type类型的变量
	reType := reflect.TypeOf(i)
	fmt.Println("reType=",reType)  //int,但不代表reType是int，只是代表reType是int的变量，reType类型是reflect.Type
	fmt.Printf("reType的类型是：%T\n",reType) //*reflect.Type

	//2、调用VauleOf()函数，返回reflect.Value类型的变量
	reValue := reflect.ValueOf(i)
	fmt.Println("reValue=",reValue) // 119,但不代表reValue是119，只是代表reValue是119的变量，reValue类型是reflect.Value
	fmt.Printf("reValue的类型是：%T\n",reValue) //reflect.Value

	//如果想获取reValue的数值，要调用Int()方法：返回reValue持有的的数值
	num2 := 80 + reValue.Int() //Int()方法返回reValue持有的的数值--直接用reValue是不行的，因为reValue是reflect.Value类型的变量，类型不匹配不能直接用，需要调用Int()方法
	fmt.Println("num2=",num2) // 199

	//reValue转成空接口
	i2 := reValue.Interface()
	//类型断言
	n := i2.(int)
	n2 := n + 100
	fmt.Println(n2)
}

func main(){
	//对基本数据类型进行反射
	//定义一个int类型的变量
	var num int = 119
	//获取变量的类型	
	testReflect(num)
}

3、对结构体进行反射

与基本数据类型同理

package main

import(
	"fmt"
	"reflect"
)

type Student struct{
	Name string
	Age int
}


func testReflect(i interface{}){
	//1、调用TypeOf()函数，返回reflect.Type类型的变量
	reType := reflect.TypeOf(i)
	fmt.Println("reType=",reType) //main.Student
	fmt.Printf("reType的类型是：%T\n",reType) //*reflect.rtype

	//2、调用VauleOf()函数，返回reflect.Value类型的变量
	reValue := reflect.ValueOf(i)
	fmt.Println("reValue=",reValue) //{张三 18}
	fmt.Printf("reValue的类型是：%T\n",reValue) //reflect.Value 

	//reValue转成空接口
	i2 := reValue.Interface()
	//类型断言
	n,flag := i2.(Student)
	if flag{//断言成功
		fmt.Println(n.Name,' ',n.Age) // 张三 18
	}else{//断言失败
		fmt.Println("类型断言失败")
	}
}

func main(){
	//对结构体数据类型进行反射
	//定义一个结构体类型的变量
	stu := Student{
		Name: "张三",
		Age: 18,
	}

	//获取变量的类型	
	testReflect(stu)
}

4、获取变量的类别

类型和类别的区别：

类别是一个大的方向：例如不同的结构体类型都属于struct这个结构体类别
类型是具体某一个类型：例如不同的结构体类型属于不同的类型

package main

import(
	"fmt"
	"reflect"
)

type Student struct{
	Name string
	Age int
}


func testReflect(i interface{}){
	//1、调用TypeOf()函数，返回reflect.Type类型的变量
	reType := reflect.TypeOf(i)

	//2、调用VauleOf()函数，返回reflect.Value类型的变量
	reValue := reflect.ValueOf(i)

	//3、获取变量的类别--Type
	fmt.Println("类别：",reType.Kind()) //类别：struct

	//4、获取变量的类别--Value
	fmt.Println("类别：",reValue.Kind()) //类别：struct

	//获取变量的类型：
	//reValue转成空接口
	i2 := reValue.Interface()
	//类型断言：
	n,flag := i2.(Student)
	if flag{
		fmt.Printf("类型：%T",n) // 类型：main.Student
	}
}

func main(){
	//对结构体数据类型进行反射
	//定义一个结构体类型的变量
	stu := Student{
		Name: "张三",
		Age: 18,
	}

	//获取变量的类型	
	testReflect(stu)
}

5、通过反射修改变量

package main

import(
	"fmt"
	"reflect"
)

type Student struct{
	Name string
	Age int
}


func testReflect(i interface{}){
	reValue := reflect.ValueOf(i)

	//通过SetInt()修改值
	reValue.Elem().SetInt(200)
}

func main(){
	var num int = 100
	testReflect(&num) //传入的是地址，才能修改值
	
	fmt.Println(num) // 200
}

6、通过反射操作结构体的属性和方法

package main
import (
	"fmt"
	"reflect"
)

type Student struct{
	Name string
	Age int
}
func (s Student) APrint(){
	fmt.Println("Name:",s.Name)
	fmt.Println("Age:",s.Age)
}

func (s Student) BGetSum(n1,n2 int) int{
	return n1 + n2
}

func (s *Student) CSet(name string,age int){
	s.Name = name
	s.Age = age
}

//定义函数操作结构体进行反射操作
func TestStudentReflect(a interface{}){
	//a转成reflect.Value
	val := reflect.ValueOf(a)

	//通过reflect.Value类型操作结构体内部的字段：
	n1 := val.NumField() // 获取结构体字段的数量
	fmt.Println(n1)
	//通过遍历--获取具体的字段
	for i := 0; i < n1; i++{
		fmt.Printf("第%d个字段的值是：%v\n",i,val.Field(i)) //获取第i个字段的值
	}

	//通过reflect.Value类型操作结构体内部的方法：
	n2 := val.NumMethod() // 获取结构体方法的数量
	fmt.Println(n2)

	//调用方法
	//调用方法，方法的首字母必须大写才能有对应的反射的访问权限
	//方法的顺序按照ASCII码表的顺序进行排序的，对应索引从0开始，依次类推
	val.Method(0).Call(nil) //调用第0个方法

	var params []reflect.Value
	params = append(params,reflect.ValueOf(11))
	params = append(params,reflect.ValueOf(19))
	result := val.Method(1).Call(params)
	fmt.Println(result[0].Int()) //30
}

//通过反射改变结构体的值
func TestStudentReflect2(a interface{}){
	//a转成reflect.Value
	val := reflect.ValueOf(a)
	
	n := val.Elem().NumField() // 获取结构体字段的数量
	fmt.Println(n)

	//直接修改字段的值
	val.Elem().Field(0).SetString("李四")
	val.Elem().Field(1).SetInt(21)

	//调用上面定义的方法--Cset()
	var params []reflect.Value
	params = append(params,reflect.ValueOf("王五"))
	params = append(params,reflect.ValueOf(22))

	val.Method(2).Call(params) //CSet方法
}

func main(){
	a := Student{
		Name: "张三",
		Age: 20,
	}
	TestStudentReflect(a)
	fmt.Println("")

	TestStudentReflect2(&a)
	fmt.Println(a) //{王五 22}
}