C/C++轻量级并发TCP服务器框架Zinx-游戏服务器开发002：框架学习-按照三层结构模式重构测试代码+Tcp数据适配+时间轮定时器

已于 2023-11-08 13:24:18 修改
阅读量1.4k 收藏 1
点赞数 1
分类专栏： Zinx-Tcp轻量级并发服务器框架-MMO游戏服务器开发 文章标签： 服务器 游戏 重构
于 2023-11-03 11:26:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangchufeng123/article/details/134194908
版权

文章目录

1 Zinx框架总览

在这里插入图片描述

2 三层模式的分析

在这里插入图片描述

3 三层重构原有的功能 - 头文件

三层结构重构原有功能

  1. 自定义消息类，继承UserData，添加一个成员变量szUserData
  2. 定义多个Role类继承Irole，重写ProcMsg函数，进行不同处理
  3. 定义protocol类，继承Iprotocol，重写四个函数，两个函数时原始
    数据和用户数据之间的转换；另两个用来找消息处理对象和消息发
    送对象。
  4. 定义channel类，继承Ichannel，在getnextinputstage函数中返回协
    议对象

3.1 通道层Stdin和Stdout类

通道类，派生自基础处理者类，提供基于系统调用的数据收发功能
一般地，用户应该根据处理的文件（信息源）不同而创建通道类的子类或选用合适的实用类（已经提供的通道类子类）来完成系统级文件IO
在这里插入图片描述

class StdInChannel :
	public Ichannel
{
public:
	StdInChannel();
	virtual ~StdInChannel();

	// 通过 Ichannel 继承
	virtual bool Init() override;
	virtual bool ReadFd(std::string& _input) override;
	virtual bool WriteFd(std::string& _output) override;
	virtual void Fini() override;
	virtual int GetFd() override;
	virtual std::string GetChannelInfo() override;
	virtual AZinxHandler* GetInputNextStage(BytesMsg& _oInput) override;
};

class StdOutChannel :public Ichannel
{
	// 通过 Ichannel 继承
	virtual bool Init() override;
	virtual bool ReadFd(std::string& _input) override;
	virtual bool WriteFd(std::string& _output) override;
	virtual void Fini() override;
	virtual int GetFd() override;
	virtual std::string GetChannelInfo() override;
	virtual AZinxHandler* GetInputNextStage(BytesMsg& _oInput) override;
};

3.1.2 StdInChannel

bool StdInChannel::ReadFd(std::string& _input)
{
	cin >> _input;
	return true;
}

bool StdInChannel::WriteFd(std::string& _output)
{
	return false;
}

int StdInChannel::GetFd()
{
	return 0;
}

std::string StdInChannel::GetChannelInfo()
{
	return "stdin";
}

AZinxHandler* StdInChannel::GetInputNextStage(BytesMsg& _oInput)
{
	/*返回协议对象*/
	return CmdCheck::GetInstance();
}

3.1.2 StdOutChannel

bool StdOutChannel::ReadFd(std::string& _input)
{
	return false;
}

bool StdOutChannel::WriteFd(std::string& _output)
{
	cout << _output << endl;
	return true;
}

int StdOutChannel::GetFd()
{
	return 1;
}

std::string StdOutChannel::GetChannelInfo()
{
	return "stdout";
}

AZinxHandler* StdOutChannel::GetInputNextStage(BytesMsg& _oInput)
{
	return nullptr;
}

3.2 协议层CmdCheck和CmdMsg类

3.2.1 CmdCheck单例模式

  1. 原始数据和业务数据相互函数，开发者重写该函数，实现协议
  2. 获取处理角色对象函数，开发者应该重写该函数，用来指定当前产生的用户数据消
  3. 获取发送通道函数，开发者应该重写该函数，用来指定当前字节流应该由哪个通道对象发出
class CmdCheck :
	public Iprotocol
{
	CmdCheck();
	virtual ~CmdCheck();
	static CmdCheck *poSingle;
public:
	// 通过 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;
	static CmdCheck *GetInstance() {
		return poSingle;
	}
	std::string szOutChannel;
};
3.2.1.1 单例模式

构造全局唯一的协议对象

#include "CmdCheck.h"
#include "CmdMsg.h"
#include "EchoRole.h"
using namespace std;

CmdCheck *CmdCheck::poSingle = new CmdCheck();
3.2.1.2 * 命令识别类向业务层不同类别做分发

通过是不是命令来进行区分：if (isCmd)

