泣血之作——初级领域设计详解，附带案例与代码

graph TD 
    A[战略设计] --> B(限界上下文)
    A --> C(上下文映射)
    D[战术设计] --> E(实体)
    D --> F(值对象)
    D --> G(聚合根)
    H[实现模式] --> I(仓储模式)
    H --> J(领域服务)

// 值对象示例 
public record Money(BigDecimal amount, Currency currency) {
    public Money {
        if (amount.compareTo(BigDecimal.ZERO) <= 0) {
            throw new IllegalArgumentException("金额必须大于0");
        }
    }
}
 
// 实体示例 
public class OrderItem {
    private final String productId;
    private final int quantity;
    private final Money price;
    
    // 构造函数与业务方法省略...
}
 
// 聚合根示例 
public class Order {
    private String orderId;
    private List<OrderItem> items;
    private OrderStatus status;
    
    public void confirmPayment() {
        if (status != OrderStatus.CREATED) {
            throw new IllegalStateException("订单状态异常");
        }
        status = OrderStatus.PAID;
    }
}

src/main/java/com/example/ddd/
├── model 
│   ├── Order.java          # 聚合根 
│   ├── OrderItem.java      # 实体 
│   └── Money.java          # 值对象 
├── service 
│   └── OrderService.java   # 领域服务 
└── repository 
    └── InventoryRepo.java  # 仓储接口 

classDiagram 
    class Money {
        <<Value Object>>
        -BigDecimal amount 
        -Currency currency 
        +Money(BigDecimal, Currency)
        +add(Money) Money 
        +multiply(int) Money 
    }
 
    class OrderItem {
        <<Entity>>
        -String productId 
        -int quantity 
        -Money price 
        +OrderItem(String, int, Money)
        +productId() String 
        +quantity() int 
        +price() Money 
    }
 
    class Order {
        <<Aggregate Root>>
        -String orderId 
        -List<OrderItem> items 
        -OrderStatus status 
        -LocalDateTime createTime 
        +Order(String, List~OrderItem~)
        +confirmPayment() void 
        +calculateTotal() BigDecimal 
        +getDomainEvents() List~DomainEvent~
    }
 
    class OrderService {
        <<Domain Service>>
        -InventoryRepository inventoryRepo 
        +placeOrder(List~OrderItem~) Order 
    }
 
    class InventoryRepository {
        <<Repository Interface>>
        +getStock(String) int 
        +reduceStock(String, int) void 
        +addStock(String, int) void 
    }
 
    class OrderStatus {
        <<Enumeration>>
        CREATED 
        PAID 
        COMPLETED 
        CANCELLED 
    }
 
    Order "1" *-- "*" OrderItem : contains 
    OrderItem "1" -- "1" Money : uses 
    OrderService ..> InventoryRepository : depends 
    OrderService ..> Order : creates 
    OrderStatus <.. Order : uses 

public record Money(BigDecimal amount, Currency currency) implements Serializable {
    
    public Money add(Money other) {
        if (!currency.equals(other.currency)) {
            throw new CurrencyMismatchException();
        }
        return new Money(amount.add(other.amount), currency);
    }
    
    public Money multiply(int quantity) {
        return new Money(amount.multiply(BigDecimal.valueOf(quantity)), currency);
    }
}

public class Order {
    private String orderId;
    private List<OrderItem> items;
    private OrderStatus status;
    private LocalDateTime createTime;
 
    public Order(String orderId, List<OrderItem> items) {
        this.orderId = Objects.requireNonNull(orderId);
        this.items = new ArrayList<>(Objects.requireNonNull(items));
        this.status = OrderStatus.CREATED;
        this.createTime = LocalDateTime.now();
    }
 
    public void confirmPayment() {
        if (status != OrderStatus.CREATED) {
            throw new IllegalOrderStateException();
        }
        status = OrderStatus.PAID;
    }
 
    public BigDecimal calculateTotal() {
        return items.stream()
                .map(item -> item.price().multiply(item.quantity()))
                .reduce(Money::add)
                .orElseThrow()
                .amount();
    }
}

public class OrderService {
    private final InventoryRepository inventoryRepo;
 
    public Order placeOrder(List<OrderItem> items) {
        // 库存检查 
        items.forEach(item -> {
            int available = inventoryRepo.getStock(item.productId());
            if (available < item.quantity()) {
                throw new InsufficientStockException();
            }
        });
 
        // 创建订单 
        Order newOrder = new Order(UUID.randomUUID().toString(), items);
        
        // 扣减库存 
        items.forEach(item -> 
            inventoryRepo.reduceStock(item.productId(), item.quantity()));
        
        return newOrder;
    }
}

// 在Money值对象中内嵌验证规则 
public Money(BigDecimal amount, Currency currency) {
    if (amount.compareTo(BigDecimal.ZERO) <= 0) {
        throw new IllegalArgumentException("金额必须大于0");
    }
    this.amount = amount.setScale(2, RoundingMode.HALF_UP);
    this.currency = currency;
}

sequenceDiagram 
    participant Client 
    participant OrderService 
    participant InventoryRepo 
    participant Order 
    
    Client->>OrderService: placeOrder(items)
    OrderService->>InventoryRepo: getStock(productId)
    InventoryRepo-->>OrderService: stock 
    OrderService->>Order: new()
    OrderService->>InventoryRepo: reduceStock()
    OrderService-->>Client: return Order 

public class Application {
    public static void main(String[] args) {
        // 初始化仓储 
        InventoryRepository repo = new MemoryInventoryRepo();
        repo.addStock("P1001", 10);
        
        // 创建订单项 
        List<OrderItem> items = List.of(
            new OrderItem("P1001", 2, new Money(new BigDecimal("99.99"), Currency.USD))
        );
        
        // 执行下单 
        OrderService service = new OrderService(repo);
        Order order = service.placeOrder(items);
        
        System.out.println("订单创建成功：" + order);
        System.out.println("当前库存：" + repo.getStock("P1001"));
    }
}
 
// 输出结果：
// 订单创建成功：Order[total=199.98 USD]
// 当前库存：8 

// 改进示例：领域事件发布 
public class Order {
    // ...
    private List<DomainEvent> domainEvents = new ArrayList<>();
    
    public void confirmPayment() {
        // ...原有逻辑...
        domainEvents.add(new OrderPaidEvent(this.orderId));
    }
    
    public List<DomainEvent> getDomainEvents() {
        return Collections.unmodifiableList(domainEvents);
    }
}