<返回更多

C++ socket网络编程——即时通信系统

2020-07-26    
加入收藏

一:项目内容

本项目使用C++实现一个具备服务器端和客户端即时通信且具有私聊功能的聊天室。

目的是学习C++网络开发的基本概念,同时也可以熟悉下linux下的C++程序编译和简单MakeFile编写

分享一个即时通讯的实战项目给大家:即时通讯实战项目

需要Linux服务器开发高阶学习资料的朋友可以后台私信【架构】获取

包括Linux,Nginx,ZeroMQ,MySQLredis,fastdfs,MongoDB,ZK,流媒体,CDN,P2P,K8S,Docker,TCP/IP,协程,DPDK等等视频学习资料。

二:需求分析

这个聊天室主要有两个程序:

1.服务端:能够接受新的客户连接,并将每个客户端发来的信息,广播给对应的目标客户端。

2.客户端:能够连接服务器,并向服务器发送消息,同时可以接收服务器发来的消息。

即最简单的C/S模型。

三:抽象与细化

服务端类需要支持:

1.支持多个客户端接入,实现聊天室基本功能。

2.启动服务,建立监听端口等待客户端连接。

3.使用epoll机制实现并发,增加效率。

4.客户端连接时,发送欢迎消息,并存储连接记录。

5.客户端发送消息时,根据消息类型,广播给所有用户(群聊)或者指定用户(私聊)。

6.客户端请求退出时,对相应连接信息进行清理。

客户端类需要支持:

1.连接服务器。

2.支持用户输入消息,发送给服务端。

3.接受并显示服务端发来的消息。

4.退出连接。

涉及两个事情,一个写,一个读。所以客户端需要两个进程分别支持以下功能。

子进程:

1.等待用户输入信息。

2.将聊天信息写入管道(pipe),并发送给父进程。

父进程:

1.使用epoll机制接受服务端发来的消息,并显示给用户,使用户看到其他用户的信息。

2.将子进程发送的聊天信息从管道(pipe)中读取出来,并发送给客户端。

四:C/S模型

C++ socket网络编程——即时通信系统

 

TCP服务端通信常规步骤:

1.socket()创建TCP套接字

2.bind()将创建的套接字绑定到一个本地地址和端口上

3.listen(),将套接字设为监听模式,准备接受客户请求

4.accept()等用户请求到来时接受,返回一个对应此连接新套接字

5.用accept()返回的套接字和客户端进行通信,recv()/send() 接受/发送信息。

6.返回,等待另一个客户请求。

7.关闭套接字

TCP客户端通信常规步骤:

1.socket()创建TCP套接字。

2.connect()建立到达服务器的连接。

3.与客户端进行通信,recv()/send()接受/发送信息,write()/read() 子进程写入管道,父进程从管道中读取信息然后send给客户端

5. close() 关闭客户连接。

五:相关技术介绍

1.socket 阻塞与非阻塞。

阻塞与非阻塞关注的是程序在等待调用结果时(消息,返回值)的状态。

阻塞调用是指在调用结果返回前,当前线程会被挂起,调用线程只有在得到调用结果之后才会返回。

非阻塞调用是指在不能立刻得到结果之前,该调用不会阻塞当前线程。

eg. 你打电话问书店老板有没有《网络编程》这本书,老板去书架上找,如果是阻塞式调用,你就会把自己一直挂起,守在电话边上,直到得到这本书有或者没有的答案。如果是非阻塞式调用,你可以干别的事情去,隔一段时间来看一下老板有没有告诉你结果。

同步异步是对书店老板而言(同步老板不会提醒你找到结果了,异步老板会打电话告诉你),阻塞和非阻塞是对你而言。

socket()函数创建套接字时,默认的套接字都是阻塞的,非阻塞设置方式代码:

//将文件描述符设置为非阻塞方式(利用fcntl函数)

fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)| O_NONBLOCK);

2. epoll

当服务端的人数越来越多,会导致资源吃紧,I/O效率越来越低,这时就应该考虑epoll,epoll是Linux内核为处理大量句柄而改进的poll,是linux特有的I/O函数。其特点如下:

