HTTP 客户端与弹性模式

// 反例 1：每次 new，Socket 泄漏
for (int i = 0; i < 1000; i++)
{
    using var client = new HttpClient();
    await client.GetStringAsync(url); // 每次都建立新 TCP 连接
}

// 反例 2：静态单例，DNS 永不刷新
private static readonly HttpClient _shared = new HttpClient();
// 运行几天后，目标服务换 IP，这里还在连旧地址

// 正例：IHttpClientFactory
builder.Services.AddHttpClient();

// 命名客户端
builder.Services.AddHttpClient("orders", client =>
{
    client.BaseAddress = new Uri("https://orders.internal.example.com");
    client.DefaultRequestHeaders.Add("Accept", "application/json");
    client.Timeout = TimeSpan.FromSeconds(10);
});

// 类型化客户端
builder.Services.AddHttpClient<IOrderGateway, OrderGateway>(client =>
{
    client.BaseAddress = new Uri("https://orders.internal.example.com");
});

public class OrderGateway(HttpClient http) : IOrderGateway
{
    public async Task<Order?> GetAsync(int id, CancellationToken ct)
        => await http.GetFromJsonAsync<Order>($"/api/orders/{id}", ct);
}

// 消费命名客户端
public class OrderService(IHttpClientFactory factory)
{
    public async Task<Order?> GetAsync(int id, CancellationToken ct)
    {
        var http = factory.CreateClient("orders");
        return await http.GetFromJsonAsync<Order>($"/api/orders/{id}", ct);
    }
}

// 引入 Microsoft.Extensions.Http.Resilience 或 Polly
builder.Services.AddHttpClient("payments", client =>
{
    client.BaseAddress = new Uri("https://payments.internal.example.com");
}).AddResilienceHandler("retry-pipeline", pipeline =>
{
    pipeline.AddRetry(new RetryStrategyOptions
    {
        MaxRetryAttempts = 3,
        Delay = TimeSpan.FromMilliseconds(200),
        BackoffType = DelayBackoffType.Exponential,
        UseJitter = true, // 随机抖动防止惊群
        ShouldHandle = args => args.Outcome.Exception is HttpRequestException ||
                               args.Outcome.Result?.StatusCode == HttpStatusCode.ServiceUnavailable
                                   ? PredicateResult.True()
                                   : PredicateResult.False()
    });
});

// 手动等价逻辑（示意）
int attempts = 0;
while (attempts < 3)
{
    try
    {
        return await http.GetAsync(url, ct);
    }
    catch (HttpRequestException) when (attempts++ < 2)
    {
        await Task.Delay(TimeSpan.FromMilliseconds(200 * (1 << attempts)));
    }
}

builder.Services.AddHttpClient("search", client =>
{
    client.Timeout = TimeSpan.FromSeconds(5); // 全局超时
}).AddResilienceHandler("cb-pipeline", pipeline =>
{
    pipeline.AddRetry(new RetryStrategyOptions
    {
        MaxRetryAttempts = 2,
        BackoffType = DelayBackoffType.Exponential
    });

    pipeline.AddCircuitBreaker(new CircuitBreakerStrategyOptions
    {
        FailureRatio = 0.5,          // 失败率超 50%
        MinimumThroughput = 10,      // 至少 10 次请求才统计
        SamplingDuration = TimeSpan.FromSeconds(10),
        BreakDuration = TimeSpan.FromSeconds(15), // 熔断 15 秒
        ShouldHandle = args => args.Outcome.Result?.StatusCode >= 500
                                   ? PredicateResult.True()
                                   : PredicateResult.False()
    });

    pipeline.AddTimeout(TimeSpan.FromSeconds(3));
});

// 多个下游实例：轮询分发
builder.Services.AddHttpClient("payments")
    .AddHttpMessageHandler(() => new RoundRobinHandler(
        ["https://payments-1.internal", "https://payments-2.internal"]));

public class RoundRobinHandler(string[] urls) : DelegatingHandler
{
    private int _index;

    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken ct)
    {
        var i = Interlocked.Increment(ref _index);
        request.RequestUri = new Uri(new Uri(urls[i % urls.Length]), request.RequestUri!.PathAndQuery);
        return await base.SendAsync(request, ct);
    }
}

// 故障转移：结合重试，失败后换下一个实例
// 配合 Polly 的 ShouldHandle，5xx 时重试且 RoundRobin 已切换到下一实例

builder.Services.AddHttpClient("billing")
    .AddHttpMessageHandler(() => new TimingHandler());

public class TimingHandler(ILogger<TimingHandler> logger) : DelegatingHandler
{
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken ct)
    {
        var sw = Stopwatch.StartNew();
        var response = await base.SendAsync(request, ct);
        sw.Stop();

        logger.LogInformation(
            "HTTP {Method} {Path} -> {StatusCode} in {ElapsedMs}ms (attempts hidden)",
            request.Method, request.RequestUri?.PathAndQuery,
            (int)response.StatusCode, sw.ElapsedMilliseconds);

        return response;
    }
}

// 打开内置 HTTP 日志（appsettings.json）
// "Logging": { "LogLevel": { "System.Net.Http.HttpClient": "Information" } }

builder.Services.AddHttpClient("orders").AddResilienceHandler("orders-pipeline", p =>
{
    // 顺序：重试 → 熔断 → 超时
    p.AddRetry(new RetryStrategyOptions
    {
        MaxRetryAttempts = 3,
        BackoffType = DelayBackoffType.Exponential,
        UseJitter = true
    });

    p.AddCircuitBreaker(new CircuitBreakerStrategyOptions
    {
        FailureRatio = 0.3,
        MinimumThroughput = 20,
        SamplingDuration = TimeSpan.FromSeconds(30),
        BreakDuration = TimeSpan.FromSeconds(10)
    });

    p.AddTimeout(TimeSpan.FromSeconds(8));
});

// 针对第三方支付：少重试、快失败
builder.Services.AddHttpClient("payment").AddResilienceHandler("payment-pipeline", p =>
{
    p.AddRetry(new RetryStrategyOptions { MaxRetryAttempts = 1, Delay = TimeSpan.FromMilliseconds(100) });
    p.AddTimeout(TimeSpan.FromSeconds(3));
});