devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

网络编程 -- 简易TCP网络程序

作者：weixin_40725706 | 2024-04-21 20:37:05

赞

踩

网络编程 -- 简易TCP网络程序

一 字符串回响

1.1 核心功能

  字符串回响程序类似于 echo 指令，客户端向服务器发送消息，服务器在收到消息后会将消息发送给客户端，该程序实现起来比较简单，同时能很好的体现 socket 套接字编程的流程。

  

1.2 程序结构

  这个程序我们已经基于 UDP 协议实现过了，换成 TCP 协议实现时，程序的结构是没有变化的，同样需要 server.hpp、server.cc、client.hpp、client.cc 这几个文件。

server.hpp 头文件

  1.  #pragma once
  2.  
  3. #include<iostream>
  4. #include<sys/types.h>
  5. #include<sys/socket.h>
  6. #include<netinet/in.h>
  7. #include<arpa/inet.h>
  8. #include "err.hpp"
  9. #include<cstring>
  10.  
  11. namespace My_server{
  12.  
  13.     const uint16_t default_port = 8888; // 默认端口号
  14.     class server{
  15.     public:
  16.  
  17.         server(const uint16_t port = default_port)
  18.             :_port(port)
  19.         {}
  20.  
  21.         ~server()
  22.         {}
  23.  
  24.         // 初始化服务器
  25.         void InitServer(){
  26.          
  27.         }
  28.  
  29.         // 启动服务器
  30.         void StartServer()
  31.         {}
  32.  
  33.     private:
  34.         int _sock; // 套接字（存疑）
  35.         uint16_t _port; // 端口号
  36.     };
  37. }

注意： 这里的 _sock 套接字成员后面需要修改

server.cc 头文件

  1. //智能指针头文件
  2. #include<memory>
  3. #include"server.hpp"
  4.  
  5. using namespace My_server;
  6.  
  7. int main(){
  8.  
  9.     std::unique_ptr<server> usvr(new server());
  10.      
  11.     usvr->InitServer();
  12.     
  13.     usvr->StartServer();
  14.  
  15.     return 0;
  16. }

创建 client.hpp 客户端头文件

  1. #pragma once
  2.  
  3. #include<iostream>
  4. #include<string>
  5. #include<sys/types.h>
  6. #include<sys/socket.h>
  7. #include<netinet/in.h>
  8. #include<arpa/inet.h>
  9. #include"err.hpp"
  10.  
  11. namespace My_client{
  12.    
  13.    class client{
  14.      public:
  15.         client(const std::string& ip,const uint16_t port)
  16.          :server_ip(ip)
  17.          ,server_port(port)
  18.         {}
  19.  
  20.         ~client(){}
  21.         
  22.         //初始化客户端
  23.         void InitClient(){}
  24.  
  25.         // 启动客户端
  26.         void StartClient(){}
  27.  
  28.      private:
  29.        int _sock;// 套接字
  30.        std::string server_ip;//服务器ip
  31.        uint16_t server_port; //服务器端口号
  32.  
  33.    };
  34. }

创建client.cc文件
 

  1. #include"client.hpp"
  2. #include<memory>
  3.  
  4. using namespace My_client;
  5.  
  6. void Usage(char* program){
  7.  
  8.     std::cout<<"Usage : "<<std::endl;
  9.     std::cout<<"\t "<<program<<" ServerIP ServerPort"<<std::endl;
  10.  
  11. }
  12.  
  13. int main(int argc,char *argv[]){
  14.    
  15.    if(argc!=3){
  16.       Usage(argv[0]);
  17.       return USAGE_ERR;
  18.    }
  19.    
  20.    //获取服务器IP地址和端口号
  21.     std::string ip(argv[1]);
  22.     uint16_t port=std::stoi(argv[2]);
  23.  
  24.     std::unique_ptr<client> usvr(new client(ip,port));
  25.  
  26.     usvr->InitClient();
  27.     usvr->StartClient();
  28.     
  29.     return 0;
  30. }

