如何在golang中干净地初始化两个相互依赖的结构？

Question

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

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

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

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

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: <nil>
INFO[0000] top: {r:0xc000010028 a:0xc00006abc0}
INFO[0000] R: &{a:0xc00006abc0}
INFO[0000] A: &{r:<nil>}

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

由于我在这里使用指针和接口，所以我预计当 top 的值发生变化时这些值会被连接，但很明显我一定是误解了一些东西。我已经尝试过使用指针，但无济于事。

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

Answer 1

为了能够以您想要的方式使用指针，您首先需要实际的指针（即不是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: <nil>

a = &T{"bar"}  // plain assignment
fmt.Println(b) // output: <nil>

请注意，即使你使用了指针间接，在nil 指针上这样做也是非法的，运行时如果遇到这样的操作，将会崩溃。

a := (*T)(nil) // nil pointer
b := a
fmt.Println(b) // output: <nil>

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

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

---

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

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

但是，正如您所看到的，初始化如此紧密耦合的依赖项的多步骤方法可能会变得不必要的复杂和丑陋，即复杂，即非常容易出错。尽量避免。

---

说了这么多，就我个人而言，我会认为这种循环依赖是一种气味，并会开始考虑重新设计，但也许这只是我自己。