// Port - 定義契約
public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(OrderId id);
}

// Adapter - 實作細節
@Repository
public class JpaOrderRepository implements OrderRepository {
    @Override
    public void save(Order order) {
        // JPA 實作細節
    }
    
    @Override
    public Optional<Order> findById(OrderId id) {
        // JPA 查詢邏輯
    }
}

// ❌ 錯誤示範：業務邏輯直接依賴具體實作
public class OrderService {
    private JpaOrderRepository repository; // 直接依賴 JPA
    private SmtpEmailSender emailSender;   // 直接依賴 SMTP
    
    public void createOrder(OrderRequest request) {
        // 業務邏輯與技術細節混合
    }
}

// ✅ 正確示範：業務邏輯只依賴抽象介面
public class OrderService {
    private final OrderRepository repository;     // 依賴抽象
    private final EmailNotification emailSender; // 依賴抽象
    
    public OrderService(OrderRepository repository, 
                       EmailNotification emailSender) {
        this.repository = repository;
        this.emailSender = emailSender;
    }
    
    public void createOrder(OrderRequest request) {
        // 純粹的業務邏輯，不包含技術細節
        Order order = new Order(request);
        repository.save(order);
        emailSender.sendConfirmation(order);
    }
}

@Configuration
public class ApplicationConfig {
    
    @Bean
    public OrderRepository orderRepository() {
        return new JpaOrderRepository(); // 可替換實作
    }
    
    @Bean
    public EmailNotification emailNotification() {
        return new SmtpEmailNotification(); // 可替換實作
    }
    
    @Bean
    public OrderService orderService() {
        return new OrderService(orderRepository(), emailNotification());
    }
}

// 單元測試變得簡單
@Test
public void should_create_order_successfully() {
    // Arrange - 使用 Mock 物件
    OrderRepository mockRepository = mock(OrderRepository.class);
    EmailNotification mockEmail = mock(EmailNotification.class);
    OrderService service = new OrderService(mockRepository, mockEmail);
    
    OrderRequest request = new OrderRequest("產品A", 2);
    
    // Act
    service.createOrder(request);
    
    // Assert
    verify(mockRepository, times(1)).save(any(Order.class));
    verify(mockEmail, times(1)).sendConfirmation(any(Order.class));
}

// Domain Entity - 純粹的業務概念
public class Order {
    private OrderId id;
    private CustomerId customerId;
    private List<OrderItem> items;
    private OrderStatus status;
    private Money totalAmount;
    
    // 業務行為，不包含技術細節
    public void confirm() {
        if (status != OrderStatus.PENDING) {
            throw new IllegalStateException("只有待處理訂單可以確認");
        }
        this.status = OrderStatus.CONFIRMED;
        // 發布領域事件
        DomainEvents.raise(new OrderConfirmedEvent(this.id));
    }
    
    public Money calculateTotal() {
        return items.stream()
                   .map(OrderItem::getSubtotal)
                   .reduce(Money.ZERO, Money::add);
    }
}

// Application Service - 編排業務流程
@UseCase
public class ConfirmOrderUseCase {
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    
    public void execute(ConfirmOrderCommand command) {
        // 1. 載入訂單
        Order order = orderRepository.findById(command.getOrderId())
                                   .orElseThrow(() -> new OrderNotFoundException());
        
        // 2. 檢查庫存
        inventoryService.reserve(order.getItems());
        
        // 3. 處理付款
        paymentService.processPayment(order.getTotalAmount(), command.getPaymentMethod());
        
        // 4. 確認訂單
        order.confirm();
        
        // 5. 儲存變更
        orderRepository.save(order);
    }
}

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository; // Spring Data JPA
    
    @Autowired
    private JavaMailSender mailSender; // Spring Mail
    
    public void createOrder(OrderDTO orderDTO) {
        // 業務邏輯與技術實作混合
        Order order = new Order();
        order.setCustomerId(orderDTO.getCustomerId());
        // ... 設定其他屬性
        
        orderRepository.save(order); // 直接使用 JPA
        
        // 直接使用 JavaMailSender
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(orderDTO.getCustomerEmail());
        message.setSubject("訂單確認");
        mailSender.send(message);
    }
}

// 1. 定義 Port
public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(OrderId id);
}

public interface EmailNotification {
    void sendOrderConfirmation(Order order);
}

// 2. 純粹的業務邏輯
@Component
public class CreateOrderUseCase {
    private final OrderRepository orderRepository;
    private final EmailNotification emailNotification;
    
    public CreateOrderUseCase(OrderRepository orderRepository,
                             EmailNotification emailNotification) {
        this.orderRepository = orderRepository;
        this.emailNotification = emailNotification;
    }
    
    public void execute(CreateOrderCommand command) {
        Order order = Order.create(command);
        orderRepository.save(order);
        emailNotification.sendOrderConfirmation(order);
    }
}

// 3. Adapter 實作
@Repository
public class JpaOrderRepository implements OrderRepository {
    // JPA 實作細節
}

@Component
public class SpringMailNotification implements EmailNotification {
    // Spring Mail 實作細節
}

// 為現有的 Repository 建立介面
public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(Long id);
}

// 將 Service 改為依賴介面而非具體實作
public class OrderService {
    private final OrderRepository orderRepository;
    // 使用建構子注入
}

// 逐步將 Service 層的方法重構為 Use Case
public class CreateOrderUseCase {
    // 專注於單一業務場景
}

// 為不同的外部系統建立對應的 Adapter
public class JpaOrderRepository implements OrderRepository {
    // 技術實作細節
}

// 輸入 Port 範例
public interface OrderManagement {
    OrderResult createOrder(CreateOrderCommand command);
    OrderResult cancelOrder(CancelOrderCommand command);
    OrderDetails getOrderDetails(OrderId orderId);
}

// Use Case 實作輸入 Port
@Component
public class OrderManagementUseCase implements OrderManagement {
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    
    @Override
    public OrderResult createOrder(CreateOrderCommand command) {
        // 業務邏輯實作
        Order order = Order.create(command);
        orderRepository.save(order);
        return OrderResult.success(order);
    }
}

// 輸出 Port 範例
public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(OrderId id);
    List<Order> findByCustomerId(CustomerId customerId);
}

public interface PaymentService {
    PaymentResult processPayment(PaymentRequest request);
    void refund(PaymentId paymentId, Money amount);
}

public interface EmailNotification {
    void sendOrderConfirmation(Order order);
    void sendShippingNotification(Order order, TrackingNumber trackingNumber);
}

// Web Controller 作為主動 Adapter
@RestController
@RequestMapping("/orders")
public class OrderController {
    private final OrderManagement orderManagement;
    
    public OrderController(OrderManagement orderManagement) {
        this.orderManagement = orderManagement;
    }
    
    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(@RequestBody CreateOrderRequest request) {
        // 將 HTTP 請求轉換為 Command
        CreateOrderCommand command = CreateOrderCommand.builder()
            .customerId(request.getCustomerId())
            .items(request.getItems())
            .build();
        
        // 呼叫輸入 Port
        OrderResult result = orderManagement.createOrder(command);
        
        // 將結果轉換為 HTTP 回應
        return ResponseEntity.ok(OrderResponse.from(result));
    }
}

// CLI Handler 作為另一種主動 Adapter
@Component
public class OrderCliHandler {
    private final OrderManagement orderManagement;
    
    @ShellMethod("Create a new order")
    public String createOrder(@ShellOption String customerId, 
                             @ShellOption String items) {
        CreateOrderCommand command = parseCommand(customerId, items);
        OrderResult result = orderManagement.createOrder(command);
        return formatResult(result);
    }
}

// JPA Repository 作為被動 Adapter
@Repository
public class JpaOrderRepository implements OrderRepository {
    private final SpringDataOrderRepository springRepository;
    
    @Override
    public void save(Order order) {
        OrderEntity entity = OrderEntity.from(order);
        springRepository.save(entity);
    }
    
    @Override
    public Optional<Order> findById(OrderId id) {
        return springRepository.findById(id.getValue())
            .map(OrderEntity::toDomain);
    }
}

// Email Service 作為被動 Adapter
@Component
public class SmtpEmailNotification implements EmailNotification {
    private final JavaMailSender mailSender;
    private final EmailTemplateService templateService;
    
    @Override
    public void sendOrderConfirmation(Order order) {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message);
        
        String content = templateService.generateOrderConfirmation(order);
        helper.setTo(order.getCustomerEmail());
        helper.setSubject("訂單確認 - " + order.getId());
        helper.setText(content, true);
        
        mailSender.send(message);
    }
}

// 1. 輸入 Port 定義
public interface OrderProcessing {
    ProcessOrderResult processOrder(ProcessOrderCommand command);
}

// 2. 輸出 Port 定義
public interface InventoryService {
    boolean checkAvailability(ProductId productId, int quantity);
    void reserveInventory(List<OrderItem> items);
}

public interface PaymentGateway {
    PaymentResult charge(CreditCard creditCard, Money amount);
}

// 3. Use Case 實作（應用程式核心）
@Component
public class ProcessOrderUseCase implements OrderProcessing {
    private final OrderRepository orderRepository;
    private final InventoryService inventoryService;
    private final PaymentGateway paymentGateway;
    private final EmailNotification emailNotification;
    
    @Override
    @Transactional
    public ProcessOrderResult processOrder(ProcessOrderCommand command) {
        // 1. 建立訂單領域物件
        Order order = Order.create(command);
        
        // 2. 檢查庫存
        for (OrderItem item : order.getItems()) {
            if (!inventoryService.checkAvailability(item.getProductId(), item.getQuantity())) {
                return ProcessOrderResult.failed("庫存不足: " + item.getProductId());
            }
        }
        
        // 3. 處理付款
        PaymentResult paymentResult = paymentGateway.charge(
            command.getCreditCard(), 
            order.getTotalAmount()
        );
        
        if (!paymentResult.isSuccess()) {
            return ProcessOrderResult.failed("付款失敗: " + paymentResult.getErrorMessage());
        }
        
        // 4. 預留庫存
        inventoryService.reserveInventory(order.getItems());
        
        // 5. 儲存訂單
        orderRepository.save(order);
        
        // 6. 發送確認信
        emailNotification.sendOrderConfirmation(order);
        
        return ProcessOrderResult.success(order);
    }
}

// 4. 主動 Adapter 實作
@RestController
public class OrderWebAdapter {
    private final OrderProcessing orderProcessing;
    
    @PostMapping("/api/orders")
    public ResponseEntity<OrderResponse> createOrder(@RequestBody OrderRequest request) {
        ProcessOrderCommand command = ProcessOrderCommand.builder()
            .customerId(CustomerId.of(request.getCustomerId()))
            .items(mapToOrderItems(request.getItems()))
            .creditCard(CreditCard.of(request.getCreditCard()))
            .build();
            
        ProcessOrderResult result = orderProcessing.processOrder(command);
        
        if (result.isSuccess()) {
            return ResponseEntity.ok(OrderResponse.from(result.getOrder()));
        } else {
            return ResponseEntity.badRequest()
                .body(OrderResponse.error(result.getErrorMessage()));
        }
    }
}

// 5. 被動 Adapter 實作
@Component
public class RestInventoryService implements InventoryService {
    private final WebClient webClient;
    
    @Override
    public boolean checkAvailability(ProductId productId, int quantity) {
        InventoryResponse response = webClient
            .get()
            .uri("/inventory/{productId}", productId.getValue())
            .retrieve()
            .bodyToMono(InventoryResponse.class)
            .block();
            
        return response.getAvailableQuantity() >= quantity;
    }
    
    @Override
    public void reserveInventory(List<OrderItem> items) {
        ReserveInventoryRequest request = ReserveInventoryRequest.from(items);
        webClient
            .post()
            .uri("/inventory/reserve")
            .bodyValue(request)
            .retrieve()
            .bodyToMono(Void.class)
            .block();
    }
}

@Configuration
public class HexagonalConfiguration {
    
    // 輸出 Port 的實作配置
    @Bean
    public OrderRepository orderRepository() {
        return new JpaOrderRepository();
    }
    
    @Bean
    public InventoryService inventoryService() {
        return new RestInventoryService();
    }
    
    @Bean
    public PaymentGateway paymentGateway() {
        return new StripePaymentGateway();
    }
    
    @Bean
    public EmailNotification emailNotification() {
        return new SmtpEmailNotification();
    }
    
    // 輸入 Port 的實作配置
    @Bean
    public OrderProcessing orderProcessing(
            OrderRepository orderRepository,
            InventoryService inventoryService,
            PaymentGateway paymentGateway,
            EmailNotification emailNotification) {
        return new ProcessOrderUseCase(
            orderRepository, 
            inventoryService, 
            paymentGateway, 
            emailNotification
        );
    }
}

// Order Entity 範例
public class Order {
    private final OrderId id;
    private final CustomerId customerId;
    private final List<OrderItem> items;
    private OrderStatus status;
    private final LocalDateTime createdAt;
    private LocalDateTime confirmedAt;
    
    // 建構子 - 確保物件創建時的完整性
    public Order(OrderId id, CustomerId customerId, List<OrderItem> items) {
        this.id = Objects.requireNonNull(id, "訂單ID不能為空");
        this.customerId = Objects.requireNonNull(customerId, "客戶ID不能為空");
        this.items = validateAndCopyItems(items);
        this.status = OrderStatus.PENDING;
        this.createdAt = LocalDateTime.now();
    }
    
    // 業務行為 - 確認訂單
    public void confirm() {
        if (this.status != OrderStatus.PENDING) {
            throw new IllegalOrderStateException("只有待處理的訂單可以確認");
        }
        
        if (this.items.isEmpty()) {
            throw new EmptyOrderException("空訂單無法確認");
        }
        
        this.status = OrderStatus.CONFIRMED;
        this.confirmedAt = LocalDateTime.now();
        
        // 發布領域事件
        DomainEvents.publish(new OrderConfirmedEvent(this.id, this.customerId));
    }
    
    // 業務行為 - 取消訂單
    public void cancel(String reason) {
        if (this.status == OrderStatus.SHIPPED || this.status == OrderStatus.DELIVERED) {
            throw new IllegalOrderStateException("已出貨或已送達的訂單無法取消");
        }
        
        this.status = OrderStatus.CANCELLED;
        
        // 發布領域事件
        DomainEvents.publish(new OrderCancelledEvent(this.id, reason));
    }
    
    // 業務計算 - 計算總金額
    public Money calculateTotal() {
        return items.stream()
                   .map(OrderItem::getSubtotal)
                   .reduce(Money.ZERO, Money::add);
    }
    
    // 業務查詢 - 檢查是否可以修改
    public boolean canBeModified() {
        return status == OrderStatus.PENDING;
    }
    
    // 不變性保護
    public List<OrderItem> getItems() {
        return Collections.unmodifiableList(items);
    }
    
    // 私有輔助方法
    private List<OrderItem> validateAndCopyItems(List<OrderItem> items) {
        if (items == null || items.isEmpty()) {
            throw new IllegalArgumentException("訂單至少要有一個項目");
        }
        return new ArrayList<>(items);
    }
}

// Money Value Object 範例
public final class Money {
    public static final Money ZERO = new Money(BigDecimal.ZERO, Currency.getInstance("TWD"));
    
    private final BigDecimal amount;
    private final Currency currency;
    
    public Money(BigDecimal amount, Currency currency) {
        this.amount = Objects.requireNonNull(amount, "金額不能為空");
        this.currency = Objects.requireNonNull(currency, "幣別不能為空");
        
        if (amount.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("金額不能為負數");
        }
    }
    
    // 業務行為 - 加法
    public Money add(Money other) {
        validateSameCurrency(other);
        return new Money(this.amount.add(other.amount), this.currency);
    }
    
    // 業務行為 - 減法
    public Money subtract(Money other) {
        validateSameCurrency(other);
        BigDecimal result = this.amount.subtract(other.amount);
        if (result.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("計算結果不能為負數");
        }
        return new Money(result, this.currency);
    }
    
    // 業務行為 - 乘法
    public Money multiply(int multiplier) {
        if (multiplier < 0) {
            throw new IllegalArgumentException("乘數不能為負數");
        }
        return new Money(this.amount.multiply(BigDecimal.valueOf(multiplier)), this.currency);
    }
    
    // 業務查詢 - 比較
    public boolean isGreaterThan(Money other) {
        validateSameCurrency(other);
        return this.amount.compareTo(other.amount) > 0;
    }
    
    public boolean isZero() {
        return this.amount.compareTo(BigDecimal.ZERO) == 0;
    }
    
    // Value Object 的相等性比較
    @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 currency.getSymbol() + " " + amount.toPlainString();
    }
    
    private void validateSameCurrency(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("不同幣別無法運算");
        }
    }
}

// OrderId Value Object 範例
public final class OrderId {
    private final String value;
    
    private OrderId(String value) {
        this.value = Objects.requireNonNull(value, "訂單ID不能為空");
        if (value.trim().isEmpty()) {
            throw new IllegalArgumentException("訂單ID不能為空字串");
        }
    }
    
    public static OrderId of(String value) {
        return new OrderId(value);
    }
    
    public static OrderId generate() {
        return new OrderId("ORD-" + UUID.randomUUID().toString());
    }
    
    public String getValue() {
        return value;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        OrderId orderId = (OrderId) obj;
        return Objects.equals(value, orderId.value);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
    
    @Override
    public String toString() {
        return value;
    }
}

// Create Order Use Case 範例
@Component
public class CreateOrderUseCase {
    private final OrderRepository orderRepository;
    private final CustomerRepository customerRepository;
    private final ProductCatalog productCatalog;
    private final InventoryService inventoryService;
    private final EventPublisher eventPublisher;
    
    public CreateOrderUseCase(OrderRepository orderRepository,
                             CustomerRepository customerRepository,
                             ProductCatalog productCatalog,
                             InventoryService inventoryService,
                             EventPublisher eventPublisher) {
        this.orderRepository = orderRepository;
        this.customerRepository = customerRepository;
        this.productCatalog = productCatalog;
        this.inventoryService = inventoryService;
        this.eventPublisher = eventPublisher;
    }
    
    @Transactional
    public CreateOrderResult execute(CreateOrderCommand command) {
        try {
            // 1. 驗證客戶存在
            Customer customer = customerRepository.findById(command.getCustomerId())
                .orElseThrow(() -> new CustomerNotFoundException(command.getCustomerId()));
            
            // 2. 驗證產品存在並取得價格
            List<OrderItem> validatedItems = validateAndBuildOrderItems(command.getItems());
            
            // 3. 檢查庫存
            checkInventoryAvailability(validatedItems);
            
            // 4. 建立訂單領域物件
            OrderId orderId = OrderId.generate();
            Order order = new Order(orderId, customer.getId(), validatedItems);
            
            // 5. 應用業務規則
            customer.validateCanPlaceOrder(); // 客戶狀態檢查
            
            // 6. 儲存訂單
            orderRepository.save(order);
            
            // 7. 發布事件
            eventPublisher.publish(new OrderCreatedEvent(order.getId(), order.getCustomerId()));
            
            return CreateOrderResult.success(order);
            
        } catch (DomainException e) {
            return CreateOrderResult.failed(e.getMessage());
        }
    }
    
    private List<OrderItem> validateAndBuildOrderItems(List<OrderItemRequest> requests) {
        return requests.stream()
            .map(this::buildOrderItem)
            .collect(Collectors.toList());
    }
    
    private OrderItem buildOrderItem(OrderItemRequest request) {
        Product product = productCatalog.findById(request.getProductId())
            .orElseThrow(() -> new ProductNotFoundException(request.getProductId()));
        
        return new OrderItem(
            product.getId(),
            product.getName(),
            request.getQuantity(),
            product.getPrice()
        );
    }
    
    private void checkInventoryAvailability(List<OrderItem> items) {
        for (OrderItem item : items) {
            if (!inventoryService.isAvailable(item.getProductId(), item.getQuantity())) {
                throw new InsufficientInventoryException(item.getProductId());
            }
        }
    }
}

// Command 物件 - 封裝輸入參數
public class CreateOrderCommand {
    private final CustomerId customerId;
    private final List<OrderItemRequest> items;
    private final ShippingAddress shippingAddress;
    
    // 使用 Builder 模式確保物件完整性
    public static Builder builder() {
        return new Builder();
    }
    
    public static class Builder {
        private CustomerId customerId;
        private List<OrderItemRequest> items = new ArrayList<>();
        private ShippingAddress shippingAddress;
        
        public Builder customerId(CustomerId customerId) {
            this.customerId = customerId;
            return this;
        }
        
        public Builder addItem(ProductId productId, int quantity) {
            this.items.add(new OrderItemRequest(productId, quantity));
            return this;
        }
        
        public Builder shippingAddress(ShippingAddress address) {
            this.shippingAddress = address;
            return this;
        }
        
        public CreateOrderCommand build() {
            validateCommand();
            return new CreateOrderCommand(customerId, items, shippingAddress);
        }
        
        private void validateCommand() {
            if (customerId == null) {
                throw new IllegalArgumentException("客戶ID為必填");
            }
            if (items.isEmpty()) {
                throw new IllegalArgumentException("訂單至少要有一個項目");
            }
            if (shippingAddress == null) {
                throw new IllegalArgumentException("配送地址為必填");
            }
        }
    }
}

// Result 物件 - 封裝輸出結果
public class CreateOrderResult {
    private final boolean success;
    private final Order order;
    private final String errorMessage;
    
    private CreateOrderResult(boolean success, Order order, String errorMessage) {
        this.success = success;
        this.order = order;
        this.errorMessage = errorMessage;
    }
    
    public static CreateOrderResult success(Order order) {
        return new CreateOrderResult(true, order, null);
    }
    
    public static CreateOrderResult failed(String errorMessage) {
        return new CreateOrderResult(false, null, errorMessage);
    }
    
