3. 限界上下文：定义、映射图与Go模块实践

限界上下文（Bounded Context）是领域驱动设计中最核心的战略设计元素。它划定了模型应用的明确边界，确保术语、规则和逻辑在边界内保持一致性。本章将深入讲解限界上下文的定义、上下文映射图的绘制方法，以及如何利用Go模块实现限界上下文的物理隔离。

3.1 限界上下文的定义与核心原则

限界上下文是一个显式的边界，领域模型在这个边界内具有特定的含义和规则。同一个术语在不同的限界上下文中可能代表完全不同的概念。

3.2 上下文映射图

上下文映射图（Context Map）描述了不同限界上下文之间的协作关系。它是团队沟通和系统集成的蓝图。

3.2.1 核心关系模式

3.2.2 上下文映射图示例

以下SVG图展示了一个电商系统中四个限界上下文之间的映射关系：

3.3 Go模块作为限界上下文的实践

在Go语言中，go module 是天然的限界上下文物理载体。每个模块拥有独立的 go.mod 文件，可以独立版本管理和构建。

3.3.1 模块结构设计原则

• 一个模块一个上下文：每个限界上下文对应一个独立的Go模块，模块名反映上下文名称。
• 显式依赖声明：模块间的依赖关系通过 require 显式声明，避免隐式耦合。
• 内部包封装：上下文内部的实现细节放在 internal 包中，禁止外部模块直接引用。
• 接口定义在消费方：依赖倒置原则，接口定义在调用方模块，实现方模块提供具体实现。

3.3.2 典型模块结构示例

以下是一个电商系统的Go模块组织结构：

ecommerce/
├── order/                    # 订单上下文模块
│   ├── go.mod                # module ecommerce/order
│   ├── internal/
│   │   ├── domain/           # 领域模型
│   │   │   ├── order.go
│   │   │   └── order_repository.go
│   │   ├── application/      # 应用服务
│   │   │   └── order_service.go
│   │   └── infrastructure/   # 基础设施
│   │       └── order_repo_impl.go
│   └── api/                  # 对外接口
│       └── order_api.go
├── payment/                  # 支付上下文模块
│   ├── go.mod                # module ecommerce/payment
│   ├── internal/
│   │   ├── domain/
│   │   │   ├── payment.go
│   │   │   └── payment_repository.go
│   │   └── application/
│   │       └── payment_service.go
│   └── api/
│       └── payment_api.go
├── inventory/                # 库存上下文模块
│   ├── go.mod                # module ecommerce/inventory
│   └── internal/
│       ├── domain/
│       └── application/
└── shipping/                 # 物流上下文模块
    ├── go.mod                # module ecommerce/shipping
    └── internal/
        ├── domain/
        └── application/

3.3.3 模块间集成模式

以下SVG图展示了Go模块作为限界上下文时的集成架构：

3.4 实践案例：订单上下文与支付上下文的集成

以下代码展示了两个限界上下文通过Go模块进行集成的典型模式：

3.4.1 订单上下文定义接口（消费方）

// order/api/order_api.go
package api

// PaymentService 定义在订单上下文中，由支付上下文实现
type PaymentService interface {
    ProcessPayment(orderID string, amount float64) (string, error)
    RefundPayment(transactionID string) error
}

// OrderService 订单应用服务
type OrderService struct {
    payment PaymentService
}

func NewOrderService(payment PaymentService) *OrderService {
    return &OrderService{payment: payment}
}

func (s *OrderService) PlaceOrder(order *Order) error {
    // 订单验证逻辑...
    transactionID, err := s.payment.ProcessPayment(order.ID, order.TotalAmount)
    if err != nil {
        return fmt.Errorf("payment failed: %w", err)
    }
    order.TransactionID = transactionID
    order.Status = OrderStatusPaid
    return nil
}

3.4.2 支付上下文实现接口（供应方）

// payment/api/payment_api.go
package api

// PaymentProcessor 支付处理实现
type PaymentProcessor struct {
    gateway PaymentGateway
}

func NewPaymentProcessor(gateway PaymentGateway) *PaymentProcessor {
    return &PaymentProcessor{gateway: gateway}
}

func (p *PaymentProcessor) ProcessPayment(orderID string, amount float64) (string, error) {
    // 调用支付网关
    transactionID, err := p.gateway.Charge(amount)
    if err != nil {
        return "", err
    }
    // 保存支付记录
    payment := &Payment{
        OrderID:        orderID,
        Amount:         amount,
        TransactionID:  transactionID,
        Status:         PaymentStatusSuccess,
    }
    if err := p.repo.Save(payment); err != nil {
        return "", err
    }
    return transactionID, nil
}

func (p *PaymentProcessor) RefundPayment(transactionID string) error {
    // 退款逻辑...
    return nil
}

3.4.3 主程序组装

// cmd/main.go
package main

import (
    "ecommerce/order/api"
    paymentapi "ecommerce/payment/api"
)

func main() {
    // 创建支付处理器
    paymentProcessor := paymentapi.NewPaymentProcessor(gateway)
    
    // 注入到订单服务
    orderService := api.NewOrderService(paymentProcessor)
    
    // 使用订单服务
    order := &api.Order{ID: "ORD-001", TotalAmount: 299.99}
    if err := orderService.PlaceOrder(order); err != nil {
        log.Fatal(err)
    }
}

3.5 限界上下文与Go模块的映射规则总结