+---------------------+
|   用戶接口層（UI Layer）     |  ← HTTP、Web、RPC 接口
+---------------------+
|   應(yīng)用層（Application Layer） |  ← 用例協(xié)調(diào)、事務(wù)控制
+---------------------+
|   領(lǐng)域?qū)樱―omain Layer）     |  ← 核心業(yè)務(wù)邏輯、實體、聚合、領(lǐng)域服務(wù)
+---------------------+
|   基礎(chǔ)設(shè)施層（Infrastructure Layer）| ← 數(shù)據(jù)庫、消息、外部服務(wù)調(diào)用
+---------------------+

// 值對象：金額
public class Money {
    private BigDecimal amount;
    private String currency;
 
    public Money(BigDecimal amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }
 
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) throw new IllegalArgumentException();
        return new Money(this.amount.add(other.amount), currency);
    }
}
 
// 實體：訂單項
public class OrderItem {
    private Long id;
    private String productName;
    private Money price;
    private int quantity;
}
 
// 聚合根：訂單
public class Order {
    private Long id;
    private List<OrderItem> items = new ArrayList<>();
    private Money total;
    private String status;
 
    public void addItem(OrderItem item) {
        this.items.add(item);
        this.total = this.total.add(item.getPrice().multiply(item.getQuantity()));
    }
 
    public void confirm() {
        if (this.status.equals("CREATED")) {
            this.status = "CONFIRMED";
            // 發(fā)布領(lǐng)域事件
            DomainEventPublisher.publish(new OrderConfirmedEvent(this.id));
        }
    }
}
 
// 領(lǐng)域服務(wù)
@Service
public class OrderService {
    public void cancelOrder(Order order) {
        // 復(fù)雜業(yè)務(wù)邏輯
        if (order.isCancelable()) {
            order.setStatus("CANCELLED");
            orderRepository.save(order);
        }
    }
}

// 傳統(tǒng)貧血模型 vs DDD充血模型

// ? 貧血模型（不推薦）
public class Order {
    private Long id;
    private BigDecimal amount;
    // 只有g(shù)etter/setter
}

public class OrderService {
    public void calculateDiscount(Order order) {
        // 業(yè)務(wù)邏輯在Service中
    }
}

// ? DDD充血模型（推薦）
public class Order {
    private Long id;
    private BigDecimal amount;
    private List<OrderItem> items;
    
    // 業(yè)務(wù)邏輯在領(lǐng)域?qū)ο笾?
    public BigDecimal calculateDiscount() {
        // 折扣計算邏輯
        return this.amount.multiply(getDiscountRate());
    }
    
    private BigDecimal getDiscountRate() {
        // 領(lǐng)域規(guī)則
        if (amount.compareTo(new BigDecimal("1000")) > 0) {
            return new BigDecimal("0.9");
        }
        return BigDecimal.ONE;
    }
}

// 典型DDD分層結(jié)構(gòu)
├── application/    // 應(yīng)用層 - 用例協(xié)調(diào)
├── domain/         // 領(lǐng)域?qū)?- 業(yè)務(wù)核心
├── infrastructure/ // 基礎(chǔ)設(shè)施層 - 技術(shù)實現(xiàn)
└── interfaces/     // 接口層 - 對外暴露

public class Order implements Entity<Order> {
    private OrderId id;  // 值對象作為標(biāo)識
    private Money totalAmount;
    private OrderStatus status;
    
    // 通過標(biāo)識判斷相等性
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Order order = (Order) obj;
        return id.equals(order.id);
    }
    
    // 業(yè)務(wù)方法
    public void cancel() {
        if (!status.canCancel()) {
            throw new IllegalStateException("訂單無法取消");
        }
        this.status = OrderStatus.CANCELLED;
    }
}

public class Money implements ValueObject {
    private final BigDecimal amount;
    private final Currency currency;
    
    public Money(BigDecimal amount, Currency currency) {
        this.amount = amount;
        this.currency = currency;
    }
    
    // 值對象基于所有屬性判斷相等性
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Money money = (Money) obj;
        return amount.compareTo(money.amount) == 0 && 
               currency.equals(money.currency);
    }
    
    // 不可變操作
    public Money add(Money other) {
        if (!currency.equals(other.currency)) {
            throw new IllegalArgumentException("貨幣類型不匹配");
        }
        return new Money(amount.add(other.amount), currency);
    }
}

public class Order implements AggregateRoot {
    private OrderId id;
    private List<OrderItem> items;  // 內(nèi)部實體
    private CustomerId customerId;
    
    // 聚合根負(fù)責(zé)維護(hù)完整性
    public void addItem(Product product, int quantity) {
        if (quantity <= 0) {
            throw new IllegalArgumentException("數(shù)量必須大于0");
        }
        
        OrderItem newItem = new OrderItem(product.getId(), quantity, product.getPrice());
        items.add(newItem);
        recalculateTotal();
    }
    
    // 外部只能通過聚合根訪問內(nèi)部對象
    public List<OrderItem> getItems() {
        return Collections.unmodifiableList(items);
    }
}

public class OrderCalculationService {
    
    // 處理不適合放在實體中的跨聚合業(yè)務(wù)邏輯
    public Discount calculateBestDiscount(Order order, Customer customer, List<Promotion> promotions) {
        // 復(fù)雜的折扣計算邏輯
        return promotions.stream()
            .filter(p -> p.isApplicable(order, customer))
            .map(p -> p.calculateDiscount(order))
            .max(Comparator.comparing(Discount::getAmount))
            .orElse(Discount.NONE);
    }
}

// 領(lǐng)域?qū)佣x接口
public interface OrderRepository {
    Order findById(OrderId id);
    void save(Order order);
    List<Order> findByCustomerId(CustomerId customerId);
}

// 基礎(chǔ)設(shè)施層實現(xiàn)
@Repository
public class OrderRepositoryImpl implements OrderRepository {
    @Autowired
    private OrderJpaRepository jpaRepository;
    
    @Override
    public Order findById(OrderId id) {
        OrderEntity entity = jpaRepository.findById(id.getValue())
            .orElseThrow(() -> new OrderNotFoundException(id));
        return orderMapper.toDomain(entity);
    }
}

com.example.ordermanagement
├── application
│   ├── command
│   ├── query
│   └── service
├── domain
│   ├── model
│   ├── service
│   ├── repository
│   └── exception
├── infrastructure
│   ├── persistence
│   ├── external
│   └── config
└── interfaces
    ├── rest
    ├── dto
    └── mapper

// 自定義注解明確DDD角色
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DomainEntity {
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DomainService {
}

@DomainEntity
public class Order {
    // 領(lǐng)域?qū)嶓w
}

@DomainService  
public class OrderValidationService {
    // 領(lǐng)域服務(wù)
}