2. 领域驱动设计(DDD)基础：实体、值对象、聚合、领域事件核心概念

在微服务与Kubernetes架构中，业务模块的边界划分直接决定了系统的可维护性与扩展性。领域驱动设计（Domain-Driven Design，DDD）提供了一套严谨的战术建模工具，帮助我们将复杂的业务逻辑映射为清晰的代码结构。本节将深入剖析DDD的四大核心构造块：实体（Entity）、值对象（Value Object）、聚合（Aggregate）和领域事件（Domain Event），为后续的K8s服务拆分奠定理论基础。

学习提示：DDD的战术建模是连接业务需求与技术实现的桥梁。在K8s环境中，一个聚合通常对应一个微服务或一个Bounded Context（限界上下文），理解这些概念有助于你设计出高内聚、低耦合的容器化服务。

2.1 实体（Entity）

实体是DDD中最核心的概念之一。它拥有唯一标识符（Identity），并且在其生命周期中，即使属性值发生变化，该标识符也保持不变。实体的判断标准是“你是谁”，而不是“你有什么”。

  • 唯一标识：每个实体必须有一个不可变的ID（如UUID、业务主键）。
  • 可变性：实体的属性可以修改，但身份不变。
  • 生命周期：实体从创建到删除，始终由标识符追踪。
  • 业务行为：实体封装了与其身份相关的业务逻辑。
特性 说明 示例（订单系统）
标识符 全局唯一，不可变 OrderId（UUID）
属性变化 地址、状态可修改 order.changeShippingAddress()
相等性 通过ID比较，而非属性 order1.equals(order2) 比较ID 
// 实体示例：订单
public class Order {
    private OrderId id;          // 唯一标识
    private String customerName;
    private Address shippingAddress; // 值对象
    private OrderStatus status;

    public Order(OrderId id, String customerName) {
        this.id = id;
        this.customerName = customerName;
        this.status = OrderStatus.PENDING;
    }

    public void changeShippingAddress(Address newAddress) {
        this.shippingAddress = newAddress;
        // 触发领域事件
        addDomainEvent(new AddressChangedEvent(this.id, newAddress));
    }

    // 通过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(); }
}

2.2 值对象（Value Object）

值对象描述事物的属性或特征，它没有唯一标识符，通过其所有属性的值来定义。值对象是不可变（Immutable）的，一旦创建就不能修改；如果需要改变，则替换为新的值对象实例。

  • 无标识：两个值对象如果所有属性相同，则视为同一个对象。
  • 不可变性：任何“修改”操作都会返回一个新实例。
  • 自包含：值对象通常作为实体的属性存在，不单独管理生命周期。
  • 可共享：多个实体可以引用同一个值对象实例（由于不可变，无副作用）。
对比维度 实体（Entity） 值对象（Value Object）
标识 有唯一ID 无ID，由属性值定义
可变性 可变 不可变
相等性 ID相等 所有属性相等
生命周期 独立管理 依附于实体
典型例子 用户、订单、产品 地址、金额、颜色、坐标 
// 值对象示例：地址（不可变）
public final class Address {
    private final String street;
    private final String city;
    private final String zipCode;

    public Address(String street, String city, String zipCode) {
        this.street = street;
        this.city = city;
        this.zipCode = zipCode;
    }

    // 不提供setter方法
    public String getStreet() { return street; }
    public String getCity() { return city; }
    public String getZipCode() { return zipCode; }

    // 通过所有属性比较
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Address address = (Address) o;
        return street.equals(address.street) &&
               city.equals(address.city) &&
               zipCode.equals(address.zipCode);
    }

    @Override
    public int hashCode() {
        return Objects.hash(street, city, zipCode);
    }
}

2.3 聚合（Aggregate）

聚合是DDD中最重要的一致性边界。它将一组相关的实体和值对象封装在一起，通过一个聚合根（Aggregate Root）对外暴露操作。外部只能通过聚合根来访问聚合内的对象，从而保证数据的一致性和业务规则的完整性。

  • 聚合根：聚合中唯一的实体，拥有全局标识，是外部访问的唯一入口。
  • 一致性边界：聚合内的所有对象在同一个事务中保持最终一致性。
  • 引用规则：聚合之间通过聚合根ID引用，不直接持有内部对象的引用。
  • 原子性：一个聚合对应一个工作单元（Unit of Work），一次事务只修改一个聚合。
K8s映射关系：在微服务架构中，一个聚合通常对应一个K8s Service或一个Deployment。聚合边界决定了服务的拆分粒度——高内聚的聚合内部不应被拆分为多个独立服务。 
// 聚合根：订单聚合
public class OrderAggregate {
    private Order order;           // 聚合根实体
    private List<OrderItem> items; // 聚合内的实体
    private Payment payment;       // 聚合内的值对象

    // 外部只能通过聚合根操作
    public void addItem(ProductId productId, Money price, int quantity) {
        // 业务规则：检查库存、价格一致性
        OrderItem item = new OrderItem(productId, price, quantity);
        items.add(item);
        // 重新计算总价
        recalculateTotal();
    }

    public void submit() {
        // 验证订单完整性
        if (items.isEmpty()) {
            throw new IllegalStateException("订单不能为空");
        }
        order.changeStatus(OrderStatus.SUBMITTED);
        // 发布领域事件
        addDomainEvent(new OrderSubmittedEvent(order.getId()));
    }

