第十三章：远程请求与HTTP客户端

一、HttpClient 基础

1.1 .NET HttpClient 概述

在现代微服务和分布式架构中，服务间的 HTTP 通信是必不可少的。.NET 提供了 HttpClient 类用于发送 HTTP 请求，而 Furion 在此基础上进行了大量增强，提供了更简洁、更强大的远程请求方式。

1.2 原生 HttpClient 的问题

问题	说明
套接字耗尽	频繁创建/销毁 HttpClient 可能导致端口耗尽
DNS 更新	单例 HttpClient 不会更新 DNS 解析结果
配置繁琐	每次请求需手动设置请求头、序列化等
缺少拦截器	不支持统一的请求/响应拦截
重试困难	没有内置的重试机制

1.3 IHttpClientFactory

.NET 推荐使用 IHttpClientFactory 管理 HttpClient 实例：

// 注册 HttpClient
builder.Services.AddHttpClient();

// 使用命名客户端
builder.Services.AddHttpClient("GitHubApi", client =>
{
    client.BaseAddress = new Uri("https://api.github.com/");
    client.DefaultRequestHeaders.Add("Accept", "application/json");
    client.DefaultRequestHeaders.Add("User-Agent", "FurionApp");
});

二、Furion 远程请求增强

2.1 注册远程请求服务

var builder = WebApplication.CreateBuilder(args);

// 注册 Furion 远程请求服务
builder.Services.AddRemoteRequest();

var app = builder.Build();
app.Run();

2.2 基本使用方式

Furion 提供了多种远程请求方式：

方式	说明	适用场景
字符串扩展方法	直接在 URL 字符串上调用	快速简单请求
IHttpDispatchProxy	接口代理方式	微服务间通信
HttpClient 增强	增强版 HttpClient	需要完全控制

// 方式1：字符串扩展方法（最简洁）
var result = await "https://api.example.com/users".GetAsAsync<List<UserDto>>();

// 方式2：POST 请求
var user = await "https://api.example.com/users".SetBody(new { Name = "张三", Age = 25 })
    .PostAsAsync<UserDto>();

// 方式3：带请求头
var data = await "https://api.example.com/data"
    .SetHeaders(new Dictionary<string, object>
    {
        { "Authorization", "Bearer xxx" },
        { "X-Request-Id", Guid.NewGuid().ToString() }
    })
    .GetAsAsync<DataDto>();

三、IHttpDispatchProxy 接口代理

3.1 声明式 HTTP 请求

IHttpDispatchProxy 允许通过定义接口来声明 HTTP 请求，类似于 Java 中的 Feign：

/// <summary>
/// 用户服务 HTTP 代理接口
/// </summary>
public interface IUserServiceApi : IHttpDispatchProxy
{
    /// <summary>
    /// 获取用户列表
    /// </summary>
    [Get("https://api.userservice.com/api/users")]
    Task<List<UserDto>> GetUsersAsync();

    /// <summary>
    /// 根据Id获取用户
    /// </summary>
    [Get("https://api.userservice.com/api/users/{id}")]
    Task<UserDto> GetUserByIdAsync([RouteParam] long id);

    /// <summary>
    /// 创建用户
    /// </summary>
    [Post("https://api.userservice.com/api/users")]
    Task<UserDto> CreateUserAsync([Body] CreateUserInput input);

    /// <summary>
    /// 更新用户
    /// </summary>
    [Put("https://api.userservice.com/api/users/{id}")]
    Task<UserDto> UpdateUserAsync([RouteParam] long id, [Body] UpdateUserInput input);

    /// <summary>
    /// 删除用户
    /// </summary>
    [Delete("https://api.userservice.com/api/users/{id}")]
    Task DeleteUserAsync([RouteParam] long id);
}

3.2 使用接口代理

[ApiDescriptionSettings("用户管理")]
public class UserAppService : IDynamicApiController
{
    private readonly IUserServiceApi _userServiceApi;

    public UserAppService(IUserServiceApi userServiceApi)
    {
        _userServiceApi = userServiceApi;
    }

