// 领域驱动设计示例

// 核心域 - 订单
public class Order {
    private OrderId id;
    private CustomerId customerId;
    private List<OrderItem> items;
    private Money totalAmount;
    private OrderStatus status;
    
    public void place() {
        // 业务逻辑
        this.status = OrderStatus.PLACED;
        DomainEvents.publish(new OrderPlacedEvent(this));
    }
}

// 支撑域 - 库存
public class Inventory {
    private ProductId productId;
    private int quantity;
    
    public void reserve(int quantity) {
        if (this.quantity < quantity) {
            throw new InsufficientInventoryException();
        }
        this.quantity -= quantity;
    }
}

// 通用域 - 通知
public class NotificationService {
    public void sendEmail(String to, String subject, String body) {
        // 发送邮件
    }
    
    public void sendSms(String phone, String message) {
        // 发送短信
    }
}

// RESTful API 示例
@RestController
@RequestMapping("/api/v1/orders")
public class OrderController {
    
    @Autowired
    private OrderService orderService;
    
    // 创建订单
    @PostMapping
    public ResponseEntity<OrderDTO> createOrder(@RequestBody CreateOrderRequest request) {
        Order order = orderService.create(request);
        OrderDTO dto = orderMapper.toDTO(order);
        return ResponseEntity.created(URI.create("/orders/" + order.getId()))
            .body(dto);
    }
    
    // 查询订单
    @GetMapping("/{orderId}")
    public ResponseEntity<OrderDTO> getOrder(@PathVariable Long orderId) {
        Order order = orderService.getById(orderId);
        return ResponseEntity.ok(orderMapper.toDTO(order));
    }
    
    // 取消订单
    @PostMapping("/{orderId}/cancel")
    public ResponseEntity<Void> cancelOrder(@PathVariable Long orderId) {
        orderService.cancel(orderId);
        return ResponseEntity.noContent().build();
    }
}

// gRPC 服务实现
@GrpcService
public class OrderGrpcService extends OrderServiceGrpc.OrderServiceImplBase {
    
