服务调用失败时有哪些处理手段

// gRPC Deadline Propagation 示意 (gRPC 1.60+)
// 客户端设置 500ms 超时
ManagedChannel channel = ManagedChannelBuilder
    .forAddress("service-b", 9090)
    .build();
 
OrderServiceGrpc.OrderServiceBlockingStub stub =
    OrderServiceGrpc.newBlockingStub(channel)
        .withDeadlineAfter(500, TimeUnit.MILLISECONDS);
 
// Deadline 自动传播到下游 service-c
// service-c 根据 context 中的剩余时间决定是否继续处理

# Dubbo 3.3 超时配置 (application.yml)
dubbo:
  consumer:
    timeout: 3000          # 全局默认超时 3s
    check: false
  service:
    timeout: 5000          # 服务级超时
  method:
    createUser:
      timeout: 1000        # 方法级超时（优先级最高）
    queryUser:
      timeout: 2000

# Istio 1.22+ VirtualService 超时配置
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: order-service
spec:
  hosts:
    - order-service
  http:
    - route:
        - destination:
            host: order-service
      timeout: 3s           # 全局超时 3s
    - match:
        - uri:
            prefix: /api/v1/orders/create
      route:
        - destination:
            host: order-service
      timeout: 1s           # 特定路径超时 1s

// 指数退避 + 抖动算法 (Java 17+)
public class RetryPolicy {
    private static final long BASE_DELAY_MS = 100;
    private static final long MAX_DELAY_MS = 10_000;
    private static final double JITTER_RATE = 0.5;
    private final SecureRandom random = new SecureRandom();
 
    public long computeDelay(int attempt) {
        long exponentialDelay = (long) Math.min(
            MAX_DELAY_MS,
            BASE_DELAY_MS * Math.pow(2, attempt)
        );
        // 加入抖动：延迟在 [exponentialDelay * (1-JITTER_RATE), exponentialDelay] 之间
        long jitteredDelay = (long) (exponentialDelay *
            (1 - JITTER_RATE + random.nextDouble() * JITTER_RATE));
        return jitteredDelay;
    }
}

# Istio 1.22+ 重试策略 + 重试预算
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: order-service
spec:
  hosts:
    - order-service
  http:
    - route:
        - destination:
            host: order-service
      retries:
        attempts: 3
        perTryTimeout: 1s
        retryOn: 5xx,reset,connect-failure,refused-stream
      # Envoy 层面可通过 cluster 配置 retry_budget

# Envoy Retry Budget 配置
retry_policy:
  retry_back_off:
    base_interval: 0.1s
    max_interval: 10s
  retry_budget:
    budget_percent:
      numerator: 20      # 重试请求占比不超过 20%
      denominator: HUNDRED
    min_retry_concurrency: 3  # 至少允许 3 个并发重试

// 幂等 Key 方案 (Spring Boot 3.x + Redis)
@Service
public class OrderService {
 
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
 
    public OrderResult createOrder(CreateOrderRequest request) {
        String idempotencyKey = request.getIdempotencyKey();
 
        // 1. 尝试获取幂等锁（SETNX + 过期时间）
        Boolean acquired = redisTemplate.opsForValue()
            .setIfAbsent("idempotent:" + idempotencyKey,
                         "processing",
                         Duration.ofMinutes(30));
 
        if (Boolean.FALSE.equals(acquired)) {
            // 2. Key 已存在，查询并返回已有结果
            String existingResult = redisTemplate.opsForValue()
                .get("idempotent:result:" + idempotencyKey);
            return deserializeResult(existingResult);
        }
 
        // 3. 执行业务逻辑
        OrderResult result = doCreateOrder(request);
 
        // 4. 存储结果并更新状态
        redisTemplate.opsForValue()
            .set("idempotent:result:" + idempotencyKey,
                 serializeResult(result),
                 Duration.ofMinutes(30));
        redisTemplate.opsForValue()
            .set("idempotent:" + idempotencyKey,
                 "completed",
                 Duration.ofMinutes(30));
 
        return result;
    }
}

