Go中的反射模型

类型和接口

反射建立在类型系统之上，所以让我们从go语言的类型开始。

Go是静态类型语言，每个变量都有一个静态的类型，即在编译时类型已知且固定：比如int, float32,*MyType,[]byte等等。如果我们声明：

type MyInt int
var i int
var j MyInt

那么i的类型是int，j的类型是MyInt.变量i和j具有不同的类型，尽管它们有相同的基础类型，但是如果不进行转换，就无法将它们赋值给彼此。

接口类型是类型的一个重要类别，它表示固定的方法集。接口变量可以存储任何具体值（非接口），只要该值实现接口的方法即可。一个典型的例子就是 io 包 的 io.Reader 和 io.Writer，Reader 和 Writer类型：

// Reader 是封装基本 Read 方法的接口
type Reader interface {
    Read(p []byte) (n int, err error)
}

// Writer 是封装基本 Write 方法的接口
type Writer interface {
    Write(p []byte) (n int, err error)
}

任何使用此签名实现 Read （或 Write）方法的类型都被称为实现了 ``io.Reader （或 io.Writer）接口。这意味着 io.Reader 类型的变量可以保存实现了 Read `方法的任何值：

r = os.Stdin
r = bufio.NewReader(r)
r = new(bytes.Buffer)
// 等等

需要明确的是，不管 r 可能包含什么具体值，r 的类型始终是 io.Reader：Go 是静态类型的语言，而 r 的静态类型是 io.Reader。

接口类型的一个非常重要的示例是空接口：

interface{}

它表示空的方法集，并且任何值都满足空接口，因为任何值都有零个或者多个方法。

有人说 Go 的接口是动态类型的，但这会产生误导。接口是静态类型的：接口类型的变量始终具有相同的静态类型，即使在运行时存储在接口变量中的值可能会更改类型，该值也将始终满足接口的要求。

接口的表示形式

接口类型的变量存储了一对值：分配给该变量的具体值，以及该值的类型描述。更确切地说，该值是实现接口的基础具体数据项，而类型描述了该数据项的完整类型。例如：

var r io.Reader
tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
if err != nil {
    return nil, err
}
r = tty

什么是类型的具体描述？类型的描述分为两部分，第一部分是类型的具体名称，第二部分是该类型的方法，或者说方法集。类型的方法可以是0个也可以是多个，但是无论如何，这些类型都是满足空接口类型的，因为空接口类型不需要你去实现任何方法集。

r 中包含(value, type) 对，即（tty, *os.File）。请注意，类型 *os.File实现的方法不只有 Read；尽管接口仅提供对 Read 方法的访问，但是其内部的值仍包含有关该值的所有类型信息。这就是为什么我们可以做下面的事情：

var w io.Writer
w = r.(io.Writer)

该表达式中的赋值时类型断言。它断言的是 r 中的数据项也实现 io.Write，因此我们可以将其分配给 w。赋值后，w 中会包含该 (value, type) 对，(tty, *os.File)，这与 r 中所持有的相同。接口的静态类型决定了接口变量可以调用哪些方法，尽管其内部的具体类型可能有更大的方法集。

我们还可以将一个接口类型变量赋值给空接口类型的变量：

var empty interface{}
empty = w

此时当我们调用empty变量时，会发些我们无法访问任何一个方法，因此此时的方法集为空。

当我们讨论接口的时候，还必须讨论另一个概念：什么是多态？

多态从字面上来说就是一个多种形态，它其实指的是一个对象可以进行多种形态的切换。在面向对象的编程范式中，我们可以定义我们自己的类，同时也可以定义我们的父类。通常父类包含了各个子类的一些通用方法和属性。而子类其实是特殊的父类。当我们将对象转换为父类对象时，此时我们所拥有的属性和方法都是父类对象的属性和方法。因此我们无法调用子类对象一些特殊方法。

比如动物是猫和狗的统称，只要是动物都会有一些通用的行为和属性，比如睡觉，觅食。但是猫和狗又有自身特殊的行为和属性，比如猫抓老鼠，狗看门，而猫不会看门，狗也不抓老鼠，这是狗和猫各自拥有的特殊行为。这些行为没有被抽象到父类中，因此是它们独占的。当我们将对象切换为猫类时，我们就拥有了猫的属性和行为，而当我们切换为父类对象时，我们此时是动物，因此不具有猫的特殊行为抓老鼠。上面举的例子就是多态的一种。

从接口反射出对象

从底层讲，反射只是一种检查存储在接口变量中的值和类型对的机制。首先，我们需要了解 反射包 的两个类型：Type 和 Value，通过这两个类型可以访问接口变量的内容。还有两个函数 reflect.TypeOf 和 reflect.ValueOf，它们可以从接口值中取出 reflect.Type 和 reflect.Value。（另外，从 reflect.Value 可以很容易地获取到 reflect.Type ，但是让我们暂时将 Value 和 Type 的概念分开。）

让我们从 TypeOf 开始：

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    fmt.Println("type:", reflect.TypeOf(x))
}

上面会打印：

type: float64

此时你可能会困惑，我们的反射机制是将存储在接口变量中的类型和值对反射出来，但是这里明明是一个具体的类型，并非接口类型，为啥我们依然可以对它进行操作？让我们看一下TypeOf的函数签名

// TypeOf 返回 interface{} 中值的反射类型
func TypeOf(i interface{}) Type

通过签名可知，该函数的形参为空接口类型的变量，此时我们定义的x变量其实是被保存在了该函数的形参i中，而该形参的类型是空接口类型。因此我们实际上是对空接口类型进行反射，而不是具体类型。

reflect.TypeOf 从该空接口中恢复类型信息。相应的，reflect.ValueOf 函数会恢复值信息：

var x float64 = 3.4
fmt.Println("value:", reflect.ValueOf(x).String())

打印：

value: <float64 Value>

我们调用String 方法，因为默认情况下，fmt 包会深入底层获取一个reflect.Value 来显示其中的具体值。String 方法不会这样。）

func Println(a ...interface{}) (n int, err error)

其实Println的形参也是空接口类型，因此我们传入的参数实际都被存储在了空接口类型的变量中，但是正如上面所述，fmt包会深入底层获取一个reflect.Value的具体值，因此我们每次打印接口类型变量都能把具体的值给打印出来。

reflect.Type 和 reflect.Value 都有许多方法可以让我们执行检查和操作。一个重要的例子是 Value 具有 Type 方法， 该方法返回reflect.Value 的 Type 类型。另一个例子是 Type 和Value 都有一个 Kind方法，该方法返回一个标识存储的数据项类型的常数：Uint, Float64, Slice，等等。还有 Value 的很多方法，名字类似于Int 和Float，可以让我们获取存储在里面的值（如 int64 和float64 ）：

var x float64 = 3.4
v := reflect.ValueOf(x)
fmt.Println("type:", v.Type())
fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
fmt.Println("value:", v.Float())

打印：

type: float64
kind is float64: true
value: 3.4

还有诸如SetInt 和 SetFloat 之类的方法，但是要使用它们，我们需要理解 settability，这是反射第三定律的主题，后续再进行讨论。

反射库具有几个值得一提的属性。首先，为了保持 API 的简单，Value 的 “getter” and “setter” 方法在可以保存该值的最大类型上进行操作，例如所有的的有符号整数都用 int64。也就是说 Value 的 Int 方法返回一个 int64， SetInt 方法接收一个 int64。使用的时候，可能需要转换为涉及的实际类型：

var x uint8 = 'x'
v := reflect.ValueOf(x)
fmt.Println("type:", v.Type())                            // uint8.
fmt.Println("kind is uint8: ", v.Kind() == reflect.Uint8) // true.
x = uint8(v.Uint())                                       // v.Uint 返回一个 uint64.

第二个属性是反射对象的 Kind 描述底层基础类型，而不是静态类型。如果反射对象包含用户自定义的整数类型的值，例如

type MyInt int
var x MyInt = 7
v := reflect.ValueOf(x)

v 的 Kind 依然是 reflect.Int，尽管 x 的静态类型是 MyInt，而不是 int。换句话说，Kind 无法区分 int 和 MyInt，尽管 Type 可以。

从反射对象到接口值

像物理反射一样，Go 中的反射会生成自己的逆。

给定 reflect.Value，我们可以使用 Interface 方法恢复接口值；实际上，该方法将类型和值信息打包回接口表示形式并返回结果：

//接口返回v的值作为接口{}。
func (v Value) Interface() interface{}

结果，我们可以说

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

打印反射对象 v 表示的 float64 值。

不过，我们可以做得更好。 fmt.Println，fmt.Printf 等的参数都作为空接口值传递，然后由 fmt 包内部解压缩我们在前面的示例中一直在做。因此，正确打印 reflect.Value 内容的全部工作就是将 Interface 方法的结果传递给格式化的打印例程：

fmt.Println(v.Interface())

简而言之，Interface 方法是 ValueOf 函数的反函数，除了它的结果始终是静态类型的 interface {}。

重申：反射从接口值到反射对象，然后再返回。

修改反射对象的值

var x float64 = 3.4
v：= reflect.ValueOf(x)
v.SetFloat(7.1)//错误：会panic错误。

打印：

panic: reflect.Value.SetFloat using unaddressable value

问题不是 7.1 值不可寻址；这是 v 不可设置的。可设置性是反射 Value 的属性，并非所有反射 Values 都具有它。

Value 的 CanSet 方法报告 Value 的可设置性；就我们而言:

var x float64 = 3.4
v：= reflect.ValueOf(x)
fmt.Println("settability of v:", v.CanSet())

在不可设置的 Value 上调用 Set 方法是错误的。

Settability 有点像可寻址性，但是更严格。它是反射对象可以修改用于创建反射对象的实际存储的属性。Settability 由反射对象是否持有原始的数据项决定。当我们这样做时:

var x float64 = 3.4
v := reflect.ValueOf(x)

我们实际上是把 x 的副本传递给了 reflect.ValueOf，因此作为 reflect.ValueOf 参数的接口值是 x 的副本，而不是 x 本身。因此，如果下面的操作:

v.SetFloat(7.1)

被允许执行，它也不会更新 x 的值，尽管 v 看起来像是从 x 创建的。相反，它会更新存在反射值内的 x 的副本， x 却不会受到影响。那将引起混乱并且是无用的，因此这种操作被定为非法的，settability 正是用来避免这种问题的属性。

这实际上是一种很常见的操作。考虑将 x 传递给函数：

f(x)

我们不希望 f 能够修改 x 的值，因为我们传递了 x 的副本，而不是 x 本身。如果我们希望 f 直接修改 x 的值，必须把 x 的地址传给函数（即指向 x 的指针）：

f(&x)

这种操作很常见，而反射也是以相同的方式工作的。如果我们想要通过反射修改 x 的值，则必须为反射库提供一个指向要修改的值的指针。

让我们开始吧。首先，我们像往常一样初始化 x，然后创建一个指向它的反射值，称为 p。

var x float64 = 3.4
p := reflect.ValueOf(&x) // 注意：取 x 的地址
fmt.Println("type of p:", p.Type())
fmt.Println("settability of p:", p.CanSet())

输出是：

type of p: *float64
settability of p: false

反射对象 p 是不可设置的，但是实际上我们想要设置的不是 p，而是 *p。为了获取 p 指向的内容，我们调用 Value 值的 Elem 方法，该方法指向指针：

v := p.Elem()
fmt.Println("settability of v:", v.CanSet())

现在 v 是一个可设置的反射对象了，

settability of v: true

既然它代表的是 x，我们终于可以使用 v.SetFloat 来修改 x 的值了：

v.SetFloat(7.1)
fmt.Println(v.Interface())
fmt.Println(x)

输出和预期一样

7.1
7.1

反射可能很难理解，通过反射中的类型 Types 和 Values 可能会掩盖正在发生的事情。请记住，反射值需要变量的地址才能修改其表示的值。

对结构体类型的值进行发射

在我们之前的示例中，v 本身并不是指针，它只是从一个指针派生的。发生这种情况的常见方法是使用反射修改结构的场。只要有了结构的地址，就可以修改其字段。

这是一个分析结构值 t 的简单示例。我们使用结构的地址创建反射对象，因为稍后将要对其进行修改。然后我们将 typeOfT 设置为其类型，并使用简单的方法调用对字段进行迭代。请注意，我们从结构类型中提取了字段的名称，但是字段本身是常规的 reflect.Value 对象。

type T struct {
    A int
    B string
}
t := T{23, "skidoo"}
s := reflect.ValueOf(&t).Elem()
typeOfT := s.Type()
for i := 0; i < s.NumField(); i++ {
    f := s.Field(i)
    fmt.Printf("%d: %s %s = %v.", i,
        typeOfT.Field(i).Name, f.Type(), f.Interface())
}

该程序输出的是

0: A int = 23
1: B string = skidoo

在此处传递的内容还涉及可设置性的另一点：T 的字段名是大写 (已导出)，因为只能设置结构的导出字段。

因为 s 包含可设置的反射对象，所以我们可以修改结构的字段。

s.Field(0).SetInt(77)
s.Field(1).SetString("Sunset Strip")
fmt.Println("t is now", t)

结果如下：

t is now {77 Sunset Strip}

如果我们修改程序以便从 t 而不是＆t 创建 s，则对 SetInt 和 SetString < aaaa>将失败，因为无法设置 t ` 的字段。

总结

反射的三条定律：

• 反射从接口值到反射对象。

• 反射从反射对象到接口值。

• 要修改反射对象，该值必须可设置。