【初识Go】| Day11 反射机制

yussuy

修改于 2020-12-25 02:05:15

4720

反射是什么

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。
有时候我们需要编写一个函数能够处理一类并不满足普通公共接口的类型的值，也可能是因为它们并没有确定的表示方式，或者是在我们设计该函数的时候这些类型可能还不存在。
Go 语言提供了一种机制在运行时更新变量和检查它们的值、调用它们的方法，但是在编译时并不知道这些变量的具体类型，这称为反射机制。

反射的作用

1.在编写不定传参类型函数的时候，或传入类型过多时

典型应用是对象关系映射

type User struct {
  gorm.Model
  Name         string
  Age          sql.NullInt64
  Birthday     *time.Time
  Email        string  `gorm:"type:varchar(100);unique_index"`
  Role         string  `gorm:"size:255"` // set field size to 255
  MemberNumber *string `gorm:"unique;not null"` // set member number to unique and not null
  Num          int     `gorm:"AUTO_INCREMENT"` // set num to auto incrementable
  Address      string  `gorm:"index:addr"` // create index with name `addr` for address
  IgnoreMe     int     `gorm:"-"` // ignore this field
}

var users []User
db.Find(&users)

2.不确定调用哪个函数，需要根据某些条件来动态执行

func bridge(funcPtr interface{}, args ...interface{})

第一个参数funcPtr以接口的形式传入函数指针，函数参数args以可变参数的形式传入，bridge函数中可以用反射来动态执行funcPtr函数。

反射的实现

Go的反射基础是接口和类型系统，Go的反射机制是通过接口来进行的。

反射是由 reflect 包提供的。它定义了两个重要的类型, Type 和 Value. 一个 Type 表示一个Go类型. 它是一个接口, 有许多方法来区分类型以及检查它们的组成部分, 例如一个结构体的成员或一个函数的参数等. 唯一能反映 reflect.Type 实现的是接口的类型描述信息, 也正是这个实体标识了接口值的动态类型.

Go 语言在 reflect 包里定义了各种类型，实现了反射的各种函数，通过它们可以在运行时检测类型的信息、改变类型的值。

反射三定律

1.反射可以将“接口类型变量”转换为“反射类型对象”。

反射提供一种机制，允许程序在运行时访问接口内的数据。首先介绍一下reflect包里的两个方法reflect.Value和reflect.Type

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var Num float64 = 3.14

	v := reflect.ValueOf(Num)
	t := reflect.TypeOf(Num)

	fmt.Println("Reflect : Num.Value = ", v)
	fmt.Println("Reflect : Num.Type  = ", t)
}

Reflect : Num.Value =  3.14
Reflect : Num.Type  =  float64

上面的例子通过reflect.ValueOf和reflect.TypeOf将接口类型变量分别转换为反射类型对象v和t，v是Num的值，t也是Num的类型。

先来看一下reflect.ValueOf和reflect.TypeOf的函数签名

func TypeOf(i interface{}) Type
func (v Value) Interface() (i interface{})

两个方法的参数类型都是空接口

在整个过程中，当我们调用reflect.TypeOf(x)的时候，

当我们调用reflect.TypeOf(x)的时候，Num会被存储在这个空接口中，然后reflect.TypeOf再对空接口进行拆解，将接口类型变量转换为反射类型变量

2.反射可以将“反射类型对象”转换为“接口类型变量”。

定律2是定律1的反过程。

根据一个 reflect.Value 类型的变量，我们可以使用 Interface 方法恢复其接口类型的值。

package main
import (
    "fmt"
    "reflect"
)
func main() {
    var Num = 3.14
    v := reflect.ValueOf(Num)
    t := reflect.TypeOf(Num)
    fmt.Println(v)
    fmt.Println(t)

    origin := v.Interface().(float64)
    fmt.Println(origin)
}

3.14
float64
3.14

3.如果要修改“反射类型对象”，其值必须是“可写的”。

运行一下程序：

package main
import (
    "reflect"
)
func main() {
        var Num float64 = 3.14
        v := reflect.ValueOf(Num)
        v.SetFloat(6.18)
}

出现panic了

panic: reflect: reflect.Value.SetFloat using unaddressable value

goroutine 1 [running]:
reflect.flag.mustBeAssignableSlow(0x8e)
	/usr/local/go/src/reflect/value.go:259 +0x138
