Qt网络编程-书接上文，浅谈TCP文件收发，以及心跳包
qt网络编程-书接上文，浅谈文件收发
上文Qt网络编程-从0到多线程编程中谈到 在qt中的qtcpsocket通讯的用法，接下来浅谈一下关于tcp通讯的实际应用，当然了由于是浅谈，也不能保证其功能的完整性，所以在此不能保证每一个技术细节都正确。
写在前面，只有tcp是适合于发送文件的，而udp不适合，原因也很简单，因为udp发送的信号是断断续续的，并不能保证客户端一定能收到服务器的所有包，有可能要陷入到无尽的等待中，当然可能较小的文件是可以的，但是光是在脑海中想想这个损耗应该就是不可接受的，故在此不谈udp文件收发的应用，当我想到了，可能又会写一篇。
首先我们来说套接字，也就是socket通讯的这个socket。其实我个人是很不喜欢套接字这个说法的，所谓的socket翻译成套接字这个，其实非常的难以理解，我觉得数据包这个翻译还可以，但是意思还是差点，不过既然如此我们就以数据包的形式来理解tcp就好了。
我们在通信中，可以理解tcp通信为一个数据包，然后直接从服务端发送给客户端，这样就完成了数据的传输。
是这么回事吗？
显然不是的，要考虑的问题很多
第一个，你怎么能保证一次传输数据的完整性？你发出一个包，中途可能遇到很多情况，比如断网，内存出错，或者数组超载等，如果是这样的话，那么接收到的数据就不完整了，那么组装起来的数据就会七扭八歪，失去其原有的含义。
第二个，数据在传输的过程中有没有可能错位？前面的数据传到后面去，或者后面的数据传到前面去？这些都是有可能的
第三个，如果传的是文件，又要怎么保证文件的完整性？文件可以看成是一个很长很长的二进制代码，长到需要用Mb乃至Gb来形容其文本大小
第四个，如果传的是文件，但是实际上传输的文件中是不会带有该文件的信息的，比如名字、后缀、所有者等信息，而是一个二进制的文本，这个文本的信息我们该如何获取呢？
以上这些都是可能在tcp协议中遇到的问题，就以上这些问题，也就构成了tcp实际应用中的一些常见基本构造，封包、心跳包、tcp头等等，接下来就简单聊聊该怎么实现这些功能。
1.封包
实际上在早期的cpp程序里面，数组的大小还不像现在现在用的qt那样直接动态的申请长度，而是用多少申请多少，比如我现在这个数组我需要1024个字节，那就只能一次申请1024个字节，少了还好说，剩下的大不了空着，但是如果多了，那就不好意思，直接内存溢出让整个程序崩溃。为了解决这个问题，我们在tcp发送的信息里面会适当地添加上一些指定的信号，以此来指挥接收端。
所以一个tcpsocket的长消息，我们要分为三个部分，分别是头 身 尾
一般头部就存放一些属性，比如包的长度，当前包个数，包的总个数，也可能是长度信息。身体就是内容。尾一般是一个0字符，就像制止符，单纯告诉你这条消息到此为止的。
当然，如果是自己用的包，就可以不用规定这么多，只需要在里面定义一个当前文件的总长度即可，至于多少个包，就可以自己内部规定，我就在内部规定的一个包就是1024个字节。另外因为是本地阻塞地发送tcpsoket（需要写锁实现），而且又是局域网内传输，所以不考虑沾包丢包的情况，当然了，如果是安全保密性要求高的链接，或者是网络通信，那么肯定是要求有沾包丢包的处理的，因为我还没实践，所以不讨论这种问题。
现在我们知道了发送端怎么处理，那么接收端呢？
接收端在创建一个实例来接受封包的时候，需要建立一个结构来存放期望接受的大小和以及实际接受到的大小，每轮接受固定长度，当实际接收到的数据大于等于期望大小时，这样就可以说明我们的一次t cp消息接受完成了，这大概就是tcp通讯的一个流程。
2.如何传输文件
解决完前面几个问题，现在来解决后续的问题，如何传输文件的信息呢？
其实也就和传输tcp信息一样，在已经实现了tcp通讯的前提下，我们在总的数据链上，再写一个自己定义的头，来存放一些信息，比如可以用|符分割，第一段存放xxx，第二段存放xxx，第三段存放xxx。。。以此类推，这样就可以组成一个完整的信息，一个包含了所有需要数据的信息，通过分割的方式来组成一个完整的文件。
这个就是比较简单的理论介绍，那么现在来看看实际上我们的工程该怎么写这样的文件
首先我们准备一个QtTcpBaseHandler类，这个类是我们做封包收发的基础，也是我们做客户端或者服务端的基础，它不需要有什么别的功能，只需要有基础的收发功能就行，也就是能定义头身尾，发送TCP和接收TCP消息
首先我们来定义一个头
struct MsgHeader
{
/*
头部12字节
[0] = 4;
[1] = 'H';
[2] = 'E';
[3] = 'A';
[4] = 'D';
[5] = 0;
[6] = 0;
[7] = 0;
[8] = 0;
[9] = 0;
[10] = 0;
[11] = 0;
*/
char gcBaseHeader[12] = { 0 };
/*
4字节，长度信息：内容长度+1
*/
int nMsgBodyLen = 0;
/*
预留字节
*/
char gcReserved[12] = { 0 };
};
头部的话比较简单，就是首先你要定义头的前几个字符，以此为标准，然后后续预留几个字节用来发送别的信息，这里存储的信息是5-10字节合起来代表了一个字节长度信息，最后预留第十二字节是0字符结尾，用以代表头部结束。下面来看发送信息
void SendTcp(QTcpSocket * pTcpSocket, const QByteArray &bytes)
{
/* 消息结构：头 + 内容 + 结尾符0 */
MsgHeader header;
header.nMsgBodyLen = bytes.length() + 1;
QByteArray bytesHeaderInfo((char*)&header, sizeof(MsgHeader));
pTcpSocket->write(bytesHeaderInfo);
char *pData = new char[header.nMsgBodyLen];
memset(pData, 0, header.nMsgBodyLen);
memcpy_s(pData, header.nMsgBodyLen, bytes.data(), bytes.length());
for (int i = 0; i < header.nMsgBodyLen; i += 1024)
{
pTcpSocket->write(pData + i, qMin(1024, header.nMsgBodyLen - i));
}
delete[] pData;
}
发送信息的话，就是把我们要发送的消息和头部信息组装起来，先做一个pData，这个是我们用来发送数组的一个缓冲区，先把所有的数据读到这个缓冲区内，
//缓冲区
memset(pData, 0, header.nMsgBodyLen);
memcpy_s(pData, header.nMsgBodyLen, bytes.data(), bytes.length());
再由QTcpsocket 转手发送出去，每次转发固定长度，像我们这里是固定了它的长度为1024长
//每次发送1024个字节，当然了如果没有1024个字节了就发剩下的部分就行了。
for (int i = 0; i < header.nMsgBodyLen; i += 1024)
{
pTcpSocket->write(pData + i, qMin(1024, header.nMsgBodyLen - i));
}
那这边就是发送端，是一个比较简单的结构，那么来看接收端。接收端的话，因为qt的tcpsocket通信是异步的操作，所以非常有可能导致接收包的动作会因为QThread::sleep 或者 调试阻塞等行为导致一些无法预料的异常，从而导致接收到的包发生占包，丢包，错位等情况。之前也说过了，当前这个tcp通信类只是在本地实现的，所以在头部只有一个信息，就是消息总长度。那么在接收端就需要写一个锁，当我们没有读完上一条tcp消息时，下一条消息到来之前需要阻塞（时间非常短，因为一条消息只有1024个字节，对于现在的局域网来说传输起来没有什么苦困难）
首先我们需要一个接收tcp消息的结构体如下：
typedef struct tagTCPRecvData
{
int nExpectSize = 0; // 期望大小
int nRecvedLen = 0; // 已收大小
QByteArray bytes;
void Clear()
{
nExpectSize = 0;
nRecvedLen = 0;
bytes.clear();
}
}TCPRecvData;
我们通过这个结构体来接收文件，记录当前期望大小和已接受大小，当已收大小大于等于期望大小时，接收行为结束
为了保证每次申请的结构都能智能释放和不重复读包、读包正确，这里使用了智能指针和哈希表
using SPTCPRecvData = std::shared_ptr<TCPRecvData>;
QHash<QTcpSocket*, SPTCPRecvData> g_qhsSock2RecvData;
一把同步互斥锁：
QMutex g_mtForQhsSock2RecvData;
整个读取tcp消息的函数如下：
void ReadTCPMsg(QTcpSocket * pTcpSocket, qint64 &nCountRecvedMsg, fun_Notice funNotice)
{
QMutexLocker am(&g_mtForQhsSock2RecvData);
if (!g_qhsSock2RecvData.contains(pTcpSocket))
{
SPTCPRecvData spTcpRecvData = std::make_shared<TCPRecvData>();
g_qhsSock2RecvData.insert(pTcpSocket, spTcpRecvData);
}
SPTCPRecvData spTcpRecvData = g_qhsSock2RecvData[pTcpSocket];
while (pTcpSocket->bytesAvailable() > 0)
{
if (0 == spTcpRecvData->nRecvedLen)
{
if (pTcpSocket->bytesAvailable() < sizeof(MsgHeader)) return;
QByteArray bytesHeader = pTcpSocket->read(sizeof(MsgHeader));
MsgHeader *pHeader = (MsgHeader*)(bytesHeader.data());
spTcpRecvData->nExpectSize = pHeader->nMsgBodyLen;
}
int nBytesAvailable = pTcpSocket->bytesAvailable();
if (nBytesAvailable > 0)
{
int nThisRecv = qMin(nBytesAvailable, spTcpRecvData->nExpectSize - spTcpRecvData->nRecvedLen);
spTcpRecvData->bytes += pTcpSocket->read(nThisRecv);
spTcpRecvData->nRecvedLen += nThisRecv;
// 其实就是等于，加大于号为了保险...
if (spTcpRecvData->nRecvedLen >= spTcpRecvData->nExpectSize)
{
// 通知
if (nullptr != funNotice) funNotice(spTcpRecvData->bytes);
// 重置
spTcpRecvData->Clear();
}
}
}
nCountRecvedMsg = spTcpRecvData->nRecvedLen;
}
一条锁 QMutexLocker am(&g_mtForQhsSock2RecvData);锁定当前函数，这个 QMutexLocker将保证在销毁前不重复执行当前函数。
后续就是处理具体数据的部分了，就是拆开来慢慢读写的问题，其实既然都能保证数据按队列输入了，接下来也就是考虑意外的问题，这里就没什么好说的了。
那以上这个类就是tcp通讯的收发基础，接下来就是写服务端和客户端两端，也就是应用层。