同时需要Makefile文件

  1. .PHONY:all
  2. all:server client
  3.  
  4. server:server.cc
  5. 	g++ -o $@ $^ -std=c++14
  6.  
  7. client:client.cc
  8. 	g++ -o $@ $^ -std=c++14
  9.  
  10. .PHONY:clean
  11. clean:
  12. 	rm -rf server client

和 err.hpp 头文件

  1. #pragma once
  2.  
  3. // 错误码
  4. enum
  5. {
  6.     USAGE_ERR=1 ,
  7.     SOCKET_ERR,
  8.     BIND_ERR
  9. };

1.3 服务端

1.3.1 初始化服务端  

  基于 TCP 协议实现的网络程序也需要 创建套接字、绑定 IP 和端口号

在使用 socket 函数创建套接字时，UDP 协议需要指定参数2为 SOCK_DGRAM，TCP 协议则是指定参数2为 SOCK_STREAM

InitServer() 初始化服务器函数 — 位于 server.hpp 服务器头文件中的 server 类

  1.  #pragma once
  2.  
  3. #include<iostream>
  4. #include<sys/types.h>
  5. #include<sys/socket.h>
  6. #include<netinet/in.h>
  7. #include<arpa/inet.h>
  8. #include "err.hpp"
  9. #include<cstring>
  10.  
  11. namespace My_server{
  12.  
  13.     const uint16_t default_port = 8888; // 默认端口号
  14.     class server{
  15.     public:
  16.  
  17.         server(const uint16_t port = default_port)
  18.             :_port(port)
  19.         {}
  20.  
  21.         ~server()
  22.         {}
  23.  
  24.         // 初始化服务器
  25.         void InitServer(){
  26.  
  27.           //1 创建套接字
  28.            _sock = socket(AF_INET,SOCK_STREAM,0);
  29.            if(_sock==-1){
  30.               //绑定失败
  31.               std::cerr<<"Create Socket Fail!"<<strerror(errno)<<std::endl;
  32.               exit(SOCKET_ERR);
  33.            }
  34.  
  35.            std::cout<<"Create Socket Success!"<<_sock<<std::endl;
  36.           //2 绑定端口号和IP地址
  37.           
  38.           struct sockaddr_in lockal;
  39.           bzero(&lockal,sizeof lockal);
  40.  
  41.           lockal.sin_family = AF_INET;
  42.           lockal.sin_addr.s_addr = INADDR_ANY;
  43.           lockal.sin_port = htons(_port);
  44.  
  45.           if(bind(_sock,(const sockaddr*)&lockal,sizeof(lockal))){
  46.             std::cout<<"Bind IP&&Port Fali:"<<strerror(errno)<<std::endl;
  47.             exit(BIND_ERR);
  48.           }
  49.          
  50.         }
  51.  
  52.         // 启动服务器
  53.         void StartServer()
  54.         {}
  55.  
  56.     private:
  57.         int _sock; // 套接字（存疑）
  58.         uint16_t _port; // 端口号
  59.     };
  60. }

注意： 在绑定端口号时，一定需要把主机序列转换为网络序列

  为什么在绑定端口号阶段需要手动转换为网络序列，而在发送信息阶段则不需要？ 这是因为在发送信息阶段，recvfrom / sendto 等函数会自动将需要发送的信息转换为网络序列，接收信息时同样会将其转换为主机序列，所以不需要手动转换

  如果使用的 UDP 协议，那么初始化服务器到此就结束了，但我们本文中使用的是 TCP 协议，这是一个 面向连接 的传输层协议，意味着在初始化服务器时，需要设置服务器为 监听 状态

  使用到的函数是 listen 函数

  1. #include <sys/types.h>          /* See NOTES */
  2. #include <sys/socket.h>
  3.  
  4. int listen(int sockfd, int backlog);

