我在当前项目中遇到了一个问题，我有两个模块，一个模块实现用于测试目的的接口，而一个模块只是一个具体的结构，每个模块都依赖于另一个方法。
为了解决这种紧张关系，我尝试创建一个顶级“容器”结构，该结构包含对依赖结构和接口的引用，然后在容器结构上使用一个方法，将其分配为每个结构的成员组件结构，该顶级容器指向另一个结构的指针。我这样做而不是使用全局变量，以便能够更好地封装我的代码以进行测试。
但是，似乎第一个初始化的结构在初始化第二个结构时都看不到另一个结构的地址的变化。我不明白为什么，而且似乎无法实现预期的功能。
由于实际代码中有许多多余的细节，所以我创建了这个玩具示例来说明我在说什么。
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>}
我希望A的r变量在调用NewR（）之后将等于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: <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
或者，如果您want一分为二，则可以执行以下操作：
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
如您所见，初始化的多步骤方法是如此紧密耦合的依赖关系可能会变得不必要地复杂和丑陋，即复杂，即非常容易出错。如果可以，请避免使用它。
所有这些，就我个人而言，我将这种循环依赖视为一种气味，并会开始考虑重新设计，但也许就是我。