/// <summary>
/// 根据绑定中的协议类型调用不同的实现方法
/// </summary>
/// <param name="state"></param>
/// <returns></returns>
private static ESB.Core.Schema.务响应 CallService(CallState callState)
{
ESBProxy esbProxy = ESBProxy.GetInstance();
Boolean noCache = false;
if (callState.InvokeParam != null)
{
noCache = (callState.InvokeParam.NoCache == 1);
}
//--如果缓存失效时间大于0，则优先从缓存中获取数据
if (callState.ServiceConfig.CacheDuration > 0)
{
String key = String.Format("MBSOA:{0}:{1}:{2}", callState.Request.务名称, callState.Request.方法名称, DataHelper.Hash(callState.Request.消息内容));
DateTime callBeginTime = DateTime.Now;
//--如果noCache为True则强制调用后台服务，刷新缓存
String message = noCache ? String.Empty : esbProxy.CacheManager.GetCache(key);
DateTime callEndTime = DateTime.Now;
if (String.IsNullOrEmpty(message))
{
ESB.Core.Schema.务响应 res = CallProxy(callState);
esbProxy.CacheManager.SetCache(key, res.消息内容, callState.ServiceConfig.CacheDuration);
return(res);
}
else
{
ESB.Core.Schema.务响应 res = new Schema.务响应()
{
消息内容 = message
};
callState.CallBeginTime = callBeginTime;
callState.CallEndTime = callEndTime;
LogUtil.AddAuditLog(1, callState.Binding, callState, message, callState.Request, 1);
return(res);
}
}
else
{
return(CallProxy(callState));
}
}
/// <summary>
/// 根据绑定的不同类型调用相关代理获取服务返回值
/// </summary>
/// <param name="callState"></param>
/// <returns></returns>
private static ESB.Core.Schema.服务响应 CallProxy(CallState callState)
{
switch (callState.Binding.BindingType)
{
case (int)BindingType.WebService:
return WebServiceClient.CallWebService(callState);
case (int)BindingType.REST:
return RestfulClient.CallRestfulService(callState);
case (int)BindingType.ASHX:
return HandlerClient.CallAshxService(callState);
case (int)BindingType.WCF_HTTP:
return WcfClient.CallWcfService(callState);
case (int)BindingType.DUBBO_JSON:
return DubboClient.CallDubboService(callState);
default:
throw LogUtil.ExceptionAndLog(callState, "未知的绑定类型", callState.Binding.BindingType.ToString(), callState.Binding, callState.Request);
}
}
public const String COMPANY_URL = "http://mb.com";//--公司网址,用于SOAP协议中的基地址
/// <summary>
/// 动态调用WebService主函数
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static ESB.Core.Schema.服务响应 DynamicalCallWebService(
Boolean needResponse
, ESB.Core.Schema.服务请求 request)
{
//--记录接收时间并放在请求结束时间中，用于判读ESB在接到请求到开始调用的耗时
DateTime receiveDateTime = DateTime.Now;
//--验证并预处理请求参数
InvalidRequest(request);
//--获取到请求对应服务的绑定
EntityList<BindingTemplate> bindings = GetBindings(request);
//--如果只有一个绑定，且需要返回结果
if (bindings.Count == 1 && needResponse == true)
{
CallState state = new CallState()
{
Binding = bindings[0],
Request = request,
RequestBeginTime = request.请求时间,
RequestEndTime = receiveDateTime
};
return CallService(state);
}
else //--如果有多个绑定则默认为发布、订阅模式，不需要将每个订阅则的结果都放回给调用方，或者指明是不需要返回结果的情况（单向调用）
{
foreach (BindingTemplate binding in bindings)
{
CallState state = new CallState()
{
Binding = binding,
Request = request,
RequestBeginTime = request.请求时间,
RequestEndTime = receiveDateTime
};
ThreadPoolX.QueueUserWorkItem(() => CallService(state));
}
return GetMultiResponse();
}
}
public const String COMPANY_URL = "http://mb.com";//--公司网址,用于SOAP协议中的基地址
/// <summary>
/// 动态调用WebService主函数
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static ESB.Core.Schema.务响应 DynamicalCallWebService(
Boolean needResponse
, ESB.Core.Schema.务请求 request)
{
//--记录接收时间并放在请求结束时间中，用于判读ESB在接到请求到开始调用的耗时
DateTime receiveDateTime = DateTime.Now;
//--验证并预处理请求参数
InvalidRequest(request);
//--获取到请求对应服务的绑定
EntityList <BindingTemplate> bindings = GetBindings(request);
//--如果只有一个绑定，且需要返回结果
if (bindings.Count == 1 && needResponse == true)
{
CallState state = new CallState()
{
Binding = bindings[0],
Request = request,
RequestBeginTime = request.请求时间,
RequestEndTime = receiveDateTime
};
return(CallService(state));
}
else //--如果有多个绑定则默认为发布、订阅模式，不需要将每个订阅则的结果都放回给调用方，或者指明是不需要返回结果的情况（单向调用）
{
foreach (BindingTemplate binding in bindings)
{
CallState state = new CallState()
{
Binding = binding,
Request = request,
RequestBeginTime = request.请求时间,
RequestEndTime = receiveDateTime
};
ThreadPoolX.QueueUserWorkItem(() => CallService(state));
}
return(GetMultiResponse());
}
}
/// <summary>
/// 根据绑定中的协议类型调用不同的实现方法
/// </summary>
/// <param name="state"></param>
/// <returns></returns>
private static ESB.Core.Schema.务响应 CallService(CallState callState)
{
switch (callState.Binding.BindingType)
{
case (int)BindingType.WebService:
return(SoapClient.CallWebService(callState));
case (int)BindingType.REST:
return(RestfulClient.CallRestfulService(callState));
case (int)BindingType.ASHX:
return(HandlerClient.CallAshxService(callState));
case (int)BindingType.WCF_HTTP:
return(WcfClient.CallWcfService(callState));
default:
throw LogUtil.ExceptionAndLog(callState, "未知的绑定类型", callState.Binding.BindingType.ToString(), callState.Binding, callState.Request);
}
}
/// <summary>
/// 动态调用WebService主函数
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static ESB.Core.Schema.服务响应 DynamicalCallWebService(
Boolean needResponse
, ESB.Core.Schema.服务请求 request
, List<BindingTemplate> bindings
, Int32 version
, EsbView_ServiceConfig serviceConfig
, AdvanceInvokeParam invokeParam)
{
//--记录接收时间并放在请求结束时间中，用于判读ESB在接到请求到开始调用的耗时
DateTime receiveDateTime = DateTime.Now;
//--验证并预处理请求参数
InvalidRequest(request);
//--获取跟踪上下文
ESBTraceContext esbTraceContext = GetEsbTraceContext();
//--获取到请求对应服务的绑定
BindingTemplate binding = LoadBalance.GetBinding(bindings, serviceConfig.HBPolicy);
//--构造调用参数
CallState state = new CallState()
{
Binding = binding,
ServiceConfig = serviceConfig,
InvokeParam = invokeParam,
Request = request,
RequestBeginTime = request.请求时间,
RequestEndTime = receiveDateTime,
TraceContext = esbTraceContext,
ServiceVersion = version,
MessageID = Guid.NewGuid().ToString()
};
return CallService(state);
}
/// <summary>
/// 动态调用WebService主函数
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static ESB.Core.Schema.务响应 DynamicalCallWebService(
Boolean needResponse
, ESB.Core.Schema.务请求 request
, List <BindingTemplate> bindings
, Int32 version
, EsbView_ServiceConfig serviceConfig
, AdvanceInvokeParam invokeParam)
{
//--记录接收时间并放在请求结束时间中，用于判读ESB在接到请求到开始调用的耗时
DateTime receiveDateTime = DateTime.Now;
//--验证并预处理请求参数
InvalidRequest(request);
//--获取跟踪上下文
ESBTraceContext esbTraceContext = GetEsbTraceContext();
//--获取到请求对应服务的绑定
BindingTemplate binding = LoadBalance.GetBinding(bindings, serviceConfig.HBPolicy);
//--构造调用参数
CallState state = new CallState()
{
Binding = binding,
ServiceConfig = serviceConfig,
InvokeParam = invokeParam,
Request = request,
RequestBeginTime = request.请求时间,
RequestEndTime = receiveDateTime,
TraceContext = esbTraceContext,
ServiceVersion = version,
MessageID = Guid.NewGuid().ToString()
};
return(CallService(state));
}
public static ESB.Core.Schema.务响应 CallWcfService(CallState callState)
{
//--STEP.1.从CallState中获取到需要的信息
ESB.Core.Schema.务请求 request = callState.Request;
String message = callState.Request.消息内容;
BindingTemplate binding = callState.Binding;
String uri = callState.Binding.Address;
//--STEP.3.构造HTTP请求并调用ASHX服务
ESB.Core.Schema.务响应 response = new ESB.Core.Schema.务响应();
try
{
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uri);
webRequest.Method = "POST";
webRequest.ContentType = "text/xml";
if (String.IsNullOrEmpty(callState.Request.方法名称))
{
throw LogUtil.ExceptionAndLog(callState, "WCF-HTTP服务的方法名称必须填写", "", binding, request);
}
else
{
webRequest.Headers.Add("SOAPAction", String.Format("{0}/{1}", EsbClient.COMPANY_URL, request.方法名称));
}
//--STEP.3.1.如果是POST请求，则需要将消息内容发送出去
if (!String.IsNullOrEmpty(message))
{
String reqMessage = CommonUtil.XmlEncoding(request.消息内容);
String soapMessage = String.Format(SOAP_MESSAGE_TEMPLATE, EsbClient.COMPANY_URL, reqMessage);
byte[] data = System.Text.Encoding.Default.GetBytes(soapMessage);
using (Stream stream = webRequest.GetRequestStream())
{
stream.Write(data, 0, data.Length);
}
}
//--STEP.3.2.获取到响应消息
callState.CallBeginTime = DateTime.Now;
HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse();
using (Stream newstream = webResponse.GetResponseStream())
{
using (StreamReader srRead = new StreamReader(newstream, System.Text.Encoding.Default))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = GetMessageFromSOAP(outString, "//" + callState.Request.方法名称 + "Result");
srRead.Close();
}
}
//--STEP.3.3.记录日志并返回ESB响应
LogUtil.AddAuditLog(
1
, binding
, callState.RequestBeginTime, callState.RequestEndTime, callState.CallBeginTime, callState.CallEndTime
, response.消息内容, request);
}
catch (Exception ex)
{
callState.CallEndTime = DateTime.Now;
String exMessage = String.Empty;
if (ex.InnerException != null)
{
exMessage = ex.InnerException.Message;
}
else
{
exMessage = ex.Message;
}
throw LogUtil.ExceptionAndLog(callState, "调用目标服务抛出异常", exMessage, binding, request);
}
return(response);
}
public static ESB.Core.Schema.服务响应 CallAshxService(CallState callState)
{
//--STEP.1.从CallState中获取到需要的信息
ESB.Core.Schema.服务请求 request = callState.Request;
String message = callState.Request.消息内容;
BindingTemplate binding = callState.Binding;
String uri = callState.Binding.Address;
String contentType = String.Equals(callState.Request.消息编码, "XML", StringComparison.OrdinalIgnoreCase)
? EsbClient.CONTENT_TYPE_XML : EsbClient.CONTENT_TYPE_JSON;
//--STEP.2.根据method拼接URL
if (String.IsNullOrEmpty(callState.Request.方法名称))
{
throw LogUtil.ExceptionAndLog(callState, "ASHX服务的方法名称必须填写", "", binding, request);
}
else
{
uri = uri + "?EsbAction=" + callState.Request.方法名称;
}
//--STEP.3.构造HTTP请求并调用ASHX服务
ESB.Core.Schema.服务响应 response = new ESB.Core.Schema.服务响应();
try
{
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uri);
webRequest.Accept = contentType;
webRequest.Method = "POST";
webRequest.ContentType = contentType;
//--STEP.3.1.如果是POST请求，则需要将消息内容发送出去
if (!String.IsNullOrEmpty(message))
{
byte[] data = System.Text.Encoding.Default.GetBytes(message);
using (Stream stream = webRequest.GetRequestStream())
{
stream.Write(data, 0, data.Length);
}
}
//--STEP.3.2.获取到响应消息
callState.CallBeginTime = DateTime.Now;
HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse();
using (Stream newstream = webResponse.GetResponseStream())
{
using (StreamReader srRead = new StreamReader(newstream, System.Text.Encoding.Default))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = outString;
srRead.Close();
}
}
//--STEP.3.3.记录日志并返回ESB响应
LogUtil.AddAuditLog(
1
, binding
, callState.RequestBeginTime, callState.RequestEndTime, callState.CallBeginTime, callState.CallEndTime
, response.消息内容, request);
}
catch (Exception ex)
{
callState.CallEndTime = DateTime.Now;
String exMessage = String.Empty;
if (ex.InnerException != null)
exMessage = ex.InnerException.Message;
else
exMessage = ex.Message;
throw LogUtil.ExceptionAndLog(callState, "调用目标服务抛出异常", exMessage, binding, request);
}
return response;
}
public static ESB.Core.Schema.务响应 CallWcfService(CallState callState)
{
//Console.WriteLine("CallWcfService 开始：{0}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
//--STEP.1.从CallState中获取到需要的信息
ESB.Core.Schema.务请求 request = callState.Request;
String message = callState.Request.消息内容;
BindingTemplate binding = callState.Binding;
String uri = callState.Binding.Address;
callState.Request.方法名称 = GetMethodName(callState.Request.方法名称);
//--STEP.3.构造HTTP请求并调用ASHX服务
ESB.Core.Schema.务响应 response = new ESB.Core.Schema.务响应();
try
{
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uri);
//webRequest.Proxy = null;
webRequest.Method = "POST";
webRequest.ContentType = "text/xml; charset=utf-8";
webRequest.Timeout = callState.ServiceConfig.Timeout;
webRequest.Headers.Add("Accept-Encoding", "gzip, deflate");
webRequest.Headers.Add(Constant.ESB_HEAD_TRACE_CONTEXT, callState.TraceContext.ToString());
webRequest.Headers.Add(Constant.ESB_HEAD_ANVOKE_ACTION, callState.Request.方法名称);
if (String.IsNullOrEmpty(callState.Request.方法名称))
{
throw LogUtil.ExceptionAndLog(callState, "WCF-HTTP服务的方法名称必须填写", "", binding, request);
}
else
{
webRequest.Headers.Add("SOAPAction", String.Format("{0}/EsbAction", Constant.COMPANY_URL));
}
//Console.WriteLine("WebRequest.Create 完成：{0}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
//--STEP.3.1.如果是POST请求，则需要将消息内容发送出去
if (!String.IsNullOrEmpty(message))
{
String reqMessage = CommonUtil.XmlEncoding(request.消息内容);
String esbAction = request.方法名称;
String soapMessage = String.Format(SOAP_MESSAGE_TEMPLATE, Constant.COMPANY_URL, reqMessage);
byte[] data = System.Text.Encoding.UTF8.GetBytes(soapMessage);
//Console.WriteLine("webRequest.GetRequestStream 开始：{0}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
using (Stream stream = webRequest.GetRequestStream())
{
stream.Write(data, 0, data.Length);
}
//Console.WriteLine("webRequest.GetRequestStream 完成：{0}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
}
//--STEP.3.2.获取到响应消息
callState.CallBeginTime = DateTime.Now;
HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse();
//--从返回头消息中取到服务调用的时间
callState.ServiceBeginTime = webResponse.Headers[Constant.ESB_HEAD_SERVICE_BEGIN];
callState.ServiceEndTime = webResponse.Headers[Constant.ESB_HEAD_SERVICE_END];
//Console.WriteLine("webRequest.GetResponse 完成：{0}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
if (webResponse.ContentEncoding.ToLower().Contains("gzip"))
{
using (GZipStream stream = new GZipStream(webResponse.GetResponseStream(), CompressionMode.Decompress))
{
using (StreamReader srRead = new StreamReader(stream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = GetMessageFromSOAP(outString, "//" + callState.Request.方法名称 + "Result");
srRead.Close();
}
}
}
else if (webResponse.ContentEncoding.ToLower().Contains("deflate"))
{
using (DeflateStream stream = new DeflateStream(webResponse.GetResponseStream(), CompressionMode.Decompress))
{
using (StreamReader srRead = new StreamReader(stream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = GetMessageFromSOAP(outString, "//" + callState.Request.方法名称 + "Result");
srRead.Close();
}
}
}
else
{
using (Stream newstream = webResponse.GetResponseStream())
{
using (StreamReader srRead = new StreamReader(newstream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = GetMessageFromSOAP(outString, "//" + callState.Request.方法名称 + "Result");
srRead.Close();
}
}
}
//Console.WriteLine("CallWcfService 完成：{0}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
//Console.WriteLine("AddAuditLog 开始：{0}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
//--STEP.3.3.记录日志并返回ESB响应
LogUtil.AddAuditLog(
1
, binding
, callState
, response.消息内容, request);
//Console.WriteLine("AddAuditLog 完成：{0}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
}
catch (Exception ex)
{
callState.CallEndTime = DateTime.Now;
String exMessage = String.Empty;
if (ex.InnerException != null)
{
exMessage = ex.InnerException.Message;
}
else
{
exMessage = ex.Message;
}
throw LogUtil.ExceptionAndLog(callState, "调用目标服务抛出异常", exMessage, binding, request);
}
return(response);
}
/// <summary>
/// 利用反射调用目标服务
/// </summary>
/// <param name="url"></param>
/// <param name="request"></param>
/// <returns></returns>
internal static ESB.Core.Schema.服务响应 CallWebService(CallState state)
{
CallState callState = state as CallState;
BindingTemplate binding = callState.Binding;
ESB.Core.Schema.服务请求 request = callState.Request;
SoapClientItem soapClient = null;
try
{
soapClient = SoapClientCache.GetItem(binding.Address, request.服务名称);
}
catch (Exception ex)
{
throw LogUtil.ExceptionAndLog(callState, "获取目标服务的代理程序集时发生异常", ex.Message, binding, request);
}
if (soapClient != null)
{
MethodInfo method = soapClient.GetMethodInfo(request.方法名称);
if (method == null)
throw LogUtil.ExceptionAndLog(callState, "目标服务未实现方法", request.方法名称, binding, request);
Object req = GetRequest(soapClient, request);
if (req == null)
throw LogUtil.ExceptionAndLog(callState, "无法将请求转换成目标服务所需要的输入参数", "", binding, request);
Object res = null;
try
{
callState.CallBeginTime = DateTime.Now;
res = method.Invoke(soapClient.PortObject, new Object[] { req });
callState.CallEndTime = DateTime.Now;
}
catch (Exception ex)
{
callState.CallEndTime = DateTime.Now;
String message = String.Empty;
if (ex.InnerException != null)
message = ex.InnerException.Message;
else
message = ex.Message;
throw LogUtil.ExceptionAndLog(callState, "调用目标服务抛出异常", message, binding, request);
}
ESB.Core.Schema.服务响应 response = GetResponse(res, method.ReturnType);
LogUtil.AddAuditLog(
1
, binding
, callState
, response.消息内容, request);
return response;
}
else
{
throw LogUtil.ExceptionAndLog(callState, "获取目标服务的代理程序集失败！", "", binding, request);
}
}
/// <summary>
/// 根据绑定中的协议类型调用不同的实现方法
/// </summary>
/// <param name="state"></param>
/// <returns></returns>
private static ESB.Core.Schema.服务响应 CallService(CallState callState)
{
ESBProxy esbProxy = ESBProxy.GetInstance();
Boolean noCache = false;
if (callState.InvokeParam != null)
noCache = (callState.InvokeParam.NoCache == 1);
//--如果缓存失效时间大于0，则优先从缓存中获取数据
if (callState.ServiceConfig.CacheDuration > 0)
{
String key = String.Format("MBSOA:{0}:{1}:{2}", callState.Request.服务名称, callState.Request.方法名称, DataHelper.Hash(callState.Request.消息内容));
DateTime callBeginTime = DateTime.Now;
//--如果noCache为True则强制调用后台服务，刷新缓存
String message = noCache ? String.Empty : esbProxy.CacheManager.GetCache(key);
DateTime callEndTime = DateTime.Now;
if (String.IsNullOrEmpty(message))
{
ESB.Core.Schema.服务响应 res = CallProxy(callState);
esbProxy.CacheManager.SetCache(key, res.消息内容, callState.ServiceConfig.CacheDuration);
return res;
}
else
{
ESB.Core.Schema.服务响应 res = new Schema.服务响应() { 消息内容 = message };
callState.CallBeginTime = callBeginTime;
callState.CallEndTime = callEndTime;
LogUtil.AddAuditLog(1, callState.Binding, callState, message, callState.Request, 1);
return res;
}
}
else{
return CallProxy(callState);
}
}
public static ESB.Core.Schema.务响应 CallAshxService(CallState callState)
{
//--STEP.1.从CallState中获取到需要的信息
ESB.Core.Schema.务请求 request = callState.Request;
String message = callState.Request.消息内容;
BindingTemplate binding = callState.Binding;
String uri = callState.Binding.Address;
String contentType = String.Equals(callState.Request.消息编码, "XML", StringComparison.OrdinalIgnoreCase)
? EsbClient.CONTENT_TYPE_XML : EsbClient.CONTENT_TYPE_JSON;
//--STEP.2.根据method拼接URL
if (String.IsNullOrEmpty(callState.Request.方法名称))
{
throw LogUtil.ExceptionAndLog(callState, "ASHX服务的方法名称必须填写", "", binding, request);
}
else
{
uri = uri + "?EsbAction=" + callState.Request.方法名称;
}
//--STEP.3.构造HTTP请求并调用ASHX服务
ESB.Core.Schema.务响应 response = new ESB.Core.Schema.务响应();
try
{
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uri);
webRequest.Accept = contentType;
webRequest.Method = "POST";
webRequest.ContentType = contentType;
//--STEP.3.1.如果是POST请求，则需要将消息内容发送出去
if (!String.IsNullOrEmpty(message))
{
byte[] data = System.Text.Encoding.Default.GetBytes(message);
using (Stream stream = webRequest.GetRequestStream())
{
stream.Write(data, 0, data.Length);
}
}
//--STEP.3.2.获取到响应消息
callState.CallBeginTime = DateTime.Now;
HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse();
using (Stream newstream = webResponse.GetResponseStream())
{
using (StreamReader srRead = new StreamReader(newstream, System.Text.Encoding.Default))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = outString;
srRead.Close();
}
}
//--STEP.3.3.记录日志并返回ESB响应
LogUtil.AddAuditLog(
1
, binding
, callState.RequestBeginTime, callState.RequestEndTime, callState.CallBeginTime, callState.CallEndTime
, response.消息内容, request);
}
catch (Exception ex)
{
callState.CallEndTime = DateTime.Now;
String exMessage = String.Empty;
if (ex.InnerException != null)
{
exMessage = ex.InnerException.Message;
}
else
{
exMessage = ex.Message;
}
throw LogUtil.ExceptionAndLog(callState, "调用目标服务抛出异常", exMessage, binding, request);
}
return(response);
}
/// <summary>
/// 增加审计日志
/// </summary>
public static String AddAuditLog(int status
, String bindingTemplateID
, String serviceID
, String address
, CallState callState
, String message
, ESB.Core.Schema.服务请求 request
, Int32 isCache = 0)
{
callState.RequestEndTime = DateTime.Now;
TimeSpan ReqTimeSpan = callState.RequestEndTime.Subtract(callState.RequestBeginTime);
ConfigurationManager cm = ConfigurationManager.GetInstance();
String consumerIP = cm.LocalIP;
if (callState.InvokeParam != null && !String.IsNullOrWhiteSpace(callState.InvokeParam.ConsumerIP))
consumerIP = callState.InvokeParam.ConsumerIP;
Int32 isQueue = 0;
if (callState.InvokeParam != null)
isQueue = callState.InvokeParam.IsQueue;
AuditBusiness log = new AuditBusiness()
{
OID = Guid.NewGuid().ToString(),
HostName = request.主机名称,
ServiceName = request.服务名称,
MethodName = request.方法名称,
ReqBeginTime = callState.RequestBeginTime.ToString("yyyy-MM-dd HH:mm:ss.ffffff"),
ReqEndTime = callState.RequestEndTime.ToString("yyyy-MM-dd HH:mm:ss.ffffff"),
Status = status,
MessageID = callState.MessageID,
MessageBody = request.消息内容,
CallBeginTime = callState.CallBeginTime.ToString("yyyy-MM-dd HH:mm:ss.ffffff"),
CallEndTime = callState.CallEndTime.ToString("yyyy-MM-dd HH:mm:ss.ffffff"),
BindingTemplateID = bindingTemplateID,
ServiceID = serviceID,
BindingAddress = address,
ReturnMessageBody = message,
BusinessName = "",
BusinessID = "",
ServiceBeginTime = callState.ServiceBeginTime,
ServiceEndTime = callState.ServiceEndTime,
TraceID = callState.TraceContext.TraceID,
InvokeLevel = callState.TraceContext.InvokeLevel,
InvokeOrder = callState.TraceContext.InvokeOrder,
InvokeID = callState.TraceContext.InvokeID,
InvokeTimeSpan = ReqTimeSpan.TotalMilliseconds,
ConsumerIP = consumerIP,
Version = callState.ServiceVersion,
IsCache = isCache,
IsQueue = isQueue
};
//log.Insert();
//String mqHost = ESBProxy.GetInstance().ESBConfig.Monitor[0].Uri;
//MSMQUtil.SendMessage<AuditBusiness>(log, String.Format(@"FormatName:DIRECT=TCP:{0}\Private$\EsbAuditQueue", "192.168.56.2"));
ESBProxy.GetInstance().MessageQueueClient.SendAuditMessage(log);
//--每调用完一次需要增加调用次数
callState.TraceContext.IncreaseInvokeOrder();
return log.OID;
}
/// <summary>
/// 抛出异常并写日志
/// </summary>
/// <param name="message"></param>
/// <param name="binding"></param>
/// <param name="request"></param>
public static Exception ExceptionAndLog(String exceptionDesc, String message, BindingTemplate binding, ESB.Core.Schema.服务请求 request)
{
CallState state = new CallState()
{
RequestBeginTime = DateTime.Now,
RequestEndTime = DateTime.Now,
CallBeginTime = DateTime.Now,
CallEndTime = DateTime.Now
};
return ExceptionAndLog(state, exceptionDesc, message, binding, request);
}
/// <summary>
/// 调用Handler服务
/// </summary>
/// <param name="callState"></param>
/// <returns></returns>
public static ESB.Core.Schema.务响应 CallAshxService(CallState callState)
{
//--STEP.1.从CallState中获取到需要的信息
ESB.Core.Schema.务请求 request = callState.Request;
String message = callState.Request.消息内容;
BindingTemplate binding = callState.Binding;
String uri = callState.Binding.Address;
String contentType = String.Equals(callState.Request.消息编码, "XML", StringComparison.OrdinalIgnoreCase)
? Constant.CONTENT_TYPE_XML : Constant.CONTENT_TYPE_JSON;
callState.Request.方法名称 = GetMethodName(callState.Request.方法名称);
//--STEP.2.根据method拼接URL
if (String.IsNullOrEmpty(callState.Request.方法名称))
{
throw LogUtil.ExceptionAndLog(callState, "ASHX服务的方法名称必须填写", "", binding, request);
}
//--STEP.3.构造HTTP请求并调用ASHX服务
ESB.Core.Schema.务响应 response = new ESB.Core.Schema.务响应();
try
{
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uri);
webRequest.Accept = contentType;
webRequest.Method = "POST";
webRequest.ContentType = contentType;
webRequest.Timeout = callState.ServiceConfig.Timeout;
webRequest.Headers.Add("Accept-Encoding", "gzip");
webRequest.Headers.Add(Constant.ESB_HEAD_TRACE_CONTEXT, callState.TraceContext.ToString());
webRequest.Headers.Add(Constant.ESB_HEAD_ANVOKE_ACTION, callState.Request.方法名称);
//--STEP.3.1.如果是POST请求，则需要将消息内容发送出去
if (!String.IsNullOrEmpty(message))
{
byte[] data = System.Text.Encoding.UTF8.GetBytes(message);
using (Stream stream = webRequest.GetRequestStream())
{
stream.Write(data, 0, data.Length);
}
}
//--STEP.3.2.获取到响应消息
callState.CallBeginTime = DateTime.Now;
HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse();
String contentEncoding = webResponse.ContentEncoding.ToLower();
callState.ServiceBeginTime = webResponse.Headers[Constant.ESB_HEAD_SERVICE_BEGIN];
callState.ServiceEndTime = webResponse.Headers[Constant.ESB_HEAD_SERVICE_END];
if (String.IsNullOrEmpty(contentEncoding))
{
using (Stream newstream = webResponse.GetResponseStream())
{
using (StreamReader srRead = new StreamReader(newstream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = outString;
srRead.Close();
}
}
}
else if (contentEncoding.Contains("gzip"))
{
using (GZipStream stream = new GZipStream(webResponse.GetResponseStream(), CompressionMode.Decompress))
{
using (StreamReader srRead = new StreamReader(stream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = outString;
srRead.Close();
}
}
}
else if (contentEncoding.Contains("deflate"))
{
using (DeflateStream stream = new DeflateStream(webResponse.GetResponseStream(), CompressionMode.Decompress))
{
using (StreamReader srRead = new StreamReader(stream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = outString;
srRead.Close();
}
}
}
else
{
using (Stream newstream = webResponse.GetResponseStream())
{
using (StreamReader srRead = new StreamReader(newstream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = outString;
srRead.Close();
}
}
}
//--STEP.3.3.记录日志并返回ESB响应
LogUtil.AddAuditLog(
1
, binding
, callState
, response.消息内容, request);
}
catch (Exception ex)
{
callState.CallEndTime = DateTime.Now;
String exMessage = String.Empty;
if (ex.InnerException != null)
{
exMessage = ex.InnerException.Message;
}
else
{
exMessage = ex.Message;
}
throw LogUtil.ExceptionAndLog(callState, "调用目标服务抛出异常", exMessage, binding, request);
}
return(response);
}
/// <summary>
/// 调用Handler服务
/// </summary>
/// <param name="callState"></param>
/// <returns></returns>
public static ESB.Core.Schema.服务响应 CallAshxService(CallState callState)
{
//--STEP.1.从CallState中获取到需要的信息
ESB.Core.Schema.服务请求 request = callState.Request;
String message = callState.Request.消息内容;
BindingTemplate binding = callState.Binding;
String uri = callState.Binding.Address;
String contentType = String.Equals(callState.Request.消息编码, "XML", StringComparison.OrdinalIgnoreCase)
? Constant.CONTENT_TYPE_XML : Constant.CONTENT_TYPE_JSON;
callState.Request.方法名称 = GetMethodName(callState.Request.方法名称);
//--STEP.2.根据method拼接URL
if (String.IsNullOrEmpty(callState.Request.方法名称))
{
throw LogUtil.ExceptionAndLog(callState, "ASHX服务的方法名称必须填写", "", binding, request);
}
//--STEP.3.构造HTTP请求并调用ASHX服务
ESB.Core.Schema.服务响应 response = new ESB.Core.Schema.服务响应();
try
{
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uri);
webRequest.Accept = contentType;
webRequest.Method = "POST";
webRequest.ContentType = contentType;
webRequest.Timeout = callState.ServiceConfig.Timeout;
webRequest.Headers.Add("Accept-Encoding", "gzip");
webRequest.Headers.Add(Constant.ESB_HEAD_TRACE_CONTEXT, callState.TraceContext.ToString());
webRequest.Headers.Add(Constant.ESB_HEAD_ANVOKE_ACTION, callState.Request.方法名称);
//--STEP.3.1.如果是POST请求，则需要将消息内容发送出去
if (!String.IsNullOrEmpty(message))
{
byte[] data = System.Text.Encoding.UTF8.GetBytes(message);
using (Stream stream = webRequest.GetRequestStream())
{
stream.Write(data, 0, data.Length);
}
}
//--STEP.3.2.获取到响应消息
callState.CallBeginTime = DateTime.Now;
HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse();
String contentEncoding = webResponse.ContentEncoding.ToLower();
callState.ServiceBeginTime = webResponse.Headers[Constant.ESB_HEAD_SERVICE_BEGIN];
callState.ServiceEndTime = webResponse.Headers[Constant.ESB_HEAD_SERVICE_END];
if (String.IsNullOrEmpty(contentEncoding))
{
using (Stream newstream = webResponse.GetResponseStream())
{
using (StreamReader srRead = new StreamReader(newstream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = outString;
srRead.Close();
}
}
}
else if (contentEncoding.Contains("gzip"))
{
using (GZipStream stream = new GZipStream(webResponse.GetResponseStream(), CompressionMode.Decompress))
{
using (StreamReader srRead = new StreamReader(stream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = outString;
srRead.Close();
}
}
}
else if (contentEncoding.Contains("deflate"))
{
using (DeflateStream stream = new DeflateStream(webResponse.GetResponseStream(), CompressionMode.Decompress))
{
using (StreamReader srRead = new StreamReader(stream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = outString;
srRead.Close();
}
}
}
else
{
using (Stream newstream = webResponse.GetResponseStream())
{
using (StreamReader srRead = new StreamReader(newstream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = outString;
srRead.Close();
}
}
}
//--STEP.3.3.记录日志并返回ESB响应
LogUtil.AddAuditLog(
1
, binding
, callState
, response.消息内容, request);
}
catch (Exception ex)
{
callState.CallEndTime = DateTime.Now;
String exMessage = String.Empty;
if (ex.InnerException != null)
exMessage = ex.InnerException.Message;
else
exMessage = ex.Message;
throw LogUtil.ExceptionAndLog(callState, "调用目标服务抛出异常", exMessage, binding, request);
}
return response;
}
public static ESB.Core.Schema.服务响应 CallWebService(CallState callState)
{
//--STEP.1.从CallState中获取到需要的信息
ESB.Core.Schema.服务请求 request = callState.Request;
String message = callState.Request.消息内容;
BindingTemplate binding = callState.Binding;
String uri = callState.Binding.Address;
callState.Request.方法名称 = GetMethodName(callState.Request.方法名称);
//--STEP.3.构造HTTP请求并调用ASHX服务
ESB.Core.Schema.服务响应 response = new ESB.Core.Schema.服务响应();
try
{
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uri);
webRequest.Method = "POST";
webRequest.ContentType = "text/xml; charset=utf-8";
webRequest.Timeout = callState.ServiceConfig.Timeout;
webRequest.Headers.Add("Accept-Encoding", "gzip, deflate");
webRequest.Headers.Add(Constant.ESB_HEAD_TRACE_CONTEXT, callState.TraceContext.ToString());
webRequest.Headers.Add(Constant.ESB_HEAD_ANVOKE_ACTION, callState.Request.方法名称);
if (String.IsNullOrEmpty(callState.Request.方法名称))
{
throw LogUtil.ExceptionAndLog(callState, "WCF-HTTP服务的方法名称必须填写", "", binding, request);
}
else
{
webRequest.Headers.Add("SOAPAction", String.Format("{0}/EsbAction", Constant.COMPANY_URL));
}
//--STEP.3.1.如果是POST请求，则需要将消息内容发送出去
//if (!String.IsNullOrEmpty(message))
{
String reqMessage = CommonUtil.XmlEncoding(request.消息内容);
String esbAction = request.方法名称;
String soapMessage = String.Format(SOAP_MESSAGE_TEMPLATE, Constant.COMPANY_URL, reqMessage);
byte[] data = System.Text.Encoding.UTF8.GetBytes(soapMessage);
using (Stream stream = webRequest.GetRequestStream())
{
stream.Write(data, 0, data.Length);
}
}
//--STEP.3.2.获取到响应消息
callState.CallBeginTime = DateTime.Now;
HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse();
//--从返回头消息中取到服务调用的时间
callState.ServiceBeginTime = webResponse.Headers[Constant.ESB_HEAD_SERVICE_BEGIN];
callState.ServiceEndTime = webResponse.Headers[Constant.ESB_HEAD_SERVICE_END];
if (webResponse.ContentEncoding.ToLower().Contains("gzip"))
{
using (GZipStream stream = new GZipStream(webResponse.GetResponseStream(), CompressionMode.Decompress))
{
using (StreamReader srRead = new StreamReader(stream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = GetMessageFromSOAP(outString);
srRead.Close();
}
}
}
else if (webResponse.ContentEncoding.ToLower().Contains("deflate"))
{
using (DeflateStream stream = new DeflateStream(webResponse.GetResponseStream(), CompressionMode.Decompress))
{
using (StreamReader srRead = new StreamReader(stream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = GetMessageFromSOAP(outString);
srRead.Close();
}
}
}
else
{
using (Stream newstream = webResponse.GetResponseStream())
{
using (StreamReader srRead = new StreamReader(newstream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = GetMessageFromSOAP(outString);
srRead.Close();
}
}
}
//--STEP.3.3.记录日志并返回ESB响应
LogUtil.AddAuditLog(
1
, binding
, callState
, response.消息内容, request);
}
catch (Exception ex)
{
callState.CallEndTime = DateTime.Now;
String exMessage = String.Empty;
if (ex.InnerException != null)
exMessage = ex.InnerException.Message;
else
exMessage = ex.Message;
throw LogUtil.ExceptionAndLog(callState, "调用目标服务抛出异常", exMessage, binding, request);
}
return response;
}
/// <summary>
/// 利用反射调用目标服务
/// </summary>
/// <param name="url"></param>
/// <param name="request"></param>
/// <returns></returns>
internal static ESB.Core.Schema.务响应 CallWebService(CallState state)
{
CallState callState = state as CallState;
BindingTemplate binding = callState.Binding;
ESB.Core.Schema.务请求 request = callState.Request;
SoapClientItem soapClient = null;
try
{
soapClient = SoapClientCache.GetItem(binding.Address, request.务名称);
}
catch (Exception ex)
{
throw LogUtil.ExceptionAndLog(callState, "获取目标服务的代理程序集时发生异常", ex.Message, binding, request);
}
if (soapClient != null)
{
MethodInfo method = soapClient.GetMethodInfo(request.方法名称);
if (method == null)
{
throw LogUtil.ExceptionAndLog(callState, "目标服务未实现方法", request.方法名称, binding, request);
}
Object req = GetRequest(soapClient, request);
if (req == null)
{
throw LogUtil.ExceptionAndLog(callState, "无法将请求转换成目标服务所需要的输入参数", "", binding, request);
}
Object res = null;
try
{
callState.CallBeginTime = DateTime.Now;
res = method.Invoke(soapClient.PortObject, new Object[] { req });
callState.CallEndTime = DateTime.Now;
}
catch (Exception ex)
{
callState.CallEndTime = DateTime.Now;
String message = String.Empty;
if (ex.InnerException != null)
{
message = ex.InnerException.Message;
}
else
{
message = ex.Message;
}
throw LogUtil.ExceptionAndLog(callState, "调用目标服务抛出异常", message, binding, request);
}
ESB.Core.Schema.务响应 response = GetResponse(res, method.ReturnType);
LogUtil.AddAuditLog(
1
, binding
, callState.RequestBeginTime, callState.RequestEndTime, callState.CallBeginTime, callState.CallEndTime
, response.消息内容, request);
return(response);
}
else
{
throw LogUtil.ExceptionAndLog(callState, "获取目标服务的代理程序集失败！", "", binding, request);
}
}
/// <summary>
/// 调用主流程
/// </summary>
/// <param name="callState"></param>
/// <returns></returns>
public static ESB.Core.Schema.务响应 CallRestfulService(CallState callState)
{
//--STEP.1.从CallState中获取到需要的信息
ESB.Core.Schema.务请求 request = callState.Request;
String message = callState.Request.消息内容;
BindingTemplate binding = callState.Binding;
String uri = callState.Binding.Address.TrimEnd('/');
String contentType = Constant.CONTENT_TYPE_JSON;
String method = "POST";
String methodName = String.Empty;
String[] methodParams = callState.Request.方法名称.Split(":");
if (methodParams.Length == 1)
{
method = "POST";
methodName = methodParams[0];
contentType = Constant.CONTENT_TYPE_JSON;
}
else if (methodParams.Length == 2)
{
method = methodParams[0];
methodName = methodParams[1];
contentType = Constant.CONTENT_TYPE_JSON;
}
else if (methodParams.Length == 3)
{
method = methodParams[0];
methodName = methodParams[2];
contentType = String.Compare("JSON", methodParams[1], true) == 0 ? Constant.CONTENT_TYPE_JSON : Constant.CONTENT_TYPE_XML;
}
//contentType = Constant.CONTENT_TYPE_JSON;
//--STEP.2.根据method拼接URL
if (method.ToUpper() == "GET")
{
message = message.Trim();
if (message.StartsWith("{"))//--如果参数以大括弧开头，说明是JSON参数，需要转化成QueryString
{
message = JsonToQueryString(message);
}
uri = uri + "/" + methodName + "?" + message;
}
else
{
uri = uri + "/" + methodName;
}
//uri = "http://10.100.20.180:8016/" + methodName + "?format=json";
//uri = "http://localhost:8080/" + methodName;// +"?format=json";
//--STEP.3.构造HTTP请求并调用RESTful服务
ESB.Core.Schema.务响应 response = new ESB.Core.Schema.务响应();
try
{
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uri);
webRequest.Accept = contentType;
webRequest.Method = method;
webRequest.ContentType = contentType;
webRequest.Timeout = callState.ServiceConfig.Timeout;
webRequest.Headers.Add(Constant.ESB_HEAD_TRACE_CONTEXT, callState.TraceContext.ToString());
//--STEP.3.1.如果是POST请求，则需要将消息内容发送出去
if (method == "POST" && !String.IsNullOrEmpty(message))
{
byte[] data = System.Text.Encoding.UTF8.GetBytes(message);
using (Stream stream = webRequest.GetRequestStream())
{
stream.Write(data, 0, data.Length);
}
}
//--STEP.3.2.获取到响应消息
callState.CallBeginTime = DateTime.Now;
HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse();
//--从返回头消息中取到服务调用的时间
callState.ServiceBeginTime = webResponse.Headers[Constant.ESB_HEAD_SERVICE_BEGIN];
callState.ServiceEndTime = webResponse.Headers[Constant.ESB_HEAD_SERVICE_END];
using (Stream newstream = webResponse.GetResponseStream())
{
using (StreamReader srRead = new StreamReader(newstream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = outString;
srRead.Close();
}
}
//--STEP.3.3.记录日志并返回ESB响应
LogUtil.AddAuditLog(
1
, binding
, callState
, response.消息内容, request);
}
catch (Exception ex)
{
callState.CallEndTime = DateTime.Now;
String exMessage = String.Empty;
if (ex.InnerException != null)
{
exMessage = ex.InnerException.Message;
}
else
{
exMessage = ex.Message;
}
throw LogUtil.ExceptionAndLog(callState, "调用目标服务抛出异常", exMessage, binding, request);
}
return(response);
}
/// <summary>
/// 抛出异常并写日志, 并需要记录异常的时间
/// </summary>
/// <param name="message"></param>
/// <param name="binding"></param>
/// <param name="request"></param>
public static Exception ExceptionAndLog(CallState state, String exceptionDesc, String message, BindingTemplate binding, ESB.Core.Schema.服务请求 request)
{
String messageID = String.Empty;
String exceptionMessage = String.Format("{0}：{1}", exceptionDesc, message);
if (state.CallBeginTime.Year != DateTime.Now.Year) state.CallBeginTime = DateTime.Now;
if (state.CallEndTime.Year != DateTime.Now.Year) state.CallEndTime = DateTime.Now;
if (binding != null)
messageID = AddAuditLog(0, binding, state , exceptionMessage, request);
else
messageID = AddAuditLog(0, "00000000-0000-0000-0000-000000000000"
, String.Empty, string.Empty, state, exceptionMessage, request);
ExceptionCoreTb exception = new ExceptionCoreTb()
{
ExceptionID = Guid.NewGuid().ToString(),
BindingTemplateID = binding == null ? "" : binding.TemplateID,
BindingType = 0,
Description = exceptionDesc,
ExceptionCode = String.Empty,
ExceptionInfo = exceptionMessage,
ExceptionLevel = 0,
ExceptionStatus = 0,
ExceptionTime = DateTime.Now,
ExceptionType = 0,
HostName = request.主机名称,
MessageBody = request.消息内容,
MessageID = messageID,
MethodName = request.方法名称,
RequestPwd = request.密码,
RequestType = 0
};
//exception.Insert();
ESBProxy.GetInstance().MessageQueueClient.SendExceptionMessage(exception);
return new Exception(message);
}
public static ESB.Core.Schema.服务响应 CallDubboService(CallState callState)
{
//--STEP.1.从CallState中获取到需要的信息
ESB.Core.Schema.服务请求 request = callState.Request;
String message = callState.Request.消息内容;
BindingTemplate binding = callState.Binding;
String uri = callState.Binding.Address.TrimEnd('/');
String contentType = Constant.CONTENT_TYPE_JSON;
String method = "POST";
String methodName = String.Empty;
String[] methodParams = callState.Request.方法名称.Split(":");
if (methodParams.Length == 1)
{
method = "POST";
methodName = methodParams[0];
contentType = Constant.CONTENT_TYPE_JSON;
}
else if (methodParams.Length == 2)
{
method = methodParams[0];
methodName = methodParams[1];
contentType = Constant.CONTENT_TYPE_JSON;
}
else if (methodParams.Length == 3)
{
method = methodParams[0];
methodName = methodParams[2];
contentType = String.Compare("JSON", methodParams[1], true) == 0 ? Constant.CONTENT_TYPE_JSON : Constant.CONTENT_TYPE_XML;
}
//--STEP.2.统一采用POST方法调用Dubbo服务
if (method.ToUpper() == "GET")
{
uri = uri + "?method=" + methodName + "¶m=" + HttpUtility.UrlEncode(message);
}
else
{
uri = uri + "?method=" + methodName;
}
contentType = Constant.CONTENT_TYPE_FROM;
//--STEP.3.构造HTTP请求并调用RESTful服务
ESB.Core.Schema.服务响应 response = new ESB.Core.Schema.服务响应();
try
{
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uri);
webRequest.Accept = contentType;
webRequest.Method = method;
webRequest.ContentType = contentType;
webRequest.Timeout = callState.ServiceConfig.Timeout;
webRequest.Headers.Add(Constant.ESB_HEAD_TRACE_CONTEXT, callState.TraceContext.ToString());
message = "param=" + HttpUtility.UrlEncode(message);
//--STEP.3.1.如果是POST请求，则需要将消息内容发送出去
if (method == "POST" && !String.IsNullOrEmpty(message))
{
byte[] data = System.Text.Encoding.UTF8.GetBytes(message);
using (Stream stream = webRequest.GetRequestStream())
{
stream.Write(data, 0, data.Length);
}
}
//--STEP.3.2.获取到响应消息
callState.CallBeginTime = DateTime.Now;
HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse();
//--从返回头消息中取到服务调用的时间
callState.ServiceBeginTime = webResponse.Headers[Constant.ESB_HEAD_SERVICE_BEGIN];
callState.ServiceEndTime = webResponse.Headers[Constant.ESB_HEAD_SERVICE_END];
using (Stream newstream = webResponse.GetResponseStream())
{
using (StreamReader srRead = new StreamReader(newstream, System.Text.Encoding.UTF8))
{
String outString = srRead.ReadToEnd();
callState.CallEndTime = DateTime.Now;
response.消息内容 = outString;
srRead.Close();
}
}
//--STEP.3.3.记录日志并返回ESB响应
LogUtil.AddAuditLog(
1
, binding
, callState
, response.消息内容, request);
}
catch (Exception ex)
{
callState.CallEndTime = DateTime.Now;
String exMessage = String.Empty;
if (ex.InnerException != null)
exMessage = ex.InnerException.Message;
else
exMessage = ex.Message;
throw LogUtil.ExceptionAndLog(callState, "调用目标服务抛出异常", exMessage, binding, request);
}
return response;
}
/// <summary>
/// 增加审计日志
/// </summary>
public static String AddAuditLog(int status
, BindingTemplate binding
, CallState callState
, String message
, ESB.Core.Schema.服务请求 request
, Int32 isCache = 0)
{
return AddAuditLog(status, binding.TemplateID, binding.ServiceID, binding.Address
, callState
, message, request, isCache);
}
/// <summary>
/// 增加审计日志
/// </summary>
public static String AddAuditLog(int status
, String bindingTemplateID
, String serviceID
, String address
, CallState callState
, String message
, ESB.Core.Schema.务请求 request
, Int32 isCache = 0)
{
callState.RequestEndTime = DateTime.Now;
TimeSpan ReqTimeSpan = callState.RequestEndTime.Subtract(callState.RequestBeginTime);
ConfigurationManager cm = ConfigurationManager.GetInstance();
String consumerIP = cm.LocalIP;
if (callState.InvokeParam != null && !String.IsNullOrWhiteSpace(callState.InvokeParam.ConsumerIP))
{
consumerIP = callState.InvokeParam.ConsumerIP;
}
Int32 isQueue = 0;
if (callState.InvokeParam != null)
{
isQueue = callState.InvokeParam.IsQueue;
}
AuditBusiness log = new AuditBusiness()
{
OID = Guid.NewGuid().ToString(),
HostName = request.主机名称,
ServiceName = request.务名称,
MethodName = request.方法名称,
ReqBeginTime = callState.RequestBeginTime.ToString("yyyy-MM-dd HH:mm:ss.ffffff"),
ReqEndTime = callState.RequestEndTime.ToString("yyyy-MM-dd HH:mm:ss.ffffff"),
Status = status,
MessageID = callState.MessageID,
MessageBody = request.消息内容,
CallBeginTime = callState.CallBeginTime.ToString("yyyy-MM-dd HH:mm:ss.ffffff"),
CallEndTime = callState.CallEndTime.ToString("yyyy-MM-dd HH:mm:ss.ffffff"),
BindingTemplateID = bindingTemplateID,
ServiceID = serviceID,
BindingAddress = address,
ReturnMessageBody = message,
BusinessName = "",
BusinessID = "",
ServiceBeginTime = callState.ServiceBeginTime,
ServiceEndTime = callState.ServiceEndTime,
TraceID = callState.TraceContext.TraceID,
InvokeLevel = callState.TraceContext.InvokeLevel,
InvokeOrder = callState.TraceContext.InvokeOrder,
InvokeID = callState.TraceContext.InvokeID,
InvokeTimeSpan = ReqTimeSpan.TotalMilliseconds,
ConsumerIP = consumerIP,
Version = callState.ServiceVersion,
IsCache = isCache,
IsQueue = isQueue
};
//log.Insert();
//String mqHost = ESBProxy.GetInstance().ESBConfig.Monitor[0].Uri;
//MSMQUtil.SendMessage<AuditBusiness>(log, String.Format(@"FormatName:DIRECT=TCP:{0}\Private$\EsbAuditQueue", "192.168.56.2"));
ESBProxy.GetInstance().MessageQueueClient.SendAuditMessage(log);
//--每调用完一次需要增加调用次数
callState.TraceContext.IncreaseInvokeOrder();
return(log.OID);
}
