13 反射 reflect

[TOC]

反射 reflect

Go是静态语言，但是通过反射可以获得一定的动态特性。

• Go在运行时通过方法名要动态调用方法或者动态解析结构体等都要通过反射，反射让静态语言具有一定的动态特性。

• 反射作为框架或者基础服务的一部分是必不可少的。

反射三定律

• 反射可以从接口值得到反射对象。

• 反射可以从反射对象获得接口值。

• 若要修改一个反射对象，则其值必须是可以修改的。

reflect 标准库

Go反射的基础是编译器和运行时把类型信息以合适的数据结构保存在可执行程序中。

• Go反射建立在Go类型系统基础之上，和接口有紧密的关系。

• reflect标准库提供了一套访问接口，所有反射操作都基于reflect标准库。

反射的两种基本类型

• reflect.Value 类型 通过 reflect.ValueOf(i inteface{}) Value

• reflect.Type 类型 通过 reflect.TypeOf(i inteface{}) Type

• ValueOf()和TypeOf()的形参都是inteface{}，内存存储了即将被反射的变量，因此反射和接口之间存在很强的联系。

实例的值 reflect.Value

reflect.Value 实例通过 reflect.ValueOf() 函数获得

• reflect.Value 表示的是实例的值信息，它本身是个struct，并绑定一系列的方法操作实例。

type Value struct {
	typ *rtype  // 指向类型的指针
	ptr unsafe.Pointer  // 指向值的指针
	flag    // 标记字段
}

reflect.Value 常用方法

NumField() int

• 获得结构体字段数量 int

NumMethod() int

• 获得实例方法数量 int

MethodByName(name string) Value

• 根据方法名称 name 获取方法 Value

Method(i int) Value

• 根据方法索引 i 获得方法 Value

Elem() Type

• 间接访问，在反射实例是指针情况下使用获得指针指向的具体数据，如果反射的实例不是指针进行Elem()后再操作数据会panic，如果反射的实例是指针不进行Elem()后再操作数据也会panic。

Type() Type

• 获取反射实例的Type。

...

• 更多方法，标准库文档 https://studygolang.com/pkgdoc reflect标准库

通过空接口类型断言获得具体的值

reflect.Value中的interface()方法以空接口的形式返回reflect.Value中的值，要获取空接口真实的值可以通过类型断言对接口进行转换

func main() {
	num := 999
	numVal := reflect.ValueOf(num)
	numValPtr := reflect.ValueOf(&num)
	fmt.Println(numVal.Interface().(int))	// 999
	fmt.Println(numValPtr.Interface().(*int))	// 0xc00000a0a8
}

通过reflect.Value绑定的方法获得具体的值

法获得具体类型的基础数据类型方法String()、Bool()、Int()、UInt()、Float()...，获得具体类型的时候同一类别下会进行统一转换，如int8、int16、int32在调用Int()方法转为具体类型时得到的都是int64

• 转换的类型与实际类型不相符会出现panic

func main() {
	num := 999
	flo := 88.99
	boo := true
	str := "字符串"
	numVal := reflect.ValueOf(num)
	floVal := reflect.ValueOf(flo)
	booVal := reflect.ValueOf(boo)
	strVal := reflect.ValueOf(str)

	fmt.Printf("t=%T,v=%d\n",numVal.Int(),numVal.Int())	// t=int64,v=999
	fmt.Printf("t=%T,v=%f\n",floVal.Float(),floVal.Float())	// t=float64,v=88.990000
	fmt.Printf("t=%T,v=%v\n",booVal.Bool(),booVal.Bool())	// t=bool,v=true
	fmt.Printf("t=%T,v=%s\n",strVal.String(),strVal.String()) // t=string,v=字符串

	// 转换的类型与实际类型不相符会出现panic
	fmt.Println(numVal.Float())	// panic: reflect: call of reflect.Value.Float on int Value
}

间接访问 Elem() 和Indirect(v Value) Value

反射的是指针，就需要使用Elem()方法获得指针或接口执行的数据再进行访问。如果不是指针就不需要使用Elem()后再进行访问否则会panic。

