Go 反射解析与实战

// 位于 src/runtime/runtime2.go
type eface struct {
    _type *_type                    // 具体的类型
    data  unsafe.Pointer            // 数据
}
type iface struct {
    tab  *itab                    // 指向itab 的指针
    data unsafe.Pointer            // 数据
}

type _type struct {
    size       uintptr         // 类型占用内存大小
    ptrdata    uintptr
    hash       uint32
    tflag          tflag         // 标记位，主要用于反射
    align      uint8           // 对齐字节信息
    fieldAlign     uint8   
    kind       uint8           // 基础类型枚举值,  26 个基础类型, int，ptr，struct，interface 
    equal func(unsafe.Pointer, unsafe.Pointer) bool // 比较两个形参对应对象的类型是否相等
  ...
}

// 位于 src/runtime/iface.go
type itab struct {
    inter  *interfacetype    // 包装了一层*_type，代表接口类型，go 中 中基础类型slice，chan 的类型 都有定义，并且都是包装了一层*_type
    _type  *_type            // 等同于 eface 中的 *_type, 具体对象的类型
    link   *itab
    bad    int32
    inhash int32              // has this itab been added to hash?
    fun    [1]uintptr         // 这里存的是指向第一个方法的指针，其他方法在这个地址后按字典序存储，偏移量即可
}

// 位于 src/runtime/type.go
type interfacetype struct {
    typ     _type
    pkgpath name        // 包路径
    mhdr    []imethod    // 方法
}

type arraytype struct {
    typ   _type
    elem  *_type    // array 上具体元素的类型
    slice *_type
    len   uintptr
}

type chantype struct {
    typ  _type
    elem *_type        // channel 上具体元素的类型
    dir  uintptr
}
// ...

TypeOf(i interface{}) Type        // 对应着 interface 结构体中 *_type
ValueOf(i interface{}) Value    // 结合了data指针与 *_type 类型信息

// 位于 src/reflect/type.go 下
type Type interface {
    Align() int
    FieldAlign() int
    Method(int) Method                                        // 返回类型方法集里的第 `i` (传入的参数)个方法
    MethodByName(string) (Method, bool)     // 通过名称获取方法
    NumMethod() int                                                // 方法个数
    Name() string                                                    // 类型名字
    Size() uintptr
    String() string
    Kind() Kind                                                        // 所属基础类型
    Implements(u Type) bool
    AssignableTo(u Type) bool                            
    ConvertibleTo(u Type) bool                        // 能否转换 u
    Comparable() bool
    Bits() int
    ChanDir() ChanDir                                            // channel 类型的方向
    IsVariadic() bool
    Elem() Type                                                        // 返回内部子元素类型，只能由类型 Array, Chan, Map, Ptr, or Slice 调用
    Field(i int) StructField                            // 获取结构体中的 字段
    FieldByIndex(index []int) StructField
    FieldByName(name string) (StructField, bool)
    FieldByNameFunc(match func(string) bool) (StructField, bool)
    In(i int) Type
    Key() Type                                                // 返回 map 的 key 类型，只能由类型 map 调用
    Len() int
    NumField() int
    NumIn() int                                    // 入参个数
    NumOut() int                                // 出参个数

    Out(i int) Type

    common() *rtype                            // 与 interface 结构中 _type 一一对应
    uncommon() *uncommonType        // 与 interface 结构中 itab 所包含内容对应，所具备的方法，包名
}

// 位于/reflect/type.go 下 struct 类型的结构
type structType struct {
    rtype
    pkgPath name
    fields  []structField // sorted by offset
}

func (t *rtype) FieldByName(name string) (StructField, bool) {
    if t.Kind() != Struct {
        panic("reflect: FieldByName of non-struct type " + t.String())
    }
    tt := (*structType)(unsafe.Pointer(t))
    return tt.FieldByName(name)
}

