┌─────────────────────┐
│   Presentation      │  表现层：用户界面
├─────────────────────┤
│   Application       │  应用层：业务流程
├─────────────────────┤
│   Domain/Business   │  领域层：核心业务逻辑
├─────────────────────┤
│   Infrastructure    │  基础设施层：数据访问、外部服务
└─────────────────────┘

// 表现层
@RestController
@RequestMapping("/orders")
public class OrderController {
    private final OrderService orderService;
    
    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }
    
    @PostMapping
    public OrderResponse createOrder(@RequestBody CreateOrderRequest request) {
        return orderService.createOrder(request);
    }
}

// 应用层
@Service
public class OrderService {
    private final OrderRepository orderRepository;
    private final PaymentClient paymentClient;
    
    public Order createOrder(CreateOrderRequest request) {
        // 业务编排
        Order order = convertToOrder(request);
        order = orderRepository.save(order);
        paymentClient.charge(order.getTotalAmount());
        return order;
    }
}

// 领域层
@Entity
public class Order {
    private Long id;
    private List<OrderItem> items;
    private BigDecimal totalAmount;
    
    public BigDecimal calculateTotal() {
        return items.stream()
            .map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())))
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

// 基础设施层
@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    // Spring Data 自动生成实现
}

// 过滤器接口
interface Filter<T> {
    T process(T input);
}

// 具体过滤器
class ToUpperCaseFilter implements Filter<String> {
    @Override
    public String process(String input) {
        return input.toUpperCase();
    }
}

class RemoveSpacesFilter implements Filter<String> {
    @Override
    public String process(String input) {
        return input.replaceAll("\\s+", "");
    }
}

class ReverseFilter implements Filter<String> {
    @Override
    public String process(String input) {
        return new StringBuilder(input).reverse().toString();
    }
}

// 管道
class Pipeline<T> {
    private final List<Filter<T>> filters = new ArrayList<>();
    
    public Pipeline<T> addFilter(Filter<T> filter) {
        filters.add(filter);
        return this;
    }
    
    public T execute(T input) {
        T result = input;
        for (Filter<T> filter : filters) {
            result = filter.process(result);
        }
        return result;
    }
}

// 使用
Pipeline<String> pipeline = new Pipeline<>();
pipeline.addFilter(new ToUpperCaseFilter())
        .addFilter(new RemoveSpacesFilter())
        .addFilter(new ReverseFilter());

String result = pipeline.execute("hello world");
// 结果: "DLROWOLLEH"

// 事件定义
record OrderCreatedEvent(String orderId, String userId, BigDecimal amount) {}
record OrderPaidEvent(String orderId, String paymentId) {}

// 事件总线
class EventBus {
    private final Map<Class<?>, List<Consumer<Object>>> handlers = new ConcurrentHashMap<>();
    
    public <T> void subscribe(Class<T> eventType, Consumer<T> handler) {
        handlers.computeIfAbsent(eventType, k -> new CopyOnWriteArrayList<>())
                .add(handler::accept);
    }
    
    public <T> void publish(T event) {
        List<Consumer<Object>> eventHandlers = handlers.getOrDefault(event.getClass(), Collections.emptyList());
        for (Consumer<Object> handler : eventHandlers) {
            handler.accept(event);
        }
    }
}

// 事件处理器
class OrderEventHandler {
    private final EventBus eventBus;
    
    public OrderEventHandler(EventBus eventBus) {
        this.eventBus = eventBus;
        
        // 订阅事件
        eventBus.subscribe(OrderCreatedEvent.class, this::handleOrderCreated);
        eventBus.subscribe(OrderPaidEvent.class, this::handleOrderPaid);
    }
    
    private void handleOrderCreated(OrderCreatedEvent event) {
        System.out.println("Order created: " + event.orderId());
        // 发送确认邮件、初始化库存预留等
    }
    
    private void handleOrderPaid(OrderPaidEvent event) {
        System.out.println("Order paid: " + event.orderId());
        // 更新订单状态、通知物流等
    }
}

// 使用
EventBus eventBus = new EventBus();
OrderEventHandler handler = new OrderEventHandler(eventBus);

// 发布事件
eventBus.publish(new OrderCreatedEvent("ORD-1", "USER-1", new BigDecimal("99.99")));
eventBus.publish(new OrderPaidEvent("ORD-1", "PAY-1"));

