一个使用超简单C++封装的网络库（包含服务器端和客户端，跨平台，比较适用于移动终端）

[yu505710025]

简介：

其实就只是对网络底层的一个封装，将一些回调全部都已经封装好，直接指定相应的回调函数就可以对收到的数据包进行处理。

个人觉得该网络库比较方便的地方就是可以直接将所有自定义及C++标准库容器直接发送到服务端，而原始的C函数发送时连续存储的内存。

注意，该库使用C11编译，所以客户端必须支持C11，废话不多说下面直接看使用demo。


服务器与客户端的相关协议定义（protocols.h）

#pragma once  
#include "protocolbase.h"  
  
  
//客户端请求登录  
class QLogin :public Net::ProtocolBase  
{  
public:  
    QLogin() = default;  
    ~QLogin() = default;  
  
    Serialize(QLogin)  
    {  
        ar(uClientId, strUsername, strPassword);  
    }  
  
    Net::UInt32 uClientId;  
    std::string strUsername;  
    std::string strPassword;  
};  
  
//客户端请求数据  
class QData :public Net::ProtocolBase  
{  
public:  
    QData() = default;  
    ~QData() = default;  
  
    Serialize(QData)  
    {  
  
    }  
};  
  
  
//响应客户端登录  
class RLogin :public Net::ProtocolBase  
{  
public:  
    RLogin() = default;  
    ~RLogin() = default;  
  
    Serialize(RLogin)  
    {  
        ar(strErrorInfo);  
    }  
  
    std::string strErrorInfo;  
};  
  
class CustomData  
{  
public:  
    CustomData() = default;  
    ~CustomData() = default;  
  
    Serialize(CustomData)  
    {  
        ar(nData, fData, dData, shData);  
    }  
  
    int nData;  
    float fData;  
    double dData;  
    short shData;  
};  
  
  
//响应客户端请求数据  
class RData :public Net::ProtocolBase  
{  
public:  
    RData() = default;  
    ~RData() = default;  
  
    Serialize(RData)  
    {  
        ar(strNickname, bSex, uAge, strEmail, vData, mData, customData);  
    }  
  
    std::string strNickname;  
    bool bSex;  
    Net::UInt8 uAge;  
    std::string strEmail;  
    std::vector<std::string> vData;  
    std::map<std::string,std::pair<int,float> > mData;  
    CustomData customData;  
};  




服务端代码(server.cpp)
#include "socketserver.h"  
#include "socketclient.h"  
  
#include "protocols.h"  
  
#include <iostream>  
  
  
class ServerSocketSession :public Net::SocketSession  
{  
public:  
    ServerSocketSession() = default;  
    ~ServerSocketSession()  
    {  
          
    }  
    ServerSocketSession(const ServerSocketSession&) = delete;  
    ServerSocketSession& operator = (const ServerSocketSession&) = delete;  
  
    //响应用户登录  
    void userLogin(std::shared_ptr<QLogin> r)  
    {  
        auto result = std::make_shared<RLogin>();  
        if (r->uClientId == 123456 &&   
            r->strUsername == "123456" &&  
            r->strPassword == "123456")  
        {  
            result->strErrorInfo = "LoginSucceed";  
        }  
        else  
        {  
            result->strErrorInfo = "LoginFailure";     
        }  
        send(result);  
    }  
  
    //响应用户请求详细数据  
    void userData(std::shared_ptr<QData> r)  
    {  
        auto result = std::make_shared<RData>();  
  
        result->strNickname = "winter";  
        result->bSex = true;  
        result->strEmail = "[e-mail]";  
        result->uAge = 100;  
        result->mData.emplace("m1",std::make_pair(1111,111.111f));  
        result->mData.emplace("m2", std::make_pair(2222, 222.222f));  
        result->mData.emplace("m3", std::make_pair(3333, 333.333f));  
  
        result->vData.push_back("v1");  
        result->vData.push_back("v2");  
        result->vData.push_back("v3");  
        result->vData.push_back("v4");  
  
        result->customData.dData = -10000000.000001f;  
        result->customData.fData = 100000.00002f;  
        result->customData.nData = -100000;  
        result->customData.shData = -100;  
        send(result);  
    }  
};  

