封装Client

1.什么是数据封装
将client视为一个对象，他有初始化，登录，登出等属性功能。
将client写成一个类，这个类中的每一个函数都实现一个功能。
就是封装client
以后外部使用client，只需要调用client类创建对象就可以了。

EasyTCPClient.hpp
/*用封装的形式，将客户端封装起来*/

//防止重编译
#ifndef _EasyTcpClient_hpp_
#define _EasyTcpClient_hpp_
//inet_addr
#define _WINSOCK_DEPRECATED_NO_WARNINGS

#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
	#include<Windows.h>
	#include<WinSock2.h>
	//链接了ws2_32这个库
	#pragma comment(lib,"ws2_32.lib")
#else
	#include<unistad.h>
	#include<arpa/inet.h>
	#include<string.h>
#endif // _WIN32

#include"MessageHeader.hpp"
#include<iostream>

class EasyTcpClient
{
	SOCKET _sock;
public:
	EasyTcpClient()
	{
		_sock = INVALID_SOCKET;
	}

	//虚析构函数
	virtual ~EasyTcpClient()
	{
		Close();
	}

	//初始化Socket
	int initSocket() 
	{
#ifdef _WIN32


		//启动Win Sock 2.x环境
		WORD ver = MAKEWORD(2, 2);
		WSADATA dat;
		WSAStartup(ver, &dat);

#endif // _WIN32
		//1.建立一个Socket
		if (INVALID_SOCKET != _sock) {
			printf("socket=%d关闭了旧链接\n",_sock);
			Close();
		}
		_sock = socket(AF_INET, SOCK_STREAM, 0);
		if (INVALID_SOCKET == _sock)
		{
			printf("错误，建立socket失败。。\n");
			return -1;
		}
		else
		{
			printf("建立socket成功\n");
			return 1;
		}
		
	}

	//链接服务器
	int Connect(const char *ip, unsigned short port)
	{
		if (INVALID_SOCKET == _sock) {
			initSocket();
		}
		//2.连接服务器
		sockaddr_in _sin = {};
		_sin.sin_family = AF_INET;
		_sin.sin_port = htons(4567);
#ifdef _WIN32
		_sin.sin_addr.S_un.S_addr = inet_addr(ip);
#else
		_sin.sin_addr.S_addr = inet_addr(ip);
#endif // _WIN32
		int ret = connect(_sock, (sockaddr*)&_sin, sizeof(sockaddr_in));
		if (SOCKET_ERROR == ret)
		{
			printf("错误，连接服务器失败。\n");
		}
		else
		{
			printf("连接服务器成功。。。\n");
		}
		return ret;

	}

	//关闭Socket
	void Close()
	{
		//关闭Win Sock 2.x环境
		if (_sock != INVALID_SOCKET)
		{
#ifdef _WIN32
			closesocket(_sock);
			WSACleanup();
#else
			close(_sock);
#endif // _WIN32
			_sock = INVALID_SOCKET;
		}
	}

	//处理网络消息
	bool onRun()
	{
		if (isRun())
		{
			fd_set fdReads;
			FD_ZERO(&fdReads);
			FD_SET(_sock, &fdReads);
			timeval t = { 1,0 };
			int ret = select(_sock + 1, &fdReads, 0, 0, &t);
			if (ret < 0)
			{
				printf("<socket=%d>Select 任务结束\n", _sock);
				return false;
			}
			if (FD_ISSET(_sock, &fdReads))
			{
				FD_CLR(_sock, &fdReads);
				if (-1 == RecvData(_sock))
				{
					printf("<socket=%d>selesct任务结束\n", _sock);
					return false;
				}
			}
			return true;
		}
	}

	//判断是否运行
	bool isRun()
	{
		return _sock != INVALID_SOCKET;
	}

	//处理进程的函数
	int RecvData(SOCKET _serverSock) {
		//第一次接受一个缓冲数据，设置缓冲区大小
		char szRecv[1024] = {};
		//5.接收客户端数据
		//第一次收了header的数据包，只剩下CMD的数据长度，指针移动到数据包包体位置
		int nLen = recv(_serverSock, szRecv, sizeof(DataHeader), 0);
		DataHeader* header = (DataHeader*)szRecv;

		if (nLen <= 0)
		{
			printf("与服务器断开连接。\n", _serverSock);
			return -1;
		}
		printf("收到命令：%d ，数据长度：%d\n", header->cmd, header->dataLength);
		//6.处理请求
		
		//拆分包
		//从_serverSock缓冲区,接收DataHeader后的数据，接收的数据长度为数据包-包头的长度
		recv(_serverSock, szRecv + sizeof(DataHeader), header->dataLength - sizeof(DataHeader), 0);
		OnNetMsg(header);

		return 0;
	}

