一：重談協議

1?理解網絡協議，可以把它想象成網絡世界里的“交通規則”和“通用語言”。它是一套預先定義好的規則、標準和約定，使得不同設備、不同系統之間能夠順利地進行通信和數據交換。

我們從TCP協議上面理解一下，首先TCP服務是全雙工的，怎么理解是全雙工的呢，就是如果使用TCP服務，在客戶端或者是服務端，都有兩個緩沖區---一個是發送緩沖區，一個是接收緩沖區，我們在TCP接收發送文件不是用的是read，wirte嗎，當要接收數據時，就從接收緩沖區里讀數據交給用戶空間，也就是從內核到用戶，從而發送數據時，write函數就把用戶空間的數據拷貝到發送緩沖區里，也就是從用戶層到內核層。刷新什么的由TCP自己決定，全全交給了OS。所以TCP又叫做傳輸控制協議，里面有各種報頭來確認數據傳輸的正確性。

這個確認數據的完整性或者正確性什么的，UDP和TCP就有了各自的特點，UDP是面向報文的，相當于快遞，他就會要求傳遞報文必須是完整的，TCP是相當于自來水接水，所以呢他就有可能傳過來的數據是一段一段的，我們在報頭里就會有一些報文的長度啦，還有什么分隔符啦，分開報頭和有效載荷了什么的。而這些要求就是我們今天要說的序列化和反序列化。

二：序列化和反序列化

我們所說的協議就是一種約定，客戶端和服務端用的是同一套協議，舉個例子，假設客戶端發送請求，這個報文里面呢設置報文長度，有效載荷傳過來的數據，性別啦，年齡了等等。而服務端接收到的數據就是已經序列化好的，就是把這些數據按照一定順序排列好了給你發送過來了，接著就要把它反序列化，就是把這些存的東西一個一個的對應的從字符串里拿出來。說簡單點了就是把字符串里的內容存放在對應的結構體里。協議是一種 "約定". socket api 的接口。

實現序列化和反序列化大體上有兩種方法：

第一種就是自定義的方式，我自己規定傳過來的數據 結構是什么樣，從而讓你讀取到一個序列化好的，你可以通過反序列化拿到對應的數據，然后再返回一個序列化的結果，服務端接收到數據，也能通過反序列化拿到對應的結果

第二種方式就是用現成的?JSON 序列化 (Serialize)，將內存中的數據結構（如對象、數組、字符串、數字、布爾值等）轉換成符合 JSON 格式的字符串的過程。JSON 反序列(Deserialize)，將一個符合 JSON 格式的字符串 解析并轉換回內存中的數據結構（如對象、數組等）的過程。

三：使用序列化和反序列化實現一個簡單的網絡計算器

客戶端和服務端沒什么太大的變化。我們今天主要寫的就是一個序列化和反序列化

我們直接用一個JSON的，比較方便，但是你前提的安裝一下，

Ubuntu的：sudo yum install -y jsoncpp-devl

Centos的：sudo apt install -y jsoncpp-devl

1.我們需要構建兩個類，一個請求，一個應答

請求在發送之前，客戶端要進行序列化

請求在發送之后，服務端要進行反序列化

應答在發送之前，服務端要進行序列化

應答在發送之后，客戶端要進行反序列化

我們實現的計算器比較簡單 請求就是 一個數字 x 一個數字 再加一個符號，例子 30 + 20?

    int _x;int _y;char _oper;

然后把他進行序列化

     bool Serialize(std::string& out_string){Json::Value root;root["x"] = _x;root["y"] = _y;root["oper"] = _oper;Json::StreamWriterBuilder wb;std::unique_ptr<Json::StreamWriter> w(wb.newStreamWriter());std::stringstream ss;w->write(root, &ss);out_string = ss.str();return true;}

這個out_string ，是作為輸出型參數，把序列化的結果存進out_string

反序列化

 bool deserialize(std::string& in_string ){Json::Value root;Json::Reader reader;bool parsingSuccessful = reader.parse(in_string, root);if (!parsingSuccessful){return false;}_x = root["x"].asInt();_y = root["y"].asInt();_oper = root["oper"].asInt();return true;}

in_string 就是作為一個輸入型參數，把對應的結果存給對方就可以

應答的話就是一個結果，還有一個結果描述符，0設為正常，1設置為 / 或%? 0了等等，這些都可以自己約定。

private:int _result;int _code;

序列化和反序列化道理一致，我們就不再分開展示了。

完整的代碼Protocol.hpp

