C++ Qt TCP协议，处理粘包、拆包问题，加上数据头来处理

前言：

    tcp协议里面，除了心跳检测是关于长连接操作的处理，这个在前一篇已经提到过了，这一篇将会对tcp本身的一个问题，进行处理：那就是做网络通信大概率会遇到的问题，粘包、拆包问题，碰到这类问题对于新手来说都是比较棘手的，需要好好处理一下。

场景：

    使用tcp协议的时候：

    1、我明明发单个小包，都很正常呀，没啥问题呀，怎么我对单个小包多发几次，频率快一些，就会数据错乱了；

    2、我明明发小包都好着，怎么发打包就不行了，很奇怪呢？

    其实这2个场景你用抓包工具一抓，分析一下封包内容，就会一目了然。

原因：

    最本质的原因是tcp协议发送数据的时候，是不会告诉对方当前发送的数据包有多大的，这是协议头决定的，如果接收端用一个很大的缓冲区来接收发送端的小包的时候，就有可能一下子接收到多个小包，从而导致粘包现象；如果用一个较小的缓冲区来接收发送端的较大的数据包，也会导致一个包收不完，得分好多次才能接收完，导致拆包现象；

解决：

    要解决粘包或者拆包问题， 有如下几个方案；

    方案1：可以给数据包前后加上一些特殊标识，用来区分头尾，这个方案的缺陷是必须找好特殊标识，万一数据内容也包含特殊标识，就会导致解包错误；

    方案2：可以给数据包加上一个数据头，在数据头里面加上一个长度信息来表示整个封包的长度，通过长度来进行收包和解包；这个方案的操作是把整个包看成两部分，数据头+数据体；先收数据头，取出长度来开辟指定长度的缓冲区，先把数据头拷贝到缓冲区，接着再把剩余的数据体内容接收到缓冲区剩余区域里即可。

    方案3：可以把方案1、方案2结合起来，不过方案还是过于复杂，但也相对安全。

下面就以方案2来进行代码演示：

方案2具体细节：

    1、由于是C++实现的，可以给应用层封装一个私有协议，那就使用结构体来作为私有协议。

结构体声明如下：

enum TypeInfo
{
    HEART_CHECK_REQ, // 心跳检测请求
    HEART_CHECK_RES, // 心跳检测响应

    LOGIN_REQ, // 登录请求
    LOGIN_RES, // 登录响应

    UPLOAD_REQ, // 文件上传请求
    UPLOAD_RES, // 文本上传响应
};

struct Head
{
    int flag;
    int type;
    int len;
};

struct HeartCheckReq
{
    Head head;
    HeartCheckReq(){
        head.flag = 0; // 0 表示软件客户端，1表示硬件客户端
        head.type = HEART_CHECK_REQ;
        head.len = sizeof(HeartCheckReq);
    }
};

struct HeartCheckRes
{
    Head head;
    HeartCheckRes() {
        head.flag = 0;
        head.type = HEART_CHECK_RES;
        head.len = sizeof(HeartCheckRes);
    }
};

纯C++服务端处理如下：

收包线程函数代码：

