如何在 Go 中处理具有相似结构的两个不同包中的解耦问题？

学习知识要善于思考，思考，再思考！今天golang学习网小编就给大家带来《如何在 Go 中处理具有相似结构的两个不同包中的解耦问题？》，以下内容主要包含等知识点，如果你正在学习或准备学习Golang，就都不要错过本文啦~让我们一起来看看吧，能帮助到你就更好了！

我相对较新，并且一直在进行大规模重写，试图尽可能减少我的依赖关系图。我对我得到它的地方感到非常满意，但是有一个部分我不知道如何最好地处理。如果答案是“两者之间会有这种依赖性”，那也很好，我只是在寻找一个好的方法，而不是期待奇迹。

所以下面我有两个包，a 和 b，它们都有相同的结构。通常你可以在 main 中将一个转换为另一个，但每个都有一个子项，它也是一个结构体，这会阻止 go 允许它，即使子项具有相同的签名。

一种方法是在 b 的结构中引用 a.tzconfig 并让其存在依赖关系，但这就是我想要摆脱的。

我想另一种方法是创建一个接口，然后通过方法获取 loc 的值，我认为这可行，但我还没有尝试过，因为这意味着为只是数据结构的东西创建方法（实际结构有很多项目，为了简单起见，我在这里将其简化为必需品），这似乎有点矫枉过正。

我可以将 tzconfig 移至第三个模块，这样它们都会引用该模块，而不是一个引用另一个模块，这就是我所想到的。

所以我的问题是，从有真实经验的人那里，在 go 中处理这种情况的最佳方法是什么？

我应该提到，它们重复结构的原因只是因为我试图打破它们之间的依赖关系，原始代码只是在一个包中包含该结构，而另一个包引用它。

package a

type cfg struct {
    addr                 string
    loc                  tzconfig
}

type tzconfig struct {
    string string
    tz     *time.location `validate:"nodescent"`
}

func getcfg() cfg {
    t, _ := time.loadlocation(`mst`)
    return cfg{
        addr: "abc",
        host: "a.bc.d",
        loc:  config.tzconfig{
            string: "mst",
            tz:     t,
        },
    }
}

package b

type cfg struct {
    addr                 string
    loc                  tzconfig
}

type tzconfig struct {
    string string
    tz     *time.location `validate:"nodescent"`
}

func dosomethingwithconfig(c cfg) {
    fmt.println(c)
}

package main

main() {
     c := a.GetCfg()
     d := b.DoSomethingWithConfig(b.Cg(c))
     fmt.Println(d)
}

正确答案

恕我直言，@burakserdar 提供的建议非常好，非常适合您的场景。我用这种方式重写了代码。

package common

package common

import "time"

type cfg struct {
    addr string
    loc  tzconfig
}

type tzconfig struct {
    string string
    tz     *time.location `validate:"nodescent"`
}

这里应该放置常用的结构体、函数、方法等。

package a

package a

import (
    "dependencies/common"
    "time"
)

type cfg struct {
    common.cfg
    host string
}

func getcfg() cfg {
    t, _ := time.loadlocation(`mst`)
    return cfg{
        cfg: common.cfg{
            addr: "abc",
            loc: common.tzconfig{
                string: "mst",
                tz:     t,
            },
        },
        host: "a.bc.d",
    }
}

这里有与 a 包相关的特定代码，它继承了 common 包的共享代码，如 import 部分所示。

请注意，我使用结构嵌入功能来获取 common 包中定义的共享字段。

package b

package b

import (
    "dependencies/common"
    "fmt"
)

func dosomethingwithconfig(c common.cfg) string {
    return fmt.sprint(c)
}

这里，没有什么特别值得一提的。

package main

package main

import (
    "dependencies/a"
    "dependencies/b"
    "fmt"
)

func main() {
    c := a.GetCfg()
    d := b.DoSomethingWithConfig(c.Cfg)
    fmt.Println(d)
}

这里，代码应该非常简单。我导入了 a 和 b 包来利用它们的功能。

我想再次澄清，这是一个主观主题，因此没有灵丹妙药的解决方案。对我来说，看起来整洁、清晰。我肯定会选择这种方式。请告诉我并谢谢！

理论要掌握，实操不能落！以上关于《如何在 Go 中处理具有相似结构的两个不同包中的解耦问题？》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！