.net core IHttpClientFactory

在 ASP.NET Core 中使用 IHttpClientFactory 发出 HTTP 请求 | Microsoft Learn

Polly 

Nuget 下载  Microsoft.Extensions.Http.Polly

AddHttpMessageHandler<HttpBaiDuHandle>() 出站处理

HttpServer 类型化客户端  

var timeout = Policy.TimeoutAsync<HttpResponseMessage>(TimeSpan.FromSeconds(10));
var longTimeoutPolicy = Policy.TimeoutAsync<HttpResponseMessage>(TimeSpan.FromSeconds(30));

//类型化客户端  HttpServer 为瞬时生命周期

builder.Services.AddHttpClient<HttpServer>()  .AddHttpMessageHandler<HttpBaiDuHandle>()  .AddPolicyHandler(httpRequestMessage => httpRequestMessage.Method == HttpMethod.Post ? timeout : longTimeoutPolicy); 
//命名客户端

builder.Services.AddHttpClient("test")
    .AddHttpMessageHandler<HttpBaiDuHandle>()
    .AddTransientHttpErrorPolicy(
    policyBuilder => policyBuilder.WaitAndRetryAsync(3, retryNumber => TimeSpan.FromMilliseconds(600)));

　　

命名客户端

    [Route("api/[controller]")]
    [ApiController]
    public class TestHttpNoServerController : ControllerBase
    {
        private readonly IHttpClientFactory _httpClientFactory;
        private readonly HttpClient _httpClient;
        public TestHttpNoServerController(IHttpClientFactory httpClientFactory)
        {
            _httpClientFactory = httpClientFactory;
            _httpClient = _httpClientFactory.CreateClient("test");
            _httpClient.BaseAddress = new Uri("http://localhost:5255");
        }
        [HttpGet]
        public async Task<IActionResult> GetName(string name)
        {
            HttpResponseMessage responseMessage = await _httpClient.GetAsync($"/api/TestHttp?name={name}");
            HttpContent httpContent = responseMessage.Content;
            string value = await httpContent.ReadAsStringAsync();
            return Ok(value);
        }
    }

 

类型化客户端

    public class HttpServer
    {
        private readonly HttpClient _httpClient;
        public HttpServer(HttpClient httpClient)
        {
            _httpClient = httpClient;
            _httpClient.BaseAddress = new Uri("http://localhost:5255");
        }

        public async Task<string> GetNameAsync(string name)
        {
            HttpResponseMessage responseMessage = await _httpClient.GetAsync($"/api/TestHttp?name={name}");
            HttpContent httpContent = responseMessage.Content;
            string value = await httpContent.ReadAsStringAsync();
            return value;
        }
    }

　　

出站请求中间件 必须实现接口 DelegatingHandler 使用 异步方法 SendAsync

注意 注入 需要 单独 注入该实现  builder.Services.AddScoped<HttpBaiDuHandle>();

使用的时候 

builder.Services.AddHttpClient<HttpServer>().AddHttpMessageHandler<HttpBaiDuHandle>()

 

    public class HttpBaiDuHandle: DelegatingHandler
    {
        private readonly ILogger<HttpBaiDuHandle> _logger;

        public HttpBaiDuHandle(ILogger<HttpBaiDuHandle> logger)
        {
            _logger = logger;
        }
        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            _logger.LogInformation($"测试的HttpBaiDuHandle1111");
            request.Headers.Add("test", "mytest");
            return base.SendAsync(request, cancellationToken);
        }
    }

　　

　　

 

 

调用 AddRefitClient 以生成接口的动态实现

Nuget  Refit.HttpClientFactory

builder.Services.AddRefitClient<IHttpUser>().ConfigureHttpClient(httpClient =>
{
httpClient.BaseAddress = new Uri("http://localhost:5255/api");
});

　　

需要 写接口  特性Get Post 

    public interface IHttpUser
    {
        [Get("/TestHttp/GetUserName/{name}")]
        Task<string> GetNameAsync(string name);


        [Post("/TestHttp")]
        Task<User> CreateUserAsync(User user);
    }

　　

namespace CBBBank.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class TestRefitController : ControllerBase
    {
        private readonly IHttpUser _httpUser;

        public TestRefitController(IHttpUser httpUser)
        {
            _httpUser = httpUser;
        }

        [HttpGet]
        public async Task<IActionResult> Get(string name)
        {
            string value = await _httpUser.GetNameAsync(name);
            return Ok(value);
        }


        [HttpPost]
        public async Task<IActionResult> User(User user)
        {
            User created = await _httpUser.CreateUserAsync(user);
            return Ok(created);
        }
    }
}

　　

 

 

 

 

 