1)epoll是Linux下多路复用IO接口select/poll的增强版本,其实现和使用方式与select/poll大有不同,epoll通过一组函数来完成有关任务,而不是一个函数。

2)epoll之所以高效,是因为epoll将用户关心的文件描述符放到内核里的一个事件列表中,而不是像select/poll每次调用都需要重复传入文件描述符集或事件集(大量拷贝开销),比如一个事件发生,epoll无需遍历整个被监听的描述符集,而只需要遍历那些被内核IO事件异步唤醒而加入就绪队列的描述符集合即可。

3)epoll有两种工作方式,LT(Level triggered) 水平触发 、ET(Edge triggered)边沿触发。LT是select/poll的工作方式,比较低效,而ET是epoll具有的高速工作方式。更多epoll之ET LT

Epoll 用法(三步曲):

第一步:int epoll_create(int size)系统调用,创建一个epoll句柄,参数size用来告诉内核监听的数目,size为epoll支持的最大句柄数。

第二步:int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) 事件注册函数

参数 epfd为epoll的句柄。参数op 表示动作 三个宏来表示:EPOLL_CTL_ADD注册新fd到epfd 、EPOLL_CTL_MOD 修改已经注册的fd的监听事件、EPOLL_CTL_DEL从epfd句柄中删除fd。参数fd为需要监听的标识符。参数结构体epoll_event告诉内核需要监听的事件。

第三步:int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout) 等待事件的产生,通过调用收集在epoll监控中已经发生的事件。参数struct epoll_event 是事件队列 把就绪的事件放进去。

eg. 服务端使用epoll的时候步骤如下:

1.调用epoll_create()在linux内核中创建一个事件表。

2.然后将文件描述符(监听套接字listener)添加到事件表中

3.在主循环中,调用epoll_wait()等待返回就绪的文件描述符集合。

4.分别处理就绪的事件集合,本项目中一共有两类事件:新用户连接事件和用户发来消息事件。

六:代码结构

C++ socket网络编程——即时通信系统

 

每个文件的作用:

1.Common.h:公共头文件,包括所有需要的宏以及socket网络编程头文件,以及消息结构体(用来表示消息类别等)

2.Client.h Client.cpp :客户端类的实现

3.Server.h Server.cpp : 服务端类的实现

4.ClientMain.cpp ServerMain.cpp 客户端及服务端的主函数。

七:代码实现

Common.h

定义一些共用的宏定义,包括一些共用的网络编程相关头文件。

1)定义一个函数将文件描述符fd添加到epfd表示的内核事件表中供客户端和服务端两个类使用。

2)定义一个信息数据结构,用来表示传送的信息,结构体包括发送方fd, 接收方fd,用来表示消息类别的type,还有文字信息。

函数recv() send() write() read() 参数传递是字符串,所以在传送前/接受后要把结构体转换为字符串/字符串转换为结构体。

#ifndef CHATROOM_COMMON_H

#define CHATROOM_COMMON_H

 

#include <IOStream>

#include <list>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <sys/epoll.h>

#include <fcntl.h>

#include <errno.h>

#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

 

// 默认服务器端IP地址

#define SERVER_IP "127.0.0.1"

 

// 服务器端口号

#define SERVER_PORT 8888

 

// int epoll_create(int size)中的size

// 为epoll支持的最大句柄数

#define EPOLL_SIZE 5000

 

// 缓冲区大小65535

#define BUF_SIZE 0xFFFF

 

// 新用户登录后的欢迎信息

#define SERVER_WELCOME "Welcome you join to the chat room! Your chat ID is: Client #%d"

 

// 其他用户收到消息的前缀

#define SERVER_MESSAGE "ClientID %d say >> %s"

#define SERVER_PRIVATE_MESSAGE "Client %d say to you privately >> %s"

#define SERVER_PRIVATE_ERROR_MESSAGE "Client %d is not in the chat room yet~"

// 退出系统

#define EXIT "EXIT"

 

// 提醒你是聊天室中唯一的客户