    // Getters...
}

// 定價服務 - Domain Service 範例
@Component
public class OrderPricingService {
    private final PromotionRepository promotionRepository;
    private final CustomerTierService customerTierService;
    
    public OrderPricingService(PromotionRepository promotionRepository,
                              CustomerTierService customerTierService) {
        this.promotionRepository = promotionRepository;
        this.customerTierService = customerTierService;
    }
    
    public PricingResult calculateOrderPrice(Order order, Customer customer) {
        Money subtotal = order.calculateSubtotal();
        
        // 1. 計算會員折扣
        CustomerTier tier = customerTierService.getTier(customer);
        Money memberDiscount = calculateMemberDiscount(subtotal, tier);
        
        // 2. 計算促銷折扣
        List<Promotion> applicablePromotions = findApplicablePromotions(order, customer);
        Money promotionDiscount = calculateBestPromotionDiscount(order, applicablePromotions);
        
        // 3. 計算運費
        Money shippingFee = calculateShippingFee(order, customer);
        
        // 4. 計算稅額
        Money tax = calculateTax(subtotal.subtract(memberDiscount).subtract(promotionDiscount));
        
        // 5. 計算最終總額
        Money total = subtotal
            .subtract(memberDiscount)
            .subtract(promotionDiscount)
            .add(shippingFee)
            .add(tax);
        
        return PricingResult.builder()
            .subtotal(subtotal)
            .memberDiscount(memberDiscount)
            .promotionDiscount(promotionDiscount)
            .shippingFee(shippingFee)
            .tax(tax)
            .total(total)
            .build();
    }
    
    private Money calculateMemberDiscount(Money subtotal, CustomerTier tier) {
        BigDecimal discountRate = tier.getDiscountRate();
        return new Money(
            subtotal.getAmount().multiply(discountRate),
            subtotal.getCurrency()
        );
    }
    
    private List<Promotion> findApplicablePromotions(Order order, Customer customer) {
        return promotionRepository.findActivePromotions().stream()
            .filter(promotion -> promotion.isApplicableTo(order, customer))
            .collect(Collectors.toList());
    }
    
    private Money calculateBestPromotionDiscount(Order order, List<Promotion> promotions) {
        return promotions.stream()
            .map(promotion -> promotion.calculateDiscount(order))
            .max(Money::compareTo)
            .orElse(Money.ZERO);
    }
    
    private Money calculateShippingFee(Order order, Customer customer) {
        // 運費計算邏輯
        if (order.qualifiesForFreeShipping()) {
            return Money.ZERO;
        }
        
        ShippingZone zone = customer.getShippingAddress().getZone();
        return zone.getShippingFee(order.getTotalWeight());
    }
    
    private Money calculateTax(Money taxableAmount) {
        BigDecimal taxRate = new BigDecimal("0.05"); // 5% 稅率
        return new Money(
            taxableAmount.getAmount().multiply(taxRate),
            taxableAmount.getCurrency()
        );
    }
}

// 庫存分配服務 - 另一個 Domain Service 範例
@Component
public class InventoryAllocationService {
    private final InventoryRepository inventoryRepository;
    private final AllocationPolicy allocationPolicy;
    
    public AllocationResult allocateInventory(Order order) {
        List<AllocationRequest> requests = order.getItems().stream()
            .map(item -> new AllocationRequest(item.getProductId(), item.getQuantity()))
            .collect(Collectors.toList());
        
        // 檢查可用庫存
        Map<ProductId, Integer> availableInventory = checkAvailableInventory(requests);
        
        // 應用分配策略
        AllocationPlan plan = allocationPolicy.createAllocationPlan(requests, availableInventory);
        
        if (plan.isFullyAllocated()) {
            // 執行分配
            executeAllocation(plan);
            return AllocationResult.success(plan);
        } else {
            return AllocationResult.partialFailure(plan, plan.getUnallocatedItems());
        }
    }
    
    private Map<ProductId, Integer> checkAvailableInventory(List<AllocationRequest> requests) {
        return requests.stream()
            .collect(Collectors.toMap(
                AllocationRequest::getProductId,
                request -> inventoryRepository.getAvailableQuantity(request.getProductId())
            ));
    }
    
    private void executeAllocation(AllocationPlan plan) {
        for (AllocationItem item : plan.getAllocatedItems()) {
            inventoryRepository.reserve(item.getProductId(), item.getQuantity());
        }
    }
}

// Domain 層定義的 Repository 介面
public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(OrderId id);
    List<Order> findByCustomerId(CustomerId customerId);
    List<Order> findByStatus(OrderStatus status);
    void delete(OrderId id);
    
    // 領域特定的查詢方法
    List<Order> findPendingOrdersOlderThan(LocalDateTime cutoffTime);
    List<Order> findOrdersRequiringShipping();
    Optional<Order> findLatestOrderByCustomer(CustomerId customerId);
}

// JPA 實作
@Repository
public class JpaOrderRepository implements OrderRepository {
    private final SpringDataOrderRepository springRepository;
    private final OrderMapper mapper;
    
    public JpaOrderRepository(SpringDataOrderRepository springRepository, 
                             OrderMapper mapper) {
        this.springRepository = springRepository;
        this.mapper = mapper;
    }
    
    @Override
    public void save(Order order) {
        OrderEntity entity = mapper.toEntity(order);
        springRepository.save(entity);
    }
    
    @Override
    public Optional<Order> findById(OrderId id) {
        return springRepository.findById(id.getValue())
                              .map(mapper::toDomain);
    }
    
    @Override
    public List<Order> findByCustomerId(CustomerId customerId) {
        return springRepository.findByCustomerId(customerId.getValue())
                              .stream()
                              .map(mapper::toDomain)
                              .collect(Collectors.toList());
    }
    
    @Override
    public List<Order> findPendingOrdersOlderThan(LocalDateTime cutoffTime) {
        return springRepository.findByStatusAndCreatedAtBefore(
                "PENDING", cutoffTime)
                .stream()
                .map(mapper::toDomain)
                .collect(Collectors.toList());
    }
}

// Spring Data JPA Repository
@Repository
interface SpringDataOrderRepository extends JpaRepository<OrderEntity, String> {
    List<OrderEntity> findByCustomerId(String customerId);
    List<OrderEntity> findByStatus(String status);
    List<OrderEntity> findByStatusAndCreatedAtBefore(String status, LocalDateTime cutoffTime);
}

// JPA Entity - 純粹的資料結構
@Entity
@Table(name = "orders")
public class OrderEntity {
    @Id
    private String id;
    
    @Column(name = "customer_id")
    private String customerId;
    
    @Column(name = "status")
    @Enumerated(EnumType.STRING)
    private OrderStatusEntity status;
    
    @Column(name = "total_amount")
    private BigDecimal totalAmount;
    
    @Column(name = "currency")
    private String currency;
    
    @Column(name = "created_at")
    private LocalDateTime createdAt;
    
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<OrderItemEntity> items = new ArrayList<>();
    
    // 建構子、Getter、Setter
}

// Mapper - 負責 Domain 物件與 Entity 之間的轉換
@Component
public class OrderMapper {
    
    public OrderEntity toEntity(Order domain) {
        OrderEntity entity = new OrderEntity();
        entity.setId(domain.getId().getValue());
        entity.setCustomerId(domain.getCustomerId().getValue());
        entity.setStatus(OrderStatusEntity.valueOf(domain.getStatus().name()));
        entity.setTotalAmount(domain.getTotalAmount().getAmount());
        entity.setCurrency(domain.getTotalAmount().getCurrency().getCurrencyCode());
        entity.setCreatedAt(domain.getCreatedAt());
        
        List<OrderItemEntity> itemEntities = domain.getItems().stream()
            .map(this::toItemEntity)
            .collect(Collectors.toList());
        entity.setItems(itemEntities);
        
        return entity;
    }
    
    public Order toDomain(OrderEntity entity) {
        OrderId id = OrderId.of(entity.getId());
        CustomerId customerId = CustomerId.of(entity.getCustomerId());
        
        List<OrderItem> items = entity.getItems().stream()
            .map(this::toItemDomain)
            .collect(Collectors.toList());
        
        Money totalAmount = new Money(
            entity.getTotalAmount(),
            Currency.getInstance(entity.getCurrency())
        );
        
        // 使用工廠方法或建構子重建領域物件
        return Order.reconstitute(id, customerId, items, 
                                 OrderStatus.valueOf(entity.getStatus().name()),
                                 totalAmount, entity.getCreatedAt());
    }
    
    private OrderItemEntity toItemEntity(OrderItem domain) {
        // 轉換邏輯
    }
    
    private OrderItem toItemDomain(OrderItemEntity entity) {
        // 轉換邏輯
    }
}

// MongoDB 實作
@Repository
public class MongoOrderRepository implements OrderRepository {
    private final MongoTemplate mongoTemplate;
    
    @Override
    public void save(Order order) {
        OrderDocument document = OrderDocument.from(order);
        mongoTemplate.save(document, "orders");
    }
    
    @Override
    public Optional<Order> findById(OrderId id) {
        OrderDocument document = mongoTemplate.findById(
            id.getValue(), OrderDocument.class, "orders");
        return Optional.ofNullable(document)
                      .map(OrderDocument::toDomain);
    }
}

// Redis 快取實作（作為輔助儲存）
@Repository
public class RedisOrderCacheRepository {
    private final RedisTemplate<String, String> redisTemplate;
    private final ObjectMapper objectMapper;
    
    public void cacheOrder(Order order) {
        try {
            String json = objectMapper.writeValueAsString(order);
            redisTemplate.opsForValue().set(
                "order:" + order.getId().getValue(), 
                json, 
                Duration.ofHours(1)
            );
        } catch (JsonProcessingException e) {
            // 處理序列化錯誤
        }
    }
    
    public Optional<Order> getFromCache(OrderId id) {
        String json = redisTemplate.opsForValue().get("order:" + id.getValue());
        if (json != null) {
            try {
                return Optional.of(objectMapper.readValue(json, Order.class));
            } catch (JsonProcessingException e) {
                // 處理反序列化錯誤
            }
        }
        return Optional.empty();
    }
}

@RestController
@RequestMapping("/api/orders")
@Validated
public class OrderRestAdapter {
    private final CreateOrderUseCase createOrderUseCase;
    private final GetOrderDetailsUseCase getOrderDetailsUseCase;
    private final CancelOrderUseCase cancelOrderUseCase;
    
    public OrderRestAdapter(CreateOrderUseCase createOrderUseCase,
                           GetOrderDetailsUseCase getOrderDetailsUseCase,
                           CancelOrderUseCase cancelOrderUseCase) {
        this.createOrderUseCase = createOrderUseCase;
        this.getOrderDetailsUseCase = getOrderDetailsUseCase;
        this.cancelOrderUseCase = cancelOrderUseCase;
    }
    
    @PostMapping
    public ResponseEntity<CreateOrderResponse> createOrder(
            @Valid @RequestBody CreateOrderRequest request) {
        
        // 1. 將 HTTP 請求轉換為 Command
        CreateOrderCommand command = CreateOrderCommand.builder()
            .customerId(CustomerId.of(request.getCustomerId()))
            .items(mapToOrderItems(request.getItems()))
            .shippingAddress(mapToShippingAddress(request.getShippingAddress()))
            .build();
        
        // 2. 呼叫 Use Case
        CreateOrderResult result = createOrderUseCase.execute(command);
        
        // 3. 將結果轉換為 HTTP 回應
        if (result.isSuccess()) {
            CreateOrderResponse response = CreateOrderResponse.from(result);
            return ResponseEntity.status(HttpStatus.CREATED).body(response);
        } else {
            return ResponseEntity.badRequest()
                .body(CreateOrderResponse.error(result.getErrorMessage()));
        }
    }
    
    @GetMapping("/{orderId}")
    public ResponseEntity<OrderDetailsResponse> getOrderDetails(
            @PathVariable String orderId) {
        
        OrderId id = OrderId.of(orderId);
        GetOrderDetailsQuery query = new GetOrderDetailsQuery(id);
        
        GetOrderDetailsResult result = getOrderDetailsUseCase.execute(query);
        
        if (result.isSuccess()) {
            OrderDetailsResponse response = OrderDetailsResponse.from(result.getOrder());
            return ResponseEntity.ok(response);
        } else {
            return ResponseEntity.notFound().build();
        }
    }
    
    @DeleteMapping("/{orderId}")
    public ResponseEntity<Void> cancelOrder(
            @PathVariable String orderId,
            @RequestBody CancelOrderRequest request) {
        
        CancelOrderCommand command = new CancelOrderCommand(
            OrderId.of(orderId),
            request.getReason()
        );
        
        CancelOrderResult result = cancelOrderUseCase.execute(command);
        
        return result.isSuccess() 
            ? ResponseEntity.noContent().build()
            : ResponseEntity.badRequest().build();
    }
    
    // 錯誤處理
    @ExceptionHandler(DomainException.class)
    public ResponseEntity<ErrorResponse> handleDomainException(DomainException e) {
        ErrorResponse error = ErrorResponse.builder()
            .code("DOMAIN_ERROR")
            .message(e.getMessage())
            .timestamp(LocalDateTime.now())
            .build();
        return ResponseEntity.badRequest().body(error);
    }
    
    private List<OrderItemRequest> mapToOrderItems(List<CreateOrderItemRequest> requests) {
        return requests.stream()
            .map(req -> new OrderItemRequest(
                ProductId.of(req.getProductId()),
                req.getQuantity()
            ))
            .collect(Collectors.toList());
    }
}

@Component
public class OrderGraphQLAdapter {
    private final CreateOrderUseCase createOrderUseCase;
    private final GetOrderDetailsUseCase getOrderDetailsUseCase;
    
    @QueryMapping
    public OrderDetailsResponse order(@Argument String id) {
        GetOrderDetailsQuery query = new GetOrderDetailsQuery(OrderId.of(id));
        GetOrderDetailsResult result = getOrderDetailsUseCase.execute(query);
        
        return result.isSuccess() 
            ? OrderDetailsResponse.from(result.getOrder())
            : null;
    }
    
    @MutationMapping
    public CreateOrderResponse createOrder(@Argument CreateOrderInput input) {
        CreateOrderCommand command = mapToCommand(input);
        CreateOrderResult result = createOrderUseCase.execute(command);
        
        return CreateOrderResponse.from(result);
    }
}

@ShellComponent
public class OrderCliAdapter {
    private final CreateOrderUseCase createOrderUseCase;
    private final GetOrderDetailsUseCase getOrderDetailsUseCase;
    
    @ShellMethod(value = "Create a new order", key = "create-order")
    public String createOrder(@ShellOption String customerId,
                             @ShellOption String productId,
                             @ShellOption int quantity) {
        try {
            CreateOrderCommand command = CreateOrderCommand.builder()
                .customerId(CustomerId.of(customerId))
                .addItem(ProductId.of(productId), quantity)
                .build();
            
            CreateOrderResult result = createOrderUseCase.execute(command);
            
            if (result.isSuccess()) {
                return String.format("訂單建立成功：%s", 
                    result.getOrder().getId().getValue());
            } else {
                return String.format("建立失敗：%s", result.getErrorMessage());
            }
        } catch (Exception e) {
            return "錯誤：" + e.getMessage();
        }
    }
    
    @ShellMethod(value = "Get order details", key = "get-order")
    public String getOrderDetails(@ShellOption String orderId) {
        GetOrderDetailsQuery query = new GetOrderDetailsQuery(OrderId.of(orderId));
        GetOrderDetailsResult result = getOrderDetailsUseCase.execute(query);
        
        if (result.isSuccess()) {
            Order order = result.getOrder();
            return String.format(
                "訂單 %s\n客戶：%s\n狀態：%s\n總額：%s",
                order.getId().getValue(),
                order.getCustomerId().getValue(),
                order.getStatus(),
                order.getTotalAmount()
            );
        } else {
            return "查無此訂單";
        }
    }
}

// 事件發布 Adapter
@Component
public class RabbitMQEventPublisher implements EventPublisher {
    private final RabbitTemplate rabbitTemplate;
    
    @Override
    public void publish(DomainEvent event) {
        String routingKey = event.getClass().getSimpleName();
        EventMessage message = EventMessage.from(event);
        
        rabbitTemplate.convertAndSend("order.events", routingKey, message);
    }
}

// 訊息消費 Adapter
@RabbitListener(queues = "order.processing")
@Component
public class OrderProcessingMessageAdapter {
    private final ProcessOrderUseCase processOrderUseCase;
    
    @RabbitHandler
    public void handleOrderCreated(OrderCreatedMessage message) {
        ProcessOrderCommand command = ProcessOrderCommand.from(message);
        processOrderUseCase.execute(command);
    }
}

// 第三方支付 API Adapter
@Component
public class StripePaymentAdapter implements PaymentGateway {
    private final StripeClient stripeClient;
    
    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        try {
            ChargeCreateParams params = ChargeCreateParams.builder()
                .setAmount(request.getAmount().longValue())
                .setCurrency(request.getCurrency().getCurrencyCode().toLowerCase())
                .setSource(request.getToken())
                .setDescription("Order payment")
                .build();
            
            Charge charge = stripeClient.charges().create(params);
            
            return PaymentResult.success(
                PaymentId.of(charge.getId()),
                Money.of(charge.getAmount(), request.getCurrency())
            );
            
        } catch (StripeException e) {
            return PaymentResult.failed(e.getMessage());
        }
    }
}

// FTP 檔案處理 Adapter
@Component
public class FtpOrderExportAdapter implements OrderExportService {
    private final FtpTemplate ftpTemplate;
    
    @Override
    public void exportOrders(List<Order> orders, ExportFormat format) {
        String fileName = generateFileName(format);
        byte[] content = formatOrders(orders, format);
        
        ftpTemplate.send(session -> {
            try (ByteArrayInputStream input = new ByteArrayInputStream(content)) {
                session.write(input, "/exports/" + fileName);
            }
            return fileName;
        });
    }
    
    private String generateFileName(ExportFormat format) {
        String timestamp = LocalDateTime.now().format(
            DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
        return String.format("orders_%s.%s", timestamp, format.getExtension());
    }
    
    private byte[] formatOrders(List<Order> orders, ExportFormat format) {
        switch (format) {
            case CSV:
                return formatAsCsv(orders);
            case JSON:
                return formatAsJson(orders);
            default:
                throw new UnsupportedOperationException("不支援的格式：" + format);
        }
    }
}

@Configuration
@EnableJpaRepositories(basePackages = "com.example.infrastructure.persistence.jpa")
@EnableRabbit
public class InfrastructureConfiguration {
    
    // Database 配置
    @Bean
    @Primary
    public OrderRepository orderRepository(
            SpringDataOrderRepository springRepository,
            OrderMapper mapper) {
        return new JpaOrderRepository(springRepository, mapper);
    }
    
    // 快取裝飾器模式
    @Bean
    @Qualifier("cachedOrderRepository")
    public OrderRepository cachedOrderRepository(
            @Qualifier("orderRepository") OrderRepository baseRepository,
            RedisTemplate<String, String> redisTemplate) {
        return new CachedOrderRepository(baseRepository, redisTemplate);
    }
    
    // 外部 API 配置
    @Bean
    public PaymentGateway paymentGateway(@Value("${stripe.api.key}") String apiKey) {
        return new StripePaymentAdapter(new StripeClient(apiKey));
    }
    
    @Bean
    public InventoryService inventoryService(@Value("${inventory.service.url}") String baseUrl) {
        WebClient client = WebClient.builder()
            .baseUrl(baseUrl)
            .build();
        return new RestInventoryService(client);
    }
    
    // 訊息佇列配置
    @Bean
    public EventPublisher eventPublisher(RabbitTemplate rabbitTemplate) {
        return new RabbitMQEventPublisher(rabbitTemplate);
    }
    
    // FTP 配置
    @Bean
    public FtpTemplate ftpTemplate(@Value("${ftp.host}") String host,
                                  @Value("${ftp.username}") String username,
                                  @Value("${ftp.password}") String password) {
        FtpSessionFactory factory = new FtpSessionFactory();
        factory.setHost(host);
        factory.setUsername(username);
        factory.setPassword(password);
        return new FtpTemplate(factory);
    }
}

// 環境特定配置
@Configuration
@Profile("production")
public class ProductionInfrastructureConfiguration {
    
    @Bean
    public OrderRepository orderRepository() {
        // 生產環境使用分散式資料庫
        return new DistributedOrderRepository();
    }
}

@Configuration
@Profile("test")
public class TestInfrastructureConfiguration {
    
    @Bean
    public OrderRepository orderRepository() {
        // 測試環境使用記憶體資料庫
        return new InMemoryOrderRepository();
    }
    
    @Bean
    public PaymentGateway paymentGateway() {
        // 測試環境使用模擬支付
        return new MockPaymentGateway();
    }
}

# application-dev.yml
spring:
  datasource:
    url: jdbc:h2:mem:devdb
    driver-class-name: org.h2.Driver
  jpa:
    hibernate:
      ddl-auto: create-drop

external:
  payment:
    type: mock
  inventory:
    type: mock
  email:
    type: console

# application-prod.yml
spring:
  datasource:
    url: jdbc:postgresql://prod-db:5432/orders
    driver-class-name: org.postgresql.Driver
  jpa:
    hibernate:
      ddl-auto: validate

external:
  payment:
    type: stripe
    api-key: ${STRIPE_API_KEY}
  inventory:
    type: rest
    base-url: ${INVENTORY_SERVICE_URL}
  email:
    type: smtp
    host: ${SMTP_HOST}

// 定義目標架構的核心 Port
public interface OrderManagement {
    // 主要業務用例
    OrderResult createOrder(CreateOrderCommand command);
    OrderResult updateOrder(UpdateOrderCommand command);
    OrderResult cancelOrder(CancelOrderCommand command);
    
