.net core请求外部api接口

文章结尾附完整封装方法

1、打开net core项目中的Startup.cs文件，找到ConfigureServices方法，添加HttpClient

 services.AddHttpClient();//注入httpclient  用于调用外部api

2.控制器中注入IHttpClientFactory

using System.Net.Http;



private   IHttpClientFactory _httpClient;
        public WeChatController( IHttpClientFactory httpClient)
        { 
            this._httpClient = httpClient;

        }

3.调用get方式api

 httpClient注入的方式使用

 /// <summary>
        /// 获取微信ID
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async Task<dynamic> GetWechatID(string js_code) {

            try
            { 
                    var url = $"https://api.weixin.qq.com/sns/jscode2session?appid=123&secret=123&js_code={js_code}&grant_type=authorization_code";
                //使用注入的httpclientfactory获取client
                //using (HttpClient client = new HttpClient())如果不使用注入client的方式可以直接new client对象
                var client = _httpClient.CreateClient();
                client.BaseAddress = new Uri(url);
                //设置请求体中的内容，并以post的方式请求
                var response = await client.GetAsync(url);
                //if (response.StatusCode == HttpStatusCode.OK)   可以获取调用服务器是否正常   200   400   500 状态码
                //获取请求到数据，并转化为字符串
                //var result = response.Content.ReadAsStringAsync().Result; 
                var result = response.Content.ReadAsStringAsync(); 
                return Ok(result.Result);
            }
            catch (Exception e)
            { 
                return Ok( e.Message );
            }
        }

非注入方式使用httpClient

/// <summary>
        /// Get请求
        /// </summary>
        /// <param name="url"></param>
        /// <param name="token"></param>
        /// <param name="httpClient"></param>
        /// <returns></returns>
        public static async Task<T验证授权返回> DoGetRequestAsync(string url, string token)
        {
            try
            {
                using (HttpClient client = new HttpClient())
                { 
                    client.BaseAddress = new Uri(url);
                    if (!string.IsNullOrEmpty(token)) client.DefaultRequestHeaders.Add("Authorization", token);

                    //设置请求体中的内容，并以gost的方式请求
                    var response = await client.GetAsync(url);
                    //获取请求到数据，并转化为字符串
                    var result = response.Content.ReadAsStringAsync().Result;
                    if (response.StatusCode == HttpStatusCode.OK)
                    {
                        return new T验证授权返回{ ok = true, msg = "响应成功", data = result };
                    }
                    return new T验证授权返回 { ok = false, msg = "请求异常", data = result };
                }
            }
            catch (Exception e)
            {
                return new T验证授权返回 { ok = false, msg = e.Message, data = null };
            }
        }

4.调用post方式api     

post请求内容类型(ContentType)  常见的就几种

application/json     application/x-www-form-urlencoded    text/xml

application/json类型

/// <summary>
    /// post请求
    /// </summary>
    /// <param name="Url"></param>
    /// <param name="message"></param>
    /// <returns></returns>
    public static async Task<dynamic> DoPost<dynamic>(string Url, object message) 
    { 
        string jsonContent = JsonConvert.SerializeObject(message);//message为要提交的数据 例new {name="张三",sex="男"}
        string responseBody = string.Empty;
        using (HttpClient httpClient = new HttpClient())
        {
            var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");//请求参数   请求消息内容
            httpClient.DefaultRequestHeaders.Add("Method", "Post");
            string authorization = $"{userName}:{password}";//basic认证方式   用户名:密码 然后base64加密.  如果是其它认证方式 请修改    如果接口未加密省略此行
            var authorizationBased64 = "Basic " + Convert.ToBase64String(newASCIIEncoding().GetBytes(authorization));//如果接口未加密省略此行
            httpClient.DefaultRequestHeaders.Add("Authorization", authorizationBased64); //basic认证basc认证     如果接口未加密省略此行
            HttpResponseMessage response = await httpClient.PostAsync(Url, content);
            //response.EnsureSuccessStatusCode();建议不要使用  一旦相应失败会直接抛出异常   参考官方文档https://docs.microsoft.com/zh-cn/dotnet/api/system.net.http.httpresponsemessage.ensuresuccessstatuscode?redirectedfrom=MSDN&view=net-5.0#System_Net_Http_HttpResponseMessage_EnsureSuccessStatusCode
if (response.StatusCode==HttpStatusCode.OK)
                    {
                        responseBody = await response.Content.ReadAsStringAsync();
           dynamic res = (dynamic)JsonConvert.DeserializeObject<dynamic>(responseBody);
return res;
                    }
            
        }
        
    }

application/x-www-form-urlencoded

这里有些注意的地方   一开始参数我是直接用的 

//parameter   为   a=1&b=2&c=3   的形式   但是返回结果总是报400错误   

var content = new StringContent(parameter, Encoding.UTF8, "application/x-www-form-urlencoded ");//请求参数    

后来就改成了   FormUrlEncodedContent这种形式  可以正常提交

