RakNet网络框架简单入门

        raknet是采用c++语言编写的一套基于UDP协议的高性能网络框架，主要使用在游戏中，当然了，其他项目也可以使用。还有，他是跨平台的。

        由于目前的手游项目的网络框架使用的就是它，花了点时间看了看，这里写个比较简单的例子来说明该如何使用它。要是在项目中使用，只需要扩展这个代码即可。

        raknet官网上下载资料包，使用vs2008及以上的版本打开里面的项目工程，编译里面的DLL项目，生成RakNet_DLL_Debug_Win32.lib和RakNet_DLL_Debug_Win32.dll文件，当然这是Debug模式下。

        

        现在我们实现这样一个效果，server接受client发送过来的数据，并添加一些字符串否再发给client，client显示发送和接受的数据。发送的内容使用一个结构体来存放。

我们新建一个文件夹，将刚刚生成的lib文件拷贝进去，并且将解压出来的source文件夹一起复制过去，里面含有raknet的头文件。

在vs中创建win32控制台程序工程，放到新建的文件夹中，工程属性中配置属性C/C++常规附加库包含目录中添加source文件夹，连接器输入中添加RakNet_DLL_Debug_Win32.lib，连接器常规附加库目录协商lib文件所在的目录。

首先看看server端代码：NetMgr.h

#ifndef __NETMGR_H__
#define __NETMGR_H__

class NetMgr
{
public:
	NetMgr();
	~NetMgr();

	//初始化网络
	void init_net_work() const;

	//接收网络消息
	void net_work_update() const;

	//发送数据给client
	void send_data_to_client() const;

	//接收client的数据
	void receive_data_from_client(const unsigned char *msg_data) const;

private:
	//处理server发送过来的消息
	void _process_client_message() const;

public:
	unsigned short server_port;
	int max_client;
};

#endif

再看看NetMgr.cpp：

#include "NetMgr.h"
#include "../../Source/RakPeerInterface.h"
#include "../../Source/RakNetTypes.h"
#include "../../Source/MessageIdentifiers.h"
#include "../../Source/BitStream.h"

#include <iostream>
#include "ServerClientMessage.h"
#include "ServerClientStruct.h"


RakNet::RakPeerInterface *net_peer;			//网络消息
RakNet::Packet *net_packet;					//网络消息包


NetMgr::NetMgr()
	: server_port(10001)
	, max_client(1000)
{

}

NetMgr::~NetMgr()
{

}

//初始化网络
void NetMgr::init_net_work() const
{
	//初始化网络消息
	net_peer = RakNet::RakPeerInterface::GetInstance();
	if (NULL == net_peer)
	{
		std::cout << "GetInstance failed" << std::endl;
		return;
	}

	std::cout << "Start Game Server ......" << server_port << std::endl;

	//开启网络线程来监听相应的端口
	//Startup函数的第一个参数是接受的最大连接数，客户端一般设置成1
	//第二个参数就是要监听的端口。SocketDescriptor监听制定的端口，他是一种套接字，服务器一般设置成SocketDescriptor(server_port, 0)
	//第三个参数是SocketDescriptor数组的大小，传1表明不确定。
	int start_up = net_peer->Startup(1, &RakNet::SocketDescriptor(server_port, 0), 1);
	if (start_up > 0)
	{
		std::cout << "Startup failed" << std::endl;
		return;
	}

	//SetMaximumIncomingConnections容许最多的连接数量
	net_peer->SetMaximumIncomingConnections(max_client);
}

//接收网络消息
void NetMgr::net_work_update() const
{
	//Receive从消息队列中获取消息
	for (net_packet = net_peer->Receive(); net_packet; net_peer->DeallocatePacket(net_packet), net_packet = net_peer->Receive())
	{
		switch (net_packet->data[0])
		{
		case ID_REMOTE_DISCONNECTION_NOTIFICATION:
			std::cout << "Another client has disconnected" << std::endl;
			break;
		case ID_REMOTE_CONNECTION_LOST:
			std::cout << "Another client has lost the connection" << std::endl;
			break;
		case ID_REMOTE_NEW_INCOMING_CONNECTION:
			std::cout << "Another client has connected" << std::endl;
			break;
		case ID_CONNECTION_REQUEST_ACCEPTED:
			std::cout << "Our connection request has been accepted for server" << std::endl;
			break;
		case ID_NEW_INCOMING_CONNECTION:
			std::cout << "A connection is incoming  " << std::endl;
			break;
		case ID_NO_FREE_INCOMING_CONNECTIONS:
			std::cout << "The server is full" << std::endl;
			break;
		case ID_DISCONNECTION_NOTIFICATION:
			std::cout << "A client has disconnected" << std::endl;
			break;
		case ID_CONNECTION_LOST:
			std::cout << "A client lost the connection  " << std::endl;
			break;
		case ID_USER_PACKET_ENUM:
			_process_client_message();				//用户自定义消息入口
			break;
		default:
			std::cout << "Message with identifier %d has arrived" << net_packet->data[0] << std::endl;
			break;
		}
	}
}