    /// <summary>
    /// 获取所有用户
    /// </summary>
    public async Task<List<UserDto>> GetUsers()
    {
        return await _userServiceApi.GetUsersAsync();
    }

    /// <summary>
    /// 获取用户详情
    /// </summary>
    public async Task<UserDto> GetUser(long id)
    {
        return await _userServiceApi.GetUserByIdAsync(id);
    }

    /// <summary>
    /// 创建用户
    /// </summary>
    public async Task<UserDto> CreateUser(CreateUserInput input)
    {
        return await _userServiceApi.CreateUserAsync(input);
    }
}

3.3 配置基础地址

通过 appsettings.json 配置服务地址，避免硬编码：

{
  "RemoteRequest": {
    "UserService": {
      "BaseUrl": "https://api.userservice.com",
      "Timeout": 30
    },
    "OrderService": {
      "BaseUrl": "https://api.orderservice.com",
      "Timeout": 60
    }
  }
}

/// <summary>
/// 使用配置的基础地址
/// </summary>
[Client("UserService")]
public interface IUserServiceApi : IHttpDispatchProxy
{
    [Get("/api/users")]
    Task<List<UserDto>> GetUsersAsync();

    [Get("/api/users/{id}")]
    Task<UserDto> GetUserByIdAsync([RouteParam] long id);

    [Post("/api/users")]
    Task<UserDto> CreateUserAsync([Body] CreateUserInput input);
}

四、RESTful 请求详解

4.1 GET 请求

// 简单 GET 请求
var users = await "https://api.example.com/users".GetAsAsync<List<UserDto>>();

// 带查询参数
var result = await "https://api.example.com/users"
    .SetQueries(new
    {
        page = 1,
        pageSize = 20,
        keyword = "张三",
        status = "active"
    })
    .GetAsAsync<PagedResult<UserDto>>();

// 带请求头的 GET
var data = await "https://api.example.com/protected/data"
    .SetHeaders(new Dictionary<string, object>
    {
        { "Authorization", $"Bearer {token}" }
    })
    .GetAsAsync<ProtectedData>();

// 获取原始字符串
var rawJson = await "https://api.example.com/users".GetAsStringAsync();

// 获取 HttpResponseMessage
var response = await "https://api.example.com/users".GetAsync();

4.2 POST 请求

// JSON Body
var newUser = await "https://api.example.com/users"
    .SetBody(new CreateUserInput
    {
        UserName = "张三",
        Email = "zhangsan@example.com",
        Password = "SecurePass123"
    })
    .PostAsAsync<UserDto>();

// Form 表单提交
var loginResult = await "https://api.example.com/auth/token"
    .SetBody(new Dictionary<string, string>
    {
        { "grant_type", "password" },
        { "username", "admin" },
        { "password", "123456" }
    }, "application/x-www-form-urlencoded")
    .PostAsAsync<TokenResult>();

// 带查询参数的 POST
var result = await "https://api.example.com/api/batch"
    .SetQueries(new { type = "import" })
    .SetBody(dataList)
    .PostAsAsync<BatchResult>();

4.3 PUT 请求

// 更新资源
var updatedUser = await "https://api.example.com/users/1"
    .SetBody(new UpdateUserInput
    {
        UserName = "张三（已更新）",
        Email = "zhangsan_new@example.com"
    })
    .PutAsAsync<UserDto>();

4.4 DELETE 请求

// 删除资源
await "https://api.example.com/users/1".DeleteAsync();

// 带条件删除
await "https://api.example.com/users"
    .SetQueries(new { ids = "1,2,3" })
    .DeleteAsync();

4.5 PATCH 请求

// 部分更新
var patchedUser = await "https://api.example.com/users/1"
    .SetBody(new { Email = "new_email@example.com" })
    .PatchAsAsync<UserDto>();

五、请求拦截器

5.1 请求拦截

/// <summary>
/// 请求拦截器：统一添加认证信息
/// </summary>
public class AuthorizationInterceptor : IHttpDispatchProxy
{
    // 在接口代理中使用拦截器
}

