前言

哈喽，大家好，我是​​asong​​​，今天这篇文章的目的主要是解答一位读者的疑问，涉及知识点是​​反射​​和结构体内存布局。我们先看一下读者的问题：

读者提问：反射是如何获取结构体成员信息的？_java

我们通过两个问题来解决他的疑惑：

  1. 结构体在内存中是如何存储的
  2. 反射获取结构体成员信息的过程

结构体是如何存储的

结构体是占用一块连续的内存，一个结构体变量的大小是由结构体中的字段决定的，结构体变量的地址等于结构体第一个字段的首地址。示例：

type User struct {
 Name string
 Age uint64
 Gender bool // true：男 false: 女
}

func main(){
 u := User{
   Name: "asong",
   Age: 18,
   Gender: false,
  }
 fmt.Printf("%p\n",&u)
 fmt.Printf("%p\n",&u.Name)
}
// 运行结果
0xc00000c060
0xc00000c060

从运行结果我们可以验证了结构体变量​​u​​​的存放地址就是字段​​Name​​的首地址。

结构体的内存布局其实就是分配一段连续的内存，具体是在栈上分配还是堆上分配取决于编译器的逃逸分析，结构体在内存分配时还要考虑到内存对齐。

对齐的作用和原因：​​CPU​​​访问内存时，并不是逐个字节访问，而是以字长（​​word size​​​)单位访问。比如​​32​​​位的​​CPU​​​，字长为​​4​​​字节，那么​​CPU​​​访问内存的单位也是​​4​​​字节。这样设计可以减少​​CPU​​​访问内存的次数，加大​​CPU​​​访问内存的吞吐量。假设我们需要读取8个字节的数据，一次读取​​4​​​个字节那么就只需读取​​2​​次就可以。内存对齐对实现变量的原子性操作也是有好处的，每次内存访问都是原子的，如果变量的大小不超过字长，那么内存对齐后，对该变量的访问就是原子的，这个特性在并发场景下至关重要。

​​C​​​语言的内存对齐规则与​​Go​​​语言一样，所以​​C​​​语言的对齐规则对​​Go​​同样适用：

  • 对于结构的各个成员，第一个成员位于偏移为0的位置，结构体第一个成员的偏移量（offset）为0，以后每个成员相对于结构体首地址的 offset 都是该成员大小与有效对齐值中较小那个的整数倍，如有需要编译器会在成员之间加上填充字节。
  • 除了结构成员需要对齐，结构本身也需要对齐，结构的长度必须是编译器默认的对齐长度和成员中最长类型中最小的数据大小的倍数对齐。

根据这个规则我们来分析一下上面示例的结构体​​User​​​，这里我使用的​​mac​​​，所以是​​64​​​位​​CPU​​​，编译器默认对齐参数是​​8​​​，​​String​​​、​​uint64​​​、​​bool​​​的对齐值分别是​​8​​​、​​8​​​、​​1​​，根据第一条规则分析：

  • 第一个字段类型是​​string​​，对齐值是​​8​​，大小为​​16​​，所以放在内存布局中的第一位。
  • 第二个字段类型是​​uin64​​，对齐值是​​8​​，大小为​​8​​，所以他的内存偏移值必须是​​8​​的倍数，因为第一个字段​​Name​​占有16位，所以直接从​​16​​开始不要补位。
  • 第三个字段类型是​​bool​​，对齐值是​​1​​，大小为​​1​​，所以他的内存偏移值必须是​​1​​的倍数，因为​​User​​的前两个字段已经排到了​​24​​位，所以下一个偏移量正好是​​24​​。

接下来我们在分析第二个规则：

  • 根据第一条内存对齐规则分析后，内存长度已经为​​25​​字节了，我们开始使用第​​2​​条规则进行对齐，默认对齐值是​​8​​，字段中最大类型的长度是​​16​​，所以可以得出该结构体的对齐值是​​8​​，我们目前的内存长度是​​25​​，不是​​8​​的倍数，所以需要补全，所以最终的结果是​​32​​，补了​​7​​位，由编译器进行填充，一般为​​0​​值，也称之为空洞。

读者提问：反射是如何获取结构体成员信息的？_java_02

注意：这里对内存对齐没有说的很细，想要更深了解内存对齐可以看我之前的一篇文章：Go看源码必会知识之unsafe包

Go语言反射获取结构体成员信息

Go语言提供了一种机制在运行时更新和检查变量的值、调用变量的方法和变量的内在操作，但是在编译时并不知道这些变量的具体类型，这种机制被称为反射。Go语言提供了 reflect 包来访问程序的反射信息。

我们可以通过调用​​reflect.TypeOf()​​​获得反射对象信息，如果他的类型是结构体，接着可以通过反射值对象​​reflect.Type​​​的​​NumField​​​和​​Field​​方法获取结构体成员的详细信息，先看一个例子：

