1
// user 模块
2
package user
3

4
type Service struct {
5
  order *order.Service // 依赖 order 模块
6
}
7

8
func (s *Service) U() {
9
  s.order.O()
10
}

1
// order 模块
2
package order
3

4
type Service struct {
5
  user *user.Service // 依赖 user 模块
6
}
7

8
func (s *Service) O() {
9
  s.user.U()
10
}

1
import cycle not allowed
2
import "example/user"
3
    import "example/order"

1
// user 模块：定义 OrderAPI 接口
2
package user
3

4
type OrderAPI interface {
5
  O()
6
}
7

8
type Service struct {
9
  order OrderAPI // 只依赖抽象，不再依赖 order 包
10
}
11

12
func NewService(o OrderAPI) *Service {
13
  return &Service{order: o}
14
}
15

16
func (s *Service) U() {
17
  s.order.O()
18
}

1
// order 模块：定义 UserAPI 接口
2
package order
3

4
type UserAPI interface {
5
  U()
6
}
7

8
type Service struct {
9
  user UserAPI // 只依赖抽象，不再依赖 user 包
10
}
11

12
func NewService(u UserAPI) *Service {
13
  return &Service{user: u}
14
}
15

16
func (s *Service) O() {
17
  s.user.U()
18
}

1
// 组合根 main.go：无论先创建哪个，另一个都还没就绪
2
func main() {
3
  userSvc := user.NewService(orderSvc)  // orderSvc 还没创建
4
  orderSvc := order.NewService(userSvc) // userSvc 还没创建
5
}

1
// 属性注入：不通过构造函数注入，先把对象建出来再补上依赖
2
func main() {
3
  userSvc := &user.Service{}               // Order 依赖先空着
4
  orderSvc := &order.Service{User: userSvc}
5
  userSvc.Order = orderSvc                 // 事后补上，绕开注入死锁
6
}

1
// 懒加载：用到的时候才去获取依赖
2
package user
3

4
type Service struct {
5
  orderOnce sync.Once
6
  order     OrderAPI
7
}
8

9
func (s *Service) getOrder() OrderAPI {
10
  s.orderOnce.Do(func() {
11
    s.order = order.GetInstance()
12
  })
13
  return s.order
14
}

1
// task 模块
2
package task
3

4
type TaskQueue interface {
5
  Enqueue(taskID string) error
6
}
7

8
type TaskService struct {
9
  queue TaskQueue
10
}
11

12
func NewTaskService(q TaskQueue) *TaskService {
13
  return &TaskService{queue: q}
14
}
15

16
func (s *TaskService) Submit(taskID string) error {
17
  return s.queue.Enqueue(taskID)
18
}
19

20
func (s *TaskService) UpdateStatus(taskID string, status string) error {
21
  // 更新任务状态
22
  return nil
23
}

1
// taskqueue 模块
2
package taskqueue
3

4
type TaskUpdater interface {
5
  UpdateStatus(taskID string, status string) error
6
}
7

8
type TaskQueue struct {
9
  updater TaskUpdater
10
}
11

12
func NewTaskQueue(u TaskUpdater) *TaskQueue {
13
  return &TaskQueue{updater: u}
14
}
15

16
func (q *TaskQueue) Enqueue(taskID string) error {
17
  // ...投递到消息队列
18
  return q.updater.UpdateStatus(taskID, "running")
19
}

1
// 组合根负责装配：双方的具体实现各自满足对方的抽象
2
func main() {
3
  taskSvc := task.NewTaskService(nil)      // 先创建，便于后续注入
4
  queue := taskqueue.NewTaskQueue(taskSvc) // task.TaskService 实现了 TaskUpdater
5
  taskSvc = task.NewTaskService(queue)     // taskqueue.TaskQueue 实现了 TaskQueue
6
}