【系统架构设计百科】DDD 战术模式：聚合、实体与值对象

public class Customer {
    private final CustomerId id; // 身份标识，不可变
    private String name;          // 可变属性
    private Email email;          // 可变属性

    public Customer(CustomerId id, String name, Email email) {
        this.id = Objects.requireNonNull(id);
        this.name = Objects.requireNonNull(name);
        this.email = Objects.requireNonNull(email);
    }

    // 基于身份标识的相等性
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Customer)) return false;
        Customer other = (Customer) o;
        return this.id.equals(other.id);
    }

    @Override
    public int hashCode() {
        return id.hashCode();
    }

    public void changeName(String newName) {
        // 属性变了，但实体的身份不变
        this.name = Objects.requireNonNull(newName);
    }
}

public final class Money {
    private final BigDecimal amount;
    private final Currency currency;

    public Money(BigDecimal amount, Currency currency) {
        this.amount = Objects.requireNonNull(amount);
        this.currency = Objects.requireNonNull(currency);
    }

    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new CurrencyMismatchException(this.currency, other.currency);
        }
        // 返回新对象，不修改原对象
        return new Money(this.amount.add(other.amount), this.currency);
    }

    public Money multiply(int quantity) {
        return new Money(
            this.amount.multiply(BigDecimal.valueOf(quantity)),
            this.currency
        );
    }

    // 基于值的相等性
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Money)) return false;
        Money money = (Money) o;
        return amount.compareTo(money.amount) == 0
            && currency.equals(money.currency);
    }

    @Override
    public int hashCode() {
        return Objects.hash(amount, currency);
    }
}

-- 值对象嵌入实体表
CREATE TABLE orders (
    id UUID PRIMARY KEY,
    -- Money 值对象，展开为两列
    total_amount DECIMAL(18, 2) NOT NULL,
    total_currency VARCHAR(3) NOT NULL,
    -- Address 值对象，展开为多列
    shipping_street VARCHAR(200),
    shipping_city VARCHAR(50),
    shipping_state VARCHAR(50),
    shipping_zip VARCHAR(20),
    shipping_country VARCHAR(2)
);

@Embeddable
public class Address {
    @Column(name = "shipping_street")
    private String street;
    @Column(name = "shipping_city")
    private String city;
    @Column(name = "shipping_state")
    private String state;
    @Column(name = "shipping_zip")
    private String zipCode;
    @Column(name = "shipping_country")
    private String country;
}

public class Order {
    private OrderId id;
    private List<OrderLine> lines;
    private Money totalAmount;
    private OrderStatus status;

    // 不变条件：总金额必须等于所有行项金额之和
    public void addLine(Product product, int quantity, Money unitPrice) {
        if (this.status != OrderStatus.DRAFT) {
            throw new OrderNotEditableException(this.id);
        }
        OrderLine line = new OrderLine(product.id(), quantity, unitPrice);
        this.lines.add(line);
        recalculateTotal(); // 维护不变条件
    }

    private void recalculateTotal() {
        this.totalAmount = lines.stream()
            .map(OrderLine::lineTotal)
            .reduce(Money.ZERO, Money::add);
    }
}

// 错误：对象引用
public class Order {
    private Customer customer; // 持有了另一个聚合的引用
}

// 正确：ID 引用
public class Order {
    private CustomerId customerId; // 只持有 ID
}

// Order 聚合发布领域事件
public class Order {
    private List<DomainEvent> domainEvents = new ArrayList<>();

    public void confirm() {
        this.status = OrderStatus.CONFIRMED;
        // 不直接修改库存聚合，而是发布事件
        domainEvents.add(new OrderConfirmedEvent(
            this.id,
            this.lines.stream()
                .map(l -> new OrderLineSnapshot(l.productId(), l.quantity()))
                .collect(toList())
        ));
    }

    public List<DomainEvent> domainEvents() {
        return Collections.unmodifiableList(domainEvents);
    }

    public void clearEvents() {
        domainEvents.clear();
    }
}

// 事件处理器在另一个事务中更新库存聚合
public class InventoryEventHandler {
    public void handle(OrderConfirmedEvent event) {
        for (OrderLineSnapshot line : event.lines()) {
            Inventory inv = inventoryRepo.findByProductId(line.productId());
            inv.reserve(line.quantity());
            inventoryRepo.save(inv);
        }
    }
}

