Go-26 Go语言中的反射
// Go语言中的反射
/*
相关概念如下:
一、反射的引子
有时我们需要写一个函数,这个函数有能力统一处理各种值类型,而这些类型可能无法共享同一个接口,也可能布局未知,也有可能这个类型在我们设计函数时还不存在,
这个时候我们就可以用到反射。
1.1、空接口可以存储任意类型的变量,那我们如何知道这个空接口保存数据的类型是什么?值是什么呢?
·可以使用类型断言
·可以使用反射实现,也就是在程序运行时动态的获取一个变量的类型信息和值信息
1.2、把结构体序列化成json字符串,自定义结构体Tag标签的时候就用到了反射
package main
import (
"encoding/json"
"fmt"
)
type Student struct{
ID int `json:"id"`
Gender string `json:"gender"`
Name string `json:"name"`
Sno string `json:"sno"`
}
func main(){
var s1 = Student{
ID: 1,
Gender: "男",
Name: "李四",
Sno: "s0001",
}
var s,_ = json.Marshal(s1)
jsonStr := string(s)
fmt.Println(jsonStr)
}
1.3、后期我们会给大家讲ORM框架,这个ORM框架就用到了反射技术
ORM:对象关系映射是通过使用描述对象和数据库之间映射的元数据,将面向对象语言程序中的对象自动持久化到关系数据库中。
二、反射的基本介绍
反射是指在程序运行期间对程序本身进行访问和修改的能力。正常情况程序在编译时,变量被转换为内存地址,变量名不会被编译器写入到可执行部分。在运行程序时,
程序无法获取自身的信息。支持反射的语言可以在程序编译期将变量的反射信息,如字段名称、类型信息、结构体信息等整合到可执行文件中,并给程序提供接口访问
反射信息,这样就可以在程序运行期获取类型的反射信息,并且有能力修改它们。
Golang中反射可以实现以下功能:
·反射可以在程序运行期间动态的获取变量的各种信息,比如变量的类型和类别
·如果是结构体,通过反射还可以获取结构体本身的信息,比如结构体的字段、结构体的方法、结构体的tag
·通过反射,可以修改变量的值,可以调用关联的方法
Go语言中的变量是分为两部分的:
·类型信息:预先定义好的元信息。
·值信息:程序运行过程中可动态变化的。
在Golang的反射机制中,任何接口值都是由一个具体类型和具体类型的值两部分组成的。
在Golang中,反射的相关功能是由reflect包提供,任意接口值在反射中都可以理解为由reflect.Type和reflect.Value两部分组成,并且reflect包提供了
reflect.TypeOf和reflect.ValueOf两个重要函数来获取任意对象的Value和Type。
三、reflect.TypeOf()获取任意值的类型对象
在Go语言中,使用reflect.TypeOf()函数可以接受任意interface{}参数,可以获得任意值的类型对象reflect.Type,程序通过类型对象可以访问任意值的类型信息。
package main
import (
"fmt"
"reflect"
)
func reflectType(x interface{}){
v := reflect.TypeOf(x)
fmt.Printf("type:%v \n", v)
}
func main(){
var a float32=12.5
reflectType(a) // type:float32
var b int64=100
reflectType(b) // type:int64
}
type Name 和 type Kind
在反射中关于类型还划分为两种:类型Type和种类Kind。因为在Go语言中我们可以使用Type关键字构造很多自定义类型,而种类Kind就是指底层的类型,但是
在反射中,当需要区分指针、结构体等大品种的类型时,就会用到种类Kind。举个例子,我们定义了两个指针类型和两个结构体类型,通过反射查看它们的类型和种类。
Go语言的反射中像数组、切片、Map、指针等类型的变量,它们的.Name()都是返回空。
package main
import (
"fmt"
"reflect"
)
func reflectType(x interface{}){
t := reflect.TypeOf(x)
fmt.Printf("TypeOf:%v Name:%v Kind:%v \n", t,t.Name(),t.Kind())
}
type myInt int64
type Person struct {
Name string
Age int
}
type Animal struct {
Name string
}
func main(){
var a *float32 // 指针
var b myInt // 自定义类型
var c rune // 类型别名
reflectType(a) // type:kind:ptr
reflectType(b) // type:myInt kind:int64
reflectType(c) // type:int32 kind:int32
var d = Person {
Name:"itying",
Age:18,
}
var e = Animal{Name:"小花"}
reflectType(d) // type:Person kind:struct
reflectType(e) // type:Animal kind:struct
var f = []int{1,2,3,4,5}
reflectType(f) // type:[]int Name: kind:slice
}
在reflect包中定义的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 // 底层指针
)
四、reflect.ValueOf()
reflect.ValueOf()返回的时reflect.Value类型,其中包含了原有值的值信息。reflect.Value与原始值之间可以相互转换。
reflect.Value 类型提供的获取原始值的方法如下:
方法 ----------------------说明----------------------
Interface()
interface{} 这两者将值以interface{}类型返回,可以通过类型断言转换为指定类型
Int() int64 将值以int类型返回,所有有符号整形均可以此方式返回
Uint() uint64 将值以uint类型返回,所有无符号整型都可以此方式返回
Float() float64 将值以双精度float64类型返回,所有浮点数float32、float64均可以此方式返回
Bool() bool 将值以bool类型返回
Bytes() []bytes 将值以字节数组[]bytes类型返回
String() string 将值以字符串类型返回
... ...
4.1、通过反射获取原始值演示1
package main
import (
"fmt"
"reflect"
)
func reflectValue(x interface{}){
v := reflect.ValueOf(x)
var c = v.Int() + 6 // 通过 v.Int() 获取反射的原始值
fmt.Println(c) // 106
}
func main(){
var a int64 = 100
reflectValue(a)
}
4.2、通过反射获取原始值演示2
package main
import (
"fmt"
"reflect"
)
func reflectValue(x interface{}){
v := reflect.ValueOf(x)
k := v.Kind()
switch k {
case reflect.Int64:
// v.Int()从反射中获取整型的原始值
fmt.Printf("type is int64, value is %d \n", v.Int())
case reflect.Float32:
// v.Float()从反射中获取浮点型的原始值
fmt.Printf("type is float32, value is %f \n", v.Float())
case reflect.Float64:
// v.Float()从反射中获取浮点型的原始值
fmt.Printf("type is float64,value is %f \n", 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
}
4.3、通过反射设置变量的值
想要在函数中通过反射修改变量的值,需要注意函数参数传递的是值拷贝,必须传递变量地址才能修改变量值。而反射中使用专有的Elem()方法来获取指针对应的值。
package main
import (
"fmt"
"reflect"
)
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:relect:reflect.Value.SetInt using unaddressable value
reflectSetValue2(&a)
fmt.Println(a) // 最后a的值重新设置成了200
}
五、结构体反射
5.1、与结构体相关的方法
任意值通过reflect.TypeOf()获得反射对象信息后,如果它的类型是结构体,可以通过反射值对象reflect.Type的NumField()方法获得结构体成员的详细信息。
reflect.Type 中与获取结构体成员相关的方法如下表所示。
方法 ----------------------说明----------------------
Field(i int) StructField 根据索引,返回索引对应的结构体字段的信息
NumField() int 返回结构体成员字段数量
FieldByName(name string)(StructField,bool) 根据给定字符串返回字符串对应的结构体字段的信息
FieldByIndex(index []int)StructField 多层成员访问时,根据[]int提供的每个结构体的字段索引,返回字段的信息
FieldByNameFunc(match func(string) bool) (StructField,bool) 根据传入的匹配函数匹配需要的字段
NumMethod() int 返回该类型的方法集中方法的数目
Method(int) Method 返回该类型方法计中的第i个方法
MethodByName(string)(Method,bool) 根据方法名返回该类型方法集中的方法
5.2、StructField类型
StructField类型用来描述结构体中的一个字段的信息。StructField的定义如下:
type StructField struct {
// 参见http://golang.org/ref/spec#Uniqueness_of_identifiers
Name string // Name 是字段的名字
PkgPath string // PkgPath 是非导出字段的包路径,对导出字段该字段为“”
Type Type // 字段的类型
Tag StructTag // 字段的标签
Offset uintptr // 字段在结构体中的字节偏移量
Index []int // 用于Type.FieldByIndex 时的索引切片
Anonymous bool // 是否匿名字段
}
5.3、结构体反射示例
当我们使用反射得到一个结构体数据之后,可以通过索引依次获取其字段的信息,也可以通过字段名去获取指定的字段信息。
5.3.1、获取结构体属性,获取执行结构体的方法
package main
import (
"fmt"
"reflect"
)
// student 结构体
type Student struct {
Name string `json:"name"`
Age int `json:"age"`
Score int `json:"score"`
}
func (s Student) GetInfo() string {
var str = fmt.Sprintf("姓名:%v 年龄:%v 成绩:%v", s.Name, s.Age, s.Score)
fmt.Println(str)
return str
}
func (s *Student) SetInfo(name string, age int, score int){
s.Name = name
s.Age = age
s.Score = score
}
func (s *Student) Print(){
fmt.Println("结构体的打印方法...")
}
// 打印字段
func PrintStructField(s interface{}){
t := reflect.TypeOf(s)
// v := reflect.ValueOf(s)
kind := t.Kind()
if t.Kind() != reflect.Struct && t.Elem().Kind != reflect.Struct {
fmt.Println("传入的不是结构体")
return
}
// 1.通过类型变量里面的Field可以获取结构体的字段
field0 := t.Field(0)
fmt.Println(field0.Name)
fmt.Println(field0.Type)
fmt.Println(field0.Tag.Get("json"))
// 2.通过类型变量里面的FieldByName可以获取结构体的字段
field1,_ := t.FieldByName("Age")
fmt.Println(field1.Name)
fmt.Println(field1.Type)
fmt.Println(field1.Tag.Get("json"))
// 3.获取到该结构体有几个字段
num := t.NumField()
fmt.Println("字段数量:", num)
}
// 方法
func PrintStructFn(s interface{}){
t := reflect.TypeOf(s)
v := reflect.ValueOf(s)
if t.Kind() != reflect.Struct && t.Elem().Kind() != reflect.Struct {
fmt.Println("传入的不是结构体")
return
}
// 1.通过类型变量里面的Method可以获取结构体的方法
var tMethod = t.Method(0) // 注意
fmt.Println(tMethod.Name)
fmt.Println(tMethod.Type)
// 2.通过类型变量获取这个结构体有多少个方法
fmt.Println(t.NumMethod())
// 3.执行方法(注意需要使用值变量,并且要注意参数)
// v.Method(0).Call(nil)
v.MethodByName("Print").Call(nil)
// 4.执行方法传入参数(注意需要使用值变量,并且要注意参数)
var params []reflect.Value // 声明了 []reflect.Value
params = append(params, reflect.ValueOf("张三"))
params = append(params, reflect.ValueOf(22))
params = append(params, reflect.ValueOf(100))
v.MethodByName("SetInfo").Call(params) // 传入的参数是[]reflect.Value,返回[]reflect.Value
// 5.执行方法获取方法的值
info := v.MethodByName("GetInfo").Call(nil)
fmt.Println(info)
}
func main(){
stu1 := Student{
Name: "小明",
Age: 15,
Score: 98,
}
// PrintStructField(stu1)
PrintStructFn(&stu1)
}
5.3.2、修改结构体方法
package main
import (
"fmt"
"reflect"
)
// student 结构体
type Student struct {
Name string `json:"name"`
Age int `json:"age"`
Score int `json:"score"`
}
func (s Student) GetInfo() string {
var str = fmt.Sprintf("姓名:%v 年龄:%v 成绩:%v", s.Name, s.Age, s.Score)
return str
}
// 反射修改结构体属性
func reflectChangeStruct(s interface{}){
t := reflect.TypeOf(s)
v := reflect.ValueOf(s)
if t.Elem().Kind() != reflect.Struct {
fmt.Println("传入的不是结构体指针类型")
return
}
name := v.Elem().FieldByName("Name")
name.SetString("李四") // 设置值
age := v.Elem().FieldByName("Age")
age.SetInt(20) // 设置值
}
func main(){
stu1 := Student{
Name: "小明",
Age: 15,
Score: 98,
}
reflectChangeStruct(&stu1)
fmt.Println(stu1.GetInfo())
}
六、不要乱用反射
反射是一个强大并富有表现力的工具,能让我们写出更灵活的代码。但是反射不应该被滥用,原因有以下两个。
1.基于反射的代码是极其脆弱的,反射中的类型错误会在真正运行的时候才会引发panic,那很可能是在代码写完的很长时间之后了。
2.大量使用反射的代码通常难以理解。
end
*/
package main
import (
"fmt"
"reflect"
)
//func main() {
// var c rune
// reflect.TypeOf(c)
//
//}
func reflectValue(x interface{}) {
v := reflect.ValueOf(x)
k := v.Kind()
switch k {
case reflect.Int64:
// v.Int()从反射中获取整型的原始值
fmt.Printf("type is int64, value is %d \n", v.Int())
case reflect.Float32:
// v.Float()从反射中获取浮点型的原始值
fmt.Printf("type is float32, value is %f \n", v.Float())
case reflect.Float64:
// v.Float()从反射中获取浮点型的原始值
fmt.Printf("type is float64,value is %f \n", 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
}