// 使用 OnRequesting 回调
var result = await "https://api.example.com/data"
    .OnRequesting((client, request) =>
    {
        // 添加认证头
        request.Headers.Authorization =
            new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", GetAccessToken());

        // 添加自定义头
        request.Headers.Add("X-Correlation-Id", Guid.NewGuid().ToString());
        request.Headers.Add("X-Client-Version", "1.0.0");
    })
    .GetAsAsync<DataResult>();

private static string GetAccessToken() => "your-access-token";

5.2 全局请求拦截

/// <summary>
/// 全局 HTTP 请求拦截处理器
/// </summary>
public class GlobalHttpMessageHandler : DelegatingHandler
{
    private readonly ILogger<GlobalHttpMessageHandler> _logger;

    public GlobalHttpMessageHandler(ILogger<GlobalHttpMessageHandler> logger)
    {
        _logger = logger;
    }

    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        // 请求前处理
        var requestId = Guid.NewGuid().ToString("N");
        request.Headers.Add("X-Request-Id", requestId);

        _logger.LogInformation("[{RequestId}] {Method} {Url}",
            requestId, request.Method, request.RequestUri);

        var stopwatch = System.Diagnostics.Stopwatch.StartNew();

        // 发送请求
        var response = await base.SendAsync(request, cancellationToken);

        stopwatch.Stop();

        // 响应后处理
        _logger.LogInformation("[{RequestId}] 响应状态：{StatusCode}，耗时：{Elapsed}ms",
            requestId, (int)response.StatusCode, stopwatch.ElapsedMilliseconds);

        return response;
    }
}

// 注册全局拦截器
builder.Services.AddTransient<GlobalHttpMessageHandler>();
builder.Services.AddHttpClient("Default")
    .AddHttpMessageHandler<GlobalHttpMessageHandler>();

六、响应拦截器

6.1 响应处理

// 响应拦截
var result = await "https://api.example.com/data"
    .OnResponsing((client, response) =>
    {
        // 检查响应状态
        if (!response.IsSuccessStatusCode)
        {
            // 记录错误日志
            Console.WriteLine($"请求失败：{response.StatusCode}");
        }

        // 检查特定响应头
        if (response.Headers.Contains("X-RateLimit-Remaining"))
        {
            var remaining = response.Headers.GetValues("X-RateLimit-Remaining").First();
            Console.WriteLine($"API 剩余调用次数：{remaining}");
        }
    })
    .GetAsAsync<DataResult>();

6.2 统一响应处理

/// <summary>
/// 远程请求帮助类
/// </summary>
public static class RemoteRequestHelper
{
    /// <summary>
    /// 带统一错误处理的 GET 请求
    /// </summary>
    public static async Task<T> SafeGetAsync<T>(string url, Dictionary<string, object> headers = null)
    {
        try
        {
            var request = url;
            if (headers != null)
            {
                request = url;
            }

            var response = await url
                .SetHeaders(headers ?? new Dictionary<string, object>())
                .OnResponsing((client, resp) =>
                {
                    if (resp.StatusCode == System.Net.HttpStatusCode.Unauthorized)
                    {
                        throw new UnauthorizedAccessException("远程服务认证失败");
                    }

                    if (resp.StatusCode == System.Net.HttpStatusCode.NotFound)
                    {
                        throw new InvalidOperationException($"远程资源不存在：{url}");
                    }
                })
                .GetAsAsync<ApiResponse<T>>();

            if (response.Code != 200)
            {
                throw new Exception($"远程请求业务异常：{response.Message}");
            }

            return response.Data;
        }
        catch (HttpRequestException ex)
        {
            throw new Exception($"远程请求网络异常：{ex.Message}", ex);
        }
        catch (TaskCanceledException)
        {
            throw new TimeoutException($"远程请求超时：{url}");
        }
    }
}