// 订单聚合
type Order struct {
    id          OrderID
    customerID  CustomerID  // 通过 ID 引用其他聚合
    lines       []OrderLine // 聚合内部的实体
    totalAmount Money       // 值对象
    status      OrderStatus
    version     int         // 乐观锁版本号
    events      []DomainEvent
}

// OrderLine 是聚合内部的实体，有本地标识
type OrderLine struct {
    lineID    LineID
    productID ProductID
    quantity  int
    unitPrice Money
}

func (l OrderLine) LineTotal() Money {
    return l.unitPrice.Multiply(l.quantity)
}

// 聚合根的方法封装业务规则
func (o *Order) AddLine(productID ProductID, qty int, price Money) error {
    if o.status != OrderStatusDraft {
        return ErrOrderNotEditable
    }
    if qty <= 0 {
        return ErrInvalidQuantity
    }
    line := OrderLine{
        lineID:    NewLineID(),
        productID: productID,
        quantity:  qty,
        unitPrice: price,
    }
    o.lines = append(o.lines, line)
    o.recalculateTotal()
    return nil
}

func (o *Order) Confirm() error {
    if o.status != OrderStatusDraft {
        return ErrOrderNotEditable
    }
    if len(o.lines) == 0 {
        return ErrEmptyOrder
    }
    o.status = OrderStatusConfirmed
    o.events = append(o.events, OrderConfirmedEvent{
        OrderID:    o.id,
        CustomerID: o.customerID,
        Lines:      o.lineSnapshots(),
        Total:      o.totalAmount,
        OccurredAt: time.Now(),
    })
    return nil
}

func (o *Order) recalculateTotal() {
    total := MoneyZero(CNY)
    for _, line := range o.lines {
        total = total.Add(line.LineTotal())
    }
    o.totalAmount = total
}

// 外部通过聚合根访问内部对象
func (o *Order) Lines() []OrderLine {
    result := make([]OrderLine, len(o.lines))
    copy(result, o.lines) // 返回副本，保护内部状态
    return result
}

public class PlaceOrderService {
    private final OrderRepository orderRepo;
    private final ProductRepository productRepo;
    private final InventoryRepository inventoryRepo;

    @Transactional
    public OrderId placeOrder(PlaceOrderCommand cmd) {
        // 加载所需的聚合
        Product product = productRepo.findById(cmd.productId());
        Inventory inventory = inventoryRepo.findByProductId(cmd.productId());

        // 业务验证
        if (!inventory.hasStock(cmd.quantity())) {
            throw new InsufficientStockException(cmd.productId());
        }

        // 创建订单聚合
        Order order = Order.create(
            cmd.customerId(),
            product.id(),
            cmd.quantity(),
            product.currentPrice()
        );

        // 注意：这里只保存订单聚合
        // 库存的扣减通过领域事件异步完成
        orderRepo.save(order);
        eventPublisher.publish(order.domainEvents());
        return order.id();
    }
}

public interface PricingPolicy {
    Money calculatePrice(ProductId productId, int quantity);
}

public class Order {
    public void addLine(ProductId productId, int quantity, PricingPolicy pricing) {
        Money price = pricing.calculatePrice(productId, quantity);
        OrderLine line = new OrderLine(productId, quantity, price);
        this.lines.add(line);
        recalculateTotal();
    }
}

// 领域服务：转账
public class TransferService {
    public void transfer(Account from, Account to, Money amount) {
        if (!from.hasSufficientBalance(amount)) {
            throw new InsufficientBalanceException(from.id());
        }
        from.debit(amount);
        to.credit(amount);
    }
}

// 应用服务：编排转账流程
public class TransferAppService {
    private final AccountRepository accountRepo;
    private final TransferService transferService;
    private final EventPublisher eventPublisher;

