Socket的综合应用总结

Socket 的传输的内容大概分3种：

封装的结构体：结构体(结构清晰，发送数据占用内存小)，例如

struct SOCKETDATA

{

DWORD password;        //每个客户端都有一个密码，为了防止外挂

DWORD messageId;        //发送内容的ID标识，每种ID对应着消息的一种操作

DWORD nowParkId;        //连续的ID号，防止丢包，和重复的发同样的包的操作

Char* buffer;            //内容

}此处也是对内容的简单的描述，真正的结构体可能更加复杂
char*(显而易见的，支持指令),例如

发送的字符串为"23,张三,10000",这样的内容的弊病在于很容易别解析，安全性低
超文本(支持脚本，类似xml，内存使用增加).可以结合1来综合运用，思路是很好的。

收发机制：封包，粘包。Send SendList, recv RecvList

向服务器一直发送数据的话，发送的内容不平均，有时内容较大，有时内容较小，一直连接对链路的负载也较大，所以我们在固定的时间间隔下发送数据，把要发送的数据存在一个链表中，集体发送，这样大大提高性能，发送的时间间隔根据游戏的情况而定，魔兽争霸为100ms，魔兽世界为200ms。

线程管理：

1、确保主线程不死

2、一段时间间隔看子线程是否死亡

3、Socket类封装:

ServerSocket

ClientSocket

NetCom (消息底层，可用socket或是DirectPlay等等)

NetMessage(消息宏和结构体)

NetManager(消息处理)

4、Socket安全

5、Socket其他功能:连包，粘包

时间问题：加时间戳，逻辑不通过时间判断

总结 Socket服务器端的设计：

服务器还是利用Socket的完成端口来实现，首先创建服务器的Socket。

然后创建Accept线程，当有客户端accept时，加入到客户端列表中，然后异步调用WSARecv。

根据cpu个数创建接受数据的线程，接收的数据存储到链表中。

处理接受到的数据时用一个单独的线程遍历其中的内容，用信号量控制。

#define MAXMESSAGESIZE 1024

enum SOCKETOPERATE

{

    soRECV

};

struct SOCKETDATA

{

   WSAOVERLAPPED        overlap;                    //重叠结构，用于异步请求的IO控制

    WSABUF                Buffer;                        //缓存，用于异步请求数据的保存

    char                sMessage[MAXMESSAGESIZE];    //真正的缓存

    DWORD                dwBytes;                    //异步请求发生时，产生的字节流量

    DWORD                Flages;

    SOCKETOPERATE        OperationType;                //异步请求的操作类型

    void Clear(SOCKETOPERATE SO)

    {

        ZeroMemory(this, sizeof(SOCKETDATA));

        Buffer.len = MAXMESSAGESIZE;

        Buffer.buf = sMessage;

        OperationType = SO;

    }

};

struct CClientPeer

{

    SOCKET    ClientSocket;

    DWORD    ID;

    DWORD    PassWord;

    DWORD    NowPackID;

    DWORD    dwIP;

    u_short    Port;

    CEasyList *gClientRecv;

    void InitList()

    {

        gClientRecv = new CEasyList;

    }

};

class CServerSocket

{

public:

    CServerSocket(void);

    ~CServerSocket(void);

    bool Create(u_short Port);

    int SendBuffer(int ClientID, void* Buffer, int Size);

    int BroadCastBuff(void* Buffer, int Size);            //广播

public:

    SOCKET        mSocket;

    CEasyList    mClients;

    HANDLE        mCP;

    u_short        mPort;

};

SOCKET CreateServerSocket(int Port);

DWORD WINAPI SocketProcMain(LPVOID lpParam);        //Socket主线程函数，负责处理IO请求

DWORD WINAPI SocketProcAccept(LPVOID lpParam);        //Socket线程函数，负责处理线程链接

CServerSocket::CServerSocket(void)

{

    WSADATA        wsaData;

    WSAStartup(0x0202,&wsaData);

    mSocket=INVALID_SOCKET;

    mCP = INVALID_HANDLE_VALUE;

}

CServerSocket::~CServerSocket(void)

{

    closesocket(mSocket);

    WSACleanup();

}

SOCKET CreateServerSocket(int Port)

{

    int iErrCode;

    WSADATA wsaData;

    iErrCode = WSAStartup(0x0202, &wsaData);

    int iRes;

    SOCKET tempSocket = socket(AF_INET, SOCK_STREAM, );

    SOCKADDR_IN addr;

    addr.sin_family = AF_INET;

    addr.sin_port = htons(Port);

    addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    iRes = bind(tempSocket,(LPSOCKADDR)&addr,sizeof(addr));

    if(iRes == SOCKET_ERROR)

    {

        closesocket(tempSocket);

        return INVALID_SOCKET;

    }

    iRes = listen(tempSocket, );

    if(iRes == SOCKET_ERROR)

    {

        closesocket(tempSocket);

        return INVALID_SOCKET;

    }

    return tempSocket;

}