    // 查詢用例
    Optional<OrderDetails> getOrderDetails(OrderId id);
    List<OrderSummary> findOrdersByCustomer(CustomerId customerId);
}

// 定義重要的輸出 Port
public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(OrderId id);
    List<Order> findByCustomerId(CustomerId customerId);
}

public interface PaymentService {
    PaymentResult processPayment(PaymentRequest request);
    void refund(PaymentId paymentId, Money amount);
}

// 原有的混雜模型
@Entity
public class OrderEntity {
    private Long id;
    private String customerId;
    private String customerName;        // 屬於 Customer 聚合
    private String customerEmail;       // 屬於 Customer 聚合
    private List<OrderItemEntity> items;
    private String paymentStatus;       // 屬於 Payment 聚合
    private String paymentMethod;       // 屬於 Payment 聚合
    private String shippingAddress;     // 屬於 Shipping 聚合
    // ... 更多混雜的屬性
}

// 重構後的清晰聚合
public class Order {  // Order 聚合根
    private final OrderId id;
    private final CustomerId customerId;  // 只保留關聯 ID
    private final List<OrderItem> items;
    private OrderStatus status;
    private final LocalDateTime createdAt;
    
    // 純粹的訂單業務邏輯
    public void confirm() { /* ... */ }
    public void cancel(String reason) { /* ... */ }
    public Money calculateTotal() { /* ... */ }
}

public class Customer {  // Customer 聚合根
    private final CustomerId id;
    private CustomerInfo info;
    private CustomerStatus status;
    
    // 客戶相關業務邏輯
    public boolean canPlaceOrder() { /* ... */ }
    public void updateProfile(CustomerInfo newInfo) { /* ... */ }
}

// 原有的 Service 層（包含技術細節）
@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;  // Spring Data JPA
    
    @Autowired
    private CustomerRepository customerRepository;
    
    @Autowired
    private JavaMailSender mailSender;  // 直接依賴技術框架
    
    public void createOrder(OrderDto orderDto) {
        // 業務邏輯與技術實作混雜
        Customer customer = customerRepository.findById(orderDto.getCustomerId());
        if (customer == null) {
            throw new RuntimeException("客戶不存在");
        }
        
        Order order = new Order();
        order.setCustomerId(orderDto.getCustomerId());
        // ... 設定其他屬性
        
        orderRepository.save(order);  // 直接使用 JPA
        
        // 直接使用 JavaMailSender
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(customer.getEmail());
        message.setSubject("訂單確認");
        mailSender.send(message);
    }
}

// 重構後的 Use Case（純業務邏輯）
@Component
public class CreateOrderUseCase {
    private final OrderRepository orderRepository;      // 抽象介面
    private final CustomerRepository customerRepository; // 抽象介面
    private final EmailNotification emailNotification;  // 抽象介面
    private final EventPublisher eventPublisher;        // 抽象介面
    
    public CreateOrderUseCase(OrderRepository orderRepository,
                             CustomerRepository customerRepository,
                             EmailNotification emailNotification,
                             EventPublisher eventPublisher) {
        this.orderRepository = orderRepository;
        this.customerRepository = customerRepository;
        this.emailNotification = emailNotification;
        this.eventPublisher = eventPublisher;
    }
    
    @Transactional
    public CreateOrderResult execute(CreateOrderCommand command) {
        // 1. 驗證客戶
        Customer customer = customerRepository.findById(command.getCustomerId())
            .orElseThrow(() -> new CustomerNotFoundException(command.getCustomerId()));
        
        if (!customer.canPlaceOrder()) {
            return CreateOrderResult.failed("客戶狀態不允許下訂單");
        }
        
        // 2. 建立訂單
        OrderId orderId = OrderId.generate();
        Order order = Order.create(orderId, command);
        
        // 3. 儲存訂單
        orderRepository.save(order);
        
        // 4. 發送通知
        emailNotification.sendOrderConfirmation(order, customer);
        
        // 5. 發布事件
        eventPublisher.publish(new OrderCreatedEvent(order.getId()));
        
        return CreateOrderResult.success(order);
    }
}

// 實作 Repository Adapter
@Repository
public class JpaOrderRepository implements OrderRepository {
    private final SpringDataOrderRepository springRepository;
    private final OrderMapper mapper;
    
    @Override
    public void save(Order order) {
        OrderEntity entity = mapper.toEntity(order);
        springRepository.save(entity);
    }
    
    @Override
    public Optional<Order> findById(OrderId id) {
        return springRepository.findById(id.getValue())
                              .map(mapper::toDomain);
    }
}

// 實作 Email Adapter
@Component
public class SmtpEmailNotification implements EmailNotification {
    private final JavaMailSender mailSender;
    private final EmailTemplateService templateService;
    
    @Override
    public void sendOrderConfirmation(Order order, Customer customer) {
        try {
            MimeMessage message = mailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message);
            
            String content = templateService.generateOrderConfirmation(order);
            helper.setTo(customer.getEmail());
            helper.setSubject("訂單確認 - " + order.getId());
            helper.setText(content, true);
            
            mailSender.send(message);
        } catch (MessagingException e) {
            throw new EmailSendingException("無法發送確認信件", e);
        }
    }
}

src/
├── main/
│   ├── java/
│   │   └── com/
│   │       └── example/
│   │           └── orders/
│   │               ├── domain/                    # Domain 層
│   │               │   ├── model/
│   │               │   │   ├── Order.java
│   │               │   │   ├── OrderId.java
│   │               │   │   ├── OrderItem.java
│   │               │   │   └── Money.java
│   │               │   ├── service/
│   │               │   │   └── OrderPricingService.java
│   │               │   └── event/
│   │               │       └── OrderCreatedEvent.java
│   │               ├── application/               # Application 層
│   │               │   ├── usecase/
│   │               │   │   ├── CreateOrderUseCase.java
│   │               │   │   └── CancelOrderUseCase.java
│   │               │   ├── port/
│   │               │   │   ├── in/
│   │               │   │   │   └── OrderManagement.java
│   │               │   │   └── out/
│   │               │   │       ├── OrderRepository.java
│   │               │   │       ├── PaymentService.java
│   │               │   │       └── EmailNotification.java
│   │               │   └── command/
│   │               │       └── CreateOrderCommand.java
│   │               └── infrastructure/            # Infrastructure 層
│   │                   ├── adapter/
│   │                   │   ├── in/
│   │                   │   │   ├── web/
│   │                   │   │   │   └── OrderController.java
│   │                   │   │   └── cli/
│   │                   │   │       └── OrderCliHandler.java
│   │                   │   └── out/
│   │                   │       ├── persistence/
│   │                   │       │   ├── JpaOrderRepository.java
│   │                   │       │   └── OrderEntity.java
│   │                   │       ├── payment/
│   │                   │       │   └── StripePaymentService.java
│   │                   │       └── notification/
│   │                   │           └── SmtpEmailNotification.java
│   │                   └── config/
│   │                       ├── ApplicationConfig.java
│   │                       └── InfrastructureConfig.java
│   └── resources/
│       ├── application.yml
│       └── application-test.yml
└── test/
    ├── java/
    │   └── com/
    │       └── example/
    │           └── orders/
    │               ├── domain/                    # Domain 測試
    │               │   └── model/
    │               │       └── OrderTest.java
    │               ├── application/               # Application 測試
    │               │   └── usecase/
    │               │       └── CreateOrderUseCaseTest.java
    │               └── infrastructure/            # Infrastructure 測試
    │                   └── adapter/
    │                       └── in/
    │                           └── web/
    │                               └── OrderControllerTest.java
    └── resources/
        └── application-test.yml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
                           http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>com.example</groupId>
    <artifactId>hexagonal-orders</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>
    
    <name>Hexagonal Orders Service</name>
    <description>Order management service using hexagonal architecture</description>
    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.0</version>
        <relativePath/>
    </parent>
    
    <properties>
        <java.version>17</java.version>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    
    <dependencies>
        <!-- Spring Boot 核心 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        
        <!-- Web 支援 -->
        <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>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        
        <!-- 驗證支援 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        
        <!-- 測試支援 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!-- Testcontainers -->
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
        
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>postgresql</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            
            <!-- ArchUnit 插件 - 架構測試 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <includes>
                        <include>**/*Test.java</include>
                        <include>**/*ArchTest.java</include>
                    </includes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

// 應用程式配置 - 只包含業務邏輯相關的配置
@Configuration
@ComponentScan(basePackages = {
    "com.example.orders.application",
    "com.example.orders.domain"
})
public class ApplicationConfiguration {
    
    // Use Case 配置
    @Bean
    public CreateOrderUseCase createOrderUseCase(
            OrderRepository orderRepository,
            CustomerRepository customerRepository,
            PaymentService paymentService,
            EmailNotification emailNotification) {
        return new CreateOrderUseCase(
            orderRepository, 
            customerRepository, 
            paymentService, 
            emailNotification
        );
    }
    
    @Bean
    public CancelOrderUseCase cancelOrderUseCase(
            OrderRepository orderRepository,
            RefundService refundService) {
        return new CancelOrderUseCase(orderRepository, refundService);
    }
    
    // Domain Service 配置
    @Bean
    public OrderPricingService orderPricingService(
            PromotionRepository promotionRepository) {
        return new OrderPricingService(promotionRepository);
    }
}

// Infrastructure 配置 - 技術實作相關的配置
@Configuration
@EnableJpaRepositories(basePackages = "com.example.orders.infrastructure.adapter.out.persistence")
@ComponentScan(basePackages = "com.example.orders.infrastructure")
public class InfrastructureConfiguration {
    
    // Repository 實作配置
    @Bean
    public OrderRepository orderRepository(
            SpringDataOrderRepository springRepository,
            OrderMapper mapper) {
        return new JpaOrderRepository(springRepository, mapper);
    }
    
    // 外部服務配置
    @Bean
    public PaymentService paymentService(
            @Value("${payment.stripe.api-key}") String apiKey) {
        return new StripePaymentService(apiKey);
    }
    
    @Bean
    public EmailNotification emailNotification(JavaMailSender mailSender) {
        return new SmtpEmailNotification(mailSender);
    }
    
    // Mapper 配置
    @Bean
    public OrderMapper orderMapper() {
        return new OrderMapper();
    }
}

// Web 配置 - Web 層相關的配置
@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.example.orders.infrastructure.adapter.in.web")
public class WebConfiguration implements WebMvcConfigurer {
    
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
                .allowedOrigins("http://localhost:3000")
                .allowedMethods("GET", "POST", "PUT", "DELETE")
                .allowCredentials(true);
    }
    
    @Bean
    public RestExceptionHandler restExceptionHandler() {
        return new RestExceptionHandler();
    }
}

@SpringBootApplication
@ImportAutoConfiguration({
    ApplicationConfiguration.class,
    InfrastructureConfiguration.class,
    WebConfiguration.class
})
public class OrdersApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(OrdersApplication.class, args);
    }
    
    // 健康檢查端點
    @Bean
    public HealthIndicator orderServiceHealthIndicator(OrderRepository orderRepository) {
        return () -> {
            try {
                // 簡單的健康檢查
                orderRepository.findById(OrderId.of("health-check"));
                return Health.up()
                           .withDetail("database", "available")
                           .build();
            } catch (Exception e) {
                return Health.down()
                           .withDetail("database", "unavailable")
                           .withException(e)
                           .build();
            }
        };
    }
}

# application.yml
spring:
  application:
    name: hexagonal-orders
  
  profiles:
    active: ${SPRING_PROFILES_ACTIVE:dev}
  
  datasource:
    driver-class-name: org.h2.Driver
    url: jdbc:h2:mem:orders;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
    username: sa
    password: ''
  
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true
    properties:
      hibernate:
        format_sql: true
  
  mail:
    host: ${MAIL_HOST:localhost}
    port: ${MAIL_PORT:587}
    username: ${MAIL_USERNAME:}
    password: ${MAIL_PASSWORD:}
    
server:
  port: 8080
  servlet:
    context-path: /orders

# 業務相關配置
orders:
  pricing:
    tax-rate: 0.05
    free-shipping-threshold: 1000
  
  payment:
    stripe:
      api-key: ${STRIPE_API_KEY:sk_test_dummy}
      webhook-secret: ${STRIPE_WEBHOOK_SECRET:whsec_dummy}

# 監控配置
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics
  endpoint:
    health:
      show-details: always

---
# application-prod.yml
spring:
  config:
    activate:
      on-profile: prod
  
  datasource:
    driver-class-name: org.postgresql.Driver
    url: ${DATABASE_URL}
    username: ${DATABASE_USERNAME}
    password: ${DATABASE_PASSWORD}
  
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false

// 輸入 Port - 訂單管理
public interface OrderManagement {
    CreateOrderResult createOrder(CreateOrderCommand command);
    UpdateOrderResult updateOrder(UpdateOrderCommand command);
    CancelOrderResult cancelOrder(CancelOrderCommand command);
    OrderDetails getOrderDetails(OrderId orderId);
    List<OrderSummary> getCustomerOrders(CustomerId customerId);
}

// 輸入 Port - 管理功能
public interface OrderAdministration {
    List<OrderSummary> getAllOrders(OrderFilter filter, Pagination pagination);
    OrderStatistics getOrderStatistics(DateRange dateRange);
    void processRefund(RefundCommand command);
}

// 輸出 Port - 資料持久化
public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(OrderId id);
    List<Order> findByCustomerId(CustomerId customerId);
    List<Order> findByStatus(OrderStatus status);
    Page<Order> findAll(OrderFilter filter, Pageable pageable);
}

public interface BookRepository {
    Optional<Book> findById(BookId id);
    List<Book> findByIds(List<BookId> ids);
    void updateStock(BookId id, int quantity);
}

// 輸出 Port - 外部服務
public interface PaymentProcessor {
    PaymentResult processPayment(PaymentRequest request);
    RefundResult processRefund(RefundRequest request);
    PaymentStatus getPaymentStatus(PaymentId paymentId);
}

public interface EmailNotifier {
    void sendOrderConfirmation(Order order, Customer customer);
    void sendOrderCancellation(Order order, String reason);
    void sendPaymentFailure(Order order, String errorMessage);
}

public interface InventoryService {
    boolean isAvailable(BookId bookId, int quantity);
    void reserveStock(List<StockReservation> reservations);
    void releaseStock(List<StockReservation> reservations);
}

// Book 聚合根
public class Book {
    private final BookId id;
    private final String title;
    private final String author;
    private final String isbn;
    private Money price;
    private int stockQuantity;
    private BookStatus status;
    
    public Book(BookId id, String title, String author, String isbn, 
                Money price, int stockQuantity) {
        this.id = Objects.requireNonNull(id);
        this.title = validateNotBlank(title, "書名不能為空");
        this.author = validateNotBlank(author, "作者不能為空");
        this.isbn = validateIsbn(isbn);
        this.price = Objects.requireNonNull(price);
        this.stockQuantity = validateStockQuantity(stockQuantity);
        this.status = BookStatus.AVAILABLE;
    }
    
    public boolean isAvailableForPurchase(int quantity) {
        return status == BookStatus.AVAILABLE && stockQuantity >= quantity;
    }
    
    public void reserveStock(int quantity) {
        if (!isAvailableForPurchase(quantity)) {
            throw new InsufficientStockException(id, quantity, stockQuantity);
        }
        this.stockQuantity -= quantity;
    }
    
    public void releaseStock(int quantity) {
        this.stockQuantity += quantity;
    }
    
    public Money calculateSubtotal(int quantity) {
        return price.multiply(quantity);
    }
    
    // 私有驗證方法
    private String validateNotBlank(String value, String message) {
        if (value == null || value.trim().isEmpty()) {
            throw new IllegalArgumentException(message);
        }
        return value.trim();
    }
    
    private String validateIsbn(String isbn) {
        if (isbn == null || !isbn.matches("\\d{10}|\\d{13}")) {
            throw new IllegalArgumentException("ISBN 格式不正確");
        }
        return isbn;
    }
    
    private int validateStockQuantity(int quantity) {
        if (quantity < 0) {
            throw new IllegalArgumentException("庫存數量不能為負數");
        }
        return quantity;
    }
}

// Order 聚合根
public class Order {
    private final OrderId id;
    private final CustomerId customerId;
    private final List<OrderItem> items;
    private OrderStatus status;
    private Money totalAmount;
    private PaymentId paymentId;
    private final LocalDateTime createdAt;
    private LocalDateTime confirmedAt;
    
    // 工廠方法
    public static Order create(CustomerId customerId, List<OrderItem> items) {
        OrderId id = OrderId.generate();
        return new Order(id, customerId, items);
    }
    
    private Order(OrderId id, CustomerId customerId, List<OrderItem> items) {
        this.id = Objects.requireNonNull(id);
        this.customerId = Objects.requireNonNull(customerId);
        this.items = validateItems(items);
        this.status = OrderStatus.PENDING;
        this.totalAmount = calculateTotalAmount();
        this.createdAt = LocalDateTime.now();
    }
    
    // 業務行為
    public void confirm(PaymentId paymentId) {
        if (status != OrderStatus.PENDING) {
            throw new IllegalOrderStateException("只有待處理的訂單可以確認");
        }
        
        this.status = OrderStatus.CONFIRMED;
        this.paymentId = paymentId;
        this.confirmedAt = LocalDateTime.now();
        
        // 發布領域事件
        DomainEvents.publish(new OrderConfirmedEvent(this.id, this.customerId));
    }
    
    public void cancel(String reason) {
        if (status == OrderStatus.SHIPPED || status == OrderStatus.DELIVERED) {
            throw new IllegalOrderStateException("已出貨或已送達的訂單無法取消");
        }
        
        OrderStatus previousStatus = this.status;
        this.status = OrderStatus.CANCELLED;
        
        // 發布領域事件
        DomainEvents.publish(new OrderCancelledEvent(this.id, reason, previousStatus));
    }
    
    public void addItem(OrderItem item) {
        if (!canBeModified()) {
            throw new IllegalOrderStateException("訂單狀態不允許修改");
        }
        
        this.items.add(item);
        this.totalAmount = calculateTotalAmount();
    }
    
    public void removeItem(BookId bookId) {
        if (!canBeModified()) {
            throw new IllegalOrderStateException("訂單狀態不允許修改");
        }
        
        this.items.removeIf(item -> item.getBookId().equals(bookId));
        this.totalAmount = calculateTotalAmount();
    }
    
    public boolean canBeModified() {
        return status == OrderStatus.PENDING;
    }
    
    public boolean requiresPayment() {
        return paymentId == null && totalAmount.isGreaterThan(Money.ZERO);
    }
    
    private Money calculateTotalAmount() {
        return items.stream()
                   .map(OrderItem::getSubtotal)
                   .reduce(Money.ZERO, Money::add);
    }
    
    private List<OrderItem> validateItems(List<OrderItem> items) {
        if (items == null || items.isEmpty()) {
            throw new IllegalArgumentException("訂單至少要有一個項目");
        }
        return new ArrayList<>(items);
    }
}

// OrderItem 值物件
public class OrderItem {
    private final BookId bookId;
    private final String bookTitle;
    private final int quantity;
    private final Money unitPrice;
    private final Money subtotal;
    
    public OrderItem(BookId bookId, String bookTitle, int quantity, Money unitPrice) {
        this.bookId = Objects.requireNonNull(bookId);
        this.bookTitle = validateNotBlank(bookTitle);
        this.quantity = validateQuantity(quantity);
        this.unitPrice = Objects.requireNonNull(unitPrice);
        this.subtotal = unitPrice.multiply(quantity);
    }
    
    public static OrderItem from(Book book, int quantity) {
        return new OrderItem(
            book.getId(),
            book.getTitle(),
            quantity,
            book.getPrice()
        );
    }
    
    private String validateNotBlank(String value) {
        if (value == null || value.trim().isEmpty()) {
            throw new IllegalArgumentException("書名不能為空");
        }
        return value.trim();
    }
    
    private int validateQuantity(int quantity) {
        if (quantity <= 0) {
            throw new IllegalArgumentException("數量必須大於 0");
        }
        return quantity;
    }
    
    // Getters...
}

// 創建訂單用例
@Component
@Transactional
public class CreateOrderUseCase implements OrderManagement {
    private final OrderRepository orderRepository;
    private final BookRepository bookRepository;
    private final CustomerRepository customerRepository;
    private final InventoryService inventoryService;
    private final OrderPricingService pricingService;
    private final EventPublisher eventPublisher;
    
    public CreateOrderUseCase(OrderRepository orderRepository,
                             BookRepository bookRepository,
                             CustomerRepository customerRepository,
                             InventoryService inventoryService,
                             OrderPricingService pricingService,
                             EventPublisher eventPublisher) {
        this.orderRepository = orderRepository;
        this.bookRepository = bookRepository;
        this.customerRepository = customerRepository;
        this.inventoryService = inventoryService;
        this.pricingService = pricingService;
        this.eventPublisher = eventPublisher;
    }
    
    @Override
    public CreateOrderResult createOrder(CreateOrderCommand command) {
        try {
            // 1. 驗證客戶
            Customer customer = customerRepository.findById(command.getCustomerId())
                .orElseThrow(() -> new CustomerNotFoundException(command.getCustomerId()));
            
            // 2. 驗證和準備訂單項目
            List<OrderItem> orderItems = prepareOrderItems(command.getItems());
            
            // 3. 檢查庫存
            checkInventoryAvailability(orderItems);
            
            // 4. 建立訂單
            Order order = Order.create(customer.getId(), orderItems);
            
            // 5. 套用定價規則
            Money finalAmount = pricingService.calculateOrderPrice(order, customer);
            order.updateTotalAmount(finalAmount);
            
            // 6. 預留庫存
            reserveInventory(orderItems);
            
            // 7. 儲存訂單
            orderRepository.save(order);
            
            // 8. 發布事件
            eventPublisher.publish(new OrderCreatedEvent(order.getId()));
            
            return CreateOrderResult.success(order);
            
        } catch (DomainException e) {
            return CreateOrderResult.failed(e.getMessage());
        } catch (Exception e) {
            return CreateOrderResult.failed("系統錯誤：" + e.getMessage());
        }
    }
    
