/// <summary>
/// 增加审计日志
/// </summary>
public static String AddAuditLog(int status
, BindingTemplate binding
, DateTime reqBeginTime
, DateTime reqEndTime
, DateTime callBeginTime
, DateTime callEndTime
, String message
, JN.ESB.Schemas.务请求 request)
{
return(AddAuditLog(status, binding.TemplateID.ToString(), binding.ServiceID.ToString(), binding.Address.ToString()
, reqBeginTime, reqEndTime, callBeginTime, callEndTime
, message, request));
}
public const String COMPANY_URL = "http://mb.com";//--公司网址,用于SOAP协议中的基地址
/// <summary>
/// 动态调用WebService主函数
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static JN.ESB.Schemas.务响应 DynamicalCallWebService(
Boolean needResponse
, JN.ESB.Schemas.务请求 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="request"></param>
private static void InvalidRequest(JN.ESB.Schemas.务请求 request)
{
if (String.IsNullOrEmpty(request.主机名称))
{
throw LogUtil.ExceptionAndLog("主机名称必须填写！", "", request);
}
if (String.IsNullOrEmpty(request.务名称))
{
throw LogUtil.ExceptionAndLog("服务名称必须填写！", "", request);
}
if (String.IsNullOrEmpty(request.方法名称))
{
EntityList <BindingTemplate> bindings = GetBindings(request);
if (bindings == null)
{
throw LogUtil.ExceptionAndLog("方法名称必须填写！", "", request);
}
else
{
throw LogUtil.ExceptionAndLog("方法名称必须填写！", "", bindings[0], request);
}
}
//--如果用户没有传递请求时间，或则传入时间无效，则默认为当前时间
if (request.请求时间.Year != DateTime.Now.Year)
{
request.请求时间 = DateTime.Now;
}
if (String.IsNullOrEmpty(request.消息内容))
{
request.消息内容 = String.Empty;
}
if (String.IsNullOrEmpty(request.密码))
{
request.密码 = String.Empty;
}
}
/// <summary>
/// 根据服务请求获取到对应的URL绑定信息
/// </summary>
/// <param name="serviceName"></param>
/// <returns></returns>
private static EntityList <BindingTemplate> GetBindings(JN.ESB.Schemas.务请求 request)
{
String serviceName = request.务名称;
BusinessService service = BusinessService.FindByServiceName(serviceName);
if (service == null)
{
throw LogUtil.ExceptionAndLog(String.Format("服务【{0}】尚未注册！", serviceName), "", request);
}
//--查找某个服务下所有启用状态的绑定
EntityList <BindingTemplate> bings = BindingTemplate.FindAllByServiceID(service.ServiceID);
if (bings == null || bings.Count == 0)
{
throw LogUtil.ExceptionAndLog(String.Format("服务【{0}】尚未绑定任何路由地址！", serviceName), "", request);
}
return(bings);
}
/// <summary>
/// 增加审计日志
/// </summary>
public static String AddAuditLog(int status
, String bindingTemplateID
, String serviceID
, String address
, DateTime reqBeginTime
, DateTime reqEndTime
, DateTime callBeginTime
, DateTime callEndTime
, String message
, JN.ESB.Schemas.务请求 request)
{
AuditBusiness log = new AuditBusiness()
{
OID = Guid.NewGuid().ToString(),
HostName = request.主机名称,
ServiceName = request.务名称,
MethodName = request.方法名称,
ReqBeginTime = reqBeginTime.ToString("yyyy-MM-dd HH:mm:ss.fff"),
ReqEndTime = reqEndTime.ToString("yyyy-MM-dd HH:mm:ss.fff"),
Status = status,
MessageID = Guid.NewGuid().ToString(),
MessageBody = request.消息内容,
CallBeginTime = callBeginTime.ToString("yyyy-MM-dd HH:mm:ss.fff"),
CallEndTime = callEndTime.ToString("yyyy-MM-dd HH:mm:ss.fff"),
BindingTemplateID = bindingTemplateID,
ServiceID = serviceID,
BindingAddress = address,
ReturnMessageBody = message,
BusinessName = "",
BusinessID = ""
};
//log.Insert();
MQUtil.SendMessage <AuditBusiness>(log, @"WIN-02UQME9JGZD\Private$\EsbAuditQueue");
return(log.MessageID);
}
/// <summary>
/// 将请求消息转换成目标服务的输入参数
/// </summary>
/// <param name="asm"></param>
/// <param name="request"></param>
/// <returns></returns>
private static Object GetRequest(SoapClientItem soapClient, JN.ESB.Schemas.务请求 request)
{
object target = null;
try
{
target = soapClient.CreateRequestObject();
if (target != null)
{
soapClient.SetReqObjProperty(target, "主机名称", request.主机名称);
soapClient.SetReqObjProperty(target, "服务名称", request.务名称);
soapClient.SetReqObjProperty(target, "方法名称", request.方法名称);
soapClient.SetReqObjProperty(target, "消息内容", request.消息内容);
soapClient.SetReqObjProperty(target, "密码", request.密码);
soapClient.SetReqObjProperty(target, "请求时间", request.请求时间);
}
}
catch (Exception ex)
{
XTrace.WriteLine("构造请求参数失败：" + ex.Message);
}
return(target);
}
public static JN.ESB.Schemas.务响应 CallAshxService(CallState callState)
{
//--STEP.1.从CallState中获取到需要的信息
JN.ESB.Schemas.务请求 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服务
JN.ESB.Schemas.务响应 response = new JN.ESB.Schemas.务响应();
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>
/// <param name="message"></param>
/// <param name="binding"></param>
/// <param name="request"></param>
public static Exception ExceptionAndLog(String exceptionDesc, String message, BindingTemplate binding, JN.ESB.Schemas.务请求 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>
/// 抛出异常并写日志
/// </summary>
/// <param name="message"></param>
/// <param name="binding"></param>
/// <param name="request"></param>
/// <returns></returns>
public static Exception ExceptionAndLog(String exceptionDesc, String message, JN.ESB.Schemas.务请求 request)
{
return(ExceptionAndLog(exceptionDesc, message, null, request));
}
/// <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, JN.ESB.Schemas.务请求 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.RequestBeginTime, state.RequestEndTime, state.CallBeginTime, state.CallEndTime
, exceptionMessage, request);
}
else
{
messageID = AddAuditLog(0, "00000000-0000-0000-0000-000000000000"
, String.Empty, string.Empty, state.RequestBeginTime, state.RequestEndTime, state.CallBeginTime, state.CallEndTime
, exceptionMessage, request);
}
ExceptionCoreTb exception = new ExceptionCoreTb()
{
ExceptionID = Guid.NewGuid(),
BindingTemplateID = binding == null ? Guid.Empty : 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 = new Guid(messageID),
MethodName = request.方法名称,
RequestPwd = request.密码,
RequestType = 0
};
exception.Insert();
return(new Exception(message));
}
/// <summary>
/// 利用反射调用目标服务
/// </summary>
/// <param name="url"></param>
/// <param name="request"></param>
/// <returns></returns>
internal static JN.ESB.Schemas.务响应 CallWebService(CallState state)
{
CallState callState = state as CallState;
BindingTemplate binding = callState.Binding;
JN.ESB.Schemas.务请求 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);
}
JN.ESB.Schemas.务响应 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);
}
}
public static JN.ESB.Schemas.务响应 CallWcfService(CallState callState)
{
//--STEP.1.从CallState中获取到需要的信息
JN.ESB.Schemas.务请求 request = callState.Request;
String message = callState.Request.消息内容;
BindingTemplate binding = callState.Binding;
String uri = callState.Binding.Address;
//--STEP.3.构造HTTP请求并调用ASHX服务
JN.ESB.Schemas.务响应 response = new JN.ESB.Schemas.务响应();
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);
}
