Linux网络 | 网络盘算器客户端实现与Json的安装以及利用 ...

         媒介：本节讲述序列化和反序列化的相干内容。 这节的内容是博主前一篇博客的续章， 内里用到了很多知识点都是前一篇文章的。 友友们如果要学习序列化反序列化， 直接看本篇文章是看不懂的， 请看前一篇文章：linux网络 | 序列化反序列化的概念 与 联合网络盘算器深度明白-CSDN博客
          前一篇文章内容除了概念以外， 主要是利用序列化反序列化的知识点实现了一个网络盘算器的服务端。 然后本节内容来实现以下客户端， 让服务端能够与客户端连接起来， 实现盘算器的功能。 另外， 本节内容还会利用一下Json， 这是一个序列化反序列化办理方案，以后我们就不消本身手搓序列化反序列化了。 
          ps：本节内容友友们务必看完前上面的文章链接的文章哦！ 
  目次
ClientCal实现
下令行参数
connect
准备工作 
write 
read 
Json的利用
运行结果

---

ClientCal实现

下令行参数

        客户端同样要有下令行参数：

1. int main(int argc, char* argv[])
2. {
3.     if (argc != 3)
4.     {
5.         Usage(argv[0]);
6.         exit(0);         
7.     }
8.     return 0;
9. }

复制代码

connect

        然后这个下令行参数第一个据说程序的名称， 第二个是表示要链接的服务器的IP地址， 第三个是表示要链接的服务器的端口号。  
        将ip地址和端口号获取之后就可以实行进行连接， 链接的接口我们在socket套接字内里直接封装起来， 方便后面的利用：

1.     bool Connect(string serverip, uint16_t serverport)
2.     {
3.         sockaddr_in server;
4.         server.sin_family = AF_INET;
5.         server.sin_port = htons(serverport);
6.         inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));
7.         connect(sockfd, (sockaddr*)&server, sizeof(server));
8.         return true;
9.     }

复制代码

        这个函数就是将要连接的服务器端的ip地址和端口号传送进去， 然后就向服务器进行连接。 
那么ClientCal内里的代码就是这样的：

1. #include<iostream>
2. using namespace std;
3. #include"tcpserver.hpp"
4. #include<string>
5. #include"socket.hpp"
6. #include<time.h>
7. #include<cstdlib>
9. void Usage(string proc)
10. {
11.     cout << "Usage: " << proc << endl;
12. }
15. int main(int argc, char* argv[])
16. {
17.     if (argc != 3)
18.     {
19.         Usage(argv[0]);
20.         exit(0);         
21.     }
23.     //
24.     string serverip = argv[1];
25.     uint16_t port = stoi(argv[2]);
26.    
27.     Socket sockfd;
28.     sockfd.SocketInit();
29.     bool r = sockfd.Connect(serverip, port);
30.     if (!r) return 1;
31.     return 0;
32. }

复制代码

准备工作 

        接下来就是向服务器发送哀求，我们这里发送哀求利用rand进行随机选数字， 选两个数字和一个操纵符， 然后打包成报文，写到网卡内里。  在发送哀求之前先做一些准备工作：

1.     srand(time(nullptr) ^ getpid());  //种随机数种子
2.     int cnt = 1;                      //对发送的请求个数进行计数， 我们只发送20次请求
3.     string opers = "+-*/%";           //加减乘除运算符
5.     string inbuffer_stream;           //请求字节流缓冲区

复制代码

write 

         然后我们就是先一下写入操纵：

1. while (cnt <= 20)
2.     {
3.         cout << "第" << cnt++ << "次测试......" << endl;  //计数这是第几次发送请求
4.         
5.         //随机数，选一个随机数   
6.         int x = rand() % 100 + 1;
7.         usleep(1234);   
9.         //选第二个随机数
10.         int y = rand() % 100 ;
11.         usleep(4321);
12.         
13.         //选一个随机的运算符
14.         char oper = opers[rand() % opers.size()];   
15.         
16.         //对两个随机数和运算符进行序列化
17.         Request req(x, y, oper);
18.         req.DebugPrint();        //这个函数属于req里面的成员函数， 用于debug， 就是对请求进行一下打印， 方便观察。 代码后面展示
19.         string package;
20.         req.Serialize(&package);
21.         
22.         //对序列化的请求打包成保温
23.         package = Encode(package);
24.         cout << "这是最新的发出去的请求:\n" << package;
25.         
26.         //发送请求
27.         write(sockfd.Fd(), package.c_str(), package.size());
28.     }

复制代码

         这是debug的函数， 这个函数是

1.     void DebugPrint()
2.     {
3.         cout << "构建请求完成: " << x << op << y <<  "?= " << endl;    
5.     }

