序列化和反序列化（Linux）

1 序列化和反序列化

write和read实质是拷贝函数

1.1序列化和反序列化的概述：

2网络版计算器

2.1代码实现

先把日志拷贝过来

2.1.1必须先要有网络功能

先把 TcpServer.hpp编写号

  1. #pragma once
  2. #include 
  3.  
  4. #include "Socket.hpp"
  5. #include "./logs/ljwlog.h"
  6.  
  7. class TcpServer
  8. {
  9. public:
  10.     TcpServer()
  11.     {}  
  12.     bool InitServer()
  13.     {}
  14.     void Start()
  15.     {}
  16.  
  17.     ~TcpServer()
  18.     {}
  19. private:
  20.     uint16_t port;
  21.  
  22. };

2.1.2 把套接字接口封装一下方便使用

  1. #pragma once
  2.  
  3. #include 
  4. #include 
  5. #include 
  6. #include 
  7. #include 
  8. #include 
  9. #include 
  10. #include 
  11. #include 
  12. #include 
  13. #include 
  14.  
  15. using namespace std;
  16.  
  17. class Sock
  18. {
  19. public:
  20.     Sock()
  21.     {}
  22.     ~Sock()
  23.     {}
  24. public:
  25.     void Socket()//创建套接字的接口
  26.     {}
  27.     void bind()//绑定的接口
  28.     {}
  29.     void Listen()//监听状态的接口
  30.     {}
  31.     int Accept()//获取连接的接口
  32.     {}
  33.     int Connect()//方便两个客户端和服务器都能使用这个Sock的这个公共方法
  34.     {}
  35.  
  36. private:
  37.     int sockfd_;
  38. };

2.1.3 TcpServer.hpp接口的补充

  1. #pragma once
  2. #include 
  3.  
  4. #include "Socket.hpp"
  5. #include "./logs/ljwlog.h"
  6.  
  7. class TcpServer
  8. {
  9. public:
  10.     TcpServer()
  11.     {}  
  12.     bool InitServer()
  13.     {
  14.         //先创建套接字，再绑定，设置监听状态
  15.         listensock_.Socket();
  16.         listensock_.bind();
  17.         listensock_.Listen();
  18.     }
  19.     void Start()
  20.     {
  21.         while(true)
  22.         {   
  23.             int sockfd = listensock_.Accept();
  24.         }
  25.     }
  26.  
  27.     ~TcpServer()
  28.     {}
  29. private:
  30.     uint16_t port_;
  31.     Sock listensock_; //叫listen套接字，Listen完后有真正的网络文件描述符
  32. };
  33.  
  34.

2.1.4 Sock.hpp接口的补充

  1. #pragma once
  2.  
  3. #include 
  4. #include 
  5. #include 
  6. #include 
  7. #include 
  8. #include 
  9. #include 
  10. #include 
  11. #include 
  12. #include 
  13. #include 
  14. #include 
  15. #include "./logs/ljwlog.h"
  16.  
  17. using namespace std;
  18.  
  19. enum{
  20.     SocketErr = 2,
  21.     BindErr,
  22.     ListenErr
  23. };
  24. const int backlog = 10;
  25. class Sock
  26. {
  27. public:
  28.     Sock()
  29.     {}
  30.     ~Sock()
  31.     {}
  32. public:
  33.     void Socket()//创建套接字的接口
  34.     {
  35.         sockfd_ = socket(AF_INET, SOCK_STREAM, 0);//流式套接字  第二个参数是协议类型
  36.         if(sockfd_ < 0)
  37.         {
  38.             FATAL("Socket errno,error:%d,errstring:%s", errno, strerror(errno));
  39.             exit(SocketErr);
  40.         }
  41.     }
  42.     void Bind(uint16_t port)//绑定的接口
  43.     {
  44.         struct sockaddr_in local;
  45.         memset(&local, 0, sizeof(local));
  46.         local.sin_family = AF_INET;
  47.         local.sin_port = htons(port);//主机转网络
  48.         local.sin_addr.s_addr = INADDR_ANY;//ip默认0.0.0.0
  49.         if(bind(sockfd_, (struct sockaddr*)&local, sizeof(local)) < 0)
  50.         {
  51.             FATAL("Bind errno,error:%d,errstring:%s", errno, strerror(errno));
  52.             exit(BindErr);            
  53.         }
  54.     }
  55.     void Listen()//监听状态的接口
  56.     {
  57.         if(listen(sockfd_, backlog) < 0)
  58.         {
  59.             FATAL("Listen errno,error:%d,errstring:%s", errno, strerror(errno));
  60.             exit(ListenErr);   
  61.         }
  62.     }
  63.     //              知道谁链接的我
  64.     int Accept(string *clientip, uint16_t *clientport)//获取连接的接口
  65.     {
  66.         struct sockaddr_in peer;//远端的意思
  67.         socklen_t len = sizeof(peer);
  68.         int newfd = accept(sockfd_, (struct sockaddr*)&peer, &len);
  69.         if(newfd < 0)
  70.         {
  71.             WARN("accept error, %s: %d", strerror(errno), errno);
  72.             return -1;
  73.         }
  74.         //网络转主机
  75.         //拿出客户端的ip和端口号
  76.         char ipstr[64];
  77.         inet_ntop(AF_INET, &peer.sin_addr, ipstr, sizeof(ipstr));//网络转主机
  78.         *clientip = ipstr;//网络转主机
  79.         *clientport = ntohs(peer.sin_port);//网络转主机
  80.         return newfd;
  81.     }
  82.     void Close()
  83.     {
  84.         close(sockfd_);
  85.     }
  86.     int Connect()//方便两个客户端和服务器都能使用这个Sock的这个公共方法
  87.     {
  88.         return 0;
  89.     }
  90.  
  91. private:
  92.     int sockfd_;
  93. };

