4. 聚合根的设计原则：唯一标识、全局访问入口、内部一致性保证、外部引用规则

聚合根（Aggregate Root）是领域驱动设计中聚合（Aggregate）的入口与边界守护者。设计聚合根时，必须遵循四项核心原则，以确保聚合内部的一致性与微服务边界的清晰性。以下逐一展开。

4.1 唯一标识（Identity）

每个聚合根必须拥有一个全局唯一的标识符（ID），该标识符在聚合的整个生命周期内保持不变。唯一标识是聚合根区别于其他实体的核心特征，也是外部系统引用聚合的唯一凭证。

// 聚合根实体基类示例（Java）
public abstract class AggregateRoot<TId> {
    private TId id;
    private int version; // 乐观锁版本号

    protected AggregateRoot(TId id) {
        this.id = id;
        this.version = 0;
    }

    public TId getId() { return id; }

    // 重写equals/hashCode基于id
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        AggregateRoot<?> that = (AggregateRoot<?>) o;
        return Objects.equals(id, that.id);
    }

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

4.2 全局访问入口（Global Access Entry）

聚合根是外部访问聚合内部实体的唯一入口。任何对聚合内部对象的操作都必须通过聚合根的方法进行，不允许外部直接获取内部实体引用后绕过聚合根修改状态。

// 正确的聚合根设计：通过方法封装业务操作
public class Order extends AggregateRoot<OrderId> {
    private List<OrderLineItem> items;
    private OrderStatus status;
    private Money totalAmount;

    // 外部只能通过此方法添加商品，不能直接操作items列表
    public void addItem(ProductId productId, int quantity, Money unitPrice) {
        if (status != OrderStatus.PENDING) {
            throw new IllegalStateException("只能向待支付订单添加商品");
        }
        OrderLineItem item = new OrderLineItem(productId, quantity, unitPrice);
        items.add(item);
        recalculateTotalAmount();
    }

    private void recalculateTotalAmount() {
        this.totalAmount = items.stream()
                .map(OrderLineItem::getSubtotal)
                .reduce(Money.ZERO, Money::add);
    }

    // 不对外暴露items的引用
    // public List<OrderLineItem> getItems() { return items; } // 禁止！
}

4.3 内部一致性保证（Internal Consistency Guarantee）

聚合根负责维护聚合内部所有实体和值对象之间的业务规则与不变量（Invariants）。任何状态变更都必须经过聚合根的验证逻辑，确保聚合始终处于有效状态。

• 不变量检查：在聚合根的方法入口处验证业务规则，如订单总金额必须大于零、库存不能为负数。
• 事务边界：一个聚合对应一个事务，聚合内部的状态变更要么全部成功，要么全部回滚。
• 版本控制：使用乐观锁（版本号）防止并发修改导致的数据不一致。

// 内部一致性保证示例
public class Inventory extends AggregateRoot<InventoryId> {
    private int availableQuantity;
    private int reservedQuantity;

    public void reserve(int quantity) {
        // 不变量：可用库存必须足够
        if (quantity <= 0) {
            throw new IllegalArgumentException("预留数量必须为正数");
        }
        if (availableQuantity - reservedQuantity < quantity) {
            throw new InsufficientInventoryException("库存不足");
        }
        this.reservedQuantity += quantity;
        // 版本号自动递增，用于乐观锁
        incrementVersion();
    }

    public void confirmReservation(int quantity) {
        if (quantity <= 0 || quantity > reservedQuantity) {
            throw new IllegalArgumentException("确认数量无效");
        }
        this.availableQuantity -= quantity;
        this.reservedQuantity -= quantity;
        incrementVersion();
    }
}

4.4 外部引用规则（External Reference Rules）

聚合之间的引用必须遵循严格规则，避免产生紧耦合和跨聚合的事务依赖。

// 外部引用规则：只保存ID，不保存对象引用
public class Order extends AggregateRoot<OrderId> {
    private CustomerId customerId;  // 正确：只保存ID
    // private Customer customer;   // 错误：保存了对象引用

    // 通过ID获取客户信息（通过应用服务或仓储）
    public CustomerId getCustomerId() {
        return customerId;
    }
}

// 应用服务协调跨聚合操作
public class OrderApplicationService {
    private final OrderRepository orderRepository;
    private final InventoryRepository inventoryRepository;
    private final EventBus eventBus;

    @Transactional
    public void createOrder(CreateOrderCommand cmd) {
        Order order = new Order(cmd.getCustomerId());
        order.addItem(cmd.getProductId(), cmd.getQuantity(), cmd.getUnitPrice());
        orderRepository.save(order);

        // 发布领域事件，由库存服务最终一致性处理
        eventBus.publish(new OrderCreatedEvent(
            order.getId(), cmd.getProductId(), cmd.getQuantity()
        ));
    }
}

4.5 聚合根设计原则全景图

以下SVG图展示了四项原则在聚合根设计中的协同关系，以及它们如何共同保障聚合边界与微服务一致性。

4.6 原则冲突与权衡

在实际建模中，四项原则之间可能出现冲突，需要根据业务场景进行权衡。

4.7 微服务边界映射

聚合根的设计直接决定了微服务的拆分粒度。一个微服务通常包含一个或多个聚合，但聚合之间的引用必须通过服务接口（API）进行，而非直接共享数据库。