{
  "eventId": "evt_12345",
  "eventType": "OrderPlaced",
  "aggregateId": "order_67890",
  "timestamp": "2024-01-15T10:30:00Z",
  "version": "1.0",
  "data": {
    "orderId": "order_67890",
    "customerId": "cust_11111",
    "items": [
      {
        "productId": "prod_22222",
        "quantity": 2,
        "unitPrice": 99.00
      }
    ],
    "totalAmount": 198.00,
    "currency": "CNY"
  },
  "metadata": {
    "source": "order-service",
    "correlationId": "corr_33333"
  }
}

// 领域模型
@Entity
@Table(name = "orders")
public class Order {
    @Id
    private String id;
    
    @Embedded
    private CustomerId customerId;
    
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
    private List<OrderItem> items;
    
    @Enumerated(EnumType.STRING)
    private OrderStatus status;
    
    private Money totalAmount;
    
    private LocalDateTime createdAt;
    
    // 构造函数
    public Order(CustomerId customerId, List<OrderItem> items) {
        this.id = UUID.randomUUID().toString();
        this.customerId = customerId;
        this.items = items;
        this.status = OrderStatus.CREATED;
        this.totalAmount = calculateTotal(items);
        this.createdAt = LocalDateTime.now();
    }
    
    private Money calculateTotal(List<OrderItem> items) {
        return items.stream()
            .map(OrderItem::getSubtotal)
            .reduce(Money.ZERO, Money::add);
    }
    
    // 业务方法
    public void confirm() {
        if (this.status != OrderStatus.CREATED) {
            throw new IllegalStateException("订单状态不正确");
        }
        this.status = OrderStatus.CONFIRMED;
    }
    
    public void cancel() {
        if (this.status == OrderStatus.COMPLETED || this.status == OrderStatus.CANCELLED) {
            throw new IllegalStateException("订单不能取消");
        }
        this.status = OrderStatus.CANCELLED;
    }
    
    // getters
}

// 仓储接口
public interface OrderRepository extends JpaRepository<Order, String> {
    List<Order> findByCustomerId(String customerId);
}

// 应用服务
@Service
@Transactional
public class OrderService {
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private DomainEventPublisher eventPublisher;
    
    @Autowired
    private InventoryClient inventoryClient;
    
    /**
     * 创建订单
     */
    public Order createOrder(CreateOrderCommand command) {
        // 检查库存
        for (OrderItemRequest item : command.getItems()) {
            boolean available = inventoryClient.checkAvailability(
                item.getProductId(), item.getQuantity()
            );
            if (!available) {
                throw new BusinessException("商品库存不足: " + item.getProductId());
            }
        }
        
        // 创建订单
        List<OrderItem> items = command.getItems().stream()
            .map(item -> new OrderItem(item.getProductId(), item.getQuantity(), item.getUnitPrice()))
            .collect(Collectors.toList());
        
        Order order = new Order(new CustomerId(command.getCustomerId()), items);
        orderRepository.save(order);
        
        // 发布领域事件
        eventPublisher.publish(new OrderCreatedEvent(
            order.getId(),
            order.getCustomerId().getValue(),
            order.getItems(),
            order.getTotalAmount(),
            LocalDateTime.now()
        ));
        
        return order;
    }
    
    /**
     * 确认订单
     */
    public void confirmOrder(String orderId) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new NotFoundException("订单不存在"));
        
        order.confirm();
        orderRepository.save(order);
        
        // 扣减库存
        for (OrderItem item : order.getItems()) {
            inventoryClient.deductStock(item.getProductId(), item.getQuantity());
        }
        
        // 发布事件
        eventPublisher.publish(new OrderConfirmedEvent(
            order.getId(),
            LocalDateTime.now()
        ));
    }
}

// Feign客户端:调用库存服务
@FeignClient(name = "inventory-service")
public interface InventoryClient {
    
    @GetMapping("/api/inventory/{productId}/availability")
    boolean checkAvailability(@PathVariable String productId, @RequestParam int quantity);
    
