数据传输的过程：

约定方案：

之前的Tcp客户端和服务端我们直接拿过来用即可，还有log.hpp等文件，然后我们的Tcp服务端只保留多进程版本：

现在我们要修改的是，如何对数据做处理，首先我们先把函数名改为handerEnter表示处理进入的逻辑，我们将以前的任务文件改名为protocol，也就是协议定制：

 准备工作做完后我们开始进行协议定制，首先我们的协议中包含请求与响应，请求就是客户让我们计算的内容，响应就是我们给出的结果和返回码：

pragma once
#include <iostream>

class Request
{
public:

public:
    //   "x op y"
    int x;
    int y;
    char op;
};

class Response
{
public:
    int exitcode;   //返回码，0表示计算成功，非0表示计算失败
    int result;     //计算结果
};

 然后我们写个构造函数初始化一下：

 我们先默认初始化为0，然后开始编写服务器中的回调函数hander:

    void handerEnter(int sock)
    {
        // 1.读取
        // 1.1 如何保证读到的消息是一个完整的请求


        // 2.对请求Request 反序列化
        // 2.1 得到一个结构化的请求对象
        Request req =    

        // 3. 计算机处理req.x  req.y   req.op
        // 3.1 得到一个结构化的响应
        Response resp;


        // 4. 对响应Response进行序列化
        // 4.1 得到了一个字符串

        // 5.然后我们再发送响应
    }

 我们有5个大步骤，首先服务端收到客户端发来的请求（就是让服务器计算某个表达式），我们第一个要保证的是如何能完整的接收客户端发来的数据，而要保证这一点可以有三个步骤（1.数据定长2.特殊符号3.自描述）这三点我们后面会讲到，能保证第一步后我们再对这个请求做去掉报头，然后做反序列化操作，一旦进行反序列化操作我们就能拿到单个的x,y,op，然后我们利用回调函数开始做计算，这个函数我们在server.cc中实现直接传入start函数，计算出来结果后我们还要发回给客户端，所以还需要将结果进行序列化操作，序列化后得到一个“x op y”的字符串，我们将这个字符串发送给客户端即可。因为我们的第3步要得到一个响应，所以我们直接搞一个回调函数：

 

这个回调函数的第一个参数是一个输入型参数，就是客户端发给我们的请求经过反序列化的对象，第二个参数是一个输出型参数，未来我们处理req的时候得到req.x,req.y,req.op然后用他们做计算，将计算结果直接放到resp中。

  void handerEnter(int sock, func_t func)
    {
        // 1.读取
        // 1.1 如何保证读到的消息是一个完整的请求


        // 2.对请求Request 反序列化
        // 2.1 得到一个结构化的请求对象
        Request req =    

        // 3. 计算机处理req.x  req.y   req.op
        // 3.1 得到一个结构化的响应
        Response resp;
        func(req,resp); //req的处理结果全部放入了resp中

        // 4. 对响应Response进行序列化
        // 4.1 得到了一个字符串

        // 5.然后我们再发送响应
    }

 有了这个回调函数，那么我们在server.cc中就直接可以根据处理好的req去填充resp:

 那么如何保证读到的消息是一个完整的请求呢？因为tcp是面向字节流的，所以我们可以明确报文和报文的边界，明确报文和报文边界有三种方式：1.定长 2.特殊符号 3.自描述，如下图：

 tcp内部是有自己的发送缓冲区和接收缓冲区的，所以我们只需要规定每个报文的大小的都是一样的，这样就明确了报文和报文边界，当然我们也可以在报文中加一个特殊的符号，用这些符号去表示报文边界，那么自描述是什么呢，其实就是我们可以规定报文的前四个字节是什么什么，后面是什么什么。（我们今天所演示的自描述就是添加报头，这个报头可以是符号也可以代表一些含义）

有了以上概念我们就可以写序列化与反序列化函数了，未来这两个函数一定是能让req和resp使用的，所以我们先给req这个类实现序列化与反序列化函数：

#define SEP " "
#define SEP_LEN strlen(SEP)

bool serialize(std::string *out)
    {
        *out = "";
        std::string x_string = std::to_string(x);
        std::string y_string = std::to_string(y);
        *out += x_string;
        *out += SEP;
        *out += op;
        *out += SEP;
        *out += y_string;
        return true;
    }