    private List<OrderItem> prepareOrderItems(List<CreateOrderItemRequest> requests) {
        List<BookId> bookIds = requests.stream()
            .map(CreateOrderItemRequest::getBookId)
            .collect(Collectors.toList());
        
        Map<BookId, Book> books = bookRepository.findByIds(bookIds)
            .stream()
            .collect(Collectors.toMap(Book::getId, Function.identity()));
        
        return requests.stream()
            .map(request -> {
                Book book = books.get(request.getBookId());
                if (book == null) {
                    throw new BookNotFoundException(request.getBookId());
                }
                return OrderItem.from(book, request.getQuantity());
            })
            .collect(Collectors.toList());
    }
    
    private void checkInventoryAvailability(List<OrderItem> items) {
        for (OrderItem item : items) {
            if (!inventoryService.isAvailable(item.getBookId(), item.getQuantity())) {
                throw new InsufficientInventoryException(
                    item.getBookId(), 
                    item.getQuantity()
                );
            }
        }
    }
    
    private void reserveInventory(List<OrderItem> items) {
        List<StockReservation> reservations = items.stream()
            .map(item -> new StockReservation(item.getBookId(), item.getQuantity()))
            .collect(Collectors.toList());
        
        inventoryService.reserveStock(reservations);
    }
}

// 訂單定價服務 (Domain Service)
@Component
public class OrderPricingService {
    private final PromotionRepository promotionRepository;
    private final CustomerTierService customerTierService;
    
    public Money calculateOrderPrice(Order order, Customer customer) {
        Money baseAmount = order.getTotalAmount();
        
        // 1. 套用會員折扣
        Money memberDiscount = calculateMemberDiscount(baseAmount, customer);
        
        // 2. 套用促銷活動
        Money promotionDiscount = calculatePromotionDiscount(order, customer);
        
        // 3. 選擇最優惠的折扣
        Money totalDiscount = Money.max(memberDiscount, promotionDiscount);
        
        // 4. 計算最終金額
        Money finalAmount = baseAmount.subtract(totalDiscount);
        
        return Money.max(finalAmount, Money.ZERO); // 確保不為負數
    }
    
    private Money calculateMemberDiscount(Money baseAmount, Customer customer) {
        CustomerTier tier = customerTierService.getTier(customer);
        BigDecimal discountRate = tier.getDiscountRate();
        
        return new Money(
            baseAmount.getAmount().multiply(discountRate),
            baseAmount.getCurrency()
        );
    }
    
    private Money calculatePromotionDiscount(Order order, Customer customer) {
        List<Promotion> applicablePromotions = promotionRepository
            .findActivePromotions()
            .stream()
            .filter(promotion -> promotion.isApplicableTo(order, customer))
            .collect(Collectors.toList());
        
        return applicablePromotions.stream()
            .map(promotion -> promotion.calculateDiscount(order))
            .max(Money::compareTo)
            .orElse(Money.ZERO);
    }
}

// REST Controller (主動 Adapter)
@RestController
@RequestMapping("/api/orders")
@Validated
public class OrderController {
    private final OrderManagement orderManagement;
    
    public OrderController(OrderManagement orderManagement) {
        this.orderManagement = orderManagement;
    }
    
    @PostMapping
    public ResponseEntity<CreateOrderResponse> createOrder(
            @Valid @RequestBody CreateOrderRequest request) {
        
        CreateOrderCommand command = CreateOrderCommand.builder()
            .customerId(CustomerId.of(request.getCustomerId()))
            .items(mapToOrderItems(request.getItems()))
            .build();
        
        CreateOrderResult result = orderManagement.createOrder(command);
        
        if (result.isSuccess()) {
            CreateOrderResponse response = CreateOrderResponse.from(result);
            return ResponseEntity.status(HttpStatus.CREATED).body(response);
        } else {
            return ResponseEntity.badRequest()
                .body(CreateOrderResponse.error(result.getErrorMessage()));
        }
    }
    
    @GetMapping("/{orderId}")
    public ResponseEntity<OrderDetailsResponse> getOrderDetails(
            @PathVariable String orderId) {
        
        OrderDetails details = orderManagement.getOrderDetails(OrderId.of(orderId));
        
        if (details != null) {
            return ResponseEntity.ok(OrderDetailsResponse.from(details));
        } else {
            return ResponseEntity.notFound().build();
        }
    }
    
    @DeleteMapping("/{orderId}")
    public ResponseEntity<Void> cancelOrder(
            @PathVariable String orderId,
            @RequestBody CancelOrderRequest request) {
        
        CancelOrderCommand command = new CancelOrderCommand(
            OrderId.of(orderId),
            request.getReason()
        );
        
        CancelOrderResult result = orderManagement.cancelOrder(command);
        
        return result.isSuccess() 
            ? ResponseEntity.noContent().build()
            : ResponseEntity.badRequest().build();
    }
    
    private List<CreateOrderItemRequest> mapToOrderItems(
            List<CreateOrderItemDto> dtos) {
        return dtos.stream()
            .map(dto -> new CreateOrderItemRequest(
                BookId.of(dto.getBookId()),
                dto.getQuantity()
            ))
            .collect(Collectors.toList());
    }
}

// JPA Repository (被動 Adapter)
@Repository
public class JpaOrderRepository implements OrderRepository {
    private final SpringDataOrderRepository springRepository;
    private final OrderEntityMapper mapper;
    
    public JpaOrderRepository(SpringDataOrderRepository springRepository,
                             OrderEntityMapper mapper) {
        this.springRepository = springRepository;
        this.mapper = mapper;
    }
    
    @Override
    public void save(Order order) {
        OrderEntity entity = mapper.toEntity(order);
        springRepository.save(entity);
    }
    
    @Override
    public Optional<Order> findById(OrderId id) {
        return springRepository.findById(id.getValue())
                              .map(mapper::toDomain);
    }
    
    @Override
    public List<Order> findByCustomerId(CustomerId customerId) {
        return springRepository.findByCustomerId(customerId.getValue())
                              .stream()
                              .map(mapper::toDomain)
                              .collect(Collectors.toList());
    }
    
    @Override
    public Page<Order> findAll(OrderFilter filter, Pageable pageable) {
        Page<OrderEntity> entityPage = springRepository.findAll(
            OrderSpecification.withFilter(filter), 
            pageable
        );
        
        return entityPage.map(mapper::toDomain);
    }
}

// Stripe 支付處理器 (被動 Adapter)
@Component
public class StripePaymentProcessor implements PaymentProcessor {
    private final StripeClient stripeClient;
    private final PaymentMapper paymentMapper;
    
    public StripePaymentProcessor(StripeClient stripeClient,
                                 PaymentMapper paymentMapper) {
        this.stripeClient = stripeClient;
        this.paymentMapper = paymentMapper;
    }
    
    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        try {
            PaymentIntentCreateParams params = PaymentIntentCreateParams.builder()
                .setAmount(request.getAmount().longValue() * 100) // 轉換為分
                .setCurrency(request.getCurrency().getCurrencyCode().toLowerCase())
                .setPaymentMethod(request.getPaymentMethodId())
                .setConfirm(true)
                .build();
            
            PaymentIntent intent = stripeClient.paymentIntents().create(params);
            
            if ("succeeded".equals(intent.getStatus())) {
                return PaymentResult.success(
                    PaymentId.of(intent.getId()),
                    request.getAmount()
                );
            } else {
                return PaymentResult.failed("付款未完成：" + intent.getStatus());
            }
            
        } catch (StripeException e) {
            return PaymentResult.failed("付款處理失敗：" + e.getMessage());
        }
    }
    
    @Override
    public RefundResult processRefund(RefundRequest request) {
        try {
            RefundCreateParams params = RefundCreateParams.builder()
                .setPaymentIntent(request.getPaymentId().getValue())
                .setAmount(request.getAmount().longValue() * 100)
                .build();
            
            Refund refund = stripeClient.refunds().create(params);
            
            return RefundResult.success(
                RefundId.of(refund.getId()),
                request.getAmount()
            );
            
        } catch (StripeException e) {
            return RefundResult.failed("退款處理失敗：" + e.getMessage());
        }
    }
}

@ExtendWith(MockitoExtension.class)
class OrderTest {
    
    private CustomerId customerId;
    private List<OrderItem> orderItems;
    
    @BeforeEach
    void setUp() {
        customerId = CustomerId.of("CUST001");
        orderItems = Arrays.asList(
            new OrderItem(BookId.of("BOOK001"), "Java 程式設計", 2, Money.of(500)),
            new OrderItem(BookId.of("BOOK002"), "Spring Boot 實戰", 1, Money.of(600))
        );
    }
    
    @Test
    @DisplayName("建立訂單 - 成功案例")
    void createOrder_Success() {
        // Given & When
        Order order = Order.create(customerId, orderItems);
        
        // Then
        assertThat(order.getId()).isNotNull();
        assertThat(order.getCustomerId()).isEqualTo(customerId);
        assertThat(order.getItems()).hasSize(2);
        assertThat(order.getStatus()).isEqualTo(OrderStatus.PENDING);
        assertThat(order.getTotalAmount()).isEqualTo(Money.of(1600)); // 500*2 + 600*1
    }
    
    @Test
    @DisplayName("確認訂單 - 成功案例")
    void confirmOrder_Success() {
        // Given
        Order order = Order.create(customerId, orderItems);
        PaymentId paymentId = PaymentId.of("PAY001");
        
        // When
        order.confirm(paymentId);
        
        // Then
        assertThat(order.getStatus()).isEqualTo(OrderStatus.CONFIRMED);
        assertThat(order.getPaymentId()).isEqualTo(paymentId);
        assertThat(order.getConfirmedAt()).isNotNull();
    }
    
    @Test
    @DisplayName("確認訂單 - 狀態不正確時拋出例外")
    void confirmOrder_ThrowsException_WhenStatusIsNotPending() {
        // Given
        Order order = Order.create(customerId, orderItems);
        order.confirm(PaymentId.of("PAY001")); // 先確認一次
        
        // When & Then
        assertThatThrownBy(() -> order.confirm(PaymentId.of("PAY002")))
            .isInstanceOf(IllegalOrderStateException.class)
            .hasMessageContaining("只有待處理的訂單可以確認");
    }
    
    @Test
    @DisplayName("取消訂單 - 成功案例")
    void cancelOrder_Success() {
        // Given
        Order order = Order.create(customerId, orderItems);
        String reason = "客戶要求取消";
        
        // When
        order.cancel(reason);
        
        // Then
        assertThat(order.getStatus()).isEqualTo(OrderStatus.CANCELLED);
    }
    
    @Test
    @DisplayName("建立訂單 - 空項目清單時拋出例外")
    void createOrder_ThrowsException_WhenItemsIsEmpty() {
        // Given
        List<OrderItem> emptyItems = Collections.emptyList();
        
        // When & Then
        assertThatThrownBy(() -> Order.create(customerId, emptyItems))
            .isInstanceOf(IllegalArgumentException.class)
            .hasMessageContaining("訂單至少要有一個項目");
    }
}

@ExtendWith(MockitoExtension.class)
class MoneyTest {
    
    @Test
    @DisplayName("金額加法 - 相同幣別")
    void add_SameCurrency() {
        // Given
        Money money1 = Money.of(100);
        Money money2 = Money.of(200);
        
        // When
        Money result = money1.add(money2);
        
        // Then
        assertThat(result.getAmount()).isEqualByComparingTo(new BigDecimal("300"));
        assertThat(result.getCurrency()).isEqualTo(Currency.getInstance("TWD"));
    }
    
    @Test
    @DisplayName("金額加法 - 不同幣別時拋出例外")
    void add_ThrowsException_WhenDifferentCurrency() {
        // Given
        Money twd = new Money(new BigDecimal("100"), Currency.getInstance("TWD"));
        Money usd = new Money(new BigDecimal("100"), Currency.getInstance("USD"));
        
        // When & Then
        assertThatThrownBy(() -> twd.add(usd))
            .isInstanceOf(IllegalArgumentException.class)
            .hasMessageContaining("不同幣別無法運算");
    }
    
    @Test
    @DisplayName("金額乘法")
    void multiply() {
        // Given
        Money money = Money.of(150);
        
        // When
        Money result = money.multiply(3);
        
        // Then
        assertThat(result.getAmount()).isEqualByComparingTo(new BigDecimal("450"));
    }
}

@ExtendWith(MockitoExtension.class)
class CreateOrderUseCaseTest {
    
    @Mock private OrderRepository orderRepository;
    @Mock private BookRepository bookRepository;
    @Mock private CustomerRepository customerRepository;
    @Mock private InventoryService inventoryService;
    @Mock private OrderPricingService pricingService;
    @Mock private EventPublisher eventPublisher;
    
    @InjectMocks
    private CreateOrderUseCase useCase;
    
    private Customer customer;
    private List<Book> books;
    private CreateOrderCommand command;
    
    @BeforeEach
    void setUp() {
        customer = Customer.create(CustomerId.of("CUST001"), "張三");
        
        books = Arrays.asList(
            Book.create(BookId.of("BOOK001"), "Java 程式設計", "作者A", Money.of(500)),
            Book.create(BookId.of("BOOK002"), "Spring Boot 實戰", "作者B", Money.of(600))
        );
        
        command = CreateOrderCommand.builder()
            .customerId(customer.getId())
            .addItem(books.get(0).getId(), 2)
            .addItem(books.get(1).getId(), 1)
            .build();
    }
    
    @Test
    @DisplayName("建立訂單 - 成功案例")
    void createOrder_Success() {
        // Given
        when(customerRepository.findById(customer.getId()))
            .thenReturn(Optional.of(customer));
        
        when(bookRepository.findByIds(anyList()))
            .thenReturn(books);
        
        when(inventoryService.isAvailable(any(BookId.class), anyInt()))
            .thenReturn(true);
        
        when(pricingService.calculateOrderPrice(any(Order.class), eq(customer)))
            .thenReturn(Money.of(1500)); // 套用折扣後
        
        // When
        CreateOrderResult result = useCase.createOrder(command);
        
        // Then
        assertThat(result.isSuccess()).isTrue();
        assertThat(result.getOrder()).isNotNull();
        assertThat(result.getOrder().getCustomerId()).isEqualTo(customer.getId());
        
        // 驗證互動
        verify(orderRepository).save(any(Order.class));
        verify(inventoryService).reserveStock(anyList());
        verify(eventPublisher).publish(any(OrderCreatedEvent.class));
    }
    
    @Test
    @DisplayName("建立訂單 - 客戶不存在時失敗")
    void createOrder_Fails_WhenCustomerNotFound() {
        // Given
        when(customerRepository.findById(customer.getId()))
            .thenReturn(Optional.empty());
        
        // When
        CreateOrderResult result = useCase.createOrder(command);
        
        // Then
        assertThat(result.isSuccess()).isFalse();
        assertThat(result.getErrorMessage()).contains("客戶不存在");
        
        // 驗證沒有進行其他操作
        verify(orderRepository, never()).save(any());
        verify(inventoryService, never()).reserveStock(any());
        verify(eventPublisher, never()).publish(any());
    }
    
    @Test
    @DisplayName("建立訂單 - 庫存不足時失敗")
    void createOrder_Fails_WhenInsufficientInventory() {
        // Given
        when(customerRepository.findById(customer.getId()))
            .thenReturn(Optional.of(customer));
        
        when(bookRepository.findByIds(anyList()))
            .thenReturn(books);
        
        when(inventoryService.isAvailable(books.get(0).getId(), 2))
            .thenReturn(false); // 第一本書庫存不足
        
        // When
        CreateOrderResult result = useCase.createOrder(command);
        
        // Then
        assertThat(result.isSuccess()).isFalse();
        assertThat(result.getErrorMessage()).contains("庫存不足");
        
        verify(orderRepository, never()).save(any());
        verify(inventoryService, never()).reserveStock(any());
    }
}

@SpringBootTest
@Testcontainers
@Transactional
class OrderIntegrationTest {
    
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:13")
            .withDatabaseName("testdb")
            .withUsername("test")
            .withPassword("test");
    
    @Autowired
    private OrderManagement orderManagement;
    
    @Autowired
    private TestDataBuilder testDataBuilder;
    
    @MockBean
    private PaymentProcessor paymentProcessor;
    
    @MockBean
    private EmailNotifier emailNotifier;
    
    @Test
    @DisplayName("完整訂單流程 - 從建立到確認")
    void completeOrderFlow() {
        // Given - 準備測試資料
        Customer customer = testDataBuilder.createCustomer("張三", "zhang@example.com");
        Book book1 = testDataBuilder.createBook("Java 程式設計", Money.of(500), 10);
        Book book2 = testDataBuilder.createBook("Spring Boot 實戰", Money.of(600), 5);
        
        CreateOrderCommand createCommand = CreateOrderCommand.builder()
            .customerId(customer.getId())
            .addItem(book1.getId(), 2)
            .addItem(book2.getId(), 1)
            .build();
        
        when(paymentProcessor.processPayment(any(PaymentRequest.class)))
            .thenReturn(PaymentResult.success(PaymentId.of("PAY001"), Money.of(1600)));
        
        // When - 建立訂單
        CreateOrderResult createResult = orderManagement.createOrder(createCommand);
        
        // Then - 驗證訂單建立
        assertThat(createResult.isSuccess()).isTrue();
        Order createdOrder = createResult.getOrder();
        assertThat(createdOrder.getStatus()).isEqualTo(OrderStatus.PENDING);
        
        // When - 處理付款並確認訂單
        PaymentRequest paymentRequest = new PaymentRequest(
            createdOrder.getTotalAmount(),
            "pm_test_card"
        );
        
        PaymentResult paymentResult = paymentProcessor.processPayment(paymentRequest);
        
        if (paymentResult.isSuccess()) {
            ConfirmOrderCommand confirmCommand = new ConfirmOrderCommand(
                createdOrder.getId(),
                paymentResult.getPaymentId()
            );
            
            ConfirmOrderResult confirmResult = orderManagement.confirmOrder(confirmCommand);
            
            // Then - 驗證訂單確認
            assertThat(confirmResult.isSuccess()).isTrue();
            
            OrderDetails orderDetails = orderManagement.getOrderDetails(createdOrder.getId());
            assertThat(orderDetails.getStatus()).isEqualTo(OrderStatus.CONFIRMED);
            assertThat(orderDetails.getPaymentId()).isEqualTo(paymentResult.getPaymentId());
        }
        
        // 驗證通知已發送
        verify(emailNotifier).sendOrderConfirmation(any(Order.class), eq(customer));
    }
    
    @Test
    @DisplayName("訂單取消流程")
    void cancelOrderFlow() {
        // Given
        Customer customer = testDataBuilder.createCustomer("李四", "li@example.com");
        Order order = testDataBuilder.createPendingOrder(customer.getId());
        
        CancelOrderCommand cancelCommand = new CancelOrderCommand(
            order.getId(),
            "客戶要求取消"
        );
        
        // When
        CancelOrderResult result = orderManagement.cancelOrder(cancelCommand);
        
        // Then
        assertThat(result.isSuccess()).isTrue();
        
        OrderDetails orderDetails = orderManagement.getOrderDetails(order.getId());
        assertThat(orderDetails.getStatus()).isEqualTo(OrderStatus.CANCELLED);
        
        verify(emailNotifier).sendOrderCancellation(any(Order.class), eq("客戶要求取消"));
    }
}

// 錯誤：Port 包含了 JPA 特定的註解和方法
public interface OrderRepository {
    @Query("SELECT o FROM OrderEntity o WHERE o.customerId = :customerId")
    List<Order> findByCustomerId(@Param("customerId") String customerId);  // 洩漏 JPA 實作
    
    @Modifying
    @Query("UPDATE OrderEntity o SET o.status = :status WHERE o.id = :id")
    void updateStatus(@Param("id") String id, @Param("status") String status);  // 洩漏 SQL
    
    // 直接依賴 Spring Data 的分頁介面
    Page<Order> findAll(Pageable pageable);  // 洩漏 Spring 技術
}

// 正確：Port 只包含領域概念
public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(OrderId id);
    List<Order> findByCustomerId(CustomerId customerId);
    void updateStatus(OrderId id, OrderStatus status);
    
    // 使用領域特定的分頁概念
    OrderPage findAll(OrderFilter filter, PageRequest pageRequest);
}

// 領域特定的分頁結果
public class OrderPage {
    private final List<Order> orders;
    private final int totalPages;
    private final long totalElements;
    private final boolean hasNext;
    
    // 建構子和方法...
}

// Adapter 負責技術實作
@Repository
public class JpaOrderRepository implements OrderRepository {
    private final SpringDataOrderRepository springRepository;
    
    @Override
    public OrderPage findAll(OrderFilter filter, PageRequest pageRequest) {
        // 轉換為 Spring Data 的 Pageable
        Pageable pageable = PageRequest.of(
            pageRequest.getPageNumber(),
            pageRequest.getPageSize()
        );
        
        Page<OrderEntity> springPage = springRepository.findAll(
            OrderSpecification.fromFilter(filter),
            pageable
        );
        
        // 轉換回領域物件
        List<Order> orders = springPage.getContent()
            .stream()
            .map(this::toDomain)
            .collect(Collectors.toList());
        
        return new OrderPage(
            orders,
            springPage.getTotalPages(),
            springPage.getTotalElements(),
            springPage.hasNext()
        );
    }
}