2.1.4 TcpServer.hpp提供服务

2.1.5定制协议（Protocol）（约定好）

双方约定好，把请求放在Request（请求），结果放在Response（响应）

约定好了，最好就不要动他了

  1. #pragma once
  2.  
  3. #include
  4.  
  5. class Request
  6. {
  7. public:
  8.  
  9. public: 
  10.     int x;
  11.     int y;
  12.     char op;// + - * / %
  13. };
  14.  
  15. class Response
  16. {
  17. public:
  18.  
  19. public:
  20.     int result;
  21.     int code;// 0,可信，否则！0具体是几，表明对应的错误原因
  22. };

2.1.6 （手写）序列化和反序列化

serialization 序列化（把struct 转换成 字符串）

deserialization 反序列化

2.1.6.1序列化

2.1.6.2反序列化

 2.1.6.3添加报头（要往网络里发 先添加报头）

这种

 

 2.1.6.4 提出有效载荷

2.1.6.5代码
  1. #pragma once
  2.  
  3. #include
  4. #include
  5. using namespace std;
  6.  
  7. const string blank_space_sep = " ";//空格分隔符
  8. const string protocol_sep = "\n";//报文分隔符
  9.  
  10.  
  11. //序列化和反序列化解决的是对应的是一个报文内部的问题
  12. //还要解决一下报文与报文之间的问题
  13.  
  14. //封装报头
  15. string Encode(string &content)
  16. {
  17.     //封装报头  这里规定的协议就是长度+有效载荷
  18.     string package = to_string(content.size());
  19.     package += protocol_sep;
  20.     package += content;
  21.     package += protocol_sep;
  22.  
  23.     return package;
  24. }
  25.  
  26. //"len"\n"x op y"\n
  27. string Decode(string &package)//将"x op y"提取出来
  28. {
  29.     return "";
  30. }
  31.  
  32. class Request
  33. {
  34. public: 
  35.     Request(int data1, int data2, char oper): x(data1), y(data2), op(oper)
  36.     {}
  37.  
  38. public:
  39.     bool serialization(string *out)
  40.     {
  41.         //构建报文的有效载荷
  42.         //序列化的就是把结构化的(struct)转成string,
  43.         // "x op y"
  44.         //数字之间是不可能出现分隔符的
  45.         string s = to_string(x);
  46.         s += blank_space_sep;
  47.         s += op;
  48.         s += blank_space_sep;
  49.         s += to_string(y);
  50.  
  51.         *out = s;
  52.         return true;
  53.     }
  54.     //"x op y"  进行分割
  55.     bool deserialization(const string &in)
  56.     {
  57.         size_t left = in.find(blank_space_sep);
  58.         if(left == string::npos) return false;//没找到
  59.         string part_x = in.substr(0, left);
  60.  
  61.         size_t right = in.rfind(blank_space_sep);//逆着找
  62.         if(right == string::npos) return false;//没找到
  63.         string part_y = in.substr(right + 1);
  64.  
  65.         if(left + 2 != right) return false;
  66.         op = in[right -1];
  67.  
  68.         x = stoi(part_x);
  69.         y = stoi(part_y);
  70.         return true;
  71.     }
  72. public: 
  73.     int x;
  74.     int y;
  75.     char op;// + - * / %
  76. };
  77.  
  78. class Response
  79. {
  80. public:
  81.     Response(int res, int c):result(res), code(c)
  82.     {}
  83. public:
  84.                 //序列化是结构体转字符串的
  85.     bool serialization(string *out)
  86.     {
  87.         // 序列化成这样"result code"
  88.         //构建报文的有效载荷
  89.         string s = to_string(result);
  90.         s += blank_space_sep;
  91.         s += to_string(code);
  92.  
  93.         *out = s;
  94.         return true;
  95.     }
  96.     //反序列化 一定是你要传过来一个字符串
  97.     bool deserialization(const string &in) //"result code" 协议定制好了就必须是这个样子
  98.     {
  99.         size_t pos = in.find(blank_space_sep);
  100.         if(pos == string::npos) return false;//没找到
  101.         string part_left = in.substr(0, pos);
  102.         string part_right = in.substr(pos + 1);
  103.         result = stoi(part_left);
  104.         code = stoi(part_right);
  105.         return true;
  106.     } 
  107. public:
  108.     int result;
  109.     int code;// 0,可信，否则！0具体是几，表明对应的错误原因
  110. };