系统级：微服务架构
  ├─ 订单服务：分层架构 + 事件驱动
  ├─ 用户服务：分层架构 + REST API
  ├─ 推荐服务：管道-过滤器 + 机器学习
  └─ API 网关：客户端-服务器

需求分析：
- 团队规模：5 人
- 预期用户：初期 1000，目标 10 万
- 业务复杂度：中等
- 上线时间：2 个月

决策：
- 初期：单体分层架构（快速开发）
- 后期：根据瓶颈逐步拆分微服务

理由：
- 小团队不适合微服务的运维复杂度
- 分层架构足够应对中等复杂度
- 保留未来演进的空间

现状：
- 10 年历史的单体应用
- 代码耦合严重
- 部署困难

改造策略：
1. 绞杀者植物模式：新功能用微服务实现
2. 逐步剥离：将独立模块拆分为服务
3. 最终目标：核心保留单体，外围微服务化

注意：
- 不要一次性重写
- 保持向后兼容
- 建立适配层隔离新旧系统

问题：报表生成慢，阻塞主线程

方案：引入管道-过滤器风格
- 将报表生成拆分为：数据提取 → 数据转换 → 格式化 → 导出
- 每个步骤独立执行，可以并行
- 使用消息队列异步处理

效果：
- 主线程不被阻塞
- 可以水平扩展处理节点
- 用户可以提交后稍后获取结果

/**
 * 电商系统分层架构示例
 * 
 * 层次：
 * 1. 表现层：REST API
 * 2. 应用层：业务编排
 * 3. 领域层：核心业务逻辑
 * 4. 基础设施层：数据访问
 */

// ==================== 领域层 ====================

package com.example.ecommerce.domain;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Order {
    private final String id;
    private final String customerId;
    private final List<OrderItem> items;
    private OrderStatus status;
    private BigDecimal totalAmount;
    
    public Order(String id, String customerId) {
        this.id = id;
        this.customerId = customerId;
        this.items = new ArrayList<>();
        this.status = OrderStatus.CREATED;
        this.totalAmount = BigDecimal.ZERO;
    }
    
    public void addItem(Product product, int quantity) {
        if (quantity <= 0) {
            throw new IllegalArgumentException("Quantity must be positive");
        }
        items.add(new OrderItem(product.getId(), product.getName(), 
                               product.getPrice(), quantity));
        recalculateTotal();
    }
    
    private void recalculateTotal() {
        this.totalAmount = items.stream()
            .map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())))
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
    
    public void confirm() {
        if (status != OrderStatus.CREATED) {
            throw new IllegalStateException("Order cannot be confirmed");
        }
        if (items.isEmpty()) {
            throw new IllegalStateException("Order must have items");
        }
        this.status = OrderStatus.CONFIRMED;
    }
    
    public void cancel() {
        if (status == OrderStatus.SHIPPED || status == OrderStatus.DELIVERED) {
            throw new IllegalStateException("Cannot cancel shipped/delivered order");
        }
        this.status = OrderStatus.CANCELLED;
    }
    
    // Getters
    public String getId() { return id; }
    public String getCustomerId() { return customerId; }
    public List<OrderItem> getItems() { return Collections.unmodifiableList(items); }
    public OrderStatus getStatus() { return status; }
    public BigDecimal getTotalAmount() { return totalAmount; }
}

class OrderItem {
    private final String productId;
    private final String productName;
    private final BigDecimal price;
    private final int quantity;
    
    public OrderItem(String productId, String productName, BigDecimal price, int quantity) {
        this.productId = productId;
        this.productName = productName;
        this.price = price;
        this.quantity = quantity;
    }
    
    public String getProductId() { return productId; }
    public String getProductName() { return productName; }
    public BigDecimal getPrice() { return price; }
    public int getQuantity() { return quantity; }
}

class Product {
    private final String id;
    private final String name;
    private final BigDecimal price;
    private int stock;
    
    public Product(String id, String name, BigDecimal price, int stock) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.stock = stock;
    }
    
    public boolean isAvailable(int quantity) {
        return stock >= quantity;
    }
    
    public void reduceStock(int quantity) {
        if (!isAvailable(quantity)) {
            throw new IllegalArgumentException("Insufficient stock");
        }
        this.stock -= quantity;
    }
    
    public String getId() { return id; }
    public String getName() { return name; }
    public BigDecimal getPrice() { return price; }
    public int getStock() { return stock; }
}

