pomelo client for server [pomelo 客户端模块化]

雨点打透心脏的1/2处 2022-08-24 00:59 389阅读 0赞

在学习pomelo时，遇到一个需求是，没有视图层要与pomelo服务端通讯，具个人所了解到的pomelo客户端与服务端联接通讯是需要在视图层创建var pomelo = window.pomelo; 能才与pomelo服务端通讯的。而在网上也没有找到相关的模块，东找西拼地于是就有了下面的东西，免强能实现所需啊。

**以下是：package.json 文件内容**

\{  
    "name": "PomeloClientForServer",  
    "version": "0.1.0",  
    "main": "index.js",  
    "private": false,  
    "description": "A Pomelo js clinent for server pomelo服务的客户端",  
    "author": \{  
     "name": "merikey8@126.com",  
     "name":" guhaizhou@126.com"  
    \}  
    "dependencies": \{  
       "pomelo-protobuf": "0.3.5",  
       "pomelo-protocol": "0.1.0",  
       "ws": "0.4.25"  
     \},  
    "keywords": \[  
    "pomelo client",  
    "pomeloClient"  
  \],  
\}

－－－－－－－－－－－－－－－－－－－－－－－－－－可以加我微信号：googlecao 进行交流－－－－－－－－－－－－－－－－－－－－－－－－－－－

**/lib/clientforserver.js**

var JS\_WS\_CLIENT\_TYPE = 'js-websocket';  
var JS\_WS\_CLIENT\_VERSION = '0.0.1';  
  
var RES\_OK = 200;  
var RES\_OLD\_CLIENT = 501;  
  
var pomelo = Object.create(EventEmitter.prototype); // object extend from object  
var socket = null;  
var reqId = 0;  
var callbacks = \{\};  
var handlers = \{\};  
var routeMap = \{\};  
  
var heartbeatInterval = 5000;  
var heartbeatTimeout = heartbeatInterval \* 2;  
var nextHeartbeatTimeout = 0;  
var gapThreshold = 100; // heartbeat gap threshold  
var heartbeatId = null;  
var heartbeatTimeoutId = null;  
var handshakeCallback = null;  
  
var handshakeBuffer = \{  
  'sys':\{  
    type: JS\_WS\_CLIENT\_TYPE,  
    version: JS\_WS\_CLIENT\_VERSION  
  \},  
  'user':\{  
  \}  
\};  
var initCallback = null;  
pomelo.init = function(params, cb)\{  
  pomelo.params = params;  
  params.debug = true;  
  initCallback = cb;  
  var host = params.host;  
  var port = params.port;  
  
  var url = 'ws://' + host;  
  if(port) \{  
    url +=  ':' + port;  
  \}  
  
  if (!params.type) \{  
    console.log('init websocket');  
    handshakeBuffer.user = params.user;  
    handshakeCallback = params.handshakeCallback;  
    pomelo.initWebSocket(url,cb);  
  \}  
\};  
  
pomelo.initWebSocket = function(url,cb)\{  
  console.log("====="+url);  
  var onopen = function(event)\{  
console.log("===1==");  
    console.log('\[pomeloclient.init\] websocket connected!');  
    var obj = Package.encode(Package.TYPE\_HANDSHAKE, Protocol.strencode(JSON.stringify(handshakeBuffer)));  
    send(obj);  
  \};  
  var onmessage = function(event) \{  
 console.log("===2==");  
    processPackage(Package.decode(event.data), cb);  
    // new package arrived, update the heartbeat timeout  
    if(heartbeatTimeout) \{  
      nextHeartbeatTimeout = Date.now() + heartbeatTimeout;  
    \}  
  \};  
  var onerror = function(event) \{  
 console.log("===3=="+event);  
    pomelo.emit('io-error', event);  
    console.log('socket error %j ',event);  
  \};  
  var onclose = function(event)\{  
 console.log("===4==");  
    pomelo.emit('close',event);  
    console.log('socket close %j ',event);  
  \};  
  socket = new WebSocket(url);  
  socket.binaryType = 'arraybuffer';  
  socket.onopen = onopen;  
  socket.onmessage = onmessage;  
  socket.onerror = onerror;  
  socket.onclose = onclose;  
  console.log("===5==");  
\};

pomelo.disconnect = function() \{  
  if(socket) \{  
    if(socket.disconnect) socket.disconnect();  
    if(socket.close) socket.close();  
    console.log('disconnect');  
    socket = null;  
  \}  
  
  if(heartbeatId) \{  
    clearTimeout(heartbeatId);  
    heartbeatId = null;  
  \}  
  if(heartbeatTimeoutId) \{  
    clearTimeout(heartbeatTimeoutId);  
    heartbeatTimeoutId = null;  
  \}  
\};  
  
