go 反射Reflect-阿里云开发者社区

一篇带你全面掌握go反射的用法 - 知乎 (zhihu.com)反射 | Golang中文学习文档 (halfiisland.com)Go reflection 三定律与最佳实践 (halfrost.com)

为什么用反射

强调一下反射的2个弊端：

代码不易阅读，不易维护，容易发生线上panic
性能很差，比正常代码慢一到两个数量级

go语言反射里最重要的两个概念是Type和Value，Type用于获取类型相关的信息（比如Slice的长度，struct的成员，函数的参数个数），Value用于获取和修改原始数据的值（比如修改slice和map中的元素，修改struct的成员变量）。

它们和go原始数据类型（比如int、float、map、struct等）的转换方式如下图：

reflect.Type

复制代码

package tests
import (
  "fmt"
  "reflect"
  "testing"
  "github.com/stretchr/testify/assert"
)
// 如何得到Type
func TestReflect1(t *testing.T) {
  typeI := reflect.TypeOf(1)
  typeS := reflect.TypeOf("hello")
  fmt.Println(typeI) //int
  fmt.Println(typeS) //string
  typeUser := reflect.TypeOf(&User{})
  fmt.Println(typeUser)               //*tests.User
  fmt.Println(typeUser.Kind())        //ptr
  fmt.Println(typeUser.Elem().Kind()) //struct
}
// 指针Type转为非指针Type
func TestReflect2(t *testing.T) {
  typeUser := reflect.TypeOf(&User{})
  typeUser2 := reflect.TypeOf(User{})
  assert.Equal(t, typeUser.Elem(), typeUser2) // 相等
}
// 获取struct成员变量的信息
func TestReflect3(t *testing.T) {
  typeUser := reflect.TypeOf(User{}) //需要用struct的Type，不能用指针的Type
  fieldNum := typeUser.NumField()    //成员变量的个数
  for i := 0; i < fieldNum; i++ {
    field := typeUser.Field(i)
    fmt.Printf("%d %s offset %d anonymous %t type %s exported %t json tag %s\n", i,
      field.Name,            //变量名称
      field.Offset,          //相对于结构体首地址的内存偏移量，string类型会占据16个字节
      field.Anonymous,       //是否为匿名成员
      field.Type,            //数据类型，reflect.Type类型
      field.IsExported(),    //包外是否可见（即是否以大写字母开头）
      field.Tag.Get("json")) //获取成员变量后面``里面定义的tag
  }
  fmt.Println()
  //可以通过FieldByName获取Field
  if nameField, ok := typeUser.FieldByName("Name"); ok {
    fmt.Printf("Name is exported %t\n", nameField.IsExported())
  }
  //也可以根据FieldByIndex获取Field
  Field := typeUser.FieldByIndex([]int{1})                          //参数是个slice，因为有struct嵌套的情况
  FieldField := reflect.TypeOf(VIPUser{}).FieldByIndex([]int{0, 1}) // 嵌套的切片，下标对应struct嵌套的层数
  fmt.Printf("field name %s\n fieldfield name %s\n", Field.Name, FieldField.Name)
}
// 获取struct成员方法的信息
func TestReflect4(t *testing.T) {
  typeUser := reflect.TypeOf(User{})
  methodNum := typeUser.NumMethod() // 成员方法的个数。接收者为指针的方法【不】包含在内
  for i := 0; i < methodNum; i++ {
    method := typeUser.Method(i)
    fmt.Printf("method name:%s ,type:%s, exported:%t\n", method.Name, method.Type, method.IsExported())
  }
  fmt.Println()
  typeUser2 := reflect.TypeOf(&User{})
  methodNum = typeUser2.NumMethod() // 成员方法的个数。接收者为指针或值的方法【都】包含在内，也就是说值实现的方法指针也实现了（反之不成立）
  for i := 0; i < methodNum; i++ {  // 根据Go语言的官方文档，不推荐在同一个结构体上同时定义值接收器（value receiver）和指针接收器（pointer receiver）的方法
    method := typeUser2.Method(i)
    fmt.Printf("method name:%s ,type:%s, exported:%t\n", method.Name, method.Type, method.IsExported())
  }
}
// 获取函数的信息
func TestReflect5(t *testing.T) {
  Add := func(a, b int) int {
    return a + b
  }
  typeFunc := reflect.TypeOf(Add) //获取函数类型
  fmt.Printf("is function type %t\n", typeFunc.Kind() == reflect.Func)
  argInNum := typeFunc.NumIn()   //输入参数的个数
  argOutNum := typeFunc.NumOut() //输出参数的个数
  for i := 0; i < argInNum; i++ {
    argTyp := typeFunc.In(i)
    fmt.Printf("第%d个输入参数的类型%s\n", i, argTyp)
  }
  for i := 0; i < argOutNum; i++ {
    argTyp := typeFunc.Out(i)
    fmt.Printf("第%d个输出参数的类型%s\n", i, argTyp)
  }
}
// 判断类型是否实现了某接口
func TestReflect6(t *testing.T) {
  //通过reflect.TypeOf((*<interface>)(nil)).Elem()获得接口类型。因为People是个接口不能创建实例，所以把nil强制转为*tests.People类型
  typeOfPeople := reflect.TypeOf((*People)(nil)).Elem()
  fmt.Printf("typeOfPeople kind is interface %t\n", typeOfPeople.Kind() == reflect.Interface)
  t1 := reflect.TypeOf(User{})
  t2 := reflect.TypeOf(&User{})
  //如果值类型实现了接口，则指针类型也实现了接口
  //反之不成立
  fmt.Printf("t1 implements People interface %t\n", t1.Implements(typeOfPeople))
  fmt.Printf("t1 implements People interface %t\n", t2.Implements(typeOfPeople))
}