enum OrderStatus {
    CREATED, CONFIRMED, PAID, SHIPPED, DELIVERED, CANCELLED
}

// ==================== 基础设施层 ====================

package com.example.ecommerce.infrastructure;

import com.example.ecommerce.domain.Order;
import com.example.ecommerce.domain.Product;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(String id);
    List<Order> findByCustomerId(String customerId);
}

public interface ProductRepository {
    Optional<Product> findById(String id);
    void update(Product product);
}

public class InMemoryOrderRepository implements OrderRepository {
    private final Map<String, Order> orders = new ConcurrentHashMap<>();
    
    @Override
    public void save(Order order) {
        orders.put(order.getId(), order);
    }
    
    @Override
    public Optional<Order> findById(String id) {
        return Optional.ofNullable(orders.get(id));
    }
    
    @Override
    public List<Order> findByCustomerId(String customerId) {
        return orders.values().stream()
            .filter(o -> o.getCustomerId().equals(customerId))
            .toList();
    }
}

public class InMemoryProductRepository implements ProductRepository {
    private final Map<String, Product> products = new ConcurrentHashMap<>();
    
    public InMemoryProductRepository() {
        // 初始化一些产品
        products.put("P1", new Product("P1", "Laptop", new BigDecimal("999.99"), 100));
        products.put("P2", new Product("P2", "Mouse", new BigDecimal("29.99"), 500));
        products.put("P3", new Product("P3", "Keyboard", new BigDecimal("59.99"), 300));
    }
    
    @Override
    public Optional<Product> findById(String id) {
        return Optional.ofNullable(products.get(id));
    }
    
    @Override
    public void update(Product product) {
        products.put(product.getId(), product);
    }
}

// ==================== 应用层 ====================

package com.example.ecommerce.application;

import com.example.ecommerce.domain.*;
import com.example.ecommerce.infrastructure.*;

import java.util.UUID;

public class OrderService {
    private final OrderRepository orderRepository;
    private final ProductRepository productRepository;
    
    public OrderService(OrderRepository orderRepository, ProductRepository productRepository) {
        this.orderRepository = orderRepository;
        this.productRepository = productRepository;
    }
    
    public Order createOrder(String customerId, List<OrderItemRequest> items) {
        String orderId = UUID.randomUUID().toString();
        Order order = new Order(orderId, customerId);
        
        for (OrderItemRequest itemReq : items) {
            Product product = productRepository.findById(itemReq.productId())
                .orElseThrow(() -> new IllegalArgumentException("Product not found: " + itemReq.productId()));
            
            if (!product.isAvailable(itemReq.quantity())) {
                throw new IllegalArgumentException("Insufficient stock for: " + product.getName());
            }
            
            product.reduceStock(itemReq.quantity());
            productRepository.update(product);
            
            order.addItem(product, itemReq.quantity());
        }
        
        order.confirm();
        orderRepository.save(order);
        
        return order;
    }
    
    public Order getOrder(String orderId) {
        return orderRepository.findById(orderId)
            .orElseThrow(() -> new IllegalArgumentException("Order not found: " + orderId));
    }
    
    public void cancelOrder(String orderId) {
        Order order = getOrder(orderId);
        order.cancel();
        orderRepository.save(order);
    }
}

record OrderItemRequest(String productId, int quantity) {}

// ==================== 表现层 ====================

package com.example.ecommerce.presentation;

import com.example.ecommerce.application.OrderService;
import com.example.ecommerce.application.OrderItemRequest;
import com.example.ecommerce.domain.Order;

