Zinx框架-游戏服务器开发003：架构搭建-需求分析及TCP通信方式的实现

文章目录

• 1 项目总体架构
• 2 项目需求
• • 2.1 服务器职责
  • 2.2 消息的格式和定义
• 3 基于Tcp连接的通信方式
• • 3.1 通道层实现GameChannel类
  • • 3.1.1 TcpChannel类
    • 3.1.2 Tcp工厂类
    • 3.1.3 创建主函数，添加Tcp的监听套接字
    • 3.1.4 代码测试
  • 3.2 协议层与消息类
  • • 3.2.1 消息的定义
    • 3.2.2 消息类-用户请求对象的创建
    • 3.2.3 protoc消息的创建
    • 3.2.4 消息对象的构造与解析
    • 3.2.5 代码测试-1
    • 3.2.6 报文里的多条请求
    • 3.2.7 Tcp报文粘包的处理
    • 3.2.8 数据包代码测试
    • • 3.2.8.1 完整数据
      • 3.2.8.2 数据缺失和错误
    • 3.2.9 协议和通道相互绑定
    • • 3.2.9.1 循环引用的问题
      • 3.2.9.1 相互绑定的实现
      • 3.2.9.3 代码测试
  • 3.3 业务层玩家类的创建
  • • 3.3.1 在Role中绑定协议
    • 3.3.2 在协议中绑定一个role
    • 3.3.3 在tcp中绑定协议和玩家对象
    • 3.3.4 重写协议层获取角色处理对象
    • 3.3.5 修改角色Init函数
    • 3.3.6 测试代码

1 项目总体架构

2 项目需求

2.1 服务器职责

服务器职责（接收客户端数据，发送数据给客户端）

• 新客户端连接后，向其发送ID和名称
• 新客户端连接后，向其发送周围玩家的位置
• 新客户端连接后，向周围玩家发送其位置
• 收到客户端的移动信息后，向周围玩家发送其新位置
• 收到客户端的移动信息后，向其发送周围新玩家位置
• 收到客户端的聊天信息后，向所有玩家发送聊天内容
• 客户端断开时，向周围玩家发送其断开的消息

2.2 消息的格式和定义

• 消息定义

每一条服务器和客户端之前的消息都应该满足以下格式

消息内容的长度（4个字节，低字节在前）| 消息ID（4个字节，低字节在前）| 消息内容 |

消息以及其处理方式已经在客户端实现，本项目要实现的是服务器端的相关处理

• 详细定义如下

3 基于Tcp连接的通信方式

3.1 通道层实现GameChannel类

• GameChannel::GetInputNextStage 函数中直接返回成员变量中的协议对象
• GameChannel 的析构函数中要一并从kernel中摘掉协议对象，玩家对象并析构之
• GameChannelFac::CreateTcpDataChannel 函数要一并创建通道对象，协议对象，玩家对象，并将这三者绑定起来，添加到kernel中

3.1.1 TcpChannel类

• 使用框架提供的Tcp通信类
• 创建GameChannel类继承ZinxTcpData，重写GetInputNextStage函数，将tcp收到的数据交给协议对象解析

每个协议对象只处理本通道的协议数据

GameProtocol* m_proto = NULL; 

创建对象啊以后交给m_proto，通过该变量访问通道内的数据

AZinxHandler* GameChannel::GetInputNextStage(BytesMsg& _oInput){return m_proto;}

3.1.2 Tcp工厂类

• 创建GameChannelFac类用于创建基于连接的GameChannel对象
• 因为玩家是通过tcp连接，所以tcp通道，协议对象，和玩家对象是一对一对一的绑定关系
• 创建通道的时候，需要创建协议，并且绑定协议对象

ZinxTcpData* GameConnFact::CreateTcpDataChannel(int _fd){/*创建tcp通道对象*/auto pChannel = new GameChannel(_fd);/*创建协议对象*/auto pProtocol = new GameProtocol();/*绑定协议对象*/pChannel->m_proto = pProtocol;/*将协议对象添加到kernel, 注意参数需要为指针*/ZinxKernel::Zinx_Add_Proto(*pProtocol);return pChannel;}

3.1.3 创建主函数，添加Tcp的监听套接字

