Golang使用反射

1.反射获取变量的值

package main

import (
	"fmt"
	"reflect"
)

func reflectTest01(b interface{}) {

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

	//2.获取到reflect.Value,int不能直接参与+-*/
	rVal := reflect.ValueOf(b)
	fmt.Printf("rVal=%v type=%T\n", rVal, rVal)

	//3.把reflect.Value能参与基本运算
	n1 := 2 + rVal.Int()
	fmt.Println("n1=", n1)

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

func reflectTest02(b interface{}) {
	fmt.Println("===============reflectTest02==================")
	rVal := reflect.ValueOf(b)
	fmt.Println("rVal:=", rVal)
	//将interface{}通过断言转成需要的类型
	iv := rVal.Interface()
	fmt.Printf("iv=%v iv type=%T\n", iv, iv)

	//将interface{}通过断言转为需要的类型
	stu, ok := iv.(Student)
	if ok {
		fmt.Printf("stu.Name=%v stu.Age=%v\n", stu.Name, stu.Age)
	}

}

type Student struct {
	Name string
	Age  int
}

func main() {
	//1.基本数据类型、interface，reflect.Value进行反射的基本操作
	var num int = 100
	reflectTest01(num)

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

=====================reflectTest01==================
rType:= int
rVal=100 type=reflect.Value                      
n1= 102                                          
num2== 100                                       
==================reflectTest02==================
rVal:= {Tom 200}                                 
iv={Tom 200} iv type=main.Student                
stu.Name=Tom stu.Age=200                         

2.使用反射修改变量的值

package main

import (
	"fmt"
	"reflect"
)

/*
*
通过反射修改
num int的值
修改student的值
*/
func reflect01(b interface{}) {
	//获取value
	rVal := reflect.ValueOf(b)
	fmt.Printf("rVal kind=%v\n", rVal.Kind())
	rVal.Elem().SetInt(20)
}

func main() {
	var num int = 100
	reflect01(&num)
	fmt.Println("num=", num)
}

rVal kind=ptr
num = 20

3.反射获取结构体的变量和方法

package main

import (
	"fmt"
	"reflect"
)

type Monster struct {
	//添加json标签
	Name  string  `json:"name"`
	Age   int     `json:"monster_age"`
	Score float32 `json:"成绩"`
	Sex   string
}

// 显示结构体的值
func (s Monster) Print() {
	fmt.Println("---start---")
	fmt.Println(s)
	fmt.Println("----end----")
}

// 返回两个数的和
func (s Monster) GetSum(n1, n2 int) int {
	return n1 + n2
}
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{}) {
	//获取reflect.Type 类型
	tye := reflect.TypeOf(a)
	//获取reflect.value类型
	val := reflect.ValueOf(a)
	//获取a对应的类型
	kd := val.Kind()

	if kd != reflect.Struct {
		fmt.Println("expected struct")
		return
	}
	//获取到该结构体有几个字段
	num := val.NumField() //num=4
	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 := tye.Field(i).Tag.Get("json")
		if tagVal != "" {
			fmt.Printf("Field %d: tage为=%v\n", i, tagVal)
		}
	}

	//获取到这结构体有多少方法
	numOfMethod := val.NumMethod()
	fmt.Printf("struct has %d methods\n", numOfMethod)

	//方法的排序默认是按照函数名的排序（ASC||码）
	val.Method(1).Call(nil)

	//调用结构体的GetSum方法
	var params []reflect.Value
	params = append(params, reflect.ValueOf(153))
	params = append(params, reflect.ValueOf(200))
	res := val.Method(0).Call(params) //传入的参数[]reflect.Value,返回的也是[]reflect.Value
	fmt.Println("res=", res[0].Int())
}
func main() {
	var a Monster = Monster{
		Name:  "K神",
		Age:   500,
		Score: 40.5,
	}
	TestStruct(a)
}

struct has 4 fields
Field 0: 值为=K神          
Field 0: tage为=name       
Field 1: 值为=500          
Field 1: tage为=monster_age
Field 2: 值为=40.5         
Field 2: tage为=成绩       
Field 3: 值为=             
struct has 3 methods       
---start---                
{K神 500 40.5 }            
----end----                
res= 353