Go 语言实践 DDD 领域模型设计：从理论到落地的完整指南

// Product 商品实体
type Product struct {
	id        string
	name      string
	price     Money
	status    ProductStatus
	createdAt time.Time
	updatedAt time.Time
}

// NewProduct 创建商品时进行业务规则校验
func NewProduct(id, name string, price Money) (*Product, error) {
	if name == "" {
		return nil, errors.New("商品名称不能为空")
	}
	if price.Amount() <= 0 {
		return nil, errors.New("商品价格必须大于零")
	}
	now := time.Now()
	return &Product{
		id:        id,
		name:      name,
		price:     price,
		status:    ProductStatusDraft,
		createdAt: now,
		updatedAt: now,
	}, nil
}

// Publish 上架商品 —— 业务行为封装在实体内部
func (p *Product) Publish() error {
	if p.status != ProductStatusDraft {
		return errors.New("只有草稿状态的商品才能上架")
	}
	p.status = ProductStatusOnSale
	p.updatedAt = time.Now()
	return nil
}

// Money 金额值对象，不可变
type Money struct {
	amount   int64  // 使用分为单位，避免浮点精度问题
	currency string
}

func NewMoney(amount int64, currency string) (Money, error) {
	if currency == "" {
		return Money{}, errors.New("币种不能为空")
	}
	return Money{amount: amount, currency: currency}, nil
}

func (m Money) Amount() int64    { return m.amount }
func (m Money) Currency() string { return m.currency }

// Add 金额相加，返回新的值对象而非修改原对象
func (m Money) Add(other Money) (Money, error) {
	if m.currency != other.currency {
		return Money{}, errors.New("不同币种不能直接相加")
	}
	return Money{amount: m.amount + other.amount, currency: m.currency}, nil
}

// Equals 值对象通过属性判等
func (m Money) Equals(other Money) bool {
	return m.amount == other.amount && m.currency == other.currency
}

// Order 订单聚合根
type Order struct {
	id         string
	customerID string
	items      []OrderItem
	status     OrderStatus
	totalPrice Money
	createdAt  time.Time
}

// OrderItem 订单项（聚合内部实体，不对外直接暴露）
type OrderItem struct {
	productID string
	name      string
	price     Money
	quantity  int
}

// NewOrder 创建订单
func NewOrder(id, customerID string) (*Order, error) {
	if customerID == "" {
		return nil, errors.New("客户 ID 不能为空")
	}
	return &Order{
		id:         id,
		customerID: customerID,
		items:      make([]OrderItem, 0),
		status:     OrderStatusPending,
		totalPrice: Money{amount: 0, currency: "CNY"},
		createdAt:  time.Now(),
	}, nil
}

// AddItem 通过聚合根添加订单项，维护总价一致性
func (o *Order) AddItem(productID, name string, price Money, quantity int) error {
	if o.status != OrderStatusPending {
		return errors.New("只有待支付状态的订单才能添加商品")
	}
	if quantity <= 0 {
		return errors.New("商品数量必须大于零")
	}

	item := OrderItem{
		productID: productID,
		name:      name,
		price:     price,
		quantity:  quantity,
	}
	o.items = append(o.items, item)

	// 重新计算总价，保证一致性
	o.recalculateTotal()
	return nil
}

// Confirm 确认订单
func (o *Order) Confirm() error {
	if o.status != OrderStatusPending {
		return errors.New("只有待支付状态的订单才能确认")
	}
	if len(o.items) == 0 {
		return errors.New("订单中至少需要包含一个商品")
	}
	o.status = OrderStatusConfirmed
	return nil
}

func (o *Order) recalculateTotal() {
	var total int64
	for _, item := range o.items {
		total += item.price.Amount() * int64(item.quantity)
	}
	o.totalPrice = Money{amount: total, currency: "CNY"}
}

// PricingService 定价领域服务
// 计算价格涉及商品、促销规则、用户会员等级等多个聚合，放在任何一个实体上都不合适
type PricingService struct{}

func (s *PricingService) CalculateOrderPrice(
	items []OrderItem,
	memberLevel MemberLevel,
	coupon *Coupon,
) (Money, error) {
	var total int64
	for _, item := range items {
		total += item.price.Amount() * int64(item.quantity)
	}

	// 会员折扣
	discount := s.getMemberDiscount(memberLevel)
	total = int64(float64(total) * discount)

	// 优惠券抵扣
	if coupon != nil && coupon.IsValid() {
		total -= coupon.DiscountAmount()
		if total < 0 {
			total = 0
		}
	}

	return NewMoney(total, "CNY")
}

func (s *PricingService) getMemberDiscount(level MemberLevel) float64 {
	switch level {
	case MemberLevelGold:
		return 0.9
	case MemberLevelPlatinum:
		return 0.85
	default:
		return 1.0
	}
}