返回值：监听成功返回 0，失败返回 -1.

  listen函数 使得一个进程可以接受其它进程的请求，从而成为一个服务器进程。在TCP服务器编程中listen函数把进程变为一个服务器，并指定相应的套接字变为被动连接。

  这里的参数2需要设置一个整数，通常为 16、32、64...，表示 全连接队列 的最大长度，关于 全连接队列 的详细知识放到后续博客中讲解，这里只需要直接使用。

server.hpp 服务器头文件

  我们改变一下网络文件的名字

  1.  #pragma once
  2.  
  3. #include<iostream>
  4. #include<cerrno>
  5. #include<sys/types.h>
  6. #include<sys/socket.h>
  7. #include<netinet/in.h>
  8. #include<arpa/inet.h>
  9. #include "err.hpp"
  10. #include<cstring>
  11.  
  12. namespace My_server{
  13.  
  14.     const uint16_t default_port = 8888; // 默认端口号
  15.     const int backlog=32; //全连接队列的最大长度
  16.  
  17.     class server{
  18.     public:
  19.  
  20.         server(const uint16_t port = default_port)
  21.             :_port(port)
  22.         {}
  23.  
  24.         ~server()
  25.         {}
  26.  
  27.         // 初始化服务器
  28.         void InitServer(){
  29.  
  30.           //1 创建套接字
  31.            _listensock = socket(AF_INET,SOCK_STREAM,0);
  32.            if(_listensock==-1){
  33.               //绑定失败
  34.               std::cerr<<"Create Socket Fail!"<<strerror(errno)<<std::endl;
  35.               exit(SOCKET_ERR);
  36.            }
  37.  
  38.            std::cout<<"Create Socket Success!"<<_listensock<<std::endl;
  39.  
  40.           //2 绑定端口号和IP地址
  41.           struct sockaddr_in local;
  42.           bzero(&local,sizeof(local));
  43.           local.sin_family = AF_INET;
  44.           local.sin_addr.s_addr = INADDR_ANY;//绑定任意可用IP地址
  45.           local.sin_port = htons(_port);
  46.  
  47.           if(bind(_listensock,(const sockaddr*)&local,sizeof(local))){
  48.  
  49.             std::cout<<"Bind IP&&Port Fali:"<<strerror(errno)<<std::endl;
  50.             exit(BIND_ERR);
  51.  
  52.           }
  53.          
  54.          //3. 监听
  55.          if(listen(_listensock,backlog) == -1){
  56.             std::cerr << "Listen Fail!" << strerror(errno) << std::endl;
  57.             //新增一个报错
  58.             exit(LISTEN_ERR);
  59.          }
  60.          std::cout<<"Listen Success!"<<std::endl;
  61.          
  62.         }
  63.  
  64.         // 启动服务器
  65.         void StartServer()
  66.         {}
  67.  
  68.     private:
  69.         int _listensock; // 套接字（存疑）
  70.         uint16_t _port; // 端口号
  71.     };
  72. }

  至此基于  TCP 协议 实现的初始化服务器函数就填充完成了，编译并运行服务器，显示初始化服务器成功。

// 示例代码中端口号为8088

1.3.2 启动服务器

1.3.2.1 处理连接请求

  TCP 是面向连接，当有客户端发起连接请求时，TCP 服务器需要正确识别并尝试进行连接，当连接成功时，与其进行通信，可使用 accept 函数进行连接。

  1. #include <sys/types.h>          /* See NOTES */
  2. #include <sys/socket.h>
  3.  
  4. int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

参数解读：

  • sockfd 服务器用于处理连接请求的 socket 套接字
  • addr 客户端的 sockaddr 结构体信息
  • addrlen 客户端的 sockaddr 结构体大写

  其中 addr 与 addrlen 是一个 输入输出型 参数，类似于 recvfrom 中的参数。

  返回值：连接成功返回一个用于通信的 socket 套接字（文件描述符），失败返回 -1。

  这也就意味着之前我们在 TcpServer 中创建的类内成员 sock_ 并非是用于通信，而是专注于处理连接请求，在 TCP 服务器中，这种套接字称为 监听套接字