public static async Task<dynamic> DoPostRequest(string Url, string token, IHttpClientFactory httpClient)
        {
            try
            {
                using (var client = httpClient.CreateClient())
                { 
                    string responseBody = string.Empty;
                    //var content = new StringContent(parameter, Encoding.UTF8, ContentType);//请求参数   请求消息内容   application/x-www-form-urlencoded "application/json"请求类型
                    client.DefaultRequestHeaders.Add("Method", "Post"); 
                    var content = new FormUrlEncodedContent(new Dictionary<string, string>()
                   { 
                       {"username", "aadasd"},
                       {"password", "123123"}
                   }); 
                    if (!string.IsNullOrEmpty(token))
                    {
                        client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token); //Bearer认证      如果接口未加密省略此行
                         
                        //var authorizationBased64 = "Basic " + Convert.ToBase64String(new ASCIIEncoding().GetBytes($"{userName}:{password}"));//basic认证方式   用户名:密码 然后base64加密
                        //client.DefaultRequestHeaders.Add("Authorization", authorizationBased64);
                    } 
                    content.Headers.Add("ContentType", "application/x-www-form-urlencoded");
                    HttpResponseMessage response = await client.PostAsync(Url, content);
                    //response.EnsureSuccessStatusCode();建议不要使用  一旦相应失败会直接抛出异常   参考官方文档https://docs.microsoft.com/zh-cn/dotnet/api/system.net.http.httpresponsemessage.ensuresuccessstatuscode?redirectedfrom=MSDN&view=net-5.0#System_Net_Http_HttpResponseMessage_EnsureSuccessStatusCode
                    if (response.StatusCode==HttpStatusCode.OK)
                    {

                        responseBody =  response.Content.ReadAsStringAsync().Result;
                        dynamic res = JsonConvert.DeserializeObject<dynamic>(responseBody);
                        return res;
                    }
                    return new {result="请求异常" };
                }
            }
            catch (Exception e)
            {
                return new { result = "请求异常" };
            }
        }

非注入方式使用httpClient

/// <summary>
        /// post请求
        /// </summary>
        /// <param name="Url"></param>
        /// <param name="parameter">序列化之后的json</param>
        /// <param name="ContentType">例如："application/json"  application/x-www-form-urlencoded    text/xml</param>
        /// <param name="token"></param>
        /// <param name="httpClient"></param>
        /// <returns></returns>
        public static async Task<dynamic> DoPostRequest(string Url, string parameter, string ContentType, string token )
        {
            try
            {
                using (HttpClient client = new HttpClient())
                {
                    string responseBody = string.Empty;
                    client.DefaultRequestHeaders.Add("Method", "Post");
                    var content = new StringContent(parameter, Encoding.UTF8, ContentType);
                    if (!string.IsNullOrEmpty(token))
                    {
                        client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token); //Bearer认证      如果接口未加密省略此行

                        //var authorizationBased64 = "Basic " + Convert.ToBase64String(new ASCIIEncoding().GetBytes($"{userName}:{password}"));//basic认证方式   用户名:密码 然后base64加密
                        //client.DefaultRequestHeaders.Add("Authorization", authorizationBased64);
                    }
                    HttpResponseMessage response = await client.PostAsync(Url, content);
                    //response.EnsureSuccessStatusCode();
                    if (response.StatusCode == HttpStatusCode.OK)
                    {
                        responseBody = response.Content.ReadAsStringAsync().Result;
                        dynamic res = JsonConvert.DeserializeObject<dynamic>(responseBody);

                        return new { ok = true, isTryException = false, data = res };
                    }
                    else
                    {
                        responseBody = response.Content.ReadAsStringAsync().Result;
                        //Response结果 res = JsonConvert.DeserializeObject<Response结果>(responseBody);
                        return new { ok = false, isTryException = false, data = responseBody };
                    }
                }
            }
            catch (Exception e)
            {
                return new { ok = false, isTryException = true, msg = e.Message, data = "" };
            }
        }

调用方法的时候要加await   方法改成async