Irole * CmdCheck::GetMsgProcessor(UserDataMsg & _oUserDataMsg)
{
	szOutChannel = _oUserDataMsg.szInfo;
	if ("stdin" == szOutChannel)
	{
		szOutChannel = "stdout";
	}
	/*根据命令不同，交给不同的处理role对象*/
	auto rolelist = ZinxKernel::Zinx_GetAllRole();

	auto pCmdMsg = dynamic_cast<CmdMsg *>(_oUserDataMsg.poUserData);

	/*读取当前消息是否是命令*/
	bool isCmd = pCmdMsg->isCmd;

	Irole *pRetRole = NULL;

	for (Irole *prole : rolelist)
	{
		if (isCmd)
		{
			auto pOutCtrl = dynamic_cast<OutputCtrl *>(prole);
			if (NULL != pOutCtrl)
			{
				pRetRole = pOutCtrl;
				break;
			}
		}
		else
		{
			auto pDate = dynamic_cast<DatePreRole *>(prole);
			if (NULL != pDate)
			{
				pRetRole = pDate;
				break;
			}
		}
	}
	
	return pRetRole;
}

3.2.2 CmdMsg自定义用户信息类，继承UserData

class CmdMsg :
	public UserData
{
public:
	/*成员变量表示要回显的字符串*/
	std::string szUserData;
	/*开启输出标志*/
	bool isOpen = true;
	/*该消息是命令*/
	bool isCmd = false;
	/*要加前缀*/
	bool needDatePre = false;
	
	CmdMsg();
	virtual ~CmdMsg();
};

3.3 业务层：回显类, 输出通道控制类, 日期前缀管理类

3.3.1 回显对象EchoRole

主要有init， procmsg，fini三个函数

#pragma once
#include <zinx.h>

class EchoRole :
	public Irole
{
public:
	EchoRole();
	virtual ~EchoRole();

	// 通过 Irole 继承
	virtual bool Init() override;
	virtual UserData * ProcMsg(UserData & _poUserData) override;
	virtual void Fini() override;
};
  • 容易出错的点：参数一必须是一个堆对象
UserData * EchoRole::ProcMsg(UserData & _poUserData)
{
	/*写出去*/
	GET_REF2DATA(CmdMsg, input, _poUserData);
	CmdMsg *pout = new CmdMsg(input);
	ZinxKernel::Zinx_SendOut(*pout, *(CmdCheck::GetInstance()));
	return nullptr;
}

3.3.2 控制输入输出

  1. 写一个关闭输出的角色类，摘除输出通道或添加输出通道
  2. 在CmdMsg用户数据类中添加开关标志，是否是命令标志
  3. 在协议类中，根据输入字符串，设置开关标志和是否是命令的标志
  4. 在协议类分发消息时，判断是否是命令，是命令则发给关闭输出角 色类，否则发给回显角色类
class OutputCtrl :public Irole {
	// 通过 Irole 继承
	virtual bool Init() override;
	virtual UserData * ProcMsg(UserData & _poUserData) override;
	virtual void Fini() override;
	Ichannel *pOut = NULL;
};

3.3.3 日期管理类

class DatePreRole :public Irole {
	// 通过 Irole 继承
	virtual bool Init() override;
	virtual UserData * ProcMsg(UserData & _poUserData) override;
	virtual void Fini() override;
	bool needAdd = false;
};

4 Tcp数据适配

4.1 工厂类 - 框架头文件分析

  • 产生tcp数据套接字通道类的抽象工厂类。
    • 开发者需要重写CreateTcpDataChannel函数，来返回一个tcp通道对象。
    • 般地，开发者应该同时创建一对tcp通道类和工厂类
class IZinxTcpConnFact {
public:
	virtual ZinxTcpData *CreateTcpDataChannel(int _fd) = 0;
};
  • tcp监听通道类，这是一个实体类（不建议继承该类）。
    • 开发者可以直接创建tcp监听通道对象，
    • 一般地，开发者应该在该类的构造函数中，指定一个tcp套接字通道类的工厂类，当有连接到来后，该工厂类的成员方法会被调用
class ZinxTCPListen :
	public Ichannel
{
private:
	unsigned short m_usPort = 0;
	int m_fd = -1;
	IZinxTcpConnFact *m_ConnFac = NULL;
	
public:
	ZinxTCPListen(unsigned short _usPort, IZinxTcpConnFact *_pConnFac) :m_usPort(_usPort), m_ConnFac(_pConnFac){}
	virtual ~ZinxTCPListen();

	virtual bool Init() override;
	virtual bool ReadFd(std::string & _input) override;
	virtual bool WriteFd(std::string & _output) override;
	virtual void Fini() override;
	virtual int GetFd() override;
	virtual std::string GetChannelInfo() override;
	virtual AZinxHandler * GetInputNextStage(BytesMsg & _oInput);
};

