目录
一、“协议” 的概念
二、结构化数据的传输
三、序列化和反序列化
序列化和反序列化的目的
四、网络版本计算器
服务端（server）
协议定制（protocal）
客户端（client）
服务器处理请求逻辑（Routine）
存在的问题（'bug'）
代码测试（test）
一、“协议” 的概念
协议，网络协议的简称，网络协议是通信计算机双方必须共同遵从的一组约定，比如怎么建立连接，怎么互相识别。
为了使数据在网络上能够从源端口到目的端口，网络通信双方必须遵守相同的规则，将这套规则称为协议（protocol），而协议最终都需要通过计算机语言的方式表示出来，只有通信计算机双方都遵守相同的协议，计算机之间才能互相通信交流。
二、结构化数据的传输
通信双方在进行网络通信时：
• 如果需要传输的数据时一个字符串，那么可以直接将这一字符串发送到网络中，此时对端也能从网络当中获取到这个字符串。
• 如果需要传输的是一些结构化的数据，此时就不能将这些数据一个一个发送到网络中了。
客户端最好把这些结构化的数据打包成一个整体后发送到网络中，服务器每次从网络中获取的数据就是一个完整的请求数据了。
比如实现一个网络版本计算器，需要客户端把要计算的两个数据，以及操作符发送过去，然后由服务器进行计算，最后将计算结果返回给客户端：
约定方案一：
• 客户端发送形如 ‘‘1+1’’的字符串。
• 这个字符串中有两个操作数，都是整型。
• 两个数字之间会有一个字符是运算符。
• 数字和运算符之间没有空格。
此时服务器再以相同方式对这个字符串进行解析，就可以从字符串中提取这些结构化数据。
约定方案二：
• 定制结构体来表示需要交换的信息。
• 发送数据时将这个结构体按照一个规则转换成网络标准数据格式，接受数据时再按照相同的规则把接受到的数据转化为结构体。
• 这个过程叫做 “序列化” 和 “反序列化”。
客户端可以定制一个结构体，将需要交互的信息定义到这个结构体中，客户端发送数据时先将数据进行序列化，服务端接收到数据化再对其进行反序列化，此时服务端就能得到客户端所发送过来的结构体了，再从结构体中提取出需要的数据。
三、序列化和反序列化
• 序列化是将对象的状态信息转换为可以存储或者传输的形式（字节序列）的过程。
• 反序列化是把字节序列恢复为对象的过程。
序列化和反序列化的目的
• 在网络传输时，序列化的目的是为了方便网络数据的发送和接收，无论是何种类型的数据，经过序列化之后都会变成二进制序列，此时底层在进行网络数据传输时看到的都是统一的二进制序列。
• 序列化或的二进制序列只有在网络传输时能被底层识别，上层应用是无法识别序列化后的二进制序列的，因此需要将从网络中获取的数据进行反序列化，将二进制序列的数据转换成应用层能够识别的数据格式。
四、网络版本计算器
服务端（server）
首先对服务器进行初始化：
• 调用 socket 函数，创建套接字
• 调用 bind 函数，对服务器进行绑定端口号等。
• 调用 listen 函数，将套接字设置成监听状态。
其次对服务器进行启动：
不断调用 accept 函数，从套接字中不断获取新连接，这里采用多线程版本，每当获取到一个新的连接后，就创建一个新线程，让新线程对客户端发来的数据进行计算服务。
#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <cstring>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
using namespace std;
#define backlog 5
// ./server 8080
int main(int argc, char *argv[])
{
if (argc != 2)
{
cerr << "Usage: " << argv[0] << "port" << endl;
exit(1);
}
int port = atoi(argv[1]);
// 1、创建套接字
int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
if (listen_sock < 0)
{
cerr << "listen_sock error!" << endl;
exit(2);
}
// 2、绑定
struct sockaddr_in local;
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_addr.s_addr = htonl(INADDR_ANY); // 主机转网络
local.sin_port = htons(port);
if (bind(listen_sock, (struct sockaddr *)&local, sizeof(local)) < 0)
{
cerr << "bind fail!" << endl;
exit(3);
}
// 3、设置监听状态
if (listen(listen_sock, backlog) < 0)
{
cerr << "listen fail!" << endl;
exit(4);
}
// 4、启动服务器
struct sockaddr_in peer;
memset(&peer, 0, sizeof(peer));
for (;;)
{
socklen_t socklen = sizeof(peer);
//一直获取新连接
int sock = accept(listen_sock, (struct sockaddr *)&peer, &socklen);
if(sock < 0)
{
cerr<<"accept fail!"<<endl;
continue;//继续获取新连接
}
//创建新线程
pthread_t tid = 0;
int *p = new int(sock);
pthread_create(&tid, nullptr, Rountine, p);//回调函数，将sock作为参数传递
}
return 0;
}说明：
• 为了避免创建出来的套接字被下一次创建的套接字覆盖，采用在堆上开辟空间存储的形式存储该文件描述符。
协议定制（protocal）
数据可以分为请求数据和响应数据进行定制协议，采用结构体的方式来实现：
• 请求结构体：需要包含两个操作数，以及所所对应的操作符。
• 响应结构体：需要包含一个计算结果，和一个状态结果，用来标识本次计算的状态，因为可以本次计算出现异常（除0等）。
状态码规定：
• 状态码为0：表示计算成功，无异常现象。
• 状态码为1：表示出现除 0 异常。
• 状态码为2：表示出现模 0 异常。
• 状态码为3：表示其他非法计算，如输入错误的操作符等。
#pragma once
typedef struct request
{
int x;//左操作数
int y;//右操作数
char op;//操作符
} request;
typedef struct response
{
int code;//状态码
int result;//计算结果
} response;客户端（client）
首先对客户端进行初始化：
• 调用 socket 函数，创建套接字。
• 初始化完毕后，调用 connect 函数进行对服务器的连接，其次将请求发送给服务器。
• 客户端等待服务器处理完毕，发送回来结果后，还需要读取服务端的响应数据。
发送数据时：使用 write 或者 send 函数，这些函数的本质都是拷贝函数。
接收数据时：使用 read 或者 recv 函数，本质也是拷贝函数。
#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <cstring>
#include <string>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
using namespace std;
#include "protocal.h"
// ./client 127.0.0.1 8080
int main(int argc, char *argv[])
{
if (argc != 3)
{
cerr << "Usage: " << argv[0] << " server_ip server_port " << endl;
exit(1);
}
std::string server_ip = argv[1];
int server_port = atoi(argv[2]);
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
cerr << "sock error!" << endl;
exit(2);
}
// 建立连接
struct sockaddr_in peer;
memset(&peer, 0, sizeof(peer));
peer.sin_family = AF_INET;
peer.sin_port = htons(server_port);
peer.sin_addr.s_addr = inet_addr(server_ip.c_str()); // 网络转主机 inet_addr
if (connect(sock, (struct sockaddr *)&peer, sizeof(peer)) < 0)
{
cerr << "connect fail!" << endl;
exit(3);
}
// 发送请求
while (1)
{
request req;
cout << "请输入左操作数# ";
cin >> req.x;
cout << "请输入右操作数# ";
cin >> req.y;
cout << "请输入操作符[+-*/%]# ";
cin >> req.op;
send(sock, &req, sizeof(req), 0);
// 接受数据
response res;
recv(sock, &res, sizeof(res), 0); // 阻塞式
cout << "status: " << res.code << endl;
cout << req.x << req.op << req.y << " = " << res.result << endl;
}
return 0;
}服务器处理请求逻辑（Routine）
创建出来的新线程，需要对客户端发送到计算请求进行读取，然后进行计算操作，如果在计算过程中，出现除0等情况，只需要对 response 结构体填充进对应的状态码即可。
void *Rountine(void *arg)
{
// 线程分离，不需要再 wait
pthread_detach(pthread_self());
int sock = *(int *)arg;
delete (int *)arg;
while (1)
{
request req;
ssize_t n = recv(sock, &req, sizeof(req), 0);
if (n > 0)
{
// 进行计算任务
response res = {0, 0};
switch (req.op)
{
case '+':
res.result = req.x + req.y;
break;
case '-':
res.result = req.x - req.y;
break;
case '*':
res.result = req.x * req.y;
break;
case '/':
if (req.y == 0)
{
res.code = 1;
}
else
{
res.result = req.x / req.y;
}
break;
case '%':
if (req.y == 0)
{
res.code = 2;
}
else
{
res.result = req.x % req.y;
}
break;
default:
res.code = 3;
break;
}
// 将结果发送回客户端
send(sock, &res, sizeof(res), 0);
}
else if (n == 0)
{
// 对端停止发送数据，退出了
cout << "Client quit,me too!" << endl;
break;
}
else
{
cerr << "recv error!" << endl;
break;
}
}
close(sock);
return nullptr; // 返回结果
}存在的问题（'bug'）
• 在发送和接收数据时没有进行对数据的序列化以及反序列化。
代码测试（test）
先运行服务器，./ server 8080 绑定端口号，再运行客户端 ./client 127.0.0.1 8080，然后进行发送数据，让服务器进行计算：