2.1.6.6 测试一下序列化和添加报头
  1. #include
  2. #include "TcpServer.hpp"
  3. #include "Protocol.hpp"
  4.  
  5. using namespace std;
  6.  
  7. int main()
  8. {
  9.     Request req(123, 456, '+');
  10.     string s;
  11.     req.serialization(&s);//序列化
  12.     cout << s << endl;
  13.  
  14.     s = Encode(s);//给s报文添加报头
  15.     cout << s ;//这是网络里发的样子
  16.  
  17.     return 0;
  18. }

2.1.6.7 测试一下拿到报文的内容
  1. #include
  2. #include "TcpServer.hpp"
  3. #include "Protocol.hpp"
  4.  
  5. using namespace std;
  6.  
  7. int main()
  8. {
  9.     Request req(123, 456, '+');
  10.     string s;
  11.     req.serialization(&s);//序列化
  12.     //cout << s << endl;
  13.  
  14.     s = Encode(s);//给s报文添加报头
  15.     cout << s ;//这是网络里发的样子
  16.  
  17.     //拿到报文的内容
  18.     string content;
  19.     bool r = Decode(s, &content);
  20.     cout<< content <
  21.  
  22.     return 0;
  23. }

2.1.6.8 测试对收到报文进行反序列化  打散成对象

2.1.6.9 测试Response的要往网络里发 先添加报头

2.1.7.0 测试解码

2.1.7.1 测试Response反序列化

2.1.7.2 创建ServerCal.hpp处理整个报文

如何处理整个报文

把协议和网络功能组合在一起 然后再把这个头文件"ServerCal.hpp"交给ServerCal.cc

  1. #pragma once
  2. #include
  3. #include
  4. #include "Protocol.hpp"
  5. using namespace std;
  6.  
  7. //如何处理整个报文
  8. //把协议和网络功能组合在一起 然后再把这个头文件"ServerCal.hpp"交给ServerCal.cc
  9.  
  10. class ServerCal
  11. {
  12. public:
  13.     ServerCal()
  14.     {}
  15.     Response CalculatorHelper(const Request &req)
  16.     {
  17.         Response resp(0, 0);
  18.         switch(req.op)
  19.         {
  20.             case '+':
  21.                 resp.result = req.x + req.y;
  22.             case '-':
  23.                 resp.result = req.x - req.y;
  24.             case '*':
  25.                 resp.result = req.x * req.y;           
  26.             case '/':
  27.                 resp.result = req.x / req.y;
  28.         }
  29.         return resp;
  30.     }
  31.  
  32.     //提供一个网络计算服务  把先把报文给我
  33.     string Calculator(string &package)//肯定是收到一个序列化的请求报文
  34.     {
  35.         //收到一个请求报文 添加报头
  36.         string content;
  37.         bool r = Decode(package, &content);
  38.         //报文不完整就直接返回
  39.         if(!r) return;
  40.  
  41.         //完整的报文
  42.         //请求的对象
  43.         Request req;
  44.         //反序列化
  45.         r = req.deserialization(content);
  46.         if(!r) return;
  47.  
  48.         //结果
  49.         Response resp = CalculatorHelper(req);
  50.         //返回结果
  51.         //序列化
  52.         string s;
  53.         resp.serialization(&s);
  54.         //序列化后，想把它当作网络报文发出去
  55.         //添加报头
  56.         s = Encode(s);
  57.  
  58.         return s;
  59.     }
  60.  
  61.     ~ServerCal()
  62.     {}
  63. };
2.1.7.3 完善一下TcpServer.hpp

2.1.7.4 测试

2.1.7.5 完善一下ClientCal.cc

tcp客户端要绑定，但不用显示的绑定

客户端端口号是随机的，但是唯一的

udp端口那里随机绑定是首次发送数据的时候，那么你的端口号就随之确定了

tcp这里是面向连接的，客户端连接成功了，我才想让你进行通信

没有bind 也就没有listen了

向服务器发起连接的接口 connect