bool CServerSocket::Create( u_short Port )

{

    mSocket = CreateServerSocket(Port);

    if (mSocket == INVALID_SOCKET)

    {

        return false;

    }

    mPort = Port;

    mCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, , );

    SYSTEM_INFO systemInfo;

    GetSystemInfo(&systemInfo);

    for (int i = ; i<systemInfo.dwNumberOfProcessors;i++)

    {

        CreateThread(NULL, NULL, SocketProcMain, this, NULL, NULL);

    }

    CreateThread(NULL, NULL, SocketProcAccept, this, NULL, NULL);

    Sleep();

    return true;

}

DWORD WINAPI SocketProcMain(LPVOID lpParam)

{

    HANDLE CP = ((CServerSocket*)lpParam)->mCP;

    SOCKET serverSocket = ((CServerSocket*)lpParam)->mSocket;

    DWORD dwBytes;

    SOCKETDATA *lpSocketData = NULL;

    while ()

    {

        //等待全局完成端口的玩曾队列

        CClientPeer *pClient=NULL;

        GetQueuedCompletionStatus(CP, &dwBytes, (PULONG_PTR)&pClient, (LPOVERLAPPED*)&lpSocketData, INFINITE);

        if(dwBytes == 0xffffffff)

        {

            return ;

        }

        //当数据类型为soRECV时，

        if(lpSocketData->OperationType == soRECV)

        {

            //当客端关闭连接时

            if(dwBytes == )

            {

                closesocket(serverSocket);

                HeapFree(GetProcessHeap(), , lpSocketData);

            }

            else

            {

                char* s = new char[dwBytes+];

                strcpy(s, lpSocketData->sMessage);

                pClient->gClientRecv->Add(s);

                /*printf("Server:%d Client:%d \t:%s\n", ((CServerSocket*)lpParam)->mPort,

                    pClient->dwIP/0x1000000,

                    lpSocketData->sMessage);*/

                //重置Socket数据为soRECV

                lpSocketData->Clear(soRECV);

                WSARecv(pClient->ClientSocket, &lpSocketData->Buffer, , &lpSocketData->dwBytes, &lpSocketData->Flages, &lpSocketData->overlap, NULL);

            }

        }

    }

}

DWORD WINAPI SocketProcAccept(LPVOID lpParam)

{

    SOCKET tmp;

    SOCKADDR_IN tempAddr;

    int dwAddrSize = sizeof(tempAddr);

    HANDLE CP = ((CServerSocket*)lpParam)->mCP;

    SOCKET serverSocket = ((CServerSocket*)lpParam)->mSocket;

    SOCKETDATA *lpSocketData;

    while()

    {

        tmp = accept(serverSocket, (sockaddr*)&tempAddr, &dwAddrSize);

        CClientPeer *pClient = NULL;

        pClient = (CClientPeer*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CClientPeer));

        pClient->InitList();

        pClient->ClientSocket = tmp;

        pClient->dwIP = tempAddr.sin_addr.s_addr;

        pClient->Port = tempAddr.sin_port;

        ((CServerSocket*)lpParam)->mClients.Add(pClient);

        //创建客户端Socket和全局完成端口的链接

        CreateIoCompletionPort((HANDLE)tmp, CP, (DWORD)pClient, );

        //在主线程堆中开辟，Socket缓存数据

        lpSocketData = (SOCKETDATA *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SOCKETDATA));

        //将此数据初始化为soRecv

        lpSocketData->Clear(soRECV);

        //异步调用WSARecv，其中第二个参数是I/O请求成功时，数据保存的地址。

        WSARecv(tmp, &lpSocketData->Buffer, , &lpSocketData->dwBytes, &lpSocketData->Flages, &lpSocketData->overlap, NULL);

    }

}

class CNetManager

{

public:

    CNetManager(void);

    ~CNetManager(void);

    bool CreateServer();

private:

    CServerSocket mServerSocket;

};

DWORD WINAPI RecvProc(LPVOID pParam);

bool CNetManager::CreateServer()

{

    mServerSocket.Create();

    CreateThread(NULL, NULL, RecvProc, &mServerSocket, NULL, NULL);

    return ;

}

DWORD WINAPI RecvProc( LPVOID pParam )

{

    if(pParam == NULL)

    {

        return ;

    }

    CServerSocket *pServer = (CServerSocket*)pParam;

    CClientPeer *pClient;

    while()

    {

        for (int i=; i<pServer->mClients.Count();i++)

        {

            pClient = (CClientPeer*)pServer->mClients.Get(i);

            if (pClient)

            {

                for (int j=; j<pClient->gClientRecv->Count();j++)

                {

                    char* s = (char*)pClient->gClientRecv->Get(j);

                    printf("%x \t (%d) %s \n",pClient->dwIP,j,s);

                    delete s;

                }

                pClient->gClientRecv->Clear();

            }

        }

    }

}

秒客网

Socket的综合应用总结

相关文章