Cocos2dx-lua中使用LuaSocket

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› LUA›LUA教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

项目背景

客户端：C++和lua混合，cocos2dx 3.10版本；服务端：C++，某狐公司的棋牌服务端。

需求

　　手机客户端使用socket与服务端通信，需要处理数据粘包半包、字符串编码转换、心跳机制、接收超时这几个主要的问题，另外使用luasocket需要考虑数据传输格式的问题。检索网上的资料，基于LuaSocket针对项目需求做了一定的调整，使用了该文中提到的ByteArray和lpack库实现了lua使用二进制数据和服务器通信，并在C++端利用iconv库实现了字符串编码格式的转换，达到了项目的需求。下面具体谈谈如何解决上述提到的几个问题。

1、lua中发送与接收二进制数据

　　这里直接使用了ByteArray，不过后来又提到该实现中与Long相关的实现存在并非bug的问题，而是由于跨平台导致的处理不一致而导致的问题，但是在我们的项目中直接使用且在pc模拟器，多品牌、多处理器平台、多安卓版本的安卓机型上，多ios版本、5s、6、7、x的苹果机型上，并没有出现问题，所以我还是继续使用了这个库来进行长整型数据的读取。在这个库的基础上，我额外加上了字符串的读写转换，这个是在C++端利用iconv库实现的，之前有试过lua版本的iconv库，可能是使用方式不对，达不到需求。

转换成宽字符的部分代码：

 6             iconv_t cd = iconv_open("UTF-16LE", "UTF-8");
 7             if (0 != cd)
 8             {
 9                 char *tmp = (char*)szTmp;
10             #ifdef WIN32
11                 if (iconv(cd, &szData, &inlen, &tmp, &outlen) != (size_t) -1 )
12             #else
13                 char *szTempData = (char*)szData;
14                 if (iconv(cd, &szTempData, &inlen, &tmp, &outlen) != (size_t) -1 )
15             #endif                
16                 {
17                     iconv_close(cd);
18                     lua_pushlstring(tolua_S, (char*)szTmp, returnlen);
19                     free(szTmp);
20                     return 1;
21                 }
22                 iconv_close(cd);
23             }

宽字符转换回的部分代码：

            iconv_t cd = iconv_open("UTF-16LE", "UTF-8");
            if (0 != cd)
            {
                char *tmp = (char*)szTmp;
            #ifdef WIN32
                iconv(cd, &szData, &inlen, &tmp, &outlen);
            #else
                char *szTempData = (char*)szData;
                iconv(cd, &szTempData, &inlen, &tmp, &outlen);
            #endif                
                iconv_close(cd);
                lua_pushlstring(tolua_S, (char*)szTmp, returnlen);
                free(szTmp);
                return 1;
            }

　　这里需要注意的是，调用 iconv()进行转换的时候输入、输出的长度一定要计算好，否则会导致内存读取异常，导致闪退！处理好了与服务端通信数据格式的问题，之后就是在lua中实现socket与服务端通信。

2、接收超时

　　这里提到的接收超时是这样的：socket处于连接状态，但是长时间无法读取到数据。前面提到的SocketTCP封装利用引擎提供的schedule和quick提供的事件框架实现了各种状态的轮询如连接超时的检测、数据接收处理，我主要的调整是根据select函数返回的结果，处理接收超时的状态

 1     local __tick = function()
 2         while true do
 3             local recvt = socket.select({self.tcp}, nil, 0)
 4             -- print("recvt ", #recvt)
 5             if #recvt > 0 then
 6                 -- if use "*l" pattern, some buffer will be discarded, why?
 7                 local __body, __status, __partial = self.tcp:receive("*a")    -- read the package body
 8                 --print("body:", __body, "__status:", __status, "__partial:", __partial)
 9                 if __status == STATUS_CLOSED or __status == STATUS_NOT_CONNECTED then
10                     self:close()
11                     if self.isConnected then
12                         self:_onDisconnect()
13                     else
14                         self:_connectFailure()
15                     end
16                     -- 跳出循环
17                        return
18                 end
19 
20                 -- 数据状态
21                 if (__body and string.len(__body) == 0) 
22                     or (__partial and string.len(__partial) == 0) then 
23                     -- 这里处理接收失败，如服务器踢
24                     -- 跳出循环
25                     return 
26                 end
27                 if __body and __partial then 
28                     __body = __body .. __partial 
29                 end
30                 -- 这里接收到数据包
31             else
32                 -- 这里抛出超时状态
33                 -- 跳出循环
34                 return
35             end
36         end
37     end
38     -- start to read TCP data
39     self.tickScheduler = scheduler.scheduleGlobal(__tick, SOCKET_TICK_TIME)

3、数据粘包

　　前面有提到使用ByteArray实现与服务端进行二进制数据通信，在这里继续使用ByteArray解决半包和粘包的问题。解决数据粘包半包的问题，首先是跟服务端约定好消息协议：数据包包头里面包含当前数据包长度；其次是将每次接收到的数据流填充到一个bytearray对象中，对比接收到的数据长度和数据包实际长度，从填充的bytearray中提取指定长度的数据。

　　前面也提到，封装好的SocketTCP利用了schedule和quick事件组件实现了事件轮询。每次接收到数据包状态，将数据包填充到bytearray对象，再判断是否获取到一个完整的数据包：

 1 stream:addData(msg)
 2 while self.status ~= STATUS_SOCKET_CLOSED do
 3     local msgPack, bHeatResponse, bHandleEnd = stream:getMsg()
 4     if bHeatResponse then
 5         -- 记录时间
 6         self.lastTime = os.time()
 7         -- 心跳回复
 8         -- ...
 9         break
10     else
11         if msgPack == nil then
12             break
13         end
14         -- 记录时间
15         self.lastTime = os.time()
17         -- 分发数据
19         -- 是否处理完数据包
20         if bHandleEnd then
21             break
22         end
23     end
24 end

　　addData是将数据包填充至ByteArray对象，getOneMsg是获取一个完整的数据包。这里使用了一个while循环，用于提取所有的数据包。

　　getMsg方法里面的实现主要是读取ByteArray数据，对比包长度，处理消息协议，解包数据。半包和粘包的问题，重点是要控制好ByteArray对象的数据位，半包的时候要将数据位置为末尾位置，以便下一个数据包填充至正确的问题，粘包的话控制好当前包的读取长度。半包和粘包处理好之后，清空ByteArray对象的缓存，再重置该对象的数据位，等待重新读取数据。

4、心跳机制

　　心跳机制结合前面提到的接收超时检测，每一次接收到心跳包、数据包的时候，记录一下接收时间，然后再在SocketTCP抛出的超时状态中进行超时时长检测，根据接收时长的间隔来判断客户端当前是否是接收超时，再做后续的逻辑处理。

总结

　　大概花了一周的时间在项目中实现luasocket与服务端的通信，难点在于如何实现二进制流通信、半包粘包的问题、接收状态的超时处理。