250｜DDD 战术设计：实体、值对象、聚合、领域服务、仓储和领域事件

┌─────────────────────────────────────────────────────────┐
│              DDD 战术设计六大模式                          │
│                                                         │
│   实体(Entity)     聚合(Aggregate)     仓储(Repository)    │
│   值对象(VO)       领域服务(Domain Service)               │
│                    领域事件(Domain Event)                  │
└─────────────────────────────────────────────────────────┘

// 实体：Order
public class Order {
    private OrderId id;          // 唯一标识——这是实体的"身份证"
    private OrderStatus status;  // 可变的
    private Money totalAmount;    // 可变的
    private Address shippingAddress; // 可变的
    
    // 实体通过标识判断相等
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Order)) return false;
        Order order = (Order) o;
        return id.equals(order.id);  // 只比 ID，不管其他字段
    }
}

// 推荐：构造时即分配标识
public class Order {
    private OrderId id;
    
    private Order() {} // ORM 用
    
    public static Order create(CustomerId customerId, List<OrderItem> items) {
        Order order = new Order();
        order.id = OrderId.generate();  // UUID 或雪花 ID
        order.customerId = customerId;
        order.items = new ArrayList<>(items);
        order.status = OrderStatus.CREATED;
        order.createdAt = Instant.now();
        return order;
    }
}

// 值对象：Money
public final class Money {
    private final BigDecimal amount;
    private final Currency currency;
    
    public Money(BigDecimal amount, Currency currency) {
        this.amount = amount.setScale(2, RoundingMode.HALF_UP);
        this.currency = Objects.requireNonNull(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);
    }
    
    // 值对象不可变：add 返回新实例而非修改自身
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("Cannot add different currencies");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }
    
    public Money multiply(int factor) {
        return new Money(this.amount.multiply(BigDecimal.valueOf(factor)), this.currency);
    }
}

// ❌ 错误：用 String 表示邮箱
public class Customer {
    private String email;  
    // 问题：这个 String 可能是"abc"、空字符串、非法格式……到处要写校验
}

// ✅ 正确：封装为值对象
public final class Email {
    private final String value;
    
    public Email(String value) {
        if (value == null || !value.matches("^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$")) {
            throw new IllegalArgumentException("Invalid email: " + value);
        }
        this.value = value;
    }
    
    public String getDomain() {
        return value.substring(value.indexOf('@') + 1);
    }
    // 校验逻辑在这里一处，所有使用者自动受益
}

public class Customer {
    private Email email; // 类型即文档，类型即约束
}

// ❌ 错误：Order 直接持有 Product 实体的引用
public class Order {
    private Product product;  // 坏了！跨聚合直接引用
}

// ✅ 正确：Order 只持有 ProductId（值对象）
public class Order {
    private ProductId productId;  // 通过 ID 引用
}

// ✅ 聚合根控制所有内部修改
public class Order {  // <- 聚合根
    private OrderId id;
    private List<OrderItem> items;  // <- 内部实体
    private Address shippingAddress;
    private OrderStatus status;
    
    // 外部不能 order.getItems().add(item) ——破坏封装
    // 只能通过聚合根的方法：
    public void addItem(ProductId productId, Money unitPrice, int quantity) {
        // 不变量1：已支付的订单不能修改
        if (status != OrderStatus.CREATED) {
            throw new OrderAlreadyPaidException(id);
        }
        // 不变量2：同商品不能重复添加（或合并数量——看业务）
        if (items.stream().anyMatch(i -> i.getProductId().equals(productId))) {
            // 合并或拒绝，取决于业务规则
        }
        items.add(new OrderItem(productId, unitPrice, quantity));
    }
    
    public void pay() {
        // 不变量：只有已创建状态的订单能支付
        if (status != OrderStatus.CREATED) {
            throw new IllegalOrderStateTransitionException(status, OrderStatus.PAID);
        }
        this.status = OrderStatus.PAID;
    }
}

聚合内部：强一致事务
├── 订单总金额必须等于各订单项金额之和 —— 必须强一致
├── 已支付的订单不能修改收货地址 —— 必须强一致
└── 订单创建时必须有至少一个订单项 —— 必须强一致

跨聚合：最终一致性
├── 订单支付后通知物流模块发货 —— 通过领域事件，可以异步
├── 订单取消后释放库存 —— 通过领域事件，允许短暂不一致
└── 订单金额更新后通知对账系统 —— 通过领域事件

// 领域服务：TransferService
// 转账涉及两个 Account 聚合，不属于任何一个 Account 实体
public class TransferService {
    
    public void transfer(AccountId from, AccountId to, Money amount) {
        Account source = accountRepository.findById(from);
        Account target = accountRepository.findById(to);
        
        source.debit(amount);   // 扣款
        target.credit(amount);  // 到账
        
        accountRepository.save(source);
        accountRepository.save(target);
    }
}

// 应用服务：编排，不包含业务逻辑
@Service
public class OrderApplicationService {
    
    public void cancelOrder(OrderId orderId) {
        // 1. 事务管理（基础设施）
        // 2. 加载聚合
        Order order = orderRepository.findById(orderId);
        // 3. 调用领域逻辑（只做这一步，但不能自己写 if/else 判断）
        order.cancel();  
        // 4. 持久化
        orderRepository.save(order);
        // 5. 发布领域事件
        eventPublisher.publish(order.getEvents());
    }
}