void ServerSocket::recvAndSendThread(SOCKET client)
{
    // 循环收发包，保存长连接通信
    while (true)
    {
        /*char buffer[1024] = { 0 };
        int len_recv = recv(client, buffer, sizeof(buffer), 0);
        cout << "len_recv:" << len_recv << endl;
        if (len_recv <= 0) {
            cout << "socket收包异常:" << WSAGetLastError() << endl;
            break;
        }*/
        // 解决粘包或拆包问题
        char *head_buffer = new char[sizeof(Head)];
        int len_recv = recv(client, head_buffer, sizeof(Head), 0);
        int head_rest = sizeof(Head) - len_recv;
        while (head_rest > 0) { // 还有没收完的
            len_recv = recv(client, head_buffer+ (sizeof(Head) - head_rest),head_rest , 0);
            head_rest -= len_recv;
        }
        // 表示结构体头收完了,可以拿出总长度
        int len_total = ((Head*)head_buffer)->len;
        char *buffer = new char[len_total];
        memcpy(buffer, head_buffer, sizeof(Head)); // 先把数据头拷贝进去
        int len_rest = len_total - sizeof(Head); // 算出剩余长度
        while (len_rest > 0) {
            len_recv = recv(client, buffer + (len_total - len_rest), len_rest, 0);
            len_rest -= len_recv;
        }

        // 正常
        m_clientSockets[client] = HEART_CHECK_TIMES; // 重置心跳阈值
        cout << "buffer:" << buffer << endl;
        int type = ((Head*)buffer)->type;
        if (type == 100) {
            Data *d = (Data*)buffer;
            cout << "收到内容:" << d->data << endl;
        }
        else if (type == HEART_CHECK_REQ) {
            // 收到心跳包
            // 回一个响应包
            cout << "收到心跳请求包" << endl;
            HeartCheckRes res;
            send(client, (char*)&res, res.head.len, 0);
        }
        else if (type == UPLOAD_REQ) {
            // 上传版本文件
            cout << "收到版本管理上传文件包" << endl;
            UploadFileReq *req = (UploadFileReq*)buffer;
            cout << req->file_info.file_name << " md5:" << req->file_info.md5 << " size:" << req->file_info.file_size << endl
                << " old:" << req->file_info.old_version << endl;
            // 服务端的业务：将文件写到指定目录，并且在数据库中记录相应的信息
            // 保存了之后，回一个响应包给客户端
            UploadFileManager upload;
            upload.business(client, req);
        }
        // 将收到的数据原封不动的回给客户端
        // send(client, buffer, len_recv, 0);

        // 释放内存,防止内存泄露
        delete[] head_buffer;
        delete[] buffer;
        head_buffer = nullptr;
        buffer = nullptr;
    }
    closesocket(client); // 关闭客户端套接字
}

Qt客户端处理如下：

收包槽函数代码：

    这里要注意的是，Qt的网络通信是异步的，不能像纯windows服务端那样，使用recv来阻塞收包，所以采用了一个全局变量来存储数据包，当然也可以考虑使用静态局部变量或者成员变量来处理，本文为了表示得更加直白，选择使用了全局变量 g_allBuffer。

QByteArray g_allBuffer; // 全局缓冲区，用来保存收到的封包内容
void TcpMainWindow::myRead()
{
    QByteArray buffer =  m_client->readAll();
    g_allBuffer.append(buffer);
    int len = g_allBuffer.size();
    while(len > 0){
        if(len < sizeof(Head)) break; // 不满足数据头大小，继续收包
        int len_total = ((Head*)(g_allBuffer.data()))->len;
        if(len < len_total) break; // 不满足全部大小，继续收包
        QByteArray datas = g_allBuffer.left(len_total);  // 可能会收到多个，先拿一个出来出来
        emit unpackSignal(datas);
        g_allBuffer = g_allBuffer.mid(len_total); // 处理完了，将后面的挪到前面来
        len = g_allBuffer.size();
    }
}

解包业务槽代码如下：

void TcpMainWindow::unpackSlot(QByteArray buffer)
{
    QString buf = buffer;
    ui->label->setText(buf);
    m_heartCheckTimes = HEART_CHECK_TIMES; // 重置阈值
    int type = ((Head*)buffer.data())->type;
    if(type == 100){
        Data *d = (Data*)buffer.data();
        qDebug()<<"收到:"<<d->data;
        buf = d->data;
        ui->label->setText(buf);
    }else if(type == HEART_CHECK_RES){
        // 收到心跳响应包
        qDebug()<<"收到心跳响应包";
    }
}

最后，以上只提供了核心代码，哪里有不清楚的，可以留言谈论一些细节，也可以关注后私信给回复，可以发完整工程代码。