reflect.Value

复制代码

package tests
import (
  "fmt"
  "reflect"
  "testing"
  "github.com/stretchr/testify/assert"
)
// 通过ValueOf()得到Value
func TestReflect7(t *testing.T) {
  fmt.Println(iValue)       //1
  fmt.Println(sValue)       //hello
  fmt.Println(userPtrValue) //&{7 杰克逊  65 1.68}
}
// Value转为Type
func TestReflect8(t *testing.T) {
  iType := iValue.Type()
  sType := sValue.Type()
  userType := userPtrValue.Type()
  //在Type和相应Value上调用Kind()结果一样的
  fmt.Println(iType.Kind() == reflect.Int, iValue.Kind() == reflect.Int, iType.Kind() == iValue.Kind())
  fmt.Println(sType.Kind() == reflect.String, sValue.Kind() == reflect.String, sType.Kind() == sValue.Kind())
  fmt.Println(userType.Kind() == reflect.Ptr, userPtrValue.Kind() == reflect.Ptr, userType.Kind() == userPtrValue.Kind())
}
// 指针Value和非指针Value互相转换
func TestReflect9(t *testing.T) {
  userValue := userPtrValue.Elem()                    //Elem() 指针Value转为非指针Value
  fmt.Println(userValue.Kind(), userPtrValue.Kind())  //struct ptr
  userPtrValue3 := userValue.Addr()                   //Addr() 非指针Value转为指针Value
  fmt.Println(userValue.Kind(), userPtrValue3.Kind()) //struct ptr
}
// 得到Value对应的原始数据
// 通过Interface()函数把Value转为interface{}，再从interface{}强制类型转换，转为原始数据类型。或者在Value上直接调用Int()、String()等一步到位。
func TestReflect10(t *testing.T) {
  userValue := userPtrValue.Elem()
  fmt.Printf("origin value iValue is %d %d\n", iValue.Interface().(int), iValue.Int())
  fmt.Printf("origin value sValue is %s %s\n", sValue.Interface().(string), sValue.String())
  user := userValue.Interface().(User)
  fmt.Printf("id=%d name=%s weight=%.2f height=%.2f\n", user.Id, user.Name, user.Weight, user.Height)
  user2 := userPtrValue.Interface().(*User)
  fmt.Printf("id=%d name=%s weight=%.2f height=%.2f\n", user2.Id, user2.Name, user2.Weight, user2.Height)
}
// 空Value的判断
func TestReflect11(t *testing.T) {
  var i interface{} //接口没有指向具体的值
  v := reflect.ValueOf(i)
  fmt.Printf("v持有值 %t, type of v is Invalid %t\n", v.IsValid(), v.Kind() == reflect.Invalid)
  var user *User = nil
  v = reflect.ValueOf(user) //Value指向一个nil
  if v.IsValid() {
    fmt.Printf("v持有的值是nil %t\n", v.IsNil()) //调用IsNil()前先确保IsValid()，否则会panic
  }
  var u User //只声明，里面的值都是0值nil
  v = reflect.ValueOf(u)
  if v.IsValid() {
    fmt.Printf("v持有的值是对应类型的0值 %t\n", v.IsZero()) //调用IsZero()前先确保IsValid()，否则会panic
  }
}
// 通过Value修改原始数据的值
func TestReflect12(t *testing.T) {
  valueI.Elem().SetInt(8) //由于valueI对应的原始对象是指针，通过Elem()返回指针指向的对象
  valueS.Elem().SetString("golang")
  valueUser.Elem().FieldByName("Weight").SetFloat(68.0) //FieldByName()通过Name返回类的成员变量
  assert.Equal(t, valueI.Elem().Int(), int64(8))
  assert.Equal(t, valueS.Elem().String(), "golang")
  assert.Equal(t, valueUser.Elem().Interface().(User), user)
  //强调一下，要想修改原始数据的值，给ValueOf传的必须是指针，
  //指针Value不能调用Set和FieldByName方法，所以得先通过Elem()转为非指针Value。
}
// 未导出成员的值不能通过反射进行修改。
func TestReflect13(t *testing.T) {
  addrValue := valueUser.Elem().FieldByName("address")
  if addrValue.CanSet() {
    addrValue.SetString("北京")
  } else {
    fmt.Println("addr是未导出成员，不可Set") //以小写字母开头的成员相当于是私有成员
  }
}
// 通过Value修改Slice
func TestReflect14(t *testing.T) {
  users := make([]*User, 1, 5) //len=1，cap=5
  users[0] = &User{
    Id:     7,
    Name:   "杰克逊",
    Weight: 65.5,
    Height: 1.68,
  }
  sliceValue := reflect.ValueOf(&users) //准备通过Value修改users，所以传users的地址
  if sliceValue.Elem().Len() > 0 {      //取得slice的长度
    sliceValue.Elem().Index(0).Elem().FieldByName("Name").SetString("令狐一刀")
    fmt.Printf("1st user name change to %s\n", users[0].Name)
  }
  //甚至可以修改slice的cap，新的cap必须位于原始的len到cap之间，即只能把cap改小。
  sliceValue.Elem().SetCap(3)
  //通过把len改大，可以实现向slice中追加元素的功能。
  sliceValue.Elem().SetLen(2)
  //调用reflect.Value的Set()函数修改其底层指向的原始数据
  sliceValue.Elem().Index(1).Set(reflect.ValueOf(&User{
    Id:     8,
    Name:   "李达",
    Weight: 80,
    Height: 180,
  }))
  fmt.Printf("2nd user name %s\n", users[1].Name)
}
// Value.SetMapIndex()函数：往map里添加一个key-value对
//
// Value.MapIndex()函数： 根据Key取出对应的map
func TestReflect15(t *testing.T) {
  u1 := &User{
    Id:     7,
    Name:   "杰克逊",
    Weight: 65.5,
    Height: 1.68,
  }
  u2 := &User{
    Id:     8,
    Name:   "杰克逊",
    Weight: 65.5,
    Height: 1.68,
  }
  userMap := make(map[int]*User, 5)
  userMap[u1.Id] = u1
  mapValue := reflect.ValueOf(&userMap)                                                         //准备通过Value修改userMap，所以传userMap的地址
  mapValue.Elem().SetMapIndex(reflect.ValueOf(u2.Id), reflect.ValueOf(u2))                      //SetMapIndex 往map里添加一个key-value对
  mapValue.Elem().MapIndex(reflect.ValueOf(u1.Id)).Elem().FieldByName("Name").SetString("令狐一刀") //MapIndex 根据Key取出对应的map
  for k, user := range userMap {
    fmt.Printf("key %d name %s\n", k, user.Name)
  }
}
// 调用函数
func TestReflect16(t *testing.T) {
  Add := func(a int, b int) int {
    return a + b
  }
  valueFunc := reflect.ValueOf(Add) //函数也是一种数据类型
  typeFunc := reflect.TypeOf(Add)
  argNum := typeFunc.NumIn()            //函数输入参数的个数
  args := make([]reflect.Value, argNum) //准备函数的输入参数
  for i := 0; i < argNum; i++ {
    if typeFunc.In(i).Kind() == reflect.Int {
      args[i] = reflect.ValueOf(3) //给每一个参数都赋3
    }
  }
  sumValue := valueFunc.Call(args) //返回[]reflect.Value，因为go语言的函数返回可能是一个列表
  if typeFunc.Out(0).Kind() == reflect.Int {
    sum := sumValue[0].Interface().(int) //从Value转为原始数据类型
    fmt.Printf("sum=%d\n", sum)
  }
}
// 调用成员方法
func TestReflect17(t *testing.T) {
  valueUser := reflect.ValueOf(&User{
    Id:     7,
    Name:   "杰克逊",
    Weight: 65.5,
    Height: 1.68,
  }) //必须传指针，因为UpdateName()在定义的时候它是指针的方法
  UpdateNameMethod := valueUser.MethodByName("UpdateName") //MethodByName()通过Name返回类的成员变量
  args := make([]reflect.Value, 1)                         //准备函数的输入参数
  args[0] = reflect.ValueOf("handsome")
  UpdateNameMethod.Call(args) //无参数时传一个空的切片
  fmt.Println(valueUser.Elem().Interface().(User).Name)
  //GetName()在定义的时候用的不是指针，valueUser可以用指针也可以不用指针
  thinkMethod := valueUser.MethodByName("GetName")
  result := thinkMethod.Call([]reflect.Value{})
  fmt.Println("Name is:" + result[0].String())
  valueUser2 := reflect.ValueOf(user)
  thinkMethod = valueUser2.MethodByName("GetName")
  thinkMethod.Call([]reflect.Value{})
  result = thinkMethod.Call([]reflect.Value{})
  fmt.Println("Name is:" + result[0].String())
}

