#DDD核心概念精讲

class Order {
    private OrderId id; // 唯一标识，整个生命周期不变
    private OrderStatus status; // 属性可变
    private Money amount; // 属性可变

    // 通过 ID 判断相等，不是通过属性
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Order order = (Order) o;
        return id.equals(order.id);
    }

    @Override
    public int hashCode() {
        return id.hashCode(); // 基于 ID 计算哈希
    }
}

// Money 是值对象
class Money {
    private final BigDecimal amount;
    private final Currency currency;

    private Money(BigDecimal amount, Currency currency) {
        this.amount = amount;
        this.currency = currency;
    }

    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("Currency mismatch");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Money money = (Money) o;
        return amount.equals(money.amount) && currency.equals(money.currency);
    }

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

// Order 是聚合根
class Order extends BaseAggregateRoot {
    private OrderId id;
    private List<OrderItem> items; // OrderItem 不能单独存在

    // 外部只能通过 Order 访问 OrderItem
    public void addItem(Product product, int quantity) {
        if (this.status != OrderStatus.DRAFT) {
            throw new OrderCannotModifyException();
        }

        // 业务规则内聚
        OrderItem existing = findItem(product.getId());
        if (existing != null) {
            existing.increaseQuantity(quantity);
        } else {
            items.add(new OrderItem(product.getId(), product.getPrice(), quantity));
        }
        recalculateTotal();
    }

    // 内部方法
    private OrderItem findItem(ProductId productId) {
        return items.stream()
            .filter(i -> i.getProductId().equals(productId))
            .findFirst()
            .orElse(null);
    }
}

// 跨聚合的业务逻辑：转账
class TransferService {
    public void transfer(Account from, Account to, Money amount) {
        // 涉及两个 Account 聚合，无法放在任何一个聚合中
        from.withdraw(amount);
        to.deposit(amount);
    }
}

// 领域事件
record OrderCreatedEvent(
    OrderId orderId,
    UserId userId,
    Money amount,
    Instant occurredAt
) implements DomainEvent {}

// 聚合根中发布事件
class Order extends BaseAggregateRoot {
    public void create(CreateOrderCommand cmd) {
        Order order = new Order(cmd.getUserId());
        order.items.addAll(cmd.getItems());
        order.calculateTotal();

        // 发布领域事件
        registerEvent(new OrderCreatedEvent(
            order.getId(),
            order.getUserId(),
            order.getTotalAmount(),
            Instant.now()
        ));

        return order;
    }
}

// 订阅领域事件
@EventListener
class InventoryService {
    @Async
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 扣减库存
        for (OrderItem item : event.getItems()) {
            inventoryService.reserve(item.getProductId(), item.getQuantity());
        }
    }
}

// 仓储接口（在领域层定义）
interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(OrderId id);
    List<Order> findByUserId(UserId userId);
}

// 仓储实现（在基础设施层）
class JpaOrderRepository implements OrderRepository {
    @Override
    public void save(Order order) {
        jpaTemplate.save(order);
    }
}