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"`
}

在对结构体对象赋值过程中，需要注意两方面的内容：

1. 用reflect.Value.Set()方法给对应字段赋值，注意该方法的传入参数是reflect.Value类型的
2. 在给字段赋值前需要进行类型检查，若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!")
	}
}

这里需要注意以下容易踩坑的地方：

1. reflect.Value.MethodByName()同样只能访问到导出了的方法，若传入了未导出的方法名，方法会返回一个零值(Zero Value)，而不会报错
2. 若直接对零值(Zero Value)调用Call()方法，程序会panic，故在调用Call()之前需验证返回值是否为零值。
3. 验证一个值是否是零值(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

参考链接

• https://www.liwenzhou.com/posts/Go/13_reflect/
• https://www.jianshu.com/p/76c3171857a7
• https://github.com/golang/go/issues/39307