    @Override
    public void createOrder(CreateOrderRequest request, 
                           StreamObserver<OrderResponse> responseObserver) {
        Order order = orderService.create(request);
        
        OrderResponse response = OrderResponse.newBuilder()
            .setOrderId(order.getId())
            .setStatus(order.getStatus().name())
            .setTotalAmount(order.getTotalAmount().doubleValue())
            .build();
        
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

// 事件发布
@Component
public class OrderEventPublisher {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void publishOrderCreated(Order order) {
        OrderCreatedEvent event = new OrderCreatedEvent();
        event.setOrderId(order.getId());
        event.setUserId(order.getUserId());
        event.setAmount(order.getTotalAmount());
        event.setTimestamp(System.currentTimeMillis());
        
        rabbitTemplate.convertAndSend(
            "order.events",
            "order.created",
            event
        );
    }
}

// 事件消费
@Component
public class InventoryEventListener {
    
    @RabbitListener(queues = "inventory.queue")
    public void handleOrderCreated(OrderCreatedEvent event) {
        try {
            inventoryService.reserveStock(event.getOrderId(), event.getItems());
        } catch (Exception e) {
            // 失败处理：重试或进入死信队列
            throw new AmqpRejectAndDontRequeueException(e);
        }
    }
}

// 命令端
@Service
public class OrderCommandService {
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Transactional
    public OrderId createOrder(CreateOrderCommand command) {
        Order order = new Order(command.getUserId(), command.getItems());
        orderRepository.save(order);
        
        // 发布领域事件
        eventPublisher.publish(new OrderCreatedEvent(order));
        
        return order.getId();
    }
}

// 查询端
@Service
public class OrderQueryService {
    
    @Autowired
    private OrderReadRepository orderReadRepository;
    
    public OrderDTO getOrder(Long orderId) {
        OrderReadModel model = orderReadRepository.findById(orderId);
        return orderMapper.toDTO(model);
    }
    
    public List<OrderDTO> getUserOrders(Long userId) {
        List<OrderReadModel> models = orderReadRepository.findByUserId(userId);
        return models.stream()
            .map(orderMapper::toDTO)
            .collect(Collectors.toList());
    }
}

// 事件存储
@Entity
public class DomainEvent {
    @Id
    private Long id;
    
    private String aggregateType;
    private String aggregateId;
    private String eventType;
    private String eventData; // JSON
    private Long timestamp;
    private Integer version;
}

// 聚合根
public class Order {
    private OrderId id;
    private List<OrderEvent> events = new ArrayList<>();
    
    public void apply(OrderEvent event) {
        events.add(event);
        // 根据事件更新状态
        if (event instanceof OrderCreatedEvent) {
            // 更新订单状态
        }
    }
    
    public List<OrderEvent> getUncommittedEvents() {
        return events;
    }
    
    public void clearUncommittedEvents() {
        events.clear();
    }
}

// 事件存储库
@Repository
public class EventStoreRepository {
    
    public void save(List<DomainEvent> events) {
        eventRepository.saveAll(events);
    }
    
    public List<DomainEvent> getEvents(String aggregateId) {
        return eventRepository.findByAggregateIdOrderByVersion(aggregateId);
    }
}

// Saga 实现
@Service
public class OrderSaga {
    
    @Autowired
    private InventoryService inventoryService;
    
    @Autowired
    private PaymentService paymentService;
    
    @Autowired
    private OrderService orderService;
    
    @Transactional
    public Order createOrder(CreateOrderRequest request) {
        try {
            // 1. 创建订单（待支付状态）
            Order order = orderService.createPending(request);
            
            // 2. 预留库存
            inventoryService.reserveStock(order.getId(), order.getItems());
            
            // 3. 创建支付
            Payment payment = paymentService.createPayment(order);
            
            // 4. 确认订单
            orderService.confirm(order.getId(), payment.getId());
            
            return order;
            
        } catch (Exception e) {
            // 补偿操作
            compensate(request, e);
            throw e;
        }
    }
    
    private void compensate(CreateOrderRequest request, Exception cause) {
        // 补偿逻辑
        if (cause instanceof PaymentException) {
            inventoryService.cancelReservation(request.getOrderId());
        }
        orderService.cancel(request.getOrderId());
    }
}

// Resilience4j 配置
@Configuration
public class ResilienceConfig {
    
    @Bean
    public CircuitBreakerConfig circuitBreakerConfig() {
        return CircuitBreakerConfig.custom()
            .failureRateThreshold(50) // 失败率阈值 50%
            .waitDurationInOpenState(Duration.ofSeconds(30)) // 打开状态等待时间
            .slidingWindowSize(10) // 滑动窗口大小
            .minimumNumberOfCalls(5) // 最小调用次数
            .build();
    }
    
    @Bean
    public RetryConfig retryConfig() {
        return RetryConfig.custom()
            .maxAttempts(3) // 最大重试次数
            .waitDuration(Duration.ofSeconds(1)) // 重试间隔
            .retryExceptions(SocketTimeoutException.class) // 重试异常类型
            .build();
    }
}

// 使用熔断器
@Service
public class OrderService {
    
    @Autowired
    private CircuitBreakerRegistry circuitBreakerRegistry;
    
    @CircuitBreaker(name = "paymentService", fallbackMethod = "createOrderFallback")
    public Order createOrder(CreateOrderRequest request) {
        // 调用支付服务
        Payment payment = paymentClient.create(request);
        return orderRepository.save(new Order(payment));
    }
    
    // 降级方法
    public Order createOrderFallback(CreateOrderRequest request, Exception e) {
        log.warn("支付服务不可用，使用降级逻辑", e);
        // 返回缓存数据或默认值
        return Order.createPending(request);
    }
}

// 超时配置
@Configuration
public class HttpClientConfig {
    
    @Bean
    public RestTemplate restTemplate() {
        HttpComponentsClientHttpRequestFactory factory = 
            new HttpComponentsClientHttpRequestFactory();
        factory.setConnectTimeout(5000); // 连接超时 5 秒
        factory.setReadTimeout(10000);   // 读取超时 10 秒
        return new RestTemplate(factory);
    }
}

// 重试机制
@Service
public class PaymentService {
    
    @Retryable(
        value = {ConnectTimeoutException.class},
        maxAttempts = 3,
        backoff = @Backoff(delay = 1000, multiplier = 2)
    )
    public Payment createPayment(Order order) {
        return paymentClient.create(order);
    }
    
    @Recover
    public Payment recover(ConnectTimeoutException e, Order order) {
        log.error("支付服务重试失败", e);
        return Payment.createPending(order);
    }
}

// 令牌桶限流
@Service
public class RateLimiterService {
    
    private final RateLimiter rateLimiter = RateLimiter.create(
        RateLimiterConfig.custom()
            .limitRefreshPeriod(Duration.ofSeconds(1))
            .limitForPeriod(100) // 每秒 100 个请求
            .timeoutDuration(Duration.ofMillis(500))
            .build()
    );
    
    public void execute(Runnable task) {
        Boolean permission = rateLimiter.acquirePermission();
        if (permission) {
            task.run();
        } else {
            throw new RateLimitExceededException("请求过于频繁");
        }
    }
}

// 网关层限流
@Configuration
public class GatewayConfig {
    
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("order-service", r -> r
                .path("/api/orders/**")
                .filters(f -> f
                    .requestRateLimiter(config -> {
                        config.setRateLimiter(redisRateLimiter());
                    })
                )
                .uri("lb://order-service")
            )
            .build();
    }
    
    @Bean
    public RedisRateLimiter redisRateLimiter() {
        return new RedisRateLimiter(100, 200); // 每秒 100 个请求，令牌桶容量 200
    }
}

// 线程池隔离
@Configuration
public class BulkheadConfig {
    
