DataCollectServerImpl

最新推荐文章于 2024-05-31 09:55:09 发布

luleiwd22

最新推荐文章于 2024-05-31 09:55:09 发布

阅读量383

点赞数

本文链接：https://blog.csdn.net/luleiwd22/article/details/8267825

版权

vpublic class DataCollectServerImpl extends Thread implements DataCollectServer
{
/**
* 日志对象
*/
private static Logger logger = Logger.getLogger(DataCollectServerImpl.class);

/**
* 1秒钟=1000毫秒
*/
private static final int ONESECOND = 1000;

/**
* 接收消息的数据流buff长度
* 与客户端发送消息的数据流buff长度一致。
*/
private int receiveDataLen = PortalCommonConst.DATA_LEN_2048;

/**
* 发送消息的数据流buff长度
*/
private int sendDataLen = PortalCommonConst.DATA_LEN_256;

/**
* 接收消息的数据流buff
*/
private byte[] recBuff = new byte[receiveDataLen];

/**
* 接收数据的消息包
*/
private DatagramPacket recPacket = new DatagramPacket(recBuff, receiveDataLen);

/**
* 发送消息的数据流buff
*/
private byte[] sendBuff = new byte[sendDataLen];

/**
* 发送数据的消息包
*/
private DatagramPacket sendPacket = new DatagramPacket(sendBuff, sendDataLen);

/**
* 接收发送消息的Socket
*/
private DatagramSocket datagramRecSocket = null;

/**
* 话筒数据汇聚处理对象
*/
private PerformanceServiceProc performanceServiceProc = null;

/**
* 系统话筒数据汇聚处理对象
*/
private SystemPerformanceServiceProc systemPerformanceServiceProc = null;

/**
* 告警数据汇聚处理对象
*/
private AlarmCheck alarmCheck = new AlarmCheck();

/**
* 连接告警数据汇聚处理对象
*/
private GatherConnectAlarm gatherConnectAlarm = new GatherConnectAlarm();

/**
* 连接码流数据汇聚处理对象
*/
private TraceServ traceServ = new TraceServImpl();

/**
*数据库告警数据汇聚处理对象
*/
private GatherDBAlarm gatherDBAlarm = new GatherDBAlarm();

/**
* 缓存告警数据汇聚处理对象
*/
private GatherCacheAlarm gatherCacheAlarm = new GatherCacheAlarm();

private void init()
{
logger.recordEnterMethodLog();
receiveDataLen = SystemConfig.getDataCollectSendAndRecDataLen();
recBuff = new byte[receiveDataLen];
recPacket = new DatagramPacket(recBuff, receiveDataLen);
logger.recordExitMethodLog();
}
/**
*
* 线程入口函数
*/
@Override
public void run()
{
recieveMessage();
}

/**
*
* 接收数据汇聚的处理函数。
*
*/



@SuppressWarnings("finally")
public void recieveMessage()
{
logger.recordEnterMethodLog();

DataCollect dataCollect = null;
int msgID = 0;
Object object = null;
int result = 0;
byte[] byteMsg = null;

if (null == performanceServiceProc)
{
performanceServiceProc = (PerformanceServiceProc)ContextRegistry.
getContextHolder().getBean("performanceServiceProc");
}

if (null == systemPerformanceServiceProc)
{
systemPerformanceServiceProc = (SystemPerformanceServiceProc)ContextRegistry.
getContextHolder().getBean("systemPerformanceServiceProc");
}

boolean bCreatSocketSuccess = false;

while (!bCreatSocketSuccess)
{
try
{
InetSocketAddress socketAddress = new InetSocketAddress(
SystemConfig.getDataCollectServerIp(), SystemConfig.getDataCollectServerPort());
datagramRecSocket = new DatagramSocket(socketAddress);
if (null != datagramRecSocket)
{
bCreatSocketSuccess = true;
break;
}
}
catch (SocketException sockete)
{
// 话筒服务端监听端口创建失败，等待系统刷新时间后重新创建
logger.recordErrorsLog("\n"
+ "***************************************************************************" + "\n"
+ "* *" + "\n"
+ " Current ip is " + SystemConfig.getDataCollectServerIp() + ", port is "
+ SystemConfig.getDataCollectServerPort() + "\n"
+ "* Creat socket fail, please config server Ip and port in BD! *" + "\n"
+ "* *" + "\n"
+ "***************************************************************************" + "\n");
}

try
{
Thread.sleep(SystemConfig.getRefushTime() * ONESECOND);
}
catch (InterruptedException e)
{
logger.recordErrorsLog("sleep fail");
continue;
}
}

logger.recordInfoLog("\n"
+ "***************************************************************************" + "\n"
+ "* *" + "\n"
+ " Current ip is " + SystemConfig.getDataCollectServerIp() + ", port is "
+ SystemConfig.getDataCollectServerPort() + "\n"
+ "* Creat socket Success! *" + "\n"
+ "* *" + "\n"
+ "***************************************************************************" + "\n");

// 此处用两个while的作用是，把try-catch放到里面的while外面，
// 减少系统消耗，提高效率，又能达到异常捕获的效果
while (true)
{
try
{
while (true)
{
// 如果接收消息的内存大小改变，需要重新申请和分配内存
if (SystemConfig.getDataCollectSendAndRecDataLen() != receiveDataLen)
{
init();
}

datagramRecSocket.receive(recPacket);

//结果返回值刷新
result = PortalCommonConst.RESULT_SUCCESS;

// 对收到的消息进行解包，解包不成功，消息丢弃，等待下一个消息
byteMsg = recPacket.getData();
if (null != byteMsg)
{
if (null == dataCollect)
{
dataCollect = new DataCollect();
}

result = dataCollect.revertPacket(byteMsg);
if (PortalCommonConst.RESULT_SUCCESS == result)
{
msgID = dataCollect.getMsgID();
logger.recordDebugLog("recevice msgID is " + msgID);
// 消息接收到后给对方响应
sendAck(new DataCollect(msgID, PortalCommonConst.RESULT_SUCCESS));
object = dataCollect.getObject();
}
else
{
logger.recordErrorsLog("dataCollect error");
continue;
}
}
else
{
logger.recordErrorsLog("byteMess is null");
continue;
}

// 处理消息
result = procRecMsg(msgID, object);
if (result != ErrorCodeDecode.SUCCESS)
{
logger.recordErrorsLog("ProcRecMsg method is fail. msgID=" + msgID);
}
}
}
catch (Exception e)
{
logger.recordErrorsLog(e.getMessage());
}
finally
{
continue;
}
}
}

/**
*
* 回复响应消息
*
* @param dataCollect 数据汇聚对象
*/
private void sendAck(DataCollect dataCollect)
{
logger.recordEnterMethodLog();

if (null == dataCollect)
{
logger.recordErrorsLog("dataCollect is null");
return;
}

// 填充发送的目标地址和发送的数据
sendPacket.setAddress(recPacket.getAddress());
sendPacket.setPort(recPacket.getPort());
sendPacket.setData(dataCollect.addPacket());

try
{
datagramRecSocket.send(sendPacket);
}
catch (IOException e)
{
logger.recordErrorsLog("send msg fail");
}

logger.recordExitMethodLog();
}

/**
*
* 根据数据类型进行数据汇聚
*
* @param msgID 消息ID
* @param object 接收到的消息对象
* @return result : 0成功非0失败
*/
private int procRecMsg(int msgID, Object object)
{
logger.recordEnterMethodLog();

int result = ErrorCodeDecode.SUCCESS;

//依据消息ID调用对应的数据汇聚处理函数，进行不同的业务处理
switch (msgID)
{
// 业务性能统计消息
case PortalCommonConst.PERFORMANCE_MSG_ID:
{
result = performanceServiceProc.procPerformance(object);
if (ErrorCodeDecode.SUCCESS != result)
{
logger.recordErrorsLog("procPerformance fail");
}
break;
}

//系统性能统计信息
case PortalCommonConst.SYSTEM_PERFORMANCE_MSG_ID :
{
result = systemPerformanceServiceProc.procSystemPerformance(object);
if (ErrorCodeDecode.SUCCESS != result)
{
logger.recordErrorsLog("procSystemPerformance fail");
}
break;
}

// 告警心跳消息
case PortalCommonConst.ALARM_HEARTBEAT_MSG_ID :
{
sendAck(new DataCollect(PortalCommonConst.ALARM_HEARTBEAT_MSG_ID , PortalCommonConst.RESULT_SUCCESS));
result = alarmCheck.check(object);
if (ErrorCodeDecode.SUCCESS != result)
{
logger.recordErrorsLog("Alarm heartbeat send fail");
}

break;
}

//连接异常告警
case PortalCommonConst.ALARM_CONNECT_MSG_ID :
{
sendAck(new DataCollect(PortalCommonConst.ALARM_CONNECT_MSG_ID , PortalCommonConst.RESULT_SUCCESS));
result = gatherConnectAlarm.check(object);
if (ErrorCodeDecode.SUCCESS != result)
{
logger.recordErrorsLog("Alarm connect send fail");
}

break;
}

//数据库异常告警
case PortalCommonConst.ALARM_DB_MSG_ID :
{
sendAck(new DataCollect(PortalCommonConst.ALARM_DB_MSG_ID , PortalCommonConst.RESULT_SUCCESS));
result = gatherDBAlarm.check(object);
if (ErrorCodeDecode.SUCCESS != result)
{
logger.recordErrorsLog("Alarm DB send fail");
}

break;
}

//缓存异常告警
case PortalCommonConst.ALARM_CACHE_MSG_ID :
{
sendAck(new DataCollect(PortalCommonConst.ALARM_CACHE_MSG_ID , PortalCommonConst.RESULT_SUCCESS));
result = gatherCacheAlarm.check(object);
if (ErrorCodeDecode.SUCCESS != result)
{
logger.recordErrorsLog("Alarm cache send fail");
}

break;
}

//码流异常告警
case PortalCommonConst.TRACE_COLLECTION_MSG_ID :
{
sendAck(new DataCollect(PortalCommonConst.TRACE_COLLECTION_MSG_ID , PortalCommonConst.RESULT_SUCCESS));
result = traceServ.decode(object);
if (ErrorCodeDecode.SUCCESS != result)
{
logger.recordErrorsLog("Trace send fail");
}

break;
}

default:
{
logger.recordErrorsLog("unknown msgID is " + msgID);
break;
}
}

logger.recordExitMethodLog();

return result;
}

}