protected override void BeginSendMessageTask(object obj)
{
try
{
while (true)
{
if (mIsSendDataEnable == false)
{
Thread.Sleep(S_SendMessageThreadInterval);
continue;
}
if (mBaseSocketMessageManager.GetWillSendSocketData(out var message))
{
int dataLength = mClientSocket.Send(message.mSendMessageByteArray.mBytes, 0, message.mSendMessageByteArray.mDataRealLength, SocketFlags.None);
#if UNITY_EDITOR
int length = SocketHead.GetPacketLength(message.mSendMessageByteArray.mBytes, 0);
Debug.LogEditorInfor($"要发送的数据长度{message.mSendMessageByteArray.mDataRealLength} 实际发送{dataLength} byte={message.mSendMessageByteArray} 头部标识长度{length}");
#endif
OnSendMessage(message);
BaseSocketSendMessage.RecycleSocketMessageData(message); //回收数据
}
Thread.Sleep(S_SendMessageThreadInterval);
}
}
catch (ThreadAbortException e)
{
} //线程被Abort() 调用时候抛出
catch (Exception e)
{
OnSocketException($"发送消息异常{e}");
}
}
private void Update()
{
AllTcpRequestData requestData = null;
while (mAllTcpRequestDatas.TryDequeue(out requestData))
{
int protocolID = SocketHead.GetPacketProtocolID(requestData.RequestMessage, 4);
if (protocolID == ProtocolCommand.RequestHearBeat)
{
Debug.Log($"收到{requestData.mClientSocket.RemoteEndPoint} 心跳包");
HeartbeatResponse response = new HeartbeatResponse()
{
mSystemTime = System.DateTime.UtcNow.Ticks
};
string responseStr = SerializeManager.SerializeObject(response);
TcpServerUIComponent.Instance.mTcpServer.SendMessage(ProtocolCommand.ResponseHearBeat, responseStr, requestData.mClientSocket);
}
else if (protocolID == ProtocolCommand.RequestLogin)
{
string message = Encoding.UTF8.GetString(requestData.RequestMessage, SocketHead.S_HeadLength, requestData.RequestMessage.Length - SocketHead.S_HeadLength);
Debug.Log($"接收到来自{requestData.mClientSocket.RemoteEndPoint} 的登录信息{message}");
LoginRequest request = SerializeManager.DeserializeObject <LoginRequest>(message);
LoginResponse response = new LoginResponse();
response.mUserName = request.mUserName;
response.mToken = "xyz";
response.mIsSuccess = true;
string responseStr = SerializeManager.SerializeObject(response);
TcpServerUIComponent.Instance.mTcpServer.SendMessage(ProtocolCommand.ResponseLogin, responseStr, requestData.mClientSocket);
}
}
}
protected override void BeginReceiveMessageTask(object obj)
{
try
{
int receiveDataOffset = 0; // mBuffer 中需要解析或者保存的数据偏移
int packageLength = 0; //需要解析的包长度
int totalReceiveDataLength = 0; //总共接收的数据总量 (待处理的数据)
while (true)
{
if (mIsReceiveDataEnable == false)
{
Thread.Sleep(S_ReceiveMessageThreadInterval);
continue;
}
int receiveDataLength = mClientSocket.Receive(mBuffer, receiveDataOffset, S_BufferSize, SocketFlags.None);
totalReceiveDataLength += receiveDataLength;
Debug.Log($"本次 解析接收的包长度 {receiveDataLength} {totalReceiveDataLength}");
if (totalReceiveDataLength > S_BufferSize)
{
Debug.LogError($"接受的数据太多{totalReceiveDataLength} 超过{S_BufferSize}");
}
if (receiveDataLength == 0)
{
IsConnected = false;
// receiveDataOffset = streamDataLength = 0;
OnBeDisConnect($"接受到数据长度为0 断开连接{mClientSocket}");
break;
// Thread.Sleep(S_ReceiveMessageThreadInterval);
}
if (mBuffer.Length < 4)
{
continue; //确保能够获取到数据长度
}
if (packageLength == 0)
{
packageLength = SocketHead.GetPacketLength(mBuffer, 0); //避免如果上一次有一个半包数据在缓存中解析错误
}
if (totalReceiveDataLength < packageLength)
{
Debug.LogInfor($"数据没有接受完 继续等待接受{totalReceiveDataLength}-- {receiveDataOffset}--- {packageLength}");
receiveDataOffset += receiveDataLength;
continue;
} //接收到了一部分数据(分包了)
//** 接收到了几个包的消息(粘包了)
receiveDataOffset = 0; //使得能够从上一次的 mBuffer 起始位置
while (packageLength + receiveDataOffset <= totalReceiveDataLength)
{
ByteArray receiveByteArray = ByteArray.GetByteArray();
receiveByteArray.CopyBytes(mBuffer, receiveDataOffset, packageLength, 0);
if (receiveByteArray.mBytes.Length < 8)
{
break; //数据不够解析出协议id
}
int protocolId = SocketHead.GetPacketProtocolID(receiveByteArray.mBytes, 4);
Debug.Log($"解析的协议id={protocolId} 长度={receiveByteArray.mDataRealLength} ");
var receiveMessage = BaseSocketReceiveMessage.GetSocketReceiveMessageData(protocolId, receiveByteArray, mClientSocket.RemoteEndPoint);
mBaseSocketMessageManager.SaveReceiveData(receiveMessage);
OnReceiveMessage(receiveMessage);
receiveDataOffset += packageLength;
if (receiveDataOffset == totalReceiveDataLength)
{
break; //刚好是几个整包
}
packageLength = SocketHead.GetPacketLength(mBuffer, receiveDataOffset); //继续处理下一个包
} //拆包
if (receiveDataOffset < totalReceiveDataLength)
{
System.Array.Copy(mBuffer, receiveDataOffset, mBuffer, 0, totalReceiveDataLength - receiveDataOffset);
receiveDataOffset = totalReceiveDataLength - receiveDataOffset;
} //说明mBuffer 后面还有一小部分下一个包的数据需要移动到buffer 开始位置
else if (receiveDataOffset == totalReceiveDataLength)
{
receiveDataOffset = 0;
} //所有的数据刚好是整包
else
{
Debug.LogError($"不可能出现的异常");
}
packageLength = 0;
totalReceiveDataLength = receiveDataOffset;
}
Thread.Sleep(S_ReceiveMessageThreadInterval);
}
catch (ThreadAbortException e)
{
} //线程被Abort() 调用时候抛出
catch (Exception e)
{
OnSocketException($"TCP 接收数据异常{e}");
}
}