    @Bean
    public ThreadPoolBulkheadRegistry bulkheadRegistry() {
        ThreadPoolBulkheadConfig config = ThreadPoolBulkheadConfig.custom()
            .maxThreadPoolSize(50)
            .coreThreadPoolSize(10)
            .queueCapacity(100)
            .build();
        
        return ThreadPoolBulkheadRegistry.of(config);
    }
}

@Service
public class OrderService {
    
    @Bulkhead(name = "paymentBulkhead", type = Bulkhead.Type.THREADPOOL)
    public Order createOrder(CreateOrderRequest request) {
        // 使用独立线程池执行
        return paymentClient.create(request);
    }
}

// 订单服务 - 依赖其他服务
@Service
public class OrderServiceImpl implements OrderService {
    
    @Autowired
    private ProductService productService;
    
    @Autowired
    private InventoryService inventoryService;
    
    @Autowired
    private PaymentService paymentService;
    
    @Autowired
    private UserService userService;
    
    @Override
    @Transactional
    public Order create(CreateOrderRequest request) {
        // 1. 验证用户
        User user = userService.getById(request.getUserId());
        
        // 2. 验证商品并计算价格
        List<Product> products = productService.getByIds(request.getProductIds());
        Money total = calculateTotal(products, request.getQuantities());
        
        // 3. 创建订单
        Order order = new Order(user, products, total);
        orderRepository.save(order);
        
        // 4. 扣减库存（异步）
        inventoryService.reserveAsync(order.getId(), request.getItems());
        
        return order;
    }
}

// 绞杀者模式 - 逐步替换
@Configuration
public class StranglerConfig {
    
    @Bean
    public RouterFunction<ServerResponse> routingFunction(
            OldService oldService,
            NewService newService) {
        
        return RouterFunctions.route()
            // 新功能走新服务
            .path("/api/v2", request -> 
                newService.handle(request))
            // 旧功能走旧服务
            .path("/api/v1", request -> 
                oldService.handle(request))
            .build();
    }
}

// Prometheus 指标
@Component
public class OrderMetrics {
    
    private final Counter orderCounter;
    private final Timer orderTimer;
    private final Gauge pendingOrdersGauge;
    
    public OrderMetrics(MeterRegistry registry) {
        orderCounter = Counter.builder("orders.total")
            .description("Total orders created")
            .register(registry);
        
        orderTimer = Timer.builder("orders.duration")
            .description("Order creation duration")
            .register(registry);
        
        pendingOrdersGauge = Gauge.builder("orders.pending")
            .description("Pending orders count")
            .register(registry, this, OrderMetrics::getPendingCount);
    }
    
    public void recordOrderCreation(long durationMs) {
        orderCounter.increment();
        orderTimer.record(durationMs, TimeUnit.MILLISECONDS);
    }
}