06-反射使用

https://golang.org/pkg/reflect/

1、介绍

Go 语言实现了反射。我们一般用到的包是reflect包，反射包中有两对非常重要的函数和类型，两个函数分别是：

方法名	描述
reflect.TypeOf	可以获得任意值的类型对象,返回类型:reflect.Type
reflect.ValueOf	可以获得任意值的值对象,返回类型:reflect.Value

反射包中的所有方法基本都是围绕着 reflect.Type 和 reflect.Value 两个类型设计的。

我们通过 reflect.TypeOf、reflect.ValueOf 可以将一个普通的变量转换成反射包中提供的 reflect.Type 和 reflect.Value，随后就可以使用反射包中的方法对它们进行复杂的操作。

2、reflect.Type

类型 reflect.Type 是反射包定义的一个接口，接口中定义了一些方法，常用如下:

2.1、常用方法列表

方法名	描述
Kind() Kind	返回该变量的的具体分类
Name() string	Name返回该类型在自身包内的类型名，如果是未命名类型会返回””
Implements(u Type) bool	检查当前类型有没有实现接口 u
Key() Type	返回map 的key 的类型，不是map会panic
Field(i int) StructField	根据索引，返回索引对应的结构体（struct）字段的信息。不是struct 会 panic，i 越界也会panic
NumField() int	返回结构体（struct）成员字段数量。不是 struct 会 panic
FieldByName(name string) (StructField, bool)	根据给定字符串返回字符串对应的结构体字段的信息。
FieldByIndex(index []int) StructField	多层成员访问时，根据 []int 提供的每个结构体的字段索引，返回字段的信息。
FieldByNameFunc(match func(string) bool) (StructField,bool)	根据传入的匹配函数匹配需要的字段。
NumMethod() int	返回该类型的方法集中方法的数目
Method(int) Method	返回该类型方法集中的第i个方法,返回的是 Method
MethodByName(name string) Value	根据方法名返回该类型方法集中的方法,返回的是 Value

类型与种类的区别：

• Type 是原生数据类型： int、string、bool、float32 ，以及 type 定义的类型，对应的反射获取方法是 reflect.Type 中 的 Name()
  • 通过反射获取到的 数组, 切片, Map, 指针, 等类型的变量, 他们的 Type.Name() 都是返回的空
• Kind 是对象归属的品种：Int、Bool、Float32、Chan、String、Struct、Ptr（指针）、Map、Interface、Fune、Array、Slice、Unsafe Pointer等

2.2、使用示例

package main
import (
	"fmt"
	"reflect"
)
type People interface {
	Eat(str string)
}
type User struct {
	Name string
	Age  int
}
func (u User) Eat(str string) {
	fmt.Println("吃" + str)
}
func main() {
	var user User
	userTypeOf := reflect.TypeOf(user)
	fmt.Printf("typeOf:%T v:%v\n", userTypeOf, userTypeOf)
	// 获取类型分类
	fmt.Printf("kind:%T v:%v\n", userTypeOf.Kind(), userTypeOf.Kind())
	// 获取类型名称
	fmt.Printf("name:%T v:%v\n", userTypeOf.Name(), userTypeOf.Name())
	// 判断类型是否实现接口People
	implements := userTypeOf.Implements(reflect.TypeOf((*People)(nil)).Elem())
	fmt.Printf("变量user是否实现接口People : %t\n", implements)
	// 变量结构体user的字段数量
	fmt.Printf("变量结构体user的字段数量: %d \n", userTypeOf.NumField())
	// 打印结构体字段
	fmt.Printf("打印结构体user第%d个字段: %v \n", 0,userTypeOf.Field(0).Name)
	fmt.Printf("打印结构体user第%d个字段: %v \n", 1,userTypeOf.Field(1).Name)
	map1 := map[string]int {
		"张三": 19,
		"李四": 23,
	}
	fmt.Printf("打印map的key类型: %v \n", reflect.TypeOf(map1).Key())
}

/**输出
typeOf:*reflect.rtype v:main.User
kind:reflect.Kind v:struct
name:string v:User
变量user是否实现接口People : true
变量结构体user的字段数量: 2 
打印结构体user第0个字段: Name 
打印结构体user第1个字段: Age 
打印map的key类型: string 
*/