创建对象

复制代码

package tests
import (
  "fmt"
  "reflect"
  "testing"
)
// 创建struct
func TestReflect18(t *testing.T) {
  userT := reflect.TypeOf(User{})
  value := reflect.New(userT) //根据reflect.Type创建一个对象，得到该对象的指针，再根据指针提到reflect.Value
  value.Elem().FieldByName("Id").SetInt(10)
  user := value.Interface().(*User) //把反射类型转成go原始数据类型Call([]reflect.Value{})
  fmt.Println(user.GetName())
}
// 创建map
func TestReflect19(t *testing.T) {
  var slice []User
  sliceType := reflect.TypeOf(slice)
  sliceValue := reflect.MakeSlice(sliceType, 1, 3)
  sliceValue.Index(0).Set(reflect.ValueOf(User{
    Id:     8,
    Name:   "李达",
    Weight: 80,
    Height: 180,
  }))
  users := sliceValue.Interface().([]User)
  fmt.Printf("1st user name %s\n", users[0].Name)
  fmt.Println(sliceValue.Interface().([]User))
}
// 创建slice
func TestReflect20(t *testing.T) {
  var userMap map[int]*User
  mapType := reflect.TypeOf(userMap)
  //mapValue := reflect.MakeMap(mapType)
  mapValue := reflect.MakeMapWithSize(mapType, 10)
  user := &User{
    Id:     7,
    Name:   "杰克逊",
    Weight: 65.5,
    Height: 1.68,
  }
  key := reflect.ValueOf(user.Id)
  mapValue.SetMapIndex(key, reflect.ValueOf(user))                    //SetMapIndex 往map里添加一个key-value对
  mapValue.MapIndex(key).Elem().FieldByName("Name").SetString("令狐一刀") //MapIndex 根据Key取出对应的map
  userMap = mapValue.Interface().(map[int]*User)
  fmt.Printf("user name %s %s\n", userMap[7].Name, user.Name)
}