type User struct {
 Name string
 Age uint64
 Gender bool // true：男 false: 女
}


func main()  {
 u := User{
  Name: "asong",
  Age: 18,
  Gender: false,
 }
 getType := reflect.TypeOf(u)
 for i:=0; i < getType.NumField(); i++{
  fieldType := getType.Field(i)
  // 输出成员名
  fmt.Printf("name: %v \n", fieldType.Name)
 }
}
// 运行结果
name: Name 
name: Age 
name: Gender

接下来我们就一起来看一看​​Go​​语言是如何通过反射来获取结构体成员信息的。

首先我们来看一看​​reflect.TypeOf()​​方法是如何获取到类型的：

func TypeOf(i interface{}) Type {
 eface := *(*emptyInterface)(unsafe.Pointer(&i))
 return toType(eface.typ)
}

我们知道在​​Go​​​语言中任何类型都可以转成​​interface{}​​类型，当向接口变量赋于一个实体类型的时候，接口会存储实体的类型信息，反射就是通过接口的类型信息实现的。

一个空接口结构如下：

type eface struct {
    _type *_type
    data  unsafe.Pointer
}

​​_type​​​ 字段，表示空接口所承载的具体的实体类型。​​data​​​ 描述了具体的值，Go 语言里所有的类型都 ​​实现了​​ 空接口。

所以在​​TypeOf​​​方法中，我们就是通过读取​​_type​​字段获取到类型。

现在我们已经知道他是怎么获取到具体的类型了，接下来我们就来看一看​​NumField()​​方法是怎么获取到字段的。

func (t *rtype) Kind() Kind { return Kind(t.kind & kindMask) }
func (t *rtype) NumField() int {
 if t.Kind() != Struct {
  panic("reflect: NumField of non-struct type " + t.String())
 }
 tt := (*structType)(unsafe.Pointer(t))
 return len(tt.fields)
}

因为只有​​struct​​​类型才可以调用，所以在​​NumFiled()​​​方法中做了类型检查，如果不是​​struct​​​类型则直接发生​​panic​​​，然后会​​rtype​​​类型强制转换成​​structType​​，最后返回结构体成员字段的数量。

// structType represents a struct type.
type structType struct {
 rtype
 pkgPath name
 fields  []structField // sorted by offset
}
// Struct field
type structField struct {
 name        name    // name is always non-empty
 typ         *rtype  // type of field
 offsetEmbed uintptr // byte offset of field<<1 | isEmbedded
}

调用​​Field()​​​方法会根据索引返回对应的结构体字段的信息，当值不是结构体或索引超界时发生​​panic​​。

func (t *rtype) Field(i int) StructField {
  // 类型检查
 if t.Kind() != Struct {
  panic("reflect: Field of non-struct type " + t.String())
 }
  // 强制转换成structType 类型
 tt := (*structType)(unsafe.Pointer(t))
 return tt.Field(i)
}
// Field returns the i'th struct field.
func (t *structType) Field(i int) (f StructField) {
  // 溢出检查
 if i < 0 || i >= len(t.fields) {
  panic("reflect: Field index out of bounds")
 }
 // 获取之前structType中fields字段的值
 p := &t.fields[i]
  // 转换成StructFiled结构体
 f.Type = toType(p.typ)
 f.Name = p.name.name()
  // 判断是否是匿名结构体
 f.Anonymous = p.embedded()
 if !p.name.isExported() {
  f.PkgPath = t.pkgPath.name()
 }
 if tag := p.name.tag(); tag != "" {
  f.Tag = StructTag(tag)
 }
  // 获取字段的偏移量
 f.Offset = p.offset()
  // 获取索引值
 f.Index = []int{i}
 return
}

返回​​StructField​​结构如下：

// A StructField describes a single field in a struct.
type StructField struct {
   Name string // 字段名
   PkgPath string // 字段路径
   Type      Type      // 字段反射类型对象
   Tag       StructTag // 字段的结构体标签
   Offset    uintptr   // 字段在结构体中的相对偏移
   Index     []int     // Type.FieldByIndex中的返回的索引值
   Anonymous bool      // 是否为匿名字段
}

到这里整个反射获取结构体成员信息的过程应该很明朗了吧～。

**小结：**因为​​Go​​​ 语言里所有的类型都 ​​实现了​​​ 空接口，所以可以根据这个特性获取到数据类型以及存放数据的地址，对于结构体类型，将其转换为​​structType​​​类型，最后转换成​​StructField​​结构获取所有结构体信息。

总结

本文没想详细展开讲解​​Go​​语言反射的原理和过程，只是简单介绍了一下反射获取到结构体成员信息的过程，更多关于反射知识的讲解会在后面持续更新，敬请期待～。


读者提问：反射是如何获取结构体成员信息的？_go_03