public async Task<dynamic> GetPHtokenAsync(T_login login) {
            try
            {  
                dynamic aaa=await PublicMethods.DoPostRequest("http://localhost:123123/connect/token", parameter,  _httpClient);
                return aaa;
            }
            catch (Exception e)
            {

                throw;
            }

帮助类

public class HttpHelper{


        /// <summary>
        /// get请求
        /// </summary>
        /// <param name="Url"></param> 
        /// <param name="AuthType">验证类型   这里示例两种  一种是cookie   一种是Bear </param>
        /// <param name="token"></param>
        /// <param name="httpClient">这里是注入的方式   也可以不用注入  直接new</param>
        /// <returns></returns>
public static async Task<dynamic> DoGetRequestAsync(string url,string AuthType,string token, IHttpClientFactory httpClient)
        { 
            try
            {
                //using(HttpClient client = new HttpClient()) 非注入方式
                using (var client = httpClient.CreateClient())
                {
                    //使用注入的httpclientfactory获取client 
                    client.BaseAddress = new Uri(url);
                    if (!string.IsNullOrWhiteSpace(AuthType))
                    {
                        switch (AuthType)
                        {
                            //Bearer认证      如果接口未加密省略此行
                            case "Bearer": client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token); break;
                            case "Cookie": client.DefaultRequestHeaders.Add("Cookie", token); break;

                        }
                    } 
                    //设置请求体中的内容，并以gost的方式请求
                    var response = await client.GetAsync(url);
                    //获取请求到数据，并转化为字符串
                    var result = response.Content.ReadAsStringAsync().Result;
                    if (response.StatusCode == HttpStatusCode.OK)
                    { 
                        return result;
                    }
                    return new { ok = false, msg = "请求异常", data = "" };
                }
            }
            catch (Exception e)
            {
                return new { ok = false, msg = e.Message, data = "" };
            }
        }
        /// <summary>
        /// post请求
        /// </summary>
        /// <param name="Url"></param>
        /// <param name="parameter">序列化之后的json</param>
        /// <param name="ContentType">例如："application/json"</param>
        /// <param name="Auth">验证类型   这里示例两种  一种是cookie   一种是Bear </param>
        /// <param name="token"></param>
        /// <param name="httpClient"></param>
        /// <returns></returns>
        public static async Task<dynamic> DoPostRequest(string Url,string parameter,string ContentType,string AuthType, string token, IHttpClientFactory httpClient)
        {
            try
            {
                //using(HttpClient client = new HttpClient()) 非注入方式
                using (var client = httpClient.CreateClient())
                {
                    string responseBody = string.Empty;
                    client.DefaultRequestHeaders.Add("Method", "Post");
                    var content = new StringContent(parameter, Encoding.UTF8, ContentType);
                    if (!string.IsNullOrEmpty(AuthType))
                    {
                        switch (AuthType)
                        {
                            //Bearer认证      如果接口未加密省略此行
                            case "Bearer": client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token); break;
                            case "Cookie": client.DefaultRequestHeaders.Add("Cookie", token); break;

                        } 

                        //var authorizationBased64 = "Basic " + Convert.ToBase64String(new ASCIIEncoding().GetBytes($"{userName}:{password}"));//basic认证方式   用户名:密码 然后base64加密
                        //client.DefaultRequestHeaders.Add("Authorization", authorizationBased64);
                    }
                    HttpResponseMessage response = await client.PostAsync(Url, content);
                    //response.EnsureSuccessStatusCode();
                    if (response.StatusCode == HttpStatusCode.OK)
                    {
                        responseBody = response.Content.ReadAsStringAsync().Result;
                        dynamic res = JsonConvert.DeserializeObject<dynamic>(responseBody);
                        string CookieValue = "";
                        if (AuthType == "Cookie"&& Url.EndsWith("login")) {
                            //如果认证是cookie那么要从请求头获取cookie  调用其它接口时要在塞到cookie里
                            string[] Cookie = (string[])response.Headers.GetValues("Set-Cookie");
                            CookieValue = Cookie[0].Split(';')[0];
                        }
                        return new { ok = true, isTryException = false, cookie = CookieValue, data = res };
                    }
                    else
                    {
                        responseBody = response.Content.ReadAsStringAsync().Result;
                        
                        return new { ok = false, isTryException = false, cookie = "", data = responseBody };
                    }
                }
            }
            catch (Exception e)
            {
                return new { ok = false,isTryException=true, msg = e.Message, data = "" };
            }
        }


        /// <summary>
        /// post请求      ContentType", "application/x-www-form-urlencoded
        /// </summary>
        /// <param name="Url"></param>
        /// <param name="parameter"></param>
        /// <param name="ContentType"></param>
        /// <param name="token"></param>
        /// <param name="httpClient"></param>
        /// <returns></returns>
        public static async Task<dynamic> DoPostRequest(string Url,Dictionary<string,string> parameter, string token, IHttpClientFactory httpClient)
        {
            try
            {
                //using(HttpClient client = new HttpClient()) 非注入方式
                using (var client = httpClient.CreateClient())
                { 
                    string responseBody = string.Empty;
                     client.DefaultRequestHeaders.Add("Method", "Post"); 
                    var content = new FormUrlEncodedContent(parameter); 
                    if (!string.IsNullOrEmpty(token))
                    {
                        client.DefaultRequestHeaders.Add("Authorization", "Bearea " + token); //Bearea认证      如果接口未加密省略此行
                         
                        //var authorizationBased64 = "Basic " + Convert.ToBase64String(new ASCIIEncoding().GetBytes($"{userName}:{password}"));//basic认证方式   用户名:密码 然后base64加密
                        //client.DefaultRequestHeaders.Add("Authorization", authorizationBased64);
                    } 
                    content.Headers.Add("ContentType", "application/x-www-form-urlencoded");
                    HttpResponseMessage response = await client.PostAsync(Url, content);
                    response.EnsureSuccessStatusCode();
                    if (response.StatusCode==HttpStatusCode.OK)
                    {
                        responseBody =  response.Content.ReadAsStringAsync().Result;
                        dynamic res = JsonConvert.DeserializeObject<dynamic>(responseBody);

                        return new { ok = true, data = res }; 
                    }
                    return new { ok = false,msg= "请求异常", data ="" }; 
                }
            }
            catch (Exception e)
            {
                return new { ok = false, msg = e.Message, data = "" };
            }
        }
}