    // 不允许直接返回内部集合，防止外部修改
    public List<OrderItem> getItems() {
        return Collections.unmodifiableList(items);
    }
}
聚合（Aggregate）结构示意图 聚合边界（事务一致性） 聚合根：Order（实体） ID: OrderId | 状态: Status OrderItem（实体） ProductId | Quantity | Price Address（值对象） Street | City | ZipCode 外部服务（通过ID引用） 引用OrderId 外部只能访问聚合根

2.4 领域事件（Domain Event）

领域事件用于记录领域中发生的重要业务事件，它是实现最终一致性和事件驱动架构的关键。当一个聚合内的状态发生变化时，会发布一个领域事件，其他聚合或限界上下文可以订阅并做出响应。

  • 业务含义：事件名称必须使用业务语言（如 OrderSubmitted、PaymentReceived）。
  • 不可变性：事件一旦发布，其数据不可更改。
  • 时间戳：每个事件记录发生的时间。
  • 解耦：发布者不关心谁订阅了事件，实现松耦合。
事件名称 触发场景 包含数据 典型订阅者
OrderSubmitted 用户提交订单 OrderId, CustomerId, TotalAmount 库存服务、支付服务、通知服务
PaymentCompleted 支付成功 OrderId, PaymentId, Amount 订单服务（更新状态）、物流服务
InventoryReserved 库存锁定成功 OrderId, ProductId, Quantity 订单服务（确认可发货） 
// 领域事件基类
public abstract class DomainEvent {
    private final Instant occurredOn;
    private final UUID eventId;

    protected DomainEvent() {
        this.occurredOn = Instant.now();
        this.eventId = UUID.randomUUID();
    }

    public Instant getOccurredOn() { return occurredOn; }
    public UUID getEventId() { return eventId; }
}

// 具体领域事件
public class OrderSubmittedEvent extends DomainEvent {
    private final OrderId orderId;
    private final Money totalAmount;

    public OrderSubmittedEvent(OrderId orderId, Money totalAmount) {
        super();
        this.orderId = orderId;
        this.totalAmount = totalAmount;
    }

    public OrderId getOrderId() { return orderId; }
    public Money getTotalAmount() { return totalAmount; }
}

// 在聚合根中发布事件
public class OrderAggregate {
    private List<DomainEvent> domainEvents = new ArrayList<>();

    public void submit() {
        // ... 业务逻辑
        addDomainEvent(new OrderSubmittedEvent(this.order.getId(), this.order.getTotal()));
    }

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

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

    public void clearDomainEvents() {
        domainEvents.clear();
    }
}
领域事件驱动流程 订单聚合 （事件发布者） 领域事件总线 （消息中间件） OrderSubmittedEvent 发布 库存服务 扣减库存 支付服务 发起支付 通知服务 发送确认邮件 最终一致性 异步解耦

2.5 四大概念对比总结

概念 有无标识 可变性 生命周期 核心作用 K8s映射参考
实体 有（唯一ID） 可变 独立管理 承载业务行为与状态 Pod实例（有唯一名称）
值对象 无 不可变 依附于实体 描述属性，无副作用 ConfigMap中的配置数据
聚合 聚合根有ID 边界内一致 事务边界 保证数据一致性 一个Deployment管理的Pod组
领域事件 有（事件ID） 不可变 发布即完成 解耦、异步通信 K8s Event API / 消息队列
常见误区：
  • 不要将所有对象都设计为实体——无标识的属性应使用值对象，避免过度建模。
  • 聚合不宜过大——一个聚合应只包含强一致性的对象，跨聚合的最终一致性通过领域事件实现。
  • 领域事件不是日志——事件必须包含业务语义，而非简单的状态记录。

2.6 实战要点：从DDD到K8s服务设计

在Kubernetes环境中，DDD的战术建模直接指导微服务的拆分与部署：

  1. 聚合 = 微服务候选：一个聚合通常对应一个独立的微服务，拥有自己的数据库和API。
  2. 聚合根 = Service入口：K8s Service暴露聚合根的操作接口，内部实现封装在Pod中。
  3. 领域事件 = 异步消息：使用K8s内置的Event机制或集成消息队列（如Kafka、NATS）实现服务间通信。
  4. 值对象 = 不可变配置：将值对象映射为ConfigMap或环境变量，确保配置的不可变性。
// K8s环境中的DDD实践示例：订单服务
// 1. 定义聚合根
@RestController
@RequestMapping("/api/orders")
public class OrderController {
    private final OrderApplicationService orderService;

    @PostMapping
    public ResponseEntity<OrderResponse> submitOrder(@RequestBody SubmitOrderRequest request) {
        // 2. 调用应用服务（Application Service）
        OrderResponse response = orderService.submitOrder(request);
        // 3. 领域事件由应用服务发布到消息队列
        return ResponseEntity.ok(response);
    }
}

// 4. 领域事件订阅者（另一个微服务）
@Component
public class InventoryEventHandler {
    @KafkaListener(topics = "order-events")
    public void handleOrderSubmitted(OrderSubmittedEvent event) {
        // 5. 处理库存扣减逻辑
        inventoryService.reserveInventory(event.getOrderId(), event.getItems());
    }
}
← 上一章 📖 返回目录 下一章 →