使用 accept 函数处理连接请求

server.hpp 服务器头文件

  1.  #pragma once
  2.  
  3. #include<iostream>
  4. #include<cerrno>
  5. #include<sys/types.h>
  6. #include<sys/socket.h>
  7. #include<netinet/in.h>
  8. #include<arpa/inet.h>
  9. #include "err.hpp"
  10. #include<cstring>
  11.  
  12. namespace My_server{
  13.  
  14.     const uint16_t default_port = 8888; // 默认端口号
  15.     const int backlog=32; //全连接队列的最大长度
  16.  
  17.     class server{
  18.     public:
  19.  
  20.         server(const uint16_t port = default_port)
  21.             :_port(port)
  22.         {}
  23.  
  24.         ~server()
  25.         {}
  26.  
  27.         // 初始化服务器
  28.         void InitServer(){
  29.  
  30.           //1 创建套接字
  31.            _listensock = socket(AF_INET,SOCK_STREAM,0);
  32.            if(_listensock==-1){
  33.               //绑定失败
  34.               std::cerr<<"Create Socket Fail!"<<strerror(errno)<<std::endl;
  35.               exit(SOCKET_ERR);
  36.            }
  37.  
  38.            std::cout<<"Create Socket Success!"<<_listensock<<std::endl;
  39.  
  40.           //2 绑定端口号和IP地址
  41.           struct sockaddr_in local;
  42.           bzero(&local,sizeof(local));
  43.           local.sin_family = AF_INET;
  44.           local.sin_addr.s_addr = INADDR_ANY;//绑定任意可用IP地址
  45.           local.sin_port = htons(_port);
  46.  
  47.           if(bind(_listensock,(const sockaddr*)&local,sizeof(local))){
  48.  
  49.             std::cout<<"Bind IP&&Port Fali:"<<strerror(errno)<<std::endl;
  50.             exit(BIND_ERR);
  51.  
  52.           }
  53.          
  54.          //3. 监听
  55.          if(listen(_listensock,backlog) == -1){
  56.             std::cerr << "Listen Fail!" << strerror(errno) << std::endl;
  57.             //新增一个报错
  58.             exit(LISTEN_ERR);
  59.          }
  60.          std::cout<<"Listen Success!"<<std::endl;
  61.          
  62.         }
  63.  
  64.         // 启动服务器
  65.         void StartServer(){
  66.             
  67.             while(!_quit){
  68.                 //1 处理连接请求
  69.                 struct sockaddr_in client;
  70.                 socklen_t len=sizeof(client);
  71.  
  72.                 int sock=accept(_listensock,(struct sockaddr*)&client,&len);
  73.  
  74.                 //2 如果连接失败 继续尝试连接
  75.                 if(sock==-1){
  76.                   std::cerr<<"Accept Fail!"<<strerror(errno)<<std::endl;
  77.                   continue;
  78.                 }
  79.  
  80.                 //连接成功，获取客户端信息
  81.                 std::string clientip=inet_ntoa(client.sin_addr);
  82.                 uint16_t clientport= ntohs(client.sin_port);
  83.  
  84.                 std::cout<<"Server accept"<<clientip + "-"<<clientport<<sock<<" from "<<_listensock<<" success!"<<std::endl;
  85.  
  86.                 //3 这里因为是字节流传递，一般而言我们会自己写一个函数
  87.                 Service(sock,clientip,clientport);
  88.             }
  89.  
  90.         }
  91.  
  92.     private:
  93.         int _listensock; // 套接字（存疑）
  94.         uint16_t _port; // 端口号
  95.         bool _quit; // 判断服务器是否结束运行
  96.     };
  97. }
1.3.2.2 业务处理