2.3、Kind 类型整理

type Kind uint
const (
    Invalid Kind = iota  // 非法类型
    Bool                 // 布尔型
    Int                  // 有符号整型
    Int8                 // 有符号8位整型
    Int16                // 有符号16位整型
    Int32                // 有符号32位整型
    Int64                // 有符号64位整型
    Uint                 // 无符号整型
    Uint8                // 无符号8位整型
    Uint16               // 无符号16位整型
    Uint32               // 无符号32位整型
    Uint64               // 无符号64位整型
    Uintptr              // 指针
    Float32              // 单精度浮点数
    Float64              // 双精度浮点数
    Complex64            // 64位复数类型
    Complex128           // 128位复数类型
    Array                // 数组
    Chan                 // 通道
    Func                 // 函数
    Interface            // 接口
    Map                  // 映射
    Ptr                  // 指针
    Slice                // 切片
    String               // 字符串
    Struct               // 结构体
    UnsafePointer        // 底层指针
)

3、reflect.Value

反射包中Value的类型与Type不同，它被声明成了结构体。这个结构体没有对外暴露的字段，但是提供了获取或者写入数据的方法。

3.1、常用方法列表

方法名	描述
Call(in []Value) []Value	调用方法,第一个参数是in[0]，第二个是in[1]，以此类推
Field(i int) StructField	返回struct 类型的第 i 个字段的值，不是struct 会 panic， i 越界也会panic。
FieldByName(name string) Value	根据字段名查找值，前提类型是struct
Index(i int) Value	返回第 i 个元素,主要用于遍历,不能越界。 前提类型是Array, Slice, String之一，
IsNil() bool	判断返回值是否为nil。如果值类型不是通道（channel）、函数、接口、map、指针或 切片时发生panic，类似于语言层的v== nil操作。常被用于判断指针是否为空。
IsValid() bool	返回v是否持有一个值。如果v是Value零值会返回假， 此时v除了IsValid、String、Kind之外的方法都会导致panic。常被用于判定返回值是否有效
MapIndex(key Value) Value	根据索引获取对应的值,前提类型是map
MapKeys() []Value	返回map中所有的key,返回类型是切片slice
Set(x Value)	通过反射修改值。
Type() Type	获取值的类型
Interface() interface {}	将值以 interface{} 类型返回，可以通过类型断言转换为指定类型
Int() int64	将值以 int 类型返回，所有有符号整型均可以此方式返回
Uint() uint64	将值以 uint 类型返回，所有无符号整型均可以此方式返回
Float() float64	将值以双精度（float64）类型返回，所有浮点数（float32、float64）均可以此方式返回
Bool() bool	将值以 bool 类型返回
Bytes() []bytes	将值以字节数组 []bytes 类型返回
String() string	将值以字符串类型返回

3.2、使用示例

func reflectValue(x interface{}) {
	v := reflect.ValueOf(x)
	k := v.Kind()
	switch k {
	case reflect.Int64:
		// v.Int()从反射中获取整型的原始值，然后通过int64()强制类型转换
		fmt.Printf("type is int64, value is %d\n", int64(v.Int()))
	case reflect.Float32:
		// v.Float()从反射中获取浮点型的原始值，然后通过float32()强制类型转换
		fmt.Printf("type is float32, value is %f\n", float32(v.Float()))
	case reflect.Float64:
		// v.Float()从反射中获取浮点型的原始值，然后通过float64()强制类型转换
		fmt.Printf("type is float64, value is %f\n", float64(v.Float()))
	}
}
func main() {
	var a float32 = 3.14
	var b int64 = 100
	reflectValue(a) // type is float32, value is 3.140000
	reflectValue(b) // type is int64, value is 100
	// 将int类型的原始值转换为reflect.Value类型
	c := reflect.ValueOf(10)
	fmt.Printf("type c :%T\n", c) // type c :reflect.Value
}

