第十九章:Go语言反射
2016 年 5 月 6 日
golang-gopher.png
1. 概述
Go语言提供了一种机制，能够在运行时更新变量和检查它们的值、调用它们的方法和它们支持的内在操作，而不需要在编译时就知道这些变量的具体类型。这种机制被称为反射。反射也可以让我们将类型本身作为第一类的值类型处理。
2. 反射类型对象
使用 reflect.TypeOf() 函数获取任意变量的类型对象 reflect.Type
**函数的源码如下 : **
// TypeOf returns the reflection Type that represents the dynamic type of i.
// If i is a nil interface value, TypeOf returns nil.
func TypeOf(i interface{}) Type {
eface := *(*emptyInterface)(unsafe.Pointer(&i))
return toType(eface.typ)
}
通过获取的类型对象就能访问原变量的类型信息
在类型信息中我们需要知道 类型(Type) 和 种类(Kind) 的区别
类型 Type : 通常指的是系统中的原生数据类型和使用 type 关键字定义的类型,通过类型对象 reflect.Type 中的 Name() 方法获取
种类Kind : 指定的对象的根本种类,是更高一层的概括,通过 reflect.Type 中的 Kind() 函数获取
- Type的值和Kind的值可能相同,也可能不相同
package main
import (
"fmt"
"reflect"
)
type char string
type dogs struct {
}
func main() {
var c char
Str := "golang go.."
// 获取C的类型对象
TypeOfC := reflect.TypeOf(c)
// Name() 获取类型
// Kind() 获取种类
fmt.Println("Type = ", TypeOfC.Name(), "Kind = ", TypeOfC.Kind()) // Type = char Kind = string
Golden := dogs{}
TypeOfGolden := reflect.TypeOf(Golden)
fmt.Println("Type = ", TypeOfGolden.Name(), "Kind = ", TypeOfGolden.Kind()) // Type = char Kind = string
TypeOfStr := reflect.TypeOf(Str)
fmt.Println("Type = ", TypeOfStr.Name(), "Kind = ", TypeOfStr.Kind()) //Type = string Kind = string
huntaway := &dogs{} // 指针变量
TypeOfHuntaway := reflect.TypeOf(huntaway)
// Go语言中所有的指针变量种类都是 `ptr`
// 指针变量的类型是此时是空
fmt.Println("Type = ", TypeOfHuntaway.Name(), "Kind = ", TypeOfHuntaway.Kind()) // Type = Kind = ptr
// 对指针获取反射对象时,可以通过 reflect.Elem() 方法获取这个指针指向的元素类
TypeOfHuntaway = TypeOfHuntaway.Elem()
fmt.Println("Type = ", TypeOfHuntaway.Name(), "Kind = ", TypeOfHuntaway.Kind()) // Type = dogs Kind = struct
}
go run main.go
Type = char Kind = string Type = dogs Kind = struct Type = string Kind = string Type = Kind = ptr Type = dogs Kind = struct
当一个变量是结构体实例的时候,怎么通过反射获取类型信息呢?
通过reflect 包中 reflect.type 的 Field() FieldByIndex FieldByName FieldByNameFunc 方法获取的 StructField 结构体有些什么内容呢?
// A StructField describes a single field in a struct.
type StructField struct {
// Name is the field name.
Name string
// PkgPath is the package path that qualifies a lower case (unexported)
// field name. It is empty for upper case (exported) field names.
// See https://golang.org/ref/spec#Uniqueness_of_identifiers
PkgPath string
Type Type // field type
Tag StructTag // field tag string
Offset uintptr // offset within struct, in bytes
Index []int // index sequence for Type.FieldByIndex
Anonymous bool // is an embedded field
}
package main
import (
"fmt"
"reflect"
)
type dogs struct {
Name string `json:"name"`
Age int8
T int `json:"t" id:"99"`
}
func main(){
// 创建实例
Hachiko := dogs{Name:"Hachiko",Age:int8(2),T:66}
//获取反射对象实例
typeD := reflect.TypeOf(Hachiko)
// NumField()函数,返回结构体成员的数量
for i:=0;i<typeD.NumField();i++{
// 获取结构体成员的类型
// Field()函数 根据索引返回结构体对应field的信息
typeOfField := typeD.Field(i)
// 输出成员字段名称和tag(标签信息),成员类型
fmt.Printf("%s , %v,%s\n",typeOfField.Name,typeOfField.Tag,typeOfField.Type)
}
// 通过结构体字段名获取其类型信息
// FieldByName()函数,根据字段名返回字段信息
if fieldType,ok := typeD.FieldByName("T");ok{
fmt.Println(fieldType.Tag.Get("json"),fieldType.Tag.Get("id"))
}
}
go run main.go
Name , json:"name",string Age , ,int8 T , json:"t" id:"99",int t 99
3. 反射的值对象
反射可以动态的获取或者设置变量的值
Go语言中使用 reflect.Value 获取和设置变量的值
package main
import (
"fmt"
"reflect"
)
func main() {
var a int = 99
fmt.Printf("a ==> %T,%v\n", a, a)
// 使用reflect.ValueOf()函数获取反射值对象
valueOfA := reflect.ValueOf(a)
// 获取的反射值对象,再通过值对象的Interface()方法获取原值
var b int = valueOfA.Interface().(int)
fmt.Printf("b ==> %T,%v\n", b, b)
// 反射对象的Int()方法获取int64类型值,然后强制转换成int32位
var c int32 = int32(valueOfA.Int())
fmt.Printf("c ==> %T,%v\n", c, c)
}
go run main.go
a ==> int,99 b ==> int,99 c ==> int32,99
package main
import (
"fmt"
"reflect"
)
type demo struct {
a int
b string
c bool
float64
d [5]int
}
func (d *demo) dF1() {
fmt.Println(d.a)
}
func (d *demo) dF2() {
fmt.Println(d.b)
}
func main() {
t := demo{99, "golang", true, 98.90, [5]int{1, 2, 3, 5, 6}}
// 获取值对象
valueOfT := reflect.ValueOf(t)
// NumField()是获取字段数量
fmt.Println(valueOfT.NumField()) // 5
// 获取索引为1的字段
fieldOf1 := valueOfT.Field(1)
// 打印该值对象的类型
fmt.Println(fieldOf1.Type()) // string
// 通过字段名查找
fieldOfd := valueOfT.FieldByName("d")
fmt.Println(fieldOfd.Type()) // [5]int
}
go run main.go
5 string [5]int
4. 反射修改值
reflect.Value 也提供了修改版值的方法
package main
import (
"fmt"
"reflect"
)
func main() {
var age int8 = 99
// 获取一个值对象
valueOfAge := reflect.ValueOf(&age)
// Elem() 对可寻值的元素获取它的值
// Addr() 对可寻址的元素获取它地址
// CanSet() bool 返回元素(值对象)是否能被设置
// CanAddr() bool 返回元素(值对象)是否能被寻址
valueOfAge = valueOfAge.Elem()
valueOfAgeAddr := valueOfAge.Addr()
fmt.Println(valueOfAge) // 99
fmt.Println(valueOfAgeAddr) // 0xc000054080
fmt.Println(valueOfAge.CanSet()) // true
fmt.Println(valueOfAge.CanAddr()) // true
// SetInt() 使用int64设置值
// SetUint() 使用uint64设置值
// SetFloat() 使用float64设置值
// SetBool() 使用bool设置值
// SetBytes() 设置字节数组[]bytes值
// SetString 设置字符串值
valueOfAge.SetInt(1)
fmt.Printf("age type= %T, value= %v",age,age)
}
go run main.go
99 0xc000054080 true true age type= int8, value= 15
通过类型创建类型实例
package main
import (
"fmt"
"reflect"
)
func main(){
var i int = 99
// 获取反射类型对象
typeOfI := reflect.TypeOf(i)
// 根据反射类型对象创建类型实例
newI := reflect.New(typeOfI)
// 答应类型和种类
fmt.Println(newI.Type(),newI.Kind()) //*int ptr
}
5. 综合Demo
package main
import (
"fmt"
"log"
"reflect"
)
type Person struct {
Name string `json:"name"`
Age int `json:"age"`
Sex string `json:"sex"`
}
func (p Person) PersonSet(name string,age int,sex string){
p.Name = name
p.Age = age
p.Sex = sex
fmt.Println(p)
}
func (p Person) ShowPerson(){
fmt.Println(p)
}
func reflectOfStruct(a interface{}){
// 获取reflect.Type类型
typeObj := reflect.TypeOf(a)
// 获取reflect.Value类型
valueObj := reflect.ValueOf(a)
// 获取Kind类别,下面两种方法都能获取
KindType := typeObj.Kind()
//KindValue := valueObj.Kind()
//fmt.Println(KindType)
//fmt.Println(KindValue)
if KindType != reflect.Struct{
log.Fatal("Kind is not error")
return
}
// 获取字段数量
fieldsNum := valueObj.NumField()
for i:=0;i<fieldsNum;i++{
fmt.Printf("field %d %v\n",i,valueObj.Field(i))
// 获取指定的标签值
tagValue := typeObj.Field(i).Tag.Get("json")
if tagValue != ""{
fmt.Printf("field %d tag = %v\n",i,tagValue)
}
}
// 获取方法数量
MethodNum := valueObj.NumMethod()
fmt.Printf("has %d methods\n",MethodNum)
// 调用第一个方法
valueObj.Method(1).Call(nil)
// 对有参数的方法调用
var params []reflect.Value
params = append(params,reflect.ValueOf("lisi"))
params = append(params,reflect.ValueOf(88))
params = append(params,reflect.ValueOf("man"))
// 传递参数,调用指定方法名的方法
valueObj.MethodByName("PersonSet").Call(params)
}
func main() {
var a Person = Person{
Name:"zhangsan",
Age:99,
}
// 调用函数
reflectOfStruct(a)
}
go run main.go
field 0 zhangsan
field 0 tag = name
field 1 99
field 1 tag = age
field 2
field 2 tag = sex
has 2 methods
{zhangsan 99 }
{lisi 88 man}
About The Author