// OrderAppService 订单应用服务
type OrderAppService struct {
	orderRepo    OrderRepository
	productRepo  ProductRepository
	pricingSvc   *PricingService
	eventPublish EventPublisher
}

// CreateOrder 创建订单用例 —— 纯流程编排，不含业务判断
func (s *OrderAppService) CreateOrder(ctx context.Context, cmd CreateOrderCommand) error {
	// 1. 查询商品信息
	products, err := s.productRepo.FindByIDs(ctx, cmd.ProductIDs)
	if err != nil {
		return fmt.Errorf("查询商品失败: %w", err)
	}

	// 2. 创建订单聚合
	order, err := NewOrder(cmd.OrderID, cmd.CustomerID)
	if err != nil {
		return err
	}

	// 3. 添加订单项（业务规则在聚合内部校验）
	for _, p := range products {
		if err := order.AddItem(p.ID(), p.Name(), p.Price(), cmd.QuantityMap[p.ID()]); err != nil {
			return err
		}
	}

	// 4. 确认订单
	if err := order.Confirm(); err != nil {
		return err
	}

	// 5. 持久化
	if err := s.orderRepo.Save(ctx, order); err != nil {
		return fmt.Errorf("保存订单失败: %w", err)
	}

	// 6. 发布领域事件
	s.eventPublish.Publish(ctx, OrderCreatedEvent{OrderID: order.ID()})

	return nil
}

// infrastructure/persistence/order_repo.go —— 基础设施层提供实现
type MySQLOrderRepository struct {
	db *sql.DB
}

func NewMySQLOrderRepository(db *sql.DB) *MySQLOrderRepository {
	return &MySQLOrderRepository{db: db}
}

func (r *MySQLOrderRepository) FindByID(ctx context.Context, id string) (*Order, error) {
	row := r.db.QueryRowContext(ctx,
		"SELECT id, customer_id, status, total_price, created_at FROM orders WHERE id = ?", id)

	var orderPO OrderPO
	if err := row.Scan(&orderPO.ID, &orderPO.CustomerID, &orderPO.Status,
		&orderPO.TotalPrice, &orderPO.CreatedAt); err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, ErrOrderNotFound
		}
		return nil, fmt.Errorf("查询订单失败: %w", err)
	}

	// PO -> 领域对象的转换
	return orderPO.ToDomain()
}

func (r *MySQLOrderRepository) Save(ctx context.Context, order *Order) error {
	po := NewOrderPOFromDomain(order)
	_, err := r.db.ExecContext(ctx,
		`INSERT INTO orders (id, customer_id, status, total_price, created_at)
		 VALUES (?, ?, ?, ?, ?)
		 ON DUPLICATE KEY UPDATE status = ?, total_price = ?`,
		po.ID, po.CustomerID, po.Status, po.TotalPrice, po.CreatedAt,
		po.Status, po.TotalPrice,
	)
	return err
}

// 领域事件定义
type DomainEvent interface {
	EventName() string
	OccurredAt() time.Time
}

type OrderCreatedEvent struct {
	OrderID    string
	CustomerID string
	TotalPrice int64
	OccurredOn time.Time
}

func (e OrderCreatedEvent) EventName() string    { return "order.created" }
func (e OrderCreatedEvent) OccurredAt() time.Time { return e.OccurredOn }

// 事件发布接口
type EventPublisher interface {
	Publish(ctx context.Context, event DomainEvent) error
}

// 事件处理器 —— 订单创建后发送通知
type OrderCreatedHandler struct {
	notificationSvc NotificationService
}

func (h *OrderCreatedHandler) Handle(ctx context.Context, event OrderCreatedEvent) error {
	return h.notificationSvc.SendOrderConfirmation(ctx, event.CustomerID, event.OrderID)
}

package domain

import (
	"errors"
	"fmt"
	"time"
)

// 订单状态枚举
type OrderStatus int

const (
	OrderStatusPending   OrderStatus = iota // 待确认
	OrderStatusConfirmed                     // 已确认
	OrderStatusPaid                          // 已支付
	OrderStatusShipped                       // 已发货
	OrderStatusCompleted                     // 已完成
	OrderStatusCancelled                     // 已取消
)

// Order 订单聚合根
type Order struct {
	id         string
	customerID string
	items      []OrderItem
	status     OrderStatus
	totalPrice Money
	address    Address
	createdAt  time.Time
	updatedAt  time.Time
	events     []DomainEvent
}

func NewOrder(id, customerID string, addr Address) (*Order, error) {
	if id == "" {
		return nil, errors.New("订单 ID 不能为空")
	}
	if customerID == "" {
		return nil, errors.New("客户 ID 不能为空")
	}
	now := time.Now()
	return &Order{
		id:         id,
		customerID: customerID,
		items:      make([]OrderItem, 0),
		status:     OrderStatusPending,
		totalPrice: Money{amount: 0, currency: "CNY"},
		address:    addr,
		createdAt:  now,
		updatedAt:  now,
		events:     make([]DomainEvent, 0),
	}, nil
}

