本文介绍了Go语言反射的意义和基本使用。

一、变量的内在机制

Go语言中的变量是分为两部分的:

  • 类型信息:预先定义好的元信息。
  • 值信息:程序运行过程中可动态变化的。

    二、反射介绍

    反射是指在程序运行期对程序本身进行访问和修改的能力。程序在编译时,变量被转换为内存地址,变量名不会被编译器写入到可执行部分。在运行程序时,程序无法获取自身的信息。
    支持反射的语言可以在程序编译期将变量的反射信息,如字段名称、类型信息、结构体信息等整合到可执行文件中,并给程序提供接口访问反射信息,这样就可以在程序运行期获取类型的反射信息,并且有能力修改它们。
    Go程序在运行期使用reflect包访问程序的反射信息。
    在上一篇博客中我们介绍了空接口。 空接口可以存储任意类型的变量,那我们如何知道这个空接口保存的数据是什么呢? 反射就是在运行时动态的获取一个变量的类型信息和值信息。

    三、reflect包

    在Go语言的反射机制中,任何接口值都由是一个具体类型具体类型的值两部分组成的(我们在上一篇接口的博客中有介绍相关概念)。 在Go语言中反射的相关功能由内置的reflect包提供,任意接口值在反射中都可以理解为由reflect.Typereflect.Value两部分组成,并且reflect包提供了reflect.TypeOfreflect.ValueOf两个函数来获取任意对象的Value和Type。

    1. TypeOf

    在Go语言中,使用reflect.TypeOf()函数可以获得任意值的类型对象(reflect.Type),程序通过类型对象可以访问任意值的类型信息。
    1. package main
    2. import (
    3. "fmt"
    4. "reflect"
    5. )
    6. func reflectType(x interface{}) {
    7. v := reflect.TypeOf(x)
    8. fmt.Printf("type:%v\n", v)
    9. }
    10. func main() {
    11. var a float32 = 3.14
    12. reflectType(a) // type:float32
    13. var b int64 = 100
    14. reflectType(b) // type:int64
    15. }

    1.1 type name和type kind

    在反射中关于类型还划分为两种:类型(Type)种类(Kind)。因为在Go语言中我们可以使用type关键字构造很多自定义类型,而种类(Kind)就是指底层的类型,但在反射中,当需要区分指针、结构体等大品种的类型时,就会用到种类(Kind)。 举个例子,我们定义了两个指针类型和两个结构体类型,通过反射查看它们的类型和种类。
  1. package main
  2. import (
  3. "fmt"
  4. "reflect"
  5. )
  6. type myInt int64
  7. func reflectType(x interface{}) {
  8. t := reflect.TypeOf(x)
  9. // 比如:Cat的结构体的name是Cat,kind是struct
  10. fmt.Printf("type:%v kind:%v\n", t.Name(), t.Kind())
  11. }
  12. func main() {
  13. var a *float32 // 指针
  14. var b myInt // 自定义类型
  15. var c rune // 类型别名
  16. reflectType(a) // type: kind:ptr
  17. reflectType(b) // type:myInt kind:int64
  18. reflectType(c) // type:int32 kind:int32
  19. type person struct {
  20. name string
  21. age int
  22. }
  23. type book struct{ title string }
  24. var d = person{
  25. name: "沙河小王子",
  26. age: 18,
  27. }
  28. var e = book{title: "《跟小王子学Go语言》"}
  29. reflectType(d) // type:person kind:struct
  30. reflectType(e) // type:book kind:struct
  31. }

Go语言的反射中像数组、切片、Map、指针等类型的变量,它们的.Name()都是返回
reflect包中定义的Kind类型如下:

  1. type Kind uint
  2. const (
  3. Invalid Kind = iota // 非法类型
  4. Bool // 布尔型
  5. Int // 有符号整型
  6. Int8 // 有符号8位整型
  7. Int16 // 有符号16位整型
  8. Int32 // 有符号32位整型
  9. Int64 // 有符号64位整型
  10. Uint // 无符号整型
  11. Uint8 // 无符号8位整型
  12. Uint16 // 无符号16位整型
  13. Uint32 // 无符号32位整型
  14. Uint64 // 无符号64位整型
  15. Uintptr // 指针
  16. Float32 // 单精度浮点数
  17. Float64 // 双精度浮点数
  18. Complex64 // 64位复数类型
  19. Complex128 // 128位复数类型
  20. Array // 数组
  21. Chan // 通道
  22. Func // 函数
  23. Interface // 接口
  24. Map // 映射
  25. Ptr // 指针
  26. Slice // 切片
  27. String // 字符串
  28. Struct // 结构体
  29. UnsafePointer // 底层指针:直接对指针进行操作(不安全)
  30. )

