/// <summary>
/// 数据接收处理
/// </summary>
/// <param name="entity">数据实体</param>
protected virtual void OnReceive(ICommunicationEntity entity)
{
if (ReceiveCount == long.MaxValue)
{
WriteInfo(string.Format("数据接收计数器达到最大值，计数器清空"));
ReceiveCount = 0;
}
System.Threading.Interlocked.Increment(ref ReceiveCount);
if (!LogicFactory.SubscribeDic.ContainsKey(entity.FindKey))
{
return;
}
foreach (var logic in LogicFactory.SubscribeDic[entity.FindKey])
{
try
{
var logicEntity = OnConvertToLogic(entity);
Dowork(logic, entity, logicEntity);
}
catch (Exception ex)
{
FrameworkLogWrite.WriteError(ex, string.Format("逻辑处理队列:{0},运行任务时发生未捕获异常", logic.FindKey));
}
}
}
public override void GivebackEntity(ICommunicationEntity entity)
{
if (_entitiesPool.Count > MaxCount)
{
return;
}
var mqEntity = entity as MqComunicationEntity;
if (mqEntity == null)
{
return;
}
_entitiesPool.Add(mqEntity);
}
/// <summary>
/// 处理下行数据逻辑
/// </summary>
public void Dowork(ICommunicationEntity messge, ILogicEntity entity)
{
if (entity == null)
{
return;
}
var logicEntity = (FromIncomBufferEntity)entity;
if (logicEntity.Buffer == null)
{
return;
}
PubulisMesssage(logicEntity.Buffer);
}
public ILogicEntity Convert(ICommunicationEntity entity)
{
try
{
return(OnConvert(entity as IFixBufferEntity));
}
finally
{
// 数据还池
if (Service != null)
{
Service.CommunicateFactory.GivebackEntity(entity);
}
}
}
/// <summary>
/// 处理上行数据逻辑
/// </summary>
/// <param name="messge">原消息</param>
/// <param name="obj">通信实体对象</param>
public void Dowork(ICommunicationEntity messge, ILogicEntity obj)
{
if (obj == null)
{
return;
}
var logicEntity = (FromInComEntity)obj;
if (logicEntity.RealEntity == null)
{
return;
}
PubulisMesssage(logicEntity.RealEntity);
}
public void Convert(ICommunicationEntity communicationEntity, ILogicEntity entity)
{
try
{
var cEntity = communicationEntity as TCEntity;
OnConvert(cEntity, entity as TLEntity);
SetRouteing(cEntity, entity as TLEntity);
}
finally
{
if (Service != null && Service.CommunicateFactory != null)
{
Service.CommunicateFactory.GivebackEntity(communicationEntity);
}
}
}
public void Push(ICommunicationEntity entity)
{
var baseEntity = entity as BufferEntity;
if (baseEntity == null)
{
return;
}
var mqEntity = (MqComunicationEntity)entity;
var exchangeName = mqEntity.ExchangeName;
var routingKey = mqEntity.RouteingKey;
exchangeName = string.IsNullOrEmpty(exchangeName) ? _mqConfig.ExchangeName : exchangeName;
routingKey = string.IsNullOrEmpty(routingKey)
? string.IsNullOrEmpty(_mqConfig.RouteingKey) ? _mqConfig.BindKey : _mqConfig.RouteingKey
: routingKey;
try
{
Initialize();
var bytes = new byte[baseEntity.BytesLength];
Array.Copy(baseEntity.Bytes, 0, bytes, 0, bytes.Length);
// 发布消息
_writeChannel.BasicPublish(exchangeName, routingKey, _properties, bytes);
}
catch (Exception ex)
{
if (ExcptionCallback != null)
{
ExcptionCallback(this, ex, string.Format("mq 发布消息失败!"));
}
ClearChannel();
errorTimes++;
// 错误次数超过3次，重新创建连接
if (errorTimes > 3)
{
ClearConnection();
}
}
finally
{
_factory.GivebackEntity(baseEntity);
}
}
/// <summary> /// 归还一个通信实体 /// </summary> /// <param name="entity"></param> public abstract void GivebackEntity(ICommunicationEntity entity);
/// <summary>
/// 执行对应逻辑指令
/// </summary>
/// <param name="logic">逻辑操作</param>
/// <param name="entity">通信实体</param>
/// <param name="logicEntity">逻辑实体</param>
protected virtual void Dowork(ILogicWork logic, ICommunicationEntity entity, ILogicEntity logicEntity)
{
logic.Dowork(entity, logicEntity);
}
/// <summary>
/// 从通信实体转换为逻辑实体
/// </summary>
/// <param name="entity">通信实体</param>
/// <returns>逻辑实体</returns>
protected virtual ILogicEntity OnConvertToLogic(ICommunicationEntity entity)
{
return(LogicFactory.ParseToLogic.ContainsKey(entity.FindKey) ?
LogicFactory.ParseToLogic[entity.FindKey].Convert(entity) :
LogicFactory.DefaultParseLogic.Convert(entity));
}
