【go源码分析】go源码之反射reflect源码分析
1. 反射描述
反射是指能够自描述和自控制，通过采用某种机制来实现对自己行为的描述。Golang语言实现了反射，反射机制就是在运行时动态的调用对象的方法和属性，官方自带的reflect包就是反射相关的
Golang设计的原则中变量包括（type, value）两部分，反射主要与Golang的interface类型相关，只有interface类型才有反射机制，实现路径为src/reflect文件中
1.1 静态类型
静态类型语言。每个变量的类型在编译时都是确定的：int，float32, *AutoType, []byte,
1.2 动态 类型
动态类型：运行时给这个变量复制(如果值为nil的时候没有动态类型)。一个变量的动态类型在运行时可能改变，这主要依赖于它的赋值（前提是这个变量时接口类型）
2. 接口
2.1 Type接口
- Name: 返回类型的名称。 没有类型名称返回空字符串
- Kind: 返回type类型，如2.2所示
- Elem: 如果不是Array, Chan, Map, Ptr, or Slice将产生panic
- Field: 返回第i个字段，只能使用在struct类型，其他类型或者跃界将panic
- Key: 返回map类型的key类型，非map类型将panic
- Len: 返回数组的长度，其他类型将panic
type Type interface {
// Methods applicable to all types.
// Align returns the alignment in bytes of a value of
// this type when allocated in memory.
Align() int
// FieldAlign returns the alignment in bytes of a value of
// this type when used as a field in a struct.
FieldAlign() int
Name() string
Kind() Kind
Elem() Type
// Field returns a struct type's i'th field.
// It panics if the type's Kind is not Struct.
// It panics if i is not in the range [0, NumField()).
Field(i int) StructField
// Key returns a map type's key type.
// It panics if the type's Kind is not Map.
Key() Type
// Len returns an array type's length.
// It panics if the type's Kind is not Array.
Len() int2.2 Kind类型
const (
Invalid Kind = iota
Bool
Int
Int8
Int16
Int32
Int64
Uint
Uint8
Uint16
Uint32
Uint64
Uintptr
Float32
Float64
Complex64
Complex128
Array
Chan
Func
Interface
Map
Ptr
Slice
String
Struct
UnsafePointer
) 2.3 emptyInterface结构体
// emptyInterface is the header for an interface{} value.
type emptyInterface struct {
typ *rtype
word unsafe.Pointer
}
3. Type
3.1 TypeOf函数
动态获取输入参数接口中的值的类型，如果接口为空则返回nil
转换为emptyInterface
// TypeOf returns the reflection Type that represents the dynamic type of i.
// If i is a nil interface value, TypeOf returns nil.
func TypeOf(i interface{}) Type {
eface := *(*emptyInterface)(unsafe.Pointer(&i))
return toType(eface.typ)
}
3.2 rtype结构体，实现了Type接口
size:存储这个类型的一个值所需要的字节数（值占用的字节数）algin:这个类型的一个变量在内存中的对齐后的所用的字节数 （变量占的字节数）FieldAlign: 这种类型的变量如果是struct中的字段，那么它对齐后所用的字节数
// rtype is the common implementation of most values.
// It is embedded in other struct types.
//
// rtype must be kept in sync with ../runtime/type.go:/^type._type.
type rtype struct {
size uintptr
ptrdata uintptr // number of bytes in the type that can contain pointers
hash uint32 // hash of type; avoids computation in hash tables
tflag tflag // extra type information flags
align uint8 // alignment of variable with this type
fieldAlign uint8 // alignment of struct field with this type
kind uint8 // enumeration for C
alg *typeAlg // algorithm table
gcdata *byte // garbage collection data
str nameOff // string form
ptrToThis typeOff // type for pointer to this type, may be zero
}
4. Value
Value描述对象的值信息，并不是所有的方法对任何的类型都有意义，特定的方法只适用于特定的类型
type Value struct {
// typ holds the type of the value represented by a Value.
typ *rtype
// Pointer-valued data or, if flagIndir is set, pointer to data.
// Valid when either flagIndir is set or typ.pointers() is true.
ptr unsafe.Pointer
// flag holds metadata about the value.
// The lowest bits are flag bits:
// - flagStickyRO: obtained via unexported not embedded field, so read-only
// - flagEmbedRO: obtained via unexported embedded field, so read-only
// - flagIndir: val holds a pointer to the data
// - flagAddr: v.CanAddr is true (implies flagIndir)
// - flagMethod: v is a method value.
// The next five bits give the Kind of the value.
// This repeats typ.Kind() except for method values.
// The remaining 23+ bits give a method number for method values.
// If flag.kind() != Func, code can assume that flagMethod is unset.
// If ifaceIndir(typ), code can assume that flagIndir is set.
flag
// A method value represents a curried method invocation
// like r.Read for some receiver r. The typ+val+flag bits describe
// the receiver r, but the flag's Kind bits say Func (methods are
// functions), and the top bits of the flag give the method number
// in r's type's method table.
}
总结
Golang reflect慢主要有两个原因
- 涉及到内存分配以及后续的GC
- reflect实现里面有大量的枚举，也就是for循环，比如类型之类的
示例
package main
import (
"fmt"
"reflect"
)
type Bird struct {
name string
age int
location string
}
func (b Bird) Sing() string {
return "sing func"
}
func (b *Bird) Fly() string {
return "fly func"
}
func (b *Bird) Eat() {
}
func main() {
bird := Bird{
name: "pig",
age: 100,
location: "Beijing",
}
t := reflect.TypeOf(bird)
fmt.Printf("type t = %#v\n", t)
fmt.Printf("type name = %#v\n", t.Name())
fmt.Printf("type string = %#v\n", t.String())
fmt.Printf("type pkg path = %#v\n", t.PkgPath())
fmt.Printf("type kind = %#v\n", t.Kind())
fmt.Printf("type size = %#v\n", t.Size())
fieldType, _ := t.FieldByName("age")
fmt.Printf("type field: %v", fieldType)
v := reflect.ValueOf(bird)
fmt.Printf("value of: %#v\n", v)
fmt.Printf("value of Type: %#v\n", v.Type())
fmt.Printf("value of Type name: %#v\n", v.Type().Name())
fmt.Printf("value of Type size: %#v\n", v.Type().Size())
fmt.Printf("value of Type kind: %#v\n", v.Type().Kind())
fieldValue := v.FieldByName("age")
fmt.Printf("value field age = %#v", fieldValue)
}