pomelo.request = function(route, msg, cb) \{  
  msg = msg || \{\};  
  route = route || msg.route;  
  if(!route) \{  
    console.log('fail to send request without route.');  
    return;  
  \}  
  reqId++;  
  sendMessage(reqId, route, msg);  
  callbacks\[reqId\] = cb;  
  routeMap\[reqId\] = route;  
\};  
  
pomelo.notify = function(route, msg) \{  
  msg = msg || \{\};  
  sendMessage(0, route, msg);  
\};  
  
var sendMessage = function(reqId, route, msg) \{  
  var type = reqId ? Message.TYPE\_REQUEST : Message.TYPE\_NOTIFY;  
  //compress message by protobuf  
  var protos = !!pomelo.data.protos?pomelo.data.protos.client:\{\};  
  if(!!protos\[route\])\{  
    msg = protobuf.encode(route, msg);  
  \}else\{  
    msg = Protocol.strencode(JSON.stringify(msg));  
  \}  
  
  var compressRoute = 0;  
  if(pomelo.dict && pomelo.dict\[route\])\{  
    route = pomelo.dict\[route\];  
    compressRoute = 1;  
  \}  
  msg = Message.encode(reqId, type, compressRoute, route, msg);  
  var packet = Package.encode(Package.TYPE\_DATA, msg);  
  send(packet);  
\};  
  
var \_host = "";  
var \_port = "";  
var \_token = "";  
/\*  
var send = function(packet)\{  
   if (!!socket) \{  
    socket.send(packet.buffer || packet,\{binary: true, mask: true\});  
   \} else \{  
    setTimeout(function() \{  
      entry(\_host, \_port, \_token, function() \{console.log('Socket is null. ReEntry!')\});  
    \}, 3000);  
   \}  
\};  
\*/  
  
var send = function(packet)\{  
  if (!!socket) \{  
    socket.send(packet.buffer || packet, \{binary: true, mask: true\});  
  \}  
\};  
var handler = \{\};  
var heartbeat = function(data) \{  
  var obj = Package.encode(Package.TYPE\_HEARTBEAT);  
  if(heartbeatTimeoutId) \{  
    clearTimeout(heartbeatTimeoutId);  
    heartbeatTimeoutId = null;  
  \}  
  
  if(heartbeatId) \{  
    // already in a heartbeat interval  
    return;  
  \}  
  heartbeatId = setTimeout(function() \{  
    heartbeatId = null;  
    send(obj);  
    nextHeartbeatTimeout = Date.now() + heartbeatTimeout;  
    heartbeatTimeoutId = setTimeout(heartbeatTimeoutCb, heartbeatTimeout);  
  \}, heartbeatInterval);  
\};  
  
var heartbeatTimeoutCb = function() \{  
  var gap = nextHeartbeatTimeout - Date.now();  
  if(gap > gapThreshold) \{  
    heartbeatTimeoutId = setTimeout(heartbeatTimeoutCb, gap);  
  \} else \{  
    console.error('server heartbeat timeout');  
    pomelo.emit('heartbeat timeout');  
    pomelo.disconnect();  
  \}  
\};  
  
var handshake = function(data)\{  
  data = JSON.parse(Protocol.strdecode(data));  
  if(data.code === RES\_OLD\_CLIENT) \{  
    pomelo.emit('error', 'client version not fullfill');  
    return;  
  \}  
  
  if(data.code !== RES\_OK) \{  
    pomelo.emit('error', 'handshake fail');  
    return;  
  \}  
  handshakeInit(data);  
  var obj = Package.encode(Package.TYPE\_HANDSHAKE\_ACK);  
  send(obj);  
  if(initCallback) \{  
    initCallback(socket);  
    initCallback = null;  
  \}  
\};  
var onData = function(data)\{  
  //probuff decode  
  var msg = Message.decode(data);  
  if(msg.id > 0)\{  
    msg.route = routeMap\[msg.id\];  
    delete routeMap\[msg.id\];  
    if(!msg.route)\{  
      return;  
    \}  
  \}  
  msg.body = deCompose(msg);  
  processMessage(pomelo, msg);  
\};  
  
var onKick = function(data) \{  
  pomelo.emit('onKick');  
\};

handlers\[Package.TYPE\_HANDSHAKE\] = handshake;  
handlers\[Package.TYPE\_HEARTBEAT\] = heartbeat;  
handlers\[Package.TYPE\_DATA\] = onData;  
handlers\[Package.TYPE\_KICK\] = onKick;  
var processPackage = function(msg)\{  
  handlers\[msg.type\](msg.body);  
\};  
  
