Go 具有可变输入/输出类型的泛型函数

只是在玩aws sdk for go。当列出不同类型的资源时，我倾向于使用许多非常相似的函数，如下面示例中的两个。 有没有办法将它们重写为一个泛型函数，该函数将根据作为param传递的内容返回特定类型

比如：

func generic(session, funcToCall, t, input) (interface{}, error) {}

目前我必须这样做（功能与类型更改相同）：

---

因为您只处理函数，所以可以在运行时使用reflect包生成函数

使用对象类型（卷，Vpc）可以导出所有子序列信息，以提供一个完全通用的实现，该实现非常枯燥，在某种程度上更复杂、更慢

它是未经测试的，欢迎您帮助测试和修复它，但类似的事情应该会让您走上正轨

注册中心的想法来自于这个答案

有关reflect软件包的golang文档，请参阅

---

代理第三方API非常容易实现 接下来，下面是如何使用endly e2e test runner实现的

我想说，只要反射性能价格不是问题，AWSAPI是代理的完美候选

其他一些第三方API，如

---

更具挑战性，但仍然很容易使用go代理，go是反射和代码生成的组合：

使用接口！使用反射包，您可以在运行时创建新函数。它们可以接受任何输入、输出类型，只需定义它即可。参见reflect.FuncOf和reflect.MakeFunc。@Abdullah，一个例子比简短的注释更有价值。如果你的函数真的非常相似，你可以很容易地生成它们的主体（使用你选择的任何文本处理工具。Go有一些内置的）。如果你这样做了，那么你就不在乎所有的重复。对于后者，我认为有一些好的项目可以帮助解决这个问题，请查看github。代码生成可能比反射更容易：）是的，当它适用于你的用例时；）在这种情况下，它可能会提供您的答案！我本来想喝的，但今晚我喝的啤酒太多了。也许明天：）@mh cbon，非常好和完整的答案，谢谢。

func getVolumes(s *session.Session) ([]*ec2.Volume, error) {

    client := ec2.New(s)

    t := []*ec2.Volume{}
    input := ec2.DescribeVolumesInput{}

    for {
        result, err := client.DescribeVolumes(&input)
        if err != nil {
            return nil, err
        }

        t = append(t, result.Volumes...)

        if result.NextToken != nil {
            input.NextToken = result.NextToken
        } else {
            break
        }
    }
    return t, nil
}

func getVpcs(s *session.Session) ([]*ec2.Vpc, error) {

    client := ec2.New(s)

    t := []*ec2.Vpc{}
    input := ec2.DescribeVpcsInput{}

    for {
        result, err := client.DescribeVpcs(&input)
        if err != nil {
            return nil, err
        }

        t = append(t, result.Vpcs...)

        if result.NextToken != nil {
            input.NextToken = result.NextToken
        } else {
            break
        }
    }
    return t, nil
} 

package main

import (
    "errors"
    "fmt"
    "reflect"
)

func main() {
    fmt.Printf("%T\n", getter(Volume{}))
    fmt.Printf("%T\n", getter(Vpc{}))
}

type DescribeVolumesInput struct{}
type DescribeVpcs struct{}

type Volume struct{}
type Vpc struct{}

type Session struct{}

type Client struct{}

func New(s *Session) Client { return Client{} }

var typeRegistry = make(map[string]reflect.Type)

func init() {
    some := []interface{}{DescribeVolumesInput{}, DescribeVpcs{}}
    for _, v := range some {
        typeRegistry[fmt.Sprintf("%T", v)] = reflect.TypeOf(v)
    }
}

var errV = errors.New("")
var errType = reflect.ValueOf(&errV).Elem().Type()
var zeroErr = reflect.Zero(reflect.TypeOf((*error)(nil)).Elem())
var nilErr = []reflect.Value{zeroErr}

func getter(of interface{}) interface{} {

    outType := reflect.SliceOf(reflect.PtrTo(reflect.TypeOf(of)))
    fnType := reflect.FuncOf([]reflect.Type{reflect.TypeOf(new(Session))}, []reflect.Type{outType, errType}, false)
    fnBody := func(input []reflect.Value) []reflect.Value {

        client := reflect.ValueOf(New).Call(input)[0]

        t := reflect.MakeSlice(outType, 0, 0)
        name := fmt.Sprintf("Describe%TsInput", of)
        descInput := reflect.New(typeRegistry[name]).Elem()

        mName := fmt.Sprintf("Describe%Ts", of)
        meth := client.MethodByName(mName)
        if !meth.IsValid() {
            return []reflect.Value{
                t,
                reflect.ValueOf(fmt.Errorf("no such method %q", mName)),
            }
        }
        for {
            out := meth.Call([]reflect.Value{descInput.Addr()})
            if len(out) > 0 {
                errOut := out[len(out)-1]
                if errOut.Type().Implements(errType) && errOut.IsNil() == false {
                    return []reflect.Value{t, errOut}
                }
            }
            result := out[1]
            fName := fmt.Sprintf("%Ts", of)
            if x := result.FieldByName(fName); x.IsValid() {
                t = reflect.AppendSlice(t, x)
            } else {
                return []reflect.Value{
                    t,
                    reflect.ValueOf(fmt.Errorf("field not found %q", fName)),
                }
            }

            if x := result.FieldByName("NextToken"); x.IsValid() {
                descInput.FieldByName("NextToken").Set(x)
            } else {
                break
            }
        }
        return []reflect.Value{t, zeroErr}
    }
    fn := reflect.MakeFunc(fnType, fnBody)
    return fn.Interface()
}