反射的定义

  • 反射是指一类的应用，他们能够 自描述 自控制
  • python反射 根据字符串执行函数、根据字符串导入包

go中反射的简介

  • go是静态语言。反射就是go提供一种机制，在编译时不知道类型的情况下，可以做如下的事情
    • 更新变量
    • 运行时查看值
    • 调用方法
    • 对他们的布局进行操作

为什么使用反射

两个经典场景

  1. 你编写的这个函数，还不知道传给你的类型具体是什么，可能是还没约定好，也可能是传入的类型很多
  2. 希望通过用户的输入来决定调用按个函数(根据字符串调用方法)，动态执行函数
  • 举例使用 interface.type判断类型
  1. package main
  3. import "fmt"
  5. func main() {
  7.     var s interface{} = "abc"
  8.     switch s.(type) {
  9.     case string:
  10.         fmt.Println("s.type=string")
  11.     case int:
  12.         fmt.Println("s.type=int")
  13.     case bool:
  14.         fmt.Println("s.type=bool")
  15.     default:
  16.         fmt.Println("未知的类型")
  17.     }
  19. }
  • 上述类型判断的问题
    • 类型判断会写很多，代码很长
    • 类型还会增删，不灵活

使用反射获取变量内部的信息

  • reflect包提供 valueOf和Typeof
  • reflect.ValueOf : 获取输入接口中数据的值，如果为空返回 0
  • reflect.Typeof : 获取输入接口中值的类型，如果为空返回 nil
  • Typeof传入所有类型，因为所有的类型都实现了空接口

举例1 内置类型的测试

  1. package main
  3. import (
  4.     "log"
  5.     "reflect"
  6. )
  8. func main() {
  10.     var s interface{} = "abc"
  11.     // TypeOf会返回模板的对象
  12.     reflectType := reflect.TypeOf(s)
  13.     reflectValue := reflect.ValueOf(s)
  15.     log.Printf("[typeof:%v]", reflectType)
  16.     log.Printf("[valueof:%v]", reflectValue)
  18. }

举例2 自定义struct的反射

  • 生成的举例，对未知类型的进行 遍历探测它的Field，抽象成一个函数
  • go语言里面struct成员变量小写，在反射的时候直接panic reflect.Value.Interface: cannot return value obtained from unexported field or method
  • 结构体方法名小写是不会panic，反射时也不会被查看到
  • 指针方法是不能被反射查看到的

对于成员变量

  1. 先获取intereface的reflect.Type，然后遍历NumField
  2. 再通过reflect.Type的Field获取字段
  3. 最后通过Field的interface获取对应的value