#include "GameChannel.h"int main(){ZinxKernel::ZinxKernelInit();/*添加监听通道：需要端口号和连接*/ZinxKernel::Zinx_Add_Channel(*(new ZinxTCPListen(8899, new GameConnFact())));ZinxKernel::Zinx_Run();ZinxKernel::ZinxKernelFini();}

3.1.4 代码测试

设置标准输入

UserData* GameProtocol::raw2request(std::string _szInput){cout << _szInput << endl;return nullptr;}

3.2 协议层与消息类

• GameProtocol::GetMsgProcessor 函数即返回绑定的玩家对象
• GameProtocol::GetMsgSender 函数即返回绑定的通道对象
• GameProtocol::response2raw 函数要返回消息内容编码后的字节流（将GameMsg 对象中每个消息对象序列化并结合长度消息ID一起粘合起来）
• GameProtocol::raw2request 函数要将一串tcp数据流转换成游戏消息

3.2.1 消息的定义

//henum MSG_TYPE {MSG_TYPE_LOGIN_ID_NAME = 1,MSG_TYPE_CHAT_CONTENT = 2,MSG_TYPE_NEW_POSTION = 3,MSG_TYPE_BROADCAST = 200,MSG_TYPE_LOGOFF_ID_NAME = 201,MSG_TYPE_SRD_POSTION = 202} enMsgType;

3.2.2 消息类-用户请求对象的创建

• 一个类一个请求

//hclass GameMsg :public UserData{public:/*用户的请求信息*/google::protobuf::Message * pMsg = NULL;enum MSG_TYPE {MSG_TYPE_LOGIN_ID_NAME = 1,MSG_TYPE_CHAT_CONTENT = 2,MSG_TYPE_NEW_POSTION = 3,MSG_TYPE_BROADCAST = 200,MSG_TYPE_LOGOFF_ID_NAME = 201,MSG_TYPE_SRD_POSTION = 202} enMsgType;/*已知消息内容创建消息对象*/GameMsg(MSG_TYPE _type, google::protobuf::Message* _pMsg);/*将字节流内容转换成消息结构*/GameMsg(MSG_TYPE _type, std::string _stream);/*序列化本消息*/std::string serialize();virtual ~GameMsg();};

• 一个消息类里应该要放多条请求，每个请求一条消息

class MultiMsg :public UserData {public:std::list<GameMsg *> m_Msgs;};

3.2.3 protoc消息的创建

protoc msg.proto --cpp_out=./

syntax="proto3";package pb;//无关选项，用于客户端option csharp_namespace="Pb";message SyncPid{int32 Pid=1;string Username=2;}message Player{int32 Pid=1;Position P=2;string Username=3;}message SyncPlayers{/*嵌套多个子消息类型Player的消息*/repeated Player ps=1;}message Position{float X=1;float Y=2;float Z=3;float V=4;int32 BloodValue=5;}message MovePackage{Position P=1;int32 ActionData=2;}message BroadCast{int32 Pid=1;int32 Tp=2;/*根据Tp不同，Broadcast消息会包含：聊天内容(Content)或初始位置(P)或新位置P*/oneof Data{string Content=3;Position P=4;/*ActionData暂时预留*/int32 ActionData=5;}string Username=6;}message Talk{string Content=1;}

3.2.4 消息对象的构造与解析

GameMsg::GameMsg(MSG_TYPE _type, std::string _stream) :enMsgType(_type){/*通过简单工厂构造具体的消息对象*/switch (_type){case GameMsg::MSG_TYPE_LOGIN_ID_NAME:pMsg = new pb::SyncPid();break;case GameMsg::MSG_TYPE_CHAT_CONTENT:pMsg = new pb::Talk();break;case GameMsg::MSG_TYPE_NEW_POSTION:pMsg = new pb::Position();break;case GameMsg::MSG_TYPE_BROADCAST:pMsg = new pb::BroadCast();break;case GameMsg::MSG_TYPE_LOGOFF_ID_NAME:pMsg = new pb::SyncPid();break;case GameMsg::MSG_TYPE_SRD_POSTION:pMsg = new pb::SyncPlayers();break;default:break;}/*将参数解析成消息对象内容*/pMsg->ParseFromString(_stream);}std::string GameMsg::serialize(){std::string ret;pMsg->SerializeToString(&ret);return ret;}