客户端代码(client.cpp)
#include "socketserver.h"  
#include "socketclient.h"  
  
  
#include "protocols.h"  
  
  
#include <iostream>  
class ClientSocketSession  
{  
public:  
    ClientSocketSession()  
    :m_socketClient("127.0.0.1", 6691, true)  
    {  
        m_socketClient.registerProtocol(&ClientSocketSession::onUserLogin, this);  
        m_socketClient.registerProtocol(&ClientSocketSession::onUserData, this);  
        m_socketClient.registerProtocol(&ClientSocketSession::onSocketEvent, this);  
  
  
        m_socketClient.connect();  
    }  
  
  
    ~ClientSocketSession() = default;  
    ClientSocketSession(const ClientSocketSession&) = delete;  
    ClientSocketSession& operator = (const ClientSocketSession&) = delete;  
  
    void update(){ m_socketClient.update(); }  
  
    void onSocketEvent(std::shared_ptr<Net::SocketEvent> r, Net::SocketClient::ErrorCode e)  
    {  
        if (e == Net::SocketClient::ErrorCode::kSucceed && r->getEvent() == Net::SocketEvent::Event::kConnect)  
        {  
            std::cout << "Connect succeed! " << r->getInfo() << std::endl;  
  
            auto qlogin = std::make_shared<QLogin>();  
            qlogin->uClientId = 11111;  
            qlogin->strUsername = "11111";  
            qlogin->strPassword = "11111";  
            m_socketClient.send(qlogin);  
        }  
        else  
        {  
            if (r->getEvent() == Net::SocketEvent::Event::kConnect)  
            {  
                std::cout << "Connect: "<< r->getInfo() << std::endl;  
            }  
            else  
            {  
                std::cout << "DisConnect: " << r->getInfo() << std::endl;  
            }  
              
        }  
    }  
  
  
    void onUserLogin(std::shared_ptr<RLogin> r, Net::SocketClient::ErrorCode e)  
    {  
        if (r->strErrorInfo == "LoginSucceed")  
        {  
            auto qdata = std::make_shared<QData>();  
            for (size_t i = 0; i < 10; i++)  
            {  
                m_socketClient.send(qdata);  
            }     
        }  
        else if (r->strErrorInfo == "LoginFailure")  
        {  
            auto qlogin = std::make_shared<QLogin>();  
            qlogin->uClientId = 123456;  
            qlogin->strUsername = "123456";  
            qlogin->strPassword = "123456";  
            m_socketClient.send(qlogin);  
        }  
          
    }  
  
    void onUserData(std::shared_ptr<RData> r, Net::SocketClient::ErrorCode e)  
    {  
        std::cout << "Nickname: " << r->strNickname << std::endl;  
        std::cout << "Sex: " << (r->bSex ? "true": "false") << std::endl;  
        std::cout << "Age: " << (int)r->uAge << std::endl;  
        std::cout << "Email: " << r->strEmail << std::endl;  
          
        for (auto data : r->vData)  
        {  
            std::cout << "vData: " << data << std::endl;  
        }  
          
        for (auto data : r->mData)  
        {  
            std::cout << "vData:" << data.first << ":" << data.second.first << ":" << data.second.second << std::endl;  
        }  
  
  
        std::cout << "customData.nData: " << r->customData.nData << std::endl;   
        std::cout << "customData.fData: " << r->customData.fData << std::endl;  
        std::cout << "customData.dData: " << r->customData.dData << std::endl;  
        std::cout << "customData.shData: " << r->customData.shData << std::endl;  
    }  
  
private:  
  
    Net::SocketClient m_socketClient;  
};  

下面是调用代码
auto server = Net::SocketServer::createInstance<ServerSocketSession>("127.0.0.1", 6691, 1,true);  
server->registerProtocol(&ServerSocketSession::userLogin);  
server->registerProtocol(&ServerSocketSession::userData);  
  
ClientSocketSession clientSession;  
  
  
//一个简单的主循环  
bool bExit(true); 
while (bExit)  
{  
    std::this_thread::sleep_for(std::chrono::milliseconds(50));  
  
    //在客户端的每一帧需要调用以下函数。  
    clientSession.update();  
}  
  
  
return 0;  

http://download.csdn.net/download/yu505710025/8944083 这里是完整demo。

[jiqiang01234]

模拟google protocol buffer?

[yu505710025]

google protocol buffer 只是一个序列化库，且不支持C++标准库容器的。这个支持任何自定义数据结构。

[jiqiang01234]

模拟boost::serialization库？

[yu505710025]

引用 3 楼 jiqiang01234 的回复:

模拟boost::serialization库？

cereal-1.1.2 跟boost::serialization原理差不多，只不过是轻量级的。