详解Golang中的反射及反射结构体

前言

        反射是在golang程序运行时检查变量所具有类型的一种机制。由于反射可以得出关于变量结构的数据（即“关于数据的数据”），所以这也被认为是golang元编程的基础。我们由反射三法则入手：

从类型和方法理解反射内涵

　　在基本的层面上，反射只是一个检查存储在接口变量中的类型和值的算法。使用反射机制，首先需要导入reflect包，reflect包中有两个重要类型需要了解，reflect.Type和reflect.Value，这两个类型使得可以访问变量的内容。与此相关的，还有两个简单的函数，reflect.TypeOf和reflect.ValueOf，可以从接口值中分别获取reflect.Type和reflect.Value。

　    初学可能会认为reflect.Type和reflect.Value是一种并列关系，但其实它们是一种包含关系，我们结合一段代码来理解这段话。

import (
   "fmt"
   "reflect"
)
   
func main() {
   var x float64 = 1.1
   fmt.Println("reflect.Value:", reflect.ValueOf(x))
   fmt.Println("reflect.Type:", reflect.TypeOf(x))
   v := reflect.ValueOf(x)
   fmt.Println("reflect.Type:",v.Type())
   fmt.Println("actual value:", v.Float())
   fmt.Println("kind is float64?", v.Kind() == reflect.Float64)
}

        根据程序及其结果，我们可以发现：在go语言中，每个值都包含两个内容：类型和实际的值。从类型角度来看，reflect.Value是一个关于<类型, 实际的值>的二元组，而reflect.Type是值的类型，二者是包含关系。从方法角度来看，reflect.TypeOf 和 (reflect.ValueOf(x)).Type都可以返回reflect.Type；(reflect.ValueOf(x)).Float可以返回实际的值（类似的方法还包括(reflect.ValueOf(x)).Int、(reflect.ValueOf(x)).Bool等）；(reflect.ValueOf(x)).Kind可以返回一个常量定义的类型。

    根据上述分析，我们可以得出一个示意图，更为直观形象的表明值、类型、实际的值的关系。

 此外，golang采用静态类型机制，TypeOf返回静态类型；但是，Kind返回底层类型。我们同样以一段代码来验证这段话。

import (
   "fmt"
   "reflect"
)
   
type MyInt int
   
func main() {
   var x MyInt = 1
   v := reflect.ValueOf(x)
   fmt.Println("reflect.Type:", v.Type())
   fmt.Println("kind is int?", v.Kind() == reflect.Int)
}

 

反射三法则

1 法则一：从接口值到反射对象的反射（Reflection goes from interface value toreflection object）

    前文所述内容其实就是从接口值到反射对象的反射，代表方法为reflect.ValueOf和reflect.TypeOf。可能有人会问，接口？接口在哪呢？我们来看一些前文提到这两个函数的声明，函数的参数是空接口，其实接口就在那里。

func ValueOf(i interface{}) Value
func TypeOf(i interface{}) Type

2 法则二：从反射对象到接口值的反射（Reflection goes from reflection object to interface value）

    从reflect.Value可以使用Interface方法还原接口值；此方法可以高效地打包类型和值信息到接口表达中，并返回这个结果。方法声明：

func (v Value) Interface() interface{}

通过反射对象 v 可以打印 float64 的表达值。

y :=v.Interface().(float64) // y 将为类型 float64。
fmt.Println(y)

 还有更为简洁的实现。fmt.Println，fmt.Printf等其他所有传递一个空接口值作为参数的函数，在 fmt包内部解包的方式就像之前的例子这样。因此正确的打印reflect.Value的内容的方法就是将Interface方法的结果进行格式化打印(formatted print routine)。

fmt.Println(v.Interface())

 为什么不是fmt.Println(v)？因为v是一个 reflect.Value；这里希望获得的是它保存的实际的值。

    我们修改前文代码还进行验证：

func main() {
   var x float64 = 1.1
   fmt.Println("reflect.Value:", reflect.ValueOf(x))
   fmt.Println("reflect.Type:", reflect.TypeOf(x))
   v := (reflect.ValueOf(x))
   fmt.Println("reflect.Type:", v.Type())
   fmt.Println("actual value(interface):", v.Interface())
   fmt.Println("kind is float64?", v.Kind() == reflect.Float64)
}

进一步地，我们可以修改上述关系示意图，新图更为简洁优雅：

3. 为了修改反射对象，其值必须可设置（To modify a reflectionobject, the value must be settable）

    反射对象可以通过SetFloat等方法设置值，通过CanSet判断可设置性。但是这里面有坑，有些值是不可设置的。我们还是通过一段代码来看。

 

import (
    "fmt"
    "reflect"
)
   
func main() {
    var x float64 = 1.1
    v := reflect.ValueOf(x)
    fmt.Println("settability of v:",v.CanSet())
    v.SetFloat(1.2)
}