class Response
{public:Response() : _result(0), _code(0){}Response(int result, int code) : _result(result), _code(code){}~Response(){}bool Serialize(std::string& out_string){Json::Value root;root["result"] = _result;root["code"] = _code;Json::StreamWriterBuilder wg;std::unique_ptr<Json::StreamWriter>  w(wg.newStreamWriter());std::stringstream ss;w->write(root,&ss); //注意這里一個取地址，一個不取地址out_string = ss.str();return true;}bool deserialize(std::string& in_string){Json::Value root;Json::Reader reader;bool parsesucess = reader.parse(in_string,root);if(!parsesucess){std::cout<<"parseucess false"<<std::endl;return false;}_result = root["result"].asInt();_code = root["code"].asInt();return true;}int Result() const { return _result; }int Code() const { return _code; }void SetResult(int res) { _result = res;}void SetCode(int c) {_code = c;}private:int _result;int _code;
};

2.客戶端

#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>
#include <cstdlib>
#include <string>
#include "Log.hpp"
#include "Common.hpp"
#include "Protocol.hpp"using namespace LogModule;int main(int argc , char* argv[])
{if(argc != 3 ){std::cout<<"Clinet need two arguments"<<std::endl;return 1;}std::string ip = argv[1];uint16_t port = std::stoi(argv[2]);int sockfd = socket(AF_INET,SOCK_STREAM,0);if(sockfd < 0){LOG(LogLevel::ERROR) << "create scokfd false";}struct sockaddr_in peer;memset(&peer,0,sizeof(peer));peer.sin_family = AF_INET;peer.sin_port = ::htons(port);peer.sin_addr.s_addr = ::inet_addr(ip.c_str());//客戶端不用bind 綁定 ，tcp是面向連接的，connect 會自動綁定int n = ::connect(sockfd,CONV(&peer),sizeof(peer));if(n<0){LOG(LogLevel::ERROR)<<"connect false";return  1;}std::string message;while(true){int x, y;char oper;std::cout << "input x: ";std::cin >> x;std::cout << "input y: ";std::cin >> y;std::cout << "input oper: ";std::cin >> oper;Request req(x,y,oper);//序列化std::string message;req.Serialize(message);Encode(message);char inbuffer[1024];// n = ::write(sockfd, message.c_str(), message.size());n = ::send(sockfd,message.c_str(),message.size(),0);if(n > 0){//int m = ::read(sockfd, inbuffer, sizeof(inbuffer));int m =::recv(sockfd,inbuffer,sizeof(inbuffer),0);if(m > 0){inbuffer[m] = 0;std::string tmp = inbuffer;std::string content;Decode(tmp,&content);Response resp;resp.deserialize(content);std::cout<<resp.Result()<<resp.Code()<<std::endl;}elsebreak;}else break;}::close(sockfd);return 0;
}

3.服務端

TCPServer.hpp

#pragma once
#include <iostream>
#include "Common.hpp"
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <cstdlib>
#include <functional>
#include "Log.hpp"
#include "Internet.hpp"
#include "ThreadPool.hpp"#define BackWait 8using namespace LogModule;
using namespace ThreadPoolModule;
using task_t = std::function<void()>;
using handler_t = std::function<std::string(std::string& tmp)>;uint16_t defaultport = 8080;
std::string defaultip = "127.0.0.1";class TcpServer
{struct Thread {int sockfd;TcpServer* self;};
public:TcpServer(handler_t hander, uint16_t port = defaultport, std::string ip = defaultip): _port(port), _ip(ip), _isrunning(false), _listensockfd(-1),_hander(hander){}~TcpServer(){}void InitServer(){_listensockfd = ::socket(AF_INET,SOCK_STREAM,0);if(_listensockfd < 0){LOG(LogLevel::FATAL) << "create sockfd false";Die(1);}LOG(LogLevel::INFO) << "socket create success, sockfd is : " << _listensockfd;struct sockaddr_in local;bzero(&local, sizeof(local));local.sin_family = AF_INET;local.sin_port = ::htons(_port);local.sin_addr.s_addr = INADDR_ANY;// //面向連接的，還要等待隨時被連接// //所以要設置為監聽模式// 2. bindint n = ::bind(_listensockfd,CONV(&local),sizeof(local));if (n < 0){LOG(LogLevel::FATAL) << "bind error";Die(BIND_ERR);}LOG(LogLevel::INFO) << "bind success, sockfd is : " << _listensockfd;// 3. cs,tcp是面向連接的，就要求tcp隨時隨地等待被連接// tcp 需要將socket設置成為監聽狀態int m = ::listen(_listensockfd,8); if(m < 0 ){LOG(LogLevel::FATAL) <<"監聽失敗";Die(LISTEN_ERR);}LOG(LogLevel::FATAL) <<"監聽成功";}void HandlerRequest(int sockfd){char buffer[1024];std::string package;while(true){//接受消息ssize_t n = ::read(sockfd,buffer,sizeof(buffer)-1);if(n>0){buffer[n] = 0;LOG(LogLevel::DEBUG)<<"接受到消息了#:"<<buffer;package += buffer;std::string cmd_result = _hander(package);::send(sockfd, cmd_result.c_str(), cmd_result.size(), 0); // 寫入也是不完善}else if(n == 0){LOG(LogLevel::INFO) << "client quit: " << sockfd;break;}elsebreak;}}static void* ThreadHandler(void* args){//用線程也要等待回收（join） 必須等待回收的話就會阻塞，所以讓線程自己結束釋放資源pthread_detach(pthread_self());Thread* tmp = (Thread*)args;tmp->self->HandlerRequest(tmp->sockfd);return nullptr;}void Start(){_isrunning = true;while(true){struct sockaddr_in peer;socklen_t len = sizeof(peer);int sockfd = ::accept(_listensockfd,CONV(&peer),&len);//建立連接之后，這個對應的文件描述符才負責傳信（接待）if (sockfd < 0){LOG(LogLevel::WARNING) << "accept error: " << strerror(errno);continue;}LOG(LogLevel::INFO) << "accept success, sockfd is : " << sockfd;InetAddr inetaddr(peer);LOG(LogLevel::INFO) << "client info: " << inetaddr.Addr();//version 0//HandlerRequest(sockfd);// version -1 多線程版本// pid_t pid = fork();//::signal(SIGCHLD,SIG_IGN);// if(pid == 0)// {//     //子進程再創建孫子進程，子進程直接退掉，由系統進程1 來回收管理孫子進程//     //子進程和父進程 各有一張文件描述符表 文件都是通過引用計數進行管理的//     //就像管道一樣//     ::close(_listensockfd);//     if(fork() > 0)//     {//         exit(0);//     }//     HandlerRequest(sockfd);//     exit(0);// }// 給出建議父進程不要關閉文件描述符，這個設計叫權責分明// 現在語法執行沒錯，如果修改內容容易有錯// ::close(sockfd);// pid_t waitid = ::waitpid(pid,nullptr,0);// if(waitid<0)// {//     LOG(LogLevel::ERROR)<<"回收父進程失敗";// }//version 2 用多線程   // pthread_t pid;// Thread* data = new Thread;// data->self = this;// data->sockfd = sockfd;// pthread_create(&pid,nullptr,ThreadHandler,data);//version 3 線程池task_t f = std::bind(&TcpServer::HandlerRequest,this,sockfd);ThreadPool<task_t>::getInstance()->Equeue([&sockfd,this](){this->HandlerRequest(sockfd);});}}private:int _listensockfd; //這個文件描述符 只負責監聽（也就是送客人，不負責招待）uint16_t _port;std::string _ip;bool _isrunning;handler_t _hander;
};

TCPServer.cc

#include"TcpServer.hpp"
#include<memory>
#include"Log.hpp"
#include"Calculator.hpp"
#include"Protocol.hpp"
#include<functional>
#include"Daemon.hpp"using namespace LogModule;using Cal_t = std::function<Response(const Request& req)>;// using cal_fun = std::function<Response(const Request &req)>;// // package一定會有完整的報文嗎？？不一定把
// // 不完整->繼續讀
// // 完整-> 提取 -> 反序列化 -> Request -> 計算模塊，進行處理class Parse
{public:Parse(Cal_t cal):_cal(cal){}std::string Entry(std::string& package){std::string message;std::string resptr;while(Decode(package,&message)){LOG(LogLevel::DEBUG) << "Content: \n" << message;if(message.empty())break;//反序列化Request req;if(!req.deserialize(message))break;//計算std::string tmp;Response resp = _cal(req);resp.Serialize(tmp);//添加長度字段Encode(tmp);//拼接應答，這樣的話有多少個需求都會處理，最后統一返回resptr+=tmp;}return resptr;}private:Cal_t _cal;
};int main()
{//ENABLE_FILE_LOG();//Daemon(false,false);Cal cal;Parse parse([&cal](const Request& req){return cal.entry(req);});std::shared_ptr<TcpServer> tserver = std::make_shared<TcpServer>([&parse](std::string &package){return parse.Entry(package);});tserver->InitServer();tserver->Start();return 0;
}

4.計算端

#include<iostream>
#include<string>
#include<memory>
#include"Protocol.hpp"class Cal
{public:Cal(){}Response entry(const Request& req){Response resp;switch (req.Oper()){case '+':resp.SetResult(req.X() + req.Y());break;case '-':resp.SetResult(req.X() - req.Y());break;case '*':resp.SetResult(req.X() * req.Y());break;case '/':{if (req.Y() == 0){resp.SetCode(1); // 1 就是除0}else{resp.SetResult(req.X() / req.Y());}}break;case '%':{if (req.Y() == 0){resp.SetCode(2); // 2 就是mod 0}else{resp.SetResult(req.X() % req.Y());}}break;default:resp.SetCode(3);break;}return resp;}private:
};

5.Log.hpp

#pragma once#include <iostream>
#include <cstdio>
#include <string>
#include <fstream>
#include <sstream>
#include <memory>
#include <filesystem> //C++17
#include <unistd.h>
#include <time.h>
#include "Mutex.hpp"
// + 日志的可變部分(<< "hello world"namespace LogModule
{using namespace Lock;std::string CurrentTime(){time_t time_stamp=::time(nullptr);struct tm curr;localtime_r(&time_stamp, &curr);char buffer[1024];snprintf(buffer,sizeof(buffer),"%4d-%02d-%02d %02d:%02d:%02d",curr.tm_year + 1900,curr.tm_mon + 1,curr.tm_mday,curr.tm_hour,curr.tm_min,curr.tm_sec);return buffer;}enum class LogLevel{DEBUG=1,INFO,WARNING,ERROR,FATAL};std::string Level2String(LogLevel level){switch (level){case LogLevel::DEBUG:return "DEBUG";case LogLevel::INFO:return "INFO";case LogLevel::WARNING:return "WARNING";case LogLevel::ERROR:return "ERROR";case LogLevel::FATAL:return "FATAL";default:return "None";}}class LogStrategy{public:virtual ~LogStrategy() = default;virtual void SyncLog(const std::string & message) = 0 ;};class ControlStrategy : public LogStrategy{public:ControlStrategy(){}~ControlStrategy(){}void SyncLog(const std::string& message){LockGuard lockguard(_mut);std::cout<<message<<std::endl;}private:Mutex _mut;};/*std::filesystem::exists(_logpath)*/const std::string defaultlogpath = "./log/";const std::string defaultlogname = "log.txt";class FileStrategy : public LogStrategy{public:FileStrategy(const std::string& logpath=defaultlogpath,const std::string& logname = defaultlogname):_logpath(logpath),_logname(logname){LockGuard lockguard(_mut);if(std::filesystem::exists(_logpath)){return;    }try{std::filesystem::create_directories(_logpath);}catch(std::filesystem::filesystem_error& t){std::cerr<<t.what()<<std::endl;}}~FileStrategy(){}void SyncLog(const std::string& message){LockGuard lockgurad(_mut);std::string log = _logpath+_logname;std::ofstream out(log,std::ios::app);if(!out.is_open()){std::cout<<"打開失敗"<<std::endl;return;}out<<message<<"\n";out.close();}private:Mutex _mut;std::string _logpath;std::string _logname;};class Logger{public:Logger(){_strategy=std::make_shared<ControlStrategy>(); }void EnableControl(){_strategy=std::make_shared<ControlStrategy>(); }void EnableFile(){_strategy=std::make_shared<FileStrategy>();}~Logger(){}//一條完整的信息: [2024-08-04 12:27:03] [DEBUG] [202938] [main.cc] [16]class LogMessage{public:LogMessage(LogLevel level,const std::string &filename, int line,Logger& logger):_time(CurrentTime()),_level(level),_pid(::getpid()),_name(filename),_line(line),_logger(logger){std::stringstream ssbuffer;ssbuffer << "[" << _time << "] "<< "[" <<Level2String(_level) << "] "<< "[" << _pid << "] "<< "[" << _name << "] "<< "[" << _line << "] - ";_loginfo = ssbuffer.str();//std::cout<<_loginfo<<std::endl;         }template<class T>LogMessage &operator<<(const T& info){std::stringstream ss;ss<<info;_loginfo += ss.str();return *this;}~LogMessage(){if(_logger._strategy){_logger._strategy->SyncLog(_loginfo);}}private:std::string _time;LogLevel _level;;pid_t _pid;std::string _name;int _line;std::string _loginfo;Logger &_logger;};LogMessage operator()(LogLevel level, const std::string &filename, int line){return LogMessage(level, filename, line,*this);}private:std::shared_ptr<LogStrategy> _strategy;};Logger logger;
#define LOG(level) logger(level,__FILE__,__LINE__)
#define ENABLE_CONSOLE_LOG() logger.EnableControl()
#define ENABLE_FILE_LOG() logger.EnableFile()}

四 重談七層協議

五層協議： 物理層? 數據鏈路層 網絡層?應用層? 傳輸層?

七層協議：物理層? 數據鏈路層? 網絡層?應用層? 傳輸層? 會話層 表示層

五層模型是將 OSI 七層模型中的會話層、表示層和應用層這三層合并成了一個單一的應用層。

為什么這樣合并？
實際應用：在實際的 TCP/IP 協議棧中，會話管理（如建立、管理和終止會話）和數據表示（如數據加密、壓縮、格式轉換）的功能通常由應用程序本身或應用層協（如 HTTP、TLS/SSL）來實現，而不是由一個獨立的、通用的協議層來處理。也就是說應用層實現大部分，所以為了不沖突，就由用戶層自我決定。