实现通用参数方法

知识点掌握了，还需要不断练习才能熟练运用。下面golang学习网给大家带来一个Golang开发实战，手把手教大家学习《实现通用参数方法》，在实现功能的过程中也带大家重新温习相关知识点，温故而知新，回头看看说不定又有不一样的感悟！

我有go代码，其中包含很多执行方法。 每个方法接收它自己的参数结构。 我希望调度程序使用其相关结构来调用每个方法。

调度程序接收执行方法的名称和参数结构的 json。 然后，它使用反射来构建结构，并调用方法。

问题是除非我使用空接口创建执行方法，否则我会遇到编译错误。 在下面的示例中，我有 2 个执行方法： api1 正在编译，但使用空接口和显式转换。 api2 是我想做的，但它因编译错误而失败：

无法在赋值中使用 api2（类型 func(api2parameters)）作为类型 api

如何使 api2 使用编译？

import (
    "encoding/json"
    "log"
    "reflect"
)

type Api func(arguments interface{})

type ApiDetails struct {
    Executor       *Api
    ParametersType reflect.Type
}

var Apis map[string]*ApiDetails

func RunApi(apiName string, data string) {
    api := Apis[apiName]
    parameters := reflect.New(api.ParametersType).Interface().(interface{})
    _ = json.Unmarshal([]byte(data), parameters)
    (*api.Executor)(parameters)
}

type Api1Parameters struct {
    Count1 int
    Id1    string
}

func api1(arguments interface{}) {
    parameters, _ := arguments.(*Api1Parameters)
    log.Printf("api1 parameters(%+v)", parameters)
}

type Api2Parameters struct {
    Count2 int
    Id2    string
}

func api2(arguments Api2Parameters) {
    log.Printf("api2 parameters(%+v)", arguments)
}

func Test() {
    // this assignment works fine
    var api_1 Api = api1
    Apis["api1"] = &ApiDetails{
        Executor:       &api_1,
        ParametersType: reflect.TypeOf(Api1Parameters{}),
    }

    // this assignment produce compile error
    var api_2 Api = api2
    Apis["api2"] = &ApiDetails{
        Executor:       &api_2,
        ParametersType: reflect.TypeOf(Api2Parameters{}),
    }

    RunApi("api1", `{"Count1":19, "Id1":"a"}`)
    RunApi("api2", `{"Count2":34, "Id2":"b"}`)
}

解决方案

使用参数类型创建一个值，解组为该值并调用该函数：

var apis = map[string]interface{}{
    "api1": api1,
    "api2": api2,
}

func runapi(apiname string, data string) {
    fv := reflect.valueof(apis[apiname])
    ft := fv.type()
    pin := reflect.new(ft.in(0))
    _ = json.unmarshal([]byte(data), pin.interface())
    fv.call([]reflect.value{pin.elem()})
}

Run it on the playground。

如果您想保持此类型安全，您可以将 json 到 args 的转换进一步推进：

type api func(string)

type apidetails struct {
    // don't use *api, that's a function pointer-pointer
    executor       api
}

然后，使用闭包进行 json 转换：

apis["api1"] = &apidetails{
        executor: func(data string) {
            var args argsforapi1
            json.unmarshal([]byte(string),&args)
            api1implem(args)
        }
    }

有了这个，你可以做到：

apis["api1"].executor( `{"count1":19, "id1":"a"}`)

您可以更改 runapi 来执行类似的操作。

第二个选项是使用反射来执行此操作：

type apidetails struct {
    // executor can accept any function signature
    // assume a function with  a single parameter
    executor     interface{}
    parameterstype reflect.type
}

然后，runapi函数可以使用反射构造一个结构体并调用executor：

parameters := reflect.New(api.ParametersType)
    _ = json.Unmarshal([]byte(data), parameters.Interface{})
    reflect.ValueOf(api.Executor).Call([]reflect.Value{parameters})

这应该可行，但如果你搞砸了，你只会得到运行时错误。

终于介绍完啦！小伙伴们，这篇关于《实现通用参数方法》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！