对于方法

  1. 先获取intereface的reflect.Type，然后遍历NumMethod
  2. 再分别通过reflect.Type的 t.Method获取真实的方法
  3. 最后通过Name和Type获取方法的类型和值
  1. package main
  3. import (
  4.     "log"
  5.     "reflect"
  6. )
  8. type Person struct {
  9.     Name string
  10.     Age  int
  11. }
  13. type Student struct {
  14.     Person     //匿名结构体嵌套
  15.     StudentId  int
  16.     SchoolName string
  17.     IsBaoSong  bool //是考上来的吗
  18.     Hobbies    []string
  19.     // panic: reflect.Value.Interface: cannot return value obtained from unexported field or method
  20.     //hobbies    []string
  21.     Labels map[string]string
  22. }
  24. func (s *Student) GoHome() {
  25.     log.Printf("[回家了][sid:%d]", s.StudentId)
  26. }
  27. func (s Student) GotoSchool() {
  28.     log.Printf("[去上学了][sid:%d]", s.StudentId)
  29. }
  31. func (s Student) baosong() {
  32.     log.Printf("[竞赛保送][sid:%d]", s.StudentId)
  33. }
  35. func main() {
  37.     s := Student{
  38.         Person:     Person{Name: "xiaoyi", Age: 9900},
  39.         StudentId:  123,
  40.         SchoolName: "五道口皇家男子职业技术学院",
  41.         IsBaoSong:  true,
  42.         Hobbies:    []string{"唱", "跳", "Rap"},
  43.         //hobbies:    []string{"唱", "跳", "Rap"},
  44.         Labels: map[string]string{"k1": "v1", "k2": "v2"},
  45.     }
  47.     // 获取目标对象
  48.     t := reflect.TypeOf(s)
  49.     log.Printf("[对象的类型名称：%s]", t.Name())
  51.     // 获取目标对象的值类型
  52.     v := reflect.ValueOf(s)
  53.     // 遍历获取成员变量
  54.     for i := 0; i < t.NumField(); i++ {
  55.         // Field 代表对象的字段名
  56.         key := t.Field(i)
  57.         value := v.Field(i).Interface()
  58.         //
  59.         if key.Anonymous {
  60.             log.Printf("[匿名字段][第:%d个字段][字段名:%s][字段的类型:%v][字段的值:%v]", i+1, key.Name, key.Type, value)
  61.         } else {
  62.             log.Printf("[命名字段][第:%d个字段][字段名:%s][字段的类型:%v][字段的值:%v]", i+1, key.Name, key.Type, value)
  64.         }
  66.     }
  68.     // 打印方法
  69.     for i := 0; i < t.NumMethod(); i++ {
  70.         m := t.Method(i)
  71.         log.Printf("[第:%d个方法][方法名称:%s][方法的类型:%v]", i+1, m.Name, m.Type)
  73.     }
  74.     /*
  75.         2021/07/10 15:21:07 [对象的类型名称：Student]
  76.         2021/07/10 15:21:07 [匿名字段][第:1个字段][字段名:Person][字段的类型:main.Person][字段的值:{xiaoyi 9900}]
  77.         2021/07/10 15:21:07 [命名字段][第:2个字段][字段名:StudentId][字段的类型:int][字段的值:123]
  78.         2021/07/10 15:21:07 [命名字段][第:3个字段][字段名:SchoolName][字段的类型:string][字段的值:五道口皇家男子职业技术学院]
  79.         2021/07/10 15:21:07 [命名字段][第:4个字段][字段名:IsBaoSong][字段的类型:bool][字段的值:true]
  80.         2021/07/10 15:21:07 [命名字段][第:5个字段][字段名:Hobbies][字段的类型:[]string][字段的值:[唱 跳 Rap]]
  81.         2021/07/10 15:21:07 [命名字段][第:6个字段][字段名:Labels][字段的类型:map[string]string][字段的值:map[k1:v1 k2:v2]]
  82.         2021/07/10 15:21:07 [第:1个方法][方法名称:GotoSchool][方法的类型:func(main.Student)]
  84.     */
  85. }
  • 抽成一个函数
  1. package main
  3. import (
  4.     "log"
  5.     "reflect"
  6. )
  8. type Person struct {
  9.     Name string
  10.     Age  int
  11. }
  13. type Student struct {
  14.     Person     //匿名结构体嵌套
  15.     StudentId  int
  16.     SchoolName string
  17.     IsBaoSong  bool //是考上来的吗
  18.     Hobbies    []string
  19.     // panic: reflect.Value.Interface: cannot return value obtained from unexported field or method
  20.     //hobbies    []string
  21.     Labels map[string]string
  22. }
  24. //func (s *Student) GoHome() {
  25. //    log.Printf("[回家了][sid:%d]", s.StudentId)
  26. //}
  27. func (s Student) GoHome() {
  28.     log.Printf("[回家了][sid:%d]", s.StudentId)
  29. }
  31. func (s Student) GotoSchool() {
  32.     log.Printf("[去上学了][sid:%d]", s.StudentId)
  33. }
  35. func (s Student) Baosong() {
  36.     log.Printf("[竞赛保送][sid:%d]", s.StudentId)
  37. }
  39. func main() {
  40.     s := Student{
  41.         Person:     Person{Name: "xiaoyi", Age: 9900},
  42.         StudentId:  123,
  43.         SchoolName: "五道口皇家男子职业技术学院",
  44.         IsBaoSong:  true,
  45.         Hobbies:    []string{"唱", "跳", "Rap"},
  46.         //hobbies:    []string{"唱", "跳", "Rap"},
  47.         Labels: map[string]string{"k1": "v1", "k2": "v2"},
  48.     }
  49.     p := Person{
  50.         Name: "李逵",
  51.         Age:  124,
  52.     }
  55.     reflectProbeStruct(s)
  56.     reflectProbeStruct(p)
  57. }
  59. func reflectProbeStruct(s interface{}) {
  61.     // 获取目标对象
  62.     t := reflect.TypeOf(s)
  63.     log.Printf("[对象的类型名称：%s]", t.Name())
  65.     // 获取目标对象的值类型
  66.     v := reflect.ValueOf(s)
  67.     // 遍历获取成员变量
  68.     for i := 0; i < t.NumField(); i++ {
  69.         // Field 代表对象的字段名
  70.         key := t.Field(i)
  71.         value := v.Field(i).Interface()
  72.         //
  73.         if key.Anonymous {
  74.             log.Printf("[匿名字段][第:%d个字段][字段名:%s][字段的类型:%v][字段的值:%v]", i+1, key.Name, key.Type, value)
  75.         } else {
  76.             log.Printf("[命名字段][第:%d个字段][字段名:%s][字段的类型:%v][字段的值:%v]", i+1, key.Name, key.Type, value)
  78.         }
  80.     }
  82.     // 打印方法
  83.     for i := 0; i < t.NumMethod(); i++ {
  84.         m := t.Method(i)
  85.         log.Printf("[第:%d个方法][方法名称:%s][方法的类型:%v]", i+1, m.Name, m.Type)
  87.     }
  88.     /*
  89.         2021/07/10 15:21:07 [对象的类型名称：Student]
  90.         2021/07/10 15:21:07 [匿名字段][第:1个字段][字段名:Person][字段的类型:main.Person][字段的值:{xiaoyi 9900}]
  91.         2021/07/10 15:21:07 [命名字段][第:2个字段][字段名:StudentId][字段的类型:int][字段的值:123]
  92.         2021/07/10 15:21:07 [命名字段][第:3个字段][字段名:SchoolName][字段的类型:string][字段的值:五道口皇家男子职业技术学院]
  93.         2021/07/10 15:21:07 [命名字段][第:4个字段][字段名:IsBaoSong][字段的类型:bool][字段的值:true]
  94.         2021/07/10 15:21:07 [命名字段][第:5个字段][字段名:Hobbies][字段的类型:[]string][字段的值:[唱 跳 Rap]]
  95.         2021/07/10 15:21:07 [命名字段][第:6个字段][字段名:Labels][字段的类型:map[string]string][字段的值:map[k1:v1 k2:v2]]
  96.         2021/07/10 15:21:07 [第:1个方法][方法名称:GotoSchool][方法的类型:func(main.Student)]
  98.     */
  99. }