import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    private final OrderService orderService;
    
    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }
    
    @PostMapping
    public Map<String, Object> createOrder(@RequestBody CreateOrderRequest request) {
        Order order = orderService.createOrder(
            request.customerId(),
            request.items().stream()
                .map(item -> new OrderItemRequest(item.productId(), item.quantity()))
                .toList()
        );
        
        return Map.of(
            "orderId", order.getId(),
            "totalAmount", order.getTotalAmount(),
            "status", order.getStatus().toString()
        );
    }
    
    @GetMapping("/{orderId}")
    public Map<String, Object> getOrder(@PathVariable String orderId) {
        Order order = orderService.getOrder(orderId);
        return Map.of(
            "orderId", order.getId(),
            "customerId", order.getCustomerId(),
            "items", order.getItems().stream()
                .map(item -> Map.of(
                    "productId", item.getProductId(),
                    "productName", item.getProductName(),
                    "price", item.getPrice(),
                    "quantity", item.getQuantity()
                ))
                .toList(),
            "totalAmount", order.getTotalAmount(),
            "status", order.getStatus().toString()
        );
    }
    
    @PostMapping("/{orderId}/cancel")
    public Map<String, String> cancelOrder(@PathVariable String orderId) {
        orderService.cancelOrder(orderId);
        return Map.of("status", "cancelled");
    }
}

record CreateOrderRequest(String customerId, List<ItemRequest> items) {}
record ItemRequest(String productId, int quantity) {}

"""
事件驱动架构示例
在线书店的订单处理流程
"""

from dataclasses import dataclass
from typing import Callable, List, Dict
from datetime import datetime
import json
import time


# ==================== 事件定义 ====================

@dataclass
class Event:
    """基础事件类"""
    event_id: str
    timestamp: datetime
    source: str
    
    def to_json(self):
        return json.dumps({
            "event_id": self.event_id,
            "timestamp": self.timestamp.isoformat(),
            "source": self.source
        })


@dataclass
class OrderPlacedEvent(Event):
    order_id: str
    customer_id: str
    items: List[Dict]
    total_amount: float


@dataclass
class PaymentProcessedEvent(Event):
    order_id: str
    payment_id: str
    amount: float
    status: str


@dataclass
class InventoryReservedEvent(Event):
    order_id: str
    reservations: List[Dict]


@dataclass
class OrderShippedEvent(Event):
    order_id: str
    tracking_number: str
    carrier: str


# ==================== 事件总线 ====================

class EventBus:
    """
    简单的事件总线实现
    支持发布-订阅模式
    """
    
    def __init__(self):
        self._subscribers: Dict[type, List[Callable]] = {}
        self._event_log: List[Event] = []
    
    def subscribe(self, event_type: type, handler: Callable):
        """订阅特定类型的事件"""
        if event_type not in self._subscribers:
            self._subscribers[event_type] = []
        self._subscribers[event_type].append(handler)
        print(f"Subscribed handler to {event_type.__name__}")
    
    def publish(self, event: Event):
        """发布事件"""
        self._event_log.append(event)
        print(f"\n📢 Publishing event: {type(event).__name__}")
        print(f"   Event ID: {event.event_id}")
        
        # 找到匹配的订阅者
        handlers = self._subscribers.get(type(event), [])
        
        for handler in handlers:
            try:
                handler(event)
                print(f"   ✓ Handler executed successfully")
            except Exception as e:
                print(f"   ✗ Handler failed: {e}")
        
        if not handlers:
            print(f"   ⚠ No subscribers for this event")


# ==================== 事件处理器 ====================

class PaymentService:
    """支付服务"""
    
    def __init__(self, event_bus: EventBus):
        self.event_bus = event_bus
        # 订阅订单创建事件
        event_bus.subscribe(OrderPlacedEvent, self.handle_order_placed)
    
    def handle_order_placed(self, event: OrderPlacedEvent):
        """处理订单创建事件，发起支付"""
        print(f"   Processing payment for order {event.order_id}")
        
        # 模拟支付处理
        payment_id = f"PAY-{event.order_id.split('-')[1]}"
        
        # 发布支付处理完成事件
        payment_event = PaymentProcessedEvent(
            event_id=f"EVT-PAY-{int(time.time())}",
            timestamp=datetime.now(),
            source="payment-service",
            order_id=event.order_id,
            payment_id=payment_id,
            amount=event.total_amount,
            status="completed"
        )
        self.event_bus.publish(payment_event)