2. 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 将值以字符串类型返回

2.1 通过反射获取值

  1. func reflectValue(x interface{}) {
  2. v := reflect.ValueOf(x)
  3. k := v.Kind()// 得到值的种类
  4. switch k {
  5. case reflect.Int64:
  6. // v.Int()从反射中获取整型的原始值,然后通过int64()强制类型转换
  7. fmt.Printf("type is int64, value is %d\n", int64(v.Int()))
  8. case reflect.Float32:
  9. // v.Float()从反射中获取浮点型的原始值,然后通过float32()强制类型转换
  10. fmt.Printf("type is float32, value is %f\n", float32(v.Float()))
  11. case reflect.Float64:
  12. // v.Float()从反射中获取浮点型的原始值,然后通过float64()强制类型转换
  13. fmt.Printf("type is float64, value is %f\n", float64(v.Float()))
  14. }
  15. }
  16. func main() {
  17. var a float32 = 3.14
  18. var b int64 = 100
  19. reflectValue(a) // type is float32, value is 3.140000
  20. reflectValue(b) // type is int64, value is 100
  21. // 将int类型的原始值转换为reflect.Value类型
  22. c := reflect.ValueOf(10)
  23. fmt.Printf("type c :%T\n", c) // type c :reflect.Value
  24. }

2.2 通过反射设置变量的值

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

  1. package main
  2. import (
  3. "fmt"
  4. "reflect"
  5. )
  6. // 通过反射设置变量的值:会报错,应该传指针才能修改
  7. func reflectSetValue1(x interface{}) {
  8. v := reflect.ValueOf(x)
  9. if v.Kind() == reflect.Int64 {
  10. v.SetInt(200) //修改的是副本,reflect包会引发panic
  11. }
  12. }
  13. // 通过反射设置变量的值:传了指针,通过Elem方法找到对应的值进行修改
  14. func reflectSetValue2(x interface{}) {
  15. v := reflect.ValueOf(x)
  16. // 反射中使用 Elem()方法获取指针对应的值
  17. if v.Elem().Kind() == reflect.Int64 {
  18. v.Elem().SetInt(200)
  19. }
  20. }
  21. func main() {
  22. var a int64 = 100
  23. // reflectSetValue1(a) //panic: reflect: reflect.Value.SetInt using unaddressable value
  24. reflectSetValue2(&a)
  25. fmt.Println(a)
  26. }

2.3 isNil()和isValid()

isNil()

  1. func (v Value) IsNil() bool

IsNil()报告v持有的值是否为nil。v持有的值的分类必须是通道、函数、接口、映射、指针、切片之一;否则IsNil函数会导致panic。

isValid()

  1. func (v Value) IsValid() bool

IsValid()返回v是否持有一个值。如果v是Value零值会返回假,此时v除了IsValid、String、Kind之外的方法都会导致panic。

举个例子

IsNil()常被用于判断指针是否为空;IsValid()常被用于判定返回值是否有效。

  1. func main() {
  2. // *int类型空指针
  3. var a *int
  4. fmt.Println("var a *int IsNil:", reflect.ValueOf(a).IsNil())
  5. // nil值
  6. fmt.Println("nil IsValid:", reflect.ValueOf(nil).IsValid())
  7. // 实例化一个匿名结构体
  8. b := struct{}{}
  9. // 尝试从结构体中查找"abc"字段
  10. fmt.Println("不存在的结构体成员:", reflect.ValueOf(b).FieldByName("abc").IsValid())
  11. // 尝试从结构体中查找"abc"方法
  12. fmt.Println("不存在的结构体方法:", reflect.ValueOf(b).MethodByName("abc").IsValid())
  13. // map
  14. c := map[string]int{}
  15. // 尝试从map中查找一个不存在的键
  16. fmt.Println("map中不存在的键:", reflect.ValueOf(c).MapIndex(reflect.ValueOf("娜扎")).IsValid())
  17. }

四、结构体反射(json包序列化和反序列化也是使用这个实现的)

1. 与结构体相关的方法

任意值通过reflect.TypeOf()获得反射对象信息后,如果它的类型是结构体,可以通过反射值对象(reflect.Type)的NumField()Field()方法获得结构体成员的详细信息。
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) 根据方法名返回该类型方法集中的方法

2. StructField类型