var processMessage = function(pomelo, msg) \{  
  if(!msg || !msg.id) \{  
    // server push message  
    // console.error('processMessage error!!!');  
    pomelo.emit(msg.route, msg.body);  
    return;  
  \}  
  //if have a id then find the callback function with the request  
  var cb = callbacks\[msg.id\];  
  delete callbacks\[msg.id\];  
  if(typeof cb !== 'function') \{  
    return;  
  \}  
  cb(msg.body);  
  return;  
\};  
  
var processMessageBatch = function(pomelo, msgs) \{  
  for(var i=0, l=msgs.length; i<l; i++) \{  
    processMessage(pomelo, msgs\[i\]);  
  \}  
\};  
  
var deCompose = function(msg)\{  
  var protos = !!pomelo.data.protos ? pomelo.data.protos.server : \{\};  
  var abbrs = pomelo.data.abbrs;  
  var route = msg.route;  
  try \{  
    //Decompose route from dict  
    if(msg.compressRoute) \{  
      if(!abbrs\[route\])\{  
        console.error('illegal msg!');  
        return \{\};  
      \}  
      route = msg.route = abbrs\[route\];  
    \}  
    if(!!protos\[route\])\{  
      return protobuf.decode(route, msg.body);  
    \}else\{  
      return JSON.parse(Protocol.strdecode(msg.body));  
    \}  
  \} catch(ex) \{  
    console.error('route, body = ' + route + ", " + msg.body);  
  \}  
  return msg;  
\};  
  
var handshakeInit = function(data)\{  
  if(data.sys && data.sys.heartbeat) \{  
    heartbeatInterval = data.sys.heartbeat \* 1000;   // heartbeat interval  
    heartbeatTimeout = heartbeatInterval \* 2;        // max heartbeat timeout  
  \} else \{  
    heartbeatInterval = 0;  
    heartbeatTimeout = 0;  
  \}  
  initData(data);  
  if(typeof handshakeCallback === 'function') \{  
    handshakeCallback(data.user);  
  \}  
\};  
  
//Initilize data used in pomelo client  
var initData = function(data) \{  
  if(!data || !data.sys) \{  
    return;  
  \}  
  pomelo.data = pomelo.data || \{\};  
  var dict = data.sys.dict;  
  var protos = data.sys.protos;  
  //Init compress dict  
  if(!!dict)\{  
    pomelo.data.dict = dict;  
    pomelo.data.abbrs = \{\};  
    for(var route in dict)\{  
      pomelo.data.abbrs\[dict\[route\]\] = route;  
    \}  
  \}  
  
  //Init protobuf protos  
  if(!!protos)\{  
    pomelo.data.protos = \{  
      server : protos.server || \{\},  
      client : protos.client || \{\}  
    \};  
    if(!!protobuf)\{  
      protobuf.init(\{encoderProtos: protos.client, decoderProtos: protos.server\});  
    \}  
  \}  
\};  
  
module.exports = pomelo;

**使用前准备**

1、手动建一个目录pomeloclient

2、建一个lib目录

3、将package.json的内容保存成package.json文件

4、命令执行 cd pomeloclient

5、命令执行npm install  安装完所依赖的模块

6、将下面的clientforserver.js文件内容放在lib目录下

**调用方式test.js   注意先开启一个pomelo的game-server**

var pomeloClient = require('./lib/clientforserver');

//显示对象方法  
console.log(pomeloClient);  
/\*pomeloClient  
init: \[Function\], 初始化联接  
initWebSocket: \[Function\],初始化联接  
disconnect: \[Function\],关闭联接  
request: \[Function\],请求服务 有回复  
notify: \[Function\] \}通知服务 无回复  
\*/  
  
var params =\{  
host:"127.0.0.1",   
port: 3010,   
log: true  
\};  
  
  
//初始化对像  
pomeloClient.init(params,function(err)\{  
console.log(err.\_events.open);  
//发送数据  
pomeloClient.request('chat.entryHandler.entry', "请帮我把杯子递给我", function(data) \{  
console.log("111111:"+data);  
//通知  
pomeloClient.notify('chat.entryHandler.entry', "我要干活了", function(data) \{  
console.log("===="+data);  
\});  
//关闭联接  
//pomeloClient.disconnect();  
\});  
\});

chat.entryHandler.entry 这是服务端的路由

node test.js 就可以查结果了。

![微笑][smile.gif]如果你觉得此文章对你有用，给我点动力，请我喝杯奶茶咯![微笑][smile.gif]

![20151119105239139][]

[smile.gif]: /images/20220823/f51b597692264909b31dbb71b1efae9a.png
[20151119105239139]: /images/20220823/cec6206291e14e129f2caff3ba9bdae8.png