#define CAUTION "There is only one int the char room!"

 

// 注册新的fd到epollfd中

// 参数enable_et表示是否启用ET模式,如果为True则启用,否则使用LT模式

static void addfd( int epollfd, int fd, bool enable_et )

{

struct epoll_event ev;

ev.data.fd = fd;

ev.events = EPOLLIN;

if( enable_et )

ev.events = EPOLLIN | EPOLLET;

epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev);

// 设置socket为非阻塞模式

// 套接字立刻返回,不管I/O是否完成,该函数所在的线程会继续运行

//eg. 在recv(fd...)时,该函数立刻返回,在返回时,内核数据还没准备好会返回WSAEWOULDBLOCK错误代码

fcntl(fd, F_SETFL, fcntl(fd, F_GETFD, 0)| O_NONBLOCK);

printf("fd added to epoll!nn");

}

 

//定义信息结构,在服务端和客户端之间传送

struct Msg

{

int type;

int fromID;

int toID;

char content[BUF_SIZE];

 

};

#endif // CHATROOM_COMMON_H

服务端类 Server.h Server.cpp

服务端需要的接口:

1)init()初始化

2)Start()启动服务

3)Close()关闭服务

4)广播消息给所有客户端函数 SendBroadcastMessage()

服务端的主循环中每次都会检查并处理EPOLL中的就绪事件,而就绪事件列表主要是两种类型:新连接或新消息。服务器会依次从就绪事件列表里提取事件进行处理,如果是新连接则accept()然后addfd(),如果是新消息则SendBroadcastMessage()实现聊天功能。

Server.h

#ifndef CHATROOM_SERVER_H

#define CHATROOM_SERVER_H

 

#include <string>

 

#include "Common.h"

 

using namespace std;

 

// 服务端类,用来处理客户端请求

class Server {

 

public:

// 无参数构造函数

Server();

 

// 初始化服务器端设置

void Init();

 

// 关闭服务

void Close();

 

// 启动服务端

void Start();

 

private:

// 广播消息给所有客户端

int SendBroadcastMessage(int clientfd);

 

// 服务器端serverAddr信息

struct sockaddr_in serverAddr;

 

//创建监听的socket

int listener;

 

// epoll_create创建后的返回值

int epfd;

 

// 客户端列表

list<int> clients_list;

};

//Server.cpp

#include <iostream>

 

#include "Server.h"

 

using namespace std;

 

// 服务端类成员函数

 

// 服务端类构造函数

Server::Server(){

 

// 初始化服务器地址和端口

serverAddr.sin_family = PF_INET;

serverAddr.sin_port = htons(SERVER_PORT);

serverAddr.sin_addr.s_addr = inet_addr(SERVER_IP);

 

// 初始化socket

listener = 0;

 

// epool fd

epfd = 0;

}

// 初始化服务端并启动监听