举例3 反射修改值

  • 必须是指针类型
  • pointer.Elem().Setxxx()
  1. package main
  3. import (
  4.     "log"
  5.     "reflect"
  6. )
  8. func main()  {
  12.     var num float64 = 3.14
  13.     log.Printf("[num原始值:%f]",num)
  15.     // 通过reflect.ValueOf获取num中的value
  16.     // 必须是指针才可以修改值
  17.     pointer:=reflect.ValueOf(&num)
  18.     newValue:=pointer.Elem()
  19.     // 赋值
  20.     newValue.SetFloat(5.6)
  21.     log.Printf("[num新值:%f]",num)
  23.     pointer = reflect.ValueOf(num)
  24.     // reflect: call of reflect.Value.Elem on float64 Value
  25.     newValue = pointer.Elem()
  26. }

举例4 反射调用方法

  • 过程说明
    1. 首先reflect.ValueOf(p1)获取 得到反射类型对象
    2. reflect.ValueOf.MethodByName ，需要传入准确的方法名称，MethodByName代表注册
      • 名字错了 会panic: reflect: call of reflect.Value.Call on zero Value
    3. []reflect.Value ，这是最终需要调用方法的参数，无参数传空切片
  1. package main
  3. import (
  4.     "log"
  5.     "reflect"
  6. )
  8. type Person struct {
  9.     Name   string
  10.     Age    int
  11.     Gender string
  12. }
  14. func (p Person) ReflectCallFuncWithArgs(name string, age int) {
  15.     log.Printf("[调用的是带参数的方法][args.name:%s][args.age:%d][[p.name:%s][p.age:%d]",
  16.         name,
  17.         age,
  18.         p.Name,
  19.         p.Age,
  20.     )
  21. }
  23. func (p Person) ReflectCallFuncWithNoArgs() {
  24.     log.Printf("[调用的是不带参数的方法]")
  25. }
  27. func main() {
  28.     p1 := Person{
  29.         Name:   "小乙",
  30.         Age:    18,
  31.         Gender: "男",
  32.     }
  34.     // 1. 首先通过 reflect.ValueOf(p1)获取 得到反射值类型
  35.     getValue := reflect.ValueOf(p1)
  37.     // 2. 带参数的方法调用
  38.     methodValue := getValue.MethodByName("ReflectCallFuncWithArgs")
  39.     // 参数是reflect.Value的切片
  40.     args := []reflect.Value{reflect.ValueOf("李逵"), reflect.ValueOf(30)}
  41.     methodValue.Call(args)
  43.     // 3. 不带参数的方法调用
  44.     methodValue = getValue.MethodByName("ReflectCallFuncWithNoArgs")
  45.     // 参数是reflect.Value的切片
  46.     args = make([]reflect.Value, 0)
  47.     methodValue.Call(args)
  49. }