复制代码

read 

         客户端将数据发送过去之后， 服务端将数据进行处理惩罚，然后客户端就从对面吸收数据，所以write函数后面就调用read函数：

1.     while (cnt <= 20)
2.     {
3.         cout << "第" << cnt++ << "次测试......" << endl;
4.         int x = rand() % 100 + 1;
5.         usleep(1234);   
7.         int y = rand() % 100 ;
8.         usleep(4321);
10.         char oper = opers[rand() % opers.size()];   
11.         Request req(x, y, oper);
13.         req.DebugPrint();
15.         string package;
16.         req.Serialize(&package);
17.         
18.         package = Encode(package);
19.         cout << "这是最新的发出去的请求:\n" << package;
20.         write(sockfd.Fd(), package.c_str(), package.size());
22.         char buffer[128];
23.         ssize_t n = read(sockfd.Fd(), buffer, sizeof(buffer));  //我们也无法保证我们能够读到一个完整的报文
24.         if (n > 0)
25.         {
26.             buffer[n] = 0;
27.             inbuffer_stream += buffer;   
28.             string content;
30.             bool r = Decode(inbuffer_stream, &content);  //result code
32.             Response resp;
33.             r = resp.DeSerialize(content);            
35.             resp.DebugPrint();
36.         }
38.         sleep(1);
40.     }

复制代码

         下面是全部代码：

1. #include<iostream>using namespace std;#include"tcpserver.hpp"#include<string>#include"socket.hpp"#include<time.h>#include<cstdlib>void Usage(string proc){    cout << "Usage: " << proc << endl;}int main(int argc, char* argv[]){    if (argc != 3)    {        Usage(argv[0]);        exit(0);             }    //    string serverip = argv[1];    uint16_t port = stoi(argv[2]);        Socket sockfd;    sockfd.SocketInit();    bool r = sockfd.Connect(serverip, port);    if (!r) return 1;    srand(time(nullptr) ^ getpid());    int cnt = 1;    string opers = "+-*/%";            string inbuffer_stream;    while (cnt <= 20)
2.     {
3.         cout << "第" << cnt++ << "次测试......" << endl;
4.         int x = rand() % 100 + 1;
5.         usleep(1234);   
7.         int y = rand() % 100 ;
8.         usleep(4321);
10.         char oper = opers[rand() % opers.size()];   
11.         Request req(x, y, oper);
13.         req.DebugPrint();
15.         string package;
16.         req.Serialize(&package);
17.         
18.         package = Encode(package);
19.         cout << "这是最新的发出去的请求:\n" << package;
20.         write(sockfd.Fd(), package.c_str(), package.size());
22.         char buffer[128];
23.         ssize_t n = read(sockfd.Fd(), buffer, sizeof(buffer));  //我们也无法保证我们能够读到一个完整的报文
24.         if (n > 0)
25.         {
26.             buffer[n] = 0;
27.             inbuffer_stream += buffer;   
28.             string content;
30.             bool r = Decode(inbuffer_stream, &content);  //result code
32.             Response resp;
33.             r = resp.DeSerialize(content);            
35.             resp.DebugPrint();
36.         }
38.         sleep(1);
40.     }    return 0;}

复制代码

Json的利用

        Json在利用之前要先安装, centos下是yum install -y jsoncpp-devel，  Ubuntu下是：apt-get install libjsoncpp-dev。Ubuntu下建议安装前先update一下apt。
        如果安装后， 可以检查一下是否安装成功：（Ubuntu下是这样的路径）

        如果有上面这些文件， 说明就是安装成功了。 
        然后下面开始利用示例：

1. #include<iostream>
2. #include<jsoncpp/json/json.h>
3. #include<string>
4. using namespace std;
6. int main()
7. {
8.     Json::Value root;
9.     root["x"] = 100;
10.     root["y"] = 200;
11.     root["op"] = "+";
12.     root["dect"] = "this is a + oper";
13.     //
14.     Json::FastWriter w;
15.     string res = w.write(root); //序列化，参数就是我们的root。
17.     cout << res << endl;
19.     Json::Value v;
20.     Json::Reader r;  //r就是一个方法， 利用r里面的方法将res字符串给V， 就完成了反序列化
21.     r.parse(res, v);
23.     //这就是将反序列化的数据提取出来
24.     int x = v["x"].asInt();      //
25.     int y = v["y"].asInt();
26.     int op = v["op"].asInt();
27.     string desc = v["desc"].asString();
28.     return 0;
29. }