class InventoryService:
    """库存服务"""
    
    def __init__(self, event_bus: EventBus):
        self.event_bus = event_bus
        self._inventory = {
            "BOOK-1": {"title": "Python Programming", "stock": 100},
            "BOOK-2": {"title": "Java Basics", "stock": 50},
            "BOOK-3": {"title": "Web Development", "stock": 75},
        }
        # 订阅订单创建事件
        event_bus.subscribe(OrderPlacedEvent, self.handle_order_placed)
    
    def handle_order_placed(self, event: OrderPlacedEvent):
        """处理订单创建事件，预留库存"""
        print(f"   Reserving inventory for order {event.order_id}")
        
        reservations = []
        for item in event.items:
            book_id = item["book_id"]
            quantity = item["quantity"]
            
            if book_id in self._inventory:
                if self._inventory[book_id]["stock"] >= quantity:
                    self._inventory[book_id]["stock"] -= quantity
                    reservations.append({
                        "book_id": book_id,
                        "title": self._inventory[book_id]["title"],
                        "quantity": quantity
                    })
                    print(f"   Reserved {quantity} x {book_id}")
                else:
                    raise ValueError(f"Insufficient stock for {book_id}")
        
        # 发布库存预留完成事件
        inventory_event = InventoryReservedEvent(
            event_id=f"EVT-INV-{int(time.time())}",
            timestamp=datetime.now(),
            source="inventory-service",
            order_id=event.order_id,
            reservations=reservations
        )
        self.event_bus.publish(inventory_event)


class ShippingService:
    """物流服务"""
    
    def __init__(self, event_bus: EventBus):
        self.event_bus = event_bus
        # 订阅支付完成事件
        event_bus.subscribe(PaymentProcessedEvent, self.handle_payment_completed)
    
    def handle_payment_completed(self, event: PaymentProcessedEvent):
        """处理支付完成事件，安排发货"""
        if event.status != "completed":
            print(f"   Payment not completed, skipping shipping")
            return
        
        print(f"   Arranging shipping for order {event.order_id}")
        
        # 模拟生成运单号
        tracking_number = f"TRACK-{event.order_id.split('-')[1]}"
        
        # 发布发货事件
        shipping_event = OrderShippedEvent(
            event_id=f"EVT-SHIP-{int(time.time())}",
            timestamp=datetime.now(),
            source="shipping-service",
            order_id=event.order_id,
            tracking_number=tracking_number,
            carrier="Express Delivery"
        )
        self.event_bus.publish(shipping_event)


class NotificationService:
    """通知服务"""
    
    def __init__(self, event_bus: EventBus):
        self.event_bus = event_bus
        # 订阅多个事件
        event_bus.subscribe(OrderPlacedEvent, self.handle_order_placed)
        event_bus.subscribe(OrderShippedEvent, self.handle_order_shipped)
    
    def handle_order_placed(self, event: OrderPlacedEvent):
        """发送订单确认通知"""
        print(f"   Sending order confirmation to customer {event.customer_id}")
        print(f"   Order: {event.order_id}, Total: ${event.total_amount}")
    
    def handle_order_shipped(self, event: OrderShippedEvent):
        """发送发货通知"""
        print(f"   Sending shipping notification for order {event.order_id}")
        print(f"   Tracking: {event.tracking_number}, Carrier: {event.carrier}")


# ==================== 测试 ====================

def main():
    print("=" * 60)
    print("事件驱动架构演示 - 在线书店订单处理")
    print("=" * 60)
    
    # 创建事件总线
    event_bus = EventBus()
    
    # 创建服务（自动订阅事件）
    payment_service = PaymentService(event_bus)
    inventory_service = InventoryService(event_bus)
    shipping_service = ShippingService(event_bus)
    notification_service = NotificationService(event_bus)
    
    # 模拟用户下单
    print("\n" + "=" * 60)
    print("用户下单...")
    print("=" * 60)
    
    order_event = OrderPlacedEvent(
        event_id="EVT-ORDER-1",
        timestamp=datetime.now(),
        source="web-store",
        order_id="ORD-001",
        customer_id="CUST-123",
        items=[
            {"book_id": "BOOK-1", "quantity": 2},
            {"book_id": "BOOK-3", "quantity": 1}
        ],
        total_amount=59.97
    )
    
    # 发布订单创建事件
    # 这会触发一系列连锁反应：
    # 1. PaymentService 处理支付
    # 2. InventoryService 预留库存
    # 3. PaymentService 发布支付完成事件
    # 4. InventoryService 发布库存预留事件
    # 5. ShippingService 收到支付完成事件，安排发货
    # 6. NotificationService 发送通知
    event_bus.publish(order_event)
    
    print("\n" + "=" * 60)
    print("订单处理完成")
    print("=" * 60)


if __name__ == "__main__":
    main()