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

Question

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

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

但是，似乎第一个初始化的结构在第二个结构初始化时看不到另一个结构地址的变化。我不明白为什么，而且我似乎无法按预期完成此功能。

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

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 指针）并且您还需要使用指针间接寻址才能 "share" 指向值的更新。

例如：

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

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

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

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

How do cleanly initialize two structs in golang which depend on each other?

pointers

dependency-injection

interface

go