对于 TCP 服务器来说，它是面向字节流传输的，我们之前使用的文件相关操作也是面向字节流，凑巧的是在 Linux 中网络是以挂接在文件系统的方式实现的，种种迹象表明：可以通过文件相关接口进行通信

  • read 从文件中读取信息（接收消息）
  • write 向文件中写入信息（发送消息）

这两个系统调用的核心参数是 fd（文件描述符），即服务器与客户端在连接成功后，获取到的 socket 套接字，所以接下来可以按文件操作的套路，完成业务处理

Service() 业务处理函数 — 位于 server.hpp 服务器头文件中的 server 类

  1.   void Service(int sock,const std::string& clientip,const uint16_t& clientport){
  2.  
  3.             char buff[1024];
  4.             std::string who=clientip + "-" + std::to_string(clientport);
  5.             while(true){
  6.                 //以C语言格式读取，预留'\0'的位置
  7.                 ssize_t n = read(sock,buff,sizeof(buff)-1);
  8.                 if(n>0){
  9.                 //读取成功
  10.                 std::cout<<"Server get: "<<buff<<" from "<<who<<std::endl;
  11.                 //实际处理可以交给上层逻辑指定
  12.                 std::string respond = _func(buff);
  13.                 //发送给服务器
  14.                 write(sock,buff,strlen(buff));
  15.                }
  16.                else if(n==0){
  17.  
  18.                 //表示当前读到了文件末尾，结束读取
  19.                 std::cout<<"Client "<<who<<" "<<sock<<" quit!"<<std::endl;
  20.                 close(sock);
  21.                 break;
  22.                }
  23.                else{
  24.                  // 读取出问题（暂时）
  25.                   std::cerr << "Read Fail!" << strerror(errno) << std::endl;
  26.                   close(sock); // 关闭文件描述符
  27.                    break;
  28.                }
  29.             }
  30.         }
1.3.2.2.1 回调函数

为了更好的实现功能解耦，这里将真正的业务处理函数交给上层处理，编写完成后传给 TcpServer 对象即可，当然，在 TcpServer 类中需要添加对应的类型

这里设置回调函数的返回值为 string，参数同样为 string

  using func_t = std::function<std::string(std::string)>;