/// <summary>
/// 统一 API 响应模型
/// </summary>
public class ApiResponse<T>
{
    public int Code { get; set; }
    public string Message { get; set; }
    public T Data { get; set; }
    public bool Success => Code == 200;
}

七、文件上传与下载

7.1 文件上传

/// <summary>
/// 文件上传服务
/// </summary>
public class FileUploadService
{
    /// <summary>
    /// 单文件上传
    /// </summary>
    public async Task<FileUploadResult> UploadFileAsync(Stream fileStream, string fileName)
    {
        var content = new MultipartFormDataContent();
        var streamContent = new StreamContent(fileStream);
        content.Add(streamContent, "file", fileName);

        var result = await "https://api.example.com/files/upload"
            .SetBody(content)
            .PostAsAsync<FileUploadResult>();

        return result;
    }

    /// <summary>
    /// 多文件上传
    /// </summary>
    public async Task<List<FileUploadResult>> UploadFilesAsync(List<(Stream Stream, string FileName)> files)
    {
        var content = new MultipartFormDataContent();

        foreach (var (stream, fileName) in files)
        {
            var streamContent = new StreamContent(stream);
            content.Add(streamContent, "files", fileName);
        }

        // 添加额外表单字段
        content.Add(new StringContent("images"), "category");

        var result = await "https://api.example.com/files/batch-upload"
            .SetBody(content)
            .PostAsAsync<List<FileUploadResult>>();

        return result;
    }
}

/// <summary>
/// 文件上传结果
/// </summary>
public class FileUploadResult
{
    public string FileId { get; set; }
    public string FileName { get; set; }
    public string Url { get; set; }
    public long Size { get; set; }
}

7.2 文件下载

/// <summary>
/// 文件下载服务
/// </summary>
public class FileDownloadService
{
    /// <summary>
    /// 下载文件到本地
    /// </summary>
    public async Task DownloadFileAsync(string fileUrl, string savePath)
    {
        var response = await fileUrl.GetAsync();
        response.EnsureSuccessStatusCode();

        await using var fileStream = File.Create(savePath);
        await response.Content.CopyToAsync(fileStream);
    }

    /// <summary>
    /// 下载文件为字节数组
    /// </summary>
    public async Task<byte[]> DownloadFileBytesAsync(string fileUrl)
    {
        var response = await fileUrl.GetAsync();
        response.EnsureSuccessStatusCode();

        return await response.Content.ReadAsByteArrayAsync();
    }

    /// <summary>
    /// 下载大文件（流式处理）
    /// </summary>
    public async Task DownloadLargeFileAsync(string fileUrl, string savePath, IProgress<long> progress = null)
    {
        using var httpClient = new HttpClient();
        using var response = await httpClient.GetAsync(fileUrl, HttpCompletionOption.ResponseHeadersRead);
        response.EnsureSuccessStatusCode();

        var totalBytes = response.Content.Headers.ContentLength ?? -1L;

        await using var contentStream = await response.Content.ReadAsStreamAsync();
        await using var fileStream = File.Create(savePath);

        var buffer = new byte[8192];
        var totalBytesRead = 0L;
        int bytesRead;

        while ((bytesRead = await contentStream.ReadAsync(buffer)) > 0)
        {
            await fileStream.WriteAsync(buffer.AsMemory(0, bytesRead));
            totalBytesRead += bytesRead;
            progress?.Report(totalBytesRead);
        }
    }
}

八、超时与重试

8.1 超时配置

// 设置请求超时
var result = await "https://api.example.com/slow-api"
    .SetHttpClientTimeout(TimeSpan.FromSeconds(60))
    .GetAsAsync<SlowResult>();

// 在命名客户端中配置超时
builder.Services.AddHttpClient("SlowService", client =>
{
    client.BaseAddress = new Uri("https://api.slowservice.com");
    client.Timeout = TimeSpan.FromMinutes(2);
});

8.2 重试策略

使用 Polly 实现重试策略：

// 安装 Microsoft.Extensions.Http.Polly 包
builder.Services.AddHttpClient("ResilientService")
    .AddTransientHttpErrorPolicy(policy =>
        policy.WaitAndRetryAsync(3, retryAttempt =>
            TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))))
    .AddTransientHttpErrorPolicy(policy =>
        policy.CircuitBreakerAsync(5, TimeSpan.FromSeconds(30)));

8.3 自定义重试逻辑

/// <summary>
/// 带重试的 HTTP 请求帮助类
/// </summary>
public static class ResilientHttpHelper
{
    /// <summary>
    /// 带重试的 GET 请求
    /// </summary>
    public static async Task<T> GetWithRetryAsync<T>(
        string url,
        int maxRetries = 3,
        int baseDelayMs = 1000)
    {
        Exception lastException = null;

        for (int i = 0; i <= maxRetries; i++)
        {
            try
            {
                return await url.GetAsAsync<T>();
            }
            catch (HttpRequestException ex) when (i < maxRetries)
            {
                lastException = ex;
                var delay = baseDelayMs * (int)Math.Pow(2, i);
                await Task.Delay(delay);
            }
            catch (TaskCanceledException ex) when (i < maxRetries)
            {
                lastException = ex;
                var delay = baseDelayMs * (int)Math.Pow(2, i);
                await Task.Delay(delay);
            }
        }

        throw new Exception($"请求 {url} 失败，已重试 {maxRetries} 次", lastException);
    }
}

九、请求日志

9.1 日志中间件

/// <summary>
/// HTTP 请求日志处理器
/// </summary>
public class HttpLoggingHandler : DelegatingHandler
{
    private readonly ILogger<HttpLoggingHandler> _logger;

    public HttpLoggingHandler(ILogger<HttpLoggingHandler> logger) => _logger = logger;

    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        var requestId = Guid.NewGuid().ToString("N")[..8];
        var stopwatch = System.Diagnostics.Stopwatch.StartNew();

        // 记录请求信息
        _logger.LogInformation(
            "[{RequestId}] >>> {Method} {Url}",
            requestId, request.Method, request.RequestUri);

        if (request.Content != null)
        {
            var body = await request.Content.ReadAsStringAsync(cancellationToken);
            if (body.Length <= 1000) // 限制日志长度
            {
                _logger.LogDebug("[{RequestId}] 请求体：{Body}", requestId, body);
            }
        }

        // 发送请求
        var response = await base.SendAsync(request, cancellationToken);

        stopwatch.Stop();

        // 记录响应信息
        var level = response.IsSuccessStatusCode ? LogLevel.Information : LogLevel.Warning;
        _logger.Log(level,
            "[{RequestId}] <<< {StatusCode} {ReasonPhrase} ({Elapsed}ms)",
            requestId, (int)response.StatusCode, response.ReasonPhrase,
            stopwatch.ElapsedMilliseconds);

        return response;
    }
}

9.2 注册日志处理器

builder.Services.AddTransient<HttpLoggingHandler>();

builder.Services.AddHttpClient("LoggedClient")
    .AddHttpMessageHandler<HttpLoggingHandler>();

十、微服务间通信

10.1 服务发现与请求

/// <summary>
/// 微服务 HTTP 代理集合
/// </summary>
[Client("OrderService")]
public interface IOrderServiceApi : IHttpDispatchProxy
{
    [Get("/api/orders")]
    Task<PagedResult<OrderDto>> GetOrdersAsync(
        [QueryString] int page = 1,
        [QueryString] int pageSize = 20);

    [Get("/api/orders/{orderId}")]
    Task<OrderDto> GetOrderAsync([RouteParam] long orderId);

    [Post("/api/orders")]
    Task<OrderDto> CreateOrderAsync([Body] CreateOrderInput input);

    [Put("/api/orders/{orderId}/status")]
    Task UpdateOrderStatusAsync(
        [RouteParam] long orderId,
        [Body] UpdateStatusInput input);
}

[Client("InventoryService")]
public interface IInventoryServiceApi : IHttpDispatchProxy
{
    [Get("/api/inventory/{productId}")]
    Task<InventoryDto> GetInventoryAsync([RouteParam] long productId);

    [Post("/api/inventory/deduct")]
    Task<bool> DeductInventoryAsync([Body] DeductInventoryInput input);

    [Post("/api/inventory/restore")]
    Task<bool> RestoreInventoryAsync([Body] RestoreInventoryInput input);
}

10.2 编排多个服务调用

/// <summary>
/// 订单编排服务
/// </summary>
[ApiDescriptionSettings("订单编排")]
public class OrderOrchestrationService : IDynamicApiController
{
    private readonly IOrderServiceApi _orderApi;
    private readonly IInventoryServiceApi _inventoryApi;
    private readonly ILogger<OrderOrchestrationService> _logger;

    public OrderOrchestrationService(
        IOrderServiceApi orderApi,
        IInventoryServiceApi inventoryApi,
        ILogger<OrderOrchestrationService> logger)
    {
        _orderApi = orderApi;
        _inventoryApi = inventoryApi;
        _logger = logger;
    }

    /// <summary>
    /// 创建订单（编排多个服务）
    /// </summary>
    public async Task<OrderDto> CreateOrder(CreateOrderInput input)
    {
        // 1. 检查库存
        var inventory = await _inventoryApi.GetInventoryAsync(input.ProductId);
        if (inventory.Available < input.Quantity)
        {
            throw new Exception("库存不足");
        }

        // 2. 扣减库存
        var deducted = await _inventoryApi.DeductInventoryAsync(new DeductInventoryInput
        {
            ProductId = input.ProductId,
            Quantity = input.Quantity
        });

        if (!deducted)
        {
            throw new Exception("扣减库存失败");
        }

        try
        {
            // 3. 创建订单
            var order = await _orderApi.CreateOrderAsync(input);
            return order;
        }
        catch (Exception ex)
        {
            // 4. 补偿：恢复库存
            _logger.LogError(ex, "创建订单失败，开始恢复库存");
            await _inventoryApi.RestoreInventoryAsync(new RestoreInventoryInput
            {
                ProductId = input.ProductId,
                Quantity = input.Quantity
            });

            throw;
        }
    }
}

十一、请求转发

11.1 网关模式转发

/// <summary>
/// API 网关转发控制器
/// </summary>
[ApiDescriptionSettings("网关")]
public class GatewayAppService : IDynamicApiController
{
    private readonly IHttpClientFactory _httpClientFactory;
    private readonly IConfiguration _configuration;

    public GatewayAppService(
        IHttpClientFactory httpClientFactory,
        IConfiguration configuration)
    {
        _httpClientFactory = httpClientFactory;
        _configuration = configuration;
    }

    /// <summary>
    /// 转发请求到目标服务
    /// </summary>
    [HttpGet("{serviceName}/{**path}")]
    public async Task<IActionResult> ForwardRequest(
        string serviceName, string path,
        [FromServices] HttpContext httpContext)
    {
        var serviceUrl = _configuration[$"Services:{serviceName}:BaseUrl"];
        if (string.IsNullOrEmpty(serviceUrl))
        {
            return new NotFoundObjectResult($"服务 {serviceName} 未配置");
        }

        var targetUrl = $"{serviceUrl}/{path}{httpContext.Request.QueryString}";
        var client = _httpClientFactory.CreateClient();

        // 复制请求头
        foreach (var header in httpContext.Request.Headers)
        {
            if (!header.Key.StartsWith("Host", StringComparison.OrdinalIgnoreCase))
            {
                client.DefaultRequestHeaders.TryAddWithoutValidation(header.Key, header.Value.ToArray());
            }
        }

        var response = await client.GetAsync(targetUrl);
        var content = await response.Content.ReadAsStringAsync();

        return new ContentResult
        {
            Content = content,
            ContentType = response.Content.Headers.ContentType?.ToString(),
            StatusCode = (int)response.StatusCode
        };
    }
}

十二、最佳实践

12.1 远程请求设计原则