客户端发起connect的时候,系统进行自动随机bind

  1. #include 
  2. #include 
  3. #include 
  4. #include 
  5. #include "Socket.hpp"
  6. #include "Protocol.hpp"
  7.  
  8. using namespace std;
  9.  
  10. void Usage(const string &proc)
  11. {
  12.     cout << "\nUsage" << proc << "  serverip   serverport\n\n"
  13.          << endl;
  14. }
  15.  
  16. //./clientcal serverip serverport
  17. int main(int argc, char *argv[])
  18. {
  19.     if (argc != 3)
  20.     {
  21.         Usage(argv[0]);
  22.         exit(0);
  23.     }
  24.     string serverip = argv[1];
  25.     uint16_t serverport = stoi(argv[2]);
  26.  
  27.     Sock sockfd;
  28.     sockfd.Socket();
  29.     bool r = sockfd.Connect(serverip, serverport);
  30.     if (!r)
  31.         return 1;
  32.  
  33.     srand(time(nullptr));
  34.     const string s = "+-*/^!~";
  35.     int cnt = 10;
  36.  
  37.     string inbuffer_stream;
  38.     while (cnt--)
  39.     {
  40.         cout<< "第" <"次测试..." <
  41.         int x = rand() % 100 + 1;
  42.         usleep(1234);
  43.         int y = rand() % 100 + 1;
  44.         usleep(4321);
  45.         char op = s[rand() % s.size()];
  46.         Request req(x, y, op);
  47.  
  48.         req.DebugPrint();
  49.  
  50.         // 根据协议把请求发给服务器，Request是一个结构化的数据，发不了
  51.         // 先序列化得到对应的字符串
  52.         string package;
  53.         req.serialization(&package);
  54.  
  55.         // 还是不能往网络里发送 添加报头还要
  56.         //"len"\n"x op y"\n
  57.         package = Encode(package);
  58.         cout << "这是最新的发出去的请求:\n"
  59.              << package;
  60.         // 把请求往服务器端写
  61.         write(sockfd.Fd(), package.c_str(), package.size());
  62.         cout<
  63.  
  64.         // 接收服务器发回来的信息
  65.         char buffer[128];
  66.         //我们也没法保证我们能够读到一个完整的报文
  67.         ssize_t n = read(sockfd.Fd(), buffer, sizeof(buffer));
  68.         if (n > 0)
  69.         {
  70.             buffer[n] = 0;
  71.             inbuffer_stream += buffer;// "len"\n"result code"\n
  72.             string content;
  73.             //解码
  74.             bool r = Decode(inbuffer_stream, &content);//"result code"
  75.             assert(r);
  76.  
  77.             //反序列化
  78.             Response resp;
  79.             r = resp.deserialization(content);
  80.             assert(r);
  81.             resp.DebugPrint();
  82.  
  83.         }
  84.         sleep(1);
  85.     }
  86.  
  87.     sockfd.Close();
  88.  
  89.     return 0;
  90. }

2.1.7.6 客户端一次发多个请求呢

解决方案

2.1.7 （jsoncpp）序列化和反序列化

2.1.7.1 安装json库
sudo apt install libjsoncpp-dev

 这是头文件（只使用json.h）

2.1.7.2 简单的json的用法
  1. #include
  2. #include "jsoncpp/json/json.h"
  3.  
  4. using namespace std;
  5.  
  6. int main()
  7. {   
  8.     Json::Value root;
  9.     root["x"] = 100;
  10.     root["y"] = 100;
  11.     root["op"] = '+';
  12.     //描述
  13.     root["dect"] = "this is a + oper";
  14.  
  15.     //比较快的序列化
  16.     Json::FastWriter w;
  17.     string res = w.write(root);
  18.  
  19.     cout<< res <
  20.  
  21.     return 0;
  22. }

编译时要带-ljsoncpp 

2.1.7.2.1 序列化 

2.1.7.2.2 反序列化 

2.1.7.2.3 json套json

2.1.7.3 Protocol.hpp中的json序列化和反序列化

2.1.7.4 守护进程化

3 重谈OSI七层模型

4 代码总合