server.hpp 服务器头文件

  1.  #pragma once
  2.  
  3. #include<iostream>
  4. #include<cerrno>
  5. #include<sys/types.h>
  6. #include<sys/socket.h>
  7. #include<netinet/in.h>
  8. #include<arpa/inet.h>
  9. #include "err.hpp"
  10. #include<cstring>
  11. #include <unistd.h>
  12. #include<functional>
  13.  
  14. namespace My_server{
  15.  
  16.     const uint16_t default_port = 8888; // 默认端口号
  17.     const int backlog=32; //全连接队列的最大长度
  18.     
  19.     using func_t = std::function<std::string(std::string)>;
  20.     class server{
  21.     public:
  22.  
  23.         server(const func_t &func,const uint16_t port = default_port)
  24.             :_func(func)
  25.             ,_port(port)
  26.             ,_quit(false)
  27.         {}
  28.  
  29.         ~server()
  30.         {}
  31.  
  32.         // 初始化服务器
  33.         void InitServer(){
  34.  
  35.           //1 创建套接字
  36.            _listensock = socket(AF_INET,SOCK_STREAM,0);
  37.            if(_listensock==-1){
  38.               //绑定失败
  39.               std::cerr<<"Create Socket Fail!"<<strerror(errno)<<std::endl;
  40.               exit(SOCKET_ERR);
  41.            }
  42.  
  43.            std::cout<<"Create Socket Success!"<<_listensock<<std::endl;
  44.  
  45.           //2 绑定端口号和IP地址
  46.           struct sockaddr_in local;
  47.           bzero(&local,sizeof(local));
  48.           local.sin_family = AF_INET;
  49.           local.sin_addr.s_addr = INADDR_ANY;//绑定任意可用IP地址
  50.           local.sin_port = htons(_port);
  51.  
  52.           if(bind(_listensock,(const sockaddr*)&local,sizeof(local))){
  53.  
  54.             std::cout<<"Bind IP&&Port Fali:"<<strerror(errno)<<std::endl;
  55.             exit(BIND_ERR);
  56.  
  57.           }
  58.          
  59.          //3. 监听
  60.          if(listen(_listensock,backlog) == -1){
  61.             std::cerr << "Listen Fail!" << strerror(errno) << std::endl;
  62.             //新增一个报错
  63.             exit(LISTEN_ERR);
  64.          }
  65.          std::cout<<"Listen Success!"<<std::endl;
  66.          
  67.         }
  68.  
  69.         // 启动服务器
  70.         void StartServer(){
  71.             
  72.             while(!_quit){
  73.                 //1 处理连接请求
  74.                 struct sockaddr_in client;
  75.                 socklen_t len=sizeof(client);
  76.  
  77.                 int sock=accept(_listensock,(struct sockaddr*)&client,&len);
  78.  
  79.                 //2 如果连接失败 继续尝试连接
  80.                 if(sock==-1){
  81.                   std::cerr<<"Accept Fail!"<<strerror(errno)<<std::endl;
  82.                   continue;
  83.                 }
  84.  
  85.                 //连接成功，获取客户端信息
  86.                 std::string clientip=inet_ntoa(client.sin_addr);
  87.                 uint16_t clientport= ntohs(client.sin_port);
  88.  
  89.                 std::cout<<"Server accept"<<clientip + "-"<<clientport<<sock<<" from "<<_listensock<<" success!"<<std::endl;
  90.  
  91.                 //3 这里因为是字节流传递，一般而言我们会自己写一个函数
  92.                 Service(sock,clientip,clientport);
  93.             }
  94.         }
  95.  
  96.         void Service(int sock,const std::string& clientip,const uint16_t& clientport){
  97.  
  98.             char buff[1024];
  99.             std::string who=clientip + "-" + std::to_string(clientport);
  100.             while(true){
  101.                 //以C语言格式读取，预留'\0'的位置
  102.                 ssize_t n = read(sock,buff,sizeof(buff)-1);
  103.                 if(n>0){
  104.                 //读取成功
  105.                 std::cout<<"Server get: "<<buff<<" from "<<who<<std::endl;
  106.                 //实际处理可以交给上层逻辑指定
  107.                 std::string respond = _func(buff);
  108.                 //发送给服务器
  109.                 write(sock,buff,strlen(buff));
  110.                }
  111.                else if(n==0){
  112.  
  113.                 //表示当前读到了文件末尾，结束读取
  114.                 std::cout<<"Client "<<who<<" "<<sock<<" quit!"<<std::endl;
  115.                 close(sock);
  116.                 break;
  117.                }
  118.                else{
  119.                  // 读取出问题（暂时）
  120.                   std::cerr << "Read Fail!" << strerror(errno) << std::endl;
  121.                   close(sock); // 关闭文件描述符
  122.                    break;
  123.                }
  124.             }
  125.         }
  126.  
  127.     private:
  128.         int _listensock; // 套接字（存疑）
  129.         uint16_t _port; // 端口号
  130.         bool _quit; // 判断服务器是否结束运行
  131.         func_t _func;// 回调函数
  132.     };
  133. }
1.3.2.2.2 server.cc文件

对于当前的 TCP 网络程序（字符串回响）来说，业务处理函数逻辑非常简单，无非就是直接将客户端发送过来的消息，重新转发给客户端

server.cc 服务器源文件

  1. //智能指针头文件
  2. #include<memory>
  3. #include"server.hpp"
  4. #include<string>
  5.  
  6. using namespace My_server;
  7. // 业务处理回调函数（字符串回响）
  8. std::string echo(std::string request){
  9.     return request;
  10. }
  11.  
  12. int main(){
  13.  
  14.     std::unique_ptr<server> usvr(new server(echo));
  15.      
  16.     usvr->InitServer();
  17.     
  18.     usvr->StartServer();
  19.  
  20.     return 0;
  21. }

  尝试编译并运行服务器，可以看到当前 bash 已经被我们的服务器程序占用了，重新打开一个终端，并通过 netstat 命令查看网络使用情况（基于 TCP 协议）

