/// <summary>
/// 将目标服务响应转换成标准的ESB响应
/// </summary>
/// <param name="target"></param>
/// <param name="type"></param>
/// <returns></returns>
private static ESB.Core.Schema.服务响应 GetResponse(object target, Type type)
{
ESB.Core.Schema.服务响应 response = new ESB.Core.Schema.服务响应();
if (target != null)
{
response.消息内容 = type.InvokeMember("消息内容", BindingFlags.GetProperty, null, target, null) as String;
response.消息类型 = type.InvokeMember("消息类型", BindingFlags.GetProperty, null, target, null) as String;
response.返回消息编码 = type.InvokeMember("返回消息编码", BindingFlags.GetProperty, null, target, null) as String;
}
else
{
response.消息内容 = "返回消息为NULL";
response.消息类型 = String.Empty;
response.返回消息编码 = String.Empty;
}
response.返回服务时间 = DateTime.Now;
return response;
}
/// <summary>
/// 将目标服务响应转换成标准的ESB响应
/// </summary>
/// <param name="target"></param>
/// <param name="type"></param>
/// <returns></returns>
private static ESB.Core.Schema.服务响应 GetResponse(object target, Type type)
{
ESB.Core.Schema.服务响应 response = new ESB.Core.Schema.服务响应();
if (target != null)
{
response.消息内容 = type.InvokeMember("消息内容", BindingFlags.GetProperty, null, target, null) as String;
response.消息类型 = type.InvokeMember("消息类型", BindingFlags.GetProperty, null, target, null) as String;
response.返回消息编码 = type.InvokeMember("返回消息编码", BindingFlags.GetProperty, null, target, null) as String;
}
else
{
response.消息内容 = "返回消息为NULL";
response.消息类型 = String.Empty;
response.返回消息编码 = String.Empty;
}
response.返回服务时间 = DateTime.Now;
return response;
}
/// <summary>
/// 返回多个路由地址的默认响应
/// </summary>
/// <param name="target"></param>
/// <param name="type"></param>
/// <returns></returns>
private static ESB.Core.Schema.服务响应 GetMultiResponse()
{
ESB.Core.Schema.服务响应 response = new ESB.Core.Schema.服务响应();
response.消息内容 = "此服务为发布订阅模式，请求已经交给ESB处理！";
response.消息类型 = String.Empty;
response.返回服务时间 = DateTime.Now;
response.返回消息编码 = String.Empty;
return response;
}
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>
/// <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);
}
}
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>
/// 调用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;
}
