public async Task <ResponseTemplate> ExecuteAsync(RequestTemplate requestTemplate, CancellationToken cancellationToken)
{
var httpClient = HttpClientFactory.CreateClient();
httpClient.Timeout = TimeSpan.FromDays(3);
var httpRequest = new HttpRequestMessage(requestTemplate.HttpMethod, requestTemplate.Url);
if (requestTemplate.HttpMethod == HttpMethod.Post)
{
if (requestTemplate.IsForm)
{
httpRequest.Content = new FormUrlEncodedContent(requestTemplate.FormValue);
}
else
{
string postData = requestTemplate.Body.HasText() ? requestTemplate.Body : "";
httpRequest.Content = new StringContent(postData);
}
}
//处理header
foreach (var requestTemplateHeader in requestTemplate.Headers)
{
var uppperKey = requestTemplateHeader.Key.ToUpper();
var key = uppperKey.Replace("-", "");
//判断普通标头
if (HttpHeaderSupport.RequestHeaders.Contains(key))
{
httpRequest.Headers.Remove(requestTemplateHeader.Key);
httpRequest.Headers.Add(requestTemplateHeader.Key, requestTemplateHeader.Value);
}
//判断body标头
else if (HttpHeaderSupport.ContentHeaders.Contains(key))
{
httpRequest.Content.Headers.Remove(requestTemplateHeader.Key);
httpRequest.Content.Headers.Add(requestTemplateHeader.Key, requestTemplateHeader.Value);
}
//自定义标头
else
{
httpRequest.Headers.TryAddWithoutValidation(requestTemplateHeader.Key,
requestTemplateHeader.Value);
}
}
var httpResponse = await httpClient.SendAsync(httpRequest, cancellationToken);
//把httpResponseMessage转化为responseTemplate
var result = await ConvertResponseAsync(httpResponse);
return(result);
}
/// <summary>
/// 处理请求头逻辑
/// </summary>
/// <param name="method"></param>
/// <param name="requestTemplate"></param>
private void ProcessHeaders(MethodInfo method, RequestTemplate requestTemplate, Type interfaceType)
{
var headersAttributes = new List <HeadersAttribute>();
var methodHeadersAttribute = method.GetCustomAttribute <HeadersAttribute>();
var interfaceHeadersAttribute = interfaceType.GetCustomAttribute <HeadersAttribute>();
if (methodHeadersAttribute != null)
{
headersAttributes.Add(methodHeadersAttribute);
}
if (interfaceHeadersAttribute != null)
{
headersAttributes.Add(interfaceHeadersAttribute);
}
foreach (var headersAttribute in headersAttributes)
{
if (headersAttribute != null)
{
var headerParams = headersAttribute.Param;
foreach (var headerParam in headerParams)
{
if (headerParam.HasIndexOf(':'))
{
var headerParamArr = headerParam.Split(":");
var key = headerParamArr[0].Trim();
var keyValue = headerParamArr[1];
//替换变量
key = ReplaceVariable(key).Trim();
keyValue = ReplaceVariable(keyValue).Trim();
var hasHeaderKey = requestTemplate.Headers.TryGetValue(key, out var keyList);
if (!hasHeaderKey)
{
keyList = new List <string>();
keyList.Add(keyValue);
requestTemplate.Headers.Add(key, keyList);
}
else
{
keyList.Add(keyValue);
}
}
}
}
}
}
public async Task <ResponseTemplate> ExecuteAsync(RequestTemplate requestTemplate, CancellationToken cancellationToken)
{
var httpClient = HttpClientFactory.CreateClient(requestTemplate.ClientName);
var httpRequest = new HttpRequestMessage(requestTemplate.HttpMethod, requestTemplate.Url);
httpRequest.Content = requestTemplate.HttpContent;
//处理header
foreach (var requestTemplateHeader in requestTemplate.Headers)
{
//HeaderNames
var uppperKey = requestTemplateHeader.Key.ToUpper();
var key = uppperKey.Replace("-", "");
//判断普通标头
if (HttpHeaderSupport.RequestHeaders.Contains(key))
{
httpRequest.Headers.Remove(requestTemplateHeader.Key);
httpRequest.Headers.Add(requestTemplateHeader.Key, requestTemplateHeader.Value);
}
//判断body标头
else if (HttpHeaderSupport.ContentHeaders.Contains(key))
{
httpRequest.Content.Headers.Remove(requestTemplateHeader.Key);
httpRequest.Content.Headers.Add(requestTemplateHeader.Key, requestTemplateHeader.Value);
}
//自定义标头
else
{
httpRequest.Headers.TryAddWithoutValidation(requestTemplateHeader.Key,
requestTemplateHeader.Value);
}
}
var httpResponse = await httpClient.SendAsync(httpRequest, cancellationToken);
httpResponse.EnsureSuccessStatusCode();
//把httpResponseMessage转化为responseTemplate
var result = await ConvertResponseAsync(httpResponse);
return(result);
}
public async Task <ResponseTemplate> ExecuteAsync(RequestTemplate requestTemplate, CancellationToken cancellationToken)
{
var httpClient = HttpClientFactory.CreateClient();
var httpRequest = new HttpRequestMessage(requestTemplate.HttpMethod, requestTemplate.Url);
foreach (var requestTemplateHeader in requestTemplate.Headers)
{
var uppperKey = requestTemplateHeader.Key.ToUpper();
var key = uppperKey.Replace("-", "");
if (HttpHeaderSupport.RequestHeaders.Contains(key))
{
httpRequest.Headers.Remove(requestTemplateHeader.Key);
httpRequest.Headers.Add(requestTemplateHeader.Key, requestTemplateHeader.Value);
}
}
if (requestTemplate.HttpMethod == HttpMethod.Post)
{
var content = new StringContent(requestTemplate.Body);
foreach (var header in requestTemplate.Headers)
{
var uppperKey = header.Key.ToUpper();
var key = uppperKey.Replace("-", "");
if (HttpHeaderSupport.ContentHeaders.Contains(key))
{
content.Headers.Remove(header.Key);
content.Headers.Add(header.Key, header.Value);
}
}
httpRequest.Content = content;
}
//var temp = await httpClient.SendAsync(new HttpRequestMessage(HttpMethod.Head, requestTemplate.Url));
var httpResponse = await httpClient.SendAsync(httpRequest, cancellationToken);
//把httpResponseMessage转化为responseTemplate
var result = await ConvertResponseAsync(httpResponse);
return(result);
}
public async Task <T> BaseExecuteAsync <T>(MethodInfo method, object[] args, IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
//获得具体的client客户端
var feignClient = serviceProvider.GetService <IClient>();
//序列化器与反序列化器
var encoder = serviceProvider.GetService <IFeignEncoder>();
var decoder = serviceProvider.GetService <IFeignDecoder>();
//读取feignClientAttribute里的信息；
//接口类型
var interfaceType = method.DeclaringType;
if (interfaceType == null)
{
throw new Exception(nameof(interfaceType));
}
var feignClientAttribute = interfaceType.GetCustomAttribute <FeignClientAttribute>();
var url = feignClientAttribute.Url;
var path = feignClientAttribute.Path;
var path2 = string.Empty;
var clientName = feignClientAttribute.Name;
var requestPath = url + path;
var requestTemplate = new RequestTemplate();
//获得请求拦截器
var requestInterceptor = serviceProvider.GetService <IRequestInterceptor>();
//处理请求头逻辑
ProcessHeaders(method, requestTemplate);
//处理get逻辑
var getMappingAttribute = method.GetCustomAttribute <GetMappingAttribute>();
if (getMappingAttribute != null)
{
path2 = getMappingAttribute.Value;
requestTemplate.HttpMethod = HttpMethod.Get;
}
//处理post逻辑
var postMappingAttribute = method.GetCustomAttribute <PostMappingAttribute>();
if (postMappingAttribute != null)
{
path2 = postMappingAttribute.Value;
requestTemplate.HttpMethod = HttpMethod.Post;
}
var urlTemp = (requestPath + path2).ToLower();
requestTemplate.Url = GetUrl(urlTemp);
//处理参数,因为有些参数需要拼接到url里，所以要在url处理完毕后才能处理参数
ProcessParameter(method, args, requestTemplate, encoder);
//如果存在拦截器，则进行拦截
if (requestInterceptor != null)
{
requestInterceptor.Apply(requestTemplate);
}
var responseTemplate = await feignClient.ExecuteAsync(requestTemplate, new CancellationToken());
//判断方法返回值是否为异步类型
var isAsyncReturnType = method.ReturnType.IsAsyncType();
//返回类型
var returnType = isAsyncReturnType ? method.ReturnType.GenericTypeArguments.First() : method.ReturnType;
var resultTmp = (T)decoder.Decoder(responseTemplate, returnType);
return(resultTmp);
}
/// <summary>
/// 处理参数
/// </summary>
private void ProcessParameter(MethodInfo method, object[] args, RequestTemplate requestTemplate, IFeignEncoder encoder)
{
var parameterInfos = method.GetParameters();
//所有参数里，body注解和form注解只能有一个
var hasBodyAttribute = false;
var hasFormAttribute = false;
//参数集合
var parameters = new Dictionary <string, string>();
//url
var url = requestTemplate.Url;
for (var i = 0; i < parameterInfos.Length; i++)
{
var arg = args[i];
var parameterInfo = parameterInfos[i];
var parameterType = parameterInfos[i].ParameterType;
var paramAttribute = parameterInfo.GetCustomAttribute <ParamAttribute>();
var bodyAttribute = parameterInfo.GetCustomAttribute <BodyAttribute>();
var formAttribute = parameterInfo.GetCustomAttribute <FormAttribute>();
var parameterName = parameterInfos[i].Name;
if (paramAttribute != null && bodyAttribute != null)
{
throw new Exception(parameterType.Name + "can not accept parameterAttrite and bodyAttribute");
}
var parameterTypeIsString = parameterType.IsString();
//处理param类型
if ((parameterTypeIsString || parameterType.IsValueType) && bodyAttribute == null)
{
parameterName = paramAttribute != null?paramAttribute.Value.GetValueOrDefault(parameterName) : parameterName;
parameters.Add(parameterName, arg.ToString());
}
//处理body类型
if (!parameterTypeIsString && parameterType.IsClass && bodyAttribute != null)
{
if (hasBodyAttribute)
{
throw new Exception("bodyAttribute just only one");
}
if (hasFormAttribute)
{
throw new Exception("formAttribute and bodyAttribute can not exist at the same time");
}
hasBodyAttribute = true;
requestTemplate.IsForm = false;
encoder.Encoder(args[i], requestTemplate);
}
//处理form类型
if (!parameterTypeIsString && parameterType.IsClass && formAttribute != null)
{
if (hasFormAttribute)
{
throw new Exception("formAttribute just only one");
}
if (hasBodyAttribute)
{
throw new Exception("formAttribute and bodyAttribute can not exist at the same time");
}
hasFormAttribute = true;
requestTemplate.IsForm = true;
encoder.EncoderFormValue(args[i], requestTemplate);
}
}
var strParam = string.Join("&", parameters.Select(o => o.Key + "=" + o.Value));
if (strParam.HasText())
{
url = string.Concat(url, '?', strParam);
}
requestTemplate.Url = url;
}
public async Task <T> BaseExecuteAsync <T>(MethodInfo method, object[] args, IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
//获得具体的client客户端
var feignClient = serviceProvider.GetService <IClient>();
//序列化器与反序列化器
var encoder = serviceProvider.GetService <IFeignEncoder>();
var decoder = serviceProvider.GetService <IFeignDecoder>();
//读取feignClientAttribute里的信息；
//接口类型
var interfaceType = method.DeclaringType;
if (interfaceType == null)
{
throw new Exception(nameof(interfaceType));
}
var feignClientAttribute = interfaceType.GetCustomAttribute <FeignClientAttribute>();
if (feignClientAttribute == null)
{
throw new Exception(nameof(feignClientAttribute));
}
var url = feignClientAttribute.Url;
var clientName = feignClientAttribute.Name.GetValueOrDefault(interfaceType.FullName);
var requestPath = url;
var requestTemplate = new RequestTemplate()
{
ClientName = clientName
};
//处理参数
ProcessParameter(method, args, requestTemplate, encoder);
//处理请求头逻辑
ProcessHeaders(method, requestTemplate, interfaceType);
var path = "";
var mappingCount = 0;
//处理get逻辑
var getMappingAttribute = method.GetCustomAttribute <GetMappingAttribute>();
if (getMappingAttribute != null)
{
mappingCount++;
path = getMappingAttribute.Value;
requestTemplate.HttpMethod = HttpMethod.Get;
}
//处理post逻辑
var postMappingAttribute = method.GetCustomAttribute <PostMappingAttribute>();
if (postMappingAttribute != null)
{
mappingCount++;
path = postMappingAttribute.Value;
requestTemplate.HttpMethod = HttpMethod.Post;
}
//处理put逻辑
var putMappingAttribute = method.GetCustomAttribute <PutMappingAttribute>();
if (putMappingAttribute != null)
{
mappingCount++;
path = putMappingAttribute.Value;
requestTemplate.HttpMethod = HttpMethod.Put;
}
//处理Delete逻辑
var deleteMappingAttribute = method.GetCustomAttribute <DeleteMappingAttribute>();
if (deleteMappingAttribute != null)
{
mappingCount++;
path = deleteMappingAttribute.Value;
requestTemplate.HttpMethod = HttpMethod.Delete;
}
if (mappingCount > 1)
{
throw new NotSupportedException("only support one httpMapping");
}
var urlTemp = requestPath + path;
urlTemp = GetUrl(urlTemp);
urlTemp = AddUrlParameter(urlTemp);
requestTemplate.Url = ReplaceVariable(urlTemp);
//如果存在拦截器，则进行拦截
var ignoreInterceptorAttribute = method.GetCustomAttribute <IgnoreInterceptorAttribute>();
if (feignClientAttribute.InterceptorType != null && ignoreInterceptorAttribute == null)
{
//获得请求拦截器
var requestInterceptor = (IRequestInterceptor)serviceProvider.GetService(feignClientAttribute.InterceptorType);
await requestInterceptor.ApplyAsync(requestTemplate);
}
var responseTemplate = await feignClient.ExecuteAsync(requestTemplate, new CancellationToken());
//直接返回文件流
if (typeof(Stream).IsAssignableFrom(typeof(T)))
{
return((T)(object)responseTemplate.Body);
}
//返回原始信息
if (typeof(HttpResponseMessage).IsAssignableFrom(typeof(T)))
{
return((T)(object)responseTemplate.OrignHttpResponseMessage);
}
Exception ex;
try
{
var resultTmp = decoder.Decoder <T>(responseTemplate);
return(resultTmp);
}
catch (Exception e)
{
ex = e;
}
responseTemplate.Body.Seek(0, SeekOrigin.Begin);
throw new Exception($@"response Decoder error,content is {responseTemplate.Body.ConvertToString()}", ex);
}
/// <summary>
/// 处理参数
/// </summary>
private void ProcessParameter(MethodInfo method, object[] args, RequestTemplate requestTemplate, IFeignEncoder encoder)
{
var parameterInfos = method.GetParameters();
var multipartAttribute = method.GetCustomAttribute <MultipartAttribute>();
var multipartFormDataContent = new MultipartFormDataContent();
for (var i = 0; i < parameterInfos.Length; i++)
{
var arg = args[i];
var parameterInfo = parameterInfos[i];
var parameterType = parameterInfos[i].ParameterType;
var aliasAsAttribute = parameterInfo.GetCustomAttribute <AliasAsAttribute>();
var bodyAttribute = parameterInfo.GetCustomAttribute <BodyAttribute>();
var queryAttribute = parameterInfo.GetCustomAttribute <QueryAttribute>();
var parameterName = aliasAsAttribute != null ? aliasAsAttribute.Name : parameterInfos[i].Name;
//处理body类型
if (bodyAttribute != null)
{
switch (bodyAttribute.SerializationKind)
{
case BodySerializationKind.Json:
requestTemplate.HttpContent = encoder.Encoder(args[i]);
break;
case BodySerializationKind.Form:
if (arg is string str)
{
requestTemplate.HttpContent = new StringContent(Uri.EscapeDataString(str),
Encoding.UTF8, "application/x-www-form-urlencoded");
}
else
{
var dictionary = new Dictionary <string, string>();
if (arg is IDictionary tempDictionary)
{
foreach (var key in tempDictionary.Keys)
{
var value = tempDictionary[key];
if (value != null)
{
dictionary.Add(key.ToString(), value?.ToString());
}
}
}
else
{
var parameterPropertyInfos = parameterType.GetProperties();
foreach (var propertyInfo in parameterPropertyInfos)
{
var propertyAliasAsAttribute = propertyInfo.GetCustomAttribute <AliasAsAttribute>();
var key = propertyAliasAsAttribute != null
? propertyAliasAsAttribute.Name
: propertyInfo.Name;
var value = propertyInfo.GetValue(arg);
if (value != null)
{
dictionary.Add(key.ToString(), value?.ToString());
}
}
}
if (multipartAttribute == null)
{
requestTemplate.HttpContent = new FormUrlEncodedContent(dictionary);
}
else
{
foreach (KeyValuePair <string, string> pair in dictionary)
{
multipartFormDataContent.Add(new StringContent(pair.Value), pair.Key);
}
}
}
break;
}
}
else if (queryAttribute != null)
{
if (arg != null)
{
if (arg is string str || parameterType.IsValueType)
{
urlParameters.Add(parameterName, arg.ToString());
}
else if (parameterType.IsClass)
{
var parameterPropertyInfos = parameterType.GetProperties();
foreach (var propertyInfo in parameterPropertyInfos)
{
var propertyAliasAsAttribute = propertyInfo.GetCustomAttribute <AliasAsAttribute>();
var key = propertyAliasAsAttribute != null
? propertyAliasAsAttribute.Name
: propertyInfo.Name;
var value = propertyInfo.GetValue(arg);
if (value != null)
{
urlParameters.Add(key, value.ToString());
}
}
}
}
}
public void Encoder(object obj, RequestTemplate requestTemplate)
{
var objStr = JsonConvert.SerializeObject(obj);
requestTemplate.Body = objStr;
}