namespace HttpClientTest.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class HttpClientTestController : ControllerBase
    {
        private readonly IHttpClientFactory _httpClientFactory;

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

        [HttpGet]
        public async Task<IActionResult> GetAsync([FromQuery] string name, [FromQuery] int age)
        {
            HttpClient httpClient = _httpClientFactory.CreateClient();
            httpClient.BaseAddress = new Uri("http://localhost:5047");
            HttpResponseMessage responseMessage = await httpClient.GetAsync($"/api/Reveice?name={name}&age={age}");
            string reuslt = await responseMessage.Content.ReadAsStringAsync();
            return Ok(reuslt);
        }

        [HttpPost("PostBody")]
        public async Task<IActionResult> PostBodyAsync([FromBody] User user)
        {
            HttpClient httpClient = _httpClientFactory.CreateClient();
            httpClient.BaseAddress = new Uri("http://localhost:5047");
            string userJson = JsonConvert.SerializeObject(user);
            HttpContent stringContent = new StringContent(userJson);
            stringContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
            HttpResponseMessage responseMessage = await httpClient.PostAsync("/api/Reveice/PostBody", stringContent);
            User reusltUser = await responseMessage.Content.ReadFromJsonAsync<User>();
            return Ok(reusltUser);
        }

        [HttpPost("PostForm")]
        public async Task<IActionResult> PostFormAsync([FromForm] string name, [FromForm] int age)
        {
            HttpClient httpClient = _httpClientFactory.CreateClient();
            httpClient.BaseAddress = new Uri("http://localhost:5047");

            Dictionary<string, string> keyValues = new Dictionary<string, string>();
            keyValues["Id"] = "1";
            keyValues["name"] = name;
            keyValues["age"] = age.ToString();
            FormUrlEncodedContent content = new FormUrlEncodedContent(keyValues);
            //content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("multipart/form-data");
            HttpResponseMessage responseMessage = await httpClient.PostAsync("/api/Reveice/PostForm", content);
            User reusltUser = await responseMessage.Content.ReadFromJsonAsync<User>();
            return Ok(reusltUser);
        }

        [HttpPost("PostFile")]
        public async Task<IActionResult> PostFileAsync(IFormFile formFile)
        {
            //send 方式
            //HttpClient httpClient = _httpClientFactory.CreateClient();
            //httpClient.BaseAddress = new Uri("http://localhost:5047");
            //var form = new MultipartFormDataContent();
            //Stream stream = formFile.OpenReadStream();
            //stream.Position = 0;
            //byte[] bytes = new byte[stream.Length];
            //stream.Read(bytes, 0, bytes.Length);        
            //var byteArrayContent = new ByteArrayContent(bytes);
            //form.Add(byteArrayContent, formFile.Name, formFile.FileName);
            //using var request = new HttpRequestMessage(HttpMethod.Post, $"/api/Reveice/PostFile")
            //{
            //    Content = form
            //};
            //HttpResponseMessage responseMessage = await httpClient.SendAsync(request);

            Stream stream = formFile.OpenReadStream();
            stream.Position = 0;
            byte[] bytes = new byte[stream.Length];
            stream.Read(bytes, 0, bytes.Length);
            var multiFormData = new MultipartFormDataContent();
            var byteArrayContent = new ByteArrayContent(bytes);
            multiFormData.Add(byteArrayContent, formFile.Name, formFile.FileName);
            HttpClient httpClient = _httpClientFactory.CreateClient();
            httpClient.BaseAddress = new Uri("http://localhost:5047");
            HttpResponseMessage responseMessage = await httpClient.PostAsync("/api/Reveice/PostFile", multiFormData);
            return Ok(responseMessage.StatusCode);
        }



        [HttpPatch]
        public async Task<IActionResult> PatchAsync(JsonPatchDocument<User> patchDocument)
        {

            HttpClient httpClient = _httpClientFactory.CreateClient();
            httpClient.BaseAddress = new Uri("http://localhost:5047");
            //JsonPatchDocument<User> patchDocument1 = new JsonPatchDocument<User>();
            //patchDocument1.Add<User>(item => item, new User { Name ="你好" });
            //string userJson = JsonConvert.SerializeObject(patchDocument1);


            string userJson = JsonConvert.SerializeObject(patchDocument);
            HttpContent stringContent = new StringContent(userJson);
            stringContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json-patch+json");
            HttpResponseMessage responseMessage = await httpClient.PatchAsync("/api/Reveice", stringContent);
            User reusltUser = await responseMessage.Content.ReadFromJsonAsync<User>();
            return Ok(reusltUser);
        }


        [HttpDelete("{Id}")]
        public async Task<IActionResult> DeleteAsync([FromRoute] int Id)
        {
            HttpClient httpClient = _httpClientFactory.CreateClient();
            httpClient.BaseAddress = new Uri("http://localhost:5047");
            HttpResponseMessage responseMessage = await httpClient.DeleteAsync($"/api/Reveice/{Id}");
            List<User> reusltUser = await responseMessage.Content.ReadFromJsonAsync<List<User>>();
            return Ok(reusltUser);
        }
    }
}