4.1 ClientCal.cc

  1. #include 
  2. #include 
  3. #include 
  4. #include 
  5. #include "Socket.hpp"
  6. #include "Protocol.hpp"
  7.  
  8. using namespace std;
  9.  
  10. void Usage(const string &proc)
  11. {
  12.     cout << "\nUsage" << proc << "  serverip   serverport\n\n"
  13.          << endl;
  14. }
  15.  
  16. //./clientcal serverip serverport
  17. int main(int argc, char *argv[])
  18. {
  19.     if (argc != 3)
  20.     {
  21.         Usage(argv[0]);
  22.         exit(0);
  23.     }
  24.     string serverip = argv[1];
  25.     uint16_t serverport = stoi(argv[2]);
  26.  
  27.     Sock sockfd;
  28.     sockfd.Socket();
  29.     bool r = sockfd.Connect(serverip, serverport);
  30.     if (!r)
  31.         return 1;
  32.  
  33.     srand(time(nullptr));
  34.     const string s = "+-*/^!~";
  35.     int cnt = 10;
  36.  
  37.     string inbuffer_stream;
  38.     while (cnt--)
  39.     {
  40.         cout<< "第" <"次测试..." <
  41.         int x = rand() % 100 + 1;
  42.         usleep(1234);
  43.         int y = rand() % 100 + 1;
  44.         usleep(4321);
  45.         char op = s[rand() % s.size()];
  46.         Request req(x, y, op);
  47.  
  48.         req.DebugPrint();
  49.  
  50.         // 根据协议把请求发给服务器，Request是一个结构化的数据，发不了
  51.         // 先序列化得到对应的字符串
  52.         string package;
  53.         req.serialization(&package);
  54.  
  55.         // 还是不能往网络里发送 添加报头还要
  56.         //"len"\n"x op y"\n
  57.         package = Encode(package);
  58.         cout << "这是最新的发出去的请求:\n"
  59.              << package;
  60.         // 把请求往服务器端写
  61.         write(sockfd.Fd(), package.c_str(), package.size());
  62.         // write(sockfd.Fd(), package.c_str(), package.size());
  63.         // write(sockfd.Fd(), package.c_str(), package.size());
  64.         // write(sockfd.Fd(), package.c_str(), package.size());
  65.         // write(sockfd.Fd(), package.c_str(), package.size());
  66.         // write(sockfd.Fd(), package.c_str(), package.size());
  67.         cout<
  68.  
  69.         // 接收服务器发回来的信息
  70.         char buffer[128];
  71.         //我们也没法保证我们能够读到一个完整的报文
  72.         ssize_t n = read(sockfd.Fd(), buffer, sizeof(buffer));
  73.         if (n > 0)
  74.         {
  75.             buffer[n] = 0;
  76.             inbuffer_stream += buffer;// "len"\n"result code"\n
  77.             cout<< inbuffer_stream <
  78.             string content;
  79.             //解码
  80.             bool r = Decode(inbuffer_stream, &content);//"result code"
  81.             assert(r);
  82.  
  83.             //反序列化
  84.             Response resp;
  85.             r = resp.deserialization(content);
  86.             assert(r);
  87.             resp.DebugPrint();
  88.  
  89.         }
  90.         sleep(1);
  91.     }
  92.  
  93.     sockfd.Close();
  94.  
  95.     return 0;
  96. }

4.2 makefile

  1. .PHONY:all
  2. all:servercal clientcal
  3. servercal:ServerCal.cc
  4. 	g++ -g -o $@ $^ -lpthread -std=c++11 -ljsoncpp
  5. clientcal:ClientCal.cc
  6. 	g++ -o $@ $^ -lpthread -std=c++11 -ljsoncpp
  7. .PHONT:clean
  8. clean:
  9. 	rm -f clientcal servercal

