.NET Core 中如何构建一个弹性的 HTTP 请求机制？

1. 理解弹性 HTTP 请求机制

什么是弹性？

弹性是指系统在面对故障或异常情况时，能够保持或快速恢复到正常状态的能力。在 HTTP 请求的上下文中，弹性意味着当请求失败时，系统能够自动采取一系列措施（如重试、降级、断路等）来确保请求最终成功或优雅地处理失败。

为什么需要弹性 HTTP 请求机制？

在分布式系统中，服务间的依赖关系复杂，任何一个服务的故障都可能导致整个系统的不可用。弹性 HTTP 请求机制可以帮助我们：

• 提高系统的可用性：通过重试、断路等策略，减少因瞬态故障导致的系统不可用。
• 增强用户体验：通过快速恢复和优雅降级，减少用户感知到的故障时间。
• 降低运维成本：通过自动化处理故障，减少人工干预的需求。

弹性机制的核心原则

• 重试（Retry）：在请求失败时，自动重试一定次数。
• 断路器（Circuit Breaker）：当失败率达到一定阈值时，暂时停止请求，避免雪崩效应。
• 超时（Timeout）：设置请求的超时时间，避免长时间等待。
• 降级（Fallback）：当请求失败时，提供备用的响应或行为。
• 负载均衡（Load Balancing）：将请求分散到多个服务实例，避免单点故障。

2. .NET Core 中的 HTTP 请求基础

HttpClient 的使用

在 .NET Core 中，HttpClient 是用于发送 HTTP 请求和接收 HTTP 响应的主要类。以下是一个简单的 HttpClient 使用示例：

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class HttpClientApplication
{
    public static async Task Main(string[] args)
    {
        using (HttpClient client = new HttpClient())
        {
            // 发送 GET 请求
            HttpResponseMessage response = await client.GetAsync("https://******");
            if (response.IsSuccessStatusCode)
            {
                // 读取响应内容
                string content = await response.Content.ReadAsStringAsync();
                Console.WriteLine(content);
            }
            else
            {
                // 输出错误状态码
                Console.WriteLine($"Error: {response.StatusCode}");
            }
        }
    }
}

HttpClientFactory 的引入

HttpClient 的直接使用存在一些问题，如 DNS 更新问题和套接字耗尽问题。为了解决这些问题，.NET Core 引入了 HttpClientFactory，它提供了更好的 HttpClient 生命周期管理和配置选项。

在 Startup.cs 中配置 HttpClientFactory：

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // 注册 HttpClientFactory 并添加一个命名的 HttpClient
        services.AddHttpClient("ResilientClient", client =>
        {
            client.BaseAddress = new Uri("https://******"); // 设置基础地址
            client.DefaultRequestHeaders.Add("Accept", "application/json"); // 设置默认请求头
        });
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // 其他中间件配置
    }
}

在控制器或服务中使用 HttpClientFactory：

using Microsoft.AspNetCore.Mvc;
using System.Net.Http;
using System.Threading.Tasks;

[ApiController]
[Route("[controller]")]
public class ResilientController : ControllerBase
{
    private readonly IHttpClientFactory _httpClientFactory;

    public ResilientController(IHttpClientFactory httpClientFactory)
    {
        _httpClientFactory = httpClientFactory;
    }

    [HttpGet]
    public async Task<IActionResult> Get()
    {
        // 通过名称获取 HttpClient 实例
        var client = _httpClientFactory.CreateClient("ResilientClient");

        // 发送 GET 请求
        var response = await client.GetAsync("posts/list");
        if (response.IsSuccessStatusCode)
        {
            var content = await response.Content.ReadAsStringAsync();
            return Ok(content); // 返回成功响应
        }

        return StatusCode((int)response.StatusCode); // 返回错误状态码
    }
}

优点：

• 生命周期管理：HttpClientFactory 自动管理 HttpClient 的生命周期，避免套接字耗尽问题。
• 配置灵活：可以为不同的 API 配置不同的 HttpClient 实例。
• DNS 更新支持：HttpClientFactory 会定期刷新 DNS 缓存。

3. 实现基本的重试机制

简单的重试逻辑

在没有使用任何库的情况下，我们可以通过简单的循环来实现重试逻辑：

public async Task<string> GetDataWithRetryAsync(int maxRetries = 3)
{
    int retryCount = 0;
    while (true)
    {
        try
        {
            // 发送 GET 请求
            HttpResponseMessage response = await _httpClient.GetAsync("data");
            response.EnsureSuccessStatusCode(); // 确保请求成功
            return await response.Content.ReadAsStringAsync(); // 返回响应内容
        }
        catch (HttpRequestException)
        {
            retryCount++;
            if (retryCount >= maxRetries)
            {
                throw; // 超过重试次数后抛出异常
            }
        }
    }
}

使用 Polly 实现重试策略