StructField类型用来描述结构体中的一个字段的信息。
StructField的定义如下:

  1. type StructField struct {
  2. // Name是字段的名字。PkgPath是非导出字段的包路径,对导出字段该字段为""。
  3. // 参见http://golang.org/ref/spec#Uniqueness_of_identifiers
  4. Name string
  5. PkgPath string
  6. Type Type // 字段的类型
  7. Tag StructTag // 字段的标签
  8. Offset uintptr // 字段在结构体中的字节偏移量
  9. Index []int // 用于Type.FieldByIndex时的索引切片
  10. Anonymous bool // 是否匿名字段
  11. }

3. 结构体反射示例

当我们使用反射得到一个结构体数据之后可以通过索引依次获取其字段信息,也可以通过字段名去获取指定的字段信息。

  1. type student struct {
  2. Name string `json:"name"`
  3. Score int `json:"score"`
  4. }
  5. func main() {
  6. stu1 := student{
  7. Name: "小王子",
  8. Score: 90,
  9. }
  10. t := reflect.TypeOf(stu1)
  11. fmt.Println(t.Name(), t.Kind()) // student struct
  12. // 通过for循环遍历结构体的所有字段信息:NumField返回字段数量
  13. for i := 0; i < t.NumField(); i++ {
  14. field := t.Field(i)// Field通过下标获取value值
  15. fmt.Printf("name:%s index:%d type:%v json tag:%v\n",
  16. ield.Name, field.Index, field.Type, field.Tag.Get("json"))
  17. }
  18. // 通过字段名获取指定结构体字段信息
  19. if scoreField, ok := t.FieldByName("Score"); ok {
  20. fmt.Printf("name:%s index:%d type:%v json tag:%v\n",
  21. scoreField.Name, scoreField.Index, scoreField.Type, scoreField.Tag.Get("json"))
  22. }
  23. }

接下来编写一个函数printMethod(s interface{})来遍历打印s包含的方法。

  1. // 给student添加两个方法 Study和Sleep(注意首字母大写)
  2. func (s student) Study() string {
  3. msg := "好好学习,天天向上。"
  4. fmt.Println(msg)
  5. return msg
  6. }
  7. func (s student) Sleep() string {
  8. msg := "好好睡觉,快快长大。"
  9. fmt.Println(msg)
  10. return msg
  11. }
  12. func printMethod(x interface{}) {
  13. t := reflect.TypeOf(x)
  14. v := reflect.ValueOf(x)
  15. fmt.Println(t.NumMethod())
  16. for i := 0; i < v.NumMethod(); i++ {
  17. methodType := v.Method(i).Type()
  18. fmt.Printf("method name:%s\n", t.Method(i).Name)
  19. fmt.Printf("method:%s\n", methodType)
  20. // 通过反射调用方法传递的参数必须是 []reflect.Value 类型
  21. var args = []reflect.Value{}
  22. v.Method(i).Call(args)
  23. }
  24. }

五、反射是把双刃剑

