一、為什么需要自定義協議？

我們上個知識點編寫的TCP中，TCP是面向字節流的，我們怎么保證讀取上來的數據是一個完整的報文呢？其實我們寫的代碼中不能保證這個問題，所以代碼是有BUG的。TCP 叫做傳輸控制協議，也就是什么時候發送給對方，發多少，出錯了怎么辦，完全是由發送方的 TCP 協議來定！當我們使用 write() 函數向 sockfd 中寫入數據時，數據不一定已經發給對方了，它的作用其實就是用戶到內核的拷貝！這跟我們以前學的向文件中寫入是一樣的，我們將數據通過 fd 寫入到內核的緩沖區，通過操作系統向磁盤中刷新緩沖區的內容。所以真正決定網路收發的協議是由 TCP 決定的！

而對于接收緩沖區來說，我們使用 read() 讀取上來的數據就完全不確定了。所以我們在應用層就需要把協議定好，把協議定好才能更好的進行讀上來的數據的分析！

所以回到最開始的問題，我們在進行讀取的時候，怎么保證讀取上來的數據是一個完整的報文呢？對于發送方，是將數據拷貝到它的 TCP 的發送緩沖區了，我們想怎么發完全不由應用層決定，是由 TCP 決定的，所以對方在它的接收緩沖區讀上來的數據有可能是我們發送的一部分！所以對方在讀的時候，怎么保證讀到的是完整的呢？這就需要協議來進行定制了！

所以我們可以規定好通信雙方只能使用固定大小的報文，即我們自己使用自定義協議。

二、網絡版計算器

1. 基本要求

例如，我們需要實現一個服務器版的加法器。我們需要客戶端把要計算的兩個加數發過去，然后由服務器進行計算，最后再把結果返回給客戶端。

在應用層定協議，我們通常需要一個比較關鍵的字段。首先，協議本身就是一種“約定”，假設我們以實現網絡版計算器為例，那么我們需要定義的第一個協議就是 request，代表需要相加的兩個數和一個操作符，如下：

				struct request{int x;int y;char op;};

另外還需要定義另一個協議為 response，代表運算結果和正確性，如下：

				struct response{int result;int code;};

所以每一個結構體的每一個字段，每一個字段里的每一種值，我們都是要讓客戶端和服務器雙方約定好的，約定好之后，我們使用結構化的方式，把約定表達出來，這就叫做我們定義出來的協議。

2. 序列化和反序列化

當我們向對方發信息時， 不僅僅只包含我們所發的信息，還有對應的頭像，昵稱和時間等等，實際上這些都是一個個的字符串，所以對方會收到四個字符串，但是肯定不能一個個發，是要把它們看作一個整體發給對方；而對方在收到這個整體的字符串后，就要將這個整體的字符串反向的轉化成四個字符串，解析成信息內容、頭像、昵稱和時間。

那么怎么將這些信息看作一個整體呢？我們可以把需要發送的一個信息看作是一個結構體，其中這個結構體中有四個字段，分別代表上面的四個字符串；然后我們再把這個結構化的數據轉化成為一個字符串，緊接著將這個字符串整體通過網絡發送給對方主機，當對方主機收到這個字符串后，需要將這個字符串解析成為相同類型的結構化數據！在這個消息轉化的過程，也是規定出來客戶端和服務器雙方約定出來的一種通用型的結構體，這就叫做雙方定義出來的聊天協議。而在網絡通信的時候，整個結構化的數據，把它多個字符串轉化成一個字符串整體，這個過程我們稱為序列化！而對方把一個字符串整體打散稱為多個字符串這個過程稱為反序列化！

而以上的過程我們可以看作兩層，一層是協議的定制，另一層是序列化和反序列化，如下圖：

那么為什么需要進行序列和反序列化呢？主要是為了方便網絡進行收發！

所以根據我們自定義的協議和序列化反序列化，我們的網絡版計算機的簡略流程如下：

下面我們根據上圖的流程圖簡易實現一個網絡版的計算器。

3. 代碼實現

（1）封裝 socket

