目录

Go语言反射获取结构体字段的过程

前言

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

https://song-oss.oss-cn-beijing.aliyuncs.com/golang_dream/article/static/%E6%88%AA%E5%B1%8F2021-07-21%20%E4%B8%8B%E5%8D%889.23.22.png

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

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

结构体是如何存储的

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
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,所以是64CPU,编译器默认对齐参数是8Stringuint64bool的对齐值分别是881,根据第一条规则分析:

  • 第一个字段类型是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值,也称之为空洞。

https://song-oss.oss-cn-beijing.aliyuncs.com/golang_dream/article/static/%E6%88%AA%E5%B1%8F2021-07-25%20%E4%B8%8A%E5%8D%8810.39.33.png

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

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

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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()方法是如何获取到类型的:

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

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

一个空接口结构如下:

1
2
3
4
type eface struct {
    _type *_type
    data  unsafe.Pointer
}

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

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

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

1
2
3
4
5
6
7
8
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,最后返回结构体成员字段的数量。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
// 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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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结构如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
// 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语言反射的原理和过程,只是简单介绍了一下反射获取到结构体成员信息的过程,更多关于反射知识的讲解会在后面持续更新,敬请期待~。

素质三连(分享、点赞、在看)都是笔者持续创作更多优质内容的动力!我是asong,我们下期见。

创建了一个Golang学习交流群,欢迎各位大佬们踊跃入群,我们一起学习交流。入群方式:关注公众号获取。更多学习资料请到公众号领取。

https://song-oss.oss-cn-beijing.aliyuncs.com/golang_dream/article/static/%E6%89%AB%E7%A0%81_%E6%90%9C%E7%B4%A2%E8%81%94%E5%90%88%E4%BC%A0%E6%92%AD%E6%A0%B7%E5%BC%8F-%E7%99%BD%E8%89%B2%E7%89%88-20210717170231906.png

推荐往期文章: