// 以資料表結構為中心
public class OrderService {
    public void createOrder(OrderDTO orderDto) {
        // 直接操作資料庫
        orderRepository.save(orderDto);
        // 業務邏輯散落各處
        if (orderDto.getAmount() > 1000) {
            // 折扣邏輯
        }
    }
}

// 以領域模型為中心
public class Order {
    private OrderId id;
    private CustomerId customerId;
    private Money totalAmount;
    private List<OrderItem> items;
    
    public Order(CustomerId customerId, List<OrderItem> items) {
        this.customerId = customerId;
        this.items = items;
        this.totalAmount = calculateTotal(items);
        this.applyDiscountRules(); // 業務邏輯封裝在領域物件中
    }
    
    private void applyDiscountRules() {
        // 領域規則的實作
    }
}

// 領域模型：會員
public class Member {
    private MemberId memberId;
    private String name;
    private MembershipType type;
    private List<BorrowRecord> borrowHistory;
    
    public boolean canBorrow(Book book) {
        // 業務規則：檢查借閱資格
        return !isOverdue() && !exceedsBorrowLimit() && book.isAvailable();
    }
    
    public BorrowRecord borrowBook(Book book) {
        if (!canBorrow(book)) {
            throw new BorrowingNotAllowedException("無法借閱此書籍");
        }
        // 業務邏輯的實作
        book.markAsBorrowed(this);
        BorrowRecord record = new BorrowRecord(this, book, LocalDate.now());
        borrowHistory.add(record);
        return record;
    }
}

// 共享的客戶模型
public class SharedCustomerModel {
    private CustomerId id;
    private String name;
    private Email email;
    // 只包含兩個上下文都需要的核心屬性
}

// 防腐層：轉譯外部模型到內部模型
public class ERPOrderAdapter {
    public InternalOrder translate(ERPOrderData erpOrder) {
        return InternalOrder.builder()
            .orderId(OrderId.from(erpOrder.getExternalId()))
            .customerInfo(translateCustomer(erpOrder.getCustomerData()))
            .items(translateItems(erpOrder.getLineItems()))
            .build();
    }
}

// 客戶實體 - 有明確的身份識別
@Entity
public class Customer {
    private CustomerId customerId;    // 唯一識別符
    private String name;             // 可變屬性
    private Email email;             // 可變屬性
    private CustomerStatus status;   // 可變狀態
    private LocalDateTime createdAt; // 不變屬性
    
    // 建構子確保實體建立時就有身份
    public Customer(CustomerId customerId, String name, Email email) {
        this.customerId = Objects.requireNonNull(customerId);
        this.name = Objects.requireNonNull(name);
        this.email = Objects.requireNonNull(email);
        this.status = CustomerStatus.ACTIVE;
        this.createdAt = LocalDateTime.now();
    }
    
    // 業務行為：變更客戶資訊
    public void updateContactInfo(String newName, Email newEmail) {
        validateNameChange(newName);
        validateEmailChange(newEmail);
        
        this.name = newName;
        this.email = newEmail;
    }
    
    // 業務行為：停用客戶
    public void deactivate(String reason) {
        if (this.status == CustomerStatus.INACTIVE) {
            throw new IllegalStateException("客戶已經是停用狀態");
        }
        this.status = CustomerStatus.INACTIVE;
        // 觸發領域事件
        DomainEventPublisher.instance().publish(
            new CustomerDeactivated(this.customerId, reason)
        );
    }
    
    // 相等性基於身份而非屬性
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Customer)) return false;
        Customer other = (Customer) obj;
        return Objects.equals(this.customerId, other.customerId);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(customerId);
    }
}

// 金額值物件
public final class Money {
    private final BigDecimal amount;
    private final Currency currency;
    
    public Money(BigDecimal amount, Currency currency) {
        this.amount = Objects.requireNonNull(amount);
        this.currency = Objects.requireNonNull(currency);
        validateAmount(amount);
    }
    
    // 靜態工廠方法
    public static Money of(double amount, String currencyCode) {
        return new Money(
            BigDecimal.valueOf(amount), 
            Currency.getInstance(currencyCode)
        );
    }
    
    // 業務操作返回新的值物件
    public Money add(Money other) {
        validateSameCurrency(other);
        return new Money(
            this.amount.add(other.amount), 
            this.currency
        );
    }
    
    public Money multiply(BigDecimal factor) {
        return new Money(
            this.amount.multiply(factor), 
            this.currency
        );
    }
    
    // 值相等性
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Money)) return false;
        Money other = (Money) obj;
        return Objects.equals(amount, other.amount) && 
               Objects.equals(currency, other.currency);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(amount, currency);
    }
    
    // 不提供 setter 方法，確保不可變性
    public BigDecimal getAmount() { return amount; }
    public Currency getCurrency() { return currency; }
}

// 地址值物件
public final class Address {
    private final String street;
    private final String city;
    private final String postalCode;
    private final String country;
    
    private Address(Builder builder) {
        this.street = builder.street;
        this.city = builder.city;
        this.postalCode = builder.postalCode;
        this.country = builder.country;
        
        validate();
    }
    
    // Builder 模式for複雜值物件
    public static class Builder {
        private String street;
        private String city;
        private String postalCode;
        private String country;
        
        public Builder street(String street) {
            this.street = street;
            return this;
        }
        
        public Builder city(String city) {
            this.city = city;
            return this;
        }
        
        public Builder postalCode(String postalCode) {
            this.postalCode = postalCode;
            return this;
        }
        
        public Builder country(String country) {
            this.country = country;
            return this;
        }
        
        public Address build() {
            return new Address(this);
        }
    }
    
    // 業務邏輯：地址驗證
    private void validate() {
        if (isEmpty(street) || isEmpty(city) || 
            isEmpty(postalCode) || isEmpty(country)) {
            throw new IllegalArgumentException("地址資訊不完整");
        }
        
        if (!isValidPostalCode(postalCode, country)) {
            throw new IllegalArgumentException("郵遞區號格式不正確");
        }
    }
    
    // 業務查詢：是否為同一國家
    public boolean isSameCountry(Address other) {
        return this.country.equals(other.country);
    }
}

// 訂單聚合根
@Aggregate
public class Order {
    private OrderId orderId;
    private CustomerId customerId;
    private OrderStatus status;
    private List<OrderItem> items;
    private ShippingAddress shippingAddress;
    private Money totalAmount;
    private LocalDateTime orderDate;
    
    // 透過工廠方法建立聚合
    public static Order create(CustomerId customerId, 
                              List<OrderItem> items,
                              ShippingAddress shippingAddress) {
        validateItems(items);
        
        Order order = new Order();
        order.orderId = OrderId.generate();
        order.customerId = customerId;
        order.items = new ArrayList<>(items);
        order.shippingAddress = shippingAddress;
        order.status = OrderStatus.PENDING;
        order.orderDate = LocalDateTime.now();
        order.calculateTotal();
        
        // 發布領域事件
        order.addDomainEvent(new OrderCreated(order.orderId, customerId));
        
        return order;
    }
    
    // 業務操作：新增訂單項目
    public void addItem(Product product, int quantity, Money unitPrice) {
        validateOrderModifiable();
        
        OrderItem item = new OrderItem(product.getId(), quantity, unitPrice);
        this.items.add(item);
        calculateTotal();
        
        // 檢查業務不變條件
        enforceInvariants();
    }
    
    // 業務操作：確認訂單
    public void confirm() {
        if (status != OrderStatus.PENDING) {
            throw new IllegalStateException("只有待處理訂單可以確認");
        }
        
        validateMinimumAmount();
        this.status = OrderStatus.CONFIRMED;
        
        addDomainEvent(new OrderConfirmed(this.orderId));
    }
    
    // 業務不變條件
    private void enforceInvariants() {
        if (items.isEmpty()) {
            throw new IllegalStateException("訂單必須包含至少一個項目");
        }
        
        if (totalAmount.getAmount().compareTo(BigDecimal.ZERO) <= 0) {
            throw new IllegalStateException("訂單總金額必須大於零");
        }
    }
    
    // 聚合內部邏輯
    private void calculateTotal() {
        this.totalAmount = items.stream()
            .map(OrderItem::getSubtotal)
            .reduce(Money.ZERO, Money::add);
    }
    
    // 只提供必要的getter，不提供setter
    public OrderId getOrderId() { return orderId; }
    public OrderStatus getStatus() { return status; }
    public Money getTotalAmount() { return totalAmount; }
    
    // 聚合內實體
    public static class OrderItem {
        private ProductId productId;
        private int quantity;
        private Money unitPrice;
        
        public OrderItem(ProductId productId, int quantity, Money unitPrice) {
            this.productId = productId;
            this.quantity = quantity;
            this.unitPrice = unitPrice;
            validate();
        }
        
        public Money getSubtotal() {
            return unitPrice.multiply(BigDecimal.valueOf(quantity));
        }
        
        private void validate() {
            if (quantity <= 0) {
                throw new IllegalArgumentException("數量必須大於零");
            }
        }
    }
}

// 倉儲介面 - 位於領域層
public interface OrderRepository {
    // 基本 CRUD 操作
    void save(Order order);
    Optional<Order> findById(OrderId orderId);
    void remove(Order order);
    
    // 業務導向的查詢方法
    List<Order> findByCustomerId(CustomerId customerId);
    List<Order> findPendingOrders();
    List<Order> findOrdersByDateRange(LocalDate startDate, LocalDate endDate);
    
    // 規格模式查詢
    List<Order> findBySpecification(OrderSpecification specification);
    
    // 分頁查詢
    Page<Order> findByCustomerId(CustomerId customerId, Pageable pageable);
    
    // 聚合計算
    OrderStatistics calculateStatistics(CustomerId customerId);
}

// JPA 實作 - 位於基礎設施層
@Repository
@Transactional
public class JpaOrderRepository implements OrderRepository {
    
    @PersistenceContext
    private EntityManager entityManager;
    
    @Override
    public void save(Order order) {
        if (order.getOrderId() == null) {
            entityManager.persist(order);
        } else {
            entityManager.merge(order);
        }
        
        // 處理領域事件
        publishDomainEvents(order);
    }
    
    @Override
    public Optional<Order> findById(OrderId orderId) {
        Order order = entityManager.find(Order.class, orderId);
        return Optional.ofNullable(order);
    }
    
    @Override
    public List<Order> findByCustomerId(CustomerId customerId) {
        TypedQuery<Order> query = entityManager.createQuery(
            "SELECT o FROM Order o WHERE o.customerId = :customerId", 
            Order.class
        );
        query.setParameter("customerId", customerId);
        return query.getResultList();
    }
    
    @Override
    public List<Order> findBySpecification(OrderSpecification specification) {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<Order> query = cb.createQuery(Order.class);
        Root<Order> root = query.from(Order.class);
        
        Predicate predicate = specification.toPredicate(root, query, cb);
        query.where(predicate);
        
        return entityManager.createQuery(query).getResultList();
    }
    
    private void publishDomainEvents(Order order) {
        order.getDomainEvents().forEach(event -> {
            applicationEventPublisher.publishEvent(event);
        });
        order.clearDomainEvents();
    }
}

// 領域服務：轉帳服務
@DomainService
public class TransferService {
    
    public TransferResult transfer(Account fromAccount, 
                                 Account toAccount, 
                                 Money amount) {
        // 跨聚合的業務邏輯
        validateTransfer(fromAccount, toAccount, amount);
        
        // 執行轉帳
        fromAccount.debit(amount);
        toAccount.credit(amount);
        
        // 建立轉帳記錄
        TransferRecord record = new TransferRecord(
            fromAccount.getAccountId(),
            toAccount.getAccountId(),
            amount,
            LocalDateTime.now()
        );
        
        return new TransferResult(record, TransferStatus.SUCCESS);
    }
    
    private void validateTransfer(Account from, Account to, Money amount) {
        if (!from.canDebit(amount)) {
            throw new InsufficientFundsException("餘額不足");
        }
        
        if (!to.canCredit(amount)) {
            throw new AccountLimitExceededException("超過帳戶限額");
        }
        
        if (amount.getAmount().compareTo(BigDecimal.ZERO) <= 0) {
            throw new InvalidAmountException("轉帳金額必須大於零");
        }
    }
}

// 應用服務：訂單應用服務
@ApplicationService
@Transactional
public class OrderApplicationService {
    
    private final OrderRepository orderRepository;
    private final CustomerRepository customerRepository;
    private final ProductRepository productRepository;
    private final DomainEventPublisher eventPublisher;
    
    public OrderId createOrder(CreateOrderCommand command) {
        // 1. 驗證權限
        validatePermissions(command.getCustomerId());
        
        // 2. 載入相關聚合
        Customer customer = customerRepository.findById(command.getCustomerId())
            .orElseThrow(() -> new CustomerNotFoundException());
        
        // 3. 驗證業務規則
        validateOrderCreation(customer);
        
        // 4. 建立訂單聚合
        List<OrderItem> items = buildOrderItems(command.getItems());
        ShippingAddress address = command.getShippingAddress();
        
        Order order = Order.create(customer.getCustomerId(), items, address);
        
        // 5. 儲存聚合
        orderRepository.save(order);
        
        // 6. 返回結果
        return order.getOrderId();
    }
    
    public void confirmOrder(OrderId orderId) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException());
        
        // 委託給領域物件執行業務邏輯
        order.confirm();
        
        orderRepository.save(order);
    }
    
    private List<OrderItem> buildOrderItems(List<OrderItemCommand> itemCommands) {
        return itemCommands.stream()
            .map(this::buildOrderItem)
            .collect(Collectors.toList());
    }
    
    private OrderItem buildOrderItem(OrderItemCommand itemCommand) {
        Product product = productRepository.findById(itemCommand.getProductId())
            .orElseThrow(() -> new ProductNotFoundException());
        
        return new OrderItem(
            product.getId(),
            itemCommand.getQuantity(),
            product.getPrice()
        );
    }
}

// 訂單工廠
public class OrderFactory {
    
    private final ProductRepository productRepository;
    private final PricingService pricingService;
    
    public Order createOrder(CustomerId customerId, 
                           List<OrderItemRequest> itemRequests,
                           ShippingAddress shippingAddress) {
        
        // 驗證客戶
        validateCustomer(customerId);
        
        // 建立訂單項目
        List<OrderItem> items = createOrderItems(itemRequests);
        
        // 應用價格策略
        applyPricingRules(items, customerId);
        
        // 建立訂單
        Order order = Order.create(customerId, items, shippingAddress);
        
        // 應用促銷規則
        applyPromotions(order, customerId);
        
        return order;
    }
    
    private List<OrderItem> createOrderItems(List<OrderItemRequest> requests) {
        return requests.stream()
            .map(this::createOrderItem)
            .collect(Collectors.toList());
    }
    
    private OrderItem createOrderItem(OrderItemRequest request) {
        Product product = productRepository.findById(request.getProductId())
            .orElseThrow(() -> new ProductNotFoundException());
        
        // 複雜的項目建立邏輯
        Money unitPrice = pricingService.calculatePrice(
            product, request.getQuantity()
        );
        
        return new OrderItem(
            product.getId(),
            request.getQuantity(),
            unitPrice
        );
    }
}

// 抽象領域事件
public abstract class DomainEvent {
    private final UUID eventId;
    private final LocalDateTime occurredOn;
    private final int version;
    
    protected DomainEvent() {
        this.eventId = UUID.randomUUID();
        this.occurredOn = LocalDateTime.now();
        this.version = 1;
    }
    
    public UUID getEventId() { return eventId; }
    public LocalDateTime getOccurredOn() { return occurredOn; }
    public int getVersion() { return version; }
    
    // 事件名稱用於路由和持久化
    public abstract String getEventType();
}

// 具體領域事件：訂單已確認
public class OrderConfirmed extends DomainEvent {
    private final OrderId orderId;
    private final CustomerId customerId;
    private final Money totalAmount;
    private final LocalDateTime confirmedAt;
    
    public OrderConfirmed(OrderId orderId, CustomerId customerId, Money totalAmount) {
        super();
        this.orderId = orderId;
        this.customerId = customerId;
        this.totalAmount = totalAmount;
        this.confirmedAt = LocalDateTime.now();
    }
    
    @Override
    public String getEventType() {
        return "OrderConfirmed";
    }
    
    // Getters...
    public OrderId getOrderId() { return orderId; }
    public CustomerId getCustomerId() { return customerId; }
    public Money getTotalAmount() { return totalAmount; }
    public LocalDateTime getConfirmedAt() { return confirmedAt; }
}

// 領域事件發布者
@Component
public class DomainEventPublisher {
    private final ApplicationEventPublisher eventPublisher;
    
    public DomainEventPublisher(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
    
    public void publish(DomainEvent event) {
        eventPublisher.publishEvent(event);
    }
    
    public void publishAll(List<DomainEvent> events) {
        events.forEach(this::publish);
    }
}

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

// 修改後的訂單聚合
public class Order extends AggregateRoot {
    // ... 其他屬性和方法
    
    public void confirm() {
        if (status != OrderStatus.PENDING) {
            throw new IllegalStateException("只有待處理訂單可以確認");
        }
        
        this.status = OrderStatus.CONFIRMED;
        this.confirmedAt = LocalDateTime.now();
        
        // 發布領域事件
        addDomainEvent(new OrderConfirmed(this.orderId, this.customerId, this.totalAmount));
    }
}

// 事件處理器：庫存扣減
@EventHandler
@Component
public class InventoryEventHandler {
    private final InventoryService inventoryService;
    
    @EventListener
    @Async
    @Transactional
    public void handle(OrderConfirmed event) {
        try {
            // 處理庫存扣減
            inventoryService.reserveInventory(event.getOrderId());
            
            // 記錄處理日誌
            log.info("庫存已為訂單 {} 預留", event.getOrderId());
            
        } catch (Exception e) {
            // 發布補償事件
            eventPublisher.publish(new InventoryReservationFailed(
                event.getOrderId(), e.getMessage()
            ));
        }
    }
}

// 事件處理器：通知客戶
@EventHandler
@Component
public class NotificationEventHandler {
    private final NotificationService notificationService;
    
    @EventListener
    @Async
    public void handle(OrderConfirmed event) {
        CustomerNotification notification = CustomerNotification.builder()
            .customerId(event.getCustomerId())
            .type(NotificationType.ORDER_CONFIRMED)
            .message("您的訂單 " + event.getOrderId() + " 已確認")
            .build();
            
        notificationService.send(notification);
    }
}

// 事件儲存介面
public interface EventStore {
    void saveEvents(String aggregateId, List<DomainEvent> events, int expectedVersion);
    List<DomainEvent> getEventsForAggregate(String aggregateId);
    List<DomainEvent> getEventsForAggregate(String aggregateId, int fromVersion);
}

// 支援 Event Sourcing 的聚合根
public abstract class EventSourcedAggregateRoot extends AggregateRoot {
    private int version = 0;
    
    public int getVersion() { return version; }
    
    // 從事件重建聚合狀態
    public void loadFromHistory(List<DomainEvent> events) {
        for (DomainEvent event : events) {
            applyEvent(event, false);
        }
    }
    
    // 應用事件並選擇性記錄
    protected void applyEvent(DomainEvent event, boolean isNew) {
        applyEventToState(event);
        if (isNew) {
            addDomainEvent(event);
        }
        version++;
    }
    
    // 子類實作具體的事件應用邏輯
    protected abstract void applyEventToState(DomainEvent event);
}

// Event Sourcing 版本的帳戶聚合
public class Account extends EventSourcedAggregateRoot {
    private AccountId accountId;
    private Money balance;
    private AccountStatus status;
    
    // 建立新帳戶
    public static Account create(AccountId accountId, Money initialBalance) {
        Account account = new Account();
        account.applyEvent(new AccountCreated(accountId, initialBalance), true);
        return account;
    }
    
    // 存款
    public void deposit(Money amount) {
        if (status != AccountStatus.ACTIVE) {
            throw new IllegalStateException("帳戶未啟用");
        }
        applyEvent(new MoneyDeposited(accountId, amount), true);
    }
    
    // 提款
    public void withdraw(Money amount) {
        if (status != AccountStatus.ACTIVE) {
            throw new IllegalStateException("帳戶未啟用");
        }
        if (balance.isLessThan(amount)) {
            throw new InsufficientFundsException("餘額不足");
        }
        applyEvent(new MoneyWithdrawn(accountId, amount), true);
    }
    
    @Override
    protected void applyEventToState(DomainEvent event) {
        switch (event.getEventType()) {
            case "AccountCreated":
                AccountCreated created = (AccountCreated) event;
                this.accountId = created.getAccountId();
                this.balance = created.getInitialBalance();
                this.status = AccountStatus.ACTIVE;
                break;
                
            case "MoneyDeposited":
                MoneyDeposited deposited = (MoneyDeposited) event;
                this.balance = this.balance.add(deposited.getAmount());
                break;
                
            case "MoneyWithdrawn":
                MoneyWithdrawn withdrawn = (MoneyWithdrawn) event;
                this.balance = this.balance.subtract(withdrawn.getAmount());
                break;
                
            default:
                throw new IllegalArgumentException("未知的事件類型: " + event.getEventType());
        }
    }
}

// 命令處理器
@Component
public class OrderCommandHandler {
    private final OrderRepository orderRepository;
    private final EventStore eventStore;
    
    @CommandHandler
    public OrderId handle(CreateOrderCommand command) {
        // 驗證命令
        validateCommand(command);
        
        // 建立聚合
        Order order = Order.create(
            command.getCustomerId(),
            command.getItems(),
            command.getShippingAddress()
        );
        
        // 儲存事件
        eventStore.saveEvents(
            order.getOrderId().toString(),
            order.getDomainEvents(),
            0
        );
        
        return order.getOrderId();
    }
    
    @CommandHandler
    public void handle(ConfirmOrderCommand command) {
        // 載入聚合
        List<DomainEvent> events = eventStore.getEventsForAggregate(
            command.getOrderId().toString()
        );
        
        Order order = new Order();
        order.loadFromHistory(events);
        
        // 執行業務邏輯
        order.confirm();
        
        // 儲存新事件
        eventStore.saveEvents(
            command.getOrderId().toString(),
            order.getDomainEvents(),
            order.getVersion()
        );
    }
}

// 查詢處理器
@Component
public class OrderQueryHandler {
    private final OrderReadModelRepository readModelRepository;
    
    @QueryHandler
    public OrderSummary handle(GetOrderSummaryQuery query) {
        return readModelRepository.findOrderSummary(query.getOrderId());
    }
    
    @QueryHandler
    public List<OrderListItem> handle(GetCustomerOrdersQuery query) {
        return readModelRepository.findOrdersByCustomer(
            query.getCustomerId(),
            query.getPageable()
        );
    }
}

// 讀取模型投影器
@Component
public class OrderProjectionEventHandler {
    private final OrderReadModelRepository readModelRepository;
    
    @EventHandler
    public void on(OrderCreated event) {
        OrderSummary summary = new OrderSummary(
            event.getOrderId(),
            event.getCustomerId(),
            event.getTotalAmount(),
            OrderStatus.PENDING,
            event.getOccurredOn()
        );
        
        readModelRepository.save(summary);
    }
    
    @EventHandler
    public void on(OrderConfirmed event) {
        OrderSummary summary = readModelRepository.findById(event.getOrderId());
        summary.updateStatus(OrderStatus.CONFIRMED);
        summary.setConfirmedAt(event.getOccurredOn());
        
        readModelRepository.save(summary);
    }
}

// 端口（介面）- 位於領域層
public interface PaymentPort {
    PaymentResult processPayment(PaymentRequest request);
    PaymentStatus getPaymentStatus(PaymentId paymentId);
    void refundPayment(PaymentId paymentId, Money amount);
}

// 適配器（實作）- 位於基礎設施層
@Component
public class StripePaymentAdapter implements PaymentPort {
    private final StripeApiClient stripeClient;
    
    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        try {
            // 轉換為 Stripe API 格式
            ChargeRequest chargeRequest = StripeChargeRequest.builder()
                .amount(request.getAmount().getAmount())
                .currency(request.getAmount().getCurrency().getCurrencyCode())
                .source(request.getPaymentMethod().getToken())
                .build();
            
            // 呼叫 Stripe API
            Charge charge = stripeClient.createCharge(chargeRequest);
            
            // 轉換回領域模型
            return PaymentResult.success(
                PaymentId.from(charge.getId()),
                Money.of(charge.getAmount(), charge.getCurrency())
            );
            
        } catch (StripeException e) {
            return PaymentResult.failure(e.getMessage());
        }
    }
}

// 應用服務使用端口
@ApplicationService
public class OrderPaymentService {
    private final PaymentPort paymentPort;
    private final OrderRepository orderRepository;
    
    @Transactional
    public void processOrderPayment(ProcessPaymentCommand command) {
        // 載入訂單聚合
        Order order = orderRepository.findById(command.getOrderId())
            .orElseThrow(() -> new OrderNotFoundException());
        
        // 建立支付請求
        PaymentRequest paymentRequest = PaymentRequest.builder()
            .amount(order.getTotalAmount())
            .paymentMethod(command.getPaymentMethod())
            .orderId(order.getOrderId())
            .build();
        
        // 通過端口處理支付
        PaymentResult result = paymentPort.processPayment(paymentRequest);
        
        if (result.isSuccess()) {
            order.markAsPaid(result.getPaymentId());
        } else {
            order.markPaymentFailed(result.getErrorMessage());
        }
        
        orderRepository.save(order);
    }
}

// 實體層（Enterprise Business Rules）
public class Customer {
    private CustomerId id;
    private String name;
    private Email email;
    private CustomerType type;
    
    // 企業級業務規則
    public boolean canReceiveDiscount(DiscountType discountType) {
        return switch (this.type) {
            case PREMIUM -> true;
            case REGULAR -> discountType != DiscountType.PREMIUM_ONLY;
            case TRIAL -> discountType == DiscountType.TRIAL_WELCOME;
        };
    }
}

// 用例層（Application Business Rules）
@UseCase
public class CreateCustomerUseCase {
    private final CustomerRepository customerRepository;
    private final EmailService emailService;
    
    public CustomerId execute(CreateCustomerRequest request) {
        // 驗證業務規則
        validateUniqueEmail(request.getEmail());
        
        // 建立實體
        Customer customer = Customer.create(
            request.getName(),
            request.getEmail(),
            request.getCustomerType()
        );
        
        // 儲存
        customerRepository.save(customer);
        
        // 發送歡迎郵件
        emailService.sendWelcomeEmail(customer);
        
        return customer.getId();
    }
    
    private void validateUniqueEmail(Email email) {
        if (customerRepository.existsByEmail(email)) {
            throw new EmailAlreadyExistsException(email);
        }
    }
}

// 介面適配器層（Interface Adapters）
@RestController
@RequestMapping("/api/customers")
public class CustomerController {
    private final CreateCustomerUseCase createCustomerUseCase;
    
    @PostMapping
    public ResponseEntity<CustomerResponse> createCustomer(
            @RequestBody @Valid CreateCustomerDto dto) {
        
        // 轉換 DTO 為請求物件
        CreateCustomerRequest request = CreateCustomerRequest.builder()
            .name(dto.getName())
            .email(Email.of(dto.getEmail()))
            .customerType(CustomerType.valueOf(dto.getType()))
            .build();
        
        // 執行用例
        CustomerId customerId = createCustomerUseCase.execute(request);
        
        // 轉換為回應 DTO
        CustomerResponse response = CustomerResponse.builder()
            .id(customerId.getValue())
            .message("客戶建立成功")
            .build();
        
        return ResponseEntity.status(HttpStatus.CREATED).body(response);
    }
}

// 同步通訊：客戶查詢 API
@FeignClient(name = "customer-service")
public interface CustomerServiceClient {
    @GetMapping("/customers/{customerId}")
    CustomerInfo getCustomer(@PathVariable("customerId") String customerId);
    
    @GetMapping("/customers/{customerId}/credit-score")
    CreditScore getCreditScore(@PathVariable("customerId") String customerId);
}

// 非同步通訊：事件發布
@Component
public class OrderEventPublisher {
    private final RabbitTemplate rabbitTemplate;
    
    public void publishOrderConfirmed(OrderConfirmed event) {
        rabbitTemplate.convertAndSend(
            "order.exchange",
            "order.confirmed",
            event
        );
    }
}

// 事件監聽：庫存服務
@RabbitListener(queues = "inventory.order.confirmed")
@Component
public class InventoryOrderEventHandler {
    private final InventoryService inventoryService;
    
    public void handleOrderConfirmed(OrderConfirmed event) {
        try {
            inventoryService.reserveItems(
                event.getOrderId(),
                event.getOrderItems()
            );
            
            // 發布庫存預留成功事件
            publishInventoryReserved(event.getOrderId());
            
        } catch (InsufficientInventoryException e) {
            // 發布庫存不足事件
            publishInventoryInsufficient(event.getOrderId(), e.getMessage());
        }
    }
}

// Saga 協調器
@Component
public class OrderProcessingSaga {
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    private final ShippingService shippingService;
    
    @SagaOrchestrationStart
    public void handle(OrderConfirmed event) {
        SagaLifeCycle.associateWith("orderId", event.getOrderId().toString());
        
        // 步驟 1：處理支付
        paymentService.processPayment(new ProcessPaymentCommand(
            event.getOrderId(),
            event.getTotalAmount(),
            event.getPaymentMethod()
        ));
    }
    
    @SagaHandler
    public void handle(PaymentProcessed event) {
        // 步驟 2：預留庫存
        inventoryService.reserveInventory(new ReserveInventoryCommand(
            event.getOrderId(),
            event.getOrderItems()
        ));
    }
    
    @SagaHandler
    public void handle(InventoryReserved event) {
        // 步驟 3：安排配送
        shippingService.scheduleShipping(new ScheduleShippingCommand(
            event.getOrderId(),
            event.getShippingAddress()
        ));
    }
    
    // 補償操作
    @SagaHandler
    public void handle(PaymentFailed event) {
        // 取消訂單
        orderService.cancelOrder(event.getOrderId(), "支付失敗");
    }
    
    @SagaHandler
    public void handle(InventoryReservationFailed event) {
        // 退款
        paymentService.refundPayment(event.getOrderId());
        orderService.cancelOrder(event.getOrderId(), "庫存不足");
    }
}

// Event Storming 結果文檔化
@EventStormingResult
public class OrderProcessingDomain {
    
    // 識別出的核心事件
    public enum DomainEvents {
        PRODUCT_ADDED_TO_CART("產品加入購物車"),
        ORDER_PLACED("訂單建立"),
        PAYMENT_PROCESSED("支付處理"),
        INVENTORY_RESERVED("庫存預留"),
        ORDER_SHIPPED("訂單出貨"),
        ORDER_DELIVERED("訂單送達");
        
        private final String description;
        DomainEvents(String description) { this.description = description; }
    }
    
    // 識別出的命令
    public enum Commands {
        ADD_PRODUCT_TO_CART("AddProductToCart"),
        PLACE_ORDER("PlaceOrder"),
        PROCESS_PAYMENT("ProcessPayment"),
        RESERVE_INVENTORY("ReserveInventory"),
        SHIP_ORDER("ShipOrder");
        
        private final String commandName;
        Commands(String commandName) { this.commandName = commandName; }
    }
    
    // 識別出的聚合
    public enum Aggregates {
        SHOPPING_CART("購物車"),
        ORDER("訂單"),
        INVENTORY("庫存"),
        PAYMENT("支付");
        
        private final String aggregateName;
        Aggregates(String aggregateName) { this.aggregateName = aggregateName; }
    }
}

// 從 Domain Story 到程式碼
@DomainStory("客戶購買產品的完整流程")
public class CustomerPurchaseStory {
    
    @StoryStep(order = 1, actor = "客戶", action = "瀏覽產品")
    public List<Product> browseProducts(CategoryId categoryId) {
        return productCatalog.findProductsByCategory(categoryId);
    }
    
    @StoryStep(order = 2, actor = "客戶", action = "加入購物車")
    public void addToCart(CustomerId customerId, ProductId productId, int quantity) {
        ShoppingCart cart = cartRepository.findByCustomerId(customerId);
        cart.addProduct(productId, quantity);
        cartRepository.save(cart);
    }
    
    @StoryStep(order = 3, actor = "客戶", action = "結帳")
    public OrderId checkout(CustomerId customerId, ShippingAddress address) {
        ShoppingCart cart = cartRepository.findByCustomerId(customerId);
        Order order = orderService.createOrderFromCart(cart, address);
        return order.getOrderId();
    }
    
    @StoryStep(order = 4, actor = "系統", action = "處理支付")
    public PaymentResult processPayment(OrderId orderId, PaymentMethod method) {
        Order order = orderRepository.findById(orderId);
        return paymentService.processPayment(order.getTotalAmount(), method);
    }
}

# 用戶故事卡範本
story_template:
  title: "作為 [角色]，我想要 [功能]，以便 [價值]"
  acceptance_criteria:
    - "給定 [前置條件]"
    - "當 [觸發事件]"
    - "那麼 [預期結果]"
  
  ddd_considerations:
    bounded_context: "所屬的限界上下文"
    domain_events: "觸發的領域事件列表"
    business_rules: "涉及的業務規則"
    aggregates: "需要修改的聚合"

# 實際範例
user_story_example:
  title: "作為客戶，我想要確認我的訂單，以便開始準備配送"
  acceptance_criteria:
    - "給定我有一個處於待確認狀態的訂單"

---

# 第五篇：學習檢測與認證準備

## 14. 章節小測驗

### 14.1 第一篇：基礎入門 - 測驗題

#### 📝 單選題

**題目 1:** DDD 的核心關注點是什麼？
A) 技術架構設計
B) 資料庫效能優化
C) 複雜業務領域的建模
D) 用戶介面設計

<details>
<summary>答案與解析</summary>

**正確答案：C**

**解析：** DDD (Domain-Driven Design) 的核心關注點是複雜業務領域的建模。DDD 強調通過深入理解業務領域，建立準確反映業務邏輯的領域模型，而不是單純關注技術實作。

</details>

**題目 2:** 通用語言 (Ubiquitous Language) 的主要目的是什麼？
A) 標準化程式碼命名規範
B) 確保團隊對業務概念有一致理解
C) 簡化技術文檔撰寫
D) 提高程式碼執行效率

<details>
<summary>答案與解析</summary>

**正確答案：B**

**解析：** 通用語言的目的是確保開發團隊、業務專家、利害關係人之間對業務概念有一致的理解，避免溝通誤解，讓所有參與者都能用同樣的術語討論業務問題。

</details>

### 14.2 第二篇：戰略設計 - 測驗題

#### 📝 單選題

**題目 3:** 以下哪個最符合核心領域 (Core Domain) 的特徵？
A) 有現成的市場解決方案
B) 跨行業的共通需求
C) 組織的競爭優勢所在
D) 技術複雜度相對較低

<details>
<summary>答案與解析</summary>

**正確答案：C**

**解析：** 核心領域是組織競爭優勢的來源，具有獨特性和高業務價值。選項 A 和 B 更像是通用子域的特徵，選項 D 不是核心領域的必要特徵。

</details>

### 14.3 第三篇：戰術設計 - 測驗題

#### 📝 程式碼分析題

**題目 4:** 以下程式碼有什麼問題？請識別並說明如何改善。

```java
public class Order {
    public String id;
    public String customerId;
    public List<String> productIds;
    public double totalAmount;
    public String status;
    
    // 所有屬性都是 public，只有 getter/setter
}

public class OrderService {
    public void processOrder(Order order) {
        // 計算總金額
        double total = 0;
        for (String productId : order.productIds) {
            Product product = productRepository.findById(productId);
            total += product.getPrice();
        }
        order.totalAmount = total;
        
        // 改變狀態
        order.status = "CONFIRMED";
    }
}

---

## 13. 專案最佳實踐

### 13.1 常見錯誤與反模式

#### ❌ 常見的 DDD 反模式

1. **貧血模型 (Anemic Domain Model)**
```java
// 錯誤示範：貧血模型
public class Order {
    private OrderId id;
    private List<OrderItem> items;
    private Money total;
    private OrderStatus status;
    
    // 只有 getter/setter，沒有業務邏輯
    public OrderId getId() { return id; }
    public void setId(OrderId id) { this.id = id; }
    // ... 其他 getter/setter
}

// 業務邏輯散落在服務中
public class OrderService {
    public void confirmOrder(Order order) {
        if (order.getStatus() != OrderStatus.PENDING) {
            throw new IllegalStateException("只有待處理訂單可以確認");
        }
        order.setStatus(OrderStatus.CONFIRMED);
        // 計算總額邏輯
        Money total = Money.ZERO;
        for (OrderItem item : order.getItems()) {
            total = total.add(item.getPrice().multiply(item.getQuantity()));
        }
        order.setTotal(total);
    }
}

// 正確示範：豐富的領域模型
public class Order {
    private OrderId id;
    private List<OrderItem> items;
    private Money total;
    private OrderStatus status;
    
    // 業務邏輯封裝在領域物件中
    public void confirm() {
        if (status != OrderStatus.PENDING) {
            throw new IllegalStateException("只有待處理訂單可以確認");
        }
        this.status = OrderStatus.CONFIRMED;
        this.total = calculateTotal();
        addDomainEvent(new OrderConfirmed(this.id));
    }
    
    private Money calculateTotal() {
        return items.stream()
            .map(OrderItem::getSubtotal)
            .reduce(Money.ZERO, Money::add);
    }
}

// 錯誤：聚合過大
public class CustomerAggregate {
    private Customer customer;
    private List<Order> orders;           // 不應該包含在聚合中
    private List<Address> addresses;      // 可能造成聚合過大
    private List<PaymentMethod> paymentMethods;
    private CustomerPreferences preferences;
    private List<SupportTicket> supportTickets; // 不應該包含在聚合中
}

// 正確：適當大小的聚合
public class Customer {
    private CustomerId id;
    private PersonalInfo personalInfo;
    private ContactInfo contactInfo;
    private CustomerStatus status;
    
    // 只包含需要保持一致性的資料
}

// 訂單應該是獨立的聚合
public class Order {
    private OrderId id;
    private CustomerId customerId; // 通過 ID 引用，而非直接引用
    private List<OrderItem> items;
    private OrderStatus status;
}

// 錯誤：跨聚合事務
@Transactional
public void processOrder(OrderId orderId) {
    Order order = orderRepository.findById(orderId);
    Customer customer = customerRepository.findById(order.getCustomerId());
    Inventory inventory = inventoryRepository.findByProducts(order.getProducts());
    
    // 在同一個事務中修改多個聚合
    order.confirm();
    customer.addLoyaltyPoints(order.getTotal());
    inventory.reserveItems(order.getItems());
    
    orderRepository.save(order);
    customerRepository.save(customer);
    inventoryRepository.save(inventory);
}

// 正確：最終一致性處理
@Transactional
public void confirmOrder(OrderId orderId) {
    Order order = orderRepository.findById(orderId);
    order.confirm(); // 只修改單一聚合
    orderRepository.save(order);
    
    // 透過事件觸發其他聚合的更新
    domainEventPublisher.publish(new OrderConfirmed(order.getId(), order.getTotalAmount()));
}

@EventHandler
public void handleOrderConfirmed(OrderConfirmed event) {
    // 在獨立事務中處理
    customerService.addLoyaltyPoints(event.getCustomerId(), event.getAmount());
    inventoryService.reserveItems(event.getOrderId());
}

subdomain_analysis:
  core_domains:
    - name: "商品推薦引擎"
      investment: "最高優先級，專門團隊"
      competitive_advantage: "個性化推薦算法"
    
    - name: "定價策略系統"
      investment: "高優先級，持續優化"
      competitive_advantage: "動態定價能力"
  
  supporting_subdomains:
    - name: "訂單管理"
      strategy: "內部開發，標準化流程"
    
    - name: "庫存管理"
      strategy: "購買商用軟體並客製化"
  
  generic_subdomains:
    - name: "使用者認證"
      strategy: "採用 OAuth 2.0 + Auth0"
    
    - name: "支付處理"
      strategy: "整合第三方支付服務"

// 商品目錄上下文
@BoundedContext("ProductCatalog")
public class ProductCatalogContext {
    // 專注於商品資訊管理
    private Product product;
    private Category category;
    private ProductSpecification specification;
}

// 訂單處理上下文
@BoundedContext("OrderProcessing")
public class OrderProcessingContext {
    // 專注於訂單生命週期
    private Order order;
    private OrderItem orderItem;
    private ShippingInfo shippingInfo;
}

// 推薦引擎上下文
@BoundedContext("RecommendationEngine")
public class RecommendationEngineContext {
    // 專注於推薦算法
    private UserProfile userProfile;
    private RecommendationModel model;
    private PersonalizedRecommendation recommendation;
}

// 投資組合聚合
public class Portfolio {
    public void rebalance(RebalancingStrategy strategy) {
        List<AssetAllocation> newAllocations = strategy.calculate(this.holdings);
        
        for (AssetAllocation allocation : newAllocations) {
            if (requiresTrading(allocation)) {
                addDomainEvent(new TradingRequired(
                    this.portfolioId,
                    allocation.getAsset(),
                    allocation.getTargetWeight()
                ));
            }
        }
        
        this.lastRebalanced = LocalDateTime.now();
    }
}

// 風險管理事件處理
@EventHandler
public class RiskManagementEventHandler {
    @EventListener
    public void handle(TradingRequired event) {
        RiskAssessment assessment = riskEngine.assessTrade(
            event.getPortfolioId(),
            event.getAsset(),
            event.getTargetWeight()
        );
        
        if (assessment.exceedsRiskLimit()) {
            eventPublisher.publish(new TradingRejected(
                event.getPortfolioId(),
                "超出風險限額"
            ));
        } else {
            eventPublisher.publish(new TradingApproved(
                event.getPortfolioId(),
                event.getAsset(),
                event.getTargetWeight()
            ));
        }
    }
}

// 命令端：交易執行
@CommandHandler
public class TradingCommandHandler {
    public void handle(ExecuteTradeCommand command) {
        Portfolio portfolio = portfolioRepository.findById(command.getPortfolioId());
        Trade trade = portfolio.executeTrade(
            command.getAsset(),
            command.getQuantity(),
            command.getPrice()
        );
        
        tradeRepository.save(trade);
        portfolioRepository.save(portfolio);
    }
}

// 查詢端：投資組合檢視
@QueryHandler
public class PortfolioQueryHandler {
    public PortfolioSummary handle(GetPortfolioSummaryQuery query) {
        return portfolioReadModel.getPortfolioSummary(query.getPortfolioId());
    }
    
    public List<PerformanceMetrics> handle(GetPerformanceHistoryQuery query) {
        return performanceReadModel.getPerformanceHistory(
            query.getPortfolioId(),
            query.getDateRange()
        );
    }
}