// client 发送过来的消息
void NetMgr::_process_client_message() const
{
	int message_id = 0;
	//将消息解析出来，使用BitStream
	//IgnoreBytes忽略掉最外层的raknet的消息类型
	RakNet::BitStream bs_in(net_packet->data, net_packet->length, false);
	bs_in.IgnoreBytes(sizeof(RakNet::MessageID));
	bs_in.Read(message_id);

	//偏移掉自定义的消息，获取实际数据，raknet的消息类型大小是一个字节，自定义的结构体是4个字节（32位机器）
	unsigned char *msg_data = net_packet->data;
	msg_data += sizeof(unsigned long) + sizeof(unsigned char);

	switch (message_id)
	{
	case msg_connect_server:
		this->receive_data_from_client(msg_data);
		break;

	default:
		break;
	}
}

// 接收 client 数据 并回应client
void NetMgr::receive_data_from_client(const unsigned char *msg_data) const
{
	connect_server *receive_data = (connect_server *)msg_data;

	std::cout << "receive from client data is :" << receive_data->content << std::endl;

	connect_server_return send_data;
	memset(&send_data, 0, sizeof(connect_server_return));

	std::string content = receive_data->content;
	content += ". server already receive client data, this is server data";

	sprintf_s(send_data.content_return, "%s", content.c_str());

	std::cout << "server data is :" << send_data.content_return << std::endl;

	//使用BitStream 对象来封装数据
	RakNet::BitStream stream;
	//先写入raknet的消息类型（raknet中自定义类型（ID_USER_PACKET_ENUM））
	stream.Write(( RakNet::MessageID )ID_USER_PACKET_ENUM);
	//再写入我们自己定义的消息类型
	stream.Write(msg_connect_server_return);
	//将数据写到stream中，第一个参数是要写入的数据字节数组，第二个是数据的位数
	stream.WriteBits((unsigned char *)&send_data , sizeof(connect_server_return) * 8);
	//将数据发送到指定的地方
	//第一个参数是要发送的bitstream对象
	//第二个参数是发送的优先级
	//第三个参数是发送的可靠性，这里使用RELIABLE_ORDERED，具体在PacketPriority.h枚举的PacketReliability中有具体说明
	//自己看api，这里设置成0
	//接收方地址
	//是否广播，注意下，要是用那个true，上一个参数就是不需要接受数据的地址
	net_peer->Send(&stream, HIGH_PRIORITY, RELIABLE_ORDERED, 0, net_packet->systemAddress, false);
}

最后看看Main.cpp：

#include "NetMgr.h"
#include <iostream>

int main()
{
	NetMgr *p = new NetMgr;

	p->init_net_work();

	while (true)
	{
		p->net_work_update();
	}
	
	delete p;
	p = NULL;

	return 0;
}

这里server 和client通信传输的数据我们使用结构体来保存，传输的消息类型在枚举变量中列出。下面这两个头文件client和server工程都都需要。
看看消息类型的头文件：ServerClientMessage.h

#ifndef __SERVERCLIENTMESSAGE_H__
#define __SERVERCLIENTMESSAGE_H__

enum message_type
{
	msg_connect_server = 101,
	msg_connect_server_return,
};

#endif

保存数据的结构体文件：ServerClientStruct.h

#ifndef __SERVERCLIENTSTRUCT_H__
#define  __SERVERCLIENTSTRUCT_H__

#pragma once


#pragma pack(push, 1)
struct connect_server
{
	char content[500];
};
#pragma pack(pop)

#pragma pack(push, 1)
struct connect_server_return
{
	char content_return[1000];
};
#pragma pack(pop)


#endif

上面的是server端，来看看client端。

NetMgr.h

#ifndef __NETSERVERMGR_H__
#define __NETSERVERMGR_H__

#include <string>

class NetServerMgr
{
public:
	NetServerMgr();
	~NetServerMgr();

	//初始化网络
	void init_net_work() const;

	//接收网络消息
	void net_work_update();

	//发送数据给server
	void send_data_to_server() const;

	//接收server的数据
	void receive_data_from_server(const unsigned char *msg_data) const;

private:
	//处理server发送过来的消息
	void _process_server_message() const;

public:
	std::string server_ip;
	unsigned short server_port;
};

#endif

NetMrg.cpp

#include "NetServerMgr.h"
#include "../../Source/RakPeerInterface.h"
#include "../../Source/RakNetTypes.h"
#include "../../Source/MessageIdentifiers.h"
#include "../../Source/BitStream.h"

#include <iostream>
#include "ServerClientMessage.h"
#include "ServerClientStruct.h"


RakNet::RakPeerInterface *net_peer;			//网络消息
RakNet::Packet *net_packet;					//网络消息包
RakNet::SystemAddress server_address;		//server 地址

NetServerMgr::NetServerMgr()
	: server_ip("localhost")
	, server_port(10001)
{

}

NetServerMgr::~NetServerMgr()
{

}