首先我们的规定是序列化后的字符串是： "x op y"的形式，所以我们将分隔符定义为空格，然后定义空格符的长度，这样以后更改会很方便。首先对out指针做初始化，因为我们不能保证给我们传的字符串是空字符串，然后我们将x和y转化为string类型让out字符串先+x，再加分隔符，再加运算符，再加分隔符最后再加y即可，这样外部的out参数就得到了序列化的数据，然后我们返回true。

bool deserialize(const std::string& in)
    {
        auto left = in.find(SEP);
        auto right = in.rfind(SEP);
        if (left==std::string::npos || right==std::string::npos)
        {
            return false;
        }
        if (left == right)
        {
            return false;
        }
        if (right - (left+SEP_LEN) != 1)
        {
            return false;
        }
        std::string x_string = in.substr(0,left);
        std::string y_string = in.substr(right+SEP_LEN);
        if (x_string.empty()) return false;
        if (y_string.empty()) return false;
        x = stoi(x_string);
        y = stoi(y_string);
        op = in[left+SEP_LEN];
        return true;
    }

反序列化也很简单，我们首先找到字符串中左边的空格和右边的空格，然后判断是否满足我们要求的格式，不满足直接返回false。满足后我们就获取序列化字符串中的x,y,op得到后保存在类内的成员变量中，然后返回true。

有了对请求的序列化和反序列化我们就可以计算了：

bool cal(const Request& req,Response& resp)
{
    //req已经有结构化完成的数据了，可以直接使用
    resp.exitcode = OK;
    resp.result = OK;
    switch (req.op)
    {
    case '+':
        resp.result = req.x + req.y;
        break;
    case '-':
        resp.result = req.x - req.y;
        break;
    case '*':
        resp.result = req.x * req.y;
        break;
    case '/':
    {
        if (req.y==0)
        {
            resp.exitcode = DIV_ZERO;
        }
        else 
        {
            resp.result = req.x / req.y;
        }
    }
    break;
    case '%':
    {
        if (req.y==0)
        {
            resp.exitcode = MOD_ZERO;
        }
        else 
        {
            resp.result = req.x % req.y;
        }
    }
    break;
    default:
        resp.exitcode = OP_ERROR;
        break;
    }
    return true;
}

 计算也很简单，首先将回应类中的返回码和结果初始化，然后利用switch判断运算符（注意：switch语句中是可以在case语句后面加大括号的，但是我们的break一定要写在大括号外面，否则就犯了C语言的错误），对于除0错误我们可以在协议头文件中设置一个错误码：

enum
{
    OK = 0,
    DIV_ZERO,
    MOD_ZERO,
    OP_ERROR
};

上面我们只是完成了请求的序列化和反序列化，我们还需要对结果的相应也做序列化与反序列化：

    //"exitcode result"
    bool serialize(std::string* out)
    {
        *out = "";
        *out+= to_string(exitcode);
        *out += SEP;
        *out+= to_string(result);
        return true;
    }
    bool deserialize(const std::string& in)
    {
        auto pos = in.find(SEP);
        if (pos==string::npos)
        {
            return false;
        }
        exitcode = stoi(in.substr(0,pos));
        result = stoi(in.substr(pos+SEP_LEN));
        return true;
    }

因为我们规定序列化的结果必须是"exitcode result"的形式，所以响应的序列化中只需要把返回码和空格和结果拼接起来即可。反序列化也很简单，就是先找到空格，然后通过空格分割出返回码和结果的字符串，然后将字符串转化为int赋值给响应类的私有成员即可，这样响应类中就保存了计算出的结果和返回码。

下面我们再写添加报头的函数，由于这个函数响应和请求都需要，所以我们直接写在协议头文件中：

#define SEP " "
#define SEP_LEN strlen(SEP)

#define LINE_SEP "\r\n"
#define LINE_SEP_LEN strlen(LINE_SEP) 


//  自定义报头："x op y" -> content_len\r\n"x op y"\r\n
//             "exitcode result" -> content_len(正文长度)\r\n"exitcode result"\r\n
const string enLength(const std::string& text)   //添加报头
{
     string send_string = to_string(text.size());
     send_string+=LINE_SEP;
     send_string+=text;
     send_string+=LINE_SEP;
     return send_string;
}