reflect.flag.mustBeAssignable(...)
	/usr/local/go/src/reflect/value.go:246
reflect.Value.SetFloat(0x488ec0, 0xc00001a0b8, 0x8e, 0x4018b851eb851eb8)
	/usr/local/go/src/reflect/value.go:1609 +0x37
main.main()
	/home/ricardo/error.go:8 +0xb3
exit status 2

因为反射对象v包含的是副本值，所以无法修改。

我们可以通过CanSet函数来判断反射对象是否可以修改，如下：

package main
import (
    "fmt"
    "reflect"
)
func main() {
    var Num float64 = 3.14
    v := reflect.ValueOf(Num)
    fmt.Println("v的可写性:", v.CanSet())
}

小结

1.反射对象包含了接口变量中存储的值以及类型。

2.如果反射对象中包含的值是原始值，那么可以通过反射对象修改原始值；

3.如果反射对象中包含的值不是原始值（反射对象包含的是副本值或指向原始值的地址），则该反射对象不可以修改。

反射的实践

通过反射修改内容

var f float64 = 3.41
fmt.Println(f)
p := reflect.ValueOf(&f)
v := p.Elem()
v.SetFloat(6.18)
fmt.Println(f)

reflect.Elem() 方法获取这个指针指向的元素类型。这个获取过程被称为取元素，等效于对指针类型变量做了一个*操作

通过反射调用方法

package main

import (
        "fmt"
        "reflect"
)

func hello() {
  fmt.Println("Hello world!")
}

func main() {
  hl := hello
  fv := reflect.ValueOf(hl)
  fv.Call(nil)
}

反射会使得代码执行效率较慢，原因有

1.涉及到内存分配以及后续的垃圾回收

2.reflect实现里面有大量的枚举，也就是for循环，比如类型之类的

建议

虽然反射提供的API远多于我们讲到的，我们前面的例子主要是给出了一个方向，通过反射可以实现哪些功能。反射是一个强大并富有表达力的工具，但是它应该被小心地使用，原因有三。

第一个原因是，基于反射的代码是比较脆弱的。对于每一个会导致编译器报告类型错误的问题，在反射中都有与之相对应的误用问题，不同的是编译器会在构建时马上报告错误，而反射则是在真正运行到的时候才会抛出panic异常，可能是写完代码很久之后了，而且程序也可能运行了很长的时间。

以前面的readList函数（§12.6）为例，为了从输入读取字符串并填充int类型的变量而调用的reflect.Value.SetString方法可能导致panic异常。绝大多数使用反射的程序都有类似的风险，需要非常小心地检查每个reflect.Value的对于值的类型、是否可取地址，还有是否可以被修改等。

避免这种因反射而导致的脆弱性的问题的最好方法是将所有的反射相关的使用控制在包的内部，如果可能的话避免在包的API中直接暴露reflect.Value类型，这样可以限制一些非法输入。如果无法做到这一点，在每个有风险的操作前指向额外的类型检查。以标准库中的代码为例，当fmt.Printf收到一个非法的操作数是，它并不会抛出panic异常，而是打印相关的错误信息。程序虽然还有BUG，但是会更加容易诊断。

fmt.Printf("%d %s\n", "hello", 42) // "%!d(string=hello) %!s(int=42)"

反射同样降低了程序的安全性，还影响了自动化重构和分析工具的准确性，因为它们无法识别运行时才能确认的类型信息。

避免使用反射的第二个原因是，即使对应类型提供了相同文档，但是反射的操作不能做静态类型检查，而且大量反射的代码通常难以理解。总是需要小心翼翼地为每个导出的类型和其它接受interface{}或reflect.Value类型参数的函数维护说明文档。

第三个原因，基于反射的代码通常比正常的代码运行速度慢一到两个数量级。对于一个典型的项目，大部分函数的性能和程序的整体性能关系不大，所以使用反射可能会使程序更加清晰。测试是一个特别适合使用反射的场景，因为每个测试的数据集都很小。但是对于性能关键路径的函数，最好避免使用反射。

参考资料

https://github.com/datawhalechina/go-talent/blob/master/10.%E5%8F%8D%E5%B0%84%E6%9C%BA%E5%88%B6.md

http://shouce.jb51.net/gopl-zh/ch12/ch12-02.html

本文系转载，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文系转载，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

登录后参与评论

0 条评论

热度