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

Question

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

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

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

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

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() 的顺序，也会出现同样的问题。

我希望因为我在这里使用指针和接口(interface)，所以当 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 上这样做也是非法的。指针和运行时，如果遇到这样的操作，就会panic。

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

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

综上所述，就个人而言，我会认为这种循环依赖是一种气味，并会开始考虑重新设计，但也许这只是我。