/// <summary>
/// 测试队列化调用
/// </summary>
static void TestInvokeQueue()
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
ESBProxy esbProxy = ESBProxy.GetInstance();
stopWatch.Stop();
Console.WriteLine("ESBProxy Init 耗时：{0}ms。", stopWatch.ElapsedMilliseconds);;
Console.ReadKey();
stopWatch.Restart();
//esbProxy.InvokeQueue("ESB_Queue", "HelloWorld", "Tony", 0, new Core.Rpc.QueueParam()
//{
// QueueName = "ERP.Order"
//});
//esbProxy.InvokeQueue("ESB_QUEUE_20", "HelloWorld", "Queue");
esbProxy.Invoke("ESB_ASHX", "HelloAction", "Hello World");
stopWatch.Stop();
Console.WriteLine("第1次调用 耗时：{0}ms。", stopWatch.ElapsedMilliseconds);
Console.ReadKey();
}
/// <summary>
/// 向服务器发送数据
/// </summary>
/// <param name="message"></param>
/// <param name="isAsync">如过为同步调用，则在回传的是后需要释放同步信号</param>
public void SendData(CometMessageAction action, String message, Boolean isAsync = true)
{
if (m_SocketClient == null || !m_SocketClient.Connected)
{
throw new Exception("无法连接服务器！");
}
try
{
CometMessage regMessage = new CometMessage()
{
Action = action,
IsAsync = isAsync,
ClientType = m_ClientType,
ClientVersion = ESBProxy.GetInstance().Version.Replace("MB.ESB.Core ", ""),
ProcessorID = Process.GetCurrentProcess().Id,
DotNetFramworkVersion = Environment.Version.ToString(),
OSVersion = Environment.OSVersion.ToString(),
MessageBody = message
};
String dataMessage = XmlUtil.SaveXmlFromObj <CometMessage>(regMessage);
Console.WriteLine("发送数据：{0}", dataMessage);
Byte[] data = Encoding.UTF8.GetBytes(dataMessage);
m_SocketClient.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendCallback), m_SocketClient);
}
catch (Exception ex)
{
OnLostConnection(ex.ToString());
}
}
/// <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));
}
/// <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));
}
}
static void TestEsbProxy(String serviceName, String methodName = "HelloAction", String message = null, int callNum = 10, Int32 version = 0)
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
ESBProxy esbProxy = ESBProxy.GetInstance();
stopWatch.Stop();
Console.WriteLine("ESBProxy Init 耗时：{0}ms。", stopWatch.ElapsedMilliseconds);;
Console.ReadKey();
stopWatch.Restart();
String msgBody = (message == null) ? new String('A', 1024 * 10) : message;
try
{
String response = esbProxy.Invoke(serviceName, methodName, msgBody, version);
}
catch (Exception ex)
{
Console.WriteLine("调用总线发生异常：" + ex.Message);
}
stopWatch.Stop();
Console.WriteLine("第1次调用 耗时：{0}ms。", stopWatch.ElapsedMilliseconds);
Console.ReadKey();
Int64 elapsedMS = 0;
for (int i = 0; i < callNum; i++)
{
stopWatch.Restart();
String ret = esbProxy.Invoke(serviceName, methodName, msgBody, version);
stopWatch.Stop();
elapsedMS += stopWatch.ElapsedMilliseconds;
Console.WriteLine("第{0}次调用 耗时：{1}ms。", i + 2, stopWatch.ElapsedMilliseconds);
}
Console.WriteLine("排除第一次后 {0} 平均耗时：{1}ms。", callNum, elapsedMS / callNum);
Console.ReadKey();
}
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main()
{
//--初始化ESB代理类
ESBProxy.GetInstance();
//ServiceBase[] ServicesToRun;
//ServicesToRun = new ServiceBase[]
//{
// new StoreAuditService()
//};
//ServiceBase.Run(ServicesToRun);
Console.WriteLine("日志队列处理服务启动。");
RabbitQueueManager m_RabbitQueueManager = m_RabbitQueueManager = new RabbitQueueManager();
m_RabbitQueueManager.StartReceive();
Console.WriteLine("启动成功！");
}
static void Main(string[] args)
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
ESBProxy esbProxy = ESBProxy.GetInstance();
stopWatch.Stop();
Console.WriteLine("ESBProxy Init 耗时：{0}ms。", stopWatch.ElapsedMilliseconds);
Console.ReadKey();
stopWatch.Restart();
String message = esbProxy.Invoke("WXSC_WeiXinServiceForApp", "GET:XML:CollocationDetailFilter", "collocationId=11");
stopWatch.Stop();
Console.WriteLine("第1次调用 耗时：{0}ms。", stopWatch.ElapsedMilliseconds);
Console.ReadKey();
}
/// <summary>
/// 注册中心消费者客户端
/// </summary>
/// <param name="esbProxy"></param>
internal RegistryConsumerClient(ESBProxy esbProxy)
{
m_ESBProxy = esbProxy;
m_ConfigurationManager = ConfigurationManager.GetInstance();
}
protected void Application_Start(object sender, EventArgs e)
{
ESBProxy.GetInstance();
}
public void test()
{
var provider = ESBProxy.GetInstance <IVerifyAppAccountProvider>("AppConnect");
//provider.VerifyAppAccount(100002,"124", "2NupQIVJ1OIIgNJTk96j51TJKsXBwbk1z_pql2BgaBZA7fzSNdLtF8qM-8pNXIDh");
//provider.EditVerifyAppAccount(100002, "", "2NupQIVJ1OIIgNJTk96j51TJKsXBwbk1z_pql2BgaBZA7fzSNdLtF8qM-8pNXIDh");
}
/// <summary>
/// 构造函数
/// </summary>
public MessageQueueClient(ESBProxy esbProxy)
{
m_ESBProxy = esbProxy;
m_LocalMQ = new LocalMQ(this);
}
/// <summary>
/// 注册中心消费者客户端
/// </summary>
/// <param name="esbProxy"></param>
public RegistryConsumerClient(ESBProxy esbProxy)
{
m_ESBProxy = esbProxy;
m_ConfigurationManager = ConfigurationManager.GetInstance();
}
/// <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>
/// <returns></returns>
public static CacheManager GetInstance()
{
return(ESBProxy.GetInstance().CacheManager);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="esbProxy"></param>
internal CacheManager(ESBProxy esbProxy)
{
m_ESBProxy = esbProxy;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="esbProxy"></param>
internal CacheManager(ESBProxy esbProxy)
{
m_ESBProxy = esbProxy;
}
static void Main(string[] args)
{
ESBProxy esbProxy = ESBProxy.GetInstance();
Console.ReadKey();
}
