以便于获取的方式在 Go 中表示多个不同结构的集合

一分耕耘，一分收获！既然打开了这篇文章《以便于获取的方式在 Go 中表示多个不同结构的集合》，就坚持看下去吧！文中内容包含等等知识点...希望你能在阅读本文后，能真真实实学到知识或者帮你解决心中的疑惑，也欢迎大佬或者新人朋友们多留言评论，多给建议！谢谢！

首先，作为序言，我坚持使用 go 版本 1.16，因此不幸的是，1.18 中的泛型内容不是一个选项。 （但是，请随意将其添加为答案，以防将来有人偶然发现此问题）

所以我有一堆如下所示的函数：

func getperson(id int) chan person { // stuff }
func getpet(id int) chan pet { // stuff }
// similar methods that get different structs

简单的目标是调用所有这些方法并从通道中获取数据并提供它们进行访问。将对象加载到通道中的原因是我们可以同时调用这些函数，因为它们通常会继续发出 http 请求等等。

现在我们希望从这些渠道中提取所有数据并使其可供一次性使用，最简单的方法是这样的

person := <- getperson(id)
pet := <- getpet(id)
...

这不会利用上述函数的并发特性，因此我的下一个解决方案是使用一个带有函数的类型，该函数基本上循环返回的通道并将它们加载到字段，就像这样。

type overalldata struct {
    field1 struct{}
    field2 struct{}
    // etc.
}

func (data overalldata) retrievedata(personid int, petid int) {
    for x:= 0, x < chanlen, x++ {
        select {
        case data.field1 = <- getperson(personid):
        case data.field2 = <- getpet(petid):
        // etc
        }
    }  

}

func getoveralldata(personid int, petid int) overalldata {
    data := overalldata{}
    data.retrievedata(personid, petid)
    return data
}

但我不太喜欢这个，它需要一种类型来聚合任何特定组的响应，并且这些类型本质上非常相似。此外， getoveralldata 函数将根据您需要返回的数据量获取越来越多的参数，并且它变得不守规矩（您可以为此添加另一种类型，但我认为这只是一种方法将问题转移到其他地方）

所以我开始考虑一个更通用的解决方案，并想出了一些更糟糕的解决方案

func processresults(results []chan struct{}) map[reflect.type]struct{} {
    respmap := map[reflect.type]struct{}
    for _, ch := range results {
        go func(c chan struct{}) {
            val <- ch
            typ := reflect.typeof(val)
            respmap[typ] = val
        }(ch)
    }
    return respmap
}

上述的目标是，您将只需要一个看起来像这样的调用。这将是您需要的代码，无需添加任何类型或传递大量内容作为参数。而且这很容易编写和阅读（大多数情况下，最后一行有点混乱）。您还会知道当您投射它时您的类型会匹配。

responses := ProcessResults([]chan struct{} {
    GetPerson(personId),
    GetPet(petId),
})


person := responses[reflect.TypeOf(Person)].(Person)

它的问题是它不起作用，你不能只将我的方法返回的类型映射到数组中的 struct{} 中，虽然我可以将其全部转换为结构，但我怀疑反射我之前使用的 .typeof() 在将其转换为结构后将不起作用（因为 struct{} 的类型和我的地图键将不起作用），还有其他问题，比如我有两个返回相同类型，但可以解决这个问题。

我还在考虑添加一个嵌入式结构，从通道返回的所有类型都将具有该结构，迫使它们仅限于一个接口，如这个问题： go接口字段

我可以使用该结构来指定映射的键，这样我就不必搞乱类型检查，而且我还可以将所有数据作为该接口类型传递，而不是将其类型转换回结构因此不会丢失输入，并且可以将其转换回通道返回的原始类型。

当我到达这一点时，我意识到我可能正在尝试做一些我不应该用 go 做的事情，并且有更好的方法来完成它。有人有更好的想法吗？否则我可能会在上面遇到一个问题，如果感觉不对，我会放弃它并采用我的第二个解决方案。

正确答案

通常是在调用方而不是被调用函数中管理并发。使用错误组来管理一组并发调用。

像这样声明函数：

func getperson(id int) (*person, error)
func getpet(id int) (*pet, error)

像这样同时调用函数：

var g errgroup.group

var person *person
g.go(func() error {
    var err error
    person, err = getperson(personid)
    return err
})

var pet *pet
g.go(func() error {
    var err error
    pet, err = getpet(petid)
    return err
})

if err := g.wait(); err != nil {
   // handle error
}

// access person and pet variables here.

使用反射包消除样板：

// ego calls fn with args in group g. fn's second return value
// is assumed to be an error and is returned to the error group.
// if the error is nil, then fn's first return value is assigned
// to the value that presult points to.
func ego(g *errgroup.group, presult any, fn any, args ...any) {
    g.go(func() error {
        var rargs []reflect.value
        for _, arg := range args {
            rargs = append(rargs, reflect.valueof(arg))
        }
        result := reflect.valueof(fn).call(rargs)
        if err, ok := result[1].interface().(error); ok && err != nil {
            return err
        }
        reflect.valueof(presult).elem().set(result[0])
        return nil
    })
}

像这样使用它：

var g &errgroup.Group{}
var person *Person
var pet *Pet
ego(g, &person, GetPerson, personId)
ego(g, &pet, GetPet, petId)
if err := g.Wait(); err != nil {
   // handle error
}
// access person and pet variables here.

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《以便于获取的方式在 Go 中表示多个不同结构的集合》文章吧，也可关注golang学习网公众号了解相关技术文章。