golang 解决循环依赖

方式一：设计合理的层级结构，避免循环调用（略）

方式二：通过接口（interface）中转，避免多个包之间的直接引用

1. 目录结构：

   |—— go-circle/   // 根目录
   ****|—— packageA/  // A包
   ********|—— a.go
   ****|—— packageB/  // B包
   ********|—— b.go
   ****|—— packageInterface/  // Interface包
   ********|—— interface.go
   ****|—— go.mod  // go module文件
   ****|—— main.go  // 入口文件

2. 代码：

   1. go.mod：

      module go-circle

   2. a.go：

       package packageA
      
       import (
           "fmt"
           "go-circle/packageInterface"
       )
      
       type ClassA struct {
           B packageInterface.InterfaceB
       }
      
       func (a ClassA) PrintA() {
           fmt.Println("aaa")
       }
      
       func (a ClassA) PrintAll() {
           a.PrintA()
           a.B.PrintB()
       }

   3. b.go：

       package packageB
      
       import (
           "fmt"
           "go-circle/packageInterface"
       )
      
       type ClassB struct {
           A packageInterface.InterfaceA
       }
      
       func (b ClassB) PrintB() {
           fmt.Println("bbb")
       }
      
       func (b ClassB) PrintAll() {
           b.PrintB()
           b.A.PrintA()
       }

   4. interface.go：

       package packageInterface
      
       type InterfaceA interface {
           PrintA()
       }
      
       type InterfaceB interface {
           PrintB()
       }

   5. main.go：

       package main
      
       import (
           "go-circle/packageA"
           "go-circle/packageB"
       )
      
       func main() {
           objA := packageA.ClassA{}
           objB := packageB.ClassB{}
           objA.B = objB
           objB.A = objA
           objA.PrintAll()
           objB.PrintAll()
       }