Go语言反射（reflection）简述

反射的基本概念

reflect 包

反射的类型对象（reflect.Type）

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var a int
    typeOfA := reflect.TypeOf(a)
    fmt.Println(typeOfA.Name(), typeOfA.Kind())
}

int  int

• 第 9 行，定义一个 int 类型的变量。
• 第 10 行，通过 reflect.TypeOf() 取得变量 a 的类型对象 typeOfA，类型为 reflect.Type()。
• 第 11 行中，通过 typeOfA 类型对象的成员函数，可以分别获取到 typeOfA 变量的类型名为 int，种类（Kind）为 int。

反射的类型（Type）与种类（Kind）

1) 反射种类（Kind）的定义

type Kind uint

const (
    Invalid Kind = iota  // 非法类型
    Bool                 // 布尔型
    Int                  // 有符号整型
    Int8                 // 有符号8位整型
    Int16                // 有符号16位整型
    Int32                // 有符号32位整型
    Int64                // 有符号64位整型
    Uint                 // 无符号整型
    Uint8                // 无符号8位整型
    Uint16               // 无符号16位整型
    Uint32               // 无符号32位整型
    Uint64               // 无符号64位整型
    Uintptr              // 指针
    Float32              // 单精度浮点数
    Float64              // 双精度浮点数
    Complex64            // 64位复数类型
    Complex128           // 128位复数类型
    Array                // 数组
    Chan                 // 通道
    Func                 // 函数
    Interface            // 接口
    Map                  // 映射
    Ptr                  // 指针
    Slice                // 切片
    String               // 字符串
    Struct               // 结构体
    UnsafePointer        // 底层指针
)

2) 从类型对象中获取类型名称和种类

package main

import (
    "fmt"
    "reflect"
)

// 定义一个Enum类型
type Enum int

const (
    Zero Enum = 0
)

func main() {
    // 声明一个空结构体
    type cat struct {
    }
    // 获取结构体实例的反射类型对象
    typeOfCat := reflect.TypeOf(cat{})
    // 显示反射类型对象的名称和种类
    fmt.Println(typeOfCat.Name(), typeOfCat.Kind())
    // 获取Zero常量的反射类型对象
    typeOfA := reflect.TypeOf(Zero)
    // 显示反射类型对象的名称和种类
    fmt.Println(typeOfA.Name(), typeOfA.Kind())
}

cat struct
Enum int

• 第 17 行，声明结构体类型 cat。
• 第 20 行，将 cat 实例化，并且使用 reflect.TypeOf() 获取被实例化后的 cat 的反射类型对象。
• 第 22 行，输出 cat 的类型名称和种类，类型名称就是 cat，而 cat 属于一种结构体种类，因此种类为 struct。
• 第 24 行，Zero 是一个 Enum 类型的常量。这个 Enum 类型在第 9 行声明，第 12 行声明了常量。如没有常量也不能创建实例，通过 reflect.TypeOf() 直接获取反射类型对象。
• 第 26 行，输出 Zero 对应的类型对象的类型名和种类。

指针与指针指向的元素

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 声明一个空结构体
    type cat struct {
    }
    // 创建cat的实例
    ins := &cat{}
    // 获取结构体实例的反射类型对象
    typeOfCat := reflect.TypeOf(ins)
    // 显示反射类型对象的名称和种类
    fmt.Printf("name:'%v' kind:'%v'\n", typeOfCat.Name(), typeOfCat.Kind())
    // 取类型的元素
    typeOfCat = typeOfCat.Elem()
    // 显示反射类型对象的名称和种类
    fmt.Printf("element name: '%v', element kind: '%v'\n", typeOfCat.Name(), typeOfCat.Kind())
}

name:'' kind:'ptr'
element name: 'cat', element kind: 'struct'

• 第 13 行，创建了 cat 结构体的实例，ins 是一个 *cat 类型的指针变量。
• 第 15 行，对指针变量获取反射类型信息。
• 第 17 行，输出指针变量的类型名称和种类。Go语言的反射中对所有指针变量的种类都是 Ptr，但需要注意的是，指针变量的类型名称是空，不是 *cat。
• 第 19 行，取指针类型的元素类型，也就是 cat 类型。这个操作不可逆，不可以通过一个非指针类型获取它的指针类型。
• 第 21 行，输出指针变量指向元素的类型名称和种类，得到了 cat 的类型名称（cat）和种类（struct）。

使用反射获取结构体的成员类型

1) 结构体字段类型

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

