基于Event-Select模型的聊天室服务器

网络通信——select模型

借用下一个博主的图:

link

说明都在注释中，代码里主要的函数解释可以看我转载的其他博客。

服务器代码

#include "stdafx.h"
#include <WinSock2.h>
#include <iostream>
#pragma comment(lib,"ws2_32.lib")
using  namespace std;
#define PORT 9527

//启动服务器
SOCKET StartSever()
{
	//套接字初始化
	WSADATA data = { 0 };
	if (WSAStartup(MAKEWORD(2, 2), &data))
	{
		printf("WSAStartup failed\n");
		return 0;
	}

	//创建套接字
	SOCKET sockSever = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (sockSever == INVALID_SOCKET)
	{
		printf("Create socket error");
		return 0;
	}
	sockaddr_in service;
	service.sin_family = AF_INET;
	service.sin_addr.S_un.S_addr = INADDR_ANY;
	service.sin_port = htons(PORT);

	//绑定套接字
	if (bind(sockSever, (sockaddr*)&service, sizeof(service)) == SOCKET_ERROR)
	{
		printf("bind failed\n");
		return 0;
	}

	//将服务器套接字设为监听状态
	if (listen(sockSever, SOMAXCONN) == SOCKET_ERROR)
	{
		printf("listen error\n");
		return 0;
	}

	//返回服务器套接字
	return sockSever;
}

int _tmain(int argc, _TCHAR* argv[])
{
	//启动服务器
	SOCKET sockSever =StartSever();

	// 为了能和多个客户端通信，使用两个数组分别记录所有通信的会话套接字
	// 以及和这些套接字绑定的事件对象
	// WSA_MAXIMUM_WAIT_EVENTS是系统内部定义的宏，值为64
	SOCKET ArrSocket[WSA_MAXIMUM_WAIT_EVENTS] = { 0 };	//最大值64
	WSAEVENT ArrEvent[WSA_MAXIMUM_WAIT_EVENTS] = { 0 };	//WSAEVENT其实是一个指针 void*

	//事件对象计数器
	DWORD nEventTotal = 0;		//DWORD即double world，这里的定义是：typedef unsigned long  DWORD;

	// 创建事件对象
	WSAEVENT AcceptEvent = WSACreateEvent();

	// 将sockSever和AcceptEvent关联起来
	// 并注册程序感兴趣的网络事件FD_ACCEPT 和 FD_CLOSE
	// 这里由于是在等待客户端connect，所以FD_ACCEPT和FD_CLOSE是我们关心的
	WSAEventSelect(sockSever, AcceptEvent, FD_ACCEPT | FD_CLOSE);

	ArrSocket[nEventTotal] = sockSever;//套接字数组
	ArrEvent[nEventTotal] = AcceptEvent;//事件数组
	++nEventTotal;//套接字数=事件数


	//主循环
	while (TRUE)
	{
		//等待套接字对应的事件发生, 最多能监听WSA_MAXIMUM_WAIT_EVENTS 个事件；
		//WSAWaitForMultipleEvents在所有事件上等待，只要一个事件发生就返回。
		DWORD index = WSAWaitForMultipleEvents(nEventTotal, ArrEvent, FALSE, WSA_INFINITE, FALSE);

		//有事件发生了,查看套接字对应的具体事件是什么
		WSANETWORKEVENTS NetWorkEvent = { 0 };//WSANETWORKEVENTS是一个网络事件结构体，里面存储着一个long整形和一个int数组
		WSAEnumNetworkEvents(ArrSocket[index - WSA_WAIT_EVENT_0], ArrEvent[index - WSA_WAIT_EVENT_0], &NetWorkEvent);

		//事件1：有服务器申请连接
		if (NetWorkEvent.lNetworkEvents & FD_ACCEPT)
		{
			if (NetWorkEvent.iErrorCode[FD_ACCEPT_BIT] != 0)//错误代码不为0，表示异常
			{
				break;
			}
			//接收新的连接
			SOCKET sockClient = accept(ArrSocket[index - WSA_WAIT_EVENT_0], NULL, NULL);
			if (sockClient == INVALID_SOCKET)
			{
				cout << "连接失败" << endl;
				break;
			}

			//给新的连接创建事件
			WSAEVENT clientEvent = WSACreateEvent();
			//把套接子与事件注册进操作系统,用于监听
			WSAEventSelect(sockClient, clientEvent, FD_READ | FD_WRITE | FD_CLOSE);

			//修改数组
			ArrSocket[nEventTotal] = sockClient;
			ArrEvent[nEventTotal] = clientEvent;
			++nEventTotal;
		}

		//事件2：接收数据
		if (NetWorkEvent.lNetworkEvents & FD_READ)
		{
			if (NetWorkEvent.iErrorCode[FD_READ_BIT] != 0)//错误代码不为0，表示异常
			{
				cout << "接收失败";
				break;
			}
			char buf[2048] = { 0 };
			//为一条语句会导致阻塞
			recv(ArrSocket[index - WSA_WAIT_EVENT_0], buf, sizeof(buf), 0);
			//获取客户端Ip
			struct sockaddr_in sa;
			int len = sizeof(sa);
			getpeername(ArrSocket[index - WSA_WAIT_EVENT_0], (struct sockaddr *)&sa, &len);
			//输出
			cout << inet_ntoa(sa.sin_addr)<<":"<<buf << endl; //inet_ntoa功能是将网络地址转换成“.”点隔的字符串格式。
		}

		//事件：发送数据
		if (NetWorkEvent.lNetworkEvents & FD_WRITE)
		{
			if (NetWorkEvent.iErrorCode[FD_WRITE_BIT] != 0)
			{
				break;
			}
		}

		//事件：关闭
		if (NetWorkEvent.lNetworkEvents & FD_CLOSE)
		{
			if (NetWorkEvent.iErrorCode[FD_CLOSE_BIT] != 0)
			{
				continue;
			}
			closesocket(ArrSocket[index - WSA_WAIT_EVENT_0]);
			//还需将关闭的套接字从数组中删除；这里省略了。
		}
	}
	// 如果出错退出循环 则将套接字数组中的套接字与事件对象统统解除关联
	// 给WSAEventSelect的最后一个参数传0可以解除g_sockArray[nIndex]和g_eventArray[nIndex]的关联
	// 解除关联后,ws2_32.dll将停止记录g_sockArray[nIndex]这个套接字的网络事件
	// 退出时还要关闭所有创建的套接字和事件对象

	//这里只演示关闭服务器套接字
	if (sockSever != INVALID_SOCKET)
	{
		closesocket(sockSever);
	}
	WSACleanup();
	return 0;
}