3.2.5 代码测试-1

3.2.6 报文里的多条请求

//hclass MultiMsg :public UserData {public:std::list<GameMsg*> m_Msgs; //注意此处要加命名空间};

MultiMsg* pRet = new MultiMsg(); //此时没有用户请求/*构造一条用户请求*/GameMsg* pMsg = new GameMsg((GameMsg::MSG_TYPE)id, szLast.substr(8, iLength)); // iLength是正文的长度pRet->m_Msgs.push_back(pMsg);//Debug打印每条请求for (auto single : pRet->m_Msgs){cout << single->pMsg->Utf8DebugString() << endl;}

3.2.7 Tcp报文粘包的处理

问题：tcp或类似的流式文件无法保证收到的数据按照期望的格式分割。

举例：服务器期望接收2个字节的数据作为一个合理请求。客户端发送了两个请求（四个字节）后，由于网络拥塞，服务器收到了1个字节后，recv返回，1秒钟后，数据到来，再次调用recv会收到3个字节。

常规套路：

1. 设定报文边界，一般使用Tag Length Value的格式
2. recv数据后，若接收缓冲区当前数据长度小于报文内规定长度，则保留当前缓冲区，下次recv数据后重新处理（缓存）
3. 若接收缓冲区数据长度大于等于报文内规定长度，则循环生成生成请求并保留后续多余的数据等待下次recv数据后重新处理（滑窗）

