云原生微服务容错软件设计：熔断、重试与超时控制的实战解析

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-circuitbreaker-resilience4j</artifactId>
    <version>3.1.0</version>
</dependency>
<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot3</artifactId>
    <version>2.2.0</version>
</dependency>

resilience4j:
  circuitbreaker:
    instances:
      paymentService:
        register-health-indicator: true
        sliding-window-type: COUNT_BASED
        sliding-window-size: 10          # 统计最近10次调用
        failure-rate-threshold: 50       # 错误率≥50%开启熔断
        slow-call-rate-threshold: 50     # 慢调用率≥50%开启熔断
        slow-call-duration-threshold: 2s # 超过2s视为慢调用
        permitted-number-of-calls-in-half-open-state: 3
        automatic-transition-from-open-to-half-open-enabled: true
        wait-duration-in-open-state: 10s # 熔断后等待10s进入半开
        minimum-number-of-calls: 5        # 至少5次调用才开始统计

@Service
@Slf4j
public class PaymentServiceClient {

    private final RestClient restClient;
    private final CircuitBreakerFactory circuitBreakerFactory;

    @Autowired
    public PaymentServiceClient(RestClient.Builder builder, 
                                CircuitBreakerFactory circuitBreakerFactory) {
        this.restClient = builder.baseUrl("http://payment-svc:8080").build();
        this.circuitBreakerFactory = circuitBreakerFactory;
    }

    public PaymentResponse charge(PaymentRequest request) {
        // 创建熔断器实例（对应配置中的 paymentService）
        CircuitBreaker cb = circuitBreakerFactory.create("paymentService");
        // 使用装饰器包装函数
        Supplier<PaymentResponse> decorated = CircuitBreaker.decorateSupplier(
            cb, () -> doCharge(request)
        );
        // 降级逻辑：返回兜底响应
        return Try.ofSupplier(decorated)
                  .recover(throwable -> fallback(request, throwable))
                  .get();
    }

    private PaymentResponse doCharge(PaymentRequest request) {
        return restClient.post()
                .uri("/api/v1/charge")
                .body(request)
                .retrieve()
                .body(PaymentResponse.class);
    }

    private PaymentResponse fallback(PaymentRequest request, Throwable t) {
        log.warn("Payment service unavailable, use fallback. request: {}", request, t);
        return PaymentResponse.builder()
                .code("FALLBACK")
                .message("降级处理，请稍后重试")
                .amount(request.getAmount())
                .status(PaymentStatus.PENDING)
                .build();
    }
}

# application.yml
management:
  health:
    circuitbreakers:
      enabled: true
  endpoints:
    web:
      exposure:
        include: health,circuitbreakers

# K8s deployment.yaml 就绪探针
readinessProbe:
  httpGet:
    path: /actuator/health/readiness
    port: 8080
  initialDelaySeconds: 30
  periodSeconds: 10

@Configuration
public class RetryConfig {

    @Bean
    public RetryTemplate retryTemplate() {
        // 固定延迟 + 指数乘数
        ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
        backOffPolicy.setInitialInterval(500);      // 首次重试间隔500ms
        backOffPolicy.setMultiplier(2.0);           // 每次翻倍
        backOffPolicy.setMaxInterval(10000);        // 最大间隔10s

        // 添加随机抖动（避免同时重试）
        RetryTemplate template = RetryTemplate.builder()
                .maxAttempts(4)                     // 最多重试3次（总调用4次）
                .exponentialBackoff(500, 2, 10000)
                .withJitter(0.3)                    // 30%随机抖动
                .retryOn(IOException.class, TimeoutException.class)
                .build();
        return template;
    }
}

@Service
public class InventoryServiceClient {

    @Retryable(
        value = {RetryableException.class},
        maxAttempts = 4,
        backoff = @Backoff(delay = 500, multiplier = 2, maxDelay = 10000, random = true)
    )
    public InventoryResponse deductStock(StockRequest request) {
        // 调用库存服务，可能抛出 RetryableException
        return restClient.post()
                .uri("/inventory/deduct")
                .body(request)
                .retrieve()
                .body(InventoryResponse.class);
    }
}

@Bean
public RestClient restClient() {
    return RestClient.builder()
            .baseUrl("http://payment-svc:8080")
            .requestFactory(
                new ClientHttpRequestFactoryBuilder() {
                    @Override
                    public ClientHttpRequestFactory build() {
                        HttpComponentsClientHttpRequestFactory factory = 
                            new HttpComponentsClientHttpRequestFactory();
                        factory.setConnectTimeout(2000);   // 2s
                        factory.setReadTimeout(3000);      // 3s
                        return factory;
                    }
                }
            )
            .build();
}

// 在熔断器配置中启用 TimeLimiter
resilience4j.timelimiter:
  instances:
    paymentService:
      timeout-duration: 5s  # 整个调用（含重试）不得超过5s

@Bean
public ExecutorService paymentExecutor() {
    return Executors.newFixedThreadPool(10, 
        new ThreadFactoryBuilder().setNameFormat("payment-pool-%d").build());
}