// 抽象實體基類
public abstract class Entity<ID> {
    protected ID id;
    
    protected Entity(ID id) {
        this.id = Objects.requireNonNull(id, "ID cannot be null");
    }
    
    public ID getId() {
        return id;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Entity<?> entity = (Entity<?>) obj;
        return Objects.equals(id, entity.id);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

// 具體實體實作
@Entity
@Table(name = "customers")
public class Customer extends Entity<CustomerId> {
    
    @Column(name = "name")
    private String name;
    
    @Embedded
    private Email email;
    
    @Embedded
    private Address address;
    
    @Column(name = "created_at")
    private LocalDateTime createdAt;
    
    // 建構子
    public Customer(CustomerId customerId, String name, Email email) {
        super(customerId);
        this.name = validateName(name);
        this.email = Objects.requireNonNull(email);
        this.createdAt = LocalDateTime.now();
    }
    
    // 業務方法
    public void changeEmail(Email newEmail) {
        // 業務規則：email 變更需要驗證
        if (newEmail.equals(this.email)) {
            throw new IllegalArgumentException("新 email 不能與現有相同");
        }
        this.email = newEmail;
    }
    
    public void updateProfile(String newName, Address newAddress) {
        this.name = validateName(newName);
        this.address = newAddress;
    }
    
    private String validateName(String name) {
        if (name == null || name.trim().isEmpty()) {
            throw new IllegalArgumentException("姓名不能為空");
        }
        if (name.length() > 100) {
            throw new IllegalArgumentException("姓名長度不能超過100字元");
        }
        return name.trim();
    }
    
    // Getters
    public String getName() { return name; }
    public Email getEmail() { return email; }
    public Address getAddress() { return address; }
    public LocalDateTime getCreatedAt() { return createdAt; }
}

// Email 值對象
public class Email {
    private final String value;
    
    public Email(String email) {
        this.value = validateEmail(email);
    }
    
    private String validateEmail(String email) {
        if (email == null || email.trim().isEmpty()) {
            throw new IllegalArgumentException("Email 不能為空");
        }
        
        String emailRegex = "^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$";
        if (!email.matches(emailRegex)) {
            throw new IllegalArgumentException("Email 格式不正確");
        }
        
        return email.toLowerCase().trim();
    }
    
    public String getValue() {
        return value;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Email email = (Email) obj;
        return Objects.equals(value, email.value);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
    
    @Override
    public String toString() {
        return value;
    }
}

// Money 值對象
public class Money {
    private final BigDecimal amount;
    private final Currency currency;
    
    public Money(BigDecimal amount, Currency currency) {
        this.amount = validateAmount(amount);
        this.currency = Objects.requireNonNull(currency, "Currency cannot be null");
    }
    
    public Money(String amount, String currencyCode) {
        this(new BigDecimal(amount), Currency.getInstance(currencyCode));
    }
    
    private BigDecimal validateAmount(BigDecimal amount) {
        if (amount == null) {
            throw new IllegalArgumentException("金額不能為空");
        }
        if (amount.scale() > 2) {
            throw new IllegalArgumentException("金額小數點不能超過2位");
        }
        return amount;
    }
    
    // 業務方法
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("不同幣別無法直接相加");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }
    
    public Money multiply(BigDecimal multiplier) {
        return new Money(this.amount.multiply(multiplier), this.currency);
    }
    
    public boolean isGreaterThan(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("不同幣別無法比較");
        }
        return this.amount.compareTo(other.amount) > 0;
    }
    
    public boolean isZero() {
        return amount.compareTo(BigDecimal.ZERO) == 0;
    }
    
    // Getters
    public BigDecimal getAmount() { return amount; }
    public Currency getCurrency() { return 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 Objects.equals(amount, money.amount) && 
               Objects.equals(currency, money.currency);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(amount, currency);
    }
    
    @Override
    public String toString() {
        return String.format("%s %s", currency.getCurrencyCode(), amount);
    }
}

// Address 值對象
public class Address {
    private final String street;
    private final String city;
    private final String state;
    private final String postalCode;
    private final String country;
    
    public Address(String street, String city, String state, 
                   String postalCode, String country) {
        this.street = validateNotEmpty(street, "街道地址");
        this.city = validateNotEmpty(city, "城市");
        this.state = state; // 可選
        this.postalCode = validatePostalCode(postalCode);
        this.country = validateNotEmpty(country, "國家");
    }
    
    private String validateNotEmpty(String value, String fieldName) {
        if (value == null || value.trim().isEmpty()) {
            throw new IllegalArgumentException(fieldName + "不能為空");
        }
        return value.trim();
    }
    
    private String validatePostalCode(String postalCode) {
        if (postalCode == null || postalCode.trim().isEmpty()) {
            throw new IllegalArgumentException("郵遞區號不能為空");
        }
        // 簡單驗證，實際應根據國家制定規則
        if (!postalCode.matches("\\d{3,10}")) {
            throw new IllegalArgumentException("郵遞區號格式不正確");
        }
        return postalCode.trim();
    }
    
    public String getFullAddress() {
        return String.join(", ", street, city, 
                          state != null ? state : "", 
                          postalCode, country);
    }
    
    // Getters
    public String getStreet() { return street; }
    public String getCity() { return city; }
    public String getState() { return state; }
    public String getPostalCode() { return postalCode; }
    public String getCountry() { return country; }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Address address = (Address) obj;
        return Objects.equals(street, address.street) &&
               Objects.equals(city, address.city) &&
               Objects.equals(state, address.state) &&
               Objects.equals(postalCode, address.postalCode) &&
               Objects.equals(country, address.country);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(street, city, state, postalCode, country);
    }
}

// 訂單聚合根
@Entity
@Table(name = "orders")
public class Order extends Entity<OrderId> {
    
    @Column(name = "customer_id")
    private CustomerId customerId;
    
    @Enumerated(EnumType.STRING)
    @Column(name = "status")
    private OrderStatus status;
    
    @ElementCollection
    @CollectionTable(name = "order_items", joinColumns = @JoinColumn(name = "order_id"))
    private List<OrderItem> items;
    
    @Embedded
    private ShippingInfo shippingInfo;
    
    @Embedded
    private Money totalAmount;
    
    @Column(name = "created_at")
    private LocalDateTime createdAt;
    
    // 建構子
    public Order(OrderId orderId, CustomerId customerId, ShippingInfo shippingInfo) {
        super(orderId);
        this.customerId = Objects.requireNonNull(customerId);
        this.status = OrderStatus.PENDING;
        this.items = new ArrayList<>();
        this.shippingInfo = Objects.requireNonNull(shippingInfo);
        this.totalAmount = Money.ZERO;
        this.createdAt = LocalDateTime.now();
    }
    
    // 業務方法 - 添加商品
    public void addItem(ProductId productId, int quantity, Money unitPrice) {
        if (status != OrderStatus.PENDING) {
            throw new IllegalStateException("只能在訂單待處理狀態下添加商品");
        }
        
        if (quantity <= 0) {
            throw new IllegalArgumentException("商品數量必須大於0");
        }
        
        // 檢查是否已存在相同商品
        Optional<OrderItem> existingItem = items.stream()
            .filter(item -> item.getProductId().equals(productId))
            .findFirst();
            
        if (existingItem.isPresent()) {
            existingItem.get().changeQuantity(
                existingItem.get().getQuantity() + quantity);
        } else {
            items.add(new OrderItem(productId, quantity, unitPrice));
        }
        
        recalculateTotal();
    }
    
    // 業務方法 - 移除商品
    public void removeItem(ProductId productId) {
        if (status != OrderStatus.PENDING) {
            throw new IllegalStateException("只能在訂單待處理狀態下移除商品");
        }
        
        items.removeIf(item -> item.getProductId().equals(productId));
        recalculateTotal();
    }
    
    // 業務方法 - 確認訂單
    public void confirm() {
        if (status != OrderStatus.PENDING) {
            throw new IllegalStateException("只能確認待處理的訂單");
        }
        
        if (items.isEmpty()) {
            throw new IllegalStateException("空訂單無法確認");
        }
        
        this.status = OrderStatus.CONFIRMED;
    }
    
    // 業務方法 - 取消訂單
    public void cancel() {
        if (status == OrderStatus.SHIPPED || status == OrderStatus.DELIVERED) {
            throw new IllegalStateException("已出貨或已送達的訂單無法取消");
        }
        
        this.status = OrderStatus.CANCELLED;
    }
    
    // 內部方法 - 重新計算總額
    private void recalculateTotal() {
        this.totalAmount = items.stream()
            .map(OrderItem::getTotalPrice)
            .reduce(Money.ZERO, Money::add);
    }
    
    // 查詢方法
    public boolean canBeModified() {
        return status == OrderStatus.PENDING;
    }
    
    public int getTotalItems() {
        return items.stream().mapToInt(OrderItem::getQuantity).sum();
    }
    
    // Getters
    public CustomerId getCustomerId() { return customerId; }
    public OrderStatus getStatus() { return status; }
    public List<OrderItem> getItems() { return Collections.unmodifiableList(items); }
    public ShippingInfo getShippingInfo() { return shippingInfo; }
    public Money getTotalAmount() { return totalAmount; }
    public LocalDateTime getCreatedAt() { return createdAt; }
}

// 訂單項目 - 聚合內部實體
@Embeddable
public class OrderItem {
    
    @Column(name = "product_id")
    private ProductId productId;
    
    @Column(name = "quantity")
    private int quantity;
    
    @Embedded
    @AttributeOverrides({
        @AttributeOverride(name = "amount", column = @Column(name = "unit_price")),
        @AttributeOverride(name = "currency", column = @Column(name = "currency"))
    })
    private Money unitPrice;
    
    // JPA 需要
    protected OrderItem() {}
    
    public OrderItem(ProductId productId, int quantity, Money unitPrice) {
        this.productId = Objects.requireNonNull(productId);
        this.quantity = validateQuantity(quantity);
        this.unitPrice = Objects.requireNonNull(unitPrice);
    }
    
    public void changeQuantity(int newQuantity) {
        this.quantity = validateQuantity(newQuantity);
    }
    
    private int validateQuantity(int quantity) {
        if (quantity <= 0) {
            throw new IllegalArgumentException("商品數量必須大於0");
        }
        return quantity;
    }
    
    public Money getTotalPrice() {
        return unitPrice.multiply(BigDecimal.valueOf(quantity));
    }
    
    // Getters
    public ProductId getProductId() { return productId; }
    public int getQuantity() { return quantity; }
    public Money getUnitPrice() { return unitPrice; }
}

// 訂單狀態枚舉
public enum OrderStatus {
    PENDING("待處理"),
    CONFIRMED("已確認"),
    SHIPPED("已出貨"),
    DELIVERED("已送達"),
    CANCELLED("已取消");
    
    private final String description;
    
    OrderStatus(String description) {
        this.description = description;
    }
    
    public String getDescription() {
        return description;
    }
}

// Repository 介面 (位於 domain 層)
public interface OrderRepository {
    
    // 基本操作
    void save(Order order);
    Optional<Order> findById(OrderId orderId);
    void delete(Order order);
    
    // 業務查詢
    List<Order> findByCustomerId(CustomerId customerId);
    List<Order> findByStatus(OrderStatus status);
    List<Order> findByCustomerAndStatus(CustomerId customerId, OrderStatus status);
    
    // 分頁查詢
    Page<Order> findByCustomerId(CustomerId customerId, Pageable pageable);
    
    // 統計查詢
    long countByCustomerId(CustomerId customerId);
    Money calculateTotalAmountByCustomer(CustomerId customerId);
    
    // 複雜業務查詢
    List<Order> findOrdersNeedingReminder();
    List<Order> findExpiredPendingOrders(LocalDateTime expiredBefore);
}

// Repository 實作 (位於 infrastructure 層)
@Repository
@Transactional
public class JpaOrderRepository implements OrderRepository {
    
    private final OrderJpaRepository jpaRepository;
    private final EntityManager entityManager;
    
    public JpaOrderRepository(OrderJpaRepository jpaRepository, 
                             EntityManager entityManager) {
        this.jpaRepository = jpaRepository;
        this.entityManager = entityManager;
    }
    
    @Override
    public void save(Order order) {
        jpaRepository.save(order);
    }
    
    @Override
    public Optional<Order> findById(OrderId orderId) {
        return jpaRepository.findById(orderId);
    }
    
    @Override
    public void delete(Order order) {
        jpaRepository.delete(order);
    }
    
    @Override
    public List<Order> findByCustomerId(CustomerId customerId) {
        return jpaRepository.findByCustomerId(customerId);
    }
    
    @Override
    public List<Order> findByStatus(OrderStatus status) {
        return jpaRepository.findByStatus(status);
    }
    
    @Override
    public List<Order> findByCustomerAndStatus(CustomerId customerId, OrderStatus status) {
        return jpaRepository.findByCustomerIdAndStatus(customerId, status);
    }
    
    @Override
    public Page<Order> findByCustomerId(CustomerId customerId, Pageable pageable) {
        return jpaRepository.findByCustomerId(customerId, pageable);
    }
    
    @Override
    public long countByCustomerId(CustomerId customerId) {
        return jpaRepository.countByCustomerId(customerId);
    }
    
    @Override
    public Money calculateTotalAmountByCustomer(CustomerId customerId) {
        String jpql = """
            SELECT SUM(o.totalAmount.amount)
            FROM Order o 
            WHERE o.customerId = :customerId 
            AND o.status IN ('CONFIRMED', 'SHIPPED', 'DELIVERED')
            """;
            
        BigDecimal total = entityManager.createQuery(jpql, BigDecimal.class)
            .setParameter("customerId", customerId)
            .getSingleResult();
            
        return total != null ? new Money(total, "TWD") : Money.ZERO;
    }
    
    @Override
    public List<Order> findOrdersNeedingReminder() {
        String jpql = """
            SELECT o FROM Order o 
            WHERE o.status = 'PENDING' 
            AND o.createdAt < :reminderTime
            """;
            
        LocalDateTime reminderTime = LocalDateTime.now().minusHours(24);
        
        return entityManager.createQuery(jpql, Order.class)
            .setParameter("reminderTime", reminderTime)
            .getResultList();
    }
    
    @Override
    public List<Order> findExpiredPendingOrders(LocalDateTime expiredBefore) {
        return jpaRepository.findByStatusAndCreatedAtBefore(
            OrderStatus.PENDING, expiredBefore);
    }
}

// Spring Data JPA Repository
@Repository
public interface OrderJpaRepository extends JpaRepository<Order, OrderId> {
    
    List<Order> findByCustomerId(CustomerId customerId);
    Page<Order> findByCustomerId(CustomerId customerId, Pageable pageable);
    
    List<Order> findByStatus(OrderStatus status);
    List<Order> findByCustomerIdAndStatus(CustomerId customerId, OrderStatus status);
    
    long countByCustomerId(CustomerId customerId);
    
    List<Order> findByStatusAndCreatedAtBefore(OrderStatus status, LocalDateTime createdBefore);
    
    @Query("SELECT o FROM Order o WHERE o.status = :status AND o.createdAt >= :startDate")
    List<Order> findByStatusAndDateRange(@Param("status") OrderStatus status, 
                                       @Param("startDate") LocalDateTime startDate);
}

// 領域服務介面
public interface OrderPricingService {
    Money calculateOrderTotal(Order order, Customer customer);
    Money calculateShippingCost(Order order, ShippingMethod method);
    Money applyDiscount(Order order, Customer customer);
}

// 領域服務實作
@Service
public class OrderPricingServiceImpl implements OrderPricingService {
    
    private final DiscountPolicy discountPolicy;
    private final ShippingCalculator shippingCalculator;
    
    public OrderPricingServiceImpl(DiscountPolicy discountPolicy,
                                 ShippingCalculator shippingCalculator) {
        this.discountPolicy = discountPolicy;
        this.shippingCalculator = shippingCalculator;
    }
    
    @Override
    public Money calculateOrderTotal(Order order, Customer customer) {
        Money subtotal = order.getTotalAmount();
        Money discount = applyDiscount(order, customer);
        Money shipping = calculateShippingCost(order, 
            order.getShippingInfo().getMethod());
        
        return subtotal.subtract(discount).add(shipping);
    }
    
    @Override
    public Money calculateShippingCost(Order order, ShippingMethod method) {
        return shippingCalculator.calculate(
            order.getTotalWeight(),
            order.getShippingInfo().getAddress(),
            method
        );
    }
    
    @Override
    public Money applyDiscount(Order order, Customer customer) {
        return discountPolicy.calculateDiscount(order, customer);
    }
}

// 折扣政策 (Strategy Pattern)
public interface DiscountPolicy {
    Money calculateDiscount(Order order, Customer customer);
}

@Component
public class VipDiscountPolicy implements DiscountPolicy {
    
    @Override
    public Money calculateDiscount(Order order, Customer customer) {
        if (customer.isVip()) {
            // VIP 顧客享有 10% 折扣
            Money discount = order.getTotalAmount().multiply(new BigDecimal("0.1"));
            // 折扣上限 1000 元
            Money maxDiscount = new Money("1000", "TWD");
            return discount.isGreaterThan(maxDiscount) ? maxDiscount : discount;
        }
        
        // 一般顧客滿額折扣
        Money threshold = new Money("2000", "TWD");
        if (order.getTotalAmount().isGreaterThan(threshold)) {
            return new Money("100", "TWD");
        }
        
        return Money.ZERO;
    }
}

// 商品目錄上下文中的 Product
@Entity
@Table(name = "products")
public class Product extends Entity<ProductId> {
    private String name;
    private String description;
    private Money price;
    private CategoryId categoryId;
    private InventoryLevel inventory;
    
    // 商品目錄相關的業務邏輯
    public void updatePrice(Money newPrice) { /* ... */ }
    public void adjustInventory(int quantity) { /* ... */ }
}

// 訂單管理上下文中的 Product (不同的模型)
@Entity
@Table(name = "order_products")
public class OrderProduct extends Entity<ProductId> {
    private String name;           // 訂單時的商品名稱
    private Money priceAtOrder;    // 訂單時的價格
    private String imageUrl;       // 展示用圖片
    
    // 訂單相關的業務邏輯
    public OrderItem createOrderItem(int quantity) { /* ... */ }
}

// 外部系統的 DTO
public class ExternalPaymentResponse {
    public String payment_id;
    public String status_code;
    public String error_message;
    // 外部系統的欄位命名和結構
}

// 防腐層 - 轉換外部模型到內部模型
@Component
public class PaymentAntiCorruptionLayer {
    
    public PaymentResult translatePaymentResponse(ExternalPaymentResponse external) {
        PaymentStatus status = mapStatusCode(external.status_code);
        
        if (status == PaymentStatus.FAILED) {
            return PaymentResult.failed(
                new PaymentId(external.payment_id),
                external.error_message
            );
        }
        
        return PaymentResult.successful(
            new PaymentId(external.payment_id)
        );
    }
    
    private PaymentStatus mapStatusCode(String statusCode) {
        return switch (statusCode) {
            case "00" -> PaymentStatus.SUCCESS;
            case "01" -> PaymentStatus.PENDING;
            default -> PaymentStatus.FAILED;
        };
    }
}

// 內部領域模型
public class PaymentResult {
    private final PaymentId paymentId;
    private final PaymentStatus status;
    private final String errorMessage;
    
    public static PaymentResult successful(PaymentId paymentId) {
        return new PaymentResult(paymentId, PaymentStatus.SUCCESS, null);
    }
    
    public static PaymentResult failed(PaymentId paymentId, String errorMessage) {
        return new PaymentResult(paymentId, PaymentStatus.FAILED, errorMessage);
    }
    
    // constructor, getters...
}

// 對外提供的統一 API
@RestController
@RequestMapping("/api/orders")
public class OrderOpenHostController {
    
    private final OrderApplicationService orderService;
    private final OrderDtoAssembler assembler;
    
    @PostMapping
    public ResponseEntity<OrderDto> createOrder(@RequestBody CreateOrderRequest request) {
        CreateOrderCommand command = new CreateOrderCommand(
            new CustomerId(request.getCustomerId()),
            request.getShippingAddress(),
            request.getItems()
        );
        
        OrderId orderId = orderService.createOrder(command);
        Order order = orderService.getOrder(orderId);
        
        return ResponseEntity.ok(assembler.toDto(order));
    }
    
    @GetMapping("/{orderId}")
    public ResponseEntity<OrderDto> getOrder(@PathVariable String orderId) {
        Order order = orderService.getOrder(new OrderId(orderId));
        return ResponseEntity.ok(assembler.toDto(order));
    }
}

// 統一的對外 DTO
public class OrderDto {
    private String orderId;
    private String customerId;
    private String status;
    private List<OrderItemDto> items;
    private BigDecimal totalAmount;
    private String currency;
    private LocalDateTime createdAt;
    
    // getters, setters...
}

// 好的範例 - 使用業務術語
public class Order {
    public void ship(ShippingAddress address) {
        if (!canBeShipped()) {
            throw new OrderCannotBeShippedException("訂單狀態不允許出貨");
        }
        // 實作出貨邏輯
    }
    
    public boolean canBeShipped() {
        return status == OrderStatus.CONFIRMED && 
               allItemsInStock();
    }
    
    public void cancel(CancellationReason reason) {
        if (!canBeCancelled()) {
            throw new OrderCannotBeCancelledException("訂單無法取消");
        }
        // 實作取消邏輯
    }
}

// 不好的範例 - 使用技術術語
public class Order {
    public void updateStatus(int statusCode) {
        this.statusCode = statusCode;
    }
    
    public void processData() {
        // 不清楚的方法名
    }
}

// 從 Event Storming 結果設計的聚合
public class Customer extends AggregateRoot<CustomerId> {
    
    // 處理註冊命令，產生領域事件
    public static Customer register(CustomerId customerId, 
                                  String name, 
                                  Email email) {
        Customer customer = new Customer(customerId, name, email);
        customer.addDomainEvent(new CustomerRegistered(customerId, name, email));
        return customer;
    }
}

public class ShoppingCart extends AggregateRoot<CartId> {
    
    public void addProduct(ProductId productId, int quantity) {
        // 業務邏輯驗證
        OrderItem item = new OrderItem(productId, quantity);
        items.add(item);
        
        addDomainEvent(new ProductAddedToCart(getId(), productId, quantity));
    }
}

// 領域事件基類
public abstract class DomainEvent {
    private final String eventId;
    private final LocalDateTime occurredOn;
    
    protected DomainEvent() {
        this.eventId = UUID.randomUUID().toString();
        this.occurredOn = LocalDateTime.now();
    }
    
    public String getEventId() { return eventId; }
    public LocalDateTime getOccurredOn() { return occurredOn; }
}

// 具體領域事件
public class OrderPlaced extends DomainEvent {
    private final OrderId orderId;
    private final CustomerId customerId;
    private final Money totalAmount;
    private final List<OrderItemData> items;
    
    public OrderPlaced(OrderId orderId, 
                      CustomerId customerId, 
                      Money totalAmount,
                      List<OrderItem> items) {
        super();
        this.orderId = orderId;
        this.customerId = customerId;
        this.totalAmount = totalAmount;
        this.items = items.stream()
            .map(OrderItemData::new)
            .collect(Collectors.toList());
    }
    
    // Getters...
    public OrderId getOrderId() { return orderId; }
    public CustomerId getCustomerId() { return customerId; }
    public Money getTotalAmount() { return totalAmount; }
    public List<OrderItemData> getItems() { return items; }
}

// 聚合根基類
public abstract class AggregateRoot<ID> extends Entity<ID> {
    private final List<DomainEvent> domainEvents = new ArrayList<>();
    
    protected AggregateRoot(ID id) {
        super(id);
    }
    
    protected void addDomainEvent(DomainEvent event) {
        domainEvents.add(event);
    }
    
    public List<DomainEvent> getDomainEvents() {
        return Collections.unmodifiableList(domainEvents);
    }
    
    public void clearDomainEvents() {
        domainEvents.clear();
    }
}

// 修改後的 Order 聚合
public class Order extends AggregateRoot<OrderId> {
    
    public static Order createOrder(OrderId orderId, 
                                  CustomerId customerId,
                                  ShippingInfo shippingInfo) {
        Order order = new Order(orderId, customerId, shippingInfo);
        
        // 發布領域事件
        order.addDomainEvent(new OrderCreated(orderId, customerId));
        
        return order;
    }
    
    public void confirm() {
        if (status != OrderStatus.PENDING) {
            throw new IllegalStateException("只能確認待處理的訂單");
        }
        
        if (items.isEmpty()) {
            throw new IllegalStateException("空訂單無法確認");
        }
        
        this.status = OrderStatus.CONFIRMED;
        
        // 發布領域事件
        addDomainEvent(new OrderPlaced(getId(), customerId, totalAmount, items));
    }
    
    public void ship(TrackingNumber trackingNumber) {
        if (status != OrderStatus.CONFIRMED) {
            throw new IllegalStateException("只能出貨已確認的訂單");
        }
        
        this.status = OrderStatus.SHIPPED;
        
        // 發布領域事件
        addDomainEvent(new OrderShipped(getId(), customerId, trackingNumber));
    }
}

// 訂單工廠
@Component
public class OrderFactory {
    
    private final ProductRepository productRepository;
    private final OrderPricingService pricingService;
    
    public OrderFactory(ProductRepository productRepository,
                       OrderPricingService pricingService) {
        this.productRepository = productRepository;
        this.pricingService = pricingService;
    }
    
    public Order createOrderFromCart(CustomerId customerId,
                                   ShoppingCart cart,
                                   ShippingInfo shippingInfo) {
        
        OrderId orderId = OrderId.generate();
        Order order = new Order(orderId, customerId, shippingInfo);
        
        // 轉換購物車項目為訂單項目
        for (CartItem cartItem : cart.getItems()) {
            Product product = productRepository.findById(cartItem.getProductId())
                .orElseThrow(() -> new ProductNotFoundException(cartItem.getProductId()));
                
            // 驗證庫存
            if (!product.hasEnoughStock(cartItem.getQuantity())) {
                throw new InsufficientStockException(
                    cartItem.getProductId(), cartItem.getQuantity());
            }
            
            order.addItem(
                cartItem.getProductId(),
                cartItem.getQuantity(),
                product.getCurrentPrice()
            );
        }
        
        return order;
    }
    
    public Order recreateOrderFromHistory(OrderHistoryData historyData) {
        // 從歷史資料重建訂單，用於查詢或分析
        OrderId orderId = new OrderId(historyData.getOrderId());
        CustomerId customerId = new CustomerId(historyData.getCustomerId());
        
        Order order = new Order(orderId, customerId, historyData.getShippingInfo());
        
        for (OrderItemData itemData : historyData.getItems()) {
            order.addItem(
                new ProductId(itemData.getProductId()),
                itemData.getQuantity(),
                itemData.getUnitPrice()
            );
        }
        
        return order;
    }
}

// 規格模式基類
public interface Specification<T> {
    boolean isSatisfiedBy(T candidate);
    
    default Specification<T> and(Specification<T> other) {
        return candidate -> this.isSatisfiedBy(candidate) && other.isSatisfiedBy(candidate);
    }
    
    default Specification<T> or(Specification<T> other) {
        return candidate -> this.isSatisfiedBy(candidate) || other.isSatisfiedBy(candidate);
    }
    
    default Specification<T> not() {
        return candidate -> !this.isSatisfiedBy(candidate);
    }
}

// 具體規格實作
public class VipCustomerSpecification implements Specification<Customer> {
    
    @Override
    public boolean isSatisfiedBy(Customer customer) {
        return customer.getTotalSpending().isGreaterThan(new Money("10000", "TWD")) &&
               customer.getOrderCount() >= 5;
    }
}

public class HighValueOrderSpecification implements Specification<Order> {
    private final Money threshold;
    
    public HighValueOrderSpecification(Money threshold) {
        this.threshold = threshold;
    }
    
    @Override
    public boolean isSatisfiedBy(Order order) {
        return order.getTotalAmount().isGreaterThan(threshold);
    }
}

public class EligibleForExpressShippingSpecification implements Specification<Order> {
    
    @Override
    public boolean isSatisfiedBy(Order order) {
        return order.getTotalAmount().isGreaterThan(new Money("1000", "TWD")) &&
               order.getItems().stream().allMatch(item -> 
                   !item.getProduct().isOversized());
    }
}

// 使用規格模式的服務
@Service
public class OrderPromotionService {
    
    public boolean isEligibleForFreeShipping(Order order, Customer customer) {
        Specification<Order> freeShippingSpec = 
            new HighValueOrderSpecification(new Money("2000", "TWD"))
            .or(new VipCustomerSpecification().and(
                new HighValueOrderSpecification(new Money("1000", "TWD"))));
                
        return freeShippingSpec.isSatisfiedBy(order);
    }
    
    public List<Promotion> getApplicablePromotions(Order order, Customer customer) {
        List<Promotion> applicablePromotions = new ArrayList<>();
        
        // VIP 顾客促销
        if (new VipCustomerSpecification().isSatisfiedBy(customer)) {
            applicablePromotions.add(new VipDiscount());
        }
        
        // 高价值订单促销
        if (new HighValueOrderSpecification(new Money("5000", "TWD"))
            .isSatisfiedBy(order)) {
            applicablePromotions.add(new HighValueOrderDiscount());
        }
        
        return applicablePromotions;
    }
}

// 重構前：貧血模型 + 服務層包含所有邏輯
@Entity
public class Order {
    private Long id;
    private Long customerId;
    private String status;
    private BigDecimal amount;
    // 只有 getters 和 setters
}

@Service
public class OrderService {
    // 包含所有業務邏輯，違反 SRP
    public void createOrder(OrderRequest request) { /* 複雜邏輯 */ }
    public void calculateDiscount(Order order) { /* 複雜邏輯 */ }
    public void validateInventory(Order order) { /* 複雜邏輯 */ }
    public void processPayment(Order order) { /* 複雜邏輯 */ }
}

// 重構後：豐富的領域模型
public class Order extends AggregateRoot<OrderId> {
    private CustomerId customerId;
    private OrderStatus status;
    private List<OrderItem> items;
    private Money totalAmount;
    private PromotionCode promotionCode;
    
    public static Order createOrder(CustomerId customerId, 
                                  List<OrderItemRequest> itemRequests) {
        Order order = new Order(OrderId.generate(), customerId);
        
        for (OrderItemRequest request : itemRequests) {
            order.addItem(request.getProductId(), 
                         request.getQuantity(), 
                         request.getUnitPrice());
        }
        
        order.addDomainEvent(new OrderCreated(order.getId(), customerId));
        return order;
    }
    
    public void applyPromotion(PromotionCode code, PromotionPolicy policy) {
        if (!policy.isApplicable(this, code)) {
            throw new PromotionNotApplicableException(code);
        }
        
        this.promotionCode = code;
        recalculateTotal();
        addDomainEvent(new PromotionApplied(getId(), code));
    }
    
    public void confirm() {
        validateCanBeConfirmed();
        this.status = OrderStatus.CONFIRMED;
        addDomainEvent(new OrderConfirmed(getId(), customerId, totalAmount));
    }
}

// 訂單服務中的商品資訊查詢
@Component
public class ProductInfoService {
    private final ProductServiceClient productClient;
    
    public ProductInfo getProductInfo(ProductId productId) {
        try {
            ProductResponse response = productClient.getProduct(productId.getValue());
            return new ProductInfo(
                productId,
                response.getName(),
                new Money(response.getPrice(), response.getCurrency()),
                response.isAvailable()
            );
        } catch (FeignException ex) {
            throw new ProductServiceUnavailableException(productId, ex);
        }
    }
}

// 訂單事件發布
@EventListener
@Component
public class OrderEventPublisher {
    private final RabbitTemplate rabbitTemplate;
    
    @Async
    public void on(OrderConfirmed event) {
        OrderConfirmedEvent externalEvent = new OrderConfirmedEvent(
            event.getOrderId().getValue(),
            event.getCustomerId().getValue(),
            event.getTotalAmount().getAmount(),
            event.getOrderItems().stream()
                .map(item -> new OrderItemEvent(
                    item.getProductId().getValue(),
                    item.getQuantity()
                ))
                .collect(Collectors.toList())
        );
        
        rabbitTemplate.convertAndSend(
            "order.events", 
            "order.confirmed", 
            externalEvent
        );
    }
}

// 庫存服務中的事件處理
@RabbitListener(queues = "inventory.order.events")
@Component
public class InventoryEventHandler {
    private final InventoryApplicationService inventoryService;
    
    public void handle(OrderConfirmedEvent event) {
        ReserveStockCommand command = new ReserveStockCommand(
            new OrderId(event.getOrderId()),
            event.getOrderItems().stream()
                .map(item -> new StockReservation(
                    new ProductId(item.getProductId()),
                    item.getQuantity()
                ))
                .collect(Collectors.toList())
        );
        
        inventoryService.reserveStock(command);
    }
}

// Anti-Corruption Layer 處理遺留系統整合
@Component
public class LegacyOrderAdapter {
    private final LegacyOrderService legacyService;
    private final OrderTranslator translator;
    
    public Order findOrderInLegacySystem(OrderId orderId) {
        LegacyOrderData legacyData = legacyService.getOrder(orderId.getValue());
        
        if (legacyData == null) {
            return null;
        }
        
        return translator.translateToNewModel(legacyData);
    }
    
    public void syncOrderToLegacySystem(Order order) {
        LegacyOrderData legacyData = translator.translateToLegacyModel(order);
        legacyService.updateOrder(legacyData);
    }
}

// 資料遷移策略
@Component
public class OrderMigrationService {
    private final LegacyOrderAdapter adapter;
    private final OrderRepository orderRepository;
    
    @Scheduled(fixedRate = 3600000) // 每小時執行
    public void migrateOrders() {
        List<String> pendingOrderIds = getLegacyOrderIds();
        
        for (String orderId : pendingOrderIds) {
            try {
                Order order = adapter.findOrderInLegacySystem(new OrderId(orderId));
                if (order != null) {
                    orderRepository.save(order);
                    markAsInNewSystem(orderId);
                }
            } catch (Exception ex) {
                logger.error("訂單遷移失敗: {}", orderId, ex);
            }
        }
    }
}

// 領域知識文件化
/**
 * 訂單聚合
 * 
 * 業務規則：
 * 1. 訂單一旦確認就不能修改商品項目
 * 2. 只有待處理狀態的訂單可以取消
 * 3. 訂單總額必須等於所有項目金額總和
 * 4. VIP 客戶享有特殊取消政策
 * 
 * 不變條件：
 * - 訂單必須至少包含一個商品項目
 * - 商品數量必須大於 0
 * - 總金額不能為負數
 * 
 * 領域事件：
 * - OrderCreated: 訂單建立時
 * - OrderConfirmed: 訂單確認時  
 * - OrderCancelled: 訂單取消時
 * - OrderShipped: 訂單出貨時
 */
public class Order extends AggregateRoot<OrderId> {
    // 實作...
}

// 命令端：專注於寫入操作
@Service
@Transactional
public class OrderCommandService {
    public OrderId createOrder(CreateOrderCommand command) {
        // 純粹的寫入邏輯，不關心查詢效能
        Order order = Order.createOrder(command.getCustomerId(), command.getItems());
        orderRepository.save(order);
        publishDomainEvents(order);
        return order.getId();
    }
}

// 查詢端：最佳化的讀取模型
@Entity
@Table(name = "order_summary_view")
public class OrderSummaryView {
    @Id
    private String orderId;
    private String customerName;
    private String customerEmail;
    private BigDecimal totalAmount;
    private String status;
    private Integer itemCount;
    private String productSummary; // 逗號分隔的商品名稱
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
    
    // 查詢最佳化的欄位
    @Column(name = "search_keywords")
    private String searchKeywords; // 包含客戶名稱、商品名稱等
    
    @Column(name = "status_order")
    private Integer statusOrder; // 用於狀態排序
}

// 查詢服務
@Service
@Transactional(readOnly = true)
public class OrderQueryService {
    
    public Page<OrderSummaryDto> searchOrders(OrderSearchCriteria criteria, 
                                            Pageable pageable) {
        // 使用最佳化的查詢模型
        Specification<OrderSummaryView> spec = OrderSpecifications.buildSpec(criteria);
        Page<OrderSummaryView> views = orderSummaryRepository.findAll(spec, pageable);
        
        return views.map(this::toDto);
    }
    
    public OrderAnalyticsDto getOrderAnalytics(LocalDate startDate, LocalDate endDate) {
        // 使用原生 SQL 進行複雜統計查詢
        return orderSummaryRepository.getAnalytics(startDate, endDate);
    }
}

// 領域事件監控
@Component
public class OrderMetricsCollector {
    private final MeterRegistry meterRegistry;
    private final Counter orderCreatedCounter;
    private final Timer orderProcessingTimer;
    
    public OrderMetricsCollector(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.orderCreatedCounter = Counter.builder("orders.created")
            .description("訂單建立數量")
            .register(meterRegistry);
        this.orderProcessingTimer = Timer.builder("orders.processing.time")
            .description("訂單處理時間")
            .register(meterRegistry);
    }
    
    @EventListener
    public void on(OrderCreated event) {
        orderCreatedCounter.increment(
            Tags.of("customer_type", determineCustomerType(event.getCustomerId()))
        );
    }
    
    @EventListener
    public void on(OrderConfirmed event) {
        Duration processingTime = Duration.between(
            event.getOrderCreatedAt(), 
            event.getOccurredOn()
        );
        orderProcessingTimer.record(processingTime);
    }
}

// 業務健康檢查
@Component
public class OrderHealthIndicator implements HealthIndicator {
    private final OrderRepository orderRepository;
    
    @Override
    public Health health() {
        try {
            long pendingOrdersCount = orderRepository.countByStatusAndCreatedAtBefore(
                OrderStatus.PENDING, 
                LocalDateTime.now().minusHours(24)
            );
            
            if (pendingOrdersCount > 100) {
                return Health.down()
                    .withDetail("pending_orders", pendingOrdersCount)
                    .withDetail("reason", "Too many long-pending orders")
                    .build();
            }
            
            return Health.up()
                .withDetail("pending_orders", pendingOrdersCount)
                .build();
                
        } catch (Exception ex) {
            return Health.down(ex).build();
        }
    }
}

src/main/java/com/company/ecommerce/
├── application/              # 應用層
│   ├── service/             # 應用服務
│   ├── dto/                 # 資料傳輸對象
│   └── command/             # 命令對象
├── domain/                  # 領域層
│   ├── model/               # 領域模型
│   │   ├── order/          # 訂單聚合
│   │   ├── product/        # 商品聚合
│   │   └── customer/       # 客戶聚合
│   ├── service/            # 領域服務
│   └── repository/         # 儲存庫介面
├── infrastructure/         # 基礎設施層
│   ├── persistence/        # 資料持久化
│   ├── messaging/          # 訊息處理
│   └── external/           # 外部服務整合
└── interfaces/             # 介面層
    ├── rest/               # REST API
    ├── web/                # Web 控制器
    └── config/             # 配置

<!-- pom.xml -->
<dependencies>
    <!-- Spring Boot Starters -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    
    <!-- Database -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    
    <!-- Domain Events -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
    </dependency>
    
    <!-- Testing -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

// 應用服務介面
public interface OrderApplicationService {
    OrderId createOrder(CreateOrderCommand command);
    void confirmOrder(ConfirmOrderCommand command);
    void cancelOrder(CancelOrderCommand command);
    OrderDto getOrder(OrderId orderId);
    List<OrderDto> getCustomerOrders(CustomerId customerId);
}

// 應用服務實作
@Service
@Transactional
public class OrderApplicationServiceImpl implements OrderApplicationService {
    
    private final OrderRepository orderRepository;
    private final CustomerRepository customerRepository;
    private final OrderFactory orderFactory;
    private final ApplicationEventPublisher eventPublisher;
    private final OrderDtoAssembler orderAssembler;
    
    public OrderApplicationServiceImpl(
            OrderRepository orderRepository,
            CustomerRepository customerRepository,
            OrderFactory orderFactory,
            ApplicationEventPublisher eventPublisher,
            OrderDtoAssembler orderAssembler) {
        this.orderRepository = orderRepository;
        this.customerRepository = customerRepository;
        this.orderFactory = orderFactory;
        this.eventPublisher = eventPublisher;
        this.orderAssembler = orderAssembler;
    }
    
    @Override
    public OrderId createOrder(CreateOrderCommand command) {
        // 1. 驗證客戶存在
        Customer customer = customerRepository.findById(command.getCustomerId())
            .orElseThrow(() -> new CustomerNotFoundException(command.getCustomerId()));
        
        // 2. 建立訂單 (透過工廠)
        Order order = orderFactory.createOrder(
            command.getCustomerId(),
            command.getShippingInfo(),
            command.getOrderItems()
        );
        
        // 3. 儲存訂單
        orderRepository.save(order);
        
        // 4. 發布領域事件
        publishDomainEvents(order);
        
        return order.getId();
    }
    
    @Override
    public void confirmOrder(ConfirmOrderCommand command) {
        Order order = findOrderById(command.getOrderId());
        
        // 領域邏輯在聚合內處理
        order.confirm();
        
        orderRepository.save(order);
        publishDomainEvents(order);
    }
    
    @Override
    @Transactional(readOnly = true)
    public OrderDto getOrder(OrderId orderId) {
        Order order = findOrderById(orderId);
        return orderAssembler.toDto(order);
    }
    
    @Override
    @Transactional(readOnly = true)
    public List<OrderDto> getCustomerOrders(CustomerId customerId) {
        List<Order> orders = orderRepository.findByCustomerId(customerId);
        return orders.stream()
            .map(orderAssembler::toDto)
            .collect(Collectors.toList());
    }
    
    private Order findOrderById(OrderId orderId) {
        return orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException(orderId));
    }
    
    private void publishDomainEvents(Order order) {
        order.getDomainEvents().forEach(eventPublisher::publishEvent);
        order.clearDomainEvents();
    }
}

// 領域事件監聽器
@Component
public class OrderEventHandler {
    
    private final InventoryService inventoryService;
    private final NotificationService notificationService;
    private final Logger logger = LoggerFactory.getLogger(OrderEventHandler.class);
    
    public OrderEventHandler(InventoryService inventoryService,
                           NotificationService notificationService) {
        this.inventoryService = inventoryService;
        this.notificationService = notificationService;
    }
    
    @EventListener
    @Async
    public void handle(OrderPlaced event) {
        logger.info("處理訂單下單事件: {}", event.getOrderId());
        
        try {
            // 庫存預留
            inventoryService.reserveStock(event.getOrderId(), event.getItems());
            
            // 發送確認郵件
            notificationService.sendOrderConfirmation(
                event.getCustomerId(), 
                event.getOrderId()
            );
            
        } catch (Exception ex) {
            logger.error("處理訂單事件失敗", ex);
            // 可以發布補償事件或進行重試
        }
    }
    
    @EventListener
    public void handle(OrderShipped event) {
        logger.info("處理訂單出貨事件: {}", event.getOrderId());
        
        // 發送出貨通知
        notificationService.sendShippingNotification(
            event.getCustomerId(),
            event.getOrderId(),
            event.getTrackingNumber()
        );
    }
    
    @EventListener
    public void handle(OrderCancelled event) {
        logger.info("處理訂單取消事件: {}", event.getOrderId());
        
        // 釋放庫存
        inventoryService.releaseReservedStock(event.getOrderId());
        
        // 發送取消通知
        notificationService.sendCancellationNotification(
            event.getCustomerId(),
            event.getOrderId()
        );
    }
}

// 非同步事件處理配置
@Configuration
@EnableAsync
public class AsyncConfig {
    
    @Bean
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(25);
        executor.setThreadNamePrefix("DomainEvent-");
        executor.initialize();
        return executor;
    }
}

@RestController
@RequestMapping("/api/v1/orders")
@Validated
public class OrderController {
    
    private final OrderApplicationService orderService;
    private final OrderQueryService orderQueryService;
    
    public OrderController(OrderApplicationService orderService,
                          OrderQueryService orderQueryService) {
        this.orderService = orderService;
        this.orderQueryService = orderQueryService;
    }
    
    @PostMapping
    public ResponseEntity<CreateOrderResponse> createOrder(
            @Valid @RequestBody CreateOrderRequest request) {
        
        CreateOrderCommand command = CreateOrderCommand.builder()
            .customerId(new CustomerId(request.getCustomerId()))
            .shippingInfo(mapToShippingInfo(request.getShippingInfo()))
            .orderItems(mapToOrderItems(request.getItems()))
            .build();
            
        OrderId orderId = orderService.createOrder(command);
        
        CreateOrderResponse response = new CreateOrderResponse(orderId.getValue());
        
        return ResponseEntity.status(HttpStatus.CREATED)
            .location(URI.create("/api/v1/orders/" + orderId.getValue()))
            .body(response);
    }
    
    @GetMapping("/{orderId}")
    public ResponseEntity<OrderDetailResponse> getOrder(
            @PathVariable String orderId) {
        
        OrderDto order = orderService.getOrder(new OrderId(orderId));
        OrderDetailResponse response = mapToDetailResponse(order);
        
        return ResponseEntity.ok(response);
    }
    
    @PostMapping("/{orderId}/confirm")
    public ResponseEntity<Void> confirmOrder(@PathVariable String orderId) {
        
        ConfirmOrderCommand command = new ConfirmOrderCommand(new OrderId(orderId));
        orderService.confirmOrder(command);
        
        return ResponseEntity.ok().build();
    }
    
    @PostMapping("/{orderId}/cancel")
    public ResponseEntity<Void> cancelOrder(
            @PathVariable String orderId,
            @Valid @RequestBody CancelOrderRequest request) {
        
        CancelOrderCommand command = new CancelOrderCommand(
            new OrderId(orderId),
            request.getReason()
        );
        orderService.cancelOrder(command);
        
        return ResponseEntity.ok().build();
    }
    
    @GetMapping
    public ResponseEntity<List<OrderSummaryResponse>> getCustomerOrders(
            @RequestParam String customerId,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size) {
        
        Pageable pageable = PageRequest.of(page, size);
        Page<OrderDto> orders = orderQueryService.findByCustomerId(
            new CustomerId(customerId), pageable);
            
        List<OrderSummaryResponse> response = orders.getContent().stream()
            .map(this::mapToSummaryResponse)
            .collect(Collectors.toList());
            
        return ResponseEntity.ok(response);
    }
    
    // Mapping methods...
    private ShippingInfo mapToShippingInfo(ShippingInfoRequest request) {
        return new ShippingInfo(
            new Address(
                request.getStreet(),
                request.getCity(),
                request.getState(),
                request.getPostalCode(),
                request.getCountry()
            ),
            ShippingMethod.valueOf(request.getShippingMethod())
        );
    }
}

// Command 端 - 寫入模型
@Service
@Transactional
public class OrderCommandService {
    
    private final OrderRepository orderRepository;
    private final ApplicationEventPublisher eventPublisher;
    
    public OrderId createOrder(CreateOrderCommand command) {
        Order order = Order.create(
            OrderId.generate(),
            command.getCustomerId(),
            command.getShippingInfo()
        );
        
        orderRepository.save(order);
        publishDomainEvents(order);
        
        return order.getId();
    }
    
    private void publishDomainEvents(Order order) {
        order.getDomainEvents().forEach(eventPublisher::publishEvent);
        order.clearDomainEvents();
    }
}

// Query 端 - 讀取模型
@Service
@Transactional(readOnly = true)
public class OrderQueryService {
    
    private final OrderReadModelRepository readModelRepository;
    
    public OrderSummaryDto getOrderSummary(OrderId orderId) {
        return readModelRepository.findSummaryById(orderId);
    }
    
    public Page<OrderListDto> getCustomerOrders(CustomerId customerId, 
                                              Pageable pageable) {
        return readModelRepository.findByCustomerId(customerId, pageable);
    }
    
    public List<OrderAnalyticsDto> getOrderAnalytics(LocalDate startDate, 
                                                    LocalDate endDate) {
        return readModelRepository.findAnalyticsData(startDate, endDate);
    }
}

// 讀取模型
@Entity
@Table(name = "order_read_model")
public class OrderReadModel {
    @Id
    private String orderId;
    private String customerId;
    private String customerName;
    private String status;
    private BigDecimal totalAmount;
    private String currency;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
    
    // 非正規化的欄位，提升查詢效率
    private int itemCount;
    private String productNames; // 逗號分隔的商品名稱
    private String shippingAddress;
    
    // getters, setters...
}

// 事件處理器更新讀取模型
@Component
public class OrderReadModelUpdater {
    
    private final OrderReadModelRepository readModelRepository;
    
    @EventListener
    public void on(OrderCreated event) {
        OrderReadModel readModel = new OrderReadModel();
        readModel.setOrderId(event.getOrderId().getValue());
        readModel.setCustomerId(event.getCustomerId().getValue());
        readModel.setStatus("PENDING");
        readModel.setCreatedAt(event.getOccurredOn());
        
        readModelRepository.save(readModel);
    }
    
    @EventListener
    public void on(OrderPlaced event) {
        OrderReadModel readModel = readModelRepository.findById(
            event.getOrderId().getValue()).orElseThrow();
            
        readModel.setStatus("CONFIRMED");
        readModel.setTotalAmount(event.getTotalAmount().getAmount());
        readModel.setCurrency(event.getTotalAmount().getCurrency().getCurrencyCode());
        readModel.setItemCount(event.getItems().size());
        readModel.setUpdatedAt(event.getOccurredOn());
        
        readModelRepository.save(readModel);
    }
}

// 服務間事件通訊
@Component
public class OrderEventPublisher {
    
    private final RabbitTemplate rabbitTemplate;
    
    @EventListener
    public void publishToMessageBroker(OrderPlaced event) {
        OrderPlacedEvent externalEvent = new OrderPlacedEvent(
            event.getOrderId().getValue(),
            event.getCustomerId().getValue(),
            event.getTotalAmount().getAmount(),
            event.getOccurredOn()
        );
        
        rabbitTemplate.convertAndSend(
            "order.exchange", 
            "order.placed", 
            externalEvent
        );
    }
}

// 外部服務整合 - Anti-Corruption Layer
@Component
public class PaymentServiceAdapter {
    
    private final PaymentServiceClient paymentClient;
    private final PaymentResponseTranslator translator;
    
    public PaymentResult processPayment(PaymentRequest request) {
        try {
            ExternalPaymentResponse response = paymentClient.processPayment(
                translateToExternalRequest(request)
            );
            
            return translator.translateToInternalModel(response);
            
        } catch (ExternalServiceException ex) {
            throw new PaymentProcessingException("支付處理失敗", ex);
        }
    }
    
    private ExternalPaymentRequest translateToExternalRequest(PaymentRequest request) {
        return new ExternalPaymentRequest(
            request.getOrderId().getValue(),
            request.getAmount().getAmount(),
            request.getAmount().getCurrency().getCurrencyCode(),
            request.getPaymentMethod().name()
        );
    }
}

// Entity 測試
@ExtendWith(MockitoExtension.class)
class OrderTest {
    
    @Test
    @DisplayName("新建訂單應該處於待處理狀態")
    void newOrder_ShouldBePendingStatus() {
        // Given
        OrderId orderId = OrderId.generate();
        CustomerId customerId = new CustomerId("customer-123");
        ShippingInfo shippingInfo = createShippingInfo();
        
        // When
        Order order = new Order(orderId, customerId, shippingInfo);
        
        // Then
        assertThat(order.getStatus()).isEqualTo(OrderStatus.PENDING);
        assertThat(order.getId()).isEqualTo(orderId);
        assertThat(order.getCustomerId()).isEqualTo(customerId);
        assertThat(order.getItems()).isEmpty();
    }
    
    @Test
    @DisplayName("添加商品項目應該更新訂單總額")
    void addItem_ShouldUpdateTotalAmount() {
        // Given
        Order order = createPendingOrder();
        ProductId productId = new ProductId("product-123");
        int quantity = 2;
        Money unitPrice = new Money("100.00", "TWD");
        
        // When
        order.addItem(productId, quantity, unitPrice);
        
        // Then
        assertThat(order.getItems()).hasSize(1);
        assertThat(order.getTotalAmount()).isEqualTo(new Money("200.00", "TWD"));
        
        OrderItem addedItem = order.getItems().get(0);
        assertThat(addedItem.getProductId()).isEqualTo(productId);
        assertThat(addedItem.getQuantity()).isEqualTo(quantity);
        assertThat(addedItem.getUnitPrice()).isEqualTo(unitPrice);
    }
    
    @Test
    @DisplayName("確認空訂單應該拋出例外")
    void confirmEmptyOrder_ShouldThrowException() {
        // Given
        Order order = createPendingOrder();
        
        // When & Then
        assertThatThrownBy(order::confirm)
            .isInstanceOf(IllegalStateException.class)
            .hasMessage("空訂單無法確認");
    }
    
    @Test
    @DisplayName("確認訂單應該發布 OrderPlaced 事件")
    void confirmOrder_ShouldPublishOrderPlacedEvent() {
        // Given
        Order order = createOrderWithItems();
        
        // When
        order.confirm();
        
        // Then
        assertThat(order.getStatus()).isEqualTo(OrderStatus.CONFIRMED);
        
        List<DomainEvent> events = order.getDomainEvents();
        assertThat(events).hasSize(1);
        assertThat(events.get(0)).isInstanceOf(OrderPlaced.class);
        
        OrderPlaced event = (OrderPlaced) events.get(0);
        assertThat(event.getOrderId()).isEqualTo(order.getId());
        assertThat(event.getCustomerId()).isEqualTo(order.getCustomerId());
    }
    
    private Order createPendingOrder() {
        return new Order(
            OrderId.generate(),
            new CustomerId("customer-123"),
            createShippingInfo()
        );
    }
    
    private Order createOrderWithItems() {
        Order order = createPendingOrder();
        order.addItem(
            new ProductId("product-123"),
            1,
            new Money("100.00", "TWD")
        );
        return order;
    }
    
    private ShippingInfo createShippingInfo() {
        return new ShippingInfo(
            new Address("123 Test St", "Test City", "Test State", "12345", "Taiwan"),
            ShippingMethod.STANDARD
        );
    }
}

// Value Object 測試
class MoneyTest {
    
    @Test
    @DisplayName("相同金額和幣別的 Money 應該相等")
    void sameCurrencyAndAmount_ShouldBeEqual() {
        // Given
        Money money1 = new Money("100.50", "TWD");
        Money money2 = new Money("100.50", "TWD");
        
        // When & Then
        assertThat(money1).isEqualTo(money2);
        assertThat(money1.hashCode()).isEqualTo(money2.hashCode());
    }
    
    @Test
    @DisplayName("相同幣別的 Money 應該可以相加")
    void sameCurrency_ShouldAllowAddition() {
        // Given
        Money money1 = new Money("100.50", "TWD");
        Money money2 = new Money("50.25", "TWD");
        
        // When
        Money result = money1.add(money2);
        
        // Then
        assertThat(result).isEqualTo(new Money("150.75", "TWD"));
    }
    
    @Test
    @DisplayName("不同幣別的 Money 相加應該拋出例外")
    void differentCurrency_ShouldThrowExceptionOnAddition() {
        // Given
        Money twd = new Money("100.00", "TWD");
        Money usd = new Money("100.00", "USD");
        
        // When & Then
        assertThatThrownBy(() -> twd.add(usd))
            .isInstanceOf(IllegalArgumentException.class)
            .hasMessage("不同幣別無法直接相加");
    }
    
    @ParameterizedTest
    @ValueSource(strings = {"", "invalid", "100.123", "abc"})
    @DisplayName("無效的金額格式應該拋出例外")
    void invalidAmount_ShouldThrowException(String invalidAmount) {
        assertThatThrownBy(() -> new Money(invalidAmount, "TWD"))
            .isInstanceOf(IllegalArgumentException.class);
    }
}

@SpringBootTest
@Transactional
@TestPropertySource(properties = {
    "spring.jpa.hibernate.ddl-auto=create-drop",
    "spring.datasource.url=jdbc:h2:mem:testdb"
})
class OrderApplicationServiceIntegrationTest {
    
    @Autowired
    private OrderApplicationService orderService;
    
    @Autowired
    private TestEntityManager entityManager;
    
    @MockBean
    private ApplicationEventPublisher eventPublisher;
    
    @Test
    @DisplayName("建立訂單應該儲存到資料庫並發布事件")
    void createOrder_ShouldPersistAndPublishEvent() {
        // Given
        Customer customer = createAndSaveCustomer();
        CreateOrderCommand command = CreateOrderCommand.builder()
            .customerId(customer.getId())
            .shippingInfo(createShippingInfo())
            .orderItems(createOrderItems())
            .build();
        
        // When
        OrderId orderId = orderService.createOrder(command);
        
        // Then
        entityManager.flush();
        entityManager.clear();
        
        Order savedOrder = entityManager.find(Order.class, orderId);
        assertThat(savedOrder).isNotNull();
        assertThat(savedOrder.getCustomerId()).isEqualTo(customer.getId());
        assertThat(savedOrder.getStatus()).isEqualTo(OrderStatus.PENDING);
        
        verify(eventPublisher).publishEvent(any(OrderCreated.class));
    }
    
    @Test
    @DisplayName("確認不存在的訂單應該拋出例外")
    void confirmNonExistentOrder_ShouldThrowException() {
        // Given
        OrderId nonExistentOrderId = OrderId.generate();
        ConfirmOrderCommand command = new ConfirmOrderCommand(nonExistentOrderId);
        
        // When & Then
        assertThatThrownBy(() -> orderService.confirmOrder(command))
            .isInstanceOf(OrderNotFoundException.class);
    }
    
    private Customer createAndSaveCustomer() {
        Customer customer = new Customer(
            CustomerId.generate(),
            "Test Customer",
            new Email("test@example.com")
        );
        entityManager.persistAndFlush(customer);
        return customer;
    }
    