UserData* GameProtocol::raw2request(std::string _szInput){MultiMsg* pRet = new MultiMsg(); //此时没有用户请求szLast.append(_szInput);while (1){if (szLast.size() < 8){break;}/*在前四个字节中读取消息内容长度*/int iLength = 0;iLength |= szLast[0] << 0;iLength |= szLast[1] << 8;iLength |= szLast[2] << 16;iLength |= szLast[3] << 24;/*中四个字节读类型id*/int id = 0;id |= szLast[4] << 0;id |= szLast[5] << 8;id |= szLast[6] << 16;id |= szLast[7] << 24;/*通过读到的长度判断后续报文是否合法*/if (szLast.size() - 8 < iLength){/*本条报文还没够，啥都不干*/break;}/*构造一条用户请求*/GameMsg* pMsg = new GameMsg((GameMsg::MSG_TYPE)id, szLast.substr(8, iLength)); // iLength是正文的长度pRet->m_Msgs.push_back(pMsg);/*弹出已经处理成功的报文*/szLast.erase(0, 8 + iLength);}//Debug打印每条请求for (auto single : pRet->m_Msgs){cout << single->pMsg->Utf8DebugString() << endl;}return pRet;}/*参数来自业务层，待发送的消息返回值转换后的字节流*/std::string * GameProtocol::response2raw(UserData & _oUserData){int iLength = 0;int id = 0;std::string MsgContent;GET_REF2DATA(GameMsg, oOutput, _oUserData);id = oOutput.enMsgType;MsgContent = oOutput.serialize();iLength = MsgContent.size();auto pret = new std::string();pret->push_back((iLength >> 0) & 0xff);pret->push_back((iLength >> 8) & 0xff);pret->push_back((iLength >> 16) & 0xff);pret->push_back((iLength >> 24) & 0xff);pret->push_back((id >> 0) & 0xff);pret->push_back((id >> 8) & 0xff);pret->push_back((id >> 16) & 0xff);pret->push_back((id >> 24) & 0xff);pret->append(MsgContent);return pret;}

3.2.8 数据包代码测试

3.2.8.1 完整数据

08000000010000000801120474657374

08 00 00 00 – 前4个字节存储数据消息的长度，变量值是数据消息的长度为8个字节。
01 00 00 00 – 第5-8个字节存储的是用户的ID，变量值表示用户ID是1
08 01 12 04 74 65 73 74 – 末尾8个字节表示数据消息的全部内容

3.2.8.2 数据缺失和错误

收到数据以后，啥都不干

3.2.9 协议和通道相互绑定

3.2.9.1 循环引用的问题

一般地来说，不涉及使用类的成员的时候，尽量避免使用头文件，直接声明一个类即可。

在GameChannel.h中引用了头文件"GameProtocol.h"

#pragma once#include#include"GameProtocol.h"class GameChannel :public ZinxTcpData{public:GameChannel(int _fd);virtual ~GameChannel();GameProtocol * m_proto = NULL; };

如果在GameProtocol.h中引用GameChannel.h，则会造成循环引用。
处理办法是，直接在前面声明相关的类。

#pragma once#include class GameChannel;//避免循环引用class GameProtocol :public Iprotocol{std::string szLast; //上次未来得及处理的报文public:GameChannel* m_channel = NULL;GameProtocol() ;virtual ~GameProtocol();};

3.2.9.1 相互绑定的实现

3.2.9.3 代码测试

pb::SyncPid* pmsg = new pb::SyncPid();pmsg->set_pid(1);pmsg->set_username("test");GameMsg gm(GameMsg::MSG_TYPE_LOGIN_ID_NAME, pmsg);auto output = gm.serialize();for (auto byte : output){printf("%02X ", byte);}puts("");char buff[] = { 0x08, 0x01, 0x12, 0x04 ,0x74, 0x65, 0x73, 0x74 };std::string input(buff, sizeof(buff));auto ingm = GameMsg(GameMsg::MSG_TYPE_LOGIN_ID_NAME, input);std::cout << dynamic_cast<pb::SyncPid*> (ingm.pMsg)->pid() << std::endl;std::cout << dynamic_cast<pb::SyncPid*> (ingm.pMsg)->username() << std::endl;

收到数据

07 00 00 00 02 00 00 00 0A 05 68 65 6C 6C 6F

07 00 00 00 – 数据消息的长度是7个字节
02 00 00 00 – 消息ID是2
0A 05 68 65 6C 6C 6F – 转换成string代表”hello”

3.3 业务层玩家类的创建

3.3.1 在Role中绑定协议

class GameProtocol;class GameRole :public Irole{public:GameRole() ;virtual ~GameRole();// 通过 Irole 继承virtual bool Init() override;virtual UserData* ProcMsg(UserData& _poUserData) override;virtual void Fini() override;GameProtocol* m_pProto = NULL;};

3.3.2 在协议中绑定一个role

class GameChannel;//避免循环引用class GameRole;class GameProtocol :public Iprotocol{std::string szLast; //上次未来得及处理的报文public:GameChannel* m_channel = NULL;GameRole* m_Role = NULL;GameProtocol() ;virtual ~GameProtocol();// 通过 Iprotocol 继承virtual UserData* raw2request(std::string _szInput) override;virtual std::string* response2raw(UserData& _oUserData) override;virtual Irole* GetMsgProcessor(UserDataMsg& _oUserDataMsg) override;virtual Ichannel* GetMsgSender(BytesMsg& _oBytes) override;};

3.3.3 在tcp中绑定协议和玩家对象

ZinxTcpData* GameConnFact::CreateTcpDataChannel(int _fd){/*创建tcp通道对象*/auto pChannel = new GameChannel(_fd);/*创建协议对象*/auto pProtocol = new GameProtocol();/*创建玩家对象*/auto pRole = new GameRole();/*绑定协议对象和通道对象*/pChannel->m_proto = pProtocol;pProtocol->m_channel = pChannel;/*绑定协议对象和玩家对象*/pProtocol->m_Role = pRole;pRole->m_pProto = pProtocol;/*将协议对象添加到kernel, 注意参数需要为指针*/ZinxKernel::Zinx_Add_Proto(*pProtocol);/*将玩家对象添加到kernel*/ZinxKernel::Zinx_Add_Role(*pRole);return pChannel;}

3.3.4 重写协议层获取角色处理对象

Irole* GameProtocol::GetMsgProcessor(UserDataMsg& _oUserDataMsg){return m_Role;}

3.3.5 修改角色Init函数

bool GameRole::Init(){return true;}

3.3.6 测试代码

/*处理游戏相关的用户请求*/UserData* GameRole::ProcMsg(UserData& _poUserData){/*测试：打印消息内容*/GET_REF2DATA(MultiMsg, input, _poUserData);for (auto single : input.m_Msgs){cout << "type is" << single->enMsgType << endl;cout << single->pMsg->Utf8DebugString() << endl;}return nullptr;

08000000010000000801120474657374