• 还有一个替代函数，reflect.Indirect(v Value) Value 函数，如果v是指针则返回指针指向的数据Value，如果v不是指针也不会出现panic依然返回v自身。

反射指针

• numValPtr是num指针的反射实例，直接调用numValPtr.Int()获得值会触发panic，需要使用Elem()进行间接访问

func main() {
	num := 999
	numValPtr := reflect.ValueOf(&num)
	// 由于反射的是num的指针 numValPtr.Int() 访问会 panic: reflect: call of reflect.Value.Int on ptr Value
	//fmt.Println(numValPtr.Int())
	numValPtr.Elem().Set(reflect.ValueOf(8999))
	fmt.Println(num)	// 8999
	fmt.Println(numValPtr.Elem().Int())	// 8999
}

，reflect.Indirect(v Value) Value 源码

• 通过Kind进行判断是否指针以确定是否要Elem()，使用该函数可避免编码时再进行冗余的判断

func Indirect(v Value) Value {
	if v.Kind() != Ptr {
		return v
	}
	return v.Elem()
}

修改反射实例的值

修改反射的值有多个方法可以使用，但是只有反射的实例是指针时才能赋值，反射的实例是指针就需要通过 Elem() 间接访问才能访问到数据

• 通过 SetXXX() 方法修改值

• CanSet() 方法可以判断是否可以修改值

func main() {
	num := 999
	numVal := reflect.ValueOf(num)
	// 反射的不是指针修改值会产生panic: reflect: reflect.Value.Set using unaddressable value
	if numVal.CanSet() {	// numVal.CanSet() = false
		numVal.Set(reflect.ValueOf(8999))
	}

	numValPtr := reflect.ValueOf(&num)
	numValPtr.Elem().Set(reflect.ValueOf(8999))
	fmt.Println(num) // 8999
	numValPtr.Elem().SetInt(9999)
	fmt.Println(num) // 9999
}

实例的类型 reflect.Type

rtype是反射包中一个通用的描述类型公共信息的结构体。

• rtype实现了reflect.Type接口，通过reflect.TypeOf()函数获得反射实例的rtype，或者通过reflect.ValueOf().Type()获得。

type rtype struct {
	size       uintptr
	ptrdata    uintptr // number of bytes in the type that can contain pointers
	hash       uint32  // hash of type; avoids computation in hash tables
	tflag      tflag   // extra type information flags
	align      uint8   // alignment of variable with this type
	fieldAlign uint8   // alignment of struct field with this type
	kind       uint8   // enumeration for C
	// function for comparing objects of this type
	// (ptr to object A, ptr to object B) -> ==?
	equal     func(unsafe.Pointer, unsafe.Pointer) bool
	gcdata    *byte   // garbage collection data
	str       nameOff // string form
	ptrToThis typeOff // type for pointer to this type, may be zero
}

• reflect.TypeOf(num) 和 reflect.ValueOf(num).Type() 是相同的

func main() {
	num := 999
	numTyp := reflect.TypeOf(num)
	numVal := reflect.ValueOf(num)
	fmt.Println(numVal.Type() == numTyp) // true
}

reflect.Type 常用方法

reflect.Type 的方法分所有类型通用的方法和不同基础类型专有的方法。

类型通用方法

Name() string

• 获取包含包名的类型名字 string

Kind() Kind

• 获取该类型的底层基础类型 Kind

NumMethod() int

• 获取方法数量 int

Method(int) Method

• 通过索引 int 获取方法 Method

MethodByName(string) (Method,bool)

• 通过方法名获取方法 Method

New(typ Type) Value

• 根据 Type 创建一个实例， Value 是反射的实例指针

不同基础类型专用方法

• 如果调用别的类型专用的方法会出现panic，一般使用Kind()确定类型后再调用专用方法。

Elem() Type

• 获取实例的类型，Array、Chan、Map、Ptr、Slice类型专用。

NumField() int

• 获取字段数量 int，结构体专用。

Field(i int) StructField

• 通过索引 i 获取结构体字段，结构体专用。

FieldByName(name string) (StructField,bool)