    @PostMapping("/api/inventory/deduct")
    void deductStock(@RequestBody DeductStockRequest request);
}

// REST Controller
@RestController
@RequestMapping("/api/orders")
public class OrderController {
    
    @Autowired
    private OrderService orderService;
    
    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(@RequestBody CreateOrderRequest request) {
        Order order = orderService.createOrder(request.toCommand());
        return ResponseEntity.status(HttpStatus.CREATED)
            .body(OrderResponse.from(order));
    }
    
    @GetMapping("/{orderId}")
    public ResponseEntity<OrderResponse> getOrder(@PathVariable String orderId) {
        Order order = orderService.getOrder(orderId);
        return ResponseEntity.ok(OrderResponse.from(order));
    }
}

// 领域模型
@Entity
@Table(name = "inventory")
public class StockItem {
    @Id
    private String productId;
    
    private int quantity;
    
    private int reservedQuantity;
    
    private LocalDateTime lastUpdated;
    
    // 构造函数
    public StockItem(String productId, int quantity) {
        this.productId = productId;
        this.quantity = quantity;
        this.reservedQuantity = 0;
        this.lastUpdated = LocalDateTime.now();
    }
    
    // 业务方法
    public boolean isAvailable(int requestedQuantity) {
        return getAvailableQuantity() >= requestedQuantity;
    }
    
    public int getAvailableQuantity() {
        return quantity - reservedQuantity;
    }
    
    public void reserve(int quantity) {
        if (!isAvailable(quantity)) {
            throw new BusinessException("库存不足");
        }
        this.reservedQuantity += quantity;
        this.lastUpdated = LocalDateTime.now();
    }
    
    public void deduct(int quantity) {
        if (reservedQuantity < quantity) {
            throw new BusinessException("预留数量不足");
        }
        this.quantity -= quantity;
        this.reservedQuantity -= quantity;
        this.lastUpdated = LocalDateTime.now();
    }
    
    public void releaseReservation(int quantity) {
        if (reservedQuantity < quantity) {
            throw new BusinessException("预留数量不足");
        }
        this.reservedQuantity -= quantity;
        this.lastUpdated = LocalDateTime.now();
    }
}

// 仓储
public interface StockItemRepository extends JpaRepository<StockItem, String> {
}

// 应用服务
@Service
@Transactional
public class InventoryService {
    
    @Autowired
    private StockItemRepository stockItemRepository;
    
    @Autowired
    private DomainEventPublisher eventPublisher;
    
    /**
     * 检查库存可用性
     */
    public boolean checkAvailability(String productId, int quantity) {
        StockItem item = stockItemRepository.findById(productId)
            .orElseThrow(() -> new NotFoundException("商品不存在"));
        return item.isAvailable(quantity);
    }
    
    /**
     * 预留库存
     */
    public void reserveStock(String productId, int quantity) {
        StockItem item = stockItemRepository.findById(productId)
            .orElseThrow(() -> new NotFoundException("商品不存在"));
        item.reserve(quantity);
        stockItemRepository.save(item);
        
        eventPublisher.publish(new StockReservedEvent(
            productId, quantity, LocalDateTime.now()
        ));
    }
    
    /**
     * 扣减库存
     */
    public void deductStock(String productId, int quantity) {
        StockItem item = stockItemRepository.findById(productId)
            .orElseThrow(() -> new NotFoundException("商品不存在"));
        item.deduct(quantity);
        stockItemRepository.save(item);
        
        eventPublisher.publish(new StockDeductedEvent(
            productId, quantity, LocalDateTime.now()
        ));
    }
}

// REST Controller
@RestController
@RequestMapping("/api/inventory")
public class InventoryController {
    
    @Autowired
    private InventoryService inventoryService;
    
    @GetMapping("/{productId}/availability")
    public ResponseEntity<Boolean> checkAvailability(
            @PathVariable String productId, @RequestParam int quantity) {
        boolean available = inventoryService.checkAvailability(productId, quantity);
        return ResponseEntity.ok(available);
    }
    