// 錯誤：領域物件被 JPA 註解污染
@Entity
@Table(name = "orders")
public class Order {
    @Id
    @Column(name = "order_id")
    private String id;  // 使用 String 而非 Value Object
    
    @Column(name = "customer_id")
    private String customerId;  // 使用 String 而非 Value Object
    
    @Enumerated(EnumType.STRING)
    private OrderStatus status;
    
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<OrderItemEntity> items;  // 直接使用 Entity
    
    // 業務邏輯與持久化邏輯混合
    @PrePersist
    public void prePersist() {
        this.createdAt = LocalDateTime.now();
    }
    
    public void confirm() {
        this.status = OrderStatus.CONFIRMED;
        // 直接呼叫 JPA 方法 - 違反了領域純粹性
        EntityManager em = // 某種方式取得 EntityManager
        em.merge(this);
    }
}

// 正確：純粹的領域物件，不包含任何技術細節
public class Order {
    private final OrderId id;
    private final CustomerId customerId;
    private final List<OrderItem> items;
    private OrderStatus status;
    private final LocalDateTime createdAt;
    private LocalDateTime confirmedAt;
    
    // 工廠方法
    public static Order create(CustomerId customerId, List<OrderItem> items) {
        return new Order(
            OrderId.generate(),
            customerId,
            items,
            OrderStatus.PENDING,
            LocalDateTime.now()
        );
    }
    
    // 重建方法（用於從持久化層載入）
    public static Order reconstitute(OrderId id,
                                   CustomerId customerId,
                                   List<OrderItem> items,
                                   OrderStatus status,
                                   LocalDateTime createdAt,
                                   LocalDateTime confirmedAt) {
        return new Order(id, customerId, items, status, createdAt, confirmedAt);
    }
    
    private Order(OrderId id, CustomerId customerId, List<OrderItem> items,
                  OrderStatus status, LocalDateTime createdAt) {
        this.id = Objects.requireNonNull(id);
        this.customerId = Objects.requireNonNull(customerId);
        this.items = new ArrayList<>(Objects.requireNonNull(items));
        this.status = Objects.requireNonNull(status);
        this.createdAt = Objects.requireNonNull(createdAt);
    }
    
    // 純粹的業務行為
    public void confirm() {
        if (this.status != OrderStatus.PENDING) {
            throw new IllegalOrderStateException("只有待處理的訂單可以確認");
        }
        
        this.status = OrderStatus.CONFIRMED;
        this.confirmedAt = LocalDateTime.now();
        
        // 發布領域事件，而非直接操作持久化
        DomainEvents.publish(new OrderConfirmedEvent(this.id));
    }
    
    // 其他業務方法...
}

// 分離的 JPA Entity
@Entity
@Table(name = "orders")
class OrderEntity {
    @Id
    @Column(name = "order_id")
    private String id;
    
    @Column(name = "customer_id")
    private String customerId;
    
    @Enumerated(EnumType.STRING)
    private OrderStatus status;
    
    @Column(name = "created_at")
    private LocalDateTime createdAt;
    
    @Column(name = "confirmed_at")
    private LocalDateTime confirmedAt;
    
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<OrderItemEntity> items;
    
    // 只包含 getter/setter，不包含業務邏輯
}

// 錯誤：為簡單的 CRUD 操作建立過多層次
public interface OrderReadRepository {
    Optional<Order> findById(OrderId id);
}

public interface OrderWriteRepository {
    void save(Order order);
}

public interface OrderQueryRepository {
    List<Order> findByCustomerId(CustomerId customerId);
}

// 每個簡單操作都有獨立的 Use Case
public class FindOrderByIdUseCase {
    private final OrderReadRepository repository;
    
    public Optional<Order> execute(OrderId id) {
        return repository.findById(id);  // 只是簡單轉發
    }
}

public class SaveOrderUseCase {
    private final OrderWriteRepository repository;
    
    public void execute(Order order) {
        repository.save(order);  // 只是簡單轉發
    }
}

// 過度複雜的抽象工廠
public interface OrderRepositoryFactory {
    OrderReadRepository createReadRepository();
    OrderWriteRepository createWriteRepository();
    OrderQueryRepository createQueryRepository();
}

public class JpaOrderRepositoryFactory implements OrderRepositoryFactory {
    // 大量的工廠方法...
}

// 正確：合理的抽象層次
public interface OrderRepository {
    // 將相關操作組合在一個介面中
    void save(Order order);
    Optional<Order> findById(OrderId id);
    List<Order> findByCustomerId(CustomerId customerId);
    List<Order> findByStatus(OrderStatus status);
    void delete(OrderId id);
}

// 只為有意義的業務場景建立 Use Case
public class CreateOrderUseCase {
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    
    public CreateOrderResult execute(CreateOrderCommand command) {
        // 包含複雜的業務邏輯編排
        // 1. 驗證
        // 2. 業務規則檢查
        // 3. 外部服務協調
        // 4. 事件發布
        return result;
    }
}

// 簡單的查詢可以直接通過 Repository
public class OrderQueryService {
    private final OrderRepository orderRepository;
    
    public Optional<OrderDetails> getOrderDetails(OrderId id) {
        return orderRepository.findById(id)
                             .map(OrderDetails::from);
    }
    
    public List<OrderSummary> getCustomerOrders(CustomerId customerId) {
        return orderRepository.findByCustomerId(customerId)
                             .stream()
                             .map(OrderSummary::from)
                             .collect(Collectors.toList());
    }
}

// 錯誤：測試 JPA Repository 的實作細節
@DataJpaTest
class JpaOrderRepositoryTest {
    
    @Autowired
    private TestEntityManager entityManager;
    
    @Autowired
    private SpringDataOrderRepository repository;
    
    @Test
    void shouldSaveOrderEntity() {
        // 測試 JPA 的基本 CRUD 功能，而非業務邏輯
        OrderEntity entity = new OrderEntity();
        entity.setId("ORDER001");
        entity.setCustomerId("CUST001");
        entity.setStatus(OrderStatus.PENDING);
        
        OrderEntity saved = repository.save(entity);
        
        assertThat(saved.getId()).isEqualTo("ORDER001");
        // 這種測試沒有太大價值，主要是測試 JPA 框架
    }
}

// 錯誤：在單元測試中使用真實的資料庫
@SpringBootTest
@Transactional
class CreateOrderUseCaseTest {
    
    @Autowired
    private CreateOrderUseCase useCase;
    
    @Autowired
    private OrderRepository orderRepository;  // 真實的 Repository
    
    @Test
    void shouldCreateOrder() {
        // 依賴真實的資料庫，測試變慢且不穩定
        CreateOrderCommand command = // ...
        CreateOrderResult result = useCase.execute(command);
        
        // 驗證資料庫中的資料
        Optional<Order> saved = orderRepository.findById(result.getOrderId());
        assertThat(saved).isPresent();
    }
}

// 正確：測試領域物件的業務邏輯
class OrderTest {
    
    @Test
    @DisplayName("確認訂單應該變更狀態並記錄確認時間")
    void confirmOrder_ShouldChangeStatusAndRecordTime() {
        // Given
        Order order = createPendingOrder();
        PaymentId paymentId = PaymentId.of("PAY001");
        
        // When
        order.confirm(paymentId);
        
        // Then
        assertThat(order.getStatus()).isEqualTo(OrderStatus.CONFIRMED);
        assertThat(order.getPaymentId()).isEqualTo(paymentId);
        assertThat(order.getConfirmedAt()).isNotNull();
    }
    
    @Test
    @DisplayName("非待處理狀態的訂單無法確認")
    void confirmOrder_ShouldThrowException_WhenNotPending() {
        // Given
        Order order = createConfirmedOrder();
        
        // When & Then
        assertThatThrownBy(() -> order.confirm(PaymentId.of("PAY001")))
            .isInstanceOf(IllegalOrderStateException.class);
    }
}

// 正確：使用 Mock 測試 Use Case 的編排邏輯
@ExtendWith(MockitoExtension.class)
class CreateOrderUseCaseTest {
    
    @Mock private OrderRepository orderRepository;
    @Mock private PaymentService paymentService;
    @Mock private InventoryService inventoryService;
    
    @InjectMocks
    private CreateOrderUseCase useCase;
    
    @Test
    @DisplayName("建立訂單應該檢查庫存、處理付款並儲存訂單")
    void createOrder_ShouldCheckInventoryProcessPaymentAndSaveOrder() {
        // Given
        CreateOrderCommand command = // ...
        when(inventoryService.isAvailable(any(), anyInt())).thenReturn(true);
        when(paymentService.processPayment(any())).thenReturn(PaymentResult.success());
        
        // When
        CreateOrderResult result = useCase.execute(command);
        
        // Then
        assertThat(result.isSuccess()).isTrue();
        
        // 驗證互動順序和呼叫
        InOrder inOrder = inOrder(inventoryService, paymentService, orderRepository);
        inOrder.verify(inventoryService).isAvailable(any(), anyInt());
        inOrder.verify(paymentService).processPayment(any());
        inOrder.verify(orderRepository).save(any());
    }
}

// 正確：契約測試確保 Adapter 符合 Port 的期望
abstract class OrderRepositoryContractTest {
    
    protected abstract OrderRepository createRepository();
    
    @Test
    void save_ShouldPersistOrder() {
        // Given
        OrderRepository repository = createRepository();
        Order order = createTestOrder();
        
        // When
        repository.save(order);
        
        // Then
        Optional<Order> found = repository.findById(order.getId());
        assertThat(found).isPresent();
        assertThat(found.get().getId()).isEqualTo(order.getId());
    }
}

// JPA 實作的契約測試
@DataJpaTest
class JpaOrderRepositoryContractTest extends OrderRepositoryContractTest {
    
    @Autowired
    private SpringDataOrderRepository springRepository;
    
    @Override
    protected OrderRepository createRepository() {
        return new JpaOrderRepository(springRepository, new OrderMapper());
    }
}

// 錯誤：在多個地方硬編碼配置
@Component
public class EmailService {
    private final String smtpHost = "smtp.gmail.com";  // 硬編碼
    private final int smtpPort = 587;  // 硬編碼
    
    public void sendEmail(String to, String subject, String content) {
        // 實作...
    }
}

@Repository
public class JpaOrderRepository {
    // 在 Repository 中包含業務規則配置
    private static final int MAX_ORDERS_PER_CUSTOMER = 10;  // 應該在 Domain 層
    
    public void save(Order order) {
        List<Order> customerOrders = findByCustomerId(order.getCustomerId());
        if (customerOrders.size() >= MAX_ORDERS_PER_CUSTOMER) {
            throw new RuntimeException("客戶訂單數量超過限制");  // 業務規則不應在此層
        }
        // ...
    }
}

@Controller
public class OrderController {
    // 在 Controller 中包含業務配置
    private static final BigDecimal FREE_SHIPPING_THRESHOLD = new BigDecimal("1000");
    
    @PostMapping("/orders")
    public ResponseEntity<?> createOrder(@RequestBody OrderRequest request) {
        // 在 Controller 中處理業務邏輯
        if (request.getTotalAmount().compareTo(FREE_SHIPPING_THRESHOLD) >= 0) {
            // 免運費邏輯
        }
        // ...
    }
}

// 正確：使用配置類集中管理
@Configuration
@ConfigurationProperties(prefix = "orders")
@Data
public class OrdersConfiguration {
    private PaymentConfig payment = new PaymentConfig();
    private ShippingConfig shipping = new ShippingConfig();
    private BusinessRulesConfig businessRules = new BusinessRulesConfig();
    
    @Data
    public static class PaymentConfig {
        private String provider = "stripe";
        private String apiKey;
        private Duration timeout = Duration.ofSeconds(30);
    }
    
    @Data
    public static class ShippingConfig {
        private BigDecimal freeShippingThreshold = new BigDecimal("1000");
        private BigDecimal defaultShippingFee = new BigDecimal("100");
    }
    
    @Data
    public static class BusinessRulesConfig {
        private int maxOrdersPerCustomer = 10;
        private Duration orderExpirationTime = Duration.ofHours(24);
    }
}

// 在 Domain Service 中使用配置
@Component
public class OrderBusinessRules {
    private final OrdersConfiguration config;
    
    public OrderBusinessRules(OrdersConfiguration config) {
        this.config = config;
    }
    
    public void validateCustomerOrderLimit(Customer customer, int currentOrderCount) {
        if (currentOrderCount >= config.getBusinessRules().getMaxOrdersPerCustomer()) {
            throw new OrderLimitExceededException(
                customer.getId(), 
                config.getBusinessRules().getMaxOrdersPerCustomer()
            );
        }
    }
    
    public boolean qualifiesForFreeShipping(Money orderAmount) {
        return orderAmount.isGreaterThanOrEqual(
            new Money(config.getShipping().getFreeShippingThreshold())
        );
    }
}

// 訂單管理 Bounded Context
package com.example.ecommerce.order;

// 訂單聚合根
public class Order {
    private final OrderId id;
    private final CustomerId customerId;  // 參考客戶管理 Context
    private final List<OrderItem> items;
    private OrderStatus status;
    private Money totalAmount;
    
    // 領域邏輯只關注訂單相關的業務規則
    public void confirm() {
        if (status != OrderStatus.PENDING) {
            throw new IllegalOrderStateException("只有待處理的訂單可以確認");
        }
        
        this.status = OrderStatus.CONFIRMED;
        
        // 發布領域事件，通知其他 Context
        DomainEvents.publish(new OrderConfirmedEvent(this.id, this.customerId));
    }
}

// 與其他 Context 的集成透過 Port
public interface CustomerService {
    Optional<Customer> findById(CustomerId id);
    boolean isEligibleForDiscount(CustomerId id);
}

public interface InventoryService {
    boolean isAvailable(ProductId productId, int quantity);
    void reserveStock(List<StockReservation> reservations);
}

// 庫存管理 Bounded Context
package com.example.ecommerce.inventory;

public class InventoryItem {
    private final ProductId productId;
    private int availableQuantity;
    private int reservedQuantity;
    
    public boolean canReserve(int quantity) {
        return availableQuantity >= quantity;
    }
    
    public void reserve(int quantity) {
        if (!canReserve(quantity)) {
            throw new InsufficientStockException(productId, quantity);
        }
        
        this.availableQuantity -= quantity;
        this.reservedQuantity += quantity;
        
        DomainEvents.publish(new StockReservedEvent(productId, quantity));
    }
}

// Order Aggregate 的完整設計
public class Order {  // Aggregate Root
    private final OrderId id;
    private final CustomerId customerId;
    private final List<OrderItem> items;  // 內部實體
    private final ShippingAddress shippingAddress;  // 值物件
    private OrderStatus status;
    private Money totalAmount;
    private final LocalDateTime createdAt;
    
    // Aggregate 的不變性條件
    private void ensureInvariants() {
        if (items.isEmpty()) {
            throw new IllegalStateException("訂單必須至少有一個項目");
        }
        
        if (totalAmount.isNegative()) {
            throw new IllegalStateException("訂單總金額不能為負數");
        }
        
        // 檢查訂單項目的總金額是否與訂單總金額一致
        Money calculatedTotal = items.stream()
            .map(OrderItem::getSubtotal)
            .reduce(Money.ZERO, Money::add);
        
        if (!totalAmount.equals(calculatedTotal)) {
            throw new IllegalStateException("訂單總金額與項目總和不一致");
        }
    }
    
    // Aggregate 的業務行為
    public void addItem(Product product, int quantity) {
        OrderItem newItem = new OrderItem(product.getId(), product.getName(), 
                                        quantity, product.getPrice());
        this.items.add(newItem);
        this.totalAmount = calculateTotalAmount();
        
        ensureInvariants();
    }
    
    public void removeItem(ProductId productId) {
        this.items.removeIf(item -> item.getProductId().equals(productId));
        this.totalAmount = calculateTotalAmount();
        
        ensureInvariants();
    }
    
    // 只有 Aggregate Root 可以被外部直接存取
    public void confirm() {
        if (status != OrderStatus.PENDING) {
            throw new IllegalOrderStateException("只有待處理的訂單可以確認");
        }
        
        ensureInvariants();
        
        this.status = OrderStatus.CONFIRMED;
        
        // 發布領域事件
        DomainEvents.publish(new OrderConfirmedEvent(this.id));
    }
    
    private Money calculateTotalAmount() {
        return items.stream()
                   .map(OrderItem::getSubtotal)
                   .reduce(Money.ZERO, Money::add);
    }
}

// OrderItem 內部實體 - 不能直接從外部存取
class OrderItem {
    private final ProductId productId;
    private final String productName;
    private int quantity;
    private final Money unitPrice;
    
    // 只能透過 Order 來修改
    void updateQuantity(int newQuantity) {
        if (newQuantity <= 0) {
            throw new IllegalArgumentException("數量必須大於 0");
        }
        this.quantity = newQuantity;
    }
    
    Money getSubtotal() {
        return unitPrice.multiply(quantity);
    }
}

// Aggregate 的 Repository Port
public interface OrderRepository {
    void save(Order order);  // 儲存整個 Aggregate
    Optional<Order> findById(OrderId id);
    
    // 不提供直接操作 OrderItem 的方法
    // OrderItem 只能透過 Order 來操作
}

// 領域事件定義
public abstract class DomainEvent {
    private final String eventId;
    private final LocalDateTime occurredOn;
    private final String eventType;
    
    protected DomainEvent(String eventType) {
        this.eventId = UUID.randomUUID().toString();
        this.occurredOn = LocalDateTime.now();
        this.eventType = eventType;
    }
    
    // Getters...
}

public class OrderConfirmedEvent extends DomainEvent {
    private final OrderId orderId;
    private final CustomerId customerId;
    private final Money totalAmount;
    
    public OrderConfirmedEvent(OrderId orderId, CustomerId customerId, Money totalAmount) {
        super("OrderConfirmed");
        this.orderId = orderId;
        this.customerId = customerId;
        this.totalAmount = totalAmount;
    }
    
    // Getters...
}

public class PaymentProcessedEvent extends DomainEvent {
    private final PaymentId paymentId;
    private final OrderId orderId;
    private final Money amount;
    private final PaymentStatus status;
    
    public PaymentProcessedEvent(PaymentId paymentId, OrderId orderId, 
                                Money amount, PaymentStatus status) {
        super("PaymentProcessed");
        this.paymentId = paymentId;
        this.orderId = orderId;
        this.amount = amount;
        this.status = status;
    }
}

// 事件發布 Port
public interface EventPublisher {
    void publish(DomainEvent event);
    void publishAll(List<DomainEvent> events);
}

// 事件處理 Port
public interface EventHandler<T extends DomainEvent> {
    void handle(T event);
    boolean canHandle(DomainEvent event);
}

// 領域事件的集中管理
public class DomainEvents {
    private static final ThreadLocal<List<DomainEvent>> events = 
        ThreadLocal.withInitial(ArrayList::new);
    
    public static void publish(DomainEvent event) {
        events.get().add(event);
    }
    
    public static List<DomainEvent> getEvents() {
        return events.get();
    }
    
    public static void clearEvents() {
        events.get().clear();
    }
    
    public static void clearAll() {
        events.remove();
    }
}

// Application Service 中處理事件
@Component
@Transactional
public class OrderApplicationService {
    private final OrderRepository orderRepository;
    private final EventPublisher eventPublisher;
    
    public void confirmOrder(ConfirmOrderCommand command) {
        // 1. 載入聚合
        Order order = orderRepository.findById(command.getOrderId())
            .orElseThrow(() -> new OrderNotFoundException(command.getOrderId()));
        
        // 2. 執行業務邏輯
        order.confirm();
        
        // 3. 儲存聚合
        orderRepository.save(order);
        
        // 4. 發布領域事件
        List<DomainEvent> events = DomainEvents.getEvents();
        eventPublisher.publishAll(events);
        DomainEvents.clearEvents();
    }
}

// 事件處理器實作
@Component
public class OrderConfirmedEventHandler implements EventHandler<OrderConfirmedEvent> {
    private final EmailNotificationService emailService;
    private final InventoryService inventoryService;
    
    @Override
    public void handle(OrderConfirmedEvent event) {
        // 發送確認信件
        emailService.sendOrderConfirmation(event.getOrderId());
        
        // 更新庫存
        inventoryService.confirmReservation(event.getOrderId());
    }
    
    @Override
    public boolean canHandle(DomainEvent event) {
        return event instanceof OrderConfirmedEvent;
    }
}

// Infrastructure 層的事件發布實作
@Component
public class SpringEventPublisher implements EventPublisher {
    private final ApplicationEventPublisher springPublisher;
    
    @Override
    public void publish(DomainEvent event) {
        springPublisher.publishEvent(event);
    }
    
    @Override
    public void publishAll(List<DomainEvent> events) {
        events.forEach(this::publish);
    }
}

// 事件監聽器
@Component
public class DomainEventListener {
    private final List<EventHandler<? extends DomainEvent>> handlers;
    
    @EventListener
    public void handleDomainEvent(DomainEvent event) {
        handlers.stream()
            .filter(handler -> handler.canHandle(event))
            .forEach(handler -> {
                try {
                    ((EventHandler<DomainEvent>) handler).handle(event);
                } catch (Exception e) {
                    // 錯誤處理和記錄
                    log.error("處理領域事件失敗: {}", event, e);
                }
            });
    }
}

// 領域層的 Repository 介面
public interface OrderRepository {
    // 聚合層級的操作
    void save(Order order);
    void remove(Order order);
    
    // 通過聚合根的唯一識別
    Optional<Order> findById(OrderId id);
    
    // 領域特定的查詢方法
    List<Order> findPendingOrdersOlderThan(Duration age);
    List<Order> findByCustomerAndStatus(CustomerId customerId, OrderStatus status);
    
    // 規格模式查詢
    List<Order> findBySpecification(OrderSpecification specification);
    