我们规定一个完整的报文必须是："x op y" -> content_len\r\n"x op y"\r\n这样的格式，就是正文长度 + \r\n(特殊符号）+正文 + \r\n，而这个函数给我们传的参数一定是正文"x op y"这样的字符串，所以我们只需要计算正文长度，然后将正文长度转化为字符串，将正文长度加上特殊符号加上正文加上特殊符号，这样就是我们规定的报文了，然后返回即可。

有了添加报头我们还需要去掉报头的函数：

bool deLength(const std::string& package,string* text)
{
     auto pos = package.find(LINE_SEP);
     if (pos==string::npos)
     {
        return false;
     }
     int len = stoi(package.substr(0,pos));
     *text = package.substr(pos+LINE_SEP_LEN,len);
     return true;
}

package参数就是一个完整报文，text是输出型参数，就是我们将去掉报头的结果放在text中返回给外界。去掉报头也很简单，先找到特殊符号，然后我们获取正文的长度，注意：我们规定完整的报文开头到第一个\r\n就是报文长度。有了报文长度后直接用substr函数就拿到了正文。拿到后返回true即可。

下面我们完善hander函数：

 void handerEnter(int sock, func_t func)
    {
        while (true)
        {
            // 1.读取
            // 1.1 如何保证读到的消息是一个完整的请求
            std::string req_str;
            //?????????
            cout<<"处理前请求的完整报文：\n"<<req_str<<endl;
            // 如果走到这里，那么可以保证req_str得到的是一个完整的请求
            string ret;
            if (!deLength(req_str, &ret))
            {
                return;
            }
            cout<<"去掉报头的请求报文：\n"<<ret<<endl;
            // 2.对请求Request 反序列化
            // 2.1 得到一个结构化的请求对象
            Request req;
            if (!req.deserialize(ret))
            {
                // 反序列化失败就return
                return;
            }
            // 3. 计算机处理req.x  req.y   req.op
            // 3.1 得到一个结构化的响应
            Response resp;
            func(req, resp);
            // 4. 对响应Response进行序列化
            // 4.1 得到了一个字符串
            std::string resp_str;
            resp.serialize(&resp_str);
            cout<<"进行序列化后的响应的字符串：\n"<<resp_str<<endl;
            // 5.然后我们再发送响应
            // 5.1构建成为一个完整的报文
            string send_string = enLength(resp_str);
            cout<<"对序列化后的响应添加报头的字符串：\n"<<send_string<<endl;
            send(sock, send_string.c_str(), send_string.size(), 0);
        }
    }

因为我们是多次给客户端发送响应，所以这里应该是个循环。然后我们除了没有保证读到的消息是一个完整的报文，其他的阶段都搞定了。假设我们已经读到一个完整的报文了，然后对请求做去掉报头操作，去掉报头后再进行反序列化操作，这样就拿到了x,y,op并且保存在req中，然后我们创建一个响应对象，调用回调函数将req中x,y,op的结果计算出来，把结果和返回码填到resp中。然后我们对resp中的返回码和结果进行序列化操作，序列化后添加报头就可以发送给客户端了，下面我们编写保证得到的是完整报文的函数：

bool recvPackage(int sock, string& inbuffer, string *text)
{
    //因为是从sock中读取数据放到text中，所以为了保险先对text清空
    (*text).clear();
    char buffer[1024];
    while (true)
    {
        ssize_t n = recv(sock,buffer,sizeof(buffer)-1,0);
        if (n>0)
        {
           buffer[n] = 0;
           inbuffer+=buffer;
           //分析处理得到一个完整的报文
           auto pos = inbuffer.find(LINE_SEP);
           if (pos==string::npos)
           {
              //没找到分隔符，一定不是完整的报文，需要继续往inbuffer中读
              continue;
           }
           int text_len = stoi(inbuffer.substr(0,pos));
           int connumber_len = to_string(text_len).size();
           int total_len = connumber_len + text_len + 2*LINE_SEP_LEN;
           if (total_len > inbuffer.size())
           {
               continue;
           }
           //inbuffer.size()大于一个完整报文长度，那么inbuffer中至少有一个完整的报文
           *text = inbuffer.substr(0,total_len);
           inbuffer.erase(0,total_len);
           //读到一个完整的报文就退出
           break;
        }
        else
        {
            return false;
        }
    }
    return true;
}

首先我们要从文件描述符中读到完整的报文放在text中，所以我们保险起见先将text清空。inbuffer参数是一个支持我们持续存放报文的字符串，因为我们读取是有可能读不到一个完整的报文的，所以这些暂时用不到的报文都会放在inbuffer中。所以我们保险起见先将text清空。然后我们定义一个