1. 反射

反射是指在程序运行期对程序本身进行访问和修改的能力

1.1.1. 变量的内在机制

  • 变量包含类型信息和值信息 var arr [10]int arr[0] = 10
  • 类型信息：是静态的元信息，是预先定义好的
  • 值信息：是程序运行过程中动态改变的

1.1.2. 反射的使用

  • reflect包封装了反射相关的方法
  • 获取类型信息：reflect.TypeOf，是静态的
  • 获取值信息：reflect.ValueOf，是动态的

1.1.3. 空接口与反射

  • 反射可以在运行时动态获取程序的各种详细信息
  • 反射获取interface类型信息 
  1. package main
  3. import (
  4.    "fmt"
  5.    "reflect"
  6. )
  8. //反射获取interface类型信息
  10. func reflect_type(a interface{}) {
  11.    t := reflect.TypeOf(a)
  12.    fmt.Println("类型是：", t)
  13.    // kind()可以获取具体类型
  14.    k := t.Kind()
  15.    fmt.Println(k)
  16.    switch k {
  17.    case reflect.Float64:
  18.       fmt.Printf("a is float64\n")
  19.    case reflect.String:
  20.       fmt.Println("string")
  21.    }
  22. }
  24. func main() {
  25.    var x float64 = 3.4
  26.    reflect_type(x)
  27. }
  • 反射获取interface值信息 
  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. //反射获取interface值信息
  10. func reflect_value(a interface{}) {
  11.     v := reflect.ValueOf(a)
  12.     fmt.Println(v)
  13.     k := v.Kind()
  14.     fmt.Println(k)
  15.     switch k {
  16.     case reflect.Float64:
  17.         fmt.Println("a是：", v.Float())
  18.     }
  19. }
  21. func main() {
  22.     var x float64 = 3.4
  23.     reflect_value(x)
  24. }
  • 反射修改值信息 
  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. //反射修改值
  9. func reflect_set_value(a interface{}) {
  10.     v := reflect.ValueOf(a)
  11.     k := v.Kind()
  12.     switch k {
  13.     case reflect.Float64:
  14.         // 反射修改值
  15.         v.SetFloat(6.9)
  16.         fmt.Println("a is ", v.Float())
  17.     case reflect.Ptr:
  18.         // Elem()获取地址指向的值
  19.         v.Elem().SetFloat(7.9)
  20.         fmt.Println("case:", v.Elem().Float())
  21.         // 地址
  22.         fmt.Println(v.Pointer())
  23.     }
  24. }
  26. func main() {
  27.     var x float64 = 3.4
  28.     // 反射认为下面是指针类型，不是float类型
  29.     reflect_set_value(&x)
  30.     fmt.Println("main:", x)
  31. }

1.1.4. 结构体与反射

查看类型、字段和方法

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. // 定义结构体
  9. type User struct {
  10.     Id   int
  11.     Name string
  12.     Age  int
  13. }
  15. // 绑方法
  16. func (u User) Hello() {
  17.     fmt.Println("Hello")
  18. }
  20. // 传入interface{}
  21. func Poni(o interface{}) {
  22.     t := reflect.TypeOf(o)
  23.     fmt.Println("类型：", t)
  24.     fmt.Println("字符串类型：", t.Name())
  25.     // 获取值
  26.     v := reflect.ValueOf(o)
  27.     fmt.Println(v)
  28.     // 可以获取所有属性
  29.     // 获取结构体字段个数：t.NumField()
  30.     for i := 0; i < t.NumField(); i++ {
  31.         // 取每个字段
  32.         f := t.Field(i)
  33.         fmt.Printf("%s : %v", f.Name, f.Type)
  34.         // 获取字段的值信息
  35.         // Interface()：获取字段对应的值
  36.         val := v.Field(i).Interface()
  37.         fmt.Println("val :", val)
  38.     }
  39.     fmt.Println("=================方法====================")
  40.     for i := 0; i < t.NumMethod(); i++ {
  41.         m := t.Method(i)
  42.         fmt.Println(m.Name)
  43.         fmt.Println(m.Type)
  44.     }
  46. }
  48. func main() {
  49.     u := User{1, "zs", 20}
  50.     Poni(u)
  51. }

查看匿名字段

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. // 定义结构体
  9. type User struct {
  10.     Id   int
  11.     Name string
  12.     Age  int
  13. }
  15. // 匿名字段
  16. type Boy struct {
  17.     User
  18.     Addr string
  19. }
  21. func main() {
  22.     m := Boy{User{1, "zs", 20}, "bj"}
  23.     t := reflect.TypeOf(m)
  24.     fmt.Println(t)
  25.     // Anonymous：匿名
  26.     fmt.Printf("%#v\n", t.Field(0))
  27.     // 值信息
  28.     fmt.Printf("%#v\n", reflect.ValueOf(m).Field(0))
  29. }

修改结构体的值

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. // 定义结构体
  9. type User struct {
  10.     Id   int
  11.     Name string
  12.     Age  int
  13. }
  15. // 修改结构体值
  16. func SetValue(o interface{}) {
  17.     v := reflect.ValueOf(o)
  18.     // 获取指针指向的元素
  19.     v = v.Elem()
  20.     // 取字段
  21.     f := v.FieldByName("Name")
  22.     if f.Kind() == reflect.String {
  23.         f.SetString("kuteng")
  24.     }
  25. }
  27. func main() {
  28.     u := User{1, "5lmh.com", 20}
  29.     SetValue(&u)
  30.     fmt.Println(u)
  31. }

调用方法

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. // 定义结构体
  9. type User struct {
  10.     Id   int
  11.     Name string
  12.     Age  int
  13. }
  15. func (u User) Hello(name string) {
  16.     fmt.Println("Hello：", name)
  17. }
  19. func main() {
  20.     u := User{1, "5lmh.com", 20}
  21.     v := reflect.ValueOf(u)
  22.     // 获取方法
  23.     m := v.MethodByName("Hello")
  24.     // 构建一些参数
  25.     args := []reflect.Value{reflect.ValueOf("6666")}
  26.     // 没参数的情况下：var args2 []reflect.Value
  27.     // 调用方法，需要传入方法的参数
  28.     m.Call(args)
  29. }

获取字段的tag

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. type Student struct {
  9.     Name string `json:"name1" db:"name2"`
  10. }
  12. func main() {
  13.     var s Student
  14.     v := reflect.ValueOf(&s)
  15.     // 类型
  16.     t := v.Type()
  17.     // 获取字段
  18.     f := t.Elem().Field(0)
  19.     fmt.Println(f.Tag.Get("json"))
  20.     fmt.Println(f.Tag.Get("db"))
  21. }

1.1.5. 反射练习

  • 任务：解析如下配置文件
    • 序列化：将结构体序列化为配置文件数据并保存到硬盘
    • 反序列化：将配置文件内容反序列化到程序的结构体
  • 配置文件有server和mysql相关配置 
  1. #this is comment
  2. ;this a comment
  3. ;[]表示一个section
  4. [server]
  5. ip = 10.238.2.2
  6. port = 8080
  8. [mysql]
  9. username = root
  10. passwd = admin
  11. database = test
  12. host = 192.168.10.10
  13. port = 8000
  14. timeout = 1.2

代码地址：https://github.com/lu569368/Practise_reflex.git