每次提供網絡通信都要重新編寫 socket 套接字的代碼，所以我們現在這里對 socket 進行一下簡單的封裝，代碼如下：

				#pragma once#include <iostream>#include <string>#include <cstring>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <sys/socket.h>#include <arpa/inet.h>#include <netinet/in.h>#include "log.hpp"enum{SocketErr = 2,BindErr, ListenErr,};const int backlog = 10;class Sock {public:Sock(){}~Sock(){}public:void Socket(){_sockfd = socket(AF_INET, SOCK_STREAM, 0);if(_sockfd < 0){lg(Fatal, "socket error, %s: %d", strerror(errno), errno);exit(SocketErr);}}void Bind(uint16_t port){sockaddr_in local;memset(&local, 0, sizeof(local));local.sin_addr.s_addr = INADDR_ANY;local.sin_family = AF_INET;local.sin_port = htons(port);if(bind(_sockfd, (const sockaddr*)&local, sizeof(local)) < 0){lg(Fatal, "bind error, %s: %d", strerror(errno), errno);exit(BindErr);}}void Listen(){if(listen(_sockfd, backlog) < 0){lg(Fatal, "listen error, %s: %d", strerror(errno), errno);exit(ListenErr);}}int Accept(std::string* client_ip, uint16_t* client_port){sockaddr_in peer;socklen_t len = sizeof(peer);int newfd = accept(_sockfd, (sockaddr*)&peer, &len);if(newfd < 0){lg(Warning, "accept error, %s: %d", strerror(errno), errno);return -1;}char buffer[64];inet_ntop(AF_INET, &peer.sin_addr, buffer, sizeof(buffer));*client_ip = buffer;*client_port = ntohs(peer.sin_port);return newfd;}void Close(){close(_sockfd);}bool Connect(std::string serverip, uint16_t serverport){sockaddr_in peer;memset(&peer, 0, sizeof(peer));inet_pton(AF_INET, serverip.c_str(), &(peer.sin_addr));peer.sin_family = AF_INET;peer.sin_port = htons(serverport);int n = connect(_sockfd, (const sockaddr*)&peer, sizeof(peer));if(n < 0){lg(Fatal, "connect error, %s: %d", strerror(errno), errno);return false;}return true;}int GetFd(){return _sockfd;}private:int _sockfd;};

（2）定制協議和序列化反序列化

在進行定制協議的時候，為了保證對方接受時是一個完整的報文，也就是當對方進行讀取時，對方怎么知道是一個報文多大多長呢？所以我們需要使用分隔符將報文和報文之間分隔開來，比如可以使用 \n，也就是使用 \n 對報文之間進行分隔。 但是我們在實現的時候，在報文前再加上一個字段，就是代表有效報文的長度，長度和報文之間也是使用 \n 進行分隔。那么在進行讀取的時候，在遇到第一個 \n 之前，就是該報文的長度，然后根據長度去讀取報文，就能保證讀取到一個完整的報文，當遇到第二個 \n 就代表本次讀取完畢，進行下一次讀取。

Request：

				const std::string blank_space_sep = " ";const std::string protocol_sep = "\n";// 定制協議class Request{public:Request(int x, int y, char op): _x(x), _y(y), _op(op){}Request(){}public:// 序列化bool Serialize(std::string *out){// 構建報文的有效載荷// struct => string// "len"\n"x op y"\nstd::string s = std::to_string(_x);s += blank_space_sep;s += _op;s += blank_space_sep;s += std::to_string(_y);*out = s;return true;}// 反序列化bool Deserialize(const std::string &in) // "x op y"{size_t left = in.find(blank_space_sep);if(left == std::string::npos) return false;std::string part_x = in.substr(0, left);size_t right = in.rfind(blank_space_sep);if(right == std::string::npos) return false;std::string part_y = in.substr(right + 1);if(left + 1 != right - 1) return false;_op = in[left + 1];_x = std::stoi(part_x);_y = std::stoi(part_y);return true;}void DebugPrint(){std::cout << "新請求構建完成: " << _x << _op << _y << "=?" << std::endl; }public:int _x;int _y;char _op;};

