【Golang实战】调用动态函数

转自：golang如何使用reflect动态调用函数

应用场景

我们知道一个函数名，通过一个字符串变量表示函数名，然后如何调用这个函数的功能。

func foo() {
  fmt.Println("in foo");
}
var funcname string = "foo"

func callFunc(funcname string) {
    ...
}

callFunc(funcname)

下面的问题是我们如何实现callFunc()的内容来完成所要的功能呢。

目前已知的办法好像是不行的，无法从全局域中通过名字获取一个函数的对象。
(对于变量也一样，无法从全局域中通过名字获取一个变量的对象)

可行的办法

使用一个map变量显式的把字符串和函数(变量)关联起来：

    funcs := map[string]interface{} {
            "foo": foo,
    }

这样我们可以通过funcs[“foo”]得到函数对象，然后才能对函数进行操作。

函数操作的例子

下面是一个函数调用的例子，包括参数的传递以及返回值的处理。

package main

import "fmt"
import "reflect"
import "errors"

type MyStruct struct {
    i int
    s string
}

func foo0() int {
    fmt.Println("running foo0: ")
    return 100
}

func foo1(a int) (string, string) {
    fmt.Println("running foo1: ", a)
    return "aaaa", "bbb"
}

func foo2(a, b int, c string) MyStruct {
    fmt.Println("running foo2: ", a, b, c)
    return MyStruct{10, "ccc"}
}

func Call(m map[string]interface{}, name string, params ... interface{}) (result []reflect.Value, err error) {
    f := reflect.ValueOf(m[name])
    if len(params) != f.Type().NumIn() {
        err = errors.New("The number of params is not adapted.")
        return
    }

    in := make([]reflect.Value, len(params))
    for k, param := range params {
        in[k] = reflect.ValueOf(param)
    }
    result = f.Call(in)
    return
}

func main() {
    funcs := map[string]interface{} {
            "foo0": foo0,
            "foo1": foo1,
            "foo2": foo2,
    }

    // call foo0
    if result, err := Call(funcs, "foo0"); err == nil {
        for _, r := range result {
            fmt.Printf("  return: type=%v, value=[%d]\n", r.Type(), r.Int())
        }
    }

    // call foo1
    if result, err := Call(funcs, "foo1", 1); err == nil {
        for _, r := range result {
            fmt.Printf("  return: type=%v, value=[%s]\n", r.Type(), r.String())
        }
    }

    // call foo2
    if result, err := Call(funcs, "foo2", 1, 2, "aa"); err == nil {
        for _, r := range result {
            fmt.Printf("  return: type=%v, value=[%+v]\n", r.Type(), r.Interface().(MyStruct))
        }
    }
}

编译运行：

running foo0: 
  return: type=int, value=[100]
running foo1:  1
  return: type=string, value=[aaaa]
  return: type=string, value=[bbb]
running foo2:  1 2 aa
  return: type=main.MyStruct, value=[{i:10 s:ccc}]

在go中，func也可以作为一种数据类型传给函数，因此可以将方法统一抽象为：

func CallFuncs(fc interface{}, params ...interface{}) (result interface{}, err error) {
	f := reflect.ValueOf(fc)
	if f.Kind() != reflect.Func {
		err = fmt.Errorf("param fc is not avaliablel, must be func")
		return
	}
	if len(params) != f.Type().NumIn() {
		err = fmt.Errorf("the number of params is not adapted")
		return
	}

	in := make([]reflect.Value, len(params))
	for k, param := range params {
		in[k] = reflect.ValueOf(param)
	}
	resp := f.Call(in)
	if len(resp) > 0 {
		result = reflect.ValueOf(resp[0].Interface()).Interface()
		return
	}
	result = nil
	return
}