复制代码

        有了Json之后， 对于序列化和反序列化就可以改成Json版本的了， 这里利用条件编译进行控制， 保留代码痕迹。 留意， 序列化反序列化是serialize和deserialize, 而Encode和 Decode是对序列化的数据进行添加报头和解报头。Encode和Decode仍必要我们本身实现， 序列化和反序列化可以由Json取代： 

1. //协议
2. #pragma once
3. #include<iostream>
4. using namespace std;
5. #include<string>
6. #include<jsoncpp/json/json.h>
8. // #define MySelf 1
10. const string blank_space_sep = " ";
11. const string protocol_sep = "\n";
13. string Encode(string &content)  //content正文部分
14. {
15.     string package = to_string(content.size()); //先添加len
16.     package += protocol_sep; //加反斜杠n
17.     package += content;
18.     package += protocol_sep; //字符串末尾加上反斜杠n
20.     return package;
21. }
23. bool Decode(string &package, string *content)
24. {
25.     size_t pos = package.find(protocol_sep);
26.     if(pos == string::npos) return false;
27.     string len_str = package.substr(0, pos);
28.     size_t len = stoi(len_str);
29.     size_t total_len = len_str.size() + len + 2;
31.     if (package.size() <= total_len) return false;
32.     *content = package.substr(pos + 1, len);
34.     package.erase(0, total_len);
35.    
36.     return true;
37. }
39. //json, protobuf。可以帮助自动序列化发序列化， 也就是线程的序列化反序列化方案。
40. class Request
41. {
42. public:
43.     Request(){}
44.     Request(int data1, int data2, char oper)
45.         : x(data1), y(data2), op(oper)
46.     {
48.     }
51.     bool serialize(string *out)
52.     {
53. #ifdef MySelf
55.         string s = to_string(x);
56.         s += blank_space_sep;
57.         s += op;
58.         s += blank_space_sep;
59.         s += to_string(y);
61.         *out += s;
62.         return true;
63. #else
64.         Json::Value root;
65.         root["x"] = x;
66.         root["y"] = y;
67.         root["op"] = op;
68.         Json::FastWriter w;
69.         *out = w.write(root);
72. #endif
74.     }
76.     bool deserialize(string &in)
77.     {
78. #ifdef MySelf
80.         size_t left = in.find(blank_space_sep);
81.         if (left == string::npos) return false;
82.         string part_x = in.substr(0, left);
83.         
84.         size_t right = in.rfind(blank_space_sep);
85.         if (right == string::npos) return false;
87.         string part_y = in.substr(right + 1);
88.         
89.         if (left + 2 != right) return false;
91.         op = in[left + 1];
92.         x = stoi(part_x);
93.         y = stoi(part_y);
95.         return true;
96. #else
97.         Json::Value root;
98.         Json::Reader r;
99.         r.parse(in, root); //反序列化
100.         x = root["x"].asInt();
101.         y = root["y"].asInt();
102.         op = root["op"].asInt();
105. #endif
106.     }
108.     void DebugPrint()
109.     {
110.         cout << "构建请求完成: " << x << op << y <<  "?= " << endl;   
112.     }
114. public:
115.     int x;
116.     int y;
117.     char op;  // + - * / %
118. };
120. class Response
121. {
122. public:
123.     Response(){}
124.     Response(int res, int c)
125.         : result(res), code(c)
126.     {
128.     }
130.     bool serialize(string *out)
131.     {
132. #ifdef MySelf
133.         string s = to_string(result);
134.         s += blank_space_sep;
135.         s += to_string(code);
136.    
137.         *out += s;
138.         return true;
139. #else
140.         Json::Value root;
141.         root["result"] = result;
142.         root["code"] = code;   
144. #endif
145.     }
147.     bool deserialize(string &in)
148.     {
149. #ifdef MySelf
151.         size_t pos = in.find(blank_space_sep);
152.         if (pos == string::npos) return false;
153.         string part_left = in.substr(0, pos);
154.         string part_right = in.substr(pos + 1, string::npos);
156.         result = stoi(part_left);
157.         code = stoi(part_right);
158.         return true;
159. #else
160.     Json::Value root;
161.     Json::Reader r;
162.     r.parse(in, root);
163.     result = root["result"].asInt();
164.     code = root["code"].asInt();
165. #endif
166.     }
167.    
170. public:
171.     int result;
172.     int code;  //0， 可信，否则!0具体是几， 表明对应的错误原因。
174. };

复制代码

运行结果

        我们完成了客户端， 服务端上一节课也完成了。 如今我们就能让网络盘算器跑起来了。 看一下运行结果：先启动服务端

        再启动客户端：

 ——————以上就是本节全部内容哦， 如果对友友们有资助的话可以关注博主， 方便学习更多知识哦！！！ 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。