    // 分頁查詢
    Page<Order> findAll(OrderSpecification specification, PageRequest pageRequest);
}

// 規格模式實作
public abstract class OrderSpecification {
    public abstract boolean isSatisfiedBy(Order order);
    
    public OrderSpecification and(OrderSpecification other) {
        return new AndSpecification(this, other);
    }
    
    public OrderSpecification or(OrderSpecification other) {
        return new OrSpecification(this, other);
    }
    
    public OrderSpecification not() {
        return new NotSpecification(this);
    }
}

public class OrdersByCustomerSpecification extends OrderSpecification {
    private final CustomerId customerId;
    
    public OrdersByCustomerSpecification(CustomerId customerId) {
        this.customerId = customerId;
    }
    
    @Override
    public boolean isSatisfiedBy(Order order) {
        return order.getCustomerId().equals(customerId);
    }
}

public class OrdersByStatusSpecification extends OrderSpecification {
    private final OrderStatus status;
    
    public OrdersByStatusSpecification(OrderStatus status) {
        this.status = status;
    }
    
    @Override
    public boolean isSatisfiedBy(Order order) {
        return order.getStatus().equals(status);
    }
}

public class OrdersByDateRangeSpecification extends OrderSpecification {
    private final LocalDateTime startDate;
    private final LocalDateTime endDate;
    
    public OrdersByDateRangeSpecification(LocalDateTime startDate, LocalDateTime endDate) {
        this.startDate = startDate;
        this.endDate = endDate;
    }
    
    @Override
    public boolean isSatisfiedBy(Order order) {
        LocalDateTime createdAt = order.getCreatedAt();
        return !createdAt.isBefore(startDate) && !createdAt.isAfter(endDate);
    }
}

// 複合規格實作
class AndSpecification extends OrderSpecification {
    private final OrderSpecification left;
    private final OrderSpecification right;
    
    public AndSpecification(OrderSpecification left, OrderSpecification right) {
        this.left = left;
        this.right = right;
    }
    
    @Override
    public boolean isSatisfiedBy(Order order) {
        return left.isSatisfiedBy(order) && right.isSatisfiedBy(order);
    }
}

// Infrastructure 層的實作
@Repository
public class JpaOrderRepository implements OrderRepository {
    private final SpringDataOrderRepository springRepository;
    private final OrderMapper mapper;
    private final SpecificationConverter specificationConverter;
    
    @Override
    public void save(Order order) {
        OrderEntity entity = mapper.toEntity(order);
        springRepository.save(entity);
    }
    
    @Override
    public Optional<Order> findById(OrderId id) {
        return springRepository.findById(id.getValue())
                              .map(mapper::toDomain);
    }
    
    @Override
    public List<Order> findBySpecification(OrderSpecification specification) {
        Specification<OrderEntity> jpaSpec = specificationConverter.convert(specification);
        
        return springRepository.findAll(jpaSpec)
                              .stream()
                              .map(mapper::toDomain)
                              .collect(Collectors.toList());
    }
    
    @Override
    public List<Order> findPendingOrdersOlderThan(Duration age) {
        LocalDateTime cutoffTime = LocalDateTime.now().minus(age);
        
        return springRepository.findByStatusAndCreatedAtBefore("PENDING", cutoffTime)
                              .stream()
                              .map(mapper::toDomain)
                              .collect(Collectors.toList());
    }
}

// 規格轉換器 - 將領域規格轉換為 JPA Specification
@Component
public class SpecificationConverter {
    
    public Specification<OrderEntity> convert(OrderSpecification domainSpec) {
        if (domainSpec instanceof OrdersByCustomerSpecification) {
            return convertCustomerSpec((OrdersByCustomerSpecification) domainSpec);
        } else if (domainSpec instanceof OrdersByStatusSpecification) {
            return convertStatusSpec((OrdersByStatusSpecification) domainSpec);
        } else if (domainSpec instanceof OrdersByDateRangeSpecification) {
            return convertDateRangeSpec((OrdersByDateRangeSpecification) domainSpec);
        } else if (domainSpec instanceof AndSpecification) {
            return convertAndSpec((AndSpecification) domainSpec);
        }
        
        throw new UnsupportedOperationException("不支援的規格類型: " + domainSpec.getClass());
    }
    
    private Specification<OrderEntity> convertCustomerSpec(OrdersByCustomerSpecification spec) {
        return (root, query, cb) -> 
            cb.equal(root.get("customerId"), spec.getCustomerId().getValue());
    }
    
    private Specification<OrderEntity> convertStatusSpec(OrdersByStatusSpecification spec) {
        return (root, query, cb) -> 
            cb.equal(root.get("status"), spec.getStatus().name());
    }
    
    private Specification<OrderEntity> convertDateRangeSpec(OrdersByDateRangeSpecification spec) {
        return (root, query, cb) -> 
            cb.between(root.get("createdAt"), spec.getStartDate(), spec.getEndDate());
    }
    
    private Specification<OrderEntity> convertAndSpec(AndSpecification spec) {
        Specification<OrderEntity> leftSpec = convert(spec.getLeft());
        Specification<OrderEntity> rightSpec = convert(spec.getRight());
        return leftSpec.and(rightSpec);
    }
}

// 1. 同步通訊 - HTTP API 呼叫
public interface ProductServicePort {
    Optional<Product> getProduct(ProductId productId);
    boolean isProductAvailable(ProductId productId, int quantity);
    List<Product> getProducts(List<ProductId> productIds);
}

// HTTP Client 實作
@Component
public class HttpProductServiceAdapter implements ProductServicePort {
    private final WebClient webClient;
    private final CircuitBreaker circuitBreaker;
    private final RetryTemplate retryTemplate;
    
    @Override
    public Optional<Product> getProduct(ProductId productId) {
        return circuitBreaker.executeSupplier(() -> 
            retryTemplate.execute(context -> {
                return webClient.get()
                    .uri("/api/products/{id}", productId.getValue())
                    .retrieve()
                    .bodyToMono(ProductDto.class)
                    .map(this::toDomain)
                    .blockOptional(Duration.ofSeconds(5));
            })
        );
    }
    
    @Override
    public boolean isProductAvailable(ProductId productId, int quantity) {
        try {
            return webClient.get()
                .uri("/api/products/{id}/availability", productId.getValue())
                .header("X-Required-Quantity", String.valueOf(quantity))
                .retrieve()
                .bodyToMono(Boolean.class)
                .block(Duration.ofSeconds(3));
        } catch (Exception e) {
            // 容錯機制：假設產品可用
            log.warn("檢查產品可用性失敗，使用預設值", e);
            return true;
        }
    }
    
    private Product toDomain(ProductDto dto) {
        return new Product(
            new ProductId(dto.getId()),
            dto.getName(),
            new Money(dto.getPrice()),
            dto.getDescription()
        );
    }
}

// 2. 非同步通訊 - 事件驅動
public interface EventPublisher {
    void publishOrderEvent(OrderEvent event);
    void publishPaymentEvent(PaymentEvent event);
}

// Message Queue 實作
@Component
public class RabbitMQEventPublisher implements EventPublisher {
    private final RabbitTemplate rabbitTemplate;
    
    @Override
    public void publishOrderEvent(OrderEvent event) {
        try {
            rabbitTemplate.convertAndSend(
                "order.exchange", 
                "order." + event.getEventType().toLowerCase(), 
                event
            );
            
            log.info("已發布訂單事件: {}", event);
        } catch (Exception e) {
            log.error("發布訂單事件失敗: {}", event, e);
            // 實作補償邏輯或重試機制
        }
    }
    
    @Override
    public void publishPaymentEvent(PaymentEvent event) {
        rabbitTemplate.convertAndSend(
            "payment.exchange", 
            "payment." + event.getEventType().toLowerCase(), 
            event
        );
    }
}

// 事件處理器
@Component
@RabbitListener(queues = "order.confirmed.queue")
public class OrderConfirmedEventHandler {
    private final InventoryService inventoryService;
    private final NotificationService notificationService;
    
    @RabbitHandler
    public void handle(OrderConfirmedEvent event) {
        try {
            // 更新庫存
            inventoryService.reserveStock(event.getOrderItems());
            
            // 發送通知
            notificationService.sendOrderConfirmation(event.getCustomerId(), event.getOrderId());
            
            log.info("處理訂單確認事件完成: {}", event.getOrderId());
        } catch (Exception e) {
            log.error("處理訂單確認事件失敗: {}", event.getOrderId(), e);
            // 實作死信隊列或重試機制
            throw e;
        }
    }
}

// Saga 模式實作 - 分散式交易
public class OrderSaga {
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    private final EmailService emailService;
    private final SagaRepository sagaRepository;
    
    public void processOrder(CreateOrderCommand command) {
        SagaInstance saga = new SagaInstance(command.getOrderId());
        
        try {
            // 步驟 1：建立訂單
            createOrder(command, saga);
            
            // 步驟 2：預留庫存
            reserveInventory(command, saga);
            
            // 步驟 3：處理付款
            processPayment(command, saga);
            
            // 步驟 4：發送確認信
            sendConfirmation(command, saga);
            
            saga.markAsCompleted();
            
        } catch (Exception e) {
            // 執行補償操作
            compensate(saga);
            saga.markAsFailed(e.getMessage());
        } finally {
            sagaRepository.save(saga);
        }
    }
    
    private void createOrder(CreateOrderCommand command, SagaInstance saga) {
        try {
            orderService.createOrder(command);
            saga.addCompletedStep("CREATE_ORDER");
        } catch (Exception e) {
            saga.addFailedStep("CREATE_ORDER", e.getMessage());
            throw e;
        }
    }
    
    private void reserveInventory(CreateOrderCommand command, SagaInstance saga) {
        try {
            inventoryService.reserveStock(command.getOrderItems());
            saga.addCompletedStep("RESERVE_INVENTORY");
        } catch (Exception e) {
            saga.addFailedStep("RESERVE_INVENTORY", e.getMessage());
            throw e;
        }
    }
    
    private void processPayment(CreateOrderCommand command, SagaInstance saga) {
        try {
            paymentService.processPayment(command.getPaymentInfo());
            saga.addCompletedStep("PROCESS_PAYMENT");
        } catch (Exception e) {
            saga.addFailedStep("PROCESS_PAYMENT", e.getMessage());
            throw e;
        }
    }
    
    private void sendConfirmation(CreateOrderCommand command, SagaInstance saga) {
        try {
            emailService.sendOrderConfirmation(command.getCustomerId(), command.getOrderId());
            saga.addCompletedStep("SEND_CONFIRMATION");
        } catch (Exception e) {
            // 通知失敗不需要回滾整個交易
            saga.addFailedStep("SEND_CONFIRMATION", e.getMessage());
            log.warn("發送確認信失敗，但不影響訂單處理: {}", e.getMessage());
        }
    }
    
    private void compensate(SagaInstance saga) {
        List<String> completedSteps = saga.getCompletedSteps();
        
        // 逆序執行補償操作
        for (int i = completedSteps.size() - 1; i >= 0; i--) {
            String step = completedSteps.get(i);
            
            try {
                switch (step) {
                    case "PROCESS_PAYMENT":
                        paymentService.refundPayment(saga.getOrderId());
                        break;
                    case "RESERVE_INVENTORY":
                        inventoryService.releaseReservation(saga.getOrderId());
                        break;
                    case "CREATE_ORDER":
                        orderService.cancelOrder(saga.getOrderId());
                        break;
                }
                
                log.info("補償步驟完成: {}", step);
                
            } catch (Exception e) {
                log.error("補償步驟失敗: {}, 需要人工介入", step, e);
                // 記錄到監控系統，需要人工處理
            }
        }
    }
}

// Event Sourcing 實作
public class OrderEventStore {
    private final EventStoreRepository repository;
    
    public void saveEvents(OrderId orderId, List<OrderEvent> events, int expectedVersion) {
        // 檢查樂觀鎖
        int currentVersion = getCurrentVersion(orderId);
        if (currentVersion != expectedVersion) {
            throw new ConcurrencyException("訂單版本衝突");
        }
        
        // 儲存事件
        for (OrderEvent event : events) {
            EventRecord record = new EventRecord(
                orderId.getValue(),
                event.getClass().getSimpleName(),
                serialize(event),
                ++currentVersion,
                LocalDateTime.now()
            );
            
            repository.save(record);
        }
    }
    
    public List<OrderEvent> getEvents(OrderId orderId) {
        return repository.findByAggregateIdOrderByVersion(orderId.getValue())
                        .stream()
                        .map(this::deserialize)
                        .collect(Collectors.toList());
    }
    
    public Order reconstructAggregate(OrderId orderId) {
        List<OrderEvent> events = getEvents(orderId);
        
        if (events.isEmpty()) {
            throw new AggregateNotFoundException(orderId);
        }
        
        Order order = new Order();  // 空的聚合
        
        // 重播事件
        for (OrderEvent event : events) {
            order = order.apply(event);
        }
        
        return order;
    }
}

// CQRS 實作 - 命令查詢責任分離
@Component
public class OrderCommandHandler {
    private final OrderEventStore eventStore;
    private final OrderRepository orderRepository;
    
    @Transactional
    public void handle(CreateOrderCommand command) {
        // 建立新聚合
        Order order = Order.create(command);
        
        // 取得領域事件
        List<OrderEvent> events = order.getUncommittedEvents();
        
        // 儲存事件
        eventStore.saveEvents(order.getId(), events, 0);
        
        // 更新查詢模型
        updateReadModel(order);
        
        // 發布整合事件
        publishIntegrationEvents(events);
    }
    
    @Transactional
    public void handle(ConfirmOrderCommand command) {
        // 重構聚合
        Order order = eventStore.reconstructAggregate(command.getOrderId());
        
        // 執行命令
        order.confirm();
        
        // 取得新事件
        List<OrderEvent> newEvents = order.getUncommittedEvents();
        
        // 儲存事件
        eventStore.saveEvents(order.getId(), newEvents, order.getVersion());
        
        // 更新查詢模型
        updateReadModel(order);
        
        // 發布整合事件
        publishIntegrationEvents(newEvents);
    }
    
    private void updateReadModel(Order order) {
        OrderReadModel readModel = OrderReadModel.from(order);
        orderRepository.save(readModel);
    }
}

@Component
public class OrderQueryHandler {
    private final OrderReadModelRepository repository;
    
    public OrderDto getOrder(OrderId orderId) {
        return repository.findById(orderId.getValue())
                        .map(OrderDto::from)
                        .orElseThrow(() -> new OrderNotFoundException(orderId));
    }
    
    public List<OrderDto> getOrdersByCustomer(CustomerId customerId) {
        return repository.findByCustomerId(customerId.getValue())
                        .stream()
                        .map(OrderDto::from)
                        .collect(Collectors.toList());
    }
    
    public Page<OrderDto> searchOrders(OrderSearchCriteria criteria, Pageable pageable) {
        return repository.searchByCriteria(criteria, pageable)
                        .map(OrderDto::from);
    }
}

// API Gateway 配置
@Configuration
public class GatewayConfig {
    
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            // 訂單服務路由
            .route("order-service", r -> r
                .path("/api/orders/**")
                .filters(f -> f
                    .circuitBreaker(config -> config
                        .setName("order-service-cb")
                        .setFallbackUri("forward:/fallback/orders"))
                    .retry(retryConfig -> retryConfig.setRetries(3))
                    .requestRateLimiter(config -> config
                        .setRateLimiter(redisRateLimiter())
                        .setKeyResolver(userKeyResolver())))
                .uri("lb://order-service"))
            
            // 產品服務路由
            .route("product-service", r -> r
                .path("/api/products/**")
                .filters(f -> f
                    .circuitBreaker(config -> config
                        .setName("product-service-cb")
                        .setFallbackUri("forward:/fallback/products"))
                    .addRequestHeader("X-Gateway", "spring-cloud-gateway"))
                .uri("lb://product-service"))
            
            // 客戶服務路由
            .route("customer-service", r -> r
                .path("/api/customers/**")
                .filters(f -> f
                    .circuitBreaker(config -> config
                        .setName("customer-service-cb"))
                    .addResponseHeader("X-Response-Time", "#{T(System).currentTimeMillis()}"))
                .uri("lb://customer-service"))
            
            .build();
    }
    
    @Bean
    public RedisRateLimiter redisRateLimiter() {
        return new RedisRateLimiter(10, 20, 1);
    }
    
    @Bean
    public KeyResolver userKeyResolver() {
        return exchange -> exchange.getRequest()
                                  .getHeaders()
                                  .getFirst("X-User-Id")
                                  .map(Mono::just)
                                  .orElse(Mono.just("anonymous"));
    }
}

// 服務間認證和授權
@Component
public class JwtAuthenticationFilter implements GatewayFilter {
    private final JwtTokenValidator tokenValidator;
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = extractToken(exchange.getRequest());
        
        if (token == null || !tokenValidator.isValid(token)) {
            return unauthorized(exchange.getResponse());
        }
        
        // 將用戶資訊加到請求標頭
        UserInfo userInfo = tokenValidator.getUserInfo(token);
        ServerHttpRequest modifiedRequest = exchange.getRequest()
            .mutate()
            .header("X-User-Id", userInfo.getUserId())
            .header("X-User-Roles", String.join(",", userInfo.getRoles()))
            .build();
        
        return chain.filter(exchange.mutate().request(modifiedRequest).build());
    }
    
    private String extractToken(ServerHttpRequest request) {
        String authorization = request.getHeaders().getFirst("Authorization");
        if (authorization != null && authorization.startsWith("Bearer ")) {
            return authorization.substring(7);
        }
        return null;
    }
    
    private Mono<Void> unauthorized(ServerHttpResponse response) {
        response.setStatusCode(HttpStatus.UNAUTHORIZED);
        return response.setComplete();
    }
}

// 服務發現與負載平衡
@Component
public class CustomLoadBalancerConfig {
    
    @Bean
    @LoadBalanced
    public WebClient.Builder webClientBuilder() {
        return WebClient.builder()
            .filter(ExchangeFilterFunction.ofRequestProcessor(
                clientRequest -> {
                    // 加入追蹤標頭
                    return Mono.just(ClientRequest.from(clientRequest)
                        .header("X-Trace-Id", generateTraceId())
                        .header("X-Request-Time", String.valueOf(System.currentTimeMillis()))
                        .build());
                }))
            .filter(ExchangeFilterFunction.ofResponseProcessor(
                clientResponse -> {
                    // 記錄回應時間
                    String requestTime = clientResponse.request()
                        .getHeaders().getFirst("X-Request-Time");
                    if (requestTime != null) {
                        long responseTime = System.currentTimeMillis() - Long.parseLong(requestTime);
                        log.info("服務回應時間: {}ms", responseTime);
                    }
                    return Mono.just(clientResponse);
                }));
    }
    
    private String generateTraceId() {
        return UUID.randomUUID().toString();
    }
}

// 分散式追蹤
@Component
public class TracingOrderService implements OrderService {
    private final OrderService delegate;
    private final Tracer tracer;
    
    @Override
    public Order createOrder(CreateOrderCommand command) {
        Span span = tracer.nextSpan()
            .name("create-order")
            .tag("order.customer-id", command.getCustomerId().getValue())
            .tag("order.item-count", String.valueOf(command.getItems().size()))
            .start();
        
        try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) {
            Order order = delegate.createOrder(command);
            
            span.tag("order.id", order.getId().getValue())
                .tag("order.status", order.getStatus().name())
                .tag("order.total-amount", order.getTotalAmount().toString());
            
            return order;
        } catch (Exception e) {
            span.tag("error", e.getMessage());
            throw e;
        } finally {
            span.end();
        }
    }
}

// 服務健康檢查
@Component
public class OrderServiceHealthIndicator implements HealthIndicator {
    private final OrderRepository orderRepository;
    private final PaymentServicePort paymentService;
    
    @Override
    public Health health() {
        try {
            // 檢查資料庫連線
            orderRepository.count();
            
            // 檢查關鍵依賴服務
            boolean paymentServiceHealthy = checkPaymentService();
            
            if (!paymentServiceHealthy) {
                return Health.down()
                    .withDetail("payment-service", "無法連接到付款服務")
                    .build();
            }
            
            return Health.up()
                .withDetail("database", "正常")
                .withDetail("payment-service", "正常")
                .build();
                
        } catch (Exception e) {
            return Health.down()
                .withDetail("error", e.getMessage())
                .build();
        }
    }
    
    private boolean checkPaymentService() {
        try {
            paymentService.healthCheck();
            return true;
        } catch (Exception e) {
            log.warn("付款服務健康檢查失敗", e);
            return false;
        }
    }
}

// 業務指標監控
@Component
public class OrderMetricsCollector {
    private final MeterRegistry meterRegistry;
    private final Counter orderCreatedCounter;
    private final Timer orderProcessingTimer;
    private final Gauge pendingOrdersGauge;
    
    public OrderMetricsCollector(MeterRegistry meterRegistry, OrderRepository orderRepository) {
        this.meterRegistry = meterRegistry;
        
        // 訂單建立計數器
        this.orderCreatedCounter = Counter.builder("orders.created")
            .description("建立的訂單總數")
            .register(meterRegistry);
        
        // 訂單處理時間
        this.orderProcessingTimer = Timer.builder("orders.processing.time")
            .description("訂單處理時間")
            .register(meterRegistry);
        
        // 待處理訂單數量
        this.pendingOrdersGauge = Gauge.builder("orders.pending.count")
            .description("待處理的訂單數量")
            .register(meterRegistry, this, metrics -> orderRepository.countByStatus(OrderStatus.PENDING));
    }
    
    public void recordOrderCreated(String customerType) {
        orderCreatedCounter.increment(
            Tags.of(Tag.of("customer.type", customerType))
        );
    }
    