Polly 是一个流行的 .NET 弹性库，提供了丰富的策略来实现重试、断路、超时等功能。以下是一个使用 Polly 实现重试策略的示例：

using Polly;
using Polly.Retry;

public class RetryService
{
    private readonly HttpClient _httpClient;
    private readonly AsyncRetryPolicy<HttpResponseMessage> _retryPolicy;

    public RetryService(HttpClient httpClient)
    {
        _httpClient = httpClient;
        // 配置重试策略：最多重试 3 次，每次等待 2 秒
        _retryPolicy = Policy
            .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode) // 处理失败响应
            .Or<HttpRequestException>() // 处理请求异常
            .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))); // 指数退避
    }

    public async Task<string> GetDataWithRetryAsync()
    {
        // 执行重试策略
        HttpResponseMessage response = await _retryPolicy.ExecuteAsync(() => _httpClient.GetAsync("data"));
        response.EnsureSuccessStatusCode(); // 确保请求成功
        return await response.Content.ReadAsStringAsync(); // 返回响应内容
    }
}

重试策略的配置

Polly 允许我们灵活地配置重试策略，包括重试次数、重试间隔等。以下是一个配置指数退避重试策略的示例：

_retryPolicy = Policy
    .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
    .Or<HttpRequestException>()
    .WaitAndRetryAsync(5, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

4. 处理瞬态故障

什么是瞬态故障？

瞬态故障是指那些暂时性的、通常会自动恢复的故障。例如，网络抖动、服务暂时不可用等。瞬态故障的特点是它们通常是短暂的，重试后可能会成功。

常见的瞬态故障类型

• 网络抖动：网络连接不稳定导致的请求失败。
• 服务暂时不可用：目标服务因负载过高或维护而暂时不可用。
• 资源限制：目标服务因资源限制（如 CPU、内存）而暂时无法处理请求。

使用 Polly 处理瞬态故障

Polly 提供了多种策略来处理瞬态故障，包括重试、断路、超时等。以下是一个结合重试和断路策略的示例：

  // 定义重试策略，当HTTP请求失败时进行重试
  var retryPolicy = Policy
      .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
      .Or<HttpRequestException>()
      // 设置重试次数为3次，每次重试的间隔时间按指数递增（2^retryAttempt秒）
      .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

  // 定义熔断策略，当连续失败次数达到阈值时，熔断一段时间
  var circuitBreakerPolicy = Policy
      .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
      .Or<HttpRequestException>()
      .CircuitBreakerAsync(5, TimeSpan.FromSeconds(30)); // 设置熔断条件：连续失败5次后，熔断30秒

  // 将重试策略和熔断策略组合成一个综合策略
  var combinedPolicy = Policy.WrapAsync(retryPolicy, circuitBreakerPolicy);

  HttpResponseMessage response = await combinedPolicy.ExecuteAsync(() => _httpClient.GetAsync("data"));

5. 实现断路器模式

断路器模式的概念

断路器模式是一种用于防止系统因依赖服务故障而崩溃的设计模式。当依赖服务的失败率达到一定阈值时，断路器会打开，停止所有请求，直到依赖服务恢复。

使用 Polly 实现熔断策略

Polly 提供了 CircuitBreaker 策略来实现熔断策略。以下是一个使用 Polly 实现熔断策略的示例：

var circuitBreakerPolicy = Policy
    .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
    .Or<HttpRequestException>()
    .CircuitBreakerAsync(5, TimeSpan.FromSeconds(30)); // 连续失败 5 次后，断路器打开 30 秒

HttpResponseMessage response = await circuitBreakerPolicy.ExecuteAsync(() => _httpClient.GetAsync("data"));

配置熔断策略参数

Polly 允许我们配置熔断策略的参数，包括失败次数阈值、断路时间等。以下是一个配置断路器的示例：

var circuitBreakerPolicy = Policy
    .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
    .Or<HttpRequestException>()
    .CircuitBreakerAsync(
        exceptionsAllowedBeforeBreaking: 5, // 允许的失败次数
        durationOfBreak: TimeSpan.FromSeconds(30) // 断路时间
    );

6. 超时和超时策略

设置请求超时

在 HttpClient 中，我们可以通过 Timeout 属性设置请求的超时时间：

_httpClient.Timeout = TimeSpan.FromSeconds(10); // 设置超时时间为 10 秒

使用 Polly 实现超时策略

Polly 提供了 Timeout 策略来实现超时控制。以下是一个使用 Polly 实现超时策略的示例：

var timeoutPolicy = Policy.TimeoutAsync<HttpResponseMessage>(TimeSpan.FromSeconds(10)); // 设置超时时间为 10 秒

HttpResponseMessage response = await timeoutPolicy.ExecuteAsync(() => _httpClient.GetAsync("data"));

超时与重试的结合

我们可以将超时策略与重试策略结合使用，以应对因超时导致的请求失败：

var retryPolicy = Policy
    .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
    .Or<HttpRequestException>()
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))); // 重试策略

var timeoutPolicy = Policy.TimeoutAsync<HttpResponseMessage>(TimeSpan.FromSeconds(10)); // 超时策略

var combinedPolicy = Policy.WrapAsync(retryPolicy, timeoutPolicy); // 组合策略

HttpResponseMessage response = await combinedPolicy.ExecuteAsync(() => _httpClient.GetAsync("data"));

7. 负载均衡与请求分流

负载均衡的基本概念

负载均衡是指将请求分散到多个服务实例，以避免单点故障和提高系统的可扩展性。常见的负载均衡策略包括轮询、随机、加权轮询等。

在 .NET Core 中实现负载均衡

在 .NET Core 中，我们可以通过配置多个 HttpClient 实例来实现负载均衡。以下是一个简单的负载均衡示例：

public class LoadBalancer
{
    private readonly List<HttpClient> _httpClients;
    private readonly Random _random = new Random();

    public LoadBalancer(IHttpClientFactory httpClientFactory)
    {
        _httpClients = new List<HttpClient>
        {
            httpClientFactory.CreateClient("ServiceInstance1"), // 实例 1
            httpClientFactory.CreateClient("ServiceInstance2"), // 实例 2
            httpClientFactory.CreateClient("ServiceInstance3")  // 实例 3
        };
    }

    public async Task<string> GetDataAsync()
    {
        // 随机选择一个 HttpClient 实例
        HttpClient client = _httpClients[_random.Next(_httpClients.Count)];
        HttpResponseMessage response = await client.GetAsync("data");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}

请求分流的策略

请求分流是指根据某些条件（如请求内容、用户身份等）将请求分发到不同的服务实例。以下是一个简单的请求分流示例：

public async Task<string> GetDataAsync(string userId)
{
    // 根据用户 ID 选择不同的 HttpClient 实例
    HttpClient client = userId.StartsWith("A") ? _httpClients[0] : _httpClients[1];
    HttpResponseMessage response = await client.GetAsync("data");
    response.EnsureSuccessStatusCode();
    return await response.Content.ReadAsStringAsync();
}

8. 监控与日志记录

监控 HTTP 请求的重要性

监控 HTTP 请求可以帮助我们及时发现和解决问题，确保系统的稳定性和可靠性。常见的监控指标包括请求成功率、响应时间、错误率等。

使用 Application Insights 进行监控

Application Insights 是 Azure 提供的一个应用性能管理服务，可以帮助我们监控和分析 HTTP 请求。以下是一个使用 Application Insights 监控 HTTP 请求的示例：

public class HttpRemoteService
{
    private readonly HttpClient _httpClient;
    private readonly TelemetryClient _telemetryClient;

    public HttpRemoteService(HttpClient httpClient, TelemetryClient telemetryClient)
    {
        _httpClient = httpClient;
        _telemetryClient = telemetryClient;
    }

    public async Task<string> GetDataAsync()
    {
        var startTime = DateTime.UtcNow;
        var timer = System.Diagnostics.Stopwatch.StartNew();

        try
        {
            HttpResponseMessage response = await _httpClient.GetAsync("data");
            response.EnsureSuccessStatusCode();
            return await response.Content.ReadAsStringAsync();
        }
        catch (Exception ex)
        {
            _telemetryClient.TrackException(ex); // 记录异常
            throw;
        }
        finally
        {
            timer.Stop();
            _telemetryClient.TrackDependency("HTTP", "GET", "data", startTime, timer.Elapsed, true); // 记录依赖调用
        }
    }
}

日志记录的最佳实践

日志记录是监控和调试的重要工具。以下是一些日志记录的最佳实践：

• 记录关键信息：如请求 URL、响应状态码、响应时间等。
• 使用结构化日志：便于日志的查询和分析。
• 避免记录敏感信息：如密码、令牌等。

public async Task<string> GetDataAsync()
{
    _logger.LogInformation("正在发送 HTTP GET 请求到 {Url}", "https://api.*****.com/data");

    try
    {
        HttpResponseMessage response = await _httpClient.GetAsync("data");
        response.EnsureSuccessStatusCode();
        string content = await response.Content.ReadAsStringAsync();
        _logger.LogInformation("请求成功，响应状态码: {StatusCode}", response.StatusCode);
        return content;
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "请求失败: {Message}", ex.Message);
        throw;
    }
}

参考资料

• Polly 官方文档
• .NET Core 官方文档
• Application Insights 官方文档

结语

在 .NET Core 中构建一个弹性的 HTTP 请求机制是一个复杂但值得的任务。希望本文能够帮助你在 .NET Core 中构建一个健壮的 HTTP 请求机制。