.NetCore简单封装基于IHttpClientFactory的HttpClient请求

IHttpClientFactory是什么？为什么出现了IHttpClientFactory

一、IHttpClientFactory是什么？

IHttpClientFactory是.netcore2.1才开始引入的，是HttpClient的工厂接口，它为我们提供了获取HttpClient的接口，它帮助我们维护HttpClient的生命周期。当我们需要HttpClient访问网络时，它会自动帮我们获取或者是创建HttpClient（存在空闲的HttpClient时，直接提供；当不存在可用的HttpClient时自动创建）。它相当于HttpClient池。

二、为什么出现IHttpClientFactory？

传统的HttpClient创建后，其占用了Socket资源并且其不会是及时的回收。我们每次new一个HttpClient时是一个全新的对象，所以在高并发下又是会导致socket资源耗尽（Unable to connect to the remote serverSystem.Net.Sockets.SocketException: Only one usage of each socket address (protocol/network address/port) is normally permitted.）。而如果采用单例或者静态的HttpClient，却达不到高效的使用网络请求，而且当访问不同的url时，单例或者静态的HttpClient往往会导致访问混乱而出现错误。

 

.NetCore简单封装基于IHttpClientFactory的HttpClient请求

 

public class HttpWebClient
    {

        private IHttpClientFactory _httpClientFactory;
        private readonly ILogger<HttpWebClient> _logger;
        public HttpWebClient(IHttpClientFactory httpClientFactory, ILogger<HttpWebClient> logger)
        {
            this._httpClientFactory = httpClientFactory;
            this._logger = logger;
        }

        /// <summary>
        /// Get
        /// </summary>
        /// <param name="url"></param>
        /// <param name="dicHeaders"></param>
        /// <param name="timeoutSecond"></param>
        /// <returns></returns>
        public async Task<T> GetAsync<T>(string url, Dictionary<string, string> dicHeaders, int timeoutSecond = 180)
        {
            try
            {
                var client = BuildHttpClient(dicHeaders, timeoutSecond);
                var response = await client.GetAsync(url);
                var responseContent = await response.Content.ReadAsStringAsync();
                if (response.IsSuccessStatusCode)
                {
                    return JsonUtil.Deserialize<T>(responseContent);
                }
                else
                {
                    throw new CustomerHttpException(response.StatusCode.ToString(), responseContent);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"HttpGet:{url} Error:{ex.ToString()}");
                throw new Exception($"HttpGet:{url} Error", ex);
            }
        }
        /// <summary>
        /// Post
        /// </summary>
        /// <param name="url"></param>
        /// <param name="requestBody"></param>
        /// <param name="dicHeaders"></param>
        /// <param name="timeoutSecond"></param>
        /// <returns></returns>
        public async Task<T> PostAsync<T>(string url, string requestBody, Dictionary<string, string> dicHeaders, int timeoutSecond = 180)
        {
            try
            {
                var client = BuildHttpClient(null, timeoutSecond);
                var requestContent = GenerateStringContent(requestBody, dicHeaders);
                var response = await client.PostAsync(url, requestContent);
                var responseContent = await response.Content.ReadAsStringAsync();
                if (response.IsSuccessStatusCode)
                {
                    var result = JsonUtil.Deserialize<T>(responseContent);
                    return result;
                }
                else
                {
                    throw new CustomerHttpException(response.StatusCode.ToString(), responseContent);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"HttpPost:{url},body:{requestBody} Error:{ex.ToString()}");
                throw new Exception($"HttpPost:{url} Error", ex);
            }
        }
        /// <summary>
        /// Put
        /// </summary>
        /// <param name="url"></param>
        /// <param name="requestBody"></param>
        /// <param name="dicHeaders"></param>
        /// <param name="timeoutSecond"></param>
        /// <returns></returns>
        public async Task<T> PutAsync<T>(string url, string requestBody, Dictionary<string, string> dicHeaders, int timeoutSecond = 180)
        {
            try
            {
                var client = BuildHttpClient(null, timeoutSecond);
                var requestContent = GenerateStringContent(requestBody, dicHeaders);
                var response = await client.PutAsync(url, requestContent);
                var responseContent = await response.Content.ReadAsStringAsync();
                if (response.IsSuccessStatusCode)
                {
                    var result = JsonUtil.Deserialize<T>(responseContent);
                    return result;
                }
                else
                {
                    throw new CustomerHttpException(response.StatusCode.ToString(), responseContent);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"HttpPut:{url},Body:{requestBody},  Error:{ex.ToString()}");
                throw new Exception($"HttpPut:{url} Error", ex);
            }
        }

        /// <summary>
        /// Patch
        /// </summary>
        /// <param name="url"></param>
        /// <param name="requestString"></param>
        /// <param name="dicHeaders"></param>
        /// <param name="timeoutSecond"></param>
        /// <returns></returns>
        public async Task<T> PatchAsync<T>(string url, string requestBody, Dictionary<string, string> dicHeaders, int timeoutSecond = 180)
        {
            try
            {
                var client = BuildHttpClient(null, timeoutSecond);
                var requestContent = GenerateStringContent(requestBody, dicHeaders);
                var response = await client.PatchAsync(url, requestContent);
                var responseContent = await response.Content.ReadAsStringAsync();
                if (response.IsSuccessStatusCode)
                {
                    var result = JsonUtil.Deserialize<T>(responseContent);
                    return result;
                }
                else
                {
                    throw new CustomerHttpException(response.StatusCode.ToString(), responseContent);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"HttpPatch:{url},body:{requestBody}, Error:{ex.ToString()}");
                throw new Exception($"HttpPatch:{url} Error", ex);
            }
        }
        /// <summary>
        /// Delete
        /// </summary>
        /// <param name="url"></param>
        /// <param name="dicHeaders"></param>
        /// <param name="timeoutSecond"></param>
        /// <returns></returns>
        public async Task<T> DeleteAsync<T>(string url, Dictionary<string, string> dicHeaders, int timeoutSecond = 180)
        {
            try
            {
                var client = BuildHttpClient(dicHeaders, timeoutSecond);
                var response = await client.DeleteAsync(url);
                var responseContent = await response.Content.ReadAsStringAsync();
                if (response.IsSuccessStatusCode)
                {
                    var result = JsonUtil.Deserialize<T>(responseContent);
                    return result;
                }
                else
                {
                    throw new CustomerHttpException(response.StatusCode.ToString(), responseContent);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"HttpDelete:{url}, Error:{ex.ToString()}");
                throw new Exception($"HttpDelete:{url} Error", ex);
            }
        }
        /// <summary>
        /// common request
        /// </summary>
        /// <param name="url"></param>
        /// <param name="method"></param>
        /// <param name="requestBody"></param>
        /// <param name="dicHeaders"></param>
        /// <param name="timeoutSecond"></param>
        /// <returns></returns>
        public async Task<T> ExecuteAsync<T>(string url, HttpMethod method, string requestBody, Dictionary<string, string> dicHeaders, int timeoutSecond = 180)
        {
            try
            {
                var client = BuildHttpClient(null, timeoutSecond);
                var request = GenerateHttpRequestMessage(url, requestBody, method, dicHeaders);
                var response = await client.SendAsync(request);
                var responseContent = await response.Content.ReadAsStringAsync();
                if (response.IsSuccessStatusCode)
                {
                    var type = typeof(T);
                    if (type.IsPrimitive || type == typeof(string))
                    {
                        return (T)Convert.ChangeType(responseContent, typeof(T));
                    }
                    else
                    {
                        return JsonUtil.Deserialize<T>(responseContent);
                    }
                }
                else
                {
                    throw new CustomerHttpException(response.StatusCode.ToString(), responseContent);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"{method.ToString()}:{url},body:{requestBody}, Error:{ex.ToString()}");
                throw new Exception($"{method.ToString()}:{url} Error", ex);
            }

        }
        /// <summary>
        /// Build HttpClient
        /// </summary>
        /// <param name="timeoutSecond"></param>
        /// <returns></returns>
        private HttpClient BuildHttpClient(Dictionary<string, string> dicDefaultHeaders, int? timeoutSecond)
        {
            var httpClient = _httpClientFactory.CreateClient();
            httpClient.DefaultRequestHeaders.Clear();   //in order that the client is not affected by the last request,it need to clear DefaultRequestHeaders
            httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            if (dicDefaultHeaders != null)
            {
                foreach (var headerItem in dicDefaultHeaders)
                {
                    if (!httpClient.DefaultRequestHeaders.Contains(headerItem.Key))
                    {
                        httpClient.DefaultRequestHeaders.Add(headerItem.Key, headerItem.Value);
                    }
                }
            }
            if (timeoutSecond != (int?)null)
            {
                httpClient.Timeout = TimeSpan.FromSeconds(timeoutSecond.Value);
            }
            return httpClient;
        }

        /// <summary>
        /// Generate HttpRequestMessage
        /// </summary>
        /// <param name="url"></param>
        /// <param name="requestBody"></param>
        /// <param name="method"></param>
        /// <param name="dicHeaders"></param>
        /// <returns></returns>
        private HttpRequestMessage GenerateHttpRequestMessage(string url, string requestBody, HttpMethod method, Dictionary<string, string> dicHeaders)
        {
            var request = new HttpRequestMessage(method, url);
            if (!string.IsNullOrEmpty(requestBody))
            {
                request.Content = new StringContent(requestBody);
            }
            if (dicHeaders != null)
            {
                foreach (var header in dicHeaders)
                {
                    request.Headers.Add(header.Key, header.Value);
                }
            }
            return request;
        }
        /// <summary>
        ///  Generate StringContent
        /// </summary>
        /// <param name="requestBody"></param>
        /// <param name="dicHeaders"></param>
        /// <returns></returns>
        private StringContent GenerateStringContent(string requestBody, Dictionary<string, string> dicHeaders)
        {
            var content = new StringContent(requestBody);
            if (dicHeaders != null)
            {
                foreach (var headerItem in dicHeaders)
                {
                    content.Headers.Add(headerItem.Key, headerItem.Value);
                }
            }
            return content;
        }
    }

 

 

CustomerHttpException类的简单定义

    public class CustomerHttpException : Exception
    {
        public string ErrorCode { get; set; }
        public string ErrorMessage { get; set; }
        public CustomerHttpException() : base()
        { }
        public CustomerHttpException(string errorCode, string errorMessage) : base()
        {
            this.ErrorCode = errorCode;
            this.ErrorMessage = ErrorMessage;
        }
    }

 

以上是简单的Http请求封装。其中一些值得注意的点

1、创建的HttpClient是由HttpClientFactory统一管理的，所以当指定了DefaultRequestHeaders时，下次再次从HttpClientFactory中获取时可能带着上次的Header信息。所以需要对其进行Clear。

2、封装了统一的调用接口ExecuteAsync，建议采用该接口进行http请求，此时就不会去配置DefaultRequestHeaders，而是将Header信息配置在请求信息中。

3、自定义了CustomerHttpException，主要是为了支持ResultFul风格的api。通过外层捕获CustomerHttpException,从而解析出具体的错误信息。