// AddItem 添加订单项
func (o *Order) AddItem(productID, name string, price Money, qty int) error {
	if o.status != OrderStatusPending {
		return fmt.Errorf("当前状态 %d 不允许添加商品", o.status)
	}
	if qty <= 0 {
		return errors.New("数量必须大于 0")
	}

	// 检查是否已存在相同商品，合并数量
	for i, item := range o.items {
		if item.productID == productID {
			o.items[i].quantity += qty
			o.recalculateTotal()
			o.updatedAt = time.Now()
			return nil
		}
	}

	o.items = append(o.items, OrderItem{
		productID: productID,
		name:      name,
		price:     price,
		quantity:  qty,
	})
	o.recalculateTotal()
	o.updatedAt = time.Now()
	return nil
}

// Confirm 确认订单
func (o *Order) Confirm() error {
	if o.status != OrderStatusPending {
		return errors.New("只有待确认的订单才能确认")
	}
	if len(o.items) == 0 {
		return errors.New("空订单无法确认")
	}
	o.status = OrderStatusConfirmed
	o.updatedAt = time.Now()

	// 记录领域事件
	o.events = append(o.events, OrderConfirmedEvent{
		OrderID:    o.id,
		CustomerID: o.customerID,
		OccurredOn: time.Now(),
	})
	return nil
}

// Pay 支付订单
func (o *Order) Pay() error {
	if o.status != OrderStatusConfirmed {
		return errors.New("只有已确认的订单才能支付")
	}
	o.status = OrderStatusPaid
	o.updatedAt = time.Now()

	o.events = append(o.events, OrderPaidEvent{
		OrderID:    o.id,
		TotalPrice: o.totalPrice.Amount(),
		OccurredOn: time.Now(),
	})
	return nil
}

// Cancel 取消订单
func (o *Order) Cancel(reason string) error {
	if o.status == OrderStatusShipped || o.status == OrderStatusCompleted {
		return errors.New("已发货或已完成的订单不能取消")
	}
	if o.status == OrderStatusCancelled {
		return errors.New("订单已经处于取消状态")
	}
	o.status = OrderStatusCancelled
	o.updatedAt = time.Now()

	o.events = append(o.events, OrderCancelledEvent{
		OrderID:    o.id,
		Reason:     reason,
		OccurredOn: time.Now(),
	})
	return nil
}

// PullEvents 获取并清空领域事件
func (o *Order) PullEvents() []DomainEvent {
	events := o.events
	o.events = make([]DomainEvent, 0)
	return events
}

func (o *Order) recalculateTotal() {
	var total int64
	for _, item := range o.items {
		total += item.price.Amount() * int64(item.quantity)
	}
	o.totalPrice = Money{amount: total, currency: o.totalPrice.Currency()}
}

// Getter 方法
func (o *Order) ID() string            { return o.id }
func (o *Order) CustomerID() string     { return o.customerID }
func (o *Order) Status() OrderStatus    { return o.status }
func (o *Order) TotalPrice() Money      { return o.totalPrice }
func (o *Order) Items() []OrderItem     { return o.items }
func (o *Order) ItemCount() int         { return len(o.items) }

// Address 地址值对象
type Address struct {
	province string
	city     string
	district string
	street   string
	zipCode  string
}

func NewAddress(province, city, district, street, zipCode string) (Address, error) {
	if province == "" || city == "" {
		return Address{}, errors.New("省份和城市不能为空")
	}
	return Address{
		province: province,
		city:     city,
		district: district,
		street:   street,
		zipCode:  zipCode,
	}, nil
}

func (a Address) FullAddress() string {
	return fmt.Sprintf("%s%s%s%s", a.province, a.city, a.district, a.street)
}

func (a Address) Equals(other Address) bool {
	return a.province == other.province &&
		a.city == other.city &&
		a.district == other.district &&
		a.street == other.street &&
		a.zipCode == other.zipCode
}

// 反面教材 —— 贫血模型
type Order struct {
	ID     string
	Status int
	Price  float64
}

// 逻辑全在 Service 里，Order 只是数据容器
func (s *OrderService) ConfirmOrder(order *Order) {
	order.Status = 1  // 直接改状态，没有业务校验
}

type BaseEntity struct {
	id        string
	createdAt time.Time
	updatedAt time.Time
}

func (b BaseEntity) ID() string           { return b.id }
func (b BaseEntity) CreatedAt() time.Time { return b.createdAt }

type Order struct {
	BaseEntity
	customerID string
	status     OrderStatus
	// ...
}