4.3 Protocol.hpp

  1. #pragma once
  2.  
  3. #include
  4. #include
  5. #include "jsoncpp/json/json.h"
  6. using namespace std;
  7.  
  8. const string blank_space_sep = " ";//空格分隔符
  9. const string protocol_sep = "\n";//报文分隔符
  10.  
  11.  
  12. //序列化和反序列化解决的是对应的是一个报文内部的问题
  13. //还要解决一下报文与报文之间的问题
  14.  
  15. //添加报头  "len"\n"x op y"\n
  16. string Encode(string &content)
  17. {
  18.     //封装报头  这里规定的协议就是长度+有效载荷
  19.     string package = to_string(content.size());
  20.     package += protocol_sep;
  21.     package += content;
  22.     package += protocol_sep;
  23.  
  24.     return package;
  25. }
  26.  
  27. //将"x op y"提取出来 有效载荷
  28. //"len"\n"x op y"\n   package整个报文    *content把结果带出去
  29. bool Decode(string &package, string *content)
  30. {
  31.     size_t pos = package.find(protocol_sep);
  32.     if(pos == string::npos) return false;
  33.     string len_str = package.substr(0, pos);
  34.     size_t len = stoi(len_str); //拿到了len长度
  35.  
  36.     //判断一下package的长度够不够
  37.     //package = len_str + content_str + 2
  38.     size_t total_len = len_str.size() + len + 2;
  39.     if(package.size() < total_len) return false;
  40.     //大于没事，因为肯定有完整的报文
  41.  
  42.     //*content把结果带出去  "x op y"
  43.     *content = package.substr(pos + 1, len);
  44.  
  45.     // earse 移除报文  
  46.     package.erase(0, total_len);
  47.     return true;
  48. }
  49.  
  50. class Request
  51. {
  52. public: 
  53.     Request(int data1, int data2, char oper): x(data1), y(data2), op(oper)
  54.     {}
  55.     Request()
  56.     {}
  57. public:
  58.     bool serialization(string *out)
  59.     {
  60.         // //构建报文的有效载荷
  61.         // //序列化的就是把结构化的(struct)转成string,
  62.         // // "x op y"
  63.         // //数字之间是不可能出现分隔符的
  64.         // string s = to_string(x);
  65.         // s += blank_space_sep;
  66.         // s += op;
  67.         // s += blank_space_sep;
  68.         // s += to_string(y);
  69.  
  70.         // *out = s;
  71.         // return true;
  72.  
  73.         //Json 序列化
  74.         Json::Value root;
  75.         root["x"] = x;
  76.         root["y"] = y;
  77.         root["op"] = op;
  78.         Json::FastWriter w;
  79.         *out = w.write(root);
  80.         return true;
  81.     }
  82.  
  83.     //"x op y"  进行分割
  84.     bool deserialization(const string &in)
  85.     {
  86.         // size_t left = in.find(blank_space_sep);
  87.         // if(left == string::npos) return false;//没找到
  88.         // string part_x = in.substr(0, left);
  89.  
  90.         // size_t right = in.rfind(blank_space_sep);//逆着找
  91.         // if(right == string::npos) return false;//没找到
  92.         // string part_y = in.substr(right + 1);
  93.  
  94.         // if(left + 2 != right) return false;
  95.         // op = in[right -1];
  96.  
  97.         // x = stoi(part_x);
  98.         // y = stoi(part_y);
  99.         // return true;
  100.  
  101.         //Json 反序列化
  102.         Json::Value root;
  103.         Json::Reader r;
  104.         r.parse(in, root);
  105.         //反序列化到root
  106.         //提取出来
  107.         x = root["x"].asInt();
  108.         y = root["y"].asInt();
  109.         op = root["op"].asInt();
  110.         return true;  
  111.     }
  112.     void DebugPrint()
  113.     {
  114.         cout<< "新请求构建完成" << x << op << y << "=?" <
  115.     }
  116.  
  117. public: 
  118.     int x;
  119.     int y;
  120.     char op;// + - * / %
  121. };
  122.  
  123. class Response
  124. {
  125. public:
  126.     Response(int res, int c):result(res), code(c)
  127.     {}
  128.     Response()
  129.     {}
  130. public:
  131.                 //序列化是结构体转字符串的
  132.     bool serialization(string *out)
  133.     {
  134.         // // 序列化成这样"result code"
  135.         // //构建报文的有效载荷
  136.         // string s = to_string(result);
  137.         // s += blank_space_sep;
  138.         // s += to_string(code);
  139.  
  140.         // *out = s;
  141.         // return true;
  142.  
  143.         //Json 序列化
  144.         Json::Value root;
  145.         root["result"] = result;
  146.         root["code"] = code;
  147.         Json::FastWriter w;
  148.         *out = w.write(root);
  149.         return true;
  150.     }
  151.  
  152.     //反序列化 一定是你要传过来一个字符串
  153.     bool deserialization(const string &in) //"result code" 协议定制好了就必须是这个样子
  154.     {
  155.         // size_t pos = in.find(blank_space_sep);
  156.         // if(pos == string::npos) return false;//没找到
  157.         // string part_left = in.substr(0, pos);
  158.         // string part_right = in.substr(pos + 1);
  159.         // result = stoi(part_left);
  160.         // code = stoi(part_right); 
  161.         // return true;
  162.  
  163.         //Json 反序列化
  164.         Json::Value root;
  165.         Json::Reader r;
  166.         r.parse(in, root);
  167.         //反序列化到root
  168.         //提取出来
  169.         result = root["result"].asInt();
  170.         code = root["code"].asInt();
  171.         return true;
  172.     } 
  173.  
  174.     void DebugPrint()
  175.     {
  176.         cout<< "响应结果完成" << "result:"<< result <<"code:" <
  177.     }
  178. public:
  179.     int result;
  180.     int code;// 0,可信，否则！0具体是几，表明对应的错误原因
  181. };

4.4 ServerCal.cc

  1. #include
  2. #include
  3. #include "TcpServer.hpp"
  4. #include "Protocol.hpp"
  5. #include "ServerCal.hpp"
  6.  
  7. using namespace std;
  8.  
  9. void Usage(const string& proc)
  10. {
  11.     cout<<"\nUsage" << proc << "port\n\n" <
  12. }
  13.  
  14. int main(int argc, char* argv[])
  15. {
  16.     if(argc != 2)
  17.     {
  18.         Usage(argv[0]);
  19.         exit(0);   
  20.     }
  21.     uint16_t port = stoi(argv[1]);
  22.  
  23.     ServerCal cal;
  24.     TcpServer *tsvp = new TcpServer(port, bind(&ServerCal::Calculator, &cal, placeholders::_1));
  25.     tsvp->InitServer();
  26.     daemon(0, 0);
  27.     tsvp->Start();
  28.  
  29.  
  30.  
  31.  
  32.     // Response resp(1000, 0);
  33.     // //发回去
  34.     // string content;
  35.     // resp.serialization(&content);
  36.     // //cout << content << endl;
  37.     // //要往网络里发 先添加报头
  38.     // string package = Encode(content);
  39.     // cout << package << endl;
  40.  
  41.     // //解码 放进s
  42.     // string s;
  43.     // bool r = Decode(package, &s);
  44.     // cout<< s <
  45.  
  46.     // //反序列化   打散成对象
  47.     // Response temp;
  48.     // temp.deserialization(s);
  49.     // cout<<"\n\n";
  50.     // cout<< temp.result <
  51.     // cout<< temp.code << endl;
  52.  
  53.  
  54.     // Request req(123, 456, '+');
  55.     // string s;
  56.     // req.serialization(&s);//序列化
  57.     // //cout << s << endl;
  58.  
  59.     // s = Encode(s);//给s报文添加报头
  60.     // cout << s ;//这是网络里发的样子
  61.  
  62.     // //拿到报文的内容
  63.     // string content;
  64.     // bool r = Decode(s, &content);
  65.     // cout<< content <
  66.  
  67.     // //对收到报文进行反序列化  打散成对象
  68.     // Request temp;
  69.     // temp.deserialization(content);
  70.     // cout<< temp.x <
  71.  
  72.     return 0;
  73. }