4.2 tcp通道实现

在这里插入图片描述

4.2.1 Tcp套接字通道通信类

  • tcp数据套接字通道类，继承通道类，该类也是一个抽象类，需要开发者继承该类，重写GetInputNextStage函数以指定读取到的字节流的处理方式
// h
class myTcpData :public ZinxTcpData {
public:
	myTcpData(int _fd) :ZinxTcpData(_fd) {}
	// 通过 ZinxTcpData 继承
	virtual AZinxHandler* GetInputNextStage(BytesMsg& _oInput) override;
};
  • Q: Ichannel对象读取到的数据给谁了？
    • 给该对象调用GetInputNextStage函数返回的对象
AZinxHandler* myTcpData::GetInputNextStage(BytesMsg& _oInput)
{
	/*返回协议对象*/
	return CmdCheck::GetInstance();
}
  • Q: Iprotocol对象转换出的用户请求给谁了？
    • 给该对象调用GetMsgProcessor函数返回的对象

4.2.2 tcp数据套接字通道类的工厂类

  • 产生tcp数据套接字通道类的抽象工厂类，开发者需要重写CreateTcpDataChannel函数，来返回一个tcp通道对象
    一般地，开发者应该同时创建一对tcp通道类和工厂类
// h
class myFact :public IZinxTcpConnFact {
	// 通过 IZinxTcpConnFact 继承
	virtual ZinxTcpData* CreateTcpDataChannel(int _fd) override;
};

ZinxTcpData* myFact::CreateTcpDataChannel(int _fd)
{
	return new myTcpData(_fd);
}

5 时间轮定时器

5.1 timerfd产生超时事件

timerfd_create()返回定时器文件描述符
timerfd_settime()设置定时周期，立刻开始计时
read，读取当当前定时器超时的次数，没超时会阻塞.
一般地，会将定时器文件描述符结合IO多路复用使用

5.1.1 测试代码

#include<sys/timerfd.h>
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
	int iTimerfd = timerfd_create(CLOCK_MONOTONIC, 0);
	struct itimerspec period
	{{5, 0},{5, 0}
	};
	timerfd_settime(iTimerfd,0, &period,NULL);
	__uint64_t count = 0;
	while(1) {
		read(iTimerfd, &count, sizeof(count));
		puts("time out");
	}
}

在这里插入图片描述

5.2 时间轮设置

单例模式

AZinxHandler * ZinxTimerChannel::GetInputNextStage(BytesMsg & _oInput)
{
	return &TimerOutMng::GetInstance();
}

TimerOutMng TimerOutMng::single;

5.2.1 时间轮的定义

// h
class TimerOutProc {
public:
	virtual void Proc() = 0;
	virtual int GetTimeSec() = 0;
	/*所剩圈数*/
	int iCount = -1;
};
  • vector存储轮的齿
  • 每个齿里用list存每个定时任务
  • 每个定时任务需要记录剩余圈数
  • 时间轮类中要有一个刻度，每秒进一步
TimerOutMng::TimerOutMng()
{
	/*创建10个齿*/
	for (int i = 0; i < 10; i++)
	{
		list<TimerOutProc *> tmp;
		m_timer_wheel.push_back(tmp);
	}
}

5.2.2 时间轮的移动

// h
class TimerOutMng :public AZinxHandler {
	std::vector<std::list<TimerOutProc *> > m_timer_wheel;
	int cur_index = 0;
	static TimerOutMng single;
	TimerOutMng();
public:
	/*处理超时事件,遍历所有超时任务*/
	virtual IZinxMsg * InternelHandle(IZinxMsg & _oInput) override;

	virtual AZinxHandler * GetNextHandler(IZinxMsg & _oNextMsg) override;
	void AddTask(TimerOutProc *_ptask);
	void DelTask(TimerOutProc *_ptask);
	static TimerOutMng &GetInstance() {
		return single;
	}
};
  • 移动当前刻度
  • 遍历当前齿中的任务列表
  • 若圈数为0，则执行处理函数，摘除本节点，重新添加
  • 否则，圈数–