// 领域服务：包含纯业务逻辑，不处理事务/持久化
public class PricingService {  // 领域服务
    
    public Money calculateTotalPrice(List<OrderItem> items, 
                                      DiscountPolicy policy,
                                      CouponId couponId) {
        Money subtotal = items.stream()
            .map(OrderItem::getSubtotal)
            .reduce(Money.ZERO, Money::add);
        Money afterDiscount = policy.apply(subtotal);
        Money afterCoupon = couponService.applyCoupon(afterDiscount, couponId);
        return afterCoupon;
    }
}

DAO 思维：      "给我一条 order 表的记录"
仓储思维：      "给我 ID 为 X 的 Order 聚合"

public interface OrderRepository {
    // 1. 通过聚合根 ID 获取完整聚合
    Optional<Order> findById(OrderId id);
    
    // 2. 保存整个聚合（而非逐个实体保存）
    void save(Order order);
    
    // 3. 面向集合的查询（不是 CRUD）
    List<Order> findByCustomerId(CustomerId customerId, Pageable page);
    
    // ❌ 不要暴露：updateStatus(), deleteById(), updateAmount()
    // 这些是 DAO 思维——对聚合的修改应该通过 load→modify→save 完成
}

领域层：domain/
└── repository/
    └── OrderRepository.java    ← 接口（纯领域概念）

基础设施层：infrastructure/
└── persistence/
    └── MyBatisOrderRepository.java  ← 实现（依赖 MyBatis/JPA）

// 领域事件
public class OrderPaidEvent implements DomainEvent {
    private final OrderId orderId;
    private final CustomerId customerId;
    private final Money paidAmount;
    private final Instant paidAt;
    
    // 事件的构造函数记录"发生了什么"——是事实，不可修改
    public OrderPaidEvent(OrderId orderId, CustomerId customerId, 
                          Money paidAmount, Instant paidAt) {
        this.orderId = orderId;
        this.customerId = customerId;
        this.paidAmount = paidAmount;
        this.paidAt = paidAt;
    }
}

public class Order {
    private List<DomainEvent> events = new ArrayList<>();
    
    public void pay() {
        // 1. 先执行业务逻辑
        if (status != OrderStatus.CREATED) {
            throw new IllegalOrderStateTransitionException(status, OrderStatus.PAID);
        }
        this.status = OrderStatus.PAID;
        this.paidAt = Instant.now();
        
        // 2. 再生成领域事件
        events.add(new OrderPaidEvent(this.id, this.customerId, 
                                       this.totalAmount, this.paidAt));
    }
    
    // 应用服务在 save 后调用此方法收集事件
    public List<DomainEvent> getEvents() {
        return Collections.unmodifiableList(events);
    }
}

1. OrderApplicationService.cancelOrder(orderId)
   │
2. OrderRepository.findById(orderId)     ← 仓储
   │  返回 Order 聚合
   │
3. order.cancel()                         ← 聚合根（内部协调实体和值对象）
   │  - 检查状态不变量
   │  - 生成 OrderCancelledEvent          ← 领域事件
   │
4. OrderRepository.save(order)            ← 仓储
   │
5. eventPublisher.publish(order.getEvents())
   │  - InventoryService.onOrderCancelled()  ← 跨聚合通过领域服务
   │    inventory.releaseReserved(orderId)    ← 另一个聚合根
   │  - NotificationService.send(orderId)

// ❌ 贫血模型——DDD 的反面教材
public class Order {
    private Long id;
    private String status;
    // getters + setters...
}

@Service
public class OrderService {
    public void cancel(Order order) {
        if (!"PAID".equals(order.getStatus())) {  // 业务逻辑泄漏到 Service
            throw new RuntimeException("...");
        }
        order.setStatus("CANCELLED");
    }
}

// ✅ 充血模型
public class Order {
    public void cancel() {
        if (status != OrderStatus.PAID) {
            throw new IllegalOrderStateTransitionException(status, OrderStatus.CANCELLED);
        }
        this.status = OrderStatus.CANCELLED;
    }
}

// ❌ 这个包含了业务逻辑 if/else，应该在 Domain Service 或实体中
public class OrderService { // 实际上是应用服务
    public void process(Order order) {
        if (order.isVIP()) {
            order.setDiscount(0.8);
        }
        if (order.getAmount() > 10000) {
            // 大额订单审计
        }
    }
}

// ❌ 仓储返回 PO/DTO
public interface OrderRepository {
    OrderPO findById(Long id); // PO 不是领域对象
}

// ✅ 仓储返回领域聚合
public interface OrderRepository {
    Order findById(OrderId id); // 返回完整的 Order 聚合
}

// ❌ 把两个聚合锁在一个事务里
@Transactional
public void payAndReduceInventory(...) {
    order.pay();
    inventory.reduce(...);  // 不同的聚合！
}

// ✅ 先提交 Order，再通过领域事件异步处理 Inventory
@Transactional
public void pay(OrderId id) {
    order.pay();
    orderRepository.save(order);
    eventPublisher.publish(new OrderPaidEvent(...));  // 事件驱动
}

// 另一个事务
@Transactional
public void onOrderPaid(OrderPaidEvent event) {
    inventory.reduce(event.getProductId(), event.getQuantity());
}