第2章：服务拆分与边界

// API接口
type ProductService interface {
    // 商品管理
    CreateProduct(product *Product) error
    UpdateProduct(id string, product *Product) error
    DeleteProduct(id string) error

    // 商品查询
    GetProduct(id string) (*Product, error)
    ListProducts(page, pageSize int) ([]*Product, error)
    SearchProducts(keyword string) ([]*Product, error)
}

// 数据模型
type Product struct {
    ID          string
    Name        string
    Description string
    Price       decimal.Decimal
    CategoryID  string
    Stock       int
    Images      []string
    Status      ProductStatus
    CreatedAt   time.Time
    UpdatedAt   time.Time
}

// 数据库表
products:
  id, name, description, price, category_id, stock, status, created_at, updated_at

product_images:
  id, product_id, image_url, sort_order

categories:
  id, name, parent_id, level

// API接口
type OrderService interface {
    // 订单操作
    CreateOrder(req CreateOrderRequest) (*Order, error)
    CancelOrder(orderID string) error

    // 订单查询
    GetOrder(orderID string) (*Order, error)
    ListUserOrders(userID string, page, pageSize int) ([]*Order, error)
}

// 数据模型
type Order struct {
    ID            string
    UserID        string  // 引用User Service
    Items         []OrderItem
    TotalAmount   decimal.Decimal
    Status        OrderStatus
    ShippingAddress Address
    CreatedAt     time.Time
}

type OrderItem struct {
    ProductID   string  // 引用Product Service
    ProductName string  // 冗余，避免查询Product
    Quantity    int
    Price       decimal.Decimal
    Subtotal    decimal.Decimal
}

// 数据库表
orders:
  id, user_id, total_amount, status, shipping_address, created_at

order_items:
  id, order_id, product_id, product_name, quantity, price, subtotal

// API接口
type PaymentService interface {
    CreatePayment(req CreatePaymentRequest) (*Payment, error)
    QueryPayment(paymentID string) (*Payment, error)
    RefundPayment(paymentID string, amount decimal.Decimal) error
}

// 数据模型
type Payment struct {
    ID            string
    OrderID       string  // 引用Order Service
    Amount        decimal.Decimal
    Method        PaymentMethod
    Status        PaymentStatus
    TransactionID string  // 第三方支付流水号
    CreatedAt     time.Time
}

// 数据库表
payments:
  id, order_id, amount, method, status, transaction_id, created_at

payment_logs:
  id, payment_id, action, result, message, created_at

// 订单服务创建订单
func (svc *OrderService) CreateOrder(ctx context.Context, req CreateOrderRequest) (*Order, error) {
    // 1. 验证商品库存（同步调用Product Service）
    for _, item := range req.Items {
        available, err := svc.productClient.CheckStock(ctx, item.ProductID, item.Quantity)
        if err != nil || !available {
            return nil, errors.New("insufficient stock")
        }
    }

    // 2. 创建订单（状态：待支付）
    order := &Order{
        ID:              generateID(),
        UserID:          req.UserID,
        Items:           req.Items,
        Status:          OrderStatusPending,
        ShippingAddress: req.ShippingAddress,
        CreatedAt:       time.Now(),
    }

    // 计算总金额
    order.calculateTotal()

    // 3. 保存订单
    if err := svc.orderRepo.Save(order); err != nil {
        return nil, err
    }

    // 4. 发布事件（异步扣库存）
    event := OrderCreatedEvent{
        OrderID: order.ID,
        Items:   order.Items,
    }
    svc.eventBus.Publish(event)

    return order, nil
}

// 库存服务监听订单创建事件
func (svc *InventoryService) OnOrderCreated(event OrderCreatedEvent) error {
    // 预扣库存
    for _, item := range event.Items {
        if err := svc.ReserveStock(item.ProductID, item.Quantity); err != nil {
            // 发布库存不足事件，触发订单取消
            svc.eventBus.Publish(StockInsufficientEvent{
                OrderID:   event.OrderID,
                ProductID: item.ProductID,
            })
            return err
        }
    }

    return nil
}

// OrderService: 创建订单后发布事件
func (svc *OrderService) CreateOrder(...) {
    // ... 创建订单

    svc.eventBus.Publish(OrderCreatedEvent{
        UserID: order.UserID,
    })
}

// UserService: 监听事件，更新订单数
func (svc *UserService) OnOrderCreated(event OrderCreatedEvent) {
    svc.userRepo.IncrementOrderCount(event.UserID)
}

优势：
 异步解耦
 无循环依赖
 性能好

// Saga协调器
type OrderSaga struct {
    orderSvc     *OrderService
    inventorySvc *InventoryService
    paymentSvc   *PaymentService
}

func (saga *OrderSaga) Execute(req CreateOrderRequest) error {
    var compensations []func() error

    // 步骤1: 创建订单
    order, err := saga.orderSvc.CreateOrder(req)
    if err != nil {
        return err
    }
    compensations = append(compensations, func() error {
        return saga.orderSvc.CancelOrder(order.ID)
    })

    // 步骤2: 扣减库存
    err = saga.inventorySvc.ReserveStock(req.Items)
    if err != nil {
        saga.compensate(compensations)
        return err
    }
    compensations = append(compensations, func() error {
        return saga.inventorySvc.ReleaseStock(req.Items)
    })

    // 步骤3: 创建支付
    payment, err := saga.paymentSvc.CreatePayment(order.ID, order.TotalAmount)
    if err != nil {
        saga.compensate(compensations)
        return err
    }

    return nil
}

func (saga *OrderSaga) compensate(compensations []func() error) {
    // 倒序执行补偿
    for i := len(compensations) - 1; i >= 0; i-- {
        compensations[i]()
    }
}