• Name：为字段名称。
• PkgPath：字段在结构体中的路径。
• Type：字段本身的反射类型对象，类型为 reflect.Type，可以进一步获取字段的类型信息。
• Tag：结构体标签，为结构体字段标签的额外信息，可以单独提取。
• Index：FieldByIndex 中的索引顺序。
• Anonymous：表示该字段是否为匿名字段。

2) 获取成员反射信息

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 声明一个空结构体
    type cat struct {
        Name string
        // 带有结构体tag的字段
        Type int `json:"type" id:"100"`
    }
    // 创建cat的实例
    ins := cat{Name: "mimi", Type: 1}
    // 获取结构体实例的反射类型对象
    typeOfCat := reflect.TypeOf(ins)
    // 遍历结构体所有成员
    for i := 0; i < typeOfCat.NumField(); i++ {
        // 获取每个成员的结构体字段类型
        fieldType := typeOfCat.Field(i)
        // 输出成员名和tag
        fmt.Printf("name: %v  tag: '%v'\n", fieldType.Name, fieldType.Tag)
    }
    // 通过字段名, 找到字段类型信息
    if catType, ok := typeOfCat.FieldByName("Type"); ok {
        // 从tag中取出需要的tag
        fmt.Println(catType.Tag.Get("json"), catType.Tag.Get("id"))
    }
}

name: Name  tag: ''
name: Type  tag: 'json:"type" id:"100"'
type 100

• 第 10 行，声明了带有两个成员的 cat 结构体。
• 第 13 行，Type 是 cat 的一个成员，这个成员类型后面带有一个以 ` 开始和结尾的字符串。这个字符串在Go语言中被称为 Tag（标签）。一般用于给字段添加自定义信息，方便其他模块根据信息进行不同功能的处理。
• 第 16 行，创建 cat 实例，并对两个字段赋值。结构体标签属于类型信息，无须且不能赋值。
• 第 18 行，获取实例的反射类型对象。
• 第 20 行，使用 reflect.Type 类型的 NumField() 方法获得一个结构体类型共有多少个字段。如果类型不是结构体，将会触发宕机错误。
• 第 22 行，reflect.Type 中的 Field() 方法和 NumField 一般都是配对使用，用来实现结构体成员的遍历操作。
• 第 24 行，使用 reflect.Type 的 Field() 方法返回的结构不再是 reflect.Type 而是 StructField 结构体。
• 第 27 行，使用 reflect.Type 的 FieldByName() 根据字段名查找结构体字段信息，catType 表示返回的结构体字段信息，类型为 StructField，ok 表示是否找到结构体字段的信息。
• 第 29 行中，使用 StructField 中 Tag 的 Get() 方法，根据 Tag 中的名字进行信息获取。

结构体标签（Struct Tag）

1) 结构体标签的格式

`key1:"value1" key2:"value2"`

2) 从结构体标签中获取值

• func (tag StructTag) Get(key string) string：根据 Tag 中的键获取对应的值，例如`key1:"value1" key2:"value2"`的 Tag 中，可以传入“key1”获得“value1”。
• func (tag StructTag) Lookup(key string) (value string, ok bool)：根据 Tag 中的键，查询值是否存在。

3) 结构体标签格式错误导致的问题

package main

import (
    "fmt"
    "reflect"
)

func main() {
    type cat struct {
        Name string
        Type int `json: "type" id:"100"`
    }
    typeOfCat := reflect.TypeOf(cat{})
    if catType, ok := typeOfCat.FieldByName("Type"); ok {
        fmt.Println(catType.Tag.Get("json"))
    }
}

type cat struct {
    Name string
    Type int `json:"type" id:"100"`
}

type

• 斗罗大陆钻石兑换码是多少_服务器
• ess公司创始人_数据库
• steam上买不了黑手党1_服务器
• 小鸟云的CPS代理分销可以叠加他们这次五周年活动吗_服务器
• 中欧班列过境一个国家要给多少钱_数据库
• 计算机中ROM和RAM是什么含义_数据库
• 如何连接到外网_服务器
• 作为一个没有专业技术的普通职员_数据库
• 如何才能实现管理上的高效_数据库
• 26的威力究竟有多大_服务器
• 体内有一股抱怨的气_java
• access中的类和对象和事件是什么意思_数据库
• 请问农行的pos机提示上电失败是怎么回事_服务器
• 手机号码服务器忘记了怎么办_服务器
• 含n的单词有n哪些_数据库
• 长安cs55plus几个usb插口_服务器
• 华为mate50需要升级吗_服务器
• 服务器内存条4r_服务器
• 交易猫不能交易混沌服吗_服务器
• knx协议详解_java