    public void recordOrderProcessingTime(Duration processingTime, OrderStatus finalStatus) {
        orderProcessingTimer.record(processingTime, 
            Tags.of(Tag.of("final.status", finalStatus.name()))
        );
    }
}

// 日誌結構化
@Component
public class StructuredLoggingOrderService implements OrderService {
    private final OrderService delegate;
    private final ObjectMapper objectMapper;
    
    @Override
    public Order createOrder(CreateOrderCommand command) {
        String correlationId = MDC.get("correlationId");
        
        StructuredLogEvent.builder()
            .event("order.creation.started")
            .correlationId(correlationId)
            .customerId(command.getCustomerId().getValue())
            .itemCount(command.getItems().size())
            .log();
        
        try {
            long startTime = System.currentTimeMillis();
            Order order = delegate.createOrder(command);
            long processingTime = System.currentTimeMillis() - startTime;
            
            StructuredLogEvent.builder()
                .event("order.creation.completed")
                .correlationId(correlationId)
                .orderId(order.getId().getValue())
                .processingTimeMs(processingTime)
                .totalAmount(order.getTotalAmount().getAmount())
                .log();
            
            return order;
            
        } catch (Exception e) {
            StructuredLogEvent.builder()
                .event("order.creation.failed")
                .correlationId(correlationId)
                .error(e.getMessage())
                .log();
            
            throw e;
        }
    }
}

public class StructuredLogEvent {
    private final Map<String, Object> fields = new HashMap<>();
    
    public static StructuredLogEvent builder() {
        return new StructuredLogEvent();
    }
    
    public StructuredLogEvent event(String eventName) {
        fields.put("event", eventName);
        return this;
    }
    
    public StructuredLogEvent correlationId(String correlationId) {
        fields.put("correlationId", correlationId);
        return this;
    }
    
    public StructuredLogEvent orderId(String orderId) {
        fields.put("orderId", orderId);
        return this;
    }
    
    public StructuredLogEvent customerId(String customerId) {
        fields.put("customerId", customerId);
        return this;
    }
    
    public StructuredLogEvent processingTimeMs(long timeMs) {
        fields.put("processingTimeMs", timeMs);
        return this;
    }
    
    public StructuredLogEvent error(String errorMessage) {
        fields.put("error", errorMessage);
        return this;
    }
    
    public void log() {
        try {
            String jsonLog = new ObjectMapper().writeValueAsString(fields);
            log.info(jsonLog);
        } catch (Exception e) {
            log.error("無法序列化結構化日誌", e);
        }
    }
}

// 領域實體測試
@DisplayName("訂單實體測試")
class OrderTest {
    
    private CustomerId customerId;
    private Money itemPrice;
    private Product book;
    
    @BeforeEach
    void setUp() {
        customerId = new CustomerId("CUST-001");
        itemPrice = new Money(new BigDecimal("29.99"));
        book = new Product(new ProductId("BOOK-001"), "Clean Code", itemPrice, "Programming book");
    }
    
    @Nested
    @DisplayName("訂單建立")
    class OrderCreation {
        
        @Test
        @DisplayName("應該能成功建立有效的訂單")
        void should_create_valid_order() {
            // Given
            List<OrderItem> items = List.of(
                new OrderItem(book.getId(), book.getName(), 2, book.getPrice())
            );
            
            // When
            Order order = Order.create(customerId, items);
            
            // Then
            assertThat(order.getId()).isNotNull();
            assertThat(order.getCustomerId()).isEqualTo(customerId);
            assertThat(order.getStatus()).isEqualTo(OrderStatus.PENDING);
            assertThat(order.getTotalAmount()).isEqualTo(itemPrice.multiply(2));
            assertThat(order.getItems()).hasSize(1);
        }
        
        @Test
        @DisplayName("建立空訂單時應該拋出例外")
        void should_throw_exception_when_creating_empty_order() {
            // Given
            List<OrderItem> emptyItems = List.of();
            
            // When & Then
            assertThatThrownBy(() -> Order.create(customerId, emptyItems))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("訂單必須至少有一個項目");
        }
        
        @Test
        @DisplayName("建立訂單時客戶ID不能為空")
        void should_throw_exception_when_customer_id_is_null() {
            // Given
            List<OrderItem> items = List.of(
                new OrderItem(book.getId(), book.getName(), 1, book.getPrice())
            );
            
            // When & Then
            assertThatThrownBy(() -> Order.create(null, items))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("客戶ID不能為空");
        }
    }
    
    @Nested
    @DisplayName("訂單項目管理")
    class OrderItemManagement {
        
        private Order order;
        
        @BeforeEach
        void setUp() {
            List<OrderItem> items = List.of(
                new OrderItem(book.getId(), book.getName(), 1, book.getPrice())
            );
            order = Order.create(customerId, items);
        }
        
        @Test
        @DisplayName("應該能新增訂單項目")
        void should_add_order_item() {
            // Given
            Product newBook = new Product(new ProductId("BOOK-002"), "Design Patterns", 
                                         new Money(new BigDecimal("39.99")), "Design book");
            
            // When
            order.addItem(newBook, 1);
            
            // Then
            assertThat(order.getItems()).hasSize(2);
            assertThat(order.getTotalAmount()).isEqualTo(
                itemPrice.add(newBook.getPrice())
            );
        }
        
        @Test
        @DisplayName("新增相同產品時應該增加數量")
        void should_increase_quantity_when_adding_same_product() {
            // When
            order.addItem(book, 2);
            
            // Then
            assertThat(order.getItems()).hasSize(1);
            
            OrderItem item = order.getItems().get(0);
            assertThat(item.getQuantity()).isEqualTo(3);
            assertThat(order.getTotalAmount()).isEqualTo(itemPrice.multiply(3));
        }
        
        @Test
        @DisplayName("應該能移除訂單項目")
        void should_remove_order_item() {
            // Given
            Product anotherBook = new Product(new ProductId("BOOK-002"), "Design Patterns", 
                                            new Money(new BigDecimal("39.99")), "Design book");
            order.addItem(anotherBook, 1);
            
            // When
            order.removeItem(book.getId());
            
            // Then
            assertThat(order.getItems()).hasSize(1);
            assertThat(order.getItems().get(0).getProductId()).isEqualTo(anotherBook.getId());
            assertThat(order.getTotalAmount()).isEqualTo(anotherBook.getPrice());
        }
        
        @Test
        @DisplayName("移除最後一個項目時應該拋出例外")
        void should_throw_exception_when_removing_last_item() {
            // When & Then
            assertThatThrownBy(() -> order.removeItem(book.getId()))
                .isInstanceOf(IllegalStateException.class)
                .hasMessage("訂單必須至少有一個項目");
        }
    }
    
    @Nested
    @DisplayName("訂單狀態轉換")
    class OrderStatusTransition {
        
        private Order order;
        
        @BeforeEach
        void setUp() {
            List<OrderItem> items = List.of(
                new OrderItem(book.getId(), book.getName(), 1, book.getPrice())
            );
            order = Order.create(customerId, items);
        }
        
        @Test
        @DisplayName("應該能確認待處理的訂單")
        void should_confirm_pending_order() {
            // When
            order.confirm();
            
            // Then
            assertThat(order.getStatus()).isEqualTo(OrderStatus.CONFIRMED);
        }
        
        @Test
        @DisplayName("已確認的訂單不能再次確認")
        void should_not_confirm_already_confirmed_order() {
            // Given
            order.confirm();
            
            // When & Then
            assertThatThrownBy(() -> order.confirm())
                .isInstanceOf(IllegalOrderStateException.class)
                .hasMessage("只有待處理的訂單可以確認");
        }
        
        @Test
        @DisplayName("應該能取消待處理的訂單")
        void should_cancel_pending_order() {
            // When
            order.cancel("客戶要求取消");
            
            // Then
            assertThat(order.getStatus()).isEqualTo(OrderStatus.CANCELLED);
        }
        
        @Test
        @DisplayName("已確認的訂單不能取消")
        void should_not_cancel_confirmed_order() {
            // Given
            order.confirm();
            
            // When & Then
            assertThatThrownBy(() -> order.cancel("嘗試取消"))
                .isInstanceOf(IllegalOrderStateException.class)
                .hasMessage("已確認的訂單不能取消");
        }
    }
    
    @Nested
    @DisplayName("業務規則驗證")
    class BusinessRuleValidation {
        
        @Test
        @DisplayName("訂單總金額應該等於所有項目的小計總和")
        void should_ensure_total_amount_consistency() {
            // Given
            List<OrderItem> items = List.of(
                new OrderItem(new ProductId("BOOK-001"), "Book 1", 2, new Money(new BigDecimal("10.00"))),
                new OrderItem(new ProductId("BOOK-002"), "Book 2", 1, new Money(new BigDecimal("15.00")))
            );
            
            // When
            Order order = Order.create(customerId, items);
            
            // Then
            Money expectedTotal = new Money(new BigDecimal("35.00")); // (2 * 10.00) + (1 * 15.00)
            assertThat(order.getTotalAmount()).isEqualTo(expectedTotal);
        }
        
        @Test
        @DisplayName("項目數量必須大於零")
        void should_validate_item_quantity_is_positive() {
            // When & Then
            assertThatThrownBy(() -> 
                new OrderItem(book.getId(), book.getName(), 0, book.getPrice()))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("數量必須大於 0");
        }
        
        @Test
        @DisplayName("項目價格不能為負數")
        void should_validate_item_price_is_not_negative() {
            // Given
            Money negativePrice = new Money(new BigDecimal("-10.00"));
            
            // When & Then
            assertThatThrownBy(() -> 
                new OrderItem(book.getId(), book.getName(), 1, negativePrice))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("價格不能為負數");
        }
    }
}

// 值物件測試
@DisplayName("金錢值物件測試")
class MoneyTest {
    
    @Test
    @DisplayName("相同金額的 Money 物件應該相等")
    void should_be_equal_when_amounts_are_same() {
        // Given
        Money money1 = new Money(new BigDecimal("10.50"));
        Money money2 = new Money(new BigDecimal("10.50"));
        
        // Then
        assertThat(money1).isEqualTo(money2);
        assertThat(money1.hashCode()).isEqualTo(money2.hashCode());
    }
    
    @Test
    @DisplayName("應該能正確執行金錢運算")
    void should_perform_money_calculations_correctly() {
        // Given
        Money money1 = new Money(new BigDecimal("10.50"));
        Money money2 = new Money(new BigDecimal("5.25"));
        
        // When & Then
        assertThat(money1.add(money2)).isEqualTo(new Money(new BigDecimal("15.75")));
        assertThat(money1.subtract(money2)).isEqualTo(new Money(new BigDecimal("5.25")));
        assertThat(money1.multiply(2)).isEqualTo(new Money(new BigDecimal("21.00")));
    }
    
    @Test
    @DisplayName("負數金額應該拋出例外")
    void should_throw_exception_for_negative_amount() {
        // When & Then
        assertThatThrownBy(() -> new Money(new BigDecimal("-10.00")))
            .isInstanceOf(IllegalArgumentException.class)
            .hasMessage("金額不能為負數");
    }
    
    @Test
    @DisplayName("應該正確判斷金額大小")
    void should_compare_money_amounts_correctly() {
        // Given
        Money smaller = new Money(new BigDecimal("10.00"));
        Money larger = new Money(new BigDecimal("20.00"));
        
        // Then
        assertThat(smaller.isLessThan(larger)).isTrue();
        assertThat(larger.isGreaterThan(smaller)).isTrue();
        assertThat(smaller.isLessThan(smaller)).isFalse();
    }
}

// 領域服務測試
@DisplayName("訂單定價服務測試")
class OrderPricingServiceTest {
    
    private OrderPricingService pricingService;
    private DiscountPolicy mockDiscountPolicy;
    private TaxCalculator mockTaxCalculator;
    
    @BeforeEach
    void setUp() {
        mockDiscountPolicy = mock(DiscountPolicy.class);
        mockTaxCalculator = mock(TaxCalculator.class);
        pricingService = new OrderPricingService(mockDiscountPolicy, mockTaxCalculator);
    }
    
    @Test
    @DisplayName("應該正確計算訂單總價")
    void should_calculate_order_total_correctly() {
        // Given
        Order order = createTestOrder();
        Money subtotal = new Money(new BigDecimal("100.00"));
        Money discount = new Money(new BigDecimal("10.00"));
        Money tax = new Money(new BigDecimal("9.00"));
        
        when(mockDiscountPolicy.calculateDiscount(order)).thenReturn(discount);
        when(mockTaxCalculator.calculateTax(subtotal.subtract(discount))).thenReturn(tax);
        
        // When
        PricingResult result = pricingService.calculateTotal(order);
        
        // Then
        assertThat(result.getSubtotal()).isEqualTo(subtotal);
        assertThat(result.getDiscount()).isEqualTo(discount);
        assertThat(result.getTax()).isEqualTo(tax);
        assertThat(result.getTotal()).isEqualTo(new Money(new BigDecimal("99.00"))); // 100 - 10 + 9
        
        verify(mockDiscountPolicy).calculateDiscount(order);
        verify(mockTaxCalculator).calculateTax(subtotal.subtract(discount));
    }
    
    private Order createTestOrder() {
        List<OrderItem> items = List.of(
            new OrderItem(new ProductId("BOOK-001"), "Book", 1, new Money(new BigDecimal("100.00")))
        );
        return Order.create(new CustomerId("CUST-001"), items);
    }
}

// Use Case 測試
@DisplayName("建立訂單 Use Case 測試")
class CreateOrderUseCaseTest {
    
    @Mock private OrderRepository orderRepository;
    @Mock private ProductService productService;
    @Mock private CustomerService customerService;
    @Mock private EventPublisher eventPublisher;
    
    private CreateOrderUseCase useCase;
    
    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        useCase = new CreateOrderUseCase(orderRepository, productService, customerService, eventPublisher);
    }
    
    @Test
    @DisplayName("應該成功建立有效的訂單")
    void should_create_valid_order_successfully() {
        // Given
        CreateOrderCommand command = createValidCommand();
        Customer customer = createTestCustomer();
        Product product = createTestProduct();
        
        when(customerService.findById(command.getCustomerId())).thenReturn(Optional.of(customer));
        when(productService.findById(any())).thenReturn(Optional.of(product));
        when(productService.isAvailable(any(), anyInt())).thenReturn(true);
        
        // When
        OrderId result = useCase.execute(command);
        
        // Then
        assertThat(result).isNotNull();
        
        ArgumentCaptor<Order> orderCaptor = ArgumentCaptor.forClass(Order.class);
        verify(orderRepository).save(orderCaptor.capture());
        
        Order savedOrder = orderCaptor.getValue();
        assertThat(savedOrder.getCustomerId()).isEqualTo(command.getCustomerId());
        assertThat(savedOrder.getStatus()).isEqualTo(OrderStatus.PENDING);
        
        verify(eventPublisher).publish(any(OrderCreatedEvent.class));
    }
    
    @Test
    @DisplayName("客戶不存在時應該拋出例外")
    void should_throw_exception_when_customer_not_found() {
        // Given
        CreateOrderCommand command = createValidCommand();
        when(customerService.findById(command.getCustomerId())).thenReturn(Optional.empty());
        
        // When & Then
        assertThatThrownBy(() -> useCase.execute(command))
            .isInstanceOf(CustomerNotFoundException.class)
            .hasMessage("客戶不存在: " + command.getCustomerId().getValue());
        
        verify(orderRepository, never()).save(any());
        verify(eventPublisher, never()).publish(any());
    }
    
    @Test
    @DisplayName("產品不存在時應該拋出例外")
    void should_throw_exception_when_product_not_found() {
        // Given
        CreateOrderCommand command = createValidCommand();
        Customer customer = createTestCustomer();
        
        when(customerService.findById(command.getCustomerId())).thenReturn(Optional.of(customer));
        when(productService.findById(any())).thenReturn(Optional.empty());
        
        // When & Then
        assertThatThrownBy(() -> useCase.execute(command))
            .isInstanceOf(ProductNotFoundException.class);
        
        verify(orderRepository, never()).save(any());
        verify(eventPublisher, never()).publish(any());
    }
    
    @Test
    @DisplayName("產品庫存不足時應該拋出例外")
    void should_throw_exception_when_product_not_available() {
        // Given
        CreateOrderCommand command = createValidCommand();
        Customer customer = createTestCustomer();
        Product product = createTestProduct();
        
        when(customerService.findById(command.getCustomerId())).thenReturn(Optional.of(customer));
        when(productService.findById(any())).thenReturn(Optional.of(product));
        when(productService.isAvailable(any(), anyInt())).thenReturn(false);
        
        // When & Then
        assertThatThrownBy(() -> useCase.execute(command))
            .isInstanceOf(InsufficientStockException.class);
        
        verify(orderRepository, never()).save(any());
        verify(eventPublisher, never()).publish(any());
    }
    
    @Test
    @DisplayName("保存訂單失敗時應該拋出例外")
    void should_throw_exception_when_save_fails() {
        // Given
        CreateOrderCommand command = createValidCommand();
        Customer customer = createTestCustomer();
        Product product = createTestProduct();
        
        when(customerService.findById(command.getCustomerId())).thenReturn(Optional.of(customer));
        when(productService.findById(any())).thenReturn(Optional.of(product));
        when(productService.isAvailable(any(), anyInt())).thenReturn(true);
        when(orderRepository.save(any())).thenThrow(new RuntimeException("Database error"));
        
        // When & Then
        assertThatThrownBy(() -> useCase.execute(command))
            .isInstanceOf(RuntimeException.class)
            .hasMessage("Database error");
        
        verify(eventPublisher, never()).publish(any());
    }
    
    private CreateOrderCommand createValidCommand() {
        return new CreateOrderCommand(
            new CustomerId("CUST-001"),
            List.of(new CreateOrderCommand.OrderItemData(
                new ProductId("BOOK-001"), 2
            ))
        );
    }
    
    private Customer createTestCustomer() {
        return new Customer(new CustomerId("CUST-001"), "John Doe", "john@example.com");
    }
    
    private Product createTestProduct() {
        return new Product(
            new ProductId("BOOK-001"), 
            "Clean Code", 
            new Money(new BigDecimal("29.99")), 
            "Programming book"
        );
    }
}

// 應用服務測試
@DisplayName("訂單應用服務測試")
class OrderApplicationServiceTest {
    
    @Mock private CreateOrderUseCase createOrderUseCase;
    @Mock private ConfirmOrderUseCase confirmOrderUseCase;
    @Mock private CancelOrderUseCase cancelOrderUseCase;
    
    private OrderApplicationService applicationService;
    
    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        applicationService = new OrderApplicationService(
            createOrderUseCase, confirmOrderUseCase, cancelOrderUseCase
        );
    }
    
    @Test
    @DisplayName("應該委派建立訂單請求給對應的 Use Case")
    void should_delegate_create_order_to_use_case() {
        // Given
        CreateOrderCommand command = mock(CreateOrderCommand.class);
        OrderId expectedId = new OrderId("ORDER-001");
        when(createOrderUseCase.execute(command)).thenReturn(expectedId);
        
        // When
        OrderId result = applicationService.createOrder(command);
        
        // Then
        assertThat(result).isEqualTo(expectedId);
        verify(createOrderUseCase).execute(command);
    }
    
    @Test
    @DisplayName("應該委派確認訂單請求給對應的 Use Case")
    void should_delegate_confirm_order_to_use_case() {
        // Given
        ConfirmOrderCommand command = mock(ConfirmOrderCommand.class);
        
        // When
        applicationService.confirmOrder(command);
        
        // Then
        verify(confirmOrderUseCase).execute(command);
    }
    
    @Test
    @DisplayName("應該正確處理 Use Case 拋出的例外")
    void should_handle_use_case_exceptions_properly() {
        // Given
        CreateOrderCommand command = mock(CreateOrderCommand.class);
        when(createOrderUseCase.execute(command)).thenThrow(new CustomerNotFoundException("CUST-001"));
        
        // When & Then
        assertThatThrownBy(() -> applicationService.createOrder(command))
            .isInstanceOf(CustomerNotFoundException.class);
    }
}

// Repository Port 契約測試
@DisplayName("訂單儲存庫契約測試")
abstract class OrderRepositoryContractTest {
    
    protected abstract OrderRepository createRepository();
    
    private OrderRepository repository;
    private Order testOrder;
    
    @BeforeEach
    void setUp() {
        repository = createRepository();
        testOrder = createTestOrder();
    }
    
    @Test
    @DisplayName("應該能保存和載入訂單")
    void should_save_and_load_order() {
        // When
        repository.save(testOrder);
        Optional<Order> loaded = repository.findById(testOrder.getId());
        
        // Then
        assertThat(loaded).isPresent();
        assertThat(loaded.get()).isEqualTo(testOrder);
    }
    
    @Test
    @DisplayName("載入不存在的訂單應該回傳空值")
    void should_return_empty_when_order_not_found() {
        // Given
        OrderId nonExistentId = new OrderId("NON-EXISTENT");
        
        // When
        Optional<Order> result = repository.findById(nonExistentId);
        
        // Then
        assertThat(result).isEmpty();
    }
    
    @Test
    @DisplayName("應該能按客戶ID查詢訂單")
    void should_find_orders_by_customer_id() {
        // Given
        CustomerId customerId = testOrder.getCustomerId();
        repository.save(testOrder);
        
        Order anotherOrder = createTestOrderForCustomer(customerId);
        repository.save(anotherOrder);
        
        Order otherCustomerOrder = createTestOrderForCustomer(new CustomerId("OTHER"));
        repository.save(otherCustomerOrder);
        
        // When
        List<Order> orders = repository.findByCustomerId(customerId);
        
        // Then
        assertThat(orders).hasSize(2);
        assertThat(orders).extracting(Order::getCustomerId)
                         .containsOnly(customerId);
    }
    