    @Transactional
    public void executeTransfer(TransferCommand cmd) {
        // 1. 加载聚合
        Account from = accountRepo.findById(cmd.fromAccountId());
        Account to = accountRepo.findById(cmd.toAccountId());
        Money amount = new Money(cmd.amount(), cmd.currency());

        // 2. 执行领域逻辑（委托给领域服务）
        transferService.transfer(from, to, amount);

        // 3. 持久化
        accountRepo.save(from);
        accountRepo.save(to);

        // 4. 发布事件
        eventPublisher.publish(new TransferCompletedEvent(
            from.id(), to.id(), amount
        ));
    }
}

// 领域层：仓储接口
public interface OrderRepository {
    Order findById(OrderId id);
    void save(Order order);
    void delete(Order order);
    List<Order> findByCustomerId(CustomerId customerId);
}

// 基础设施层：仓储实现
public class JpaOrderRepository implements OrderRepository {
    private final EntityManager em;

    @Override
    public Order findById(OrderId id) {
        OrderEntity entity = em.find(OrderEntity.class, id.value());
        if (entity == null) {
            throw new OrderNotFoundException(id);
        }
        return OrderMapper.toDomain(entity);
    }

    @Override
    public void save(Order order) {
        OrderEntity entity = OrderMapper.toEntity(order);
        em.merge(entity);
    }
}

// 领域层：仓储接口
type OrderRepository interface {
    FindByID(ctx context.Context, id OrderID) (*Order, error)
    Save(ctx context.Context, order *Order) error
    NextID() OrderID
}

// 基础设施层：PostgreSQL 实现
type pgOrderRepository struct {
    db *sql.DB
}

func (r *pgOrderRepository) FindByID(ctx context.Context, id OrderID) (*Order, error) {
    row := r.db.QueryRowContext(ctx,
        `SELECT id, customer_id, total_amount, total_currency, status, version
         FROM orders WHERE id = $1`, id.String())

    var o orderRow
    if err := row.Scan(&o.id, &o.customerID, &o.totalAmount,
        &o.totalCurrency, &o.status, &o.version); err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            return nil, ErrOrderNotFound
        }
        return nil, fmt.Errorf("查询订单失败: %w", err)
    }

    lines, err := r.loadLines(ctx, id)
    if err != nil {
        return nil, err
    }

    return reconstitute(o, lines), nil
}

func (r *pgOrderRepository) Save(ctx context.Context, order *Order) error {
    tx, err := r.db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }
    defer tx.Rollback()

    // 乐观锁：版本号检查
    result, err := tx.ExecContext(ctx,
        `UPDATE orders SET customer_id=$1, total_amount=$2,
         total_currency=$3, status=$4, version=version+1
         WHERE id=$5 AND version=$6`,
        order.customerID.String(), order.totalAmount.Amount(),
        order.totalAmount.Currency(), order.status,
        order.id.String(), order.version)
    if err != nil {
        return err
    }

    rows, _ := result.RowsAffected()
    if rows == 0 {
        return ErrConcurrencyConflict
    }

    // 保存行项（先删后插，简化逻辑）
    if err := r.deleteLines(ctx, tx, order.id); err != nil {
        return err
    }
    if err := r.insertLines(ctx, tx, order.id, order.lines); err != nil {
        return err
    }

    return tx.Commit()
}

public class OrderConfirmedEvent implements DomainEvent {
    private final OrderId orderId;
    private final CustomerId customerId;
    private final Money totalAmount;
    private final Instant occurredAt;

    public OrderConfirmedEvent(OrderId orderId, CustomerId customerId,
                               Money totalAmount) {
        this.orderId = orderId;
        this.customerId = customerId;
        this.totalAmount = totalAmount;
        this.occurredAt = Instant.now();
    }

    // getter 方法省略
}

public abstract class AggregateRoot<ID> {
    private final List<DomainEvent> domainEvents = new ArrayList<>();

    protected void registerEvent(DomainEvent event) {
        domainEvents.add(event);
    }

    public List<DomainEvent> domainEvents() {
        return Collections.unmodifiableList(domainEvents);
    }

    public void clearEvents() {
        domainEvents.clear();
    }
}

public class Order extends AggregateRoot<OrderId> {
    public void confirm() {
        // 业务逻辑
        this.status = OrderStatus.CONFIRMED;
        // 注册领域事件
        registerEvent(new OrderConfirmedEvent(this.id, this.customerId, this.totalAmount));
    }
}