反射是一个强大并富有表现力的工具,能让我们写出更灵活的代码。但是反射不应该被滥用,原因有以下三个。

  1. 基于反射的代码是极其脆弱的,反射中的类型错误会在真正运行的时候才会引发panic,那很可能是在代码写完的很长时间之后。
  2. 大量使用反射的代码通常难以理解。
  3. 反射的性能低下,基于反射实现的代码通常比正常代码运行速度慢一到两个数量级。

    练习题

  4. 编写代码利用反射实现一个ini文件的解析器程序。

    1. # config.ini文件
    2. [mysql]
    3. address=127.0.0.1
    4. port=3306
    5. username=root
    6. password=rootroot

    主要用到了:strconv类型转换 ```go package main

import ( “errors” “fmt” “io/ioutil” “reflect” “strconv” “strings” )

// MysqlConfig 具体配置; type MysqlConfig struct { Address string ini:"address" Port int ini:"port" Username string ini:"username" Password string ini:"password" }

// Config 包含所有配置项的结构体; type Config struct { // 结构体嵌套 MysqlConfig MysqlConfig ini:"mysql" }

func loadIni(fileName string, target interface{}) (err error) { // 1. 参数校验:是否为结构体指针(需在函数内对其修改键值对) t := reflect.TypeOf(target) if t.Kind() != reflect.Ptr { err = errors.New(“target params should be a pointer”) //实例化一个error类型的值,// 这种生成的错误不会打印在终端 return } if t.Elem().Kind() != reflect.Struct { err = errors.New(“target params should be a struct pointer”) //实例化一个error类型的值 }

  1. // 2. 读文件,一行一行读:区分注释、[]节、键值对
  2. // 优化:一次性读取得到字节类型数据,就关闭文件,不用一直处于打开状态
  3. b, err := ioutil.ReadFile(fileName)
  4. if err != nil {
  5. return
  6. }
  7. lineSlice := strings.Split(string(b), "\r\n") //装为字符串再切割成切片
  8. var structName string
  9. for index, line := range lineSlice {
  10. line = strings.TrimSpace(line) // 1.去掉前后空格,也确保不会有空行
  11. if len(line) == 0 {
  12. continue
  13. }
  14. if strings.HasPrefix(line, "#") || strings.HasPrefix(line, ";") { // 2.注释
  15. continue
  16. }
  17. if strings.HasPrefix(line, "[") { // 3.节
  18. sectionName := strings.TrimSpace(line[1 : len(line)-1]) //去掉前后[]
  19. if line[0] != '[' || line[len(line)-1] != ']' {
  20. err = fmt.Errorf("line: %d syntax error", index+1) // 这种生成的错误会打印在终端
  21. return
  22. }
  23. if len(sectionName) == 0 { // []内没写东西
  24. err = fmt.Errorf("line: %d syntax error", index+1)
  25. return
  26. }
  27. // 找到属于自己的节
  28. for i := 0; i < t.Elem().NumField(); i++ {
  29. field := t.Elem().Field(i)
  30. if sectionName == field.Tag.Get("ini") {
  31. structName = field.Name
  32. // fmt.Printf("找到节名为%s对应的嵌套结构体%s\n", sectionName, structName)
  33. }
  34. }
  35. } else { // 4.键值对
  36. if strings.Index(line, "=") == -1 || strings.HasPrefix(line, "=") {
  37. err = fmt.Errorf("line: %d syntax error 键值对不合法", index+1)
  38. return
  39. }
  40. v := reflect.ValueOf(target)
  41. sValue := v.Elem().FieldByName(structName) //拿到嵌套结构体的值信息
  42. sType := sValue.Type() //拿到嵌套结构体的类型信息
  43. if sType.Kind() != reflect.Struct {
  44. fmt.Printf("target中的 %s 字段应该是一个结构体\n", structName)
  45. return
  46. }
  47. // keyValue := strings.Split(line, "=")
  48. // key := strings.TrimSpace(keyValue[0])
  49. // value := strings.TrimSpace(keyValue[1])
  50. denghaoIdx := strings.Index(line, "=")
  51. key := strings.TrimSpace(line[:denghaoIdx])
  52. value := strings.TrimSpace(line[denghaoIdx+1:])
  53. // 每个字段的名和类型
  54. var fieldName string
  55. var fieldType reflect.StructField
  56. for i := 0; i < sValue.NumField(); i++ {
  57. field := sType.Field(i)
  58. fieldType = field
  59. if field.Tag.Get("ini") == key { //找到对应字段
  60. fieldName = field.Name
  61. break
  62. }
  63. }
  64. if len(fileName) == 0 {
  65. continue
  66. }
  67. fileObj := sValue.FieldByName(fieldName)
  68. // 通过strconv判断处理类型
  69. switch fieldType.Type.Kind() {
  70. case reflect.String:
  71. fileObj.SetString(value)
  72. case reflect.Int, reflect.Int8, reflect.Int32, reflect.Int64:
  73. var valueInt int64
  74. valueInt, err = strconv.ParseInt(value, 10, 64)
  75. if err != nil {
  76. err = fmt.Errorf("line: %d value type error", index+1)
  77. return
  78. }
  79. fileObj.SetInt(valueInt)
  80. case reflect.Bool:
  81. var valueBool bool
  82. valueBool, err = strconv.ParseBool(value)
  83. if err != nil {
  84. err = fmt.Errorf("line: %d value type error", index+1)
  85. return
  86. }
  87. fileObj.SetBool(valueBool)
  88. case reflect.Float32, reflect.Float64:
  89. var valueFloat float64
  90. valueFloat, err = strconv.ParseFloat(value, 64)
  91. if err != nil {
  92. err = fmt.Errorf("line: %d value type error", index+1)
  93. return
  94. }
  95. fileObj.SetFloat(valueFloat)
  96. }
  97. // fmt.Println(fieldName, fileObj, fieldType.Type.Kind())
  98. }
  99. }
  100. return

} func main() { var c Config err := loadIni(“./config.ini”, &c) if err != nil { fmt.Printf(“load ini failed, err: %v\n”, err) return } fmt.Println(c) }

```