4.5 ServerCal.hpp

  1. #pragma once
  2. #include
  3. #include
  4. #include "Protocol.hpp"
  5. using namespace std;
  6.  
  7. //如何处理整个报文
  8. //把协议和网络功能组合在一起 然后再把这个头文件"ServerCal.hpp"交给ServerCal.cc
  9.  
  10. class ServerCal
  11. {
  12. public:
  13.     ServerCal()
  14.     {}
  15.     Response CalculatorHelper(const Request &req)
  16.     {
  17.         Response resp(0, 0);
  18.         switch(req.op)
  19.         {
  20.             case '+':
  21.                 resp.result = req.x + req.y;
  22.                 break;
  23.             case '-':
  24.                 resp.result = req.x - req.y;
  25.                 break;
  26.             case '*':
  27.                 resp.result = req.x * req.y;           
  28.                 break;
  29.             case '/':
  30.                 if(req.y == 0) resp.code = 1;
  31.                 else 
  32.                 {
  33.                     resp.result = req.x / req.y;
  34.                 }
  35.                 break;
  36.             default:
  37.                 resp.code = 2;
  38.                 break;
  39.         }
  40.         return resp;
  41.     }
  42.  
  43.     //提供一个网络计算服务  把先把报文给我
  44.     //           package: "len"\n"10 + 20"\n
  45.     string Calculator(string &package)//肯定是收到一个序列化的请求报文
  46.     {
  47.         //收到一个请求报文 添加报头
  48.         string content;
  49.         bool r = Decode(package, &content);
  50.         //报文不完整就直接返回
  51.         if(!r) return "";
  52.  
  53.         //完整的报文
  54.         //请求的对象
  55.         Request req;
  56.         //反序列化
  57.         r = req.deserialization(content);
  58.         if(!r) return "";
  59.  
  60.         //结果
  61.         Response resp = CalculatorHelper(req);
  62.         //返回结果
  63.         //序列化
  64.         string s;
  65.         resp.serialization(&s);
  66.         //序列化后，想把它当作网络报文发出去
  67.         //添加报头
  68.         s = Encode(s);
  69.  
  70.         return s;
  71.     }
  72.  
  73.     ~ServerCal()
  74.     {}
  75. };

4.6 Socket.hpp

  1. #pragma once
  2.  
  3. #include 
  4. #include 
  5. #include 
  6. #include 
  7. #include 
  8. #include 
  9. #include 
  10. #include 
  11. #include 
  12. #include 
  13. #include 
  14. #include 
  15. #include "./logs/ljwlog.h"
  16.  
  17. using namespace std;
  18.  
  19. enum
  20. {
  21.     SocketErr = 2,
  22.     BindErr,
  23.     ListenErr
  24. };
  25. const int backlog = 10;
  26. class Sock
  27. {
  28. public:
  29.     Sock()
  30.     {
  31.     }
  32.     ~Sock()
  33.     {
  34.     }
  35.  
  36. public:
  37.     void Socket() // 创建套接字的接口
  38.     {
  39.         sockfd_ = socket(AF_INET, SOCK_STREAM, 0); // 流式套接字  第二个参数是协议类型
  40.         if (sockfd_ < 0)
  41.         {
  42.             FATAL("Socket errno,error:%d,errstring:%s", errno, strerror(errno));
  43.             exit(SocketErr);
  44.         }
  45.     }
  46.     void Bind(uint16_t port) // 绑定的接口
  47.     {
  48.         struct sockaddr_in local;
  49.         memset(&local, 0, sizeof(local));
  50.         local.sin_family = AF_INET;
  51.         local.sin_port = htons(port);       // 主机转网络
  52.         local.sin_addr.s_addr = INADDR_ANY; // ip默认0.0.0.0
  53.         if (bind(sockfd_, (struct sockaddr *)&local, sizeof(local)) < 0)
  54.         {
  55.             FATAL("Bind errno,error:%d,errstring:%s", errno, strerror(errno));
  56.             exit(BindErr);
  57.         }
  58.     }
  59.     void Listen() // 监听状态的接口
  60.     {
  61.         if (listen(sockfd_, backlog) < 0)
  62.         {
  63.             FATAL("Listen errno,error:%d,errstring:%s", errno, strerror(errno));
  64.             exit(ListenErr);
  65.         }
  66.     }
  67.     //              知道谁链接的我
  68.     int Accept(string *clientip, uint16_t *clientport) // 获取连接的接口
  69.     {
  70.         struct sockaddr_in peer; // 远端的意思
  71.         socklen_t len = sizeof(peer);
  72.         int newfd = accept(sockfd_, (struct sockaddr *)&peer, &len);
  73.         if (newfd < 0)
  74.         {
  75.             WARN("accept error, %s: %d", strerror(errno), errno);
  76.             return -1;
  77.         }
  78.         // 网络转主机
  79.         // 拿出客户端的ip和端口号
  80.         char ipstr[64];
  81.         inet_ntop(AF_INET, &peer.sin_addr, ipstr, sizeof(ipstr)); // 网络转主机
  82.         *clientip = ipstr;                                        // 网络转主机
  83.         *clientport = ntohs(peer.sin_port);                       // 网络转主机
  84.         return newfd;
  85.     }
  86.     void Close()
  87.     {
  88.         close(sockfd_);
  89.     }
  90.     int Connect(const string &ip, const uint16_t &port) // 方便两个客户端和服务器都能使用这个Sock的这个公共方法
  91.     {
  92.         struct sockaddr_in peer;
  93.         memset(&peer, 0, sizeof(peer));
  94.         peer.sin_family = AF_INET;
  95.         peer.sin_port = htons(port);
  96.         inet_pton(AF_INET, ip.c_str(), &(peer.sin_addr));
  97.         int n = connect(sockfd_, (struct sockaddr *)&peer, sizeof(peer));
  98.         if (n == -1)
  99.         {
  100.             cerr << "connect to" << ip << "::" << port <<"error"<< endl;
  101.             return false;
  102.         }
  103.  
  104.         return true;
  105.     }
  106.     int Fd()
  107.     {
  108.         return sockfd_;
  109.     }
  110.  
  111. private:
  112.     int sockfd_;
  113. };

