韧性架构三件事：超时、重试和熔断

# ❌ 坏做法：没有超时，默认值可能是无限等待
import requests
 
def get_user_profile(user_id):
    resp = requests.get(f"http://user-service/api/profile/{user_id}")
    return resp.json()

# ✅ 好做法：显式超时 + 根据下游能力设置合理值
import requests
 
def get_user_profile(user_id, timeout_ms=500):
    try:
        resp = requests.get(
            f"http://user-service/api/profile/{user_id}",
            timeout=timeout_ms / 1000
        )
        resp.raise_for_status()
        return resp.json()
    except requests.Timeout:
        logger.warning("user-service profile timeout", extra={"user_id": user_id})
        raise ServiceTimeoutError("user-service profile request timed out")

// ❌ 坏做法：context 没有超时，goroutine 可能永久阻塞
func GetUser(ctx context.Context, id string) (*User, error) {
    resp, err := http.Get(fmt.Sprintf("http://user-service/api/%s", id))
    // 如果 user-service 挂掉，这个 goroutine 永远不会返回
}

// ✅ 好做法：用 context.WithTimeout 控制超时，并传播截止时间
func GetUser(ctx context.Context, id string, timeoutMs time.Duration) (*User, error) {
    ctx, cancel := context.WithTimeout(ctx, timeoutMs*time.Millisecond)
    defer cancel()
 
    req, _ := http.NewRequestWithContext(ctx, "GET",
        fmt.Sprintf("http://user-service/api/%s", id), nil)
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        if ctx.Err() == context.DeadlineExceeded {
            return nil, fmt.Errorf("user-service timeout after %dms", timeoutMs)
        }
        return nil, err
    }
    defer resp.Body.Close()
    // ...
}

# ❌ 坏做法：无条件重试、没有退避、没有区分错误类型
def call_payment_service(order_id):
    for i in range(5):
        try:
            resp = requests.post("http://payment/charge", json={"order_id": order_id})
            return resp.json()
        except Exception:
            continue  # 所有异常都重试，包括参数错误；无间隔，立即重试
    raise PaymentError("payment failed after 5 retries")

# ✅ 好做法：区分错误类型、指数退避 + 抖动、最大次数限制
import random
import time
 
def call_payment_service(order_id, max_retries=3, base_delay_ms=100):
    for attempt in range(max_retries + 1):
        try:
            resp = requests.post(
                "http://payment/charge",
                json={"order_id": order_id, "idempotency_key": f"{order_id}-{attempt}"},
                timeout=2.0
            )
            # 4xx 错误不重试——参数问题重试没有意义
            if resp.status_code < 500:
                resp.raise_for_status()
                return resp.json()
            # 5xx 才进入重试逻辑
            if attempt < max_retries:
                delay = base_delay_ms * (2 ** attempt)
                jitter = random.randint(0, base_delay_ms)
                time.sleep((delay + jitter) / 1000)
        except requests.ConnectionError:
            if attempt < max_retries:
                delay = base_delay_ms * (2 ** attempt)
                jitter = random.randint(0, base_delay_ms)
                time.sleep((delay + jitter) / 1000)
                continue
            raise
    raise PaymentError(f"payment failed after {max_retries} retries")

// ❌ 坏做法：没有熔断，下游挂了还在不断调用
public UserProfile getUserProfile(String userId) {
    // 每次请求都直接调用下游，即使下游已经挂了 10 分钟
    return restTemplate.getForObject(
        "http://user-service/api/profile/" + userId,
        UserProfile.class
    );
}

// ✅ 好做法：使用 Resilience4j 的熔断器包装调用
import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
 
import java.time.Duration;
 
// 配置熔断器
CircuitBreakerConfig config = CircuitBreakerConfig.custom()
    .failureRateThreshold(50)                    // 失败率超过 50% 触发熔断
    .slowCallRateThreshold(80)                   // 慢调用超过 80% 也触发
    .slowCallDurationThreshold(Duration.ofMillis(500))
    .waitDurationInOpenState(Duration.ofSeconds(15))  // 熔断 15 秒后尝试恢复
    .permittedNumberOfCallsInHalfOpenState(5)    // 半开状态放 5 个探测请求
    .slidingWindowSize(100)                      // 统计最近 100 次调用
    .minimumNumberOfCalls(10)                    // 至少 10 次调用才开始统计
    .build();
 
CircuitBreakerRegistry registry = CircuitBreakerRegistry.of(config);
CircuitBreaker circuitBreaker = registry.circuitBreaker("userService");
 
// 使用熔断器包装调用
public UserProfile getUserProfile(String userId) {
    return CircuitBreaker.decorateSupplier(circuitBreaker, () ->
        restTemplate.getForObject(
            "http://user-service/api/profile/" + userId,
            UserProfile.class
        )
    ).get();
}

# ✅ 降级示例：推荐服务不可用时返回热门商品缓存
def get_recommendations(user_id):
    try:
        return recommend_service.get_personalized(user_id, timeout_ms=200)
    except ServiceTimeoutError:
        # 降级：返回全局热门商品缓存
        logger.info("recommend service timeout, fallback to hot items")
        return cache.get("global_hot_items")
    except CircuitBreakerOpenError:
        # 熔断：快速失败，返回缓存
        logger.info("recommend circuit open, fallback to cache")
        return cache.get(f"user_hot_items:{user_id}")