.NET Core 3.0之深入源码理解HttpClientFactory(二)

 

写在前面

上一篇文章讨论了通过在ConfigureServices中调用services.AddHttpClient()方法，并基于此进一步探讨了DefaultHttpClientFactory是如何创建HttpClient实例和HttpMessageHandler实例的，并了解了DefaultHttpClientFactory内部维护者一个定时器和两个HttpMessageHandler对象集合，以定期清理无效的 HttpMessageHandler对象，详细的内容可以点击链接跳转，接下来我会接着前一篇文章继续展开相关讨论。

详细介绍

HttpMessageHandlerBuilder

该类是一个抽象类，起到生成器的作用，可用于用于配置HttpMessageHandler实例。HttpMessageHandlerBuilder会在ServiceCollection中被注册为Transient服务。调用方要为每个要创建的HttpMessageHandler实例检索一个新实例。实现者应该确保每个实例都只使用一次。

HttpMessageHandlerBuilder里面有三个比较重要的属性：

/// <summary>
/// 主HttpMessageHandler实例
/// </summary>
public abstract HttpMessageHandler PrimaryHandler { get; set; }

/// <summary>
/// 这个是一个附加实例，用于配置HttpClient管道
/// </summary>
public abstract IList<DelegatingHandler> AdditionalHandlers { get; }

/// <summary>
/// 可用于从依赖项注入容器解析服务的IServiceProvider
/// </summary>
public virtual IServiceProvider Services { get; }

这三个属性意味着每个HttpMessageHandlerBuilder都需要维护自身的HttpMessageHandler实例和管道。

其内部还有一个抽象方法：

public abstract HttpMessageHandler Build();

当然，内部最核心的方法就是管道的创建过程了，需要传入主派生类自身的HttpMessageHandler和管道列表对象。它会将primaryHandler实例付给管道列表的第一个Item的InnerHandler，其他对象会依此后移，这也为我们自定义HttpMessageHandler(各种中间件)提供了无限可能。

相关实现如下：

var next = primaryHandler;
for (var i = additionalHandlersList.Count - 1; i >= 0; i--)
{
    var handler = additionalHandlersList[i];
    if (handler == null)
    {
        var message = Resources.FormatHttpMessageHandlerBuilder_AdditionalHandlerIsNull(nameof(additionalHandlers));
        throw new InvalidOperationException(message);
    }

    if (handler.InnerHandler != null)
    {
        var message = Resources.FormatHttpMessageHandlerBuilder_AdditionHandlerIsInvalid(
            nameof(DelegatingHandler.InnerHandler),
            nameof(DelegatingHandler),
            nameof(HttpMessageHandlerBuilder),
            Environment.NewLine,
            handler);
        throw new InvalidOperationException(message);
    }

    handler.InnerHandler = next;
    next = handler;
}

接下来我们看一下HttpMessageHandlerBuilder一个派生类DefaultHttpMessageHandlerBuilder，其构造函数会传入IServiceProvider实例，我们的自定义操作也可以参照这个类。

关于Build方法的实现如下，比较简单主要是调用了CreateHandlerPipeline方法：

public override HttpMessageHandler Build()
{
    if (PrimaryHandler == null)
    {
        var message = Resources.FormatHttpMessageHandlerBuilder_PrimaryHandlerIsNull(nameof(PrimaryHandler));
        throw new InvalidOperationException(message);
    }

    return CreateHandlerPipeline(PrimaryHandler, AdditionalHandlers);
}

ITypedHttpClientFactory

这是一个抽象工厂，该组件可以使用给定逻辑名称的自定义配置创建类型化HttpClient实例，与命名方式创建HttpClient具有相同的的功能。类型化客户端可能用于单个后端终结点，并封装此终结点的所有处理逻辑。 另一个优势是它们使用 DI 被注入到应用中需要的位置，下一篇文章会再次讨论相关功能。

我们首先看一下调用方式：