客户端代码

#include "stdafx.h"
#include "windows.h"
#include "iostream"
#include "process.h"
#include <string>
using namespace std;
#pragma comment(lib, "ws2_32.lib")

void Receive(void *param)
{
	string msg;
	while (1)
	{
		//客户端接受来自服务器的数据
		SOCKET clientSocket = *(SOCKET*)(param);
		char  recvbuf[2048] = {};		//接收缓冲区
		if (recv(clientSocket, recvbuf, 2048, 0) == SOCKET_ERROR)
		{
			cout << "数据接受失败" << endl;
		}
		else
		{
			msg = recvbuf;
			char sendPlayerName[5] = { 0 };
			int len = strlen(recvbuf);		//消息长度
			copy(&recvbuf[1], &recvbuf[5], sendPlayerName);	//分离出名字
			msg = msg.substr(5, len - 5);
			cout << sendPlayerName << "对你说：" << msg<<endl;
		}
			
	}
}

void Send(void *param)
{
	while (1)
	{
		//客户端发送数据给服务器
		SOCKET clientSocket = *(SOCKET*)(param);
		char sendbuf[2048] = {};		//发送缓冲区
		cin.getline(sendbuf, 2048);
		if (send(clientSocket, sendbuf, strlen(sendbuf), 0) == SOCKET_ERROR)
		{
			cout << "发送消息失败！";
		}
		else
			cout << "发送消息成功" << endl;
	}
}

int main()
{
	cout << "-----------个人客户端-----------" << endl;
	WSADATA  wsa;
	if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0)
	{
		cout << "套接字初始化失败!"<<endl;
	}
	SOCKET clientSocket;
	if ((clientSocket = socket(AF_INET, SOCK_STREAM, 0)) == SOCKET_ERROR)
	{
		cout << "套接字创建失败!"<<endl;
	}
	Sleep(30);
	struct sockaddr_in ClientAddress;		//一个绑定地址:有IP地址,有端口号,有协议族
	memset(&ClientAddress, 0, sizeof(sockaddr_in)); //初始化结构体
	ClientAddress.sin_family = AF_INET;
	ClientAddress.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//填入本机IP地址 
	//ClientAddress.sin_port = htons(9527);//设定端口号
	//绑定套接字     指定绑定的IP地址和端口号
	if (bind(clientSocket, (sockaddr*)&ClientAddress, sizeof(ClientAddress)) == SOCKET_ERROR)
	{
		cout << "套接字绑定失败！" << endl;
		return 0;
	}
	struct sockaddr_in SeverAddress;		//服务器地址 也就是即将要连接的目标地址
	memset(&SeverAddress, 0, sizeof(sockaddr_in)); 
	SeverAddress.sin_family = AF_INET;
	SeverAddress.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");  //127.0.0.1表示本机ip地址
	SeverAddress.sin_port = htons(9527);//设定端口号

	//开始连接
	if (connect(clientSocket, (sockaddr*)&SeverAddress, sizeof(SeverAddress)) == SOCKET_ERROR)
	{
		cout << "客户端：和服务器连接失败！"<<endl;
		return 0;
	}
	else
		cout << "与服务器连接成功！" << endl;

	//创建两个子线程
	_beginthread(Receive, 0, &clientSocket);
	_beginthread(Send, 0, &clientSocket);

	Sleep(INFINITE);	//这里采用另外一种技术避免主线程执行完退出——使其无限期休眠
	//	关闭socket
	if (clientSocket != INVALID_SOCKET) {
		closesocket(clientSocket);
		clientSocket = INVALID_SOCKET;
	}

	//	终止
	WSACleanup();
	cout << "客户端退出！" << endl;
    return 0;
}

运行效果