#Resilience4j 熔断器实战

@Service
@Slf4j
public class OrderService {

    private final CircuitBreakerRegistry circuitBreakerRegistry;
    private final ProductFeignClient productFeignClient;
    private final PaymentFeignClient paymentFeignClient;
    private final UserFeignClient userFeignClient;

    public OrderService(CircuitBreakerRegistry circuitBreakerRegistry,
                       ProductFeignClient productFeignClient,
                       PaymentFeignClient paymentFeignClient,
                       UserFeignClient userFeignClient) {
        this.circuitBreakerRegistry = circuitBreakerRegistry;
        this.productFeignClient = productFeignClient;
        this.paymentFeignClient = paymentFeignClient;
        this.userFeignClient = userFeignClient;
    }

    public Order createOrder(CreateOrderRequest request) {
        CircuitBreaker productCircuitBreaker =
            circuitBreakerRegistry.circuitBreaker("productService");
        CircuitBreaker paymentCircuitBreaker =
            circuitBreakerRegistry.circuitBreaker("paymentService");

        // 1. 获取商品信息（带熔断保护）
        Product product = Decorators.ofSupplier(() -> productFeignClient.getProduct(request.getProductId()))
            .withCircuitBreaker(productCircuitBreaker)
            .withFallback(List.of(Exception.class),
                e -> handleProductFallback(request.getProductId(), e))
            .decorate()
            .get();

        // 2. 检查用户状态（带熔断保护）
        User user = Decorators.ofSupplier(() -> userFeignClient.getUser(request.getUserId()))
            .withCircuitBreaker(circuitBreakerRegistry.circuitBreaker("userService"))
            .withFallback(List.of(Exception.class),
                e -> handleUserFallback(request.getUserId(), e))
            .decorate()
            .get();

        // 3. 创建订单
        Order order = new Order();
        order.setId(UUID.randomUUID().toString());
        order.setProductId(product.getId());
        order.setUserId(user.getId());
        order.setPrice(product.getPrice());
        order.setStatus(OrderStatus.CREATED);

        // 4. 处理支付（带熔断保护）
        PaymentResult paymentResult = Decorators.ofSupplier(() ->
                paymentFeignClient.processPayment(order.getId(), order.getPrice()))
            .withCircuitBreaker(paymentCircuitBreaker)
            .withFallback(List.of(Exception.class),
                e -> handlePaymentFallback(order, e))
            .decorate()
            .get();

        order.setPaymentStatus(paymentResult.getStatus());
        return order;
    }

    // 商品服务降级：返回缓存数据或默认商品
    private Product handleProductFallback(Long productId, Exception e) {
        log.warn("商品服务调用失败，触发降级: productId={}, error={}", productId, e.getMessage());
        Product cachedProduct = productCache.get(productId);
        if (cachedProduct != null) {
            return cachedProduct;
        }
        // 返回默认商品，保证订单流程继续
        return Product.defaultProduct(productId);
    }

    // 用户服务降级：返回默认用户
    private User handleUserFallback(Long userId, Exception e) {
        log.warn("用户服务调用失败，触发降级: userId={}, error={}", userId, e.getMessage());
        return User.defaultUser(userId);
    }

    // 支付服务降级：创建订单但标记为待支付
    private PaymentResult handlePaymentFallback(Order order, Exception e) {
        log.warn("支付服务调用失败，触发降级: orderId={}, error={}", order.getId(), e.getMessage());
        // 标记为待支付，稍后重试
        return PaymentResult.pending("支付服务暂时不可用，请稍后重试");
    }
}

@Component
@Slf4j
public class CircuitBreakerEventListener {

    @Autowired
    private CircuitBreakerRegistry registry;

    @PostConstruct
    public void init() {
        registry.getAllCircuitBreakers().forEach(this::registerListeners);
    }

    private void registerListeners(CircuitBreaker circuitBreaker) {
        String name = circuitBreaker.getName();

        // 状态转换事件
        circuitBreaker.getEventPublisher()
            .onStateTransition(event -> {
                StateTransition transition = event.getStateTransition();
                log.warn("熔断器 [{}] 状态转换: {} -> {}",
                    name,
                    transition.getFromState(),
                    transition.getToState());

                // 发送告警
                if (transition.getToState() == State.OPEN) {
                    alertingService.sendAlert("CIRCUIT_BREAKER_OPEN",
                        "熔断器 " + name + " 已打开");
                }
            })
            .onFailureRateExceeded(event -> {
                log.warn("熔断器 [{}] 失败率超标: {}%",
                    name, event.getFailureRate());
            })
            .onSlowCallRateExceeded(event -> {
                log.warn("熔断器 [{}] 慢调用率超标: {}%",
                    name, event.getSlowCallRate());
            })
            .onCallNotPermitted(event -> {
                log.warn("熔断器 [{}] 拒绝请求（熔断器打开）", name);
            })
            .onError(event -> {
                log.debug("熔断器 [{}] 记录错误: {}", name, event.getThrowable().getMessage());
            });
    }
}

@Component
@Slf4j
public class CircuitBreakerHealthIndicator implements ReactiveHealthIndicator {

    @Autowired
    private CircuitBreakerRegistry registry;

    @Override
    public Mono<Health> health() {
        Map<String, CircuitBreaker> circuitBreakers = registry.getAllCircuitBreakers();

        Map<String, Object> details = new HashMap<>();
        boolean allHealthy = true;

        for (Map.Entry<String, CircuitBreaker> entry : circuitBreakers.entrySet()) {
            CircuitBreaker circuitBreaker = entry.getValue();
            CircuitBreakerMetrics metrics = circuitBreaker.getMetrics();

            Map<String, Object> cbDetails = new HashMap<>();
            cbDetails.put("state", circuitBreaker.getState().toString());
            cbDetails.put("failureRate", metrics.getFailureRate());
            cbDetails.put("slowCallRate", metrics.getSlowCallRate());
            cbDetails.put("bufferedCalls", metrics.getNumberOfBufferedCalls());
            cbDetails.put("failedCalls", metrics.getNumberOfFailedCalls());

            details.put(entry.getKey(), cbDetails);

            if (circuitBreaker.getState() == State.OPEN) {
                allHealthy = false;
            }
        }

        if (allHealthy) {
            return Mono.just(Health.up().withDetails(details).build());
        } else {
            return Mono.just(Health.down().withDetails(details).build());
        }
    }
}

@Configuration
public class Resilience4jConfig {

    @Bean
    public CircuitBreakerRegistry circuitBreakerRegistry(
            CircuitBreakerConfigurationProperties properties) {
        return CircuitBreakerRegistry.of(properties.createDefaultConfig());
    }
}

@Component
class CircuitBreakerConfigurationProperties {
    // 从 application.yml 读取配置
}