    @PostMapping("/deduct")
    public ResponseEntity<Void> deductStock(@RequestBody DeductStockRequest request) {
        inventoryService.deductStock(request.getProductId(), request.getQuantity());
        return ResponseEntity.ok().build();
    }
}

// Saga协调器
@Component
public class OrderCreationSagaOrchestrator {
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private InventoryService inventoryService;
    
    @Autowired
    private PaymentService paymentService;
    
    /**
     * 执行订单创建Saga
     */
    @Transactional
    public void executeOrderCreationSaga(CreateOrderCommand command) {
        String orderId = null;
        try {
            // 步骤1: 创建订单
            orderId = orderService.createOrder(command);
            
            // 步骤2: 预留库存
            inventoryService.reserveStockForOrder(orderId);
            
            // 步骤3: 处理支付
            paymentService.processPayment(orderId);
            
            // 步骤4: 确认订单
            orderService.confirmOrder(orderId);
            
        } catch (Exception e) {
            // 补偿: 回滚之前的操作
            compensate(orderId, e);
            throw e;
        }
    }
    
    private void compensate(String orderId, Exception originalException) {
        if (orderId == null) return;
        
        try {
            // 反向执行补偿操作
            paymentService.refundPayment(orderId);
            inventoryService.releaseReservation(orderId);
            orderService.cancelOrder(orderId);
        } catch (Exception compensationException) {
            // 记录补偿失败,需要人工干预
            log.error("Saga补偿失败", compensationException);
            // 发布补偿失败事件,触发人工处理流程
            eventPublisher.publish(new SagaCompensationFailedEvent(
                orderId, originalException.getMessage(), compensationException.getMessage()
            ));
        }
    }
}

// 订单服务:发布订单创建事件
@Service
public class OrderService {
    
    @Autowired
    private DomainEventPublisher eventPublisher;
    
    public Order createOrder(CreateOrderCommand command) {
        Order order = new Order(command.getCustomerId(), command.getItems());
        orderRepository.save(order);
        
        // 发布订单创建事件
        eventPublisher.publish(new OrderCreatedEvent(
            order.getId(),
            command.getCustomerId(),
            command.getItems(),
            LocalDateTime.now()
        ));
        
        return order;
    }
}

// 库存服务:监听订单创建事件
@Component
public class InventoryEventHandler {
    
    @Autowired
    private InventoryService inventoryService;
    
    @Autowired
    private DomainEventPublisher eventPublisher;
    
    @EventListener
    @Transactional
    public void handleOrderCreated(OrderCreatedEvent event) {
        try {
            // 预留库存
            for (OrderItemSnapshot item : event.getItems()) {
                inventoryService.reserveStock(item.getProductId(), item.getQuantity());
            }
            
            // 发布库存预留成功事件
            eventPublisher.publish(new StockReservedEvent(
                event.getOrderId(),
                LocalDateTime.now()
            ));
        } catch (Exception e) {
            // 发布库存预留失败事件
            eventPublisher.publish(new StockReservationFailedEvent(
                event.getOrderId(),
                e.getMessage(),
                LocalDateTime.now()
            ));
        }
    }
}

// 支付服务:监听库存预留成功事件
@Component
public class PaymentEventHandler {
    
    @Autowired
    private PaymentService paymentService;
    
    @Autowired
    private DomainEventPublisher eventPublisher;
    
    @EventListener
    @Transactional
    public void handleStockReserved(StockReservedEvent event) {
        try {
            // 处理支付
            paymentService.processPayment(event.getOrderId());
            
            // 发布支付成功事件
            eventPublisher.publish(new PaymentCompletedEvent(
                event.getOrderId(),
                LocalDateTime.now()
            ));
        } catch (Exception e) {
            // 发布支付失败事件
            eventPublisher.publish(new PaymentFailedEvent(
                event.getOrderId(),
                e.getMessage(),
                LocalDateTime.now()
            ));
        }
    }
}