• 通过字段名 name 获取结构体字段，结构体专用。

...

• 更多方法，标准库文档 https://studygolang.com/pkgdoc reflect标准库

基础类型 Kind

Kind是一个整数枚举值，不同的值代表不同的类型。

• Kind的类型是一个抽象的概念，是一个大的类别，比如所有结构体的类别是struct，函数的类别是func。类别是根据编译器、运行时构建类型的内部数据结构不同来划分的，不同类别其构建的最终内部数据结构不同。

type Kind uint

const (
	Invalid Kind = iota
	Bool
	Int
	Int8
	Int16
	Int32
	Int64
	Uint
	Uint8
	Uint16
	Uint32
	Uint64
	Uintptr
	Float32
	Float64
	Complex64
	Complex128
	Array
	Chan
	Func
	Interface
	Map
	Ptr
	Slice
	String
	Struct
	UnsafePointer
)

类别Kind和类型Type的区别

Kind 描述的是一个大的类别，Type描述的是一个具体的类型

• 基础数据类型int，Kind和Type都是int，但如果是自定义类型则Type是自定义类型的名称，Kind是自定义类型的类型。

• 如自定义类型struct TestKind，具体类型Type就是TestKind，而类别Kind是struct，同样是自定义类型的Integer也是如此。

type TestKind struct {
	Name string
}
type Integer int

func main() {
	num := 999
	numTyp := reflect.TypeOf(num)
	fmt.Println(numTyp.Name())	//  int
	fmt.Println(numTyp.Kind())	//  int

	tk := TestKind{"测试"}
	tkTyp := reflect.TypeOf(tk)
	fmt.Println(tkTyp.Name())	// TestKind
	fmt.Println(tkTyp.Kind())	// struct

	var i Integer = 88
	iTyp := reflect.TypeOf(i)
	fmt.Println(iTyp.Name())	// Integer
	fmt.Println(iTyp.Kind())	// int
}

结构体反射

反射在大部分情况下都是对结构体的操作，包括获得结构体字段、字段Tag、调用结构体方法。

定义案例用结构体：

• Animal 结构体定义一个字段Category string，绑定了一个Sleep()方法。

• Cat 结构体嵌套了Animal结构体，定义 Name string 字段， 并且定义了一个私有的 age int 字段。绑定一个Work(h int) int方法。

type Animal struct {
	Category string `json:"category" table:"category_animal"`
}
func (ani Animal) Sleep(){
	fmt.Println("睡觉")
}
type Cat struct {
	Ani Animal
	Name string	`json:"name" table:"name_cat"`
	age int	`json:"age" table:"age_cat"`
}
func (cat *Cat) Work(h int) int{
	fmt.Printf("%s工作%d小时,抓到%d只老鼠\n",cat.Name,h,10)
	return 10
}

反射获取结构体字段、字段Tag

反射中结构体字段信息在Type中，值在Value中，因此Type和Value都需要

• 字段信息通过Type获取

• 字段值通过Value获取

func main() {
	ani := Animal{"爬行动物"}
	aniVal := reflect.ValueOf(ani)
	aniType := aniVal.Type()
	// 遍历读取字段
	numF := aniType.NumField()
	for i:=0;i<numF;i++{
		// 读取字段信息通过Type
		fieTyp := aniType.Field(i)
		tagJson := fieTyp.Tag.Get("json")
		tagTable := fieTyp.Tag.Get("table")
		fmt.Printf("读取到%s字段的Tag,json=%s,table=%s \n",fieTyp.Name,tagJson,tagTable)
		// 读取字段值通过Value
		fieVal := aniVal.Field(i)
		fmt.Printf("%s字段的值=%s,字段类别=%s\n",fieTyp.Name,fieVal.String(),fieTyp.Type.Kind())
	}
	// 输出结果：
	//读取到Category字段的Tag,json=category,table=category_animal
	//Category字段的值=爬行动物,字段类型=string
}

嵌套结构体赋值

嵌套结构体3个注意事项

• 赋值注意1：赋值需要注意必须反射指针，不是指针不能赋值。