package main
import (
	"fmt"
	"reflect"
)
type User struct {
	Name string
	Age  int
}
func (u User) Eat(str string) {
	fmt.Println("调用函数: 吃" + str)
}
func main() {
	user := User{"张福生", 30}
	userValOf := reflect.ValueOf(user)
	// 调用方法
	param := []reflect.Value{reflect.ValueOf("香蕉")}
	userValOf.MethodByName("Eat").Call(param)
	// 打印结构体的值
	fmt.Printf("打印结构体user第%d个字段值v: %v\n", 0, userValOf.Field(0))
	fmt.Printf("打印结构体user第%d个字段值v: %v\n",1, userValOf.Field(1))
	// 根据属性值打印结构体的值
	fmt.Printf("打印结构体user字段%s的值v: %v\n", "Age",userValOf.FieldByName("Age"))
	// 返回第 i 个元素,主要用于遍历,不能越界。前提类型是Array, Slice, String之一，
	strSlice :=[]string{"你","我","他","!"}
	strSliceValOf := reflect.ValueOf(strSlice)
	fmt.Printf("打印字符串第%d个元素值v: %v\n", 0,strSliceValOf.Index(0))
	fmt.Printf("打印字符串第%d个元素值v: %v\n", 1,strSliceValOf.Index(1))
	fmt.Printf("打印字符串第%d个元素值v: %v\n", 3,strSliceValOf.Index(2))

	// IsNil: 判断是否是nil
	fmt.Printf("变量strSlice的值是否是nil: %t\n",strSliceValOf.IsNil())
	var u []User
	uuOf := reflect.ValueOf(u)
	fmt.Printf("IsNil: 变量u的值是否是nil: %t\n",uuOf.IsNil())
	// IsValid：判断返回值是否有效
	fmt.Printf("存在的方法: %t\n",userValOf.MethodByName("Eat").IsValid())
	fmt.Printf("不存在的方法: %t\n",userValOf.MethodByName("A").IsValid())

	// #####  针对map的操作  #####
	map1 := map[string]string{
		"姓名": "张三",
		"phone": "176666666666",
		"?": "ABC",
	}
	mapValOf := reflect.ValueOf(map1)
	// 根据索引获取对应的值
	fmt.Printf("根据索引获取map值，key=%s,v=%s \n","姓名",mapValOf.MapIndex(reflect.ValueOf("姓名")))
	fmt.Printf("根据索引获取map值，key=%s,v=%s \n","phone",mapValOf.MapIndex(reflect.ValueOf("phone")))
	fmt.Printf("根据索引获取map值，key=%s,v=%s \n","?",mapValOf.MapIndex(reflect.ValueOf("?")))
	// 返回map中所有的key,返回类型是切片slice
	fmt.Printf("返回map中所有的key: %+v 类型:%T \n",mapValOf.MapKeys(),mapValOf.MapKeys())
	// 通过反射修改值
	num := 10
	numValOf := reflect.ValueOf(&num)//注意这里需要传地址
	fmt.Printf("修改前的值: %v \n",num)
	numValOf.Elem().Set(reflect.ValueOf(100))
	fmt.Printf("修改后的值: %v \n",num)
	// 获取值的类型
	fmt.Printf("获取mapValOf值的类型: %v \n",mapValOf.Type())
}

输出:

调用函数: 吃香蕉
打印结构体user第0个字段值v: 张福生
打印结构体user第1个字段值v: 30
打印结构体user字段Age的值v: 30
打印字符串第0个元素值v: 你
打印字符串第1个元素值v: 我
打印字符串第3个元素值v: 他
变量strSlice的值是否是nil: false
IsNil: 变量u的值是否是nil: true
存在的方法: true
不存在的方法: false
根据索引获取map值，key=姓名,v=张三 
根据索引获取map值，key=phone,v=176666666666 
根据索引获取map值，key=?,v=ABC 
返回map中所有的key: [姓名 phone ?] 类型:[]reflect.Value 
修改前的值: 10 
修改后的值: 100 
获取mapValOf值的类型: map[string]string

4、实践场景

4.1、动态调用结构体方法、函数

使用 MethodByName("xx").Call(param) 调用函数