其结果表明，反射对象v是不可设置的，如果硬要设置的话，会有panic异常。

    为什么不能设置呢？我们可以从函数传参的角度来思考这个问题。V := reflect.ValueOf(x)，这个函数是值传递，即传递了一个x的副本到函数中，而非x本身。我们都知道，值传递的参数是不能被真正修改的。

    我最初还有过这样的想法：v和x又不是一个变量，x不能被修改，但是v应该可以被修改啊。完全从形式上考虑，这样似乎有道理。但是再多想一层，如果允许执行，虽然v可以被修改，但是却无法更新x。也就是说，在反射值内部允许修改x的副本，但是x本身却不会受到这个影响。这会造成混乱，并且毫无意义，因此在golang中这样操作是非法的。

    让我们重新用函数传参的角度思考这个问题。如果传递副本不能修改，那我们就通过就传递指针好了。我们来试试：

func main() {
    var x float64 = 1.1
    p := reflect.ValueOf(&x)
    fmt.Println("type of p:",p.Type())
    fmt.Println("settability of p:",p.CanSet())
}

　还是不行。因为p的实际类型是*float64，而非float64，这样修改相当于要直接修改地址了。

　　我们可以借助Elem方法，通过指针来修改指针指向的具体值。

func (v Value)Elem() Value

func main() {
    var x float64 = 1.1
    p := reflect.ValueOf(&x)
    fmt.Println("type of p:",p.Type())
    v := p.Elem()
    fmt.Println("type of v:",v.Type())
    fmt.Println("settability of v:",v.CanSet())
}

这样就可以进行修改了。虽然p是不可修改的，但是v可以修改。这种方法思路上类似引用传参，传入地址，修改地址所指向的具体值。

反射结构体

"反射结构体"是指在程序执行时，遍历结构体中的字段以及方法。

下面使用一个简单的例子说明如何反射结构体。

定义一个结构体，包括3个字段，以及一个方法。

通过reflect包，首先查看这个结构体对应的动态类型reflect.Type和动态值reflect.Value，并查看这个结构体对应的基本类型。

接着查看结构体的字段数量，并遍历每个字段。
打印每个字段的类型、值、以及tag标签。

最后，调用结构体中的方法，并打印返回结果。

具体代码如下。

package main

import (
	"fmt"
	"reflect"
)

type Orange struct {
	size	int	`kitty:"size"`
	Weight	int	`kitty:"wgh"`
	From	string	`kitty:"source"`
}

func (this Orange) GetWeight() int  {
	return this.Weight
}

func main(){

	orange := Orange{1, 18, "Shanghai"}

	refValue := reflect.ValueOf(orange) // value

	refType := reflect.TypeOf(orange)  // type

	fmt.Println("orange refValue:", refValue)
	fmt.Println("orange refType:", refType)

	orangeKind := refValue.Kind() // basic type
	fmt.Println("orange Kind:", orangeKind)

	fieldCount := refValue.NumField() // field count
	fmt.Println("fieldCount:", fieldCount)


	for i:=0; i < fieldCount; i++{
		fieldType := refType.Field(i) // field type
		fieldValue := refValue.Field(i) // field vlaue
		fieldTag := fieldType.Tag.Get("kitty") // field tag

		fmt.Println("fieldTag:", fieldTag)
		fmt.Println("field type:", fieldType.Type)
		fmt.Println("fieldValue:", fieldValue)
		
	}

	// method
	result := refValue.Method(0).Call(nil)
	fmt.Println("method result:", result[0])
}

输出结果：

orange refValue: {1 18 Shanghai}
orange refType: main.Orange
orange Kind: struct
fieldCount: 3
fieldTag: size
field type: int
fieldValue: 1
fieldTag: wgh
field type: int
fieldValue: 18
fieldTag: source
field type: string
fieldValue: Shanghai
method result: 18

另外， 如果反射时，使用的参数是结构体指针：

refValue := reflect.ValueOf(&orange) // value

则需要首先解引用指针，取得指针指向的对象：

refValue = refValue.Elem()

相关函数说明

Value.Kind()

func (v Value) Kind() Kind 

其返回值为Kind,表示golang语言自身定义的基本类型:

type Kind uint 

取值包括：

const (
    Invalid Kind = iota
    Bool
    Int
    Int8
    Int16
    Int32
    Int64
    Uint
    Uint8
    Uint16
    Uint32
    Uint64
    Uintptr
    Float32
    Float64
    Complex64
    Complex128
    Array
    Chan
    Func
    Interface
    Map
    Ptr
    Slice
    String
    Struct
    UnsafePointer
) 

Value.Elem()

func (v Value) Elem() Value 

方法返回v指向的对象。

要求v必须是interface或指针。

Type.Elem()

type Type Interface{
    // Elem returns a type's element type.
	// It panics if the type's Kind is not Array, Chan, Map, Ptr, or Slice.
	Elem() Type
	... ...
}

返回指向对象的具体类型。
要求调用者必须是Array, Chan, Map, Ptr, or Slice。

例如，

i := 1
v := reflect.ValueOf(&i)

valueType := v.Type()
elemType := valueType.Elem()

fmt.Println("valueType:", valueType) //*int
fmt.Println("elemType:", elemType) // int

v是*int，则element type就是int。

例如，

sli := []string{"abc", "ef", "gh", "123"}

v := reflect.ValueOf(sli)

valueType := v.Type()
elemType := valueType.Elem()

fmt.Println("valueType:", valueType) // []string
fmt.Println("elemType:", elemType) // string

v是字符串数组，则element type就是字符串。