	//收数据：处理粘包，拆分包
	void OnNetMsg(DataHeader* header)
	{
		switch (header->cmd)
		{
		case CMD_LOGIN_RESULT:
		{
			//因为都是login，logout都是header的子类所以可以相互转化
			LoginResult* login = (LoginResult*)header;
			printf("收到服务器消息：CMD_LOGIN_RESULT,数据长度：%d\n", login->dataLength);

		}
		break;
		case CMD_LOGOUT:
		{
			LogoutResult* logoutret = (LogoutResult*)header;
			printf("收到服务端返回消息：CMD_LOGOUT_RESULT,数据长度：%d\n", logoutret->dataLength);

		}
		break;
		case CMD_NEW_USER_JOIN:
		{
			NewUserJoin* newuser = (NewUserJoin*)header;
			printf("新的SOCKET：%d 加入进服务器\n", newuser->sock);

		}
		break;
		//定义默认的错误信息
		}
	}

	//发送数据
	int SendData(DataHeader* header)
	{
		//isRun is bool && header 是不是为空
		if (isRun() && header)
		{	//int _stdcall send() _stdcall意思为从右往左压入栈（0-》header->dataLength->header->_sock）
			return send(_sock, (const char*)header, header->dataLength, 0);
		}
		return SOCKET_ERROR;
	}

private:

};



#endif

MessageHeader.hpp
//用来存放消息结构

//传输的数据结构，最简单的数据包
//每个函数的类型必须一样，而且在客户端和服务端传输和接收顺序一致，也就是内存对齐
//long类型的在64位编译器下就是64位，而32位编译器下就是32位，
//所以需要考虑平台和系统，关注是否内存对齐

enum CMD
{
	CMD_LOGIN,
	CMD_LOGIN_RESULT,
	CMD_LOGOUT_RESULT,
	CMD_LOGOUT,
	CMD_NEW_USER_JOIN,
	CMD_ERROR
};


//消息结构体
struct DataHeader {
	short dataLength;//数据长度
	short cmd;//命令：接收的命令，服务器处理后反馈数据。
};
//定义登录的数据结构
//使用继承方式，是报文更完整，不容易出错，也不用每次单独定义dataheader
struct Login :public DataHeader {
	Login()
	{
		dataLength = sizeof(Login);
		cmd = CMD_LOGIN;
	}
	char userName[32];
	char PassWord[32];
};

struct LoginResult :public DataHeader {
	LoginResult()
	{
		dataLength = sizeof(LoginResult);
		cmd = CMD_LOGIN_RESULT;
	}
	int result;
};

struct LogoutResult :public DataHeader {
	LogoutResult()
	{
		dataLength = sizeof(LogoutResult);
		cmd = CMD_LOGOUT_RESULT;
	}
	int result;
};

struct NewUserJoin :public DataHeader {
	NewUserJoin()
	{
		dataLength = sizeof(NewUserJoin);
		cmd = CMD_NEW_USER_JOIN;
		sock = 0;
	}
	int sock;
};

struct Logout :public DataHeader {
	Logout()
	{
		dataLength = sizeof(Logout);
		cmd = CMD_LOGOUT;
	}
	char userName[32];
};

Clinet.cpp
#include "EasyTcpClient.hpp"
#include<thread>


//Thread can input the command
//windows 下可以穿easytcpclient 的引用，其他的不行
void cmdThread(EasyTcpClient* client)
{
	while (true)
	{
		char cmdBuf[256] = {};
		std::cin >> cmdBuf;
		if (0 == strcmp(cmdBuf, "exit"))
		{
			client->Close();
			printf("Exit the thread\n");
			break;
		}
		else if (0 == strcmp(cmdBuf, "login"))
		{
			Login login;
			strcpy_s(login.userName, "李逵");
			strcpy_s(login.PassWord, "110");
			client->SendData(&login);
		}
		else if(0==strcmp(cmdBuf,"logout"))
		{
			Logout logout;
			strcpy_s(logout.userName, "李逵");
			//因为logout是继承header的结构体，所以发送header也可以发送logout
			client->SendData(&logout);
		}
		else
		{
			printf("The command is not supported!\n");
		}
	}
}

int main()
{
	EasyTcpClient client;
	//start up the thread
	
	//client.initSocket();
	client.Connect("127.0.0.1",4567);

	EasyTcpClient client2;
	//client2.initSocket();
	client2.Connect("127.0.0.1",4000);

	std::thread t1(cmdThread, &client);
	t1.detach();
	std::thread t2(cmdThread, &client2);
	t2.detach();

	while (client.isRun()||client2.isRun())
	{
		client.onRun();
		client2.onRun();
	}

	client.Close();
	client2.Close();
	printf("已退出\n");
	getchar();
	return 0;
}