// 订单服务:监听支付完成事件,确认订单
@Component
public class OrderConfirmationHandler {
    
    @Autowired
    private OrderService orderService;
    
    @EventListener
    @Transactional
    public void handlePaymentCompleted(PaymentCompletedEvent event) {
        orderService.confirmOrder(event.getOrderId());
    }
    
    @EventListener
    @Transactional
    public void handlePaymentFailed(PaymentFailedEvent event) {
        // 取消订单
        orderService.cancelOrder(event.getOrderId());
        
        // 发布取消事件,触发库存释放
        eventPublisher.publish(new OrderCancelledEvent(
            event.getOrderId(),
            event.getReason(),
            LocalDateTime.now()
        ));
    }
}

// Outbox实体
@Entity
@Table(name = "outbox_events")
public class OutboxEvent {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String eventId;
    
    private String eventType;
    
    private String aggregateId;
    
    @Column(columnDefinition = "TEXT")
    private String payload;
    
    private String status; // PENDING, PROCESSED, FAILED
    
    private int retryCount;
    
    private LocalDateTime createdAt;
    
    private LocalDateTime processedAt;
    
    // constructors, getters, setters
}

// Outbox仓储
public interface OutboxEventRepository extends JpaRepository<OutboxEvent, Long> {
    List<OutboxEvent> findByStatusOrderByCreatedAtAsc(String status);
}

// 领域事件发布者(使用Outbox)
@Component
public class OutboxDomainEventPublisher implements DomainEventPublisher {
    
    @Autowired
    private OutboxEventRepository outboxRepository;
    
    @Override
    @Transactional
    public void publish(DomainEvent event) {
        OutboxEvent outboxEvent = new OutboxEvent();
        outboxEvent.setEventId(UUID.randomUUID().toString());
        outboxEvent.setEventType(event.getClass().getSimpleName());
        outboxEvent.setAggregateId(extractAggregateId(event));
        outboxEvent.setPayload(JsonUtils.toJson(event));
        outboxEvent.setStatus("PENDING");
        outboxEvent.setRetryCount(0);
        outboxEvent.setCreatedAt(LocalDateTime.now());
        
        outboxRepository.save(outboxEvent);
    }
    
    private String extractAggregateId(DomainEvent event) {
        // 从事件中提取聚合根ID
        try {
            Field field = event.getClass().getDeclaredField("aggregateId");
            field.setAccessible(true);
            return (String) field.get(event);
        } catch (Exception e) {
            return null;
        }
    }
}

// Outbox处理器:定期扫描并发布事件
@Component
public class OutboxEventProcessor {
    
    @Autowired
    private OutboxEventRepository outboxRepository;
    
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;
    
    private static final String TOPIC = "domain-events";
    
    private static final int MAX_RETRIES = 3;
    
    /**
     * 定时处理待发布的事件
     */
    @Scheduled(fixedDelay = 5000) // 每5秒执行一次
    @Transactional
    public void processPendingEvents() {
        List<OutboxEvent> pendingEvents = outboxRepository.findByStatusOrderByCreatedAtAsc("PENDING");
        
        for (OutboxEvent event : pendingEvents) {
            try {
                // 发布到Kafka
                kafkaTemplate.send(TOPIC, event.getAggregateId(), event.getPayload());
                
                // 标记为已处理
                event.setStatus("PROCESSED");
                event.setProcessedAt(LocalDateTime.now());
                outboxRepository.save(event);
                
                log.info("事件发布成功: {}", event.getEventId());
                
            } catch (Exception e) {
                log.error("事件发布失败: {}", event.getEventId(), e);
                
                // 增加重试计数
                event.setRetryCount(event.getRetryCount() + 1);
                
                if (event.getRetryCount() >= MAX_RETRIES) {
                    event.setStatus("FAILED");
                    log.error("事件发布失败,已达最大重试次数: {}", event.getEventId());
                }
                
                outboxRepository.save(event);
            }
        }
    }
}