业务中台上线后异常处理：API 调用失败 / 数据同步延迟 / 能力复用故障？应急方案

// API调用重试机制示例
public async Task RetryApiCall(Func<>> apiCall, int maxRetries = 3)
{
    var retryCount = 0;
    var delay = 1000; // 初始延迟1秒
    
    while (true)
    {
        try
        {
            return await apiCall();
        }
        catch (Exception ex) when (retryCount < maxRetries)
        {
            retryCount++;
            await Task.Delay(delay);
            delay *= 2; // 指数退避
            // 记录日志
            Logger.Warning($"API调用失败，正在进行第{retryCount}次重试", ex);
        }
    }
}

// 使用Entity Framework Core实现数据同步状态监控
public class DataSyncMonitorService
{
    private readonly AppDbContext _context;
    
    public async Task CheckSyncStatus(string tableName, DateTime lastSyncTime)
    {
        var expectedCount = await _context.Set()
            .Where(x => x.TableName == tableName && x.OperationTime >= lastSyncTime)
            .CountAsync();
            
        var actualCount = await _context.Set()
            .Where(x => x.TableName == tableName && x.OperationTime >= lastSyncTime && x.Synced)
            .CountAsync();
            
        return expectedCount == actualCount;
    }
    
    // 数据不一致时自动修复
    public async Task RepairDataInconsistency(string tableName, DateTime startTime)
    {
        var unsyncedRecords = await _context.Set()
            .Where(x => x.TableName == tableName && 
                       x.OperationTime >= startTime && 
                       !x.Synced)
            .ToListAsync();
            
        foreach (var record in unsyncedRecords)
        {
            // 执行数据修复逻辑
            await RepairSingleRecord(record);
            record.Synced = true;
            record.SyncTime = DateTime.UtcNow;
        }
        
        await _context.SaveChangesAsync();
    }
}

// 使用Polly实现熔断机制
public class ResilientServiceClient
{
    private readonly AsyncCircuitBreakerPolicy _circuitBreakerPolicy;
    
    public ResilientServiceClient()
    {
        _circuitBreakerPolicy = Policy
            .Handle()
            .CircuitBreakerAsync(
                exceptionsAllowedBeforeBreaking: 3,
                durationOfBreak: TimeSpan.FromSeconds(30),
                onBreak: (ex, breakDelay) => 
                {
                    Logger.Error($"熔断器开启，{breakDelay.TotalSeconds}秒后重试", ex);
                },
                onReset: () => Logger.Info("熔断器关闭，恢复正常请求"),
                onHalfOpen: () => Logger.Info("熔断器半开，尝试接收请求"));
    }
    
    public async Task ExecuteWithResilience(Func<>> action)
    {
        return await _circuitBreakerPolicy.ExecuteAsync(action);
    }
}

// 前端监控告警集成示例
class MonitoringService {
  // API健康检查
  async checkAPIHealth() {
    try {
      const response = await fetch('/api/health-check');
      const data = await response.json();
      
      if (data.status !== 'healthy') {
        this.sendAlert('API服务异常', data);
        return false;
      }
      return true;
    } catch (error) {
      this.sendAlert('API健康检查失败', error);
      return false;
    }
  }
  
  // 发送告警
  sendAlert(title, content) {
    // 集成企业告警平台
    console.warn(`[告警] ${title}:`, content);
    // 实际项目中可接入邮件、短信、钉钉等告警渠道
  }
  
  // 定期执行监控
  startMonitoring() {
    setInterval(() => {
      this.checkAPIHealth();
      // 其他监控项...
    }, 60000); // 每分钟检查一次
  }
}

// 初始化监控
const monitor = new MonitoringService();
monitor.startMonitoring();