    private List<OrderItemData> createOrderItems() {
        return List.of(
            new OrderItemData(
                new ProductId("product-1"),
                2,
                new Money("100.00", "TWD")
            )
        );
    }
}

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Testcontainers
class OrderControllerE2ETest {
    
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:13")
            .withDatabaseName("testdb")
            .withUsername("test")
            .withPassword("test");
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Autowired
    private OrderRepository orderRepository;
    
    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }
    
    @Test
    @DisplayName("完整的訂單流程測試")
    void completeOrderFlow_ShouldWork() {
        // 1. 建立訂單
        CreateOrderRequest createRequest = new CreateOrderRequest();
        createRequest.setCustomerId("customer-123");
        createRequest.setShippingInfo(createShippingInfoRequest());
        createRequest.setItems(createOrderItemRequests());
        
        ResponseEntity<CreateOrderResponse> createResponse = restTemplate.postForEntity(
            "/api/v1/orders",
            createRequest,
            CreateOrderResponse.class
        );
        
        assertThat(createResponse.getStatusCode()).isEqualTo(HttpStatus.CREATED);
        String orderId = createResponse.getBody().getOrderId();
        
        // 2. 查詢訂單
        ResponseEntity<OrderDetailResponse> getResponse = restTemplate.getForEntity(
            "/api/v1/orders/" + orderId,
            OrderDetailResponse.class
        );
        
        assertThat(getResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
        assertThat(getResponse.getBody().getStatus()).isEqualTo("PENDING");
        
        // 3. 確認訂單
        ResponseEntity<Void> confirmResponse = restTemplate.postForEntity(
            "/api/v1/orders/" + orderId + "/confirm",
            null,
            Void.class
        );
        
        assertThat(confirmResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
        
        // 4. 驗證訂單狀態已更新
        Order confirmedOrder = orderRepository.findById(new OrderId(orderId)).orElseThrow();
        assertThat(confirmedOrder.getStatus()).isEqualTo(OrderStatus.CONFIRMED);
    }
}

// 錯誤示範 - 貧血模型
public class Order {
    private OrderId id;
    private CustomerId customerId;
    private OrderStatus status;
    private List<OrderItem> items;
    
    // 只有 getters 和 setters，沒有業務邏輯
    public OrderId getId() { return id; }
    public void setId(OrderId id) { this.id = id; }
    public OrderStatus getStatus() { return status; }
    public void setStatus(OrderStatus status) { this.status = status; }
    // ...
}

// 業務邏輯散布在服務層
@Service
public class OrderService {
    public void confirmOrder(OrderId orderId) {
        Order order = orderRepository.findById(orderId);
        if (order.getStatus() != OrderStatus.PENDING) {
            throw new IllegalStateException("訂單狀態錯誤");
        }
        if (order.getItems().isEmpty()) {
            throw new IllegalStateException("空訂單無法確認");
        }
        order.setStatus(OrderStatus.CONFIRMED);
        orderRepository.save(order);
    }
}

public class Order extends AggregateRoot<OrderId> {
    private CustomerId customerId;
    private OrderStatus status;
    private List<OrderItem> items;
    
    // 業務邏輯封裝在實體內
    public void confirm() {
        validateCanBeConfirmed();
        this.status = OrderStatus.CONFIRMED;
        addDomainEvent(new OrderConfirmed(getId(), customerId));
    }
    
    private void validateCanBeConfirmed() {
        if (status != OrderStatus.PENDING) {
            throw new IllegalStateException("只能確認待處理狀態的訂單");
        }
        if (items.isEmpty()) {
            throw new IllegalStateException("空訂單無法確認");
        }
    }
    
    public boolean canBeShipped() {
        return status == OrderStatus.CONFIRMED && hasShippableItems();
    }
    
    private boolean hasShippableItems() {
        return items.stream().allMatch(OrderItem::isShippable);
    }
}

// 錯誤示範 - 包含太多概念的聚合
public class Customer extends AggregateRoot<CustomerId> {
    private String name;
    private Email email;
    private List<Address> addresses;
    private List<Order> orders;           // 不應該包含
    private List<PaymentMethod> paymentMethods; // 不應該包含
    private List<Preference> preferences; // 不應該包含
    private List<Review> reviews;         // 不應該包含
    
    // 會導致性能問題和一致性邊界模糊
}

// 客戶聚合只包含基本資訊
public class Customer extends AggregateRoot<CustomerId> {
    private String name;
    private Email email;
    private CustomerStatus status;
    private LocalDateTime registeredAt;
    
    public void changeEmail(Email newEmail) {
        validateEmailChange(newEmail);
        this.email = newEmail;
        addDomainEvent(new CustomerEmailChanged(getId(), newEmail));
    }
    
    public void activate() {
        if (status == CustomerStatus.ACTIVE) {
            throw new IllegalStateException("客戶已經是啟用狀態");
        }
        this.status = CustomerStatus.ACTIVE;
        addDomainEvent(new CustomerActivated(getId()));
    }
}

// 訂單是獨立的聚合
public class Order extends AggregateRoot<OrderId> {
    private CustomerId customerId; // 透過 ID 參考客戶
    // ... 訂單相關邏輯
}

// 錯誤示範 - 過度使用領域服務
@Service
public class OrderDomainService {
    // 這些邏輯應該在 Order 聚合內
    public void addItem(Order order, ProductId productId, int quantity) {
        order.getItems().add(new OrderItem(productId, quantity));
    }
    
    public void removeItem(Order order, ProductId productId) {
        order.getItems().removeIf(item -> item.getProductId().equals(productId));
    }
    
    public Money calculateTotal(Order order) {
        return order.getItems().stream()
            .map(OrderItem::getTotalPrice)
            .reduce(Money.ZERO, Money::add);
    }
}

// 領域服務只處理跨聚合的業務邏輯
@Service
public class OrderPricingService {
    private final TaxCalculator taxCalculator;
    private final DiscountPolicy discountPolicy;
    
    // 需要外部資訊計算的複雜定價邏輯
    public OrderPricing calculatePricing(Order order, Customer customer, Location location) {
        Money subtotal = order.calculateSubtotal(); // 聚合內部方法
        Money discount = discountPolicy.calculateDiscount(order, customer);
        Money tax = taxCalculator.calculateTax(subtotal, location);
        Money shipping = calculateShipping(order, location);
        
        return new OrderPricing(subtotal, discount, tax, shipping);
    }
}

// 錯誤示範
@Entity
public class Order {
    @ManyToOne
    @JoinColumn(name = "customer_id")
    private Customer customer; // 直接引用其他聚合
    
    @ManyToMany
    @JoinTable(name = "order_products")
    private List<Product> products; // 直接引用其他聚合
}

@Entity
public class Order {
    @Column(name = "customer_id")
    private CustomerId customerId; // 透過 ID 引用
    
    @ElementCollection
    @CollectionTable(name = "order_items")
    private List<OrderItem> items; // 聚合內部對象
}

@Embeddable
public class OrderItem {
    @Column(name = "product_id")
    private ProductId productId; // 透過 ID 引用商品
    
    @Column(name = "product_name")
    private String productName; // 快照資料
    
    @Column(name = "quantity")
    private int quantity;
    
    @Embedded
    private Money unitPrice;
}

// 錯誤示範 - 領域對象依賴技術框架
public class Order {
    @Autowired
    private OrderRepository repository; // 領域對象不應依賴基礎設施
    
    public void confirm() {
        this.status = OrderStatus.CONFIRMED;
        repository.save(this); // 違反領域層純淨性
    }
}

// 領域對象專注於業務邏輯
public class Order extends AggregateRoot<OrderId> {
    public void confirm() {
        validateCanBeConfirmed();
        this.status = OrderStatus.CONFIRMED;
        addDomainEvent(new OrderConfirmed(getId(), customerId));
    }
}

// 應用服務負責協調和持久化
@Service
@Transactional
public class OrderApplicationService {
    private final OrderRepository orderRepository;
    
    public void confirmOrder(ConfirmOrderCommand command) {
        Order order = orderRepository.findById(command.getOrderId()).orElseThrow();
        order.confirm(); // 調用領域邏輯
        orderRepository.save(order); // 持久化
        publishDomainEvents(order); // 發布事件
    }
}

// 練習目標：設計 Book 聚合
public class Book extends AggregateRoot<BookId> {
    private String title;
    private ISBN isbn;
    private List<Author> authors;
    private BookStatus status;
    private MemberId borrowedBy;
    private LocalDate dueDate;
    
    public BorrowResult borrowTo(MemberId memberId, LocalDate dueDate) {
        // 實作借閱邏輯
    }
    
    public void returnBook() {
        // 實作歸還邏輯
    }
}