    @Test
    @DisplayName("應該能按狀態查詢訂單")
    void should_find_orders_by_status() {
        // Given
        repository.save(testOrder);
        
        Order confirmedOrder = createTestOrder();
        confirmedOrder.confirm();
        repository.save(confirmedOrder);
        
        // When
        List<Order> pendingOrders = repository.findByStatus(OrderStatus.PENDING);
        List<Order> confirmedOrders = repository.findByStatus(OrderStatus.CONFIRMED);
        
        // Then
        assertThat(pendingOrders).hasSize(1);
        assertThat(confirmedOrders).hasSize(1);
        assertThat(pendingOrders.get(0).getStatus()).isEqualTo(OrderStatus.PENDING);
        assertThat(confirmedOrders.get(0).getStatus()).isEqualTo(OrderStatus.CONFIRMED);
    }
    
    @Test
    @DisplayName("更新訂單後應該反映變更")
    void should_reflect_changes_after_update() {
        // Given
        repository.save(testOrder);
        
        // When
        testOrder.confirm();
        repository.save(testOrder);
        
        Optional<Order> updated = repository.findById(testOrder.getId());
        
        // Then
        assertThat(updated).isPresent();
        assertThat(updated.get().getStatus()).isEqualTo(OrderStatus.CONFIRMED);
    }
    
    @Test
    @DisplayName("刪除訂單後應該無法找到")
    void should_not_find_order_after_deletion() {
        // Given
        repository.save(testOrder);
        
        // When
        repository.remove(testOrder);
        Optional<Order> result = repository.findById(testOrder.getId());
        
        // Then
        assertThat(result).isEmpty();
    }
    
    private Order createTestOrder() {
        return createTestOrderForCustomer(new CustomerId("CUST-001"));
    }
    
    private Order createTestOrderForCustomer(CustomerId customerId) {
        List<OrderItem> items = List.of(
            new OrderItem(new ProductId("BOOK-001"), "Test Book", 1, 
                         new Money(new BigDecimal("29.99")))
        );
        return Order.create(customerId, items);
    }
}

// JPA 實作的契約測試
@DataJpaTest
@DisplayName("JPA 訂單儲存庫測試")
class JpaOrderRepositoryTest extends OrderRepositoryContractTest {
    
    @Autowired
    private TestEntityManager entityManager;
    
    @Autowired
    private SpringDataOrderRepository springRepository;
    
    @Override
    protected OrderRepository createRepository() {
        OrderMapper mapper = new OrderMapper();
        return new JpaOrderRepository(springRepository, mapper);
    }
}

// In-Memory 實作的契約測試
@DisplayName("記憶體訂單儲存庫測試")
class InMemoryOrderRepositoryTest extends OrderRepositoryContractTest {
    
    @Override
    protected OrderRepository createRepository() {
        return new InMemoryOrderRepository();
    }
}

// 外部服務 Port 契約測試
@DisplayName("付款服務契約測試")
abstract class PaymentServiceContractTest {
    
    protected abstract PaymentService createPaymentService();
    
    private PaymentService paymentService;
    
    @BeforeEach
    void setUp() {
        paymentService = createPaymentService();
    }
    
    @Test
    @DisplayName("應該能處理有效的付款請求")
    void should_process_valid_payment() {
        // Given
        PaymentRequest request = new PaymentRequest(
            new OrderId("ORDER-001"),
            new Money(new BigDecimal("99.99")),
            new CreditCard("4111111111111111", "12/25", "123")
        );
        
        // When
        PaymentResult result = paymentService.processPayment(request);
        
        // Then
        assertThat(result.isSuccessful()).isTrue();
        assertThat(result.getTransactionId()).isNotNull();
    }
    
    @Test
    @DisplayName("無效的信用卡應該拒絕付款")
    void should_reject_invalid_credit_card() {
        // Given
        PaymentRequest request = new PaymentRequest(
            new OrderId("ORDER-001"),
            new Money(new BigDecimal("99.99")),
            new CreditCard("invalid", "12/25", "123")
        );
        
        // When
        PaymentResult result = paymentService.processPayment(request);
        
        // Then
        assertThat(result.isSuccessful()).isFalse();
        assertThat(result.getError()).contains("信用卡號碼無效");
    }
    
    @Test
    @DisplayName("零金額付款應該拋出例外")
    void should_throw_exception_for_zero_amount() {
        // Given
        PaymentRequest request = new PaymentRequest(
            new OrderId("ORDER-001"),
            Money.ZERO,
            new CreditCard("4111111111111111", "12/25", "123")
        );
        
        // When & Then
        assertThatThrownBy(() -> paymentService.processPayment(request))
            .isInstanceOf(IllegalArgumentException.class)
            .hasMessage("付款金額必須大於零");
    }
}

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private EmailService emailService;
    
    @Autowired
    private PaymentGateway paymentGateway;
    
    public void createOrder(CreateOrderRequest request) {
        // 建立訂單
        Order order = new Order();
        order.setCustomerId(request.getCustomerId());
        order.setItems(request.getItems());
        order.setStatus("PENDING");
        
        // 處理付款
        PaymentResult result = paymentGateway.processPayment(
            request.getPaymentInfo()
        );
        
        if (result.isSuccess()) {
            order.setStatus("CONFIRMED");
            orderRepository.save(order);
            
            // 發送確認郵件
            emailService.sendConfirmation(
                request.getCustomerId(), 
                order.getId()
            );
        } else {
            throw new PaymentFailedException("付款失敗");
        }
    }
}

// 培訓課程大綱
public class HexagonalArchitectureTraining {
    
    // 第一週：基礎理論
    public void week1_fundamentals() {
        // 1. 軟體架構演進史
        // 2. 分層架構的問題與挑戰
        // 3. 六邊形架構的核心概念
        // 4. Port-Adapter 模式詳解
    }
    
    // 第二週：實作練習
    public void week2_handson() {
        // 1. 簡單的計算器應用實作
        // 2. Port 和 Adapter 設計練習
        // 3. 單元測試撰寫
        // 4. 程式碼審查與討論
    }
    
    // 實作練習：計算器範例
    // Domain 層
    public class Calculator {
        public double add(double a, double b) {
            return a + b;
        }
        
        public double divide(double a, double b) {
            if (b == 0) {
                throw new IllegalArgumentException("除數不能為零");
            }
            return a / b;
        }
    }
    
    // Port 定義
    public interface CalculationHistoryPort {
        void saveCalculation(CalculationRecord record);
        List<CalculationRecord> getHistory(int limit);
    }
    
    // Use Case
    @UseCase
    public class PerformCalculationUseCase {
        private final Calculator calculator;
        private final CalculationHistoryPort historyPort;
        
        public CalculationResult execute(CalculationCommand command) {
            double result = switch (command.getOperation()) {
                case ADD -> calculator.add(command.getA(), command.getB());
                case DIVIDE -> calculator.divide(command.getA(), command.getB());
                default -> throw new UnsupportedOperationException();
            };
            
            // 記錄計算歷史
            historyPort.saveCalculation(new CalculationRecord(
                command.getOperation(),
                command.getA(),
                command.getB(),
                result,
                LocalDateTime.now()
            ));
            
            return new CalculationResult(result);
        }
    }
}

public class PilotProjectCriteria {
    
    // 理想的試點專案特徵
    public static class IdealCharacteristics {
        // ✅ 適合特徵
        private boolean hasSimpleDomain = true;        // 業務邏輯相對簡單
        private boolean isNewProject = true;           // 新專案，沒有歷史包袱
        private boolean hasMotivatedTeam = true;       // 團隊成員積極參與
        private boolean allowsExperimentation = true;  // 允許嘗試新技術
        private boolean hasReasonableTimeline = true;  // 時程合理，不過度緊急
        
        // ❌ 避免特徵
        private boolean isLegacySystem = false;        // 避免複雜的遺留系統
        private boolean hasTightDeadline = false;      // 避免時程過緊的專案
        private boolean isBusinessCritical = false;    // 避免業務關鍵系統
        private boolean hasComplexIntegration = false; // 避免複雜的整合需求
    }
    
    // 試點專案範例：員工請假系統
    @Component
    public class LeaveRequestSystem {
        
        // 簡單的業務邏輯
        // 有限的外部依賴
        // 團隊熟悉的領域
        
        // Domain 物件
        public class LeaveRequest {
            private final EmployeeId employeeId;
            private final DateRange dateRange;
            private final LeaveType type;
            private LeaveStatus status;
            
            public void approve(ManagerId managerId) {
                if (status != LeaveStatus.PENDING) {
                    throw new IllegalStateException("只有待審核的請假可以批准");
                }
                
                this.status = LeaveStatus.APPROVED;
                DomainEvents.publish(new LeaveApprovedEvent(this.id, managerId));
            }
        }
        
        // Port 定義
        public interface LeaveRepository {
            void save(LeaveRequest request);
            Optional<LeaveRequest> findById(LeaveRequestId id);
            List<LeaveRequest> findPendingRequests(ManagerId managerId);
        }
        
        public interface NotificationService {
            void notifyApproval(EmployeeId employeeId, LeaveRequestId requestId);
            void notifyRejection(EmployeeId employeeId, String reason);
        }
        
        // Use Case
        @UseCase
        public class ApproveLeaveUseCase {
            private final LeaveRepository repository;
            private final NotificationService notificationService;
            
            public void execute(ApproveLeaveCommand command) {
                LeaveRequest request = repository.findById(command.getRequestId())
                    .orElseThrow(() -> new LeaveRequestNotFoundException(command.getRequestId()));
                
                request.approve(command.getManagerId());
                repository.save(request);
                
                notificationService.notifyApproval(
                    request.getEmployeeId(), 
                    request.getId()
                );
            }
        }
    }
}

public class CodeReviewChecklist {
    
    // 1. 分層依賴檢查
    public void checkLayerDependencies() {
        /*
        ✅ 檢查項目：
        - Domain 層不依賴任何外部層
        - Application 層只依賴 Domain 層
        - Infrastructure 層可以依賴所有層
        - Port 介面定義在正確的層中
        
        ❌ 常見問題：
        - Domain 層導入 Spring 註解
        - Domain 層直接使用 HTTP 或資料庫相關類別
        - Application 層直接導入具體的 Adapter 實作
        */
    }
    
    // 2. Port 設計審查
    public void reviewPortDesign() {
        /*
        ✅ 好的 Port 設計：
        */
        
        // 介面簡潔，職責單一
        public interface OrderRepository {
            void save(Order order);
            Optional<Order> findById(OrderId id);
            List<Order> findByStatus(OrderStatus status);
        }
        
        // 使用領域語言
        public interface PaymentProcessor {
            PaymentResult processPayment(PaymentRequest request);
            void refundPayment(RefundRequest request);
        }
        
        /*
        ❌ 問題的 Port 設計：
        */
        
        // 職責過多，介面複雜
        public interface OrderService {
            void saveOrder(Order order);
            void sendEmail(String email);      // 應該分離到 NotificationPort
            void updateInventory(Product p);   // 應該分離到 InventoryPort
            void processPayment(Payment p);    // 應該分離到 PaymentPort
        }
        
        // 洩漏技術細節
        public interface OrderRepository {
            EntityManager getEntityManager(); // 洩漏 JPA 實作細節
            Connection getConnection();       // 洩漏 JDBC 實作細節
        }
    }
    
    // 3. 領域物件審查
    public void reviewDomainObjects() {
        /*
        ✅ 好的領域物件：
        */
        
        public class Order {
            private final OrderId id;
            private final CustomerId customerId;
            private final List<OrderItem> items;
            private OrderStatus status;
            
            // 豐富的業務行為
            public void addItem(Product product, int quantity) {
                if (status != OrderStatus.DRAFT) {
                    throw new IllegalStateException("只有草稿狀態的訂單可以新增項目");
                }
                
                // 業務規則驗證
                validateProduct(product);
                validateQuantity(quantity);
                
                OrderItem item = new OrderItem(product.getId(), quantity, product.getPrice());
                this.items.add(item);
                
                // 重新計算總金額
                recalculateTotal();
            }
            
            // 封裝業務邏輯
            private void validateProduct(Product product) {
                if (!product.isAvailable()) {
                    throw new ProductNotAvailableException(product.getId());
                }
            }
        }
        
        /*
        ❌ 問題的領域物件：
        */
        
        // 貧血模型 - 只有 getter/setter
        public class Order {
            private String id;
            private String customerId;
            private List<OrderItem> items;
            private String status;
            
            // 只有 getter/setter，沒有業務邏輯
            public String getId() { return id; }
            public void setId(String id) { this.id = id; }
            // ...
        }
        
        // 洩漏技術細節
        public class Order {
            @Entity  // Domain 層不應該有 JPA 註解
            @Table(name = "orders")
            public class Order {
                @Id
                @GeneratedValue
                private Long id;
                // ...
            }
        }
    }
    
    // 4. 測試覆蓋率審查
    public void reviewTestCoverage() {
        /*
        ✅ 完整的測試覆蓋：
        */
        
        // Domain 層 - 純單元測試
        public class OrderTest {
            @Test
            void should_add_item_to_draft_order() {
                // 不依賴任何外部服務
                Order order = Order.createDraft(customerId);
                Product product = createTestProduct();
                
                order.addItem(product, 2);
                
                assertThat(order.getItems()).hasSize(1);
                assertThat(order.getTotalAmount()).isEqualTo(product.getPrice().multiply(2));
            }
        }
        
        // Application 層 - Mock 依賴測試
        public class CreateOrderUseCaseTest {
            @Mock private OrderRepository orderRepository;
            @Mock private ProductService productService;
            
            @Test
            void should_create_order_successfully() {
                // 測試協調邏輯
                when(productService.findById(any())).thenReturn(Optional.of(product));
                
                CreateOrderCommand command = new CreateOrderCommand(customerId, items);
                
                OrderId result = useCase.execute(command);
                
                verify(orderRepository).save(any(Order.class));
                assertThat(result).isNotNull();
            }
        }
        
        // Infrastructure 層 - 整合測試
        @DataJpaTest
        public class JpaOrderRepositoryTest {
            @Test
            void should_save_and_retrieve_order() {
                // 測試實際的資料庫操作
                Order order = createTestOrder();
                
                repository.save(order);
                Optional<Order> retrieved = repository.findById(order.getId());
                
                assertThat(retrieved).isPresent();
                assertThat(retrieved.get()).isEqualTo(order);
            }
        }
    }
}

public class TeamCollaboration {
    
    // 角色分工建議
    public static class RoleDistribution {
        
        // 資深開發者：負責架構設計和核心領域
        @Role("Senior Developer")
        public class ArchitectureOwner {
            // 責任：
            // - 設計 Domain 模型
            // - 定義核心 Port 介面
            // - Review 架構決策
            // - 指導團隊成員
            
            public void designDomainModel() {
                // 領域專家訪談
                // 業務流程分析
                // 聚合邊界設計
                // 領域事件識別
            }
            
            public void defineCorePorts() {
                // 識別業務能力
                // 設計 Port 介面
                // 定義資料契約
                // 撰寫介面文件
            }
        }
        
        // 中級開發者：負責 Application 層和部分 Adapter
        @Role("Mid-level Developer")
        public class ApplicationDeveloper {
            // 責任：
            // - 實作 Use Case
            // - 設計 Application Service
            // - 處理 Command 和 Query
            // - 實作一般 Adapter
            
            public void implementUseCases() {
                // 分析業務流程
                // 設計協調邏輯
                // 處理異常情況
                // 撰寫單元測試
            }
            
            public void createAdapters() {
                // 實作 REST API
                // 設計資料映射
                // 整合外部服務
                // 撰寫整合測試
            }
        }
        
        // 初級開發者：負責簡單 Adapter 和測試
        @Role("Junior Developer")
        public class AdapterDeveloper {
            // 責任：
            // - 實作簡單 Adapter
            // - 撰寫測試案例
            // - 文件撰寫
            // - 程式碼重構
            
            public void implementSimpleAdapters() {
                // 資料庫操作
                // 檔案處理
                // 快取操作
                // 訊息發送
            }
            
            public void writeTests() {
                // 單元測試
                // 整合測試
                // 測試資料準備
                // 測試覆蓋率分析
            }
        }
    }
}

public class DevelopmentWorkflow {
    
    // Git 分支策略
    public void gitBranchStrategy() {
        /*
        建議的分支命名規範：
        
        feature/hex-{component}-{description}
        
        範例：
        feature/hex-domain-order-aggregate
        feature/hex-adapter-payment-stripe
        feature/hex-usecase-create-order
        feature/hex-port-inventory-management
        */
    }
    
    // Pull Request 檢查清單
    public class PullRequestChecklist {
        
        // 架構層面檢查
        private boolean[] architectureChecks = {
            true,  // 依賴方向正確
            true,  // Port 介面設計合理
            true,  // 領域邏輯在正確位置
            true,  // 沒有技術細節洩漏
            true   // 遵循命名慣例
        };
        
        // 程式碼品質檢查
        private boolean[] qualityChecks = {
            true,  // 有適當的單元測試
            true,  // 程式碼覆蓋率達標
            true,  // 遵循編碼標準
            true,  // 有適當的註解
            true   // 沒有程式碼重複
        };
        
        // 文件檢查
        private boolean[] documentationChecks = {
            true,  // API 文件更新
            true,  // 架構決策記錄
            true,  // 使用範例提供
            true   // 變更日誌更新
        };
    }
    
    // 程式碼審查範本
    public class CodeReviewTemplate {
        
        public String generateReviewComment(String issueType, String suggestion) {
            return switch (issueType) {
                case "DEPENDENCY_VIOLATION" -> 
                    "🚨 依賴方向錯誤：" + suggestion + 
                    "\n請確保 Domain 層不依賴外部技術。";
                    
                case "PORT_DESIGN" -> 
                    "🔌 Port 設計建議：" + suggestion + 
                    "\n考慮是否符合單一職責原則。";
                    
                case "DOMAIN_LOGIC" -> 
                    "💼 業務邏輯建議：" + suggestion + 
                    "\n建議將業務規則移到 Domain 物件中。";
                    
                case "TEST_COVERAGE" -> 
                    "🧪 測試覆蓋率：" + suggestion + 
                    "\n請新增對應的測試案例。";
                    
                default -> "💡 一般建議：" + suggestion;
            };
        }
    }
}

public class PerformanceMetrics {
    
    // 開發效率指標
    public static class DevelopmentEfficiency {
        
        // 導入前
        public static class Before {
            private double newFeatureDevelopmentTime = 5.0;  // 天
            private double bugFixTime = 2.0;                 // 天
            private double testWritingTime = 3.0;            // 天
            private double codeReviewTime = 1.0;             // 天
            private int testCoveragePercentage = 40;         // %
        }
        
        // 導入後（6個月後）
        public static class After {
            private double newFeatureDevelopmentTime = 3.5;  // 天 (-30%)
            private double bugFixTime = 1.2;                 // 天 (-40%)
            private double testWritingTime = 1.5;            // 天 (-50%)
            private double codeReviewTime = 0.8;             // 天 (-20%)
            private int testCoveragePercentage = 85;         // % (+112%)
        }
    }
    
    // 程式碼品質指標
    public static class CodeQuality {
        
        // 導入前
        public static class Before {
            private int cyclomaticComplexity = 12;           // 平均圈複雜度
            private int couplingLevel = 8;                   // 耦合度
            private int cohesionLevel = 3;                   // 內聚度
            private int duplicatedCodePercentage = 15;       // 重複代碼 %
        }
        
        // 導入後
        public static class After {
            private int cyclomaticComplexity = 6;            // (-50%)
            private int couplingLevel = 3;                   // (-62%)
            private int cohesionLevel = 8;                   // (+167%)
            private int duplicatedCodePercentage = 5;        // (-67%)
        }
    }
    
    // 系統維護指標
    public static class MaintenanceMetrics {
        
        public void trackMaintenanceEfforts() {
            /*
            追蹤項目：
            1. 需求變更響應時間
            2. 新技術導入容易度
            3. 系統擴展成本
            4. 回歸測試時間
            5. 生產環境問題數量
            */
        }
        
        // 自動化指標收集
        @Scheduled(fixedRate = 86400000) // 每日執行
        public void collectMetrics() {
            // 程式碼複雜度分析
            analyzeCodeComplexity();
            
            // 測試覆蓋率統計
            calculateTestCoverage();
            
            // 依賴關係分析
            analyzeDependencies();
            
            // 效能基準測試
            runPerformanceBenchmarks();
        }
    }
    
    // ROI 計算
    public static class ROICalculation {
        
        public double calculateArchitectureROI(
                double implementationCost,
                double trainingSost,
                double toolingCost,
                double maintenanceSavings,
                double developmentSpeedUp,
                double qualityImprovement) {
            
            // 總投資成本
            double totalInvestment = implementationCost + trainingSost + toolingCost;
            
            // 年度收益 (以人天成本計算)
            double annualSavings = maintenanceSavings + developmentSpeedUp + qualityImprovement;
            
            // 投資回報率 (第一年)
            return (annualSavings - totalInvestment) / totalInvestment * 100;
        }
        
        // 實際案例計算
        public void realWorldExample() {
            // 假設數據：中型團隊 (10人)，專案週期 1年
            double implementationCost = 50;    // 人天
            double trainingCost = 20;          // 人天
            double toolingCost = 10;           // 人天
            
            double maintenanceSavings = 80;    // 人天/年
            double developmentSpeedUp = 120;   // 人天/年
            double qualityImprovement = 60;    // 人天/年
            
            double roi = calculateArchitectureROI(
                implementationCost, trainingCost, toolingCost,
                maintenanceSavings, developmentSpeedUp, qualityImprovement
            );
            
            System.out.println("架構導入 ROI: " + roi + "%");
            // 預期輸出：架構導入 ROI: 225%
        }
    }
}