void Server::Init() {

cout << "Init Server..." << endl;

 

//创建监听socket

listener = socket(PF_INET, SOCK_STREAM, 0);

if(listener < 0) { perror("listener"); exit(-1);}

 

//绑定地址

if( bind(listener, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {

perror("bind error");

exit(-1);

}

 

//监听

int ret = listen(listener, 5);

if(ret < 0) {

perror("listen error");

exit(-1);

}

 

cout << "Start to listen: " << SERVER_IP << endl;

 

//在内核中创建事件表 epfd是一个句柄

epfd = epoll_create (EPOLL_SIZE);

 

if(epfd < 0) {

perror("epfd error");

exit(-1);

}

 

//往事件表里添加监听事件

addfd(epfd, listener, true);

 

}

 

// 关闭服务,清理并关闭文件描述符

void Server::Close() {

 

//关闭socket

close(listener);

 

//关闭epoll监听

close(epfd);

}

 

// 发送广播消息给所有客户端

int Server::SendBroadcastMessage(int clientfd)

{

// buf[BUF_SIZE] 接收新消息

// message[BUF_SIZE] 保存格式化的消息

char recv_buf[BUF_SIZE];

char send_buf[BUF_SIZE];

Msg msg;

bzero(recv_buf, BUF_SIZE);

// 接收新消息

cout << "read from client(clientID = " << clientfd << ")" << endl;

int len = recv(clientfd, recv_buf, BUF_SIZE, 0);

//清空结构体,把接受到的字符串转换为结构体

memset(&msg,0,sizeof(msg));

memcpy(&msg,recv_buf,sizeof(msg));

//判断接收到的信息是私聊还是群聊

msg.fromID=clientfd;

if(msg.content[0]=='\'&&isdigit(msg.content[1])){

msg.type=1;

msg.toID=msg.content[1]-'0';

memcpy(msg.content,msg.content+2,sizeof(msg.content));

}

else

msg.type=0;

// 如果客户端关闭了连接

if(len == 0)

{

close(clientfd);

 

// 在客户端列表中删除该客户端

clients_list.remove(clientfd);

cout << "ClientID = " << clientfd

<< " closed.n now there are "

<< clients_list.size()

<< " client in the char room"

<< endl;

 

}

// 发送广播消息给所有客户端

else

{

// 判断是否聊天室还有其他客户端

if(clients_list.size() == 1){

// 发送提示消息

memcpy(&msg.content,CAUTION,sizeof(msg.content));

bzero(send_buf, BUF_SIZE);

memcpy(send_buf,&msg,sizeof(msg));

send(clientfd, send_buf, sizeof(send_buf), 0);

return len;

}

//存放格式化后的信息

char format_message[BUF_SIZE];

//群聊

if(msg.type==0){

// 格式化发送的消息内容 #define SERVER_MESSAGE "ClientID %d say >> %s"

sprintf(format_message, SERVER_MESSAGE, clientfd, msg.content);

memcpy(msg.content,format_message,BUF_SIZE);

// 遍历客户端列表依次发送消息,需要判断不要给来源客户端发

list<int>::iterator it;

for(it = clients_list.begin(); it != clients_list.end(); ++it) {

if(*it != clientfd){

//把发送的结构体转换为字符串

bzero(send_buf, BUF_SIZE);

memcpy(send_buf,&msg,sizeof(msg));

if( send(*it,send_buf, sizeof(send_buf), 0) < 0 ) {

return -1;

}

}

}

}

//私聊

if(msg.type==1){

bool private_offline=true;

sprintf(format_message, SERVER_PRIVATE_MESSAGE, clientfd, msg.content);

memcpy(msg.content,format_message,BUF_SIZE);

// 遍历客户端列表依次发送消息,需要判断不要给来源客户端发

list<int>::iterator it;

for(it = clients_list.begin(); it != clients_list.end(); ++it) {

if(*it == msg.toID){

private_offline=false;

//把发送的结构体转换为字符串

bzero(send_buf, BUF_SIZE);

memcpy(send_buf,&msg,sizeof(msg));

if( send(*it,send_buf, sizeof(send_buf), 0) < 0 ) {

return -1;

}

}

}

//如果私聊对象不在线

if(private_offline){

sprintf(format_message,SERVER_PRIVATE_ERROR_MESSAGE,msg.toID);

memcpy(msg.content,format_message,BUF_SIZE);

bzero(send_buf,BUF_SIZE);

memcpy(send_buf,&msg,sizeof(msg));

if(send(msg.fromID,send_buf,sizeof(send_buf),0)<0)

return -1;

}

}

}

return len;

}

 

// 启动服务端

void Server::Start() {

 

// epoll 事件队列

static struct epoll_event events[EPOLL_SIZE];

 

// 初始化服务端

Init();

 

//主循环

while(1)

{

//epoll_events_count表示就绪事件的数目

int epoll_events_count = epoll_wait(epfd, events, EPOLL_SIZE, -1);

 

if(epoll_events_count < 0) {

perror("epoll failure");

break;

}

 

cout << "epoll_events_count =n" << epoll_events_count << endl;

 

//处理这epoll_events_count个就绪事件

for(int i = 0; i < epoll_events_count; ++i)

{

int sockfd = events[i].data.fd;

//新用户连接

if(sockfd == listener)

{

struct sockaddr_in client_address;

socklen_t client_addrLength = sizeof(struct sockaddr_in);

int clientfd = accept( listener, ( struct sockaddr* )&client_address, &client_addrLength );

 

cout << "client connection from: "

<< inet_ntoa(client_address.sin_addr) << ":"

<< ntohs(client_address.sin_port) << ", clientfd = "

<< clientfd << endl;

 

addfd(epfd, clientfd, true);

 

// 服务端用list保存用户连接

clients_list.push_back(clientfd);

cout << "Add new clientfd = " << clientfd << " to epoll" << endl;

cout << "Now there are " << clients_list.size() << " clients int the chat room" << endl;

 

// 服务端发送欢迎信息

cout << "welcome message" << endl;

char message[BUF_SIZE];

bzero(message, BUF_SIZE);

sprintf(message, SERVER_WELCOME, clientfd);

int ret = send(clientfd, message, BUF_SIZE, 0);

if(ret < 0) {

perror("send error");

Close();

exit(-1);

}

}

//处理用户发来的消息,并广播,使其他用户收到信息

else {

int ret = SendBroadcastMessage(sockfd);

if(ret < 0) {

perror("error");

Close();

exit(-1);

}

}

}

}

 

// 关闭服务

Close();

}

客户端类实现

需要的接口:

1)连接服务端connect()

2)退出连接close()