• 赋值注意2：结构体字段必须是公开的（首字母大写）才能被反射赋值，否则panic。

• 赋值注意3：被嵌套结构体的字段也是不可直接读取，需要使用被嵌套结构体的变量来读取。

func main() {
	// 要赋值则必须反射指针
	catVal := reflect.Indirect(reflect.ValueOf(&Cat{}))
	catType := catVal.Type()
	// 遍历读取字段
	numF := catType.NumField()
	for i:=0;i<numF;i++{
		// 读取字段信息通过Type
		fieTyp := catType.Field(i)
		tagJson := fieTyp.Tag.Get("json")
		tagTable := fieTyp.Tag.Get("table")
		fmt.Printf("读取到%s字段的Tag,json=%s,table=%s \n",fieTyp.Name,tagJson,tagTable)
		// 修改字段通过Value
		fieVal := catVal.Field(i)
		fmt.Printf("\t %s字段的类型=%s,全类型=%s,字段类别=%s \n",fieTyp.Name,fieTyp.Type.Name(),fieVal.Type().String(),fieTyp.Type.Kind())
		if !fieVal.CanSet() {
			fmt.Printf("字段%s是不可通过反射赋值的\n",fieTyp.Name)
			continue
		}
		if "Animal" == fieTyp.Type.Name() {
			// 是嵌入结构体Animal
			fieVal.Set(reflect.ValueOf(Animal{"爬行动物"}))
		}else if "Name" == fieTyp.Name{
			fieVal.SetString("大白")
		}
	}
	fmt.Println("最终赋值结果：",catVal)
	//	输出结果：
	//读取到Ani字段的Tag,json=,table=
	//	Ani字段的类型=Animal,全类型=main.Animal,字段类别=struct
	//读取到Name字段的Tag,json=name,table=name_cat
	//	Name字段的类型=string,全类型=string,字段类别=string
	//读取到age字段的Tag,json=age,table=age_cat
	//	age字段的类型=int,全类型=int,字段类别=int
	//字段age是不可通过反射赋值的
	//最终赋值结果： {{爬行动物} 大白 0}
}

反射调用方法

动态调用方法使用 Call([]reflect.Value) []reflect.Value

• 方法的信息在Type中获取,但是方法名是获取不到的。

• 私有方法（首字母小写）反射获取不到也不能调用。

• 反射无法直接访问组合的方法。

• 调用方法也要使用指针调用，否则方法绑定的变量将是nil，反射调用方法时编译器无法优化调用传参时的方法绑定参数。

• 调用方法如果是通过方法编号调用，注意方法的编号是按照ASCII码表排序，序号从0开始。

func main() {
	cat := &Cat{Ani:Animal{"爬行动物"},Name:"大白",age: 999}
	catVal := reflect.ValueOf(cat)
	numMethod := catVal.NumMethod()
	fmt.Printf("有%d个方法\n",numMethod)
	for i:=0;i<numMethod;i++ {
		mVal := catVal.Method(i)
		mTyp := mVal.Type()
		fmt.Printf("方法名：%s,签名：%s,方法参数%d个,返回值%d个\n",mTyp.Name(),mTyp.String(),mTyp.NumIn(),mTyp.NumOut())
		inType := mTyp.In(0)
		fmt.Printf("方法第一个参数类型%s\n",inType.Name())
		outType := mTyp.Out(0)
		fmt.Printf("方法第一个返回值类型%s\n",outType.Name())
	}
	// 等同于 work.Call([]reflect.Value{reflect.ValueOf(8)})
	work := catVal.MethodByName("Work")
	params := make([]reflect.Value,1)
	params[0] = reflect.ValueOf(8)
	results := work.Call(params)
	fmt.Println("方法返回值：",results[0])
	//输出结果：
	//有1个方法
	//方法名：,签名：func(int) int,方法参数1个,返回值1个
	//方法第一个参数类型int
	//方法第一个返回值类型int
	//大白工作8小时,抓到10只老鼠
	//方法返回值： 10
}

反射调用组合的方法

反射是无法直接读取到被嵌套的结构体的方法的，需要拿到被嵌套结构体的变量才能访问被嵌套结构体的方法。

