1. 引言

反射是现代编程语言中非常重要的一个特性，尤其是在面向对象编程语言中

此前的文章中，我们看到 golang 如何实现面向对象的封装： 通过 GoLang 实现面向对象思想

如果能够熟练运用反射特性，可以在很多情况下写出通用性极强的代码，达到事半功倍的效果，那么，究竟什么是反射，在 golang 中反射又是如何实现的，本文我们就来详细解读。

2. 反射

什么是反射？为什么要使用反射？这是本文开始前必须要解决的两个问题。

2.1. 什么是反射

反射机制是现代编程语言中一个比较高级的特性。 在编译时不知道类型的情况下，通过反射机制可以获取对象的类型、值、方法甚至动态改变对象的成员，这就是反射机制。

2.2. 为什么使用反射

在很多时候，我们都希望代码具备良好的通用性。 最基本的，对于 fmt.Print 函数，他可以接受任意类型的对象作为参数，我们无法罗列出究竟有多少种入参的可能，此时，主动获取入参的类型就可以大大简化代码的编写。 更进一步，对于依赖注入与面向切面等设计模式来说，我们需要为被注入对象动态添加成员，动态调用对象的不同成员。 显然，反射的存在极大地增加了代码的灵活度与通用性。

3. golang 与反射

之前的文章中，我们讲了 golang 的接口： golang 中的接口

golang 的接口作为 golang 语言中运行时类型抽象的主要工具，它的实现与反射机制的实现有着非常密切的关联，他们都涉及 golang 中是如何管理类型的。 golang 中有两种类型：

1. static type — 静态类型，创建变量时指定的类型，如 var str string，str 的类型 string 就是他的静态类型
2. concrete type — 运行时类型，如一个变量实现了接口中全部方法，那么这个变量的 concrete type 就是该接口类型

所以，golang 中，反射是必须与接口类型结合使用的。

4. golang 中的接口

golang 中的接口使用下面的几个结构实现的：

type emptyInterface struct {
    typ  *rtype
    word unsafe.Pointer
}

// nonEmptyInterface is the header for an interface value with methods.
type nonEmptyInterface struct {
    // see ../runtime/iface.go:/Itab
    itab *struct {
        ityp *rtype // static interface type
        typ  *rtype // dynamic concrete type
        hash uint32 // copy of typ.hash
        _    [4]byte
        fun  [100000]unsafe.Pointer // method table
    }
    word unsafe.Pointer
}

type rtype struct {
    size       uintptr
    ptrdata    uintptr  // number of bytes in the type that can contAIn pointers
    hash       uint32   // hash of type; avoids computation in hash tables
    tflag      tflag    // extra type information flags
    align      uint8    // alignment of variable with this type
    fieldAlign uint8    // alignment of struct field with this type
    kind       uint8    // enumeration for C
    alg        *typeAlg // algorithm table
    gcdata     *byte    // garbage collection data
    str        nameOff  // string form
    ptrToThis  typeOff  // type for pointer to this type, may be zero
}

// An InterfaceType node represents an interface type.
InterfaceType struct {
    Interface  token.Pos  // position of "interface" keyword
    Methods    *FieldList // list of methods
    Incomplete bool       // true if (source) methods are missing in the Methods list
}

复制

因为 golang 中指针类型与指向区域的数据类型必须一致且不能变更，这为抽象功能的实现带来了太大的局限，于是 golang 中提供了 unsafe 包，提供了对指针的增强功能，unsafe.Pointer类似于C中的void*，任何类型的指针都可以转换为unsafe.Pointer 类型，unsafe.Pointer 类型也可以转换为任何指针类型。 从上面的代码中，我们看到，在 golang 中，不具有方法的接口类型与具有方法的接口类型是分别通过 eface 与 iface 两种类型实现的。

eface 与 iface 两者都同样是由两个指针来实现的，分别指向接口本身的类型描述结构与接口实现的内存空间。

4.1. 接口类型断言的实现

此前介绍接口的文章中，我们有介绍到接口的类型断言，其实现原理就是通过将断言类型的 _type 与 data 指针指向的数据空间中的 type 进行比较实现的。 因此，即使断言类型与数据类型在内存中是一模一样的，也无法通过断言实现其类型的转换：

package main

import "fmt"

type temprature int

func main() {
    var temprature interface{} = temprature(5)
    fmt.Printf("temprature is %d", temprature.(int))
}

复制

虽然在内存中，我们定义的 temprature 与 int 是相同的，但其 _type 值是不同的，因此上述代码抛出了 panic：

panic: interface conversion: interface {} is main.temprature, not int

5. 反射的实现 — reflect 包

在 golang 中，reflect 包实现了反射机制，它定义了两个重要的类型：Type 和 Value，分别用来获取接口类型变量的实际类型与值。 获取他们的方法就是 TypeOf 和 ValueOf 方法。 我们修改一下上面的示例代码：

package main

import (
    "fmt"
    "reflect"
)

type temprature int

func main() {
    var temp interface{} = temprature(5)
    fmt.Printf("temprature is %dn", temp.(temprature))
    itype := reflect.TypeOf(temp)
    ivalue := reflect.ValueOf(temp)
    fmt.Printf("%v: %v", itype, ivalue)
}

复制

打印出了：

temprature is 5 main.temprature: 5

可以看到，通过 TypeOf 与 ValueOf 方法，我们已经取到了接口变量的类型和实际的值。

6. golang 反射的实现原理

让我们来看一下 TypeOf 与 ValueOf 的实现。

6.1. TypeOf 源码

func TypeOf(i interface{}) Type {
    eface := *(*emptyInterface)(unsafe.Pointer(&i))
    return toType(eface.typ)
}

func toType(t *rtype) Type {
    if t == nil {
        return nil
    }
    return t
}

复制

TypeOf 的实现通过 unsafe.Pointer 进行指针类型的强制转换，从而通过返回的实例中获取到内存中数据的实际类型字段。

6.2. ValueOf 源码

func ValueOf(i interface{}) Value {
    if i == nil {
        return Value{}
    }
    escapes(i)

    return unpackEface(i)
}

func escapes(x interface{}) {
    if dummy.b {
        dummy.x = x
    }
}

func unpackEface(i interface{}) Value {
    e := (*emptyInterface)(unsafe.Pointer(&i))
    // NOTE: don't read e.word until we know whether it is really a pointer or not.
    t := e.typ
    if t == nil {
        return Value{}
    }
    f := flag(t.Kind())
    if ifaceIndir(t) {
        f |= flagIndir
    }
    return Value{t, e.word, f}
}

复制

ValueOf 的实现相较于 TypeOf 的实现显得略为复杂一些。 在 unpackEface 函数中，同样通过 unsafe.Pointer 将传入参数转换为了 emptyInterface 类型，从而可以获取到传入参数的类型字段与指向实际数据的指针，最终封装为 Value 类型值返回：

type flag uintptr

type Value struct {
    typ *rtype
    ptr unsafe.Pointer
    flag
}

复制

这个结构正是 golang 保存任何一个类型变量的存储结构，因此，ValueOf 的返回值可以直接作为变量值来使用。

7. 后记

那么，在实际的使用场景中，反射能够为我们带来哪些便捷的功能呢？敬请期待下一篇文章 — golang 中反射的使用。