之前的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)){// 反序列化失败就returnreturn;}// 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清空。然后我们定义一个