详解Golang利用反射reflect动态调用方法

编程语言中反射的概念

在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。

每种语言的反射模型都不同，并且有些语言根本不支持反射。golang语言实现了反射，反射机制就是在运行时动态的调用对象的方法和属性，官方自带的reflect包就是反射相关的，只要包含这个包就可以使用。

多插一句，golang的grpc也是通过反射实现的。

golang的官方包 reflect 实现了运行时反射（run-time reflection）。运用得当，可谓威力无穷。今天，我们就来利用reflect进行方法的动态调用……

基本知识

首先，反射主要与 golang 的 interface 类型相关。一个 interface 类型的变量包含了两个指针：一个指向变量的类型，另一个指向变量的值。最常用的莫过于这两个函数：

func main(){
 s := "hello world"
 fmt.println(reflect.valueof(s))  // hello world
 fmt.println(reflect.typeof(s))  // string
}

其中,

• reflect.valueof() 返回值类型：reflect.value
• reflect.typeof() 返回值类型：reflect.type

创建变量

接下来，我们可以使用 reflect  来动态的创建变量：

func main(){
 var s string
 t := reflect.typeof(s)
 fmt.println(t)         // string
 sptr := reflect.new(t)
 fmt.printf("%s\n", sptr)    // %!s(*string=0xc00000e1e0)
}

需要留意， reflect.new() 返回的是一个 指针 ：

new returns a value representing a pointer to a new zero value for the specified type. that is, the returned value's type is ptrto(typ).

这时候，我们可以使用 reflect.value.elem() 来取得其实际的值：

sval := sptr.elem()  // 返回值类型：reflect.value

然后再将其转为 interface 并做 type-assertion ：

ss := sval.interface().(string)
fmt.println(ss)    // 空字符串

动态调用

假设我们已经定义了以下的 struct 并实现了相关的方法：

type m struct{}
type in struct{}
type out struct{}
 
func (m *m) example(in in) out {
 return out{}
}

然后我们就可以通过下面这种方式来进行调用了：

func main() {
 v := reflect.valueof(&m{})
 m := v.methodbyname("example")
 in := m.type().in(0)
 out := m.type().out(0)
 fmt.println(in, out)
    
 inval := reflect.new(in).elem()
    // 可以将 inval 转为interface后进行赋值之类的操作……
 rtn := m.call([]reflect.value{inval})
 fmt.println(rtn[0])
}

注册方法

我们再定义一个保存 m 所有方法的 map struct ：

type handler struct {
 func  reflect.value
 in   reflect.type
 numin int
 out  reflect.type
 numout int
}

然后我们就可以来遍历结构体 m 的所有方法了：

func main() {
 handlers := make(map[string]*handler)
 v := reflect.valueof(&m{})
 t := reflect.typeof(&m{})
 for i := 0; i < v.nummethod(); i++ {
 name := t.method(i).name
 // 可以根据 i 来获取实例的方法，也可以用 v.methodbyname(name) 获取 
 m := v.method(i)
 // 这个例子我们只获取第一个输入参数和第一个返回参数
 in := m.type().in(0)
 out := m.type().out(0)
 handlers[name] = &handler{
  func:  m,
  in:   in,
  numin: m.type().numin(),
  out:  out,
  numout: m.type().numout(),
 }
 }
}

elem()

在学习 reflect 的过程中，我们发现 reflect.value 和 reflect.type 都提供了 elem() 方法。

reflect.value.elem() 的作用已经在前面稍微提到了，主要就是返回一个 interface 或者 pointer 的值：

elem returns the value that the interface v contains or that the pointer v points to. it panics if v's kind is not interface or ptr. it returns the zero value if v is nil.

reflect.type.elem() 的作用则是返回一个类型（如：array，map，chan等）的元素的类型：

elem returns a type's element type. it panics if the type's kind is not array, chan, map, ptr, or slice.

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。