-- 唯一约束幂等方案
CREATE TABLE orders (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    order_no VARCHAR(64) UNIQUE,     -- 业务唯一键，防止重复创建
    user_id BIGINT NOT NULL,
    amount DECIMAL(10, 2),
    status VARCHAR(32),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
 
-- 插入时利用唯一约束防重
INSERT INTO orders (order_no, user_id, amount, status)
VALUES ('ORD-20250609-001', 12345, 99.99, 'CREATED')
ON DUPLICATE KEY UPDATE status = status;  -- MySQL 8.0+

# Resilience4j 2.x CircuitBreaker 配置
resilience4j:
  circuitbreaker:
    configs:
      default:
        slidingWindowSize: 100            # 滑动窗口大小
        minimumNumberOfCalls: 10          # 最少请求数（避免样本不足误判）
        failureRateThreshold: 50          # 失败率阈值 50%
        slowCallDurationThreshold: 3s     # 慢调用判定时间
        slowCallRateThreshold: 80         # 慢调用比例阈值 80%
        waitDurationInOpenState: 30s      # Open 状态持续时间
        permittedNumberOfCallsInHalfOpenState: 5  # Half-Open 探测请求数
        automaticTransitionFromOpenToHalfOpenEnabled: true
    instances:
      orderService:
        baseConfig: default
        failureRateThreshold: 60
  retry:
    configs:
      default:
        maxAttempts: 3
        waitDuration: 500ms
        enableExponentialBackoff: true
        exponentialBackoffMultiplier: 2
        retryExceptions:
          - java.io.IOException
          - java.util.concurrent.TimeoutException

// Resilience4j 2.x 使用示例 (Java 17+)
@Service
public class OrderServiceClient {
 
    private final CircuitBreaker circuitBreaker;
    private final Retry retry;
 
    public OrderServiceClient(CircuitBreakerRegistry cbRegistry,
                               RetryRegistry retryRegistry) {
        this.circuitBreaker = cbRegistry.circuitBreaker("orderService");
        this.retry = retryRegistry.retry("orderService");
    }
 
    public Order getOrder(Long orderId) {
        // 函数式装饰：Retry → CircuitBreaker → 实际调用
        Supplier<Order> supplier = SupplierUtils
            .decorateSupplier(
                circuitBreaker,
                () -> doRemoteCall(orderId)
            );
 
        // 装饰 Retry
        supplier = Retry.decorateSupplier(retry, supplier);
 
        // 执行并处理降级
        return Try.ofSupplier(supplier)
            .recover(throwable -> fallbackOrder(orderId))
            .get();
    }
}

# Dubbo 3.3 集群容错配置
dubbo:
  consumer:
    cluster: failover       # 全局默认策略
    retries: 2              # failover 重试次数（不含首次调用）
  service:
    cluster: failfast       # 非幂等操作用 failfast
    method:
      createOrder:
        cluster: failfast   # 方法级覆盖
      queryOrder:
        cluster: failover
        retries: 3

// Dubbo 3.3 注解方式指定容错策略
@DubboService(cluster = "failfast")
public class OrderServiceImpl implements OrderService {
    // 创建订单 - 非幂等，使用 failfast
}
 
@DubboService(cluster = "failover", retries = 3)
public class QueryServiceImpl implements QueryService {
    // 查询服务 - 幂等，允许重试
}
 
@DubboService(cluster = "forking", forks = 3)
public class PriceServiceImpl implements PriceService {
    // 实时报价 - 并行调用 3 个节点取最快
}

# Istio 1.22+ DestinationRule 熔断配置
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: order-service
spec:
  host: order-service
  trafficPolicy:
    connectionPool:
      tcp:
        maxConnections: 100          # 最大 TCP 连接数
      http:
        h2UpgradePolicy: DEFAULT
        http1MaxPendingRequests: 200 # 最大待处理请求
        http2MaxRequests: 500        # 最大并发请求
    outlierDetection:
      consecutiveGatewayErrors: 5    # 连续 5 次网关错误触发熔断
      consecutive5xxErrors: 5        # 连续 5 次 5xx 错误触发熔断
      interval: 30s                  # 异常检测间隔
      baseEjectionTime: 60s          # 基础驱逐时间
      maxEjectionPercent: 50         # 最大驱逐比例（不超过 50% 节点被驱逐）
      minHealthPercent: 25           # 最少健康节点比例

// Seata 2.x AT 模式使用示例
@Service
public class BusinessService {
 
    @Autowired
    private OrderService orderService;
 
    @Autowired
    private StockService stockService;
 
    @GlobalTransactional(name = "create-order", rollbackFor = Exception.class)
    public void purchase(String userId, String commodityCode, int count) {
        // 1. 扣减库存（远程调用，自动纳入全局事务）
        stockService.deduct(commodityCode, count);
        // 2. 创建订单（远程调用，自动纳入全局事务）
        orderService.create(userId, commodityCode, count);
        // 任一步骤失败，Seata 自动回滚所有分支事务
    }
}

// Seata 2.x TCC 模式示例
@LocalTCC
public interface AccountTccService {
 
    @TwoPhaseBusinessAction(
        name = "deductAccount",
        commitMethod = "commit",
        rollbackMethod = "rollback"
    )
    boolean deduct(
        @BusinessActionContextParameter(paramName = "userId") String userId,
        @BusinessActionContextParameter(paramName = "amount") BigDecimal amount
    );
 
    boolean commit(BusinessActionContext context);
 
    boolean rollback(BusinessActionContext context);
}
 
@Service
public class AccountTccServiceImpl implements AccountTccService {
 
    @Autowired
    private AccountMapper accountMapper;
 
    @Override
    public boolean deduct(String userId, BigDecimal amount) {
        // Try 阶段：冻结金额（而非直接扣减）
        return accountMapper.freeze(userId, amount) > 0;
    }
 
    @Override
    public boolean commit(BusinessActionContext context) {
        // Confirm 阶段：扣减冻结金额
        String userId = context.getActionContext("userId", String.class);
        BigDecimal amount = context.getActionContext("amount", BigDecimal.class);
        return accountMapper.deductFrozen(userId, amount) > 0;
    }
 
    @Override
    public boolean rollback(BusinessActionContext context) {
        // Cancel 阶段：解冻金额，归还可用余额
        String userId = context.getActionContext("userId", String.class);
        BigDecimal amount = context.getActionContext("amount", BigDecimal.class);
        return accountMapper.unfreeze(userId, amount) > 0;
    }
}

# 生产环境推荐配置模板 (Dubbo 3.3 + Resilience4j 2.x + Istio 1.22+)
dubbo:
  consumer:
    timeout: 3000
    cluster: failover
    retries: 2
    check: false
 
resilience4j:
  circuitbreaker:
    instances:
      default:
        slidingWindowSize: 100
        minimumNumberOfCalls: 10
        failureRateThreshold: 50
        slowCallDurationThreshold: 3s
        slowCallRateThreshold: 80
        waitDurationInOpenState: 30s
        permittedNumberOfCallsInHalfOpenState: 5
  retry:
    instances:
      default:
        maxAttempts: 3
        waitDuration: 500ms
        enableExponentialBackoff: true
        exponentialBackoffMultiplier: 2
 
# Istio VirtualService + DestinationRule
# 见上文各章节配置示例