反射

先看一个问题

  1. 前面我们学习过结构体的序列化和反序列化，里面 tags 的底层采用的就是反射的原理。 ```go package main

import ( “encoding/json” “fmt” )

type Monster struct { Name string json:"name" Age int json:"age" Sal float64 json:"sal" Sex string json:"sex" }

func main() { monster := Monster{ Name: “玉兔精”, Age: 20, Sal: 888.99, Sex: “female”, }

  1. data, _ := json.Marshal(monster)
  2. fmt.Println("json result: ", string(data))

}

  2. 2. 应用领域
  3. ```go
  4. // 定义了两个匿名函数
  5. test1 := func(v1 int, v2 int) {
  6.     t.Log(v1, v2)
  7. }
  8. test2 := func(v1 int, v2 int, s string) {
  9.     t.Log(v1, v2, s)
  10. }
  11. // 定义一个适配器函数用作统一处理接口，其大致结构如下：
  12. bridge := func(call interface{}, args...interface{}) {
  13.     //内容
  14. }
  15. //实现调用 test1 对应的函数
  16. bridge(test1, 1, 2)
  17. //实现调用 test2 对应的函数
  18. bridge(test2, 1, 2, "test2")
  19. // 要求使用反射机制完成

基本介绍

  1. 反射的基本介绍
    • 反射可以在运行时动态获取变量的各种信息，比如变量的类型，类别
    • 如果是结构体变量，还可以获取到结构体本身的信息(包括结构体的字段、方法)
    • 通过反射，可以修改变量的值，可以调用关联的方法。
    • 使用反射，需要 import(“reflect”)
  2. 反射重要的函数和概念
    • reflect.TypeOf(变量名)， 获取变量的类型，返回 reflect.Type 类型
    • reflect.ValueOf(变量名)，获取变量的值，返回 reflect.Value 类型 reflect.Value 是一个结构体类型。
    • 变量、interface{} 和 reflect.Value 是可以相互转换的。

  3. 类型转换

    • 变量 -> 手段：传递参数->interface{} -> 手段：reflect.Value() 函数 -> reflect.Value
    • reflect.Value -> 手段：Interface -> interface{} 手段：类型断言 -> 变量

      快速入门

  4. 编写一个案例。演示对基本数据类型、interface{}、reflect.Value进行反射操作。 ```go package main

import ( “fmt” “reflect” )

//专门演示反射 func reflectTest01(b interface{}) {

  1. //通过反射获取传入的变量的 type，kind，value
  2. //1. 先获取到 reflect.Type
  3. rtyp := reflect.TypeOf(b)
  4. fmt.Println("rtype =", rtyp)
  6. //2. 获取到 reflect.Value
  7. rVal := reflect.ValueOf(b)
  8. fmt.Println("rVal =", rVal) //不是普通的100
  9. fmt.Printf("rVal = %v rVal = %T \n", rVal, rVal)
  11. //将 reflect.Value 改为 int
  12. n2 := 2 + rVal.Int()
  13. fmt.Println(n2)
  15. // 将 reflect.Value 改为 interface{}
  16. iVal := rVal.Interface()
  18. //将 interface{} 通过断言转成需要的类型
  19. num2 := iVal.(int)
  20. fmt.Printf("num2 = %v num2 = %T \n", num2, num2)

}

func main() { / 案例一： 编写一个案例。演示对基本数据类型、interface{}、reflect.Value进行反射操作。 /

  1. //1. 先定义一个 int
  2. var num int = 100
  4. reflectTest01(num)

}

  2. 2. 编写一个案例，演示对(结构体类型、interface{}、reflect.Value)进行反射的基本操作。
  3. ```go
  4. package main
  6. import (
  7.     "fmt"
  8.     "reflect"
  9. )
  11. type Student struct {
  12.     Name string
  13.     Age int
  14. }
  18. //专门演示反射[对结构体的反射]
  19. func reflectTest02(b interface{}) {
  20.     //通过反射获取传入的变量的 type，kind，value
  21.     //1. 先获取到 reflect.Type
  22.     rType := reflect.TypeOf(b)
  23.     fmt.Println("rType =", rType)
  25.     //2. 获取到 reflect.Value
  26.     rVal := reflect.ValueOf(b)
  27.     fmt.Println("rVal =", rVal)
  28.     fmt.Printf("rVal = %v rVal = %T \n", rVal, rVal)
  30.     // 将 reflect.Value 改为 interface{}
  31.     iVal := rVal.Interface()
  32.     fmt.Printf("iVal = %v iVal = %T \n", iVal, iVal)
  34.     //将 interface{} 通过断言转成需要的类型
  35.     //println(iVal.Name) 报错
  36.     //这里，我们就简单使用了待检测的类型
  37.     //可以使用 switch 的断言形式来做得更加灵活
  38.     stu, ok := iVal.(Student)
  39.     if ok {
  40.         fmt.Printf("stu.Name = %v \n", stu.Name)
  41.     }
  43. }
  47. func main() {
  48.     //定义一个 Student 实例
  49.     stu := Student{
  50.         Name: "Tom",
  51.         Age: 20,
  52.     }
  54.     reflectTest02(stu)
  55. }