// A StructField describes a single field in a struct.
type StructField struct {
    Name string                    // 字段名
    PkgPath string            // 包路径

    Type      Type      // 字段类型
    Tag       StructTag // 字段 tag
    Offset    uintptr   // offset within struct, in bytes
    Index     []int     // index sequence for Type.FieldByIndex
    Anonymous bool      // is an embedded field
}

type Value struct {
    typ *rtype                        // 类型
    ptr unsafe.Pointer        // 实际数据
    flag                                     // 标记位
}

func Copy(dest, src interface{}) error {
    // dest 预期是指向对象的ptr，Go 中是值传递，不是 ptr 的话，修改会无效
    // Indirect 如果这个值是指针，会返回指向的值，其中 flag 会加上 CanAddr 的标记
    destValue := reflect.Indirect(reflect.ValueOf(dest))
    if !destValue.CanAddr() {
        return fmt.Errorf("dest type is not ptr")
    }

    // 反射 src 得到 src 的类型 与 对象值
    srcValue := reflect.ValueOf(src)
    srcType := reflect.TypeOf(src)
    if srcType.Kind() == reflect.Ptr {
        srcType = srcType.Elem()
    }
    // 遍历 src类型字段
    for i := 0; i < srcType.NumField(); i ++ {
        fieldSrc := srcType.Field(i)
        // 根据 src 的字段名 在 dest 的结构中查找
        fieldDest, exist := destValue.Type().FieldByName(fieldSrc.Name)
        // dest 不存在同名的字段跳过
        if !exist {
            continue
        }
        // 判断 src 字段类型能否转化成 dest 字段类型
        if ok := fieldSrc.Type.ConvertibleTo(fieldDest.Type); ok {
            // 获取 src value 对象中具体的字段值，并且转换成 dest 字段的类型
            convertValue := srcValue.FieldByName(fieldSrc.Name).Convert(fieldDest.Type)
            // 设置 dest value 对象的相应字段的值
            destValue.FieldByName(fieldSrc.Name).Set(convertValue)
        }
    }
    return nil
}

// Schema 解析 model 得到的元数据
type Schema struct {
    Model      interface{}            // 实体对象
    Name       string                 // 实体的名字，作为表名
    Fields     []*Field                // 字段列表，转化成 sql 中用到的信息
    FieldNames []string                // 字段名列表，这里用实体字段名作为 sql 中字段名
    fieldMap   map[string]*Field    // map[字段名] 字段
}

// Field sql 表中字段
type Field struct {
    Name string        // sql 字段名
    Type string        // sql 类型 int bigint..
    Tag  string        // 额外信息，例如 primary key
}

// model 作为与数据库表一一对应的实体，dialect 代表一种类型转换规则，例如 go -> mysql 中 string -> varchar
// 而 go -> sqlite中， string -> text
func Parse(model interface{}, dialect dialect.Dialect) *Schema {
    // 获取 model 的实际类型
    modelType := reflect.Indirect(reflect.ValueOf(model)).Type()
    schema := &Schema{
        Model:    model,
        Name:     modelType.Name(),        // 类型信息中 有实体名字
        fieldMap: map[string]*Field{},
    }
    // 遍历实体中每个字段
    for i := 0; i < modelType.NumField(); i++ {
        // 字段信息
        structField := modelType.Field(i)
        // 字段必须是不是匿名的和对外暴露的
        if !structField.Anonymous && ast.IsExported(structField.Name) {
            // 根据 go 对象 构建 sql 表中字段
            field := &Field{
                Name: structField.Name,        // 字段的名字
                Type: dialect.DataTypeOf(reflect.Indirect(reflect.New(structField.Type))),
                // 这里把 go 中的类型转换成 sql 中的类型，dialect 有多个实现，例如 sqlite， mysql
            }
            // 从 structFiled 获取需要的 tag 信息
            if v, ok := structField.Tag.Lookup("orm"); ok {
                field.Tag = v
            }
            // 存入 schema 中
            schema.Fields = append(schema.Fields, field)
            schema.FieldNames = append(schema.FieldNames, field.Name)
            schema.fieldMap[field.Name] = field
        }
    }
    return schema
}