3)启动客户端Start()

Client.h

#ifndef CHATROOM_CLIENT_H

#define CHATROOM_CLIENT_H

 

#include <string>

#include "Common.h"

 

using namespace std;

 

// 客户端类,用来连接服务器发送和接收消息

class Client {

 

public:

// 无参数构造函数

Client();

 

// 连接服务器

void Connect();

 

// 断开连接

void Close();

 

// 启动客户端

void Start();

 

private:

 

// 当前连接服务器端创建的socket

int sock;

 

// 当前进程ID

int pid;

 

// epoll_create创建后的返回值

int epfd;

 

// 创建管道,其中fd[0]用于父进程读,fd[1]用于子进程写

int pipe_fd[2];

 

// 表示客户端是否正常工作

bool isClientwork;

 

// 聊天信息

Msg msg;

//结构体要转换为字符串

char send_buf[BUF_SIZE];

char recv_buf[BUF_SIZE];

//用户连接的服务器 IP + port

struct sockaddr_in serverAddr;

};

Client.cpp

#include <iostream>

 

#include "Client.h"

 

using namespace std;

 

// 客户端类成员函数

 

// 客户端类构造函数

Client::Client(){

 

// 初始化要连接的服务器地址和端口

serverAddr.sin_family = PF_INET;

serverAddr.sin_port = htons(SERVER_PORT);

serverAddr.sin_addr.s_addr = inet_addr(SERVER_IP);

 

// 初始化socket

sock = 0;

 

// 初始化进程号

pid = 0;

 

// 客户端状态

isClientwork = true;

 

// epool fd

epfd = 0;

}

 

// 连接服务器