common

复制代码

package tests
import (
  "reflect"
)
type User struct {
  Id      int
  Name    string
  Weight  float64
  Height  float64
  address string
}
func (Copy User) GetName() string {
  return Copy.Name
}
func (Ptr *User) UpdateName(name string) {
  Ptr.Name = name
}
type VIPUser struct {
  User
  level int
}
type People interface {
  Body() string
}
func (Copy User) Body() string {
  return ""
}
var (
  iValue       = reflect.ValueOf(1)
  sValue       = reflect.ValueOf("hello")
  userPtrValue = reflect.ValueOf(&User{
    Id:     7,
    Name:   "Handsome",
    Weight: 65,
    Height: 1.68,
  })
  i    = 10
  s    = "hello"
  user = User{
    Id:     7,
    Name:   "杰克逊",
    Weight: 65.5,
    Height: 1.68,
  }
  valueI    = reflect.ValueOf(&i) //由于go语言所有函数传的都是值，所以要想修改原来的值就需要传指针
  valueS    = reflect.ValueOf(&s)
  valueUser = reflect.ValueOf(&user)
)

实例讲解

复制代码

// List 查询列表
func List[T any]() {
  indexName := reflect.ValueOf(new(T)).MethodByName("IndexName").Call([]reflect.Value{})[0].String()
}

以上代码可以拆解为

new(T) 根据 T 的类型，创建一个 *Value 类型的值
ValueOf() 获得它的值
MethodByName() 获得他的成员函数，通过"IndexName"
Call([]Value{}) 调用成员函数，入参为空
[0].string() 拿到函数调用结果返回的第一个值，并拿到他的string的值

路线为 Type -> *Value -> (*Value).func

go 反射Reflect

为什么用反射

reflect.Type

reflect.Value

创建对象

common

实例讲解

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

go 反射Reflect

为什么用反射

reflect.Type

reflect.Value

创建对象

common

实例讲解

热门文章

最新文章

相关课程

相关电子书