4.7 TcpServer.hpp

  1. #pragma once
  2. #include 
  3. #include 
  4. #include 
  5. #include "Socket.hpp"
  6. #include "./logs/ljwlog.h"
  7.  
  8. //                     返回值    参数
  9. using fun_t = function< string(string &package)>;
  10.  
  11. class TcpServer
  12. {
  13. public:
  14.     TcpServer(uint16_t port, fun_t callback):port_(port), callback_(callback)
  15.     {}  
  16.     bool InitServer( )
  17.     {
  18.         //先创建套接字，再绑定，设置监听状态
  19.         listensock_.Socket();
  20.         listensock_.Bind(port_);
  21.         listensock_.Listen();
  22.         INFO("init server");
  23.         return true;
  24.     }
  25.     void Start()
  26.     {
  27.         signal(SIGCHLD, SIG_IGN);//忽略就不用等待了
  28.         signal(SIGPIPE, SIG_IGN);//忽略就不用等待了
  29.         while(true)
  30.         {   
  31.             string clientip;
  32.             uint16_t clientport;
  33.             int sockfd = listensock_.Accept(&clientip, &clientport);
  34.             if(sockfd < 0) continue;
  35.             INFO("Accept server   sockfd:%d  clientip:%s  clientport:%d", sockfd, clientip.c_str(), clientport);
  36.             //提供服务
  37.             if(fork() == 0)
  38.             {
  39.                 //子进程
  40.                 listensock_.Close();
  41.                 
  42.                 //请求的信息流
  43.                 string inbuffer_stream;
  44.  
  45.                 //数据计算
  46.                 while(true)
  47.                 {
  48.                     //从网络当中读数据到buffer当中
  49.                     char buffer[1024];
  50.                     ssize_t n = read(sockfd, buffer, sizeof(buffer));
  51.                     if(n > 0)
  52.                     {
  53.                         buffer[n] = 0;
  54.                         inbuffer_stream += buffer;
  55.  
  56.                         DEBUG("inbuffer_stream: %s", inbuffer_stream.c_str());
  57.                         while(true)
  58.                         {
  59.                             string info = callback_(inbuffer_stream);
  60.                             //如果没有读到完整的报文，就会返回一个空串infp
  61.                             if(info.empty()) break;
  62.  
  63.                             write(sockfd, info.c_str(), info.size());
  64.                         }
  65.  
  66.                     }
  67.                     else if(n == 0) break;
  68.                     else break;
  69.                 }
  70.  
  71.                 exit(0);
  72.             }
  73.             close(sockfd);//不用等了直接关就好了
  74.         }
  75.     }
  76.  
  77.     ~TcpServer()
  78.     {}
  79. private:
  80.     uint16_t port_;
  81.     Sock listensock_; //叫listen套接字，Listen完后有真正的网络文件描述符
  82.  
  83.     fun_t callback_;
  84. };
  85.  
  86.

注：本文转载自blog.csdn.net的Ljw...的文章"https://blog.csdn.net/2401_83427936/article/details/144003486"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！