在golang中如何优雅地处理两个相互依赖的结构体的初始化？

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

我在当前的项目中遇到了一个问题，其中我有两个模块，一个实现用于测试目的的接口，另一个只是一个具体的结构，每个模块都依赖于另一个模块的方法。

为了解决这种紧张，我尝试创建一个顶级“容器”结构，它保存对依赖结构和接口的引用，然后使用容器结构上的方法，分配为每个组件结构都是顶级容器指向另一个结构的指针。我这样做而不是使用全局变量是为了能够更好地封装我的代码以进行测试。

但是，似乎无论哪个结构先被初始化，在初始化第二个结构时都看不到另一个结构的地址发生变化。我不明白为什么，我似乎无法按预期实现此功能。

由于实际代码中有许多无关的细节，我创建了这个玩具示例来说明我正在谈论的内容。

type container struct {
    r requestor
    a *a
}

type requestor interface {
    request()
}

type a struct {
    r requestor
}

type r struct {
    a *a
}

func (r r) request() {
    log.info("i requested")
    return
}

func (container *container) newa() *a {
    log.info("new a received container.r: ", container.r)
    a := &a{
        r: container.r,
    }
    container.a = a
    return a
}

func (container *container) newr() *r {
    r := &r{
        a: container.a,
    }
    container.r = r
    return r
}

func testdepresolution(t *testing.t) {
    top := container{}

    top.newr()
    top.newa()

    // top.a.r = r

    log.infof("top: %+v", top)
    log.infof("r: %+v", top.r)
    log.infof("a: %+v", top.a)

}

它被设置为测试，因此我可以在我的项目中轻松执行它。输出如下：

=== RUN   TestDepResolution
INFO[0000] New A received container.r: 
INFO[0000] top: {r:0xc000010028 a:0xc00006abc0}
INFO[0000] R: &{a:0xc00006abc0}
INFO[0000] A: &{r:}

我预计在调用 newr() 后 a 的 r 变量将等于 top 的 r 变量，但它似乎没有改变。如果我交换 newa() 和 newr() 的顺序，也会出现同样的问题。

由于我在这里使用指针和接口，因此我预计当 top 的值发生更改时，这些值将被连接，但显然我一定是误解了某些东西。我已经尝试过使用指针很多次但没有成功。

那么为什么这没有像我预期的那样工作呢？有没有办法按照我的建议进行这项工作？或者我是否以一种完全错误的方式思考这个问题？我试图考虑从模块中提取功能，以便它们不相互依赖，并且我可以完全避免这个问题，但我一直无法想出一个好的方法来做到这一点。

解决方案

为了能够按照您想要的方式使用指针，您首先需要实际的指针（即不是 nil 指针），并且还需要使用指针间接来“共享”指向值的更新。

例如：

type t struct { f string }

a := &t{"foo"} // non-nil pointer
b := a
fmt.println(b) // output: {"foo"}

*a = t{"bar"}  // pointer indirection
fmt.println(b) // output: {"bar"}

为了进行比较，以下是您的代码尝试执行的操作：

type t struct { f string }

a := (*t)(nil) // nil pointer
b := a
fmt.println(b) // output: 

a = &t{"bar"}  // plain assignment
fmt.println(b) // output: 

请注意，即使您使用了指针间接寻址，在 nil 指针上这样做也是非法的，并且运行时如果遇到这样的操作，将会出现恐慌。

a := (*t)(nil) // nil pointer
b := a
fmt.println(b) // output: 

*a = t{"bar"} // pointer indirection on nil, will crash the program
fmt.println(b)

因此，您的示例不起作用，因为它没有正确初始化指针，并且不使用指针间接寻址，而是使用简单的赋值，仅更新目标变量的指针而不是指向的值。 p>

要正确初始化容器，您应该一步完成：

func newcontainer() *container {
    c := &container{a: &a{}}
    c.r = &r{a: c.a}
    c.a.r = c.r
    return c
}

https://play.golang.com/p/hfbqJEVyAHZ

或者，如果您想将其分成两部分，您可以执行以下操作：

func (c *container) NewA() *A {
    log.Println("New A received c.r: ", c.r)
    a := &A{
        r: c.r,
    }
    if c.a != nil {
        *c.a = *a
    } else {
        c.a = a
    }
    return a
}

func (c *container) NewR() *R {
    if c.a == nil {
        c.a = new(A)
    }

    r := &R{
        a: c.a,
    }
    c.r = r
    c.a.r = r
    return r
}

https://play.golang.com/p/krmUQOsACdU

总而言之，就我个人而言，我会认为这种循环依赖是一种味道，并会开始考虑重新设计，但也许这只是我的想法。

今天关于《在golang中如何优雅地处理两个相互依赖的结构体的初始化？》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！