//初始化网络
void NetServerMgr::init_net_work() const
{
	//初始化网络消息
	net_peer = RakNet::RakPeerInterface::GetInstance();
	if (NULL == net_peer)
	{
		std::cout << "GetInstance failed" << std::endl;
		return;
	}

	int start_up = net_peer->Startup(1, &RakNet::SocketDescriptor(), 1);
	if (start_up > 0)
	{
		std::cout << "Startup failed" << std::endl;
		return;
	}

	//Connect 连接server
	//successful 返回 CONNECTION_ATTEMPT_STARTED
	bool rs = (net_peer->Connect(server_ip.c_str(), server_port, NULL, 0, 0) == RakNet::CONNECTION_ATTEMPT_STARTED);
	if (!rs)
	{
		std::cout << "connect server failed" << std::endl;
		return;
	}
}

//接收网络消息
void NetServerMgr::net_work_update()
{
	for (net_packet = net_peer->Receive(); net_packet; net_peer->DeallocatePacket(net_packet), net_packet = net_peer->Receive())
	{
		switch (net_packet->data[0])
		{
		case ID_REMOTE_DISCONNECTION_NOTIFICATION:
			std::cout << "Another client has disconnected" << std::endl;
			break;
		case ID_REMOTE_CONNECTION_LOST:
			std::cout << "Another client has lost the connection" << std::endl;
			break;
		case ID_REMOTE_NEW_INCOMING_CONNECTION:
			std::cout << "Another client has connected" << std::endl;
			break;
		//client连接上server后会触发
		case ID_CONNECTION_REQUEST_ACCEPTED:
			std::cout << "Our connection request has been accepted for server" << std::endl;
			server_address = net_packet->systemAddress;
			this->send_data_to_server();
			break;
		case ID_NEW_INCOMING_CONNECTION:
			std::cout << "A connection is incoming  " << std::endl;
			break;
		case ID_NO_FREE_INCOMING_CONNECTIONS:
			std::cout << "The server is full" << std::endl;
			break;
		case ID_DISCONNECTION_NOTIFICATION:
			std::cout << "A client has disconnected" << std::endl;
			break;
		case ID_CONNECTION_LOST:
			std::cout << "A client lost the connection  " << std::endl;
			break;
		case ID_USER_PACKET_ENUM:
			_process_server_message();				//用户自定义消息入口
			break;
		default:
			std::cout << "Message with identifier %d has arrived" << net_packet->data[0] << std::endl;
			break;
		}
	}
}

// server 发送过来的消息
void NetServerMgr::_process_server_message() const
{
	int message_id = 0;
	RakNet::BitStream bs_in(net_packet->data, net_packet->length, false);
	bs_in.IgnoreBytes(sizeof(RakNet::MessageID));
	bs_in.Read(message_id);

	unsigned char *msg_data = net_packet->data;
	msg_data += sizeof(unsigned long) + sizeof(unsigned char);
	switch (message_id)
	{
	case msg_connect_server_return:
		this->receive_data_from_server(msg_data);
		break;

	default:
		break;
	}
}

// 向 server 发送数据
void NetServerMgr::send_data_to_server() const
{
	connect_server send_data;
	memset(&send_data, 0, sizeof(connect_server));
	sprintf_s(send_data.content, "%s", "hello, this is client send to server");

	std::cout << "send to server data is : " << send_data.content << std::endl;

	RakNet::BitStream stream;
	stream.Write( ( RakNet::MessageID )ID_USER_PACKET_ENUM );
	stream.Write( msg_connect_server );
	stream.WriteBits((unsigned char *)&send_data , sizeof(connect_server) * 8 );
	net_peer->Send( &stream, HIGH_PRIORITY, RELIABLE_ORDERED, 0, server_address, false );
}

// 接收 server 回应的数据 并打印出来
void NetServerMgr::receive_data_from_server(const unsigned char *msg_data) const
{
	connect_server_return *receive_data = (connect_server_return *)msg_data;

	std::cout << "receive from server data is :" << receive_data->content_return << std::endl;
}

Main.cpp

#include "NetServerMgr.h"
#include <iostream>

int main()
{
	NetServerMgr *p = new NetServerMgr;

	p->init_net_work();

	while (true)
	{
		p->net_work_update();
	}
	
	delete p;
	p = NULL;

	return 0;
}

运行程序的时候，需要将RakNet_DLL_Debug_Win32.dll放到exe所在的目录下面。开启server，再开启client测试下：

由于server和client其实代码都差不过，注释就写了server的，感觉还是比较详细了，要是想深入了解，可以使用的时候直接查看里面的api文档。

发送数据的时候，先添加raknet的消息类型（就是ID_USER_PACKET_ENUM），再添加我们自定义的（这里是struct），最后添加实际数据。

接受的时候，要先偏移掉raknet的消息类型，这里其实一个char的大小，再偏移掉自定义的枚举消息类型，这里其实是整形，就可以获得实际的传输数据。发送的封包和解包是一个逆向的过程。