go语言reflect包最佳实践之struct操作（遍历、赋值与方法调用）
go语言reflect包最佳实践之struct操作（遍历、赋值与方法调用）
1. 反射基本概念
反射是指在程序运行期对程序本身进行访问和修改的能力。程序在编译时，变量被转换为内存地址，变量名不会被编译器写入到可执行部分。在运行程序时，程序无法获取自身的信息。
支持反射的语言可以在程序编译期将变量的反射信息，如字段名称、类型信息、结构体信息等整合到可执行文件中，并给程序提供接口访问反射信息，这样就可以在程序运行期获取类型的反射信息，并且有能力修改它们。
Go程序在运行期使用reflect包访问程序的反射信息。
golang中的接口值是两字节的数据结构，两个字节各是一个指针，其中：
- 第一个指针指向一个叫做iTable的内部表，表中包含两方面内容，一是值的类型信息，二是值的方法集
- 第二个指针指向实际存储的值。
对应地，任意接口值在go反射中都分为reflect.Type和reflect.Value两部分，我们可分别通过reflect.TypeOf()和reflect.ValueOf()函数对象的Type和Value。
本文将使用reflect包对结构体进行遍历、赋值与方法调用操作，以熟悉了解reflect包的基本概念与使用。
2. struct字段的遍历
2.1 简单结构体的遍历
首先定义一个如下的简单结构体，如程序所示，共有三个字段。
type Employee struct {
Name string
Role string
Salary float64
}
下面，我们尝试用reflect包对一个Employee类型的值进行遍历，要求输出字段的名称、类型和值。
var xiaowang = &Employee{
Name: "xiaowang",
Role: "glory engineer",
Salary: 0.5,
}
func traverse(target interface{}) {
sVal := reflect.ValueOf(target)
sType := reflect.TypeOf(target)
if sType.Kind() == reflect.Ptr {
//用Elem()获得实际的value
sVal = sVal.Elem()
sType = sType.Elem()
}
num := sVal.NumField()
for i := 0; i < num; i++ {
f := sType.Field(i)
val := sVal.Field(i).Interface()
fmt.Printf("%5s %v = %v\n", f.Name, f.Type, val)
}
}
func main() {
traverse(xiaowang)
}
需要注意的是，程序在正式遍历字段前，对种类(Kind)为指针(reflect.Ptr)的值调用了Elem()方法，令其指向实际的值。
（而事实上，reflect.Value.NumField()与reflect.Value.Field()等方法均需要调用者的种类(Kind)为结构体(reflect.Struct)，否则程序会panic。）
运行程序，输出如下，可见已成功遍历了结构体的各字段
Name string = xiaowang
Role string = glory engineer
Salary float64 = 0.5
2.2 复杂结构体的遍历
考虑字段类型为结构体的特殊情况，比如
type ComplexStruct struct {
CField1 string
CField2 *SimpleStruct
CField3 []string
}
我们需要将程序简单修改为递归遍历的结构，如下所示
var ComplexTarget = &ComplexStruct{
CField1: "CValue1",
CField2: SimpleTarget,
CField3: []string{"CValue3", "sadf"},
}
func traverse2(target interface{}) {
sVal := reflect.ValueOf(target)
sType := reflect.TypeOf(target)
if sType.Kind() == reflect.Ptr {
sVal = sVal.Elem()
sType = sType.Elem()
}
num := sVal.NumField()
for i := 0; i < num; i++ {
//判断字段是否为结构体类型，或者是否为指向结构体的指针类型
if sVal.Field(i).Kind() == reflect.Struct || (sVal.Field(i).Kind() == reflect.Ptr && sVal.Field(i).Elem().Kind() == reflect.Struct) {
traverse2(sVal.Field(i).Interface())
} else {
f := sType.Field(i)
val := sVal.Field(i).Interface()
fmt.Printf("%5s %v = %v\n", f.Name, f.Type, val)
}
}
}
func main() {
traverse2(ComplexTarget)
}
每次访问字段都先判断其是否为结构体类型，或者是否为指向结构体的指针类型，若是则递归调用递归方法，否则直接输出访问结果即可。
运行程序，可得如下输出，可见已实现了期望的递归遍历的功能。
TeamName string = urTeam
Name string = xiaowang
Role string = glory engineer
Salary float64 = 0.5
Duty []string = [code debug]
3. struct赋值操作（根据map构建新struct）
给定一个map值，我们根据该map提供的信息，恢复构建出一个Employee类型的值
var employeeData = map[string]interface{}{
"name": "laozhang",
"role": "annother glory engineer",
"salary": 1.5,
}
针对employeeData中key与结构体中字段名大小写不一致的问题，我们在Employee结构体定义中，给字段加入一些tag信息。（由于map信息往往由外部给出，其key不一定满足go的字段命名习惯，故直接修改字段名的方法来达到两者一致是不合适的。）
type Employee struct {
Name string `key:"name"`
Role string `key:"role"`
Salary float64 `key:"salary"`
}
在对结构体对象赋值过程中，需要注意两方面的内容：
- 用reflect.Value.Set()方法给对应字段赋值，注意该方法的传入参数是reflect.Value类型的
- 在给字段赋值前需要进行类型检查，若map中的value和字段类型一致，则可以直接调用Set()方法赋值；若两者类型不一致，则需调用reflect.Type.ConvertibleTo()方法来判断是否可以进行类型转换，若可转换则调用reflect.Value.Convert()方法转换传参类型，倘若不可转换而强行调用Convert()方法，会导致程序panic。为了简便起见，若类型不可转换，我们在程序中同样返回panic并给出错误信息。
func rebuiltStruct(mapData map[string]interface{}, target interface{}) {
sVal := reflect.ValueOf(target)
sType := reflect.TypeOf(target)
if sType.Kind() == reflect.Ptr {
sVal = sVal.Elem()
sType = sType.Elem()
}
num := sVal.NumField()
for i := 0; i < num; i++ {
f := sType.Field(i)
val := sVal.Field(i)
key := f.Tag.Get("key")
if dataVal, ok := mapData[key]; ok {
//类型判断与转换
dataType := reflect.TypeOf(dataVal)
fieldType := val.Type()
if dataType == fieldType {
val.Set(reflect.ValueOf(dataVal))
} else {
if dataType.ConvertibleTo(fieldType) {
val.Set(reflect.ValueOf(dataVal).Convert(fieldType))
} else {
panic(fmt.Sprintf("failed to convert from %s to %s \n", dataType, fieldType))
}
}
} else {
fmt.Printf("key %s not found in struct definition! \n", key)
}
}
traverse2(target)
}
func main() {
rebuiltStruct(employeeData, &Employee{})
}
运行上述程序，可得输出如下
Name string = laozhang
Role string = annother glory engineer
Salary float64 = 1.5
4. 调用struct的方法
4.1 方法遍历与无参调用
首先，我们对Employee结构体增加两个方法：
func (e Employee) Code() {
fmt.Printf("I like to code \n")
}
func (e Employee) Debug() {
fmt.Printf("I dislike to debug \n")
}
func (e Employee) raiseSalary() {
fmt.Printf("I want to raise my salasy \n")
}
接着我们编写程序，用reflect遍历调用两个方法：
func callMethodWithReflect(x interface{}) {
t := reflect.TypeOf(x).Elem()
v := reflect.ValueOf(x).Elem()
if t.Kind() == reflect.Ptr {
v = v.Elem()
t = t.Elem()
}
//NumMethod()只会计算导出的方法，即首字母大写的方法
numOfMethod := v.NumMethod()
fmt.Printf("We have %v methods. \n", numOfMethod)
//以索引的方式遍历调用所有的方法
for i := 0; i < numOfMethod; i++ {
methodName := t.Method(i).Name
methodType := t.Method(i).Type
//方法的Type也可以用v.Method(i).Type()获得
fmt.Printf("method-%v name is %s \n", i, methodName)
fmt.Printf("method-%v type is %s \n", i, methodType)
args := []reflect.Value{} //不含参调用
v.Method(i).Call(args)
}
}
运行程序可得如下结果，发现程序只调用了Code()和Debug()，忽略了raiseSalary()方法。这是因为reflect.Value.NumMethod()只能发现导出（首字母大写）的方法，而reflect.Type.Method()也只能访问到导出的方法。
需要注意的是，reflect.Type.Method()方法返回的仍是一个reflect.Value类型的值，只不过其Kind为Func。在调用方法时，reflect.Value.Call()方法的入参是一个reflect.Value的切片，且若Call()方法的调用者的Kind不是Func种类，程序会panic。
We have 2 methods.
method-0 name is Code
method-0 type is func(main.Employee)
I like to code
method-1 name is Debug
method-1 type is func(main.Employee)
I dislike to debug
因此若修改方法raiseSalary()为导出方法，
func (e Employee) RaiseSalary() {
fmt.Printf("I want to raise my salary \n")
}
再重新执行程序可以发现三个方法均已被遍历到
We have 3 methods.
...
...
method-2 name is RaiseSalary
method-2 type is func(main.Employee)
I want to raise my salary
4.2 按方法名调用
我们再增加一个含参数方法
func (e Employee) Work(i int) {
fmt.Printf("I work for %v hours per day. \n", i)
}
下面，通过指定方法名的方法调用它
func callByMethodName(x interface{}) {
t := reflect.TypeOf(x).Elem()
v := reflect.ValueOf(x).Elem()
if t.Kind() == reflect.Ptr {
v = v.Elem()
t = t.Elem()
}
//通过方法名调用指定方法,这里同样无法调用未导出的方法
printMethod := v.MethodByName("Work")
//此处需注意判断Zero Value
if printMethod.IsValid() {
args := []reflect.Value{reflect.ValueOf(10)}
printMethod.Call(args)
} else {
fmt.Printf("method not found!")
}
}
这里需要注意以下容易踩坑的地方：
- reflect.Value.MethodByName()同样只能访问到导出了的方法，若传入了未导出的方法名，方法会返回一个零值(Zero Value)，而不会报错
- 若直接对零值(Zero Value)调用Call()方法，程序会panic，故在调用Call()之前需验证返回值是否为零值。
- 验证一个值是否是零值(Zero Value)，千万不可以用isZero()方法，否则程序会panic。这是因为零值不是IsZero方法返回true的值，而是IsValid方法返回false的值。在golang文档中，有如下说明："The zero Value represents no value. Its IsValid method returns false, its Kind method returns Invalid, its String method returns "", and all other methods panic." 即，零值的IsValid方法返回false，其Kind方法返回Invalid，其String方法返回""，对零值的任何其他方法的调用均会导致panic