反射注意事项和细节说明

  1. reflect.Value.Kind，获取变量的类别，返回的是一个常量。
  2. Type 是类型，kind 是类型，Type 和 kind 可能是相同的，也可能是不同的。
    • 比如：var num int = 10 num 的 Type 是 int，Kind 也是 int。
    • 比如：var stu Student stu 的 Type 是包名.student，Kind 是 struct
  3. 通过反射可以让变量在 interface{} 和 reflect.Value 之间相互转换。
  4. 使用反射的方式来去变量的值(并返回对应的类型)，要求数据类型匹配，比如 x 是 int，那么就应该使用 reflect.Value(x).Int()，而不能使用其他的，否则报 panic。
  5. 通过反射的来修改变量，注意当使用 SetXxx 方法来设置需要通过对应的指针类型来完成，这样才能改变传入的变量的值，同时需要使用到 reflect.Value.Elem() 方法。 ```go package main

import ( “fmt” “reflect” )

//通过反射，修改 num int 的值；修改 Student 的值

func reflect01(b interface{}) { //获取到 reflect.Value rVal := reflect.ValueOf(b) // 看看 rVal 的 kind fmt.Printf(“rVal Kind = %v \n”, rVal.Kind())

  1. // rVal.SetInt(20) error
  2. rVal.Elem().SetInt(20)

}

func main() { var num int = 10 reflect01(&num) fmt.Println(num) }

  1. <a name="314422fe"></a>
  2. ## 反射的最佳实践
  4. 1. 使用反射来遍历结构体的字段，调用结构体的方法，并获取结构体标签的值。
  5. ```go
  6. package main
  8. import (
  9.     "fmt"
  10.     "reflect"
  11. )
  13. // 定义了一个 Monster 结构体
  14. type Monster struct {
  15.     Name string `json:"name"`
  16.     Age int `json:"age"`
  17.     Score float32
  18.     Sex string
  19. }
  21. //方法，显示 s 的值
  22. func(s Monster) Print() {
  23.     fmt.Println("---start---")
  24.     fmt.Println(s)
  25.     fmt.Println("---end---")
  26. }
  28. //方法， 返回两个数的和
  29. func (s Monster) GetSum(n1 int, n2 int) int {
  30.     return n1 + n2
  31. }
  33. //方法，接受四个值，给 s 赋值
  34. func (s Monster) Set(name string, age int, score float32, sex string) {
  35.     s.Name = name
  36.     s.Age = age
  37.     s.Score = score
  38.     s.Sex = sex
  39. }
  41. func TestStruct(a interface{}) {
  42.     // 获取 reflect.Type 类型
  43.     typ := reflect.TypeOf(a)
  44.     // 获取 reflect.Value
  45.     val := reflect.ValueOf(a)
  46.     // 获取到 a 对应的类别
  47.     kd := val.Kind()
  48.     // 如果传入的不是 struct ，就退出函数
  49.     if kd != reflect.Struct {
  50.         fmt.Println("expect struct...")
  51.         return
  52.     }
  54.     // 获取该结构体有几个字段
  55.     num := val.NumField()
  56.     fmt.Printf("struct has %d fields\n", num)
  57.     //遍历结构体的所有字段
  58.     for i := 0; i < num; i++ {
  59.         fmt.Printf("Field%d: %v \n", i, val.Field(i))
  60.         // 获取到 struct 标签，注意需要通过 reflect.type 来获取 tag 标签的值
  61.         tagVal := typ.Field(i).Tag.Get("json")
  62.         // 如果该字段有 tag 标签就显示，否则不显示
  63.         if tagVal != "" {
  64.             fmt.Printf("Field%d: tag = %v \n", i, tagVal)
  65.         }
  66.     }
  68.     // 获取到当前结构体有多少个方法
  69.     numOfMethod := val.NumMethod()
  70.     fmt.Printf("struct has %d methods \n", numOfMethod)
  71.     // var params []reflect.Value
  72.     // 方法的排序默认是按照 函数名的排序(ASCII码)
  73.     val.Method(1).Call(nil) // 获取到第二个方法，调用它
  75.     // 调用结构体的第1个方法 Method(1)
  76.     var params []reflect.Value // 声明 []reflect.Value 切片
  77.     params = append(params, reflect.ValueOf(10))
  78.     params = append(params, reflect.ValueOf(40))
  80.     res := val.Method(0).Call(params) // 传入的参数是 []reflect.Value , 返回[]reflect.Value
  82.     fmt.Println("res =", res[0].Int())
  84. }
  86. func main() {
  87.     //创建了一个 Monster 实例
  88.     monster := Monster{
  89.         Name: "黄鼠狼精",
  90.         Age: 400,
  91.         Score: 30.8,
  92.     }
  94.     // 将 Monster 实例传递给 TestStruct 函数
  95.     TestStruct(monster)
  96. }
  1. 使用反射的方式来获取结构体的 tag 标签，遍历字段的值，修改字段值，调用结构体方法。 ```go package main

import ( “encoding/json” “fmt” “reflect” )

type Monster struct { Name string json:"name" Age int Score float32 Sex string }

func (s Monster) Print() { fmt.Println(“—-start—-“) fmt.Println(s) fmt.Println(“—-end—-“) }

func TestStruct(a interface{}) { tye := reflect.TypeOf(a) val := reflect.ValueOf(a) kd := val.Kind() if kd != reflect.Ptr && val.Elem().Kind() == reflect.Struct { fmt.Println(“expect struct”) return }

  1. num := val.Elem().NumField()
  2. val.Elem().Field(0).SetString("白象精")
  3. for i := 0; i < num; i++ {
  4.     fmt.Printf("%d %v \n", i, val.Elem().Field(i).Kind())
  5. }
  7. fmt.Printf("struct has %d fields \n", num)
  8. tag := tye.Elem().Field(0).Tag.Get("json")
  9. fmt.Printf("tag = %s \n", tag)
  11. numOfMethod := val.Elem().NumMethod()
  12. fmt.Printf("struct has %d methods \n", numOfMethod)
  14. val.Elem().Method(0).Call(nil)

}

func main() { monster := Monster{ Name: “黄狮子”, Age: 408, Score: 92.8, }

  1. //先说明一下， Marshal 就是通过反射获取到 struct 的 tag 值
  2. result, _ := json.Marshal(monster)
  3. fmt.Println("json result:", string(result))
  5. TestStruct(&monster)
  6. fmt.Println(monster)

}

  2. 3. 定义了两个函数 test1 和 test2，定义一个适配器函数用作统一处理接口。 
  3.    - 定义了两个函数 
  4.    - 定义一个适配器函数用作统一处理接口 
  5.    - 要求使用反射机制完成 
  6. ```go
  7. package test
  9. import (
  10.     "reflect"
  11.     "testing"
  12. )
  15. func TestReflectFunction(t *testing.T) {
  16.     call1 := func(v1 int, v2 int) {
  17.         t.Log(v1, v2)
  18.     }
  20.     call2 := func(v1 int, v2 int, s string) {
  21.         t.Log(v1, v2, s)
  22.     }
  24.     var (
  25.         function reflect.Value
  26.         inValue []reflect.Value
  27.         n int
  28.     )
  30.     bridge := func(call interface{}, args...interface{}) {
  31.         n = len(args)
  32.         inValue = make([]reflect.Value, n)
  33.         for i :=0 ;i < n; i++ {
  34.             inValue[i] = reflect.ValueOf(args[i])
  35.         }
  37.         function = reflect.ValueOf(call)
  38.         function.Call(inValue)
  39.     }
  41.     bridge(call1, 1, 2)
  42.     bridge(call2 ,1, 2, "test2")
  43. }
  1. 使用反射操作任意结构体类型 ```go package test

import ( “reflect” “testing” )

type user struct { UserId string Name string }

func TestReflectStruct(t testing.T) { var ( model user sv reflect.Value )

  1. model = &user{}
  2. sv = reflect.ValueOf(model)
  3. t.Log("reflect.Value.Elem", sv.Kind().String())
  4. t.Log("sv.Elem().Kind()", sv.Elem().Kind())
  5. sv = sv.Elem()
  6. sv.FieldByName("UserId").SetString("12345678")
  7. sv.FieldByName("Name").SetString("nickname")
  8. t.Log("model", model)

}

  2. 5. 使用反射创建并操作结构体
  3. ```go
  4. package test
  6. import (
  7.     "reflect"
  8.     "testing"
  9. )
  12. type user struct {
  13.     UserId string
  14.     Name string
  15. }
  17. func TestReflectStructPtr(t *testing.T) {
  18.     var (
  19.         model *user
  20.         st reflect.Type
  21.         elem reflect.Value
  22.     )
  24.     st = reflect.TypeOf(model) //获取类型 *user
  25.     t.Log("reflect.TypeOf", st.Kind().String()) //ptr
  26.     st = st.Elem() // st 指向的类型
  27.     t.Log("reflect.TypeOf.elem", st.Kind().String()) //struct
  28.     elem = reflect.New(st) // New 返回一个 value 类型值，该值持有一个指针
  29.     t.Log("reflect.New", elem.Kind().String()) // ptr
  30.     t.Log("reflect.New.Elem", elem.Elem().Kind().String()) //struct
  31.     // model 就是创建的 user 结构体变量(实例)
  32.     model = elem.Interface().(*user) // model 是 *user 它的指向和 elem 是一样的
  33.     t.Log("model model.Name", model, model.Name)
  34.     t.Log("elem elem.Elem", elem, elem.Elem())
  35.     elem = elem.Elem() //取得 elem 指向的值
  36.     elem.FieldByName("UserId").SetString("12345678") //赋值
  37.     elem.FieldByName("Name").SetString("nickname")
  38.     t.Log("model model.Name", model, model.Name)
  39.     t.Log("*model", *model)
  40. }
  1. 课堂练习 ```go package main

import ( “fmt” “reflect” )

/ 课堂练习： (1) 编写一个 Cal 结构体，有两个字段 Num1，Num2 (2) 方法 GetSub(name string) (3) 使用反射机制完成对 GetSub 的调用，输出形式为 “tom 完成了 减法运行，8 - 3 = 5” /

type Cal struct { Num1 int Num2 int }

func (cal Cal) GetSub(name string) { fmt.Printf(“%v 完成了减法运行，%v - %v = %v \n”, name, cal.Num1, cal.Num2, cal.Num1 - cal.Num2) }

func TestStruct(a interface{}) { //typ := reflect.TypeOf(a) val := reflect.ValueOf(a) kd := val.Kind() // fmt.Println(val.Elem().Kind()) // struct if kd != reflect.Ptr && val.Elem().Kind() == reflect.Struct { fmt.Println(“expect struct…”) return }

  1. num := val.Elem().NumField()
  2. fmt.Printf("struct has %d fields \n", num)
  3. for i := 0; i < num; i++ {
  4.     fmt.Printf("field(%d) %v \n", i, val.Elem().Field(i))
  5. }
  7. numOfMethod := val.Elem().NumMethod()
  8. fmt.Printf("struct has %d methods \n", numOfMethod)
  10. // 调用结构体的第1个方法 Method(1)
  11. var params []reflect.Value // 声明 []reflect.Value 切片
  12. params = append(params, reflect.ValueOf("tom"))
  14. val.Elem().Method(0).Call(params)

}

func main() { cal := Cal{ Num1: 8, Num2: 3, }

  1. cal.GetSub("tom")
  2. TestStruct(&cal)

} ```

课程来源