public static IHttpClientBuilder AddHttpClient<TClient>(this IServiceCollection services)
    where TClient : class
{
    if (services == null)
    {
        throw new ArgumentNullException(nameof(services));
    }

    AddHttpClient(services);

    var name = TypeNameHelper.GetTypeDisplayName(typeof(TClient), fullName: false);
    var builder = new DefaultHttpClientBuilder(services, name);
    builder.AddTypedClient<TClient>();
    return builder;
}

可以看出此处的调用与普通的HttpClient没有什么太大区别，只是增加了一个泛型标记，而且该类型没有特殊的要求，只要是个类就行。其内部依然调用AddHttpClient(services），但它调用了另一个扩展方法，如下所示：

public static IHttpClientBuilder AddTypedClient<TClient>(this IHttpClientBuilder builder)
    where TClient : class
{
    if (builder == null)
    {
        throw new ArgumentNullException(nameof(builder));
    }

    builder.Services.AddTransient<TClient>(s =>
    {
        var httpClientFactory = s.GetRequiredService<IHttpClientFactory>();
        var httpClient = httpClientFactory.CreateClient(builder.Name);

        var typedClientFactory = s.GetRequiredService<ITypedHttpClientFactory<TClient>>();
        return typedClientFactory.CreateClient(httpClient);
    });

    return builder;
}

可以看到最终的代码调用了ITypedHttpClientFactory的CreateClient方法，Microsoft.Extensions.Http包中有一个默认的ITypedHttpClientFactory派生类，DefaultTypedHttpClientFactory<TClient>，该类提供了了构造函数用于接收IServiceProvider实例，以及一个内部类声明的缓存对象，该对象十分重要，它被注册为singleton类型，已达到全局使用，并可以充当相关实例激活时的对象池。它也允许它的外部类注册为transient，这样它就不会在应用根服务提供程序上被关掉了。

相关代码如下：

public TClient CreateClient(HttpClient httpClient)
{
    if (httpClient == null)
    {
        throw new ArgumentNullException(nameof(httpClient));
    }

    return (TClient)_cache.Activator(_services, new object[] { httpClient });
}

内部缓存对象：

public class Cache
{
    private readonly static Func<ObjectFactory> _createActivator = () => ActivatorUtilities.CreateFactory(typeof(TClient), new Type[] { typeof(HttpClient), });

    private ObjectFactory _activator;
    private bool _initialized;
    private object _lock;

    public ObjectFactory Activator => LazyInitializer.EnsureInitialized(
        ref _activator,
        ref _initialized,
        ref _lock,
        _createActivator);
}

最后我们看一下源码中提供的范例：

class ExampleClient
{
    private readonly HttpClient _httpClient;
    private readonly ILogger _logger;
    // typed clients can use constructor injection to access additional services
    public ExampleClient(HttpClient httpClient, ILogger<ExampleClient> logger)
    {
        _httpClient = httpClient;
        _logger = logger;
    }
    // typed clients can expose the HttpClient for application code to call directly
    public HttpClient HttpClient => _httpClient;
    // typed clients can also define methods that abstract usage of the HttpClient
    public async Task SendHelloRequest()
    {
        var response = await _httpClient.GetAsync("/helloworld");
        response.EnsureSuccessStatusCode();
    }
}
//This sample shows how to consume a typed client from an ASP.NET Core middleware.
public void Configure(IApplicationBuilder app, ExampleClient exampleClient)
{
    app.Run(async (context) =>
    {
        var response = await _exampleClient.GetAsync("/helloworld");
        await context.Response.WriteAsync("Remote server said: ");
        await response.Content.CopyToAsync(context.Response.Body);
    });
}
//This sample shows how to consume a typed client from an ASP.NET Core MVC Controller.
public class HomeController : ControllerBase(IApplicationBuilder app, ExampleClient exampleClient)
{
    private readonly ExampleClient _exampleClient;
    public HomeController(ExampleClient exampleClient)
    {
        _exampleClient = exampleClient;
    }
    public async Task<IActionResult> Index()
    {
        var response = await _exampleClient.GetAsync("/helloworld");
        var text = await response.Content.ReadAsStringAsync();
        return Content("Remote server said: " + text, "text/plain");
    };
}