通过反射修改结构体字段值

代码

需要转入 指针 类型， 并调用 Elem() 方法 转化， 然后调用 SetXxx() 方法修改属性值

  1. // 运用反射 修改 结构体 字段 案例
  2. // 反射可以用来开发底层框架
  3. package main
  5. import (
  6.     "encoding/json"
  7.     "fmt"
  8.     "reflect"
  9. )
  11. // 这就需要通过 tag 来转化大写的字段，同时又保证内部调用的时候可以暴露变量
  12. // 反射原理
  13. type People struct {
  14.     Name   string  `json:"name01"`
  15.     Age    int     `json:"age"`
  16.     Height float64 `json:"height"`
  17.     Action string
  18. }
  20. // 给结构体绑定方法
  22. func (p People) Print() {
  23.     fmt.Println("print() = ", p)
  24. }
  26. func (p People) GetSum(n1, n2 int) int {
  27.     return n1 + n2
  28. }
  30. func (p People) Set(name string, age int, height float64, action string) {
  31.     p.Name = name
  32.     p.Age = age
  33.     p.Height = height
  34.     p.Action = action
  35. }
  37. func TestStruct(a interface{}) {
  38.     typ := reflect.TypeOf(a)
  39.     val := reflect.ValueOf(a)
  40.     kd := val.Kind()
  41.     if kd != reflect.Ptr && val.Elem().Kind() == reflect.Struct {
  42.         fmt.Println("except struct, but its not")
  43.         return
  44.     }
  45.     // 结构体字段
  46.     // 字段的顺序跟定义结构体时字段的先后顺序一致
  47.     num := val.Elem().NumField()
  48.     fmt.Printf("struct has %v fields \n", num)
  49.     for i := 0; i < num; i++ {
  50.         fmt.Printf("第%v个字段：%v \n", i+1, val.Elem().Field(i))
  51.         tagVal := typ.Elem().Field(i).Tag.Get("json")
  52.         if tagVal != "" {
  53.             fmt.Printf("第%v个字段, tag ： %v \n", i+1, tagVal)
  54.         }
  55.     }
  56.     // 结构体方法
  57.     numOfMethod := val.NumMethod()
  58.     fmt.Printf("struct 有 %v 个方法 \n", numOfMethod)
  60.     // 内部方法名顺序，按照函数名的 ascii 码排序的
  61.     val.Method(1).Call(nil)
  63.     var params []reflect.Value
  64.     params = append(params, reflect.ValueOf(10))
  65.     params = append(params, reflect.ValueOf(40))
  66.     res := val.Method(0).Call(params)
  67.     fmt.Println("res = ", res[0].Int())
  69.     // 修改结构体字段值
  70.     val.Elem().Field(1).SetInt(20)
  71. }
  73. func main() {
  74.     // struct
  76.     p1 := People{
  77.         Name:   "tom",
  78.         Age:    18,
  79.         Height: 178.5,
  80.         Action: "衣食住行",
  81.     }
  83.     // 序列化就是通过反射机制获取到 tag 值
  84.     p1Str, err := json.Marshal(p1)
  85.     if err != nil {
  86.         fmt.Println("序列化失败", err)
  87.     } else {
  88.         fmt.Println("p1Str = ", string(p1Str))
  89.     }
  91.     // 传入指针类型， 调用 Elem() 和 SetXxx()
  92.     TestStruct(&p1)
  93.     fmt.Println("p1 = ", p1)
  94. }
  96. /*
  97. print() =  {tom 18 178.5 衣食住行}
  98. p1 =  {tom 20 178.5 衣食住行}
  99. */

使用反射机制，编写函数适配器，桥连接

reflect_test.go 单元测试

代码

  1. // reflect_test.go 单元测试
  2. // 使用反射机制，编写适配器函数 桥连接
  3. package test
  5. import (
  6.     "reflect"
  7.     "testing"
  8. )
  10. // type User struct {
  11. //     UserId string
  12. //     Name   string
  13. // }
  15. func TestReflectFunc(t *testing.T) {
  16.     // 定义两个不同参数的函数
  17.     call1 := func(v1 int, v2 int) {
  18.         t.Log(v1, v2)
  19.     }
  20.     call2 := func(v1 int, v2 int, s string) {
  21.         t.Log(v1, v2, s)
  22.     }
  23.     var (
  24.         function reflect.Value
  25.         inValue  []reflect.Value
  26.         n        int
  27.     )
  28.     bridge := func(call interface{}, args ...interface{}) {
  29.         n = len(args)
  30.         inValue = make([]reflect.Value, n)
  31.         for i := 0; i < n; i++ {
  32.             inValue[i] = reflect.ValueOf(args[i])
  33.         }
  34.         function = reflect.ValueOf(call)
  35.         // len(in) == 3, v.Call(in)代表调用v(in[0], in[1], in[2])
  36.         function.Call(inValue)
  37.     }
  38.     bridge(call1, 1, 2)
  39.     bridge(call2, 1, 2, "test2")
  40. }
  42. /*
  43. go test -v
  45. === RUN   TestReflectFunc
  46.     reflect_test.go:17: 1 2
  47.     reflect_test.go:20: 1 2 test2
  48. --- PASS: TestReflectFunc (0.00s)
  49. PASS
  50. ok      go_code/reflect/reflect04/main  0.545s
  51. */

通过反射创建并操作结构体

代码

  1. // reflect_test.go 测试用例
  2. // 通过反射创建并操作结构体
  3. package test
  5. import (
  6.     "reflect"
  7.     "testing"
  8. )
  10. type User struct {
  11.     UserId string
  12.     Name   string
  13. }
  15. func TestReflectStructPtr(t *testing.T) {
  16.     var (
  17.         model *User
  18.         st    reflect.Type
  19.         elem  reflect.Value
  20.     )
  22.     // 获取 *User 类型
  23.     st = reflect.TypeOf(model)
  24.     t.Log("reflect.TypeOf = ", st.Kind().String()) // ptr
  25.     // st 真正指向的类型
  26.     st = st.Elem()
  27.     t.Log("reflect.TypeOf.Elem = ", st.Kind().String()) // struct
  28.     // New 返回一个 Value 类型的值，该值持有一个指向类型为 typ 的新申请的零值的指针
  29.     elem = reflect.New(st)
  30.     t.Log("reflect.New", elem.Kind().String())             // ptr
  31.     t.Log("reflect.New.Elem", elem.Elem().Kind().String()) // struct
  32.     // model 就是创建的 User 结构体变量（实例）
  33.     // 类型断言
  34.     model = elem.Interface().(*User) // model 是 *User, 它的指向跟elem 是一样的
  35.     elem = elem.Elem()               // 取得 elem 指向的值
  36.     // 结构体赋值
  37.     elem.FieldByName("UserId").SetString("123456")
  38.     elem.FieldByName("Name").SetString("xiao")
  39.     t.Log("model model.Name", model, model.Name)
  40. }
  42. /*
  43. go test -v
  45. === RUN   TestReflectStructPtr
  46.     reflect_test.go:24: reflect.TypeOf =  ptr
  47.     reflect_test.go:27: reflect.TypeOf.Elem =  struct
  48.     reflect_test.go:30: reflect.New ptr
  49.     reflect_test.go:31: reflect.New.Elem struct
  50.     reflect_test.go:39: model model.Name &{123456 xiao} xiao
  51. --- PASS: TestReflectStructPtr (0.00s)
  52. PASS
  53. ok      go_code/reflect/reflect05/test  0.740s
  54. */