如何深入理解并高效运用.NETCore中的HttpClientFactory类？

本文共计1883个文字，预计阅读时间需要8分钟。

一、HttpClient使用+在Java中发送HTTP请求

1. 添加依赖

首先，在项目中添加HttpClient的依赖。如果是Maven项目，可以在pom.xml文件中添加以下依赖：

xml org.apache.httpcomponents httpclient 4.5.13

2. 创建HttpClient对象

接下来，创建一个HttpClient对象。这可以通过以下代码实现：

javaCloseableHttpClient httpClient=HttpClients.createDefault();

3. 创建HttpRequest对象

根据要发送的HTTP请求类型（GET、POST等），创建相应的HttpRequest对象。以下是一个创建GET请求对象的示例：

javaHttpGet httpGet=new HttpGet(http://www.example.com);

4. 执行请求

使用HttpClient对象执行HttpRequest对象，并获取响应。以下是一个示例：

javaCloseableHttpResponse response=httpClient.execute(httpGet);

5. 获取响应内容

最后，从响应对象中获取内容。以下是一个示例：

javaHttpEntity entity=response.getEntity();if (entity !=null) { String result=EntityUtils.toString(entity); System.out.println(result);}

6. 关闭连接

最后，关闭HttpClient对象和响应对象，以释放资源。以下是一个示例：

javaresponse.close();httpClient.close();

这样，你就使用HttpClient在Java中发送HTTP请求了。

一、HttpClient使用

在C#中，如果我们需要向某特定的URL地址发送Http请求的时候，通常会用到HttpClient类。会将HttpClient包裹在using内部进行声明和初始化，如下面的代码：

using (var www.baidu.com"); Console.WriteLine($"{i}:{result.StatusCode}"); } } } } }

运行项目输出结果后，通过netstate查看下TCP连接情况，会发现连接依然存在，状态为“TIME_WAIT”（继续等待看是否还有延迟的包会传输过来）。

这里就会出现一个坑：在高并发的情况下，连接来不及释放，socket连接被耗尽，耗尽之后就会出现错误。就是会出现“各种套接字问题”。

那么如何解决这个问题呢？比较好的解决方法是延长HttpClient对象的使用寿命，实现HttpClient对象的复用，比如对其建一个静态的对象：

private static HttpClient Client = new HttpClient();

我们使用这种方式优化上面的代码

using System; using System.Net.Http; namespace HttpClientDemo { class Program { private static readonly HttpClient _client = new HttpClient(); static void Main(string[] args) { HttpAsync(); Console.WriteLine("Hello World"); Console.ReadKey(); } public static async void HttpAsync() { for (int i = 0; i < 10; i++) { var result = await _client.GetAsync("www.baidu.com"); Console.WriteLine($"{i}:{result.StatusCode}"); } } } }

这样调整HttpClient的引用后，虽然可以解决一些问题，但是仍然存在一些问题：

• 因为是复用的HttpClient，那么一些公共的设置就没办法灵活的调整，如请求头的自定义。
• 因为HttpClient请求每个url时，会缓存url对应的主机ip，从而会导致DNS更新失效。

为了解决这些问题，在.NET Core 2.1中引入了新的HttpClientFactory类。

二、HttpClientFactory使用

微软在.NET Core 2.1中新引入了HttpClientFactory类，具有如下的优势：

• HttpClientFactory很高效，可以最大程度上节省系统的sock而。
• Factory，顾名思义HttpClientfactory就是HttpClient的工厂，内部已经帮我们处理好了对HttpClient的管理，不需要我们人工进行对象释放，同时，支持自定义请求头、支持DNS更新等。

我们用一个ASP.NET Core的程序作为示例，它的用法非常简单，首先是对其进行IOC注册：

public void ConfigureServices(IServiceCollection services) { // 注入HttpClient services.AddHttpClient("client_1", config => //这里指定的name=client_1，可以方便我们后期服用该实例 { config.BaseAddress = new Uri("www.baidu.com"); config.DefaultRequestHeaders.Add("header_1", "header_1"); }); services.AddHttpClient("client_2", config => { config.BaseAddress = new Uri("www.qq.com/"); config.DefaultRequestHeaders.Add("header_2", "header_2"); }); services.AddHttpClient(); services.AddControllers(); }

然后在控制器里面通过IHttpClientFactory创建一个HttpClient对象，之后的操作跟以前一样，但不需要担心其内部资源的释放：

using System.Net.Http; using System.Threading.Tasks; using Microsoft.AspNetCore.Mvc; namespace HttpClientFactoryDemo.Controllers { [Route("api/[controller]")] [ApiController] public class DemoController : ControllerBase { IHttpClientFactory _www.baidu.com"); return result2.StatusCode.ToString(); } } }

程序运行结果：

AddHttpClient的源码：

public static IServiceCollection AddHttpClient(this IServiceCollection services) { if (services == null) { throw new ArgumentNullException(nameof(services)); } services.AddLogging(); services.AddOptions(); // // Core abstractions // services.TryAddTransient<HttpMessageHandlerBuilder, DefaultHttpMessageHandlerBuilder>(); services.TryAddSingleton<IHttpClientFactory, DefaultHttpClientFactory>(); // // Typed Clients // services.TryAdd(ServiceDescriptor.Singleton(typeof(ITypedHttpClientFactory<>), typeof(DefaultTypedHttpClientFactory<>))); // // Misc infrastructure // services.TryAddEnumerable(ServiceDescriptor.Singleton<IHttpMessageHandlerBuilderFilter, LoggingHttpMessageHandlerBuilderFilter>()); return services; }

看下面这句代码：

services.TryAddSingleton<IHttpClientFactory, DefaultHttpClientFactory>();

这里添加依赖注入的时候为IHttpClientFactory接口绑定了DefaultHttpClientFactory类。

我们在来看IHttpClientFactory接口中关键的CreateClient方法：

public HttpClient CreateClient(string name) { if (name == null) { throw new ArgumentNullException(nameof(name)); } var entry = _activeHandlers.GetOrAdd(name, _entryFactory).Value; var client = new HttpClient(entry.Handler, disposeHandler: false); StartHandlerEntryTimer(entry); var options = _optionsMonitor.Get(name); for (var i = 0; i < options.HttpClientActions.Count; i++) { options.HttpClientActions[i](client); } return client; }

从代码中我们可以看出：HttpClient的创建不在是简单的new HttpClient()，而是传入了两个参数：HttpMessageHandler handler与bool disposeHandler。

disposeHandler参数为false时表示要重用内部的handler对象。handler参数则从上一句的代码中可以看出是以name为键值从一字典中取出，又因为DefaultHttpClientFactory类是通过TryAddSingleton方法注册的，也就意味着其为单例，那么这个内部字典便是唯一的，每个键值对应的ActiveHandlerTrackingEntry对象也是唯一，该对象内部中包含着handler。

下一句代码StartHandlerEntryTimer(entry);开启了ActiveHandlerTrackingEntry对象的过期计时处理。默认过期时间是2分钟。

internal void ExpiryTimer_Tick(object state) { var active = (ActiveHandlerTrackingEntry)state; // The timer callback should be the only one removing from the active collection. If we can't find // our entry in the collection, then this is a bug. var removed = _activeHandlers.TryRemove(active.Name, out var found); Debug.Assert(removed, "Entry not found. We should always be able to remove the entry"); Debug.Assert(object.ReferenceEquals(active, found.Value), "Different entry found. The entry should not have been replaced"); // At this point the handler is no longer 'active' and will not be handed out to any new clients. // However we haven't dropped our strong reference to the handler, so we can't yet determine if // there are still any other outstanding references (we know there is at least one). // // We use a different state object to track expired handlers. This allows any other thread that acquired // the 'active' entry to use it without safety problems. var expired = new ExpiredHandlerTrackingEntry(active); _expiredHandlers.Enqueue(expired); Log.HandlerExpired(_logger, active.Name, active.Lifetime); StartCleanupTimer(); }

先是将ActiveHandlerTrackingEntry对象传入新的ExpiredHandlerTrackingEntry对象。

public ExpiredHandlerTrackingEntry(ActiveHandlerTrackingEntry other) { Name = other.Name; _livenessTracker = new WeakReference(other.Handler); InnerHandler = other.Handler.InnerHandler; }

在其构造方法内部，handler对象通过弱引用方式关联着，不会影响其被GC释放。

然后新建的ExpiredHandlerTrackingEntry对象被放入专用的队列。

最后开始清理工作，定时器的时间间隔设定为每10秒一次。

internal void CleanupTimer_Tick(object state) { // Stop any pending timers, we'll restart the timer if there's anything left to process after cleanup. // // With the scheme we're using it's possible we could end up with some redundant cleanup operations. // This is expected and fine. // // An alternative would be to take a lock during the whole cleanup process. This isn't ideal because it // would result in threads executing ExpiryTimer_Tick as they would need to block on cleanup to figure out // whether we need to start the timer. StopCleanupTimer(); try { if (!Monitor.TryEnter(_cleanupActiveLock)) { // We don't want to run a concurrent cleanup cycle. This can happen if the cleanup cycle takes // a long time for some reason. Since we're running user code inside Dispose, it's definitely // possible. // // If we end up in that position, just make sure the timer gets started again. It should be cheap // to run a 'no-op' cleanup. StartCleanupTimer(); return; } var initialCount = _expiredHandlers.Count; Log.CleanupCycleStart(_logger, initialCount); var stopwatch = ValueStopwatch.StartNew(); var disposedCount = 0; for (var i = 0; i < initialCount; i++) { // Since we're the only one removing from _expired, TryDequeue must always succeed. _expiredHandlers.TryDequeue(out var entry); Debug.Assert(entry != null, "Entry was null, we should always get an entry back from TryDequeue"); if (entry.CanDispose) { try { entry.InnerHandler.Dispose(); disposedCount++; } catch (Exception ex) { Log.CleanupItemFailed(_logger, entry.Name, ex); } } else { // If the entry is still live, put it back in the queue so we can process it // during the next cleanup cycle. _expiredHandlers.Enqueue(entry); } } Log.CleanupCycleEnd(_logger, stopwatch.GetElapsedTime(), disposedCount, _expiredHandlers.Count); } finally { Monitor.Exit(_cleanupActiveLock); } // We didn't totally empty the cleanup queue, try again later. if (_expiredHandlers.Count > 0) { StartCleanupTimer(); } }

上述方法核心是判断是否handler对象已经被GC，如果是的话，则释放其内部资源，即网络连接。

回到最初创建HttpClient的代码，会发现并没有传入任何name参数值。这是得益于HttpClientFactoryExtensions类的扩展方法。

public static HttpClient CreateClient(this IHttpClientFactory factory) { if (factory == null) { throw new ArgumentNullException(nameof(factory)); } return factory.CreateClient(Options.DefaultName); }

Options.DefaultName的值为string.Empty。

到此这篇关于.NET Core中的HttpClientFactory类用法的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持自由互联。