原则	说明
使用 IHttpClientFactory	避免直接 new HttpClient
设置合理超时	根据业务场景设置超时时间
添加重试策略	网络不稳定场景添加重试
断路器模式	避免雪崩效应
请求日志	记录请求和响应便于排查
接口代理	使用 IHttpDispatchProxy 提升可维护性
配置外置	服务地址放配置文件
异常处理	统一处理远程请求异常

12.2 完整的远程请求服务示例

/// <summary>
/// 第三方支付服务代理
/// </summary>
[Client("PaymentService")]
public interface IPaymentApi : IHttpDispatchProxy
{
    /// <summary>
    /// 创建支付订单
    /// </summary>
    [Post("/api/payment/create")]
    Task<PaymentResult> CreatePaymentAsync([Body] CreatePaymentInput input);

    /// <summary>
    /// 查询支付状态
    /// </summary>
    [Get("/api/payment/{paymentId}/status")]
    Task<PaymentStatusResult> GetPaymentStatusAsync([RouteParam] string paymentId);

    /// <summary>
    /// 退款
    /// </summary>
    [Post("/api/payment/{paymentId}/refund")]
    Task<RefundResult> RefundAsync([RouteParam] string paymentId, [Body] RefundInput input);
}

/// <summary>
/// 支付服务封装
/// </summary>
public class PaymentService
{
    private readonly IPaymentApi _paymentApi;
    private readonly ILogger<PaymentService> _logger;

    public PaymentService(IPaymentApi paymentApi, ILogger<PaymentService> logger)
    {
        _paymentApi = paymentApi;
        _logger = logger;
    }

    /// <summary>
    /// 发起支付（带重试和异常处理）
    /// </summary>
    public async Task<PaymentResult> CreatePaymentWithRetry(CreatePaymentInput input)
    {
        const int maxRetries = 3;

        for (int i = 0; i <= maxRetries; i++)
        {
            try
            {
                var result = await _paymentApi.CreatePaymentAsync(input);
                _logger.LogInformation("支付订单创建成功：{PaymentId}", result.PaymentId);
                return result;
            }
            catch (Exception ex) when (i < maxRetries)
            {
                _logger.LogWarning(ex, "支付请求失败，第 {Retry} 次重试", i + 1);
                await Task.Delay(1000 * (i + 1));
            }
        }

        throw new Exception("支付服务暂时不可用，请稍后重试");
    }
}

通过 Furion 的远程请求增强功能，可以极大简化微服务间的 HTTP 通信代码，提升代码的可读性和可维护性。结合拦截器、重试策略和日志记录，可以构建出健壮可靠的分布式系统。

上一章: 第12章-定时任务 | 返回目录 | 下一章: 第14章-对象映射

此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。原文来自 — 版权归原作者所有。

推荐订阅源

博客园 - 我才是银古

第十三章：远程请求与HTTP客户端

一、HttpClient 基础

1.1 .NET HttpClient 概述

1.2 原生 HttpClient 的问题

1.3 IHttpClientFactory

二、Furion 远程请求增强

2.1 注册远程请求服务

2.2 基本使用方式

三、IHttpDispatchProxy 接口代理

3.1 声明式 HTTP 请求

3.2 使用接口代理

3.3 配置基础地址

四、RESTful 请求详解

4.1 GET 请求

4.2 POST 请求

4.3 PUT 请求

4.4 DELETE 请求

4.5 PATCH 请求

五、请求拦截器

5.1 请求拦截

5.2 全局请求拦截

六、响应拦截器

6.1 响应处理

6.2 统一响应处理

七、文件上传与下载

7.1 文件上传

7.2 文件下载

八、超时与重试

8.1 超时配置

8.2 重试策略

8.3 自定义重试逻辑

九、请求日志

9.1 日志中间件

9.2 注册日志处理器

十、微服务间通信

10.1 服务发现与请求

10.2 编排多个服务调用

十一、请求转发

11.1 网关模式转发

十二、最佳实践

12.1 远程请求设计原则

12.2 完整的远程请求服务示例