IZinxMsg * TimerOutMng::InternelHandle(IZinxMsg & _oInput)
{
	unsigned long iTimeoutCount = 0;
	GET_REF2DATA(BytesMsg, obytes, _oInput);
	obytes.szData.copy((char *)&iTimeoutCount, sizeof(iTimeoutCount), 0);

	while (iTimeoutCount-- > 0)
	{
		/*移动刻度*/
		cur_index++;
		cur_index %= 10;
		list<TimerOutProc *> m_cache;
		/*遍历当前刻度所有节点，指向处理函数或圈数-1，*/
		for (auto itr = m_timer_wheel[cur_index].begin(); itr != m_timer_wheel[cur_index].end(); )
		{
			if ((*itr)->iCount <= 0)
			{
				/*缓存待处理的超时节点*/
				m_cache.push_back(*itr);
				auto ptmp = *itr;
				itr = m_timer_wheel[cur_index].erase(itr);
				AddTask(ptmp);
			}
			else
			{
				(*itr)->iCount--;
				++itr;
			}
		}

		/*统一待处理超时任务*/
		for (auto task : m_cache)
		{
			task->Proc();
		}
	}
	
	return nullptr;
}

5.2.3 添加和删除任务

5.2.3.1 添加任务
  • 计算当前任务在哪个齿上
  • 添加该任务到该齿对应的list里
  • 计算所需圈数记录到任务中
void TimerOutMng::AddTask(TimerOutProc * _ptask)
{
	/*计算当前任务需要放到哪个齿上*/
	int index = (_ptask->GetTimeSec() + cur_index) % 10;
	/*把任务存到该齿上*/
	m_timer_wheel[index].push_back(_ptask);
	/*计算所需圈数*/
	_ptask->iCount = _ptask->GetTimeSec() / 10;
}
5.2.3.2 删除任务
  • 遍历所有齿
  • 在每个齿中遍历所有节点
  • 若找到则删除并返回
void TimerOutMng::DelTask(TimerOutProc * _ptask)
{
	/*遍历时间轮所有齿，删掉任务*/
	for (list<TimerOutProc *> &chi : m_timer_wheel)
	{
		for (auto task : chi)
		{
			if (task == _ptask)
			{
				chi.remove(_ptask);
				return;
			}
		}
	}
}

5.3 定时器设置

5.3.1 定时器定义

class ZinxTimerChannel :
	public Ichannel
{
	int m_TimerFd = -1;

public:
	ZinxTimerChannel();
	virtual ~ZinxTimerChannel();

	// 通过 Ichannel 继承
	virtual bool Init() override;
	virtual bool ReadFd(std::string & _input) override;
	virtual bool WriteFd(std::string & _output) override;
	virtual void Fini() override;
	virtual int GetFd() override;
	virtual std::string GetChannelInfo() override;
	virtual AZinxHandler * GetInputNextStage(BytesMsg & _oInput) override;
};

5.3.2 定时器初始化

/*创建定时器文件描述符*/
bool ZinxTimerChannel::Init()
{
	bool bRet = false; //判断成功或者失败
	/*创建文件描述符*/
	int iFd = timerfd_create(CLOCK_MONOTONIC, 0);
	if (0 <= iFd)
	{
		/*设置定时周期*/
		struct itimerspec period = {
			{1,0}, {1,0}
		};
		if (0 == timerfd_settime(iFd, 0, &period, NULL))
		{
			bRet = true;
			m_TimerFd = iFd;  
		}
	}
	return bRet;
}
/*读取超时次数*/
bool ZinxTimerChannel::ReadFd(std::string & _input)
{
	bool bRet = false;
	char buff[8] = { 0 };

	if (sizeof(buff) == read(m_TimerFd, buff, sizeof(buff)))
	{
		bRet = true;
		_input.assign(buff, sizeof(buff));
	}
	return bRet;
}

bool ZinxTimerChannel::WriteFd(std::string & _output)
{
	return false;
}

/*关闭文件描述符*/
void ZinxTimerChannel::Fini()
{
	close(m_TimerFd);
	m_TimerFd = -1;
}

/*返回当前的定时器文件描述符*/
int ZinxTimerChannel::GetFd()
{
	return m_TimerFd;
}


std::string ZinxTimerChannel::GetChannelInfo()
{
	return "TimerFd"; // 名字随便起的
}

5.3.3 输出hello world