1.4 客户端

1.4.1 初始化客户端

 对于客户端来说，服务器的 IP 地址与端口号是两个不可或缺的元素，因此在客户端类中，  server_ip 和 server_port 这两个成员是少不了的，当然得有 socket 套接字

初始化客户端只需要干一件事：创建套接字，客户端是主动发起连接请求的一方，也就意味着它不需要使用 listen 函数设置为监听状态

注意： 客户端也是需要 bind 绑定的，但不需要自己手动绑定，由操作系统帮我们自动完成

client.hpp 客户端头文件

  1. #pragma once
  2.  
  3. #include<iostream>
  4. #include<string>
  5. #include<sys/types.h>
  6. #include<sys/socket.h>
  7. #include<netinet/in.h>
  8. #include<arpa/inet.h>
  9. #include"err.hpp"
  10. #include<cerrno>
  11. #include<cstring>
  12.  
  13. namespace My_client{
  14.    
  15.    class client{
  16.      public:
  17.         client(const std::string& ip,const uint16_t port)
  18.          :server_ip(ip)
  19.          ,server_port(port)
  20.         {}
  21.  
  22.         ~client(){}
  23.         
  24.         //初始化客户端
  25.         void InitClient(){
  26.  
  27.            // 1. 创建套接字
  28.             _sock = socket(AF_INET, SOCK_STREAM, 0);
  29.             if (_sock == -1)
  30.             {
  31.                 std::cerr << "Create Socket Fail!" << strerror(errno) << std::endl;
  32.                 exit(SOCKET_ERR);
  33.             }   
  34.             std::cout << "Create Sock Succeess! " << _sock << std::endl;
  35.             
  36.  
  37.         }
  38.  
  39.         // 启动客户端
  40.         void StartClient(){}
  41.  
  42.      private:
  43.        int _sock;// 套接字
  44.        std::string server_ip;//服务器ip
  45.        uint16_t server_port; //服务器端口号
  46.  
  47.    };
  48. }

1.4.2 启动客户端

1.4.2.1 尝试进行连接

  因为 TCP 协议是面向连接的，服务器已经处于处理连接请求的状态了，客户端现在需要做的就是尝试进行连接，使用 connect 函数进行连接。

  1. #include <sys/types.h>          /* See NOTES */
  2. #include <sys/socket.h>
  3.  
  4. int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

参数解读：

  • sockfd 需要进行连接的套接字
  • addr 服务器的 sockaddr 结构体信息
  • addrlen 服务器的 sockaddr 结构体大小

返回值：连接成功返回 0，连接失败返回 -1.

  在连接过程中，可能遇到很多问题，比如 网络传输失败、服务器未启动 等，这些问题的最终结果都是客户端连接失败，如果按照之前的逻辑（失败就退出），那么客户端的体验感会非常不好，因此在面对连接失败这种常见问题时，客户端应该尝试重连，如果重连数次后仍然失败，才考虑终止进程

注意： 在进行重连时，可以使用 sleep() 等函数使程序睡眠一会，给网络恢复留出时间