Response：

				class Response{public:Response(int result, int code): _result(result), _code(code){}Response(){}public:// 序列化bool Serialize(std::string *out){// "len"\n"result code"\nstd::string s = std::to_string(_result);s += blank_space_sep;s += std::to_string(_code);*out = s;return true;}// 反序列化bool Deserialize(const std::string &in)     // "result code"{size_t pos = in.find(blank_space_sep);if(pos == std::string::npos) return false;std::string part_left = in.substr(0, pos);std::string part_right = in.substr(pos + 1);_result = std::stoi(part_left);_code = std::stoi(part_right);return true;}void DebugPrint(){std::cout << "結果響應完成, result: " << _result << ", code: "<< _code << std::endl; }public:int _result;int _code; // 表示結果的準確性};

下面對封裝報頭和提取報文也進行簡單封裝：

				// 封裝報頭   "x op y" =>  "len"\n"x op y"\nstd::string Encode(std::string &content){std::string package = std::to_string(content.size());package += protocol_sep;package += content;package += protocol_sep;return package;}// 提取報文   "len"\n"x op y"\n => "x op y"bool Decode(std::string& package, std::string* content){size_t pos = package.find(protocol_sep);if(pos == std::string::npos) return false;std::string len_str = package.substr(0, pos);size_t len = stoi(len_str);// package = len_str + content_str + 2(\n)// size_t total_len = len_str.size() + len + 2*protocol_sep.size();size_t total_len = len_str.size() + len + 2;if(package.size() < total_len) return false;*content = package.substr(pos + 1, len);// 如果已經得到一個完整的報文，需要移除這個報文package.erase(0, total_len);return true;}

（3）客戶端

客戶端首先創建需求，然后將需求序列化，并添加報頭后通過網絡進行發送，當服務端把計算結果返回響應時，客戶端進行讀取，將數據提取報文，并反序列化得到結果。

				#include <iostream>#include <string>#include <ctime>#include <unistd.h>#include "Socket.hpp"#include "Protocol.hpp"using namespace std;void Usage(const string& str){cout << "\nUsage: " << str << " serverip serverport\n\n" << endl;}int main(int argc, char* argv[]){if(argc != 3){Usage(argv[0]);exit(0);}uint16_t server_port = stoi(argv[2]);string server_ip = argv[1];Sock _sock;_sock.Socket();bool ret = _sock.Connect(server_ip, server_port); if(!ret){cerr << "client connect error" << endl;return 1;}srand(time(nullptr));int cnt = 1;string operas = "+-*/%=^&";string inbuffer_stream;while(cnt <= 10){cout << "====================第" << cnt << "次測試......" << endl;int x = rand() % 100 + 1;usleep(1000);int y = rand() % 100;usleep(1000);char op = operas[rand() % operas.size()];Request req(x, y, op);req.DebugPrint();string package;req.Serialize(&package);package = Encode(package);std::cout << "最新請求: \n" << package;write(_sock.GetFd(), package.c_str(), package.size());char buffer[128];size_t n = read(_sock.GetFd(), buffer, sizeof(buffer));if(n > 0){buffer[n] = 0;inbuffer_stream += buffer;  // "len"\n"result code"\nstd::cout << inbuffer_stream << std::endl;string content;bool ret = Decode(inbuffer_stream, &content);   // "result code"if(!ret){cerr << "Decode err" << endl;return 2;}Response resp;ret = resp.Deserialize(content);if(!ret){cerr << "Deserialize err" << endl;return 3;}resp.DebugPrint();}cnt++;cout << "=================================" << endl;sleep(1);}_sock.Close();return 0;}

（4）計算器服務端

計算器服務端的 Calculator 方法對 package 進行提取報文，獲取到需要計算的數據，然后進行反序列化進行計算后，再根據 Response 進行序列化，最后添加報頭后返回。

				#pragma once#include <string>#include <iostream>#include "Protocol.hpp"enum{DIV_ERR = 1,MOD_ERR = 2,OP_ERR = 3};class ServerCal{public:ServerCal(){}Response CalculatorHelper(const Request &req){Response resp(0, 0);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._code = MOD_ERR;elseresp._result = req._x % req._y;}break;case '/':{if (req._y == 0)resp._code = DIV_ERR;elseresp._result = req._x / req._y;}break;default:resp._code = OP_ERR;break;}return resp;}// "len"\n"10 + 20"\nstd::string Calculator(std::string &package){std::string content;bool ret = Decode(package, &content); // content = "10 + 20"if (!ret)return "";Request req;ret = req.Deserialize(content); // x = 10, y = 20, op = '+'if (!ret)return "";content = "";Response resp = CalculatorHelper(req); // result = 30, code = 0resp.Serialize(&content);              // content = "30 0"content = Encode(content);             // content = "len"\n"30 0\n"return content;}~ServerCal(){}};

（5）TCP服務端

當TCP服務端獲取到新連接后，根據返回的sockfd就可以進行網絡通信，也就是獲取到客戶端的連接請求，緊接著我們創建子進程為其提供服務，首先進行數據讀取，將讀取到的數據每次添加到 inbuffer_stream 中，每次獲取到數據都進行調用計算器服務端的 Calculator 方法，嘗試對獲取到的數據進行處理，如果處理成功，會在 Decode 方法中將已經提取的報文移除，所以不影響下次讀取。當成功調用 Calculator 方法，就將計算結果發送回去。

				#pragma once#include <signal.h>#include <functional>#include "Socket.hpp"#include "log.hpp"using func_t = std::function<std::string(std::string &)>;class TcpServer{public:TcpServer(uint16_t port, func_t callback): _port(port), _callback(callback){}~TcpServer(){}bool InitServer(){_listen_sock.Socket();_listen_sock.Bind(_port);_listen_sock.Listen();lg(Info, "init server done");return true;}void Start(){signal(SIGCHLD, SIG_IGN);signal(SIGPIPE, SIG_IGN);while (true){// 獲取連接std::string client_ip;uint16_t client_port;int sockfd = _listen_sock.Accept(&client_ip, &client_port);if (sockfd < 0)continue;lg(Info, "accept a new link, sockfd: %d, clientip: %s, clientport: %d", sockfd, client_ip.c_str(), client_port);// 提供服務if (fork() == 0){_listen_sock.Close();std::string inbuffer_stream;// 數據計算while (true){char buffer[1280];ssize_t n = read(sockfd, buffer, sizeof(buffer));if (n > 0){buffer[n] = 0;inbuffer_stream += buffer;lg(Debug, "debug: \n%s", inbuffer_stream.c_str());while (true){// 如果解析失敗，會返回空串std::string info = _callback(inbuffer_stream);if (info.empty())break;write(sockfd, info.c_str(), info.size());}}else if (n == 0)break;elsebreak;}exit(0);}close(sockfd);}}private:uint16_t _port;Sock _listen_sock;func_t _callback;};

（6）啟動服務器

				#include "TcpServer.hpp"#include "Protocol.hpp"#include "ServerCal.hpp"using namespace std;void Usage(const string& str){cout << "\nUsage: " << str << " port\n\n" << endl;}int main(int argc, char* argv[]){if(argc != 2){Usage(argv[0]);exit(0);}uint16_t port = stoi(argv[1]);ServerCal cal;TcpServer* tsvp = new TcpServer(port, bind(&ServerCal::Calculator, &cal, std::placeholders::_1));tsvp->InitServer();tsvp->Start();return 0;}

4. 使用 JSON 進行序列化和反序列化

JSON 其實是一種幫我們進行序列化和反序列化的工具，上面的序列化和反序列化都是我們自己寫的，而現在我們可以直接使用 JSON 幫我們完成序列化和反序列化。

（1）安裝 JSON 庫

我們在 C++ 中想要使用 JSON，首先需要安裝 jsoncpp 第三方庫，在我們的云服務器上執行指令 sudo yum install jsoncpp-devel -y 即可。

安裝成功后，我們可以通過 ls /usr/include/jsoncpp/json/ 查看到我們需要的頭文件，下面我們使用到的是 json.h，但是系統默認的搜索路徑是 /usr/include/，所以我們可以在包頭文件的時候帶上路徑，也可以在編譯選項中添加。

我們也可以在 /lib64/libjsoncpp.so 路徑下找到 JSON 的第三方庫，如下：

（2）測試 JSON

下面我們簡單使用一下 JSON，我們先使用一下序列化的功能：

				int main(){Json::Value root;root["x"] = 10;root["y"] = 20;root["op"] = '*';Json::FastWriter w;string res = w.write(root);cout << res << endl;return 0;}

如上代碼，我們創建一個 Value 萬能對象，然后建立 k-v 映射關系，接下來創建一個 FastWriter 的對象，調用對象中的 write() 方法即可進行序列化，結果如下：

另外，在序列化的時候，我們還可以創建 StyledWriter 的對象，這種是按照特定風格形成的字符串，如下：

接下來我們進行反序列化，代碼如下：

				int main(){Json::Value root;root["x"] = 10;root["y"] = 20;root["op"] = '*';Json::FastWriter w;// Json::StyledWriter w;string res = w.write(root);cout << res << endl;Json::Value v;Json::Reader r;r.parse(res, v);int x = v["x"].asInt();int y = v["y"].asInt();char op = v["op"].asInt();cout << "x = " << x << ", y = " << y << ", op = " << op << endl;return 0;}

如上代碼，在反序列化中我們需要創建一個 Reader 對象，并調用對象中的 parse() 方法，該方法的第一個參數就是需要進行反序列化的字符串，第二個參數就是將反序列化后的字段需要寫入到哪個對象中，結果如下：

（3）在網絡計算器中使用 JSON

下面我們對網絡版計算器的序列化和反序列化的部分進行修改，我們在該部分添加 JSON 代碼，但是我們使用的是條件編譯，可以讓我們在自己的序列化和反序列化與 JSON 之間進行平滑的切換，代碼如下：

				#pragma once#include <iostream>#include <string>#include <jsoncpp/json/json.h>// #define USE_MYSELF 1const std::string blank_space_sep = " ";const std::string protocol_sep = "\n";// 封裝報頭   "x op y" =>  "len"\n"x op y"\nstd::string Encode(std::string &content){std::string package = std::to_string(content.size());package += protocol_sep;package += content;package += protocol_sep;return package;}// 提取報文   "len"\n"x op y"\n => "x op y"bool Decode(std::string& package, std::string* content){size_t pos = package.find(protocol_sep);if(pos == std::string::npos) return false;std::string len_str = package.substr(0, pos);size_t len = stoi(len_str);// package = len_str + content_str + 2(\n)// size_t total_len = len_str.size() + len + 2*protocol_sep.size();size_t total_len = len_str.size() + len + 2;if(package.size() < total_len) return false;*content = package.substr(pos + 1, len);// 如果已經得到一個完整的報文，需要移除這個報文package.erase(0, total_len);return true;}// 定制協議class Request{public:Request(int x, int y, char op): _x(x), _y(y), _op(op){}Request(){}public:// 序列化bool Serialize(std::string *out){#ifdef USE_MYSELF// 構建報文的有效載荷// struct => string// "len"\n"x op y"\nstd::string s = std::to_string(_x);s += blank_space_sep;s += _op;s += blank_space_sep;s += std::to_string(_y);*out = s;return true;#elseJson::Value root;root["x"] = _x;root["y"] = _y;root["op"] = _op;Json::FastWriter w;*out = w.write(root);return true;#endif}// 反序列化bool Deserialize(const std::string &in) // "x op y"{#ifdef USE_MYSELFsize_t left = in.find(blank_space_sep);if(left == std::string::npos) return false;std::string part_x = in.substr(0, left);size_t right = in.rfind(blank_space_sep);if(right == std::string::npos) return false;std::string part_y = in.substr(right + 1);if(left + 1 != right - 1) return false;_op = in[left + 1];_x = std::stoi(part_x);_y = std::stoi(part_y);return true;#elseJson::Value root;Json::Reader r;r.parse(in, root);_x = root["x"].asInt();_y = root["y"].asInt();_op = root["op"].asInt();return true;#endif}void DebugPrint(){std::cout << "新請求構建完成: " << _x << _op << _y << "=?" << std::endl; }public:int _x;int _y;char _op;};class Response{public:Response(int result, int code): _result(result), _code(code){}Response(){}public:// 序列化bool Serialize(std::string *out){#ifdef USE_MYSELF// "len"\n"result code"\nstd::string s = std::to_string(_result);s += blank_space_sep;s += std::to_string(_code);*out = s;return true;#else Json::Value root;root["result"] = _result;root["code"] = _code;Json::FastWriter w;*out = w.write(root);return true;#endif}// 反序列化bool Deserialize(const std::string &in)     // "result code"{#ifdef USE_MYSELFsize_t pos = in.find(blank_space_sep);if(pos == std::string::npos) return false;std::string part_left = in.substr(0, pos);std::string part_right = in.substr(pos + 1);_result = std::stoi(part_left);_code = std::stoi(part_right);return true;#elseJson::Value root;Json::Reader r;r.parse(in, root);_result = root["result"].asInt();_code = root["code"].asInt();return true;#endif}void DebugPrint(){std::cout << "結果響應完成, result: " << _result << ", code: "<< _code << std::endl; }public:int _result;int _code; // 表示結果的準確性};

我們可以通過在編譯選項中加上宏定義的選項，使我們更方便地選擇哪種序列化和反序列化的方式，例如 makefile 文件中：

				.PHONY:allall:servercal clientcalFlag=-DUSE_MYSELF=1Lib=-ljsoncppservercal:ServerCal.ccg++ -o $@ $^ -std=c++11 $(Lib) $(Flag)clientcal:ClientCal.cc g++ -o $@ $^ -std=c++11 $(Lib) $(Flag).PHONY:clean clean:rm -f servercal clientcal

我的博客即將同步至騰訊云開發者社區，邀請大家一同入駐：https://cloud.tencent.com/developer/support-plan?invite_code=1can36hco3ehk