.NET Core - .NET Core | 请求外部api接口 - 《.Net 学习历程》

1、打开net core项目中的Startup.cs文件，找到ConfigureServices方法，添加HttpClient
2、控制器中注入IHttpClientFactory
- 1. 注入方式
- 继承StringContent（命名空间为：System.Net.Http）的类">2. 继承StringContent（命名空间为：System.Net.Http）的类
  - 1.Get请求
  - 2. Post请求
3、调用get方式api
- 1. httpClient注入的方式使用
- 2. 非注入方式使用httpClient">2. 非注入方式使用httpClient
4、调用post方式api

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

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

.NET Core | 请求外部api接口 - 图1

2、控制器中注入IHttpClientFactory

1. 注入方式

using System.Net.Http;
private   IHttpClientFactory _httpClient;
public WeChatController( IHttpClientFactory httpClient)
{ 
    this._httpClient = httpClient;
}

.NET Core | 请求外部api接口 - 图2

2. 继承StringContent（命名空间为：System.Net.Http）的类

public class JsonContent : StringContent
{
    public JsonContent(object obj) :
    base(JsonConvert.SerializeObject(obj), Encoding.UTF8, "application/json")
    { }
}

1.Get请求

//设置请求的路径
var url = "";
//使用注入的httpclientfactory获取client
var client = _httpClient.CreateClient();
client.BaseAddress = new Uri(url);
//设置请求体中的内容，并以post的方式请求
var response = await client.GetAsync(url);
//获取请求到数据，并转化为字符串
var result = response.Content.ReadAsStringAsync().Result;

2. Post请求

//设置请求的路径
var url = "";
//使用注入的httpclientfactory获取client
var client = _httpClient.CreateClient();
client.BaseAddress = new Uri(url);
//设置请求体中的内容，并以post的方式请求                   
var response = await client.PostAsync(url,new JsonContent(new { PayId= pay_id, DeviceId= sbid, DeviceMode="1", PayMode="0", PayDataId= "1234567890123456", PayData=pd, PayTime = datetime , PayAmount =amt, PayNum =1}));
//获取请求到数据，并转化为字符串
back = response.Content.ReadAsStringAsync().Result;

3、调用get方式api

1. 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 );
            }
        }

2. 非注入方式使用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

1. 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;
        }
    }
}

2. 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 = "请求异常" };
    }
}

3. 非注入方式使用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;
    }