class output_hello :public AZinxHandler {
	// 通过 AZinxHandler 继承
	virtual IZinxMsg * InternelHandle(IZinxMsg & _oInput) override
	{
		auto pchannel = ZinxKernel::Zinx_GetChannel_ByInfo("stdout");
		std::string output = "hello world";
		ZinxKernel::Zinx_SendOut(output, *pchannel);
		return nullptr;
	}
	virtual AZinxHandler * GetNextHandler(IZinxMsg & _oNextMsg) override
	{
		return nullptr;
	}
} *pout_hello = new output_hello();
大大枫
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Zinx 一个基于Golang的轻量级并发服务器框架
07-23
zinx具体使用领域包括:后端模块的消息中转、长链接游戏服务器、Web框架中的消息处理插件等。zinx的定位是代码简洁，让更多的开发者迅速的了解框架的内脏细节并且可以快速基于zinx DIY(二次开发)一款适合自己企业场景的模块。
C/C++轻量级并发TCP服务器框架Zinx-游戏服务器开发006：基于redis查找玩家姓名+游戏业务实现总结
啊枫
11-09 1576
7.2版本命令在目录下: 1.4 Hiredis API的使用 1.5 我的动态库和头文件 根据上述的输出信息，我把动态库直接拷贝到了系统目录下,程序加载的时候加载的是 头文件的位置没有改变，使用的默认设置 路径和库要根据实际情况设置 redisConnect跟数据库建立链接（redisFree释放掉）。 redisCommand发命令并通过返回值取出结果（freeReplyObject释放掉）。 2 Redis的使用 2.1 初始化时候 2.2 结束的时候 3 测试
Linux下C++轻量级WebServer服务器 框架梳理
最新发布
qq_58220428的博客
03-02 1565
WebServer是一个很好的入门级C++项目，因为它涉及到了方方面面，不仅可以提高编程能力，还包括了操作系统、计算机网络、数据库等方面的知识，所以我很推荐大家去入手这个项目。说细一点这个项目包含锁机制、日志系统、线程池、http处理、并发模型等实现，但是很多人一开始做这个项目的时候，会觉得逻辑很混乱从而无从下手，所以我写下这篇文章目的就是帮助大家起到一个梳理逻辑的作用，好了废话不多说，咱们往下看！
Zinx 是一个基于Golang的轻量级并发服务器框架
04-25
基于 Go 的轻量级并发TCP服务器框架
Zinx--Golang轻量级并发服务器框架
03-18
我们为什么要做Zinx，Golang目前在服务器的应用框架很多，但是应用在游戏领域或者其他长链接的领域的轻量级企业框架甚少。 ​ 设计Zinx的目的是我们可以通过Zinx框架来了解基于Golang编写一个TCP服务器的整体轮廓，让更多的Golang爱好者能深入浅出的去学习和认识这个领域。 ​ Zinx框架的项目制作采用编码和学习教程同步进行，将开发的全部递进和迭代思维带入教程中，而不是一下子给大家一个非常完整的框架去学习，让很多人一头雾水，不知道该如何学起。 ​ 教程会一个版本一个版本迭代，每个版本的添加功能都是微小的，让一个服务框架小白，循序渐进的曲线方式了解服务器框架的领域。 ​ 当然，最后希望Zinx会有更多的人加入，给我们提出宝贵的意见，让Zinx成为真正的解决企业的服务器框架！在此感谢您的关注！
zinx：基于Golang轻量级TCP并发服务器框架
02-04
Zinx是一个基于Golang的轻量级并发服务器框架 说明：现有的zinx已经在很多企业进行开发使用，具体的使用领域包括：串行模块的消息中转，长链接游戏服务器，Web框架中的消息处理插件等。zinx的定位是代码简洁，让更多的开发者Swift的了解框架的内部脏细节和可以快速基于zinx DIY一种适合自己企业场景的模块。 开发者 刘丹冰（ ） 张超（ ） 高智辉Roger（ ） 胡贵建（ ） 开发者 刘洋（ ） 开发者 胡琪（ ） 开发者 胡贵建（ ） zinx原始码地址 Github Git： : 编码云（Gitee） Git： : 在线开发教程 [B站]
C++高性能分布式服务器框架
01-17
C++高性能分布式服务器框架,webserver,websocket server,自定义tcp_server（包含日志模块，配置模块，线程模块，协程模块，协程调度模块，io协程调度模块，hook模块，socket模块，bytearray序列化，http模块，TcpServer模块，Websocket模块，Https模块等, Smtp邮件模块, MySQL, SQLite3, ORM,Redis,Zookeeper)
Zinx框架学习 - 构建最基础的Server
qq_47431008的博客
05-31 1364
Zinx框架学习记录
Zinx框架学习 - 消息封装
qq_47431008的博客
06-03 1060
Zinx框架学习记录
基于Zinx框架实现轻量级TCP服务器
wmkkk_的博客
09-22 1030
刘丹冰老师zinx教程
C/C++轻量级并发TCP服务器框架Zinx-游戏服务器开发003：架构搭建-需求分析及TCP通信方式的实现
啊枫
11-05 1134
消息定义每一条服务器和客户端之前的消息都应该满足以下格式消息内容的长度（4个字节，低字节在前）| 消息ID（4个字节，低字节在前）| 消息内容 |消息以及其处理方式已经在客户端实现，本项目要实现的是服务器端的相关处理详细定义如下消息ID消息内容发送方向客户端处理服务器处理1玩家ID和玩家姓名S->C记录自己ID和姓名无2聊天内容C->S无广播给所有玩家3新位置C->S无处理玩家位置更新后的信息同步200玩家ID，聊天内容/初始位置/动作（预留）/新位置。
zinx —— golang —— MMO游戏服务器开发对应客户端
06-01
zinx —— golang —— MMO游戏服务器开发对应客户端
C/C++轻量级并发TCP服务器框架Zinx-框架开发003:转大写字母输出+责任链模式+代码重构思路及实现
啊枫
11-17 280
通道类和功能处理类的对象都是整个流程中的环节，将这些环节连起来则形成责任链。
Zinx框架学习 - 多路由实现
qq_47431008的博客
06-04 696
Zinx框架学习记录
0基础要怎么开始学习c++？
技术专家
05-17 929
0基础要怎么开始学习c++？
C++游戏服务器框架笔记(一)_封装数据包类
木可的博客
09-20 2954
笔记目录导航 C++游戏服务器框架笔记(一)_封装数据包类 C++游戏服务器框架笔记(二)_封装Socket类 C++游戏服务器框架笔记(三)_封装ByteBuffer类 ...... 【前要注明】: 该系列博客是我在学习总结开发C++游戏服务器底层框架的【学习笔记】,目的是为了记录自己学习经历，方便以后反思和优化提升。欢迎各位大佬对文章中的错误和不足提出建议和指导【抱拳】 游戏服务器与客户端的通信是通过socket网络接口按照既定的协议发送、接受数据包传递数据...
Zinx框架学习 - 连接管理
qq_47431008的博客
06-05 698
Zinx框架学习记录
【zinx】Golang轻量级TCP服务器框架（十）—— zinx框架感想
一年之内毫无半点成绩，想起来做人真是没趣。
10-02 4459
Golang轻量级TCP服务器框架（十）—— zinx框架感想 原作者视频地址：zinx-Golang轻量级TCP服务器框架 本人为自学整理的文档，梳理思考开发框架的基本思路，方法，以及视频中不理解的地方。 若想学习，强烈建议直接观看原作视频即可。 可在下方留言交流。 现在的网站开发都是利用各种框架。 基本上我们刚学习语言，之后立马就被带入的框架之中。 然而，框架背后的一些设计理念，我们根本不知道。 虽然zinx仅仅是一个简单的TCP-sever框架，我也有很大的收获。 虽然，以后在工作用，不会直接用
【Go 框架开发】Zinx 框架开发笔记
萌宅鹿的技术小屋
03-02 3084
Zinx - V0.1 构建最基础的 server Zinx - V0.2 连接封装与业务绑定 Zinx - V0.3 框架路由模块 Zinx - V0.4 全局配置 Zinx - V0.5 消息封装 Zinx - V0.6 多路由模式 Zinx - V0.7 读写协程分离 Zinx - V0.8 消息队列及多任务机制 Zinx - V0.9 连接管理 Zinx - V1.0 连接属性配置
c++游戏服务端学习路线
12-07
C++游戏服务端开发是一个非常有前途的领域，以下是一个C++游戏服务端学习路线： 1.首先需要学习C++语言基础，包括语法、指针、内存管理等知识。 2.学习Linux操作系统基础知识，包括Linux命令、进程管理、网络编程等。 3.学习网络编程，包括TCP/IP协议、Socket编程等。 4.学习数据库编程，包括MySQL、Redis等。 5.学习多线程编程，包括线程同步、线程池等。 6.学习游戏服务器框架，包括zinx并发框架、Muduo网络库等。 7.学习Docker容器技术，用于部署游戏服务器。 8.学习Nginx反向代理服务器，用于负载均衡和静态资源服务器。 9.学习Unity3D游戏引擎，用于客户端开发和与服务端的交互。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大大枫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值