结构体标签和反射

  • json的标签解析json
  • yaml的标签解析yaml
  • xorm gorm的标签 标识db字段
  • 自定义标签
  • 原理是t.Field.Tag.Lookup(“标签名”)
  • 混合的例子如下
  1. package main
  3. import (
  4.     "encoding/json"
  5.     "gopkg.in/yaml.v2"
  6.     "io/ioutil"
  7.     "log"
  8.     "reflect"
  9. )
  11. type Person struct {
  12.     Name string `json:"name" yaml:"yaml_name" mage:"name"`
  13.     Age  int    `json:"age"  yaml:"yaml_age"  mage:"age"`
  14.     City string `json:"-" yaml:"yaml_city" mage:"-"`
  15. }
  17. //json解析
  18. func jsonWork() {
  20.     // 对象marshal成字符串
  21.     p := Person{
  22.         Name: "xiaoyi",
  23.         Age:  18,
  24.         City: "北京",
  25.     }
  26.     data, err := json.Marshal(p)
  27.     if err != nil {
  28.         log.Printf("[json.marshal.err][err:%v]", err)
  29.         return
  30.     }
  31.     log.Printf("[person.marshal.res][res:%v]", string(data))
  33.     // 从字符串解析成结构体
  34.     p2Str := `
  35.    {
  36.     "name":"李逵",
  37.     "age":28,
  38.     "city":"山东"
  39. }
  40. `
  41.     var p2 Person
  42.     err = json.Unmarshal([]byte(p2Str), &p2)
  43.     if err != nil {
  44.         log.Printf("[json.unmarshal.err][err:%v]", err)
  45.         return
  46.     }
  47.     log.Printf("[person.unmarshal.res][res:%v]", p2)
  49. }
  51. // yaml读取文件
  52. func yamlWork() {
  53.     filename := "a.yaml"
  54.     content, err := ioutil.ReadFile(filename)
  55.     if err != nil {
  56.         log.Printf("[ioutil.ReadFile.err][err:%v]", err)
  57.         return
  58.     }
  59.     p := &Person{}
  60.     //err = yaml.Unmarshal(content, p)
  61.     err = yaml.UnmarshalStrict(content, p)
  62.     if err != nil {
  63.         log.Printf("[yaml.UnmarshalStrict.err][err:%v]", err)
  64.         return
  65.     }
  66.     log.Printf("[yaml.UnmarshalStrict.res][res:%v]", p)
  68. }
  70. func jiexizidingyibiaoqian(s interface{}) {
  72.     // typeOf type类型
  73.     r := reflect.TypeOf(s)
  74.     value := reflect.ValueOf(s)
  75.     for i := 0; i < r.NumField(); i++ {
  76.         field := r.Field(i)
  77.         key := field.Name
  78.         if tag, ok := field.Tag.Lookup("mage"); ok {
  79.             if tag == "-" {
  80.                 continue
  81.             }
  82.             log.Printf("[找到了mage标签][key:%v][value:%v][标签：mage=%s]",
  83.                 key,
  84.                 value.Field(i),
  85.                 tag,
  86.             )
  88.         }
  90.     }
  92. }
  94. func main() {
  95.     //jsonWork()
  96.     //yamlWork()
  97.     p := Person{
  98.         Name: "xiaoyi",
  99.         Age:  18,
  100.         City: "北京",
  101.     }
  102.     jiexizidingyibiaoqian(p)
  103. }

反射的副作用

1.代码可读性变差

2.隐藏的错误躲过编译检查

  • go静态语言，编译器能发现类型的错误
  • 但是对于反射代码是无能为力的，可能运行很久才会panic
  • 反射调用方法的副作用，将string参数传成 int
  1. panic: reflect: Call using float64 as type int
  3. goroutine 1 [running]:
  4. reflect.Value.call(0x31c260, 0xc0000783c0, 0x293, 0x328479, 0x4, 0xc00011df48, 0
  5. x2, 0x2, 0x353a00, 0xc0000200c0, ...)
  6.         C:/Program Files/Go/src/reflect/value.go:406 +0x1337
  7. reflect.Value.Call(0x31c260, 0xc0000783c0, 0x293, 0xc00011df48, 0x2, 0x2, 0xc000
  8. 0783c0, 0x293, 0xc000047f30)
  9.         C:/Program Files/Go/src/reflect/value.go:337 +0xc5
  10. main.main()
  11.         D:/nyy_work/go_path/src/maday06/reader.go:41 +0x316

3. go反射性能问题

  1. type := reflect.value(obj)
  2. fieldValue:=type_.FieldByName("xx")
  • 每次取出的fieldValue类型是reflect.value
  • 它是一个具体的值，不是一个可复用的对象
  • 每次反射都要malloc这个reflect.Value结构退，还有GC
  • 反射比正常的代码要慢1-2个数据量级，如果是追求性能的关键模块应减少反射