void Client::Connect() {

cout << "Connect Server: " << SERVER_IP << " : " << SERVER_PORT << endl;

 

// 创建socket

sock = socket(PF_INET, SOCK_STREAM, 0);

if(sock < 0) {

perror("sock error");

exit(-1);

}

 

// 连接服务端

if(connect(sock, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {

perror("connect error");

exit(-1);

}

 

// 创建管道,其中fd[0]用于父进程读,fd[1]用于子进程写

if(pipe(pipe_fd) < 0) {

perror("pipe error");

exit(-1);

}

 

// 创建epoll

epfd = epoll_create(EPOLL_SIZE);

 

if(epfd < 0) {

perror("epfd error");

exit(-1);

}

 

//将sock和管道读端描述符都添加到内核事件表中

addfd(epfd, sock, true);

addfd(epfd, pipe_fd[0], true);

 

}

 

// 断开连接,清理并关闭文件描述符

void Client::Close() {

 

if(pid){

//关闭父进程的管道和sock

close(pipe_fd[0]);

close(sock);

}else{

//关闭子进程的管道

close(pipe_fd[1]);

}

}

 

// 启动客户端

void Client::Start() {

 

// epoll 事件队列

static struct epoll_event events[2];

 

// 连接服务器

Connect();

 

// 创建的进程

pid = fork();

 

// 如果创建的进程失败则退出

if(pid < 0) {

perror("fork error");

close(sock);

exit(-1);

} else if(pid == 0) {

// 进入子进程执行流程

//子进程负责写入管道,因此先关闭读端

close(pipe_fd[0]);

 

// 输入exit可以退出聊天室

cout << "Please input 'exit' to exit the chat room" << endl;

cout<<"\ + ClientID to private chat "<<endl;

// 如果客户端运行正常则不断读取输入发送给服务端

while(isClientwork){

//清空结构体

memset(msg.content,0,sizeof(msg.content));

fgets(msg.content, BUF_SIZE, stdin);

// 客户输出exit,退出

if(strncasecmp(msg.content, EXIT, strlen(EXIT)) == 0){

isClientwork = 0;

}

// 的进程将信息写入管道

else {

//清空发送缓存

memset(send_buf,0,BUF_SIZE);

//结构体转换为字符串

memcpy(send_buf,&msg,sizeof(msg));

if( write(pipe_fd[1], send_buf, sizeof(send_buf)) < 0 ) {

perror("fork error");

exit(-1);

}

}

}

} else {

//pid > 0 父进程

//父进程负责读管道数据,因此先关闭写端

close(pipe_fd[1]);

 

// 主循环(epoll_wait)

while(isClientwork) {

int epoll_events_count = epoll_wait( epfd, events, 2, -1 );

 

//处理就绪事件

for(int i = 0; i < epoll_events_count ; ++i)

{

memset(recv_buf,0,sizeof(recv_buf));

//服务端发来消息

if(events[i].data.fd == sock)

{

//接受服务端广播消息

int ret = recv(sock, recv_buf, BUF_SIZE, 0);

//清空结构体

memset(&msg,0,sizeof(msg));

//将发来的消息转换为结构体

memcpy(&msg,recv_buf,sizeof(msg));

 

// ret= 0 服务端关闭

if(ret == 0) {

cout << "Server closed connection: " << sock << endl;

close(sock);

isClientwork = 0;

} else {

cout << msg.content << endl;

}

}

//子进程写入事件发生,父进程处理并发送服务端

else {

//父进程从管道中读取数据

int ret = read(events[i].data.fd, recv_buf, BUF_SIZE);

// ret = 0

if(ret == 0)

isClientwork = 0;

else {

// 将从管道中读取的字符串信息发送给服务端

send(sock, recv_buf, sizeof(recv_buf), 0);

}

}

}//for

}//while

}

 

// 退出进程

Close();

}

ClientMain.cpp

#include "Client.h"

 

// 客户端主函数

// 创建客户端对象后启动客户端

int main(int argc, char *argv[]) {

Client client;

client.Start();

return 0;

}

ServerMain.cpp

#include "Server.h"

 

// 服务端主函数

// 创建服务端对象后启动服务端

int main(int argc, char *argv[]) {

Server server;

server.Start();

return 0;

}

最后是Makefile 文件 对上面的文件进行编译

CC = g++

CFLAGS = -std=c++11

 

all: ClientMain.cpp ServerMain.cpp Server.o Client.o

$(CC) $(CFLAGS) ServerMain.cpp Server.o -o chatroom_server

$(CC) $(CFLAGS) ClientMain.cpp Client.o -o chatroom_client

 

Server.o: Server.cpp Server.h Common.h

$(CC) $(CFLAGS) -c Server.cpp

 

Client.o: Client.cpp Client.h Common.h

$(CC) $(CFLAGS) -c Client.cpp

 

clean:

rm -f *.o chatroom_server chatroom_client

声明:本站部分内容来自互联网,如有版权侵犯或其他问题请与我们联系,我们将立即删除或处理。
▍相关推荐
更多资讯 >>>