StartClient() 启动客户端函数 — 位于 client.hpp 中的client 类.

  1. #pragma once
  2.  
  3. #include<iostream>
  4. #include<string>
  5. #include<sys/types.h>
  6. #include<sys/socket.h>
  7. #include<netinet/in.h>
  8. #include<arpa/inet.h>
  9. #include"err.hpp"
  10. #include<cerrno>
  11. #include<cstring>
  12. #include<unistd.h>
  13. namespace My_client{
  14.    
  15.    class client{
  16.      public:
  17.         client(const std::string& ip,const uint16_t port)
  18.          :server_ip(ip)
  19.          ,server_port(port)
  20.         {}
  21.  
  22.         ~client(){}
  23.         
  24.         //初始化客户端
  25.         void InitClient(){
  26.  
  27.            // 1. 创建套接字
  28.             _sock = socket(AF_INET, SOCK_STREAM, 0);
  29.             if (_sock == -1)
  30.             {
  31.                 std::cerr << "Create Socket Fail!" << strerror(errno) << std::endl;
  32.                 exit(SOCKET_ERR);
  33.             }   
  34.             std::cout << "Create Sock Succeess! " << _sock << std::endl;
  35.             
  36.  
  37.         }
  38.  
  39.         // 启动客户端
  40.         void StartClient(){
  41.           
  42.           //填充服务器的sockaddr_int 结构体信息
  43.           struct sockaddr_in server;
  44.           socklen_t len=sizeof(server);
  45.           bzero(&server,len);
  46.           server.sin_family = AF_INET;
  47.           inet_aton(server_ip.c_str(), &server.sin_addr); // 将点分十进制转化为二进制IP地址的另一种方法
  48.           server.sin_port = htons(server_port);
  49.  
  50.           //尝试重连五次
  51.           int n=5;
  52.           while(n){
  53.             int ret = connect(_sock,(const struct sockaddr*)&server,len);
  54.             if(ret==0){
  55.                // 连接成功，可以跳出循环
  56.                break;
  57.             }
  58.                  // 尝试进行重连
  59.              std::cerr << "网络异常，正在进行重连... 剩余连接次数: " << --n << std::endl;
  60.              sleep(1);
  61.           }
  62.  
  63.             // 如果剩余重连次数为 0，证明连接失败
  64.           if(n == 0)
  65.          {
  66.            std::cerr << "连接失败! " << strerror(errno) <<    std::endl;
  67.            close(_sock);
  68.            exit(CONNECT_ERR);//新加错误标识符
  69.  
  70.           }
  71.  
  72.            // 连接成功
  73.           std::cout << "连接成功!" << std::endl;
  74.  
  75.          // 进行业务处理
  76.          // Service();
  77.         }
  78.  
  79.      private:
  80.        int _sock;// 套接字
  81.        std::string server_ip;//服务器ip
  82.        uint16_t server_port; //服务器端口号
  83.  
  84.    };
  85. }
1.4.2.2 业务处理

客户端在进行业务处理时，同样可以使用 read 和 write 进行网络通信

Service() 业务处理函数 — 位于 client.hpp 客户端头文件中的 TcpClient 类

  1. // 业务处理
  2. void Service()
  3. {
  4.     char buff[1024];
  5.     std::string who = server_ip + "-" + std::to_string(server_port);
  6.     while(true)
  7.     {
  8.         // 由用户输入信息
  9.         std::string msg;
  10.         std::cout << "Please Enter >> ";
  11.         std::getline(std::cin, msg);
  12.  
  13.         // 发送信息给服务器
  14.         write(_sock, msg.c_str(), msg.size());
  15.         // 接收来自服务器的信息
  16.         ssize_t n = read(_sock, buff, sizeof(buff) - 1);
  17.         if(n > 0)
  18.         {
  19.             // 正常通信
  20.             buff[n] = '\0';
  21.             std::cout << "Client get: " << buff << " from " << who << std::endl;
  22.         }
  23.         else if(n == 0)
  24.         {
  25.             // 读取到文件末尾（服务器关闭了）
  26.             std::cout << "Server " << who  << " quit!" << std::endl;
  27.             close(_sock); // 关闭文件描述符
  28.             break;
  29.         }
  30.         else
  31.         {
  32.             // 读取异常
  33.             std::cerr << "Read Fail!" << strerror(errno) << std::endl;
  34.             close(_sock); // 关闭文件描述符
  35.             break;
  36.         }
  37.     }
  38. }

代码示例： 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/464988
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号