type People struct {
	Name string
}
func (p People) GetName() string {
	return p.Name
}
func (p People) Tell(toName, context string) string {
	return fmt.Sprintf(p.Name+"告诉%s,%s", toName, context)
}

func main() {
	p := People{"张三"}
	peopleValOf := reflect.ValueOf(p)
	// 通过反射调用方法(无参数)
	call := peopleValOf.MethodByName("GetName").Call(nil)
	fmt.Printf("无参函数调用,返回: %v %T \n", call, call)       // 无参函数调用,返回: [张三] []reflect.Value 

	// 通过反射调用方法(有参数)
	param := []reflect.Value{
		reflect.ValueOf("小明"),
		reflect.ValueOf("你通过考试了！"),
	}
	values := peopleValOf.MethodByName("Tell").Call(param)
	fmt.Printf("有参函数调用,返回: %v %T \n", values, values)   // 有参函数调用,返回: [张三告诉小明,你通过考试了！] []reflect.Value 
}

4.2、处理错误结果

type People struct {
	Name string
}
func (p People)ThrowError()error  {
	return errors.New("测试错误抛出")
}
func main() {
	p := People{"张三"}
	peopleValOf := reflect.ValueOf(p)
	ret := peopleValOf.MethodByName("ThrowError").Call(nil)
	// 返回值也是 Value 类型，对于错误，可以转为 interface 之后断言
	fmt.Printf("errValue: %v 类型转换: %T", ret[0], ret[0].Interface().(error))
}

4.3、解析结构体标签

使用field.Tag.Lookup()或field.Tag.Get()查找对应的标签值

type People struct {
	Name string `json:"name" db:"t_name"`
	Age int `json:"age" db:"t_age"`
}
func main() {
	p := People{"张三",23}
	peopleTypeOf := reflect.TypeOf(p)
	// 获取结构体字段数量
	fieldNum := peopleTypeOf.NumField()
	for i := 0; i < fieldNum; i++ {
		// 获取结构体中，第i个字段的值
		field := peopleTypeOf.Field(i)
		// 获取json标签对应的值(方法一)
		if lookup, ok := field.Tag.Lookup("json");ok {
			fmt.Printf("字段 %v, 对应的json-tag: %s \n" ,field.Name, lookup)
		}
		// 获取db标签对应的值(方法二)
		dbTag := field.Tag.Get("db")
		fmt.Printf("字段 %v, 对应的db-tag: %s \n" ,field.Name, dbTag)
	}
}
/**输出
字段 Name, 对应的json-tag: name 
字段 Name, 对应的db-tag: t_name 
字段 Age, 对应的json-tag: age 
字段 Age, 对应的db-tag: t_age 
*/

4.4、判断是否实现接口

type People interface {
	Eat(str string)
}
type User struct {}
func (u User) Eat(str string) {
	fmt.Println("吃" + str)
}
func main() {
	user := &User{}
	// 当变量不是传指针时，Eat方法的接收方是指针，则没有实现接口
	userTypeOf := reflect.TypeOf(user)
	// 判断类型是否实现接口People
	implements := userTypeOf.Implements(reflect.TypeOf((*People)(nil)).Elem())
	fmt.Printf("变量user是否实现接口People : %t\n", implements)
}
// 输出: 变量user是否实现接口People : false

4.5、通过反射设置变量的值

想要在函数中通过反射修改变量的值，需要注意函数参数传递的是值拷贝，必须传递变量地址才能修改变量值。而 反射中使用专有的 Elem() 方法来获取指针对应的值。

func reflectSetValue1(x interface{}) {
	v := reflect.ValueOf(x)
	if v.Kind() == reflect.Int64 {
		v.SetInt(200) //修改的是副本，reflect包会引发panic
	}
}

func reflectSetValue2(x interface{}) {
	v := reflect.ValueOf(x)
	// 反射中使用 Elem()方法获取指针对应的值
	if v.Elem().Kind() == reflect.Int64 {
		v.Elem().SetInt(200)
	}
}

func main() {
	var a int64 = 100
	// reflectSetValue1(a) //panic: reflect: reflect.Value.SetInt using unaddressable value
	reflectSetValue2(&a)
	fmt.Println(a)
}