func main() {
	cat := &Cat{Ani:Animal{"爬行动物"},Name:"大白",age: 999}
	catVal := reflect.ValueOf(cat).Elem()
	aniVal := catVal.FieldByName("Ani")
	sleep := aniVal.MethodByName("Sleep")
	sleep.Call([]reflect.Value{})
	//输出结果：
	//	睡觉
}

案例中 Animal和Cat结构体的陷阱

在正常调用中自定义类型的方法绑定的是指针还是实例在调用时都可以通过指针或实例方式调用，这是编译器优化的结果。

• 但是在反射中，编译器是无法做出优化的，因此Animal结构体的 (ani Animal) Sleep() 方法是实例绑定在反射中只能实例调用，而Cat结构体的 (cat *Cat) Work(h int) int 方法是指针绑定只能指针调用。

• 如果将(ani Animal) Sleep()改为 (ani *Animal) Sleep() 则 【反射调用组合的方法】中的代码会panic，因为Cat结构体嵌入的是Ani Animal而不是Ani *Animal。

为了避免跳入这样的陷阱，编码中应该尽可能都采取一种绑定方法、一种嵌入方式。

• (ani *Animal) Sleep() 这样绑定 则 嵌入结构体都采用 Ani *Animal。

反射案例，根据Model生成一条sql插入语句

根据Model使用反射生成SQL增加一条数据语句

• 读取 Model 的 Tag.table，生成一条插入数据的sql语句

type UserSubjectModel struct {
	IdUser int64 `json:"idUser" table:"id_user" type:"BIGINT UNSIGNED" isNullable:"false" len:"20" unique:"true" comment:"search用户编号"`
	UsernameUser string `json:"usernameUser" table:"username_user" type:"VARCHAR" isNullable:"false" len:"20" unique:"true" comment:"search用户名"`
	PwdUser string `json:"pwdUser" table:"pwd_user" type:"VARCHAR" isNullable:"false" len:"32" unique:"false" comment:"密码"`
	EmailUser string `json:"emailUser" table:"email_user" type:"VARCHAR" isNullable:"true" len:"20" unique:"false" comment:"邮箱"`
}

func (user *UserSubjectModel) GetTableName() string {
	return "user_subject"
}

func createInsertSql(mo interface{}) (sql string,params []interface{}){
	moVal :=reflect.ValueOf(mo)
	tableName := moVal.MethodByName("GetTableName").Call([]reflect.Value{})[0].String()
	sql = fmt.Sprintf("INSERT INTO %s (",tableName)
	values := "VALUES("
	moVal = reflect.Indirect(moVal)
	moTyp := moVal.Type()
	params = make([]interface{},moTyp.NumField())
	for i:=0;i<moTyp.NumField();i++ {
		fieTyp := moTyp.Field(i)
		tagTable := fieTyp.Tag.Get("table")
		fieVal := moVal.Field(i)
		sql = fmt.Sprintf("%s %s",sql,tagTable)
		values = fmt.Sprintf("%s ? ",values)
		switch fieVal.Kind() {
		case reflect.Int,reflect.Int8,reflect.Int16,reflect.Int32,reflect.Int64:
			params[i] = fieVal.Int()
		case reflect.String:
			params[i] = fieVal.String()
		}
		if i != moTyp.NumField()-1 {
			values = fmt.Sprintf("%s,",values)
			sql = fmt.Sprintf("%s,",sql)
		}
	}
	sql = fmt.Sprintf("%s) %s)",sql,values)
	return
}

func main() {
	mo := UserSubjectModel{99,"老泥鳅","adsadsadsadsadsadas","[email protected]"}
	sql,params := createInsertSql(&mo)
	fmt.Println("生成的sql语句：",sql)
	fmt.Println("sql语句参数：",params)
	//输出结果：
	//生成的sql语句： INSERT INTO user_subject ( id_user, username_user, pwd_user, email_user) VALUES( ? , ? , ? , ? )
	//sql语句参数： [99 老泥鳅 adsadsadsadsadsadas [email protected]]
}