实现网络版加法计算器

再谈“协议”

1. 基本概念

        我们知道,协议就是一种“约定”。套接字实现的网络通信的接口,在读写数据时,都是按照“字符串”的方式来发送和接收的,那如果我们要传输一些“结构化的数据”,该怎么办呢?

        这里我们就要提出两个概念:

(1)序列化:将对象的状态信息转化为可以存储或是可以传输的形式的过程,比如将结构体等类型转化为字符串类型;

(2)反序列化:将可以存储或是可以传输的形式转化为对象的状态信息的过程,比如将字符串类型转化为结构体等类型。

2. 具体实现

        比如,我们要实现一个网络版的加法计算器,有两种方法:

(1)客户端向服务器端发送一个形容“1+1”的字符串,该字符串以“+”为分隔,有两个操作数,且两个操作数都是整型,“+”即为运算符,且只能是“+”,同时数字与运算符间不能有空格。

(2)我们可以定义两个结构体来表示我们要交互的信息,一个用于传输要计算的数据,一个用于接收计算后的结果。发送数据时通过序列化将数据转换为一个字符串,接收时通过反序列化再将字符串转回结构体,具体实现代码如下:

1)要用到的头文件,以及结构体的定义:

#pragma once                                                                                                                                          

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define MAXSIZE 128

typedef struct
{//客服端发送的用于计算的两个数据
    int x;
    int y;
}request;

typedef struct
{//服务器端计算完返回给客户端的值
    int res;
}response;

2)服务器端——计算两个数的和

//实现网络版加法计算器,利用TCP多线程服务器计算客户端发过来数的和                                                                                     
#include "comm.h"

typedef struct
{
    int sock;
    char ip[24];
    int port;
}net_info_t;

int startup(int port, char* ip) 
{
    //1.创建套接字,这里是流式的套接字,因为TCP面向字节流
    int sock = socket(AF_INET, SOCK_STREAM, 0); 
    if(sock < 0)
    {   
        printf("socket error\n");
        exit(2);//套接字创建失败,直接终止进程,因为没有套接字网络通信根本无法实现,后续代码根本不用执行
    }   
    //2.绑定
    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);//端口号
    local.sin_addr.s_addr = inet_addr(ip);//IP

    if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    {   
        printf("bind error\n");
        exit(3);
    }   

    //3.监听:一直等待客户来连接(因为TCP是面向连接的),提取新连接;
    if(listen(sock, 5) < 0)//最多容纳5个客户连接请求
    {   
        printf("listen error\n");
        exit(4);
    }
    return sock;//返回一个监听套接字
}

void service(int sock, char* ip, int port)
{
    while(1)
    {
        request r;
        //read函数可以读取任意类型的内容
        ssize_t s = read(sock, &r, sizeof(r));
        response rp;
        rp.res = r.x + r.y;
        write(sock, &rp, sizeof(rp));
    }
}

void* thread_service(void* arg)
{
    net_info_t *p = (net_info_t* )arg;
    service(p->sock, p->ip, p->port);

    close(p->sock);
    free(p);
}

//./tcp_server 127.0.0.1 8080                                                                                                                         
int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        printf("Usage: %s [ip] [port]\n", argv[0]);
        exit(1);
    }
    
    //创建套接字
    int listen_sock = startup(atoi(argv[2]), argv[1]);
    
    struct sockaddr_in peer;
    char ipbuf[24];
    for( ; ; )
    {
        ipbuf[0] = 0;
        socklen_t len = sizeof(peer);
        //从监听套接字中拿连接
        int new_sock = accept(listen_sock, (struct sockaddr*)&peer, &len);
        if(new_sock < 0)//拿连接失败,不用管,因为还可以去拿其他连接
        {
            printf("accept error\n");
            continue;
        }
        //获得了一个新连接
        inet_ntop(AF_INET, (const void*)&peer.sin_addr, ipbuf, sizeof(ipbuf));//将四字节IP地址转换为点分十进制
        int p = ntohs(peer.sin_port);//端口号:网络序列转换为主机序列的端口号
        printf("get a new connect,[%s:%d]\n", ipbuf, p);//将新连接的IP和端口号打印

        //这里不用像多进程的版本关闭多余的文件描述符
        //因为线程共享地址空间,关掉一个文件,其他线程就看不到用不了了
        net_info_t* info = (net_info_t*)malloc(sizeof(net_info_t));
        if(info == NULL)
        {                                                                                                                                             
            perror("malloc");
            close(new_sock);
            continue;
        }
        info->sock = new_sock;
        strcpy(info->ip,ipbuf);
        info->port = p;

        pthread_t tid;
        pthread_create(&tid, NULL, thread_service, (void* )info);
        pthread_detach(tid);//线程分离后,该线程的资源会自动释放
    }
    return 0;
}           

3)客户端——发送要计算的数据,以及接收计算结果

//客户端,输入两个用于加法计算的数                                                                                                                     
#include "comm.h"

//./tcp_client 127.0.0.1 8080
int main(int argc, char* argv[])
{
    if(argc != 3)
    {   
        printf("Usage: %s [ip] [port]\n", argv[0]);
        return 1;
    }   
    //创建套接字
    int sock = socket(AF_INET, SOCK_STREAM, 0); 
    if(sock < 0)
    {   
        printf("socket error\n");
        return 2;
    }   
    //客户端不用绑定(bind),不用监听(listen),不用获取新连接(accept)
    
    //客户端有一个个性化操作connect,向服务器发起连接
    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);
    if(connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0)
    {   
        printf("connect error\n");
        return 3;
    }   
    //走到这,连接成功

    //发送数据,并收回结果
    char buf[MAXSIZE];
    while(1)
    {
        request r;
        printf("please enter# ");
        fflush(stdout);
        scanf("%d%d", &r.x, &r.y);

        write(sock, &r, sizeof(r));

        response rp;
        read(sock, &rp, sizeof(rp));

        printf("%d+%d = %d\n", r.x, r.y, rp.res);
        
    }
    close(sock);
    return 0;
}             

4)运行结果:

        因为上述代码实现的是多线程版本,所以可以接受多个连接请求,具体测试结果如下:

实现网络版加法计算器_第1张图片

你可能感兴趣的:(Linux,网络版加法计算器,协议,序列化,反序列化)