Go 反射
变量机制
在Go语言中，变量分为两部分。
类型信息：预先定义好的变量类型，属于元信息
值信息：程序运行过程中可变化的一部分信息
反射介绍
反射是指在程序运行期对程序本身进行访问和修改的能力。程序在编译时，变量被转换为内存地址，变量名不会被编译器写入到可执行部分。在运行程序时，程序无法获取自身的信息。
支持反射的语言可以在程序编译期将变量的反射信息，如字段名称、类型信息、结构体信息等整合到可执行文件中，并给程序提供接口访问反射信息，这样就可以在程序运行期获取类型的反射信息，并且有能力修改它们。
Go程序在运行期使用reflect包访问程序的反射信息。
空接口可以存储任意类型的变量，那我们如何知道这个空接口保存的数据是什么呢？ 反射就是在运行时动态的获取一个变量的类型信息和值信息。
反射就是对空接口拥有更灵活的处理
reflect包
在Go语言的反射机制中，任何接口值都由是一个具体类型和具体类型的值两部分组成的。
在Go语言中反射的相关功能由内置的reflect包提供，任意接口值在反射中都可以理解为由reflect.Type和reflect.Value两部分组成，并且reflect包提供了reflect.TypeOf和reflect.ValueOf两个函数来获取任意对象的Value和Type。
TypeOf()
在Go语言中，使用reflect.TypeOf()函数可以获得任意值的类型对象（reflect.Type），程序通过类型对象可以访问任意值的类型信息。
该方法获取的类型对象是浅层的，意思在于如果是自定义对象不能获取到其根本的对象。
package main
import (
"fmt"
"reflect"
)
func getType(v1 interface{}){
t := reflect.TypeOf(v1)
fmt.Println(t) // float64
}
func main(){
var num float64
num = 3.14
getType(num)
}
深层类型与种类
Go中由于支持自定义类型，所以还存在深层类型的说法，除此之外还有种类的说法。
如何理解种类呢？比如一个map[string]int64与map[string]interface{}它们的类型并不一样，但是都是属于map这个种类的。
注意：Go语言的反射中像数组、切片、Map、指针等类型的变量，它们的.Name()都是返回空。
package main
import (
"fmt"
"reflect"
)
func getType(v1 interface{}) string {
t := reflect.TypeOf(v1)
return fmt.Sprintf("浅层类型Type：%s,深层类型Name:%s,种类Kind:%s", t, t.Name(), t.Kind())
}
func main() {
var n1 float64
n1 = 3.14
result := getType(n1)
fmt.Println(result) // 浅层类型Type：float64,深层类型Name:float64,种类Kind:float64
type iInt int // 自定义类型
var n2 iInt
n2 = 1000
result = getType(n2)
fmt.Println(result) // 浅层类型Type：main.iInt,深层类型Name:iInt,种类Kind:int
type iFloat = float64 // 类型别名
var n3 iFloat
n3 = 3.15
result = getType(n3)
fmt.Println(result) // 浅层类型Type：float64,深层类型Name:float64,种类Kind:float64
}
在reflect包中，定义的种类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 // 底层指针
)
ValueOf()
reflect.ValueOf()用于返回原始值，下面是支持获取值的类型。
| 方法 | 说明 |
|---|---|
| Interface() interface {} | 将值以 interface{} 类型返回，可以通过类型断言转换为指定类型 |
| Int() int64 | 将值以 int 类型返回，所有有符号整型均可以此方式返回 |
| Uint() uint64 | 将值以 uint 类型返回，所有无符号整型均可以此方式返回 |
| Float() float64 | 将值以双精度（float64）类型返回，所有浮点数（float32、float64）均可以此方式返回 |
| Bool() bool | 将值以 bool 类型返回 |
| Bytes() []bytes | 将值以字节数组 []bytes 类型返回 |
| String() string | 将值以字符串类型返回 |
反射获取值
如下示例：
package main
import (
"reflect"
"fmt"
)
func getValue(v1 interface{}) interface{} {
value := reflect.ValueOf(v1) // 获取原始值
kind := value.Kind() // 获取种类
switch kind {
case reflect.Int64:
return int64(value.Int()) // 返回
case reflect.Float32, reflect.Float64:
return float32(value.Float())
default:
return "不支持获取该类型"
}
}
func main() {
var n1 float32
n1 = 3.14
result := getValue(n1)
fmt.Printf("%T\n",result) // float32
}
反射设置值
由于在函数中传递的都是值拷贝，以前我们想设置原本的值必须传入指针变量。
通过反射的Elem()方法可以进行值设置，这常用在传入值是空接口时。
package main
import (
"fmt"
"reflect"
)
func setValue(v1 interface{}) { // 传入空接口
value := reflect.ValueOf(v1) // 获取原始值
kind := value.Elem().Kind()
switch kind { // 进行种类捕获
case reflect.Int64:
value.Elem().SetInt(1000) // 若不使用Elem则会抛出异常
case reflect.Float32, reflect.Float64:
value.Elem().SetFloat(1.11)
default:
fmt.Println("你传入的类型让我无法设置")
}
}
func main() {
var n1 float32
n1 = 3.14
setValue(&n1) // 传入地址
fmt.Println(n1) // 1.11
}
IsNil()
使用格式：
func (v Value) IsNil() bool
IsNil()报告v持有的值是否为nil。v持有的值的分类必须是通道、函数、接口、映射、指针、切片之一；否则IsNil()函数会导致panic。
IsNil()常被用于判断指针是否为空
package main
import (
"fmt"
"reflect"
)
func main() {
var a *int // int类型空指针
fmt.Println(reflect.ValueOf(a).IsNil()) // true
}
IsVaild()
使用格式：
func (v Value) IsValid() bool
IsValid()返回v是否持有一个值。如果v是Value零值会返回假，此时v除了IsValid()、String()、Kind()之外的方法都会导致panic()。
IsValid()常被用于判定返回值是否有效。
package main
import (
"fmt"
"reflect"
)
func main() {
b := struct{}{}
// 尝试从结构体中查找"abc"字段
fmt.Println("不存在的结构体成员:", reflect.ValueOf(b).FieldByName("abc").IsValid())
// 尝试从结构体中查找"abc"方法
fmt.Println("不存在的结构体方法:", reflect.ValueOf(b).MethodByName("abc").IsValid())
// map
c := map[string]int{}
// 尝试从map中查找一个不存在的键
fmt.Println("map中不存在的键：", reflect.ValueOf(c).MapIndex(reflect.ValueOf("和尚")).IsValid())
}
结构体反射
JSON是如何反序列化为结构体的？这就蕴含结构体反射的内容了。
任意值通过reflect.TypeOf()获得反射对象信息后，如果它的类型是结构体，可以通过反射值对象（reflect.Type）的NumField()和Field()方法获得结构体成员的详细信息。
reflect.Type中与获取结构体成员相关的的方法如下表所示。
| 方法 | 说明 |
|---|---|
| Field(i int) StructField | 根据索引，返回索引对应的结构体字段的信息。 |
| NumField() int | 返回结构体成员字段数量。 |
| FieldByName(name string) (StructField, bool) | 根据给定字符串返回字符串对应的结构体字段的信息。 |
| FieldByIndex(index []int) StructField | 多层成员访问时，根据 []int 提供的每个结构体的字段索引，返回字段的信息。 |
| FieldByNameFunc(match func(string) bool) (StructField,bool) | 根据传入的匹配函数匹配需要的字段。 |
| NumMethod() int | 返回该类型的方法集中方法的数目 |
| Method(int) Method | 返回该类型方法集中的第i个方法 |
| MethodByName(string)(Method, bool) | 根据方法名返回该类型方法集中的方法 |
StructField类型
StructField类型用来描述结构体中的一个字段的信息。
StructField的定义如下：
type StructField struct {
// Name是字段的名字。PkgPath是非导出字段的包路径，对导出字段该字段为""。
// 参见http://golang.org/ref/spec#Uniqueness_of_identifiers
Name string
PkgPath string
Type Type // 字段的类型
Tag StructTag // 字段的标签
Offset uintptr // 字段在结构体中的字节偏移量
Index []int // 用于Type.FieldByIndex时的索引切片
Anonymous bool // 是否匿名字段
}
结构体反射示例
当我们使用反射得到一个结构体数据之后可以通过索引依次获取其字段信息，也可以通过字段名去获取指定的字段信息。
type student struct {
Name string `json:"name"`
Score int `json:"score"`
}
func main() {
stu1 := student{
Name: "小王子",
Score: 90,
}
t := reflect.TypeOf(stu1)
fmt.Println(t.Name(), t.Kind()) // student struct
// 通过for循环遍历结构体的所有字段信息
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
fmt.Printf("name:%s index:%d type:%v json tag:%v\n", field.Name, field.Index, field.Type, field.Tag.Get("json"))
}
// 通过字段名获取指定结构体字段信息
if scoreField, ok := t.FieldByName("Score"); ok {
fmt.Printf("name:%s index:%d type:%v json tag:%v\n", scoreField.Name, scoreField.Index, scoreField.Type, scoreField.Tag.Get("json"))
}
}
接下来编写一个函数printMethod(s interface{})来遍历打印s包含的方法。
// 给student添加两个方法 Study和Sleep(注意首字母大写)
func (s student) Study() string {
msg := "好好学习，天天向上。"
fmt.Println(msg)
return msg
}
func (s student) Sleep() string {
msg := "好好睡觉，快快长大。"
fmt.Println(msg)
return msg
}
func printMethod(x interface{}) {
t := reflect.TypeOf(x)
v := reflect.ValueOf(x)
fmt.Println(t.NumMethod())
for i := 0; i < v.NumMethod(); i++ {
methodType := v.Method(i).Type()
fmt.Printf("method name:%s\n", t.Method(i).Name)
fmt.Printf("method:%s\n", methodType)
// 通过反射调用方法传递的参数必须是 []reflect.Value 类型
var args = []reflect.Value{}
v.Method(i).Call(args)
}
}
反射是把双刃剑
反射是一个强大并富有表现力的工具，能让我们写出更灵活的代码。但是反射不应该被滥用，原因有以下三个。
- 基于反射的代码是极其脆弱的，反射中的类型错误会在真正运行的时候才会引发panic，那很可能是在代码写完的很长时间之后。
- 大量使用反射的代码通常难以理解。
- 反射的性能低下，基于反射实现的代码通常比正常代码运行速度慢一到两个数量级。
实例操作
需求分析
解析ini配置文件，如下有一个ini配置文件。
[mysql]
address = 10.20.30.40
port = 3306
username = root
password = rootroot
如何将内容解析到下面这个结构体中？
package main
import (
"errors"
"fmt"
"io/ioutil"
"reflect"
"strconv"
"strings"
)
// Config 配置文件结构体
type Config struct {
MysqlConfig `ini:"mysql"`
}
// MysqlConfig MySQL配置结构体，结构体字段需要与配置文件中的对应。
type MysqlConfig struct {
Address string `ini:"address"`
Port int `ini:"port"`
Username string `ini:"username"`
Password string `ini:"password"`
}
func loadIni(fileName string, data interface{}) (err error) {
// 补全代码
}
func main() {
var cfg Config
err := loadIni("./conf.ini", &cfg)
if err != nil {
fmt.Printf("load ini failed err%v \n", err)
return
}
fmt.Println(cfg)
}
解决方案
其实只要打开配置文件每一行进行读取，再拿到结构体字段后对比tag。如果tag相同则将配置文件中的数据写入到结构体中即可。
package main
import (
"errors"
"fmt"
"io/ioutil"
"reflect"
"strconv"
"strings"
)
// Config 配置文件结构体
type Config struct {
MysqlConfig `ini:"mysql"`
}
// MysqlConfig MySQL配置结构体
type MysqlConfig struct {
Address string `ini:"address"`
Port int `ini:"port"`
Username string `ini:"username"`
Password string `ini:"password"`
}
func loadIni(fileName string, data interface{}) (err error) {
var sectionName string // 节点名称
var structName string // 结构体名字
// 参数校验：
// 传入的data参数是否是一个结构体指针类型（要对结构体进行字段填充）
t := reflect.TypeOf(data)
// 判断是否是指针
if t.Kind() != reflect.Ptr {
err = errors.New("data should be a pointer")
return err
}
// 判断是否是结构体指针
if t.Elem().Kind() != reflect.Struct {
err = errors.New("data should be a Struct pointer")
return err
}
// 1.读文件，得到字节类型的数据,转换为字符串
b, err := ioutil.ReadFile(fileName)
if err != nil {
return
}
lineSlice := strings.Split(string(b), "\n")
// 2 一行一行读数据，如果是注释就忽略
// 3 一行一行读数据，如果是[开头的则代表是一个节点
// 4 一行一行读数据，如不不是[开头的就是=号分割的键值对
for idex, line := range lineSlice {
// 去空格
line = strings.TrimSpace(line)
// 过滤空行
if len(line) == 0 {
continue
}
// 这是注释
if strings.HasPrefix(line, ";") {
continue
}
// 这是[开头的节点
if strings.HasPrefix(line, "[") {
// 不合格的节点
if line[0] != '[' || line[len(line)-1] != ']' {
err = fmt.Errorf("line:%d syntax error", idex+1)
return err
}
// []里没有内容
sectionName = strings.TrimSpace(line[1:(len(line) - 1)])
if len(sectionName) == 0 {
err = fmt.Errorf("line:%d syntax error", idex+1)
return err
}
// v := reflect.ValueOf(data)
// 根据sectionName找结构体
for i := 0; i < t.Elem().NumField(); i++ {
field := t.Elem().Field(i)
if sectionName == field.Tag.Get("ini") {
// 找到了嵌套结构体，记录字段名
structName = field.Name
fmt.Printf("找到%s对应的嵌套结构体%s\n", sectionName, structName)
}
}
} else {
// 等号进行分割，k = v
if strings.Index(line, "=") == -1 || strings.HasPrefix(line, "=") || strings.HasSuffix(line, "=") {
err = fmt.Errorf("line:%d syntax error", idex+1)
return err
}
index := strings.Index(line, "=")
key := strings.TrimSpace(line[:index])
value := strings.TrimSpace(line[index+1:])
// 根据strucrName在data中拿到对应的嵌套结构体
v := reflect.ValueOf(data)
sValue := v.Elem().FieldByName(structName) // 拿到嵌套结构体的值信息
sType := sValue.Type() // 拿到嵌套结构体的类型信息
if sType.Kind() != reflect.Struct {
err = fmt.Errorf("data中的%s字段在结构体中不存在", structName)
return err
}
var filedName string
var fileType reflect.StructField
// 遍历嵌套结构体的字段，判断tag是否等于key
for i := 0; i < sValue.NumField(); i++ {
filed := sType.Field(i) // tag信息存储在类型中
fileType = filed
if filed.Tag.Get("ini") == key {
// 找到字段
filedName = filed.Name
break
}
}
if len(filedName) == 0 {
// 结构体中找不到对应的字段
continue
}
// 如果key == tag 给字段进行赋值
fileObj := sValue.FieldByName(filedName)
// 赋值
switch fileType.Type.Kind() {
case reflect.String:
fileObj.SetString(value)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
var valueInt int64
valueInt, err = strconv.ParseInt(value, 10, 64)
if err != nil {
err = fmt.Errorf("line:%d value type error", idex+1)
return err
}
fileObj.SetInt(valueInt)
case reflect.Bool:
var valueBool bool
valueBool, err = strconv.ParseBool(value)
if err != nil {
err = fmt.Errorf("line:%d value type error", idex+1)
return err
}
fileObj.SetBool(valueBool)
case reflect.Float32, reflect.Float64:
var valueFloat float64
valueFloat, err = strconv.ParseFloat(value, 64)
if err != nil {
err = fmt.Errorf("line:%d value type error", idex+1)
return err
}
fileObj.SetFloat(valueFloat)
}
}
}
return
}
func main() {
var cfg Config
err := loadIni("./conf.ini", &cfg)
if err != nil {
fmt.Printf("load ini failed err%v \n", err)
return
}
fmt.Println(cfg)
}
