From:http://cn.cocos2d-x.org/tutorial/show?id=2193

---

Socket基类

包括Socket的初始化,主要是Windows上，在Android上就不需要了。

如果平台为Windows，则需要初始化

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

SocketBase::SocketBase() {      _bInitSuccess =  false ;      # if  (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)      WORD  wVersionRequested;      wVersionRequested = MAKEWORD(2, 0);      WSADATA wsaData;      int  nRet = WSAStartup(wVersionRequested, &wsaData);      if  (nRet != 0)       {          fprintf (stderr,  "Initilize Error!\n" );          return ;      }      _bInitSuccess =  true ;      #endif    }

当然析构时也要释放资源

1 2 3 4 5 6 7 8 9

SocketBase::~SocketBase()   {        # if  (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)        if  (_bInitSuccess)        {            WSACleanup();        }        #endif    }

因为Windows的socket()返回的socket句柄为SOCKET(UINT_PTR)与Android的socket()返回的socket句柄int, 类型不一样，所以都定义为HSocket。

对于服务端和客户端都有关闭连接，所以基类就实现共同的。

1 2 3 4 5 6 7 8

void  SocketBase::closeConnect(HSocket socket)   {        # if  (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)        close(socket);        #elif (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)        closesocket(socket);        #endif   }

当执行socket()出错时，Windows返回SOCKET_ERROR, Android返回<0，所以实现error()

1 2 3 4 5 6 7 8

bool  SocketBase::error(HSocket socket)   {        # if  (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)        return  socket == SOCKET_ERROR;        #elif (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)        return  socket < 0;        #endif   }

SocketBase.h

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

#ifndef __SOCKET_BASE_H__ #define __SOCKET_BASE_H__ #include "cocos2d.h" #include <list> #include <thread> USING_NS_CC; // 对于windows平台 #if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32) #include <WinSock2.h> #pragma comment(lib, "WS2_32.lib") #define HSocket SOCKET // 对于android平台 #elif (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID) #include <arpa/inet.h>   // for inet_** #include <netdb.h>   // for gethost** #include <netinet/in.h>  // for sockaddr_in #include <sys/types.h>   // for socket #include <sys/socket.h>  // for socket #include <unistd.h> #include <stdio.h>        // for printf #include <stdlib.h>  // for exit #include <string.h>  // for bzero #define HSocket int #endif     class  SocketBase :  public  Ref {      public :          SocketBase();          ~SocketBase();             protected :          void  closeConnect(HSocket socket);          bool  error(HSocket socket);             protected :          std::mutex _mutex;             private :          bool  _bInitSuccess; };    #endif

服务端

初始化服务端

向指定客户端发送消息

1	void  sendMessage(HSocket socket,  const  char * data,  int  count);

向所有客户端发送消息

1	void  sendMessage( const  char * data,  int  count);

当服务端开启后的回调函数

1	std::function< void ( const  char * ip)> onStart;

当有新连接时的回调函数

1	std::function< void (HSocket socket)> onNewConnection;

当有消息时的回调函数

1	std::function< void ( const  char * data,  int  count)> onRecv;

当有客户端断开连接时的回调函数

1	std::function< void (HSocket socket)> onDisconnect;

SocketServer.h

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

#ifndef __SOCKET_SERVER_H__ #define __SOCKET_SERVER_H__   #include "SocketBase.h"   class  SocketServer :  public  SocketBase {      public :      static  SocketServer* create();        SocketServer();      ~SocketServer();        bool  startServer();      void  sendMessage(HSocket socket,  const  char * data,  int  count);      void  sendMessage( const  char * data,  int  count);        std::function< void ( const  char * ip)> onStart;      std::function< void (HSocket socket)> onNewConnection;      std::function< void ( const  char * data,  int  count)> onRecv;      std::function< void (HSocket socket)> onDisconnect;        private :      bool  initServer();      void  acceptClient();      void  acceptFunc();      void  newClientConnected(HSocket socket);      void  recvMessage(HSocket socket);            private :      HSocket _socketServer;        private :      std::list<HSocket> _clientSockets;   };   #endif

SocketServer.cpp

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196

#include "SocketServer.h"   SocketServer* SocketServer::create() {      auto server =  new  SocketServer;        return  server; }   SocketServer::SocketServer() :      _socketServer(0),      onRecv(nullptr),      onStart(nullptr),      onNewConnection(nullptr) {   }   SocketServer::~SocketServer() {      _clientSockets.clear();        if  (_socketServer)      {          this ->closeConnect(_socketServer);      } };   bool  SocketServer::startServer() {      if  (!initServer())      {          return  false ;      }        return  true ; }   bool  SocketServer::initServer() {      if  (_socketServer != 0)      {          this ->closeConnect(_socketServer);      }      _socketServer = socket(AF_INET, SOCK_STREAM, 0);      if  (error(_socketServer))      {          log ( "socket error!" );          _socketServer = 0;          return  false ;      }      do       {          struct  sockaddr_in sockAddr;          memset (&sockAddr, 0,  sizeof (sockAddr));            sockAddr.sin_family = AF_INET;          sockAddr.sin_port = htons(8000);          sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);          int  ret = 0;          ret = bind(_socketServer, ( const  sockaddr*)&sockAddr,  sizeof (sockAddr));          if  (ret < 0)          {              log ( "bind error!" );              break ;          }                ret = listen(_socketServer, 5);          if  (ret < 0)          {              log ( "listen error!" );              break ;          }          // start           char  hostName[256];          gethostname(hostName,  sizeof (hostName));          struct  hostent* hostInfo = gethostbyname(hostName);          char * ip = inet_ntoa(*( struct  in_addr *)*hostInfo->h_addr_list);          this ->acceptClient();            if  (onStart != nullptr)          {              log ( "start server!" );              onStart(ip);          }            return  true ;        }  while  ( false );            this ->closeConnect(_socketServer);      _socketServer = 0;      return  false ; }   void  SocketServer::acceptClient() {      std:: thread  th(&SocketServer::acceptFunc,  this );      th.detach(); }   void  SocketServer::acceptFunc() {      int  len =  sizeof (sockaddr);      struct  sockaddr_in sockAddr;      while  ( true )      {            HSocket clientSock = accept(_socketServer, (sockaddr*)&sockAddr, &len);          if  (error(clientSock))          {              log ( "accept error!" );              break ;          }            this ->newClientConnected(clientSock);      } }   void  SocketServer::newClientConnected(HSocket socket) {      log ( "new connect!" );        _clientSockets.push_back(socket);      std:: thread  th(&SocketServer::recvMessage,  this , socket);      th.detach();        if  (onNewConnection != nullptr)      {          onNewConnection(socket);      } }   void  SocketServer::recvMessage(HSocket socket) {      char  buff[1024];      int  ret = 0;        while  ( true )      {          ret = recv(socket, buff,  sizeof (buff), 0);          if  (ret < 0)          {              log ( "recv(%d) error!" , socket);              _mutex.lock();              this ->closeConnect(socket);              _clientSockets. remove (socket);              if  (onDisconnect != nullptr)              {                  onDisconnect(socket);              }              _mutex.unlock();                break ;          }          else          {              buff[ret] = 0;              log ( "recv msg : %s" , buff);              if  (ret > 0 && onRecv != nullptr)              {                  onRecv(buff, ret);              }          }      } }   void  SocketServer::sendMessage(HSocket socket,  const  char * data,  int  count) {      for  (auto& sock : _clientSockets)      {          if  (sock == socket)          {              int  ret = send(socket, data, count, 0);              if  (ret < 0)              {                  log ( "send error!" );              }              break ;          }      }   }   void  SocketServer::sendMessage( const  char * data,  int  count) {      for  (auto& socket : _clientSockets)      {          int  ret = send(socket, data, count, 0);          if  (ret < 0)          {              log ( "send error!" );          }        }   }

客户端

连接服务端

1	bool  connectServer( const  char * serverIP, unsigned  short  port);

向服务端发送消息

1	void  sendMessage( const  char * data,  int  count);

接受服务端数据的回调函数

1	std::function< void ( const  char * data,  int  count)> onRecv;

断开连接的回调函数

1	std::function< void ()> onDisconnect;

SocketClient.h

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

#ifndef __SOCKET_CLIENT_H__ #define __SOCKET_CLIENT_H__ #include "SocketBase.h"   class  SocketClient :  public  SocketBase {      public :      SocketClient( void );      ~SocketClient( void );        bool  connectServer( const  char * serverIP, unsigned  short  port);      void  sendMessage( const  char * data,  int  count);        std::function< void ( const  char * data,  int  count)> onRecv;      std::function< void ()> onDisconnect;        private :      bool  initClient();      void  recvMessage();        private :      HSocket _socketServer;      HSocket _socektClient; };   #endif

SocketClient.cpp

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106

#include "SocketClient.h"     SocketClient::SocketClient( void ) :      onRecv(nullptr),      _socektClient(0) { }     SocketClient::~SocketClient( void ) {      if  (_socektClient != 0)      {          _mutex.lock();          this ->closeConnect(_socektClient);          _mutex.unlock();      } }   bool  SocketClient::initClient() {      if  (_socektClient != 0)      {          _mutex.lock();          this ->closeConnect(_socektClient);          _mutex.unlock();      }        _socektClient = socket(AF_INET, SOCK_STREAM, 0);      if  (error(_socketServer))      {          log ( "init client error!" );          _socektClient = 0;          return  false ;      }        return  true ; }   bool  SocketClient::connectServer( const  char * serverIP, unsigned  short  port) {      if  (! this ->initClient())      {          return  false ;      }        struct  sockaddr_in serverAddr;      memset (&serverAddr, 0,  sizeof ( struct  sockaddr_in));        serverAddr.sin_family = AF_INET;      serverAddr.sin_port = htons(port);      serverAddr.sin_addr.s_addr = inet_addr(serverIP);        int  ret = 0;      ret = connect(_socektClient, ( struct  sockaddr*)&serverAddr,  sizeof ( struct  sockaddr));      if  (ret < 0)      {          this ->closeConnect(_socektClient);          _socektClient = 0;          return  false ;      }        std:: thread  recvThread(&SocketClient::recvMessage,  this );      recvThread.detach();      return  true ; }   void  SocketClient::recvMessage() {      char  recvBuf[1024];      int  ret = 0;      while  ( true )      {          ret = recv(_socektClient, recvBuf,  sizeof (recvBuf), 0);          if  (ret < 0)          {              log ( "recv error" );              break ;          }          if  (ret > 0 && onRecv != nullptr)          {              onRecv(recvBuf, ret);          }      }      _mutex.lock();      this ->closeConnect(_socektClient);      if  (onDisconnect != nullptr)      {          onDisconnect();      }      _socektClient = 0;      _mutex.unlock(); }   void  SocketClient::sendMessage( const  char * data,  int  count) {      if  (_socektClient != 0)      {          int  ret = send(_socektClient, data, count, 0);          if  (ret < 0)          {              log ( "send error!" );          }      } }