上个章节我们简单介绍了下pomelo的安装和目录结构，有读者可能觉得有点吃不消，为什么不再深入讲一讲目录结构和里边的库，这里我就不费口舌了，大家可以去官网参考文档说明，本文只告诉大家如何利用这个框架来开发自己的东西。

随着文章的后续不断推进，我相信大家会越来越熟悉pomelo，对猪场框架的使用也会越来越得心用手。

为什么是聊天服务器?

我们目标是搭建游戏服务器，为什么从聊天开始呢？

聊天可认为是简化的实时游戏，它与游戏服务器有着很多共通之处，如实时性、频道、广播等。由于游戏在场景管理、客户端动画等方面有一定的复杂性，并不适合作为 pomelo 的入门应用。聊天应用通常是 Node.js 入门接触的第一个应用，因此更适合做入门教程。

一个聊天系统我们设计思路是客户端连接gate网关服务器，由gate网关服务器根据玩家的uid的crc32的校验码与connector服务器的个数取余，从而得到一个connector服务器，把这个connector服务器分配给请求用户，那么客户端就可以通过此connector服务器建立连接，而和connector服务器保持连接的是chat逻辑服务器，所有的逻辑处理交给connector发起remote的RPC调用。

新建gate和chat服务器

在app/servers目录下新建gate和chat服务器。

gate服务器：

在一般情况下用户量一台机器就可以支撑，但用户量多了就得横向扩充服务器（在gate服务器之前通过nginx反向代理做端口转发，相关文章可以参考我之前的 nginx+apache专栏），gate服务器的作用就相当于前端负载均衡服务器；

客户端向gate服务器发出请求，gate服务器会给客户端分配一个connector服务器；

分配策略是根据客户端的某一个key做hash得到connector的id，这样就可以实现各个connector服务器的负载均衡。

connector服务器：

接受客户端请求，并将其路由到chat服务器，以及维护客户端的链接；

同时，接收客户端对后端服务器的请求，按照用户配置的路由策略，将请求路由给具体的后端服务器。当后端服务器处理完请求或者需要给客户端推送消息的时候，connector服务器同样会扮演一个中间角色，完成对客户端的消息发送；

connector服务器会同时拥有clientPort和port，其中clientPort用来监听客户端的连接，port端口用来给后端提供服务；

chat服务器：

handler和remote决定了服务器的行为；

handler接收用户发送过来的send请求，remote由connector RPC发起远程调用时调用；

在remote里由于涉及到用户的加入和退出，所以会有对channel的操作。

配置master.json

在config下打开master.json

{
  "development": {
    "id": "master-server-1", "host": "127.0.0.1", "port": 3005
  },
  "production": {
    "id": "master-server-1", "host": "127.0.0.1", "port": 3005
  }
}

配置servers.json

打开config目录下servers.json文件，配置好各种 type 的服务器，配置如下

{
    "development":{
        "connector":[
             {"id":"connector-server-1", "host":"127.0.0.1", "port":4050, "clientPort": 3050, "frontend": true},
             {"id":"connector-server-2", "host":"127.0.0.1", "port":4051, "clientPort": 3051, "frontend": true},
             {"id":"connector-server-3", "host":"127.0.0.1", "port":4052, "clientPort": 3052, "frontend": true}
         ],
        "chat":[
             {"id":"chat-server-1", "host":"127.0.0.1", "port":6050},
             {"id":"chat-server-2", "host":"127.0.0.1", "port":6051},
             {"id":"chat-server-3", "host":"127.0.0.1", "port":6052}
        ],
        "gate":[
           {"id": "gate-server-1", "host": "127.0.0.1", "clientPort": 3014, "frontend": true}
        ]
    },
    "production":{
           "connector":[
             {"id":"connector-server-1", "host":"127.0.0.1", "port":4050, "clientPort": 3050, "frontend": true},
             {"id":"connector-server-2", "host":"127.0.0.1", "port":4051, "clientPort": 3051, "frontend": true},
             {"id":"connector-server-3", "host":"127.0.0.1", "port":4052, "clientPort": 3052, "frontend": true}
         ],
        "chat":[
             {"id":"chat-server-1", "host":"127.0.0.1", "port":6050},
             {"id":"chat-server-2", "host":"127.0.0.1", "port":6051},
             {"id":"chat-server-3", "host":"127.0.0.1", "port":6052}
        ],
        "gate":[
           {"id": "gate-server-1", "host": "127.0.0.1", "clientPort": 3014, "frontend": true}
        ]
  }
}

解释一下配置中的各字段：

id: 字符串类型的应用服务器ID

host：应用服务器的IP或者域名

port：RPC请求监听的端口

clientPort： 前端服务器的客户端请求的监听端口

frontend：bool类型，是否是前端服务器，默认: false

可选参数：

max-connections：前端服务器最大客户连接数

args：node/v8配置，如配置为"args": "--debug=5858 "这样就可以启用项目调试（没用过，临时问了一下谷歌，看别人是这么解释的^_^!）

配置adminServer.json

打开config目录下adminServer.json文件，配置好各种 type 的服务器，adminServer.json的使用是让指定type的服务器通过token去向master注册。

master是框架组件，在poemlo.start()时首先被启动，然后由它负责启动其他的组件，包括系统组件和servers.json 中的用户配置组件。

servers.json 中的组件被启动，要向master注册报告自己已经启动了。

在报告的时候需要通过consoleService的authserver的token进行验证。

这个authserver的token就在adminServer.json中

若是没有对对应的type配置对应的token，那么这个服务器就无法注册到master。

这个功能在 node_modules/pomelo/node_modules/pomelo-admin中实现。

因此，你server.json中有几种服务器，那么就得在adminserver.json中配置对应的type与token.

进入config/adminServer.json

[{
    "type": "connector",
    "token": "agarxhqb98rpajloaxn34ga8xrunpagkjwlaw3ruxnpaagl29w4rxn"
}, {
    "type": "chat",
    "token": "agarxhqb98rpajloaxn34ga8xrunpagkjwlaw3ruxnpaagl29w4rxn"
},{
    "type": "gate",
    "token": "agarxhqb98rpajloaxn34ga8xrunpagkjwlaw3ruxnpaagl29w4rxn"
}]

解决服务器分配问题

从上面的servers.json配置的修改可以看出与最开始创建出来的项目一个服务器相比，connector和chat我都配置了三个服务器

这就要解决客户端请求服务器分配问题

解决思路：用户访问gate服务器，使用用户的uid的crc32的校验码与connector服务器的个数取余，从而得到一个connector服务器，把这个connector服务器分配给请求用户

在app目录下新建util目录，目录下新建“dispatcher.js”和 “routeUtil.js”文件，处理此服务器分配逻辑

dispatcher.js

var crc = require('crc');
module.exports.dispatch = function(uid, connectors) {
  var index = Math.abs(crc.crc32(uid)) % connectors.length;
  return connectors[index];
};

routeUtil.js

var dispatcher = require('./dispatcher');
module.exports.chat = function(session, msg, app, cb) {
  var chatServers = app.getServersByType('chat');
  if(!chatServers || chatServers.length === 0) {
    cb(new Error('can not find chat servers.'));
    return;
  }
  var res = dispatcher.dispatch(session.get('rid'), chatServers);
  cb(null, res.id);
};

准备好这些文件后，在game-server服务器入口文件app.js中添加配配置:

注意：

app.configure('production|development', 'connector', function(){

修改为

app.configure('production|development', function(){

这个如果不修改，在启动调用时会遇到 engine.io 中报错 TypeError: Cannot read property 'indexOf' of undefined at Server.verify .

这里我们使用的connector是sioconnector（支持socket.io）

这里我有必要说明下route的API:

API

说明

route(serverType, routeFunc)

Application.route(); serverType:服务类型;routeFunc:路由功能函数,如：routeFunc(session, msg, app, cb)

未指定的服务类型设置路由功能。如：

app.route('area', routeFunc);

var routeFunc = function(session, msg, app, cb) {

　　// all request to area would be route to the first area server

　　var areas = app.getServersByType('area');

　　cb(null, areas[0].id);

}

另外注意的是transports这个参数：这个配置选项是用于sioconnector的，因为socket.io的通信方式可能会有多种，如websocket，xhr-polling等等。通过这个配置选项可以选择需要的方式。

配置connector组件，通过调用如下方式进行:

app.set('connectorConfig', opts);

知道了以上基础知识，那么我们直接上代码“：

var pomelo = require('pomelo');
var routeUtil = require('./app/util/routeUtil');
/**
 * Init app for client.
 */
var app = pomelo.createApp();
app.set('name', 'demoserver');
// app configure
app.configure('production|development', function() {
  // route configures
  app.route('chat', routeUtil.chat);
  app.set('connectorConfig', {
    connector: pomelo.connectors.sioconnector,
    // 'websocket', 'polling-xhr', 'polling-jsonp', 'polling'
    transports: ['websocket', 'polling'],
    heartbeats: true,
    closeTimeout: 60 * 1000,
    heartbeatTimeout: 60 * 1000,
    heartbeatInterval: 25 * 1000
  });
  // filter configures
  app.filter(pomelo.timeout());
});
// start app
app.start();
process.on('uncaughtException', function(err) {
  console.error(' Caught exception: ' + err.stack);
});

实现 gate.gateHandler

作用：用户连接gate服务器，返回分配的connector

在gate目录下handler下新建gateHandler.js，代码如下

var dispatcher = require('../../../util/dispatcher');
module.exports = function(app) {
  return new Handler(app);
};
var Handler = function(app) {
  this.app = app;
};
var handler = Handler.prototype;
/**
 * Gate handler that dispatch user to connectors.
 *
 * @param {Object} msg message from client
 * @param {Object} session
 * @param {Function} next next stemp callback
 *
 */
handler.queryEntry = function(msg, session, next) {
  var uid = msg.uid;
  if(!uid) {
    next(null, {
      code: 500
    });
    return;
  }
  // get all connectors
  var connectors = this.app.getServersByType('connector');
  if(!connectors || connectors.length === 0) {
    next(null, {
      code: 500
    });
    return;
  }
  // select connector
  var res = dispatcher.dispatch(uid, connectors);
  next(null, {
    code: 200,
    host: res.host,
    port: res.clientPort
  });
};

其中handler.queryEntry是到时候客户端请求访问的路由接口，如果读者对此处有疑惑的可以阅读我上一篇文章里的架构部分，有专门对route路由规则介绍的。

实现connector中entryHandler.js

主要完成接受客户端的请求，维护与客户端的连接，路由客户端的请求到chat服务器;

在原有的entryHandler.js基础上做修改，加入enter进入聊天室的接口.

这里我要说明下：

在chat服务器里创建了channel, 这个channel只有在chat服务器里能用.

别的服务器里, 获取不到chat服务器的channel, 不过你可以通过RPC方式调用chat服务器的方式来获取其属性。

module.exports = function(app) {
  return new Handler(app);
};
var Handler = function(app) {
  this.app = app;
}; 
/**
 * New client entry chat server.
 *
 * @param  {Object}   msg     request message
 * @param  {Object}   session current session object
 * @param  {Function} next    next stemp callback
 * @return {Void}
 */
Handler.prototype.enter = function(msg, session, next) {
  var self = this;
  var rid = msg.rid;
  var uid = msg.username + '*' + rid
  var sessionService = self.app.get('sessionService');
  //duplicate log in
  if( !! sessionService.getByUid(uid)) {
    next(null, {
      code: 500,
      error: true
    });
    return;
  }
  session.bind(uid);
  session.set('rid', rid);
  session.push('rid', function(err) {
    if(err) {
      console.error('set rid for session service failed! error is : %j', err.stack);
    }
  });
  session.on('closed', onUserLeave.bind(null, self.app));
  //put user into channel
  self.app.rpc.chat.chatRemote.add(session, uid, self.app.get('serverId'), rid, true, function(users){
    next(null, {
      users:users
    });
  });
};
/**
 * User log out handler
 *
 * @param {Object} app current application
 * @param {Object} session current session object
 *
 */
var onUserLeave = function(app, session) {
  if(!session || !session.uid) {
    return;
  }
  app.rpc.chat.chatRemote.kick(session, session.uid, app.get('serverId'), session.get('rid'), null);
};
/**
 * New client entry.
 *
 * @param  {Object}   msg     request message
 * @param  {Object}   session current session object
 * @param  {Function} next    next step callback
 * @return {Void}
 */
Handler.prototype.entry = function(msg, session, next) {
  next(null, {code: 200, msg: 'game server is ok.'});
};
/**
 * Publish route for mqtt connector.
 *
 * @param  {Object}   msg     request message
 * @param  {Object}   session current session object
 * @param  {Function} next    next step callback
 * @return {Void}
 */
Handler.prototype.publish = function(msg, session, next) {
  var result = {
    topic: 'publish',
    payload: JSON.stringify({code: 200, msg: 'publish message is ok.'})
  };
  next(null, result);
};
/**
 * Subscribe route for mqtt connector.
 *
 * @param  {Object}   msg     request message
 * @param  {Object}   session current session object
 * @param  {Function} next    next step callback
 * @return {Void}
 */
Handler.prototype.subscribe = function(msg, session, next) {
  var result = {
    topic: 'subscribe',
    payload: JSON.stringify({code: 200, msg: 'subscribe message is ok.'})
  };
  next(null, result);
};

这里完成的主要就是RPC远程调用chat服务器chatRemote中的实现(通过app.rpc.chat.chatRemote来拉起RPC调用，我们将在下面实现chat服务器的remote接口)。

这里我有必要说下为什么要用rpc方式，而不是用socket.io 方式或者websocket方式：

比如我们游戏的角色信息是作为一个redis缓存对方存放的，有一个不好的地方就是，如果别的地方调用该玩家的信息并进行修改，就可能会出现两处数据修改，结果却只有一处能够修改成功。

例如：Ａ接口，Ｂ接口。都会获取charInfo并对charInfo 进行修改。

先调用A接口，在A接口处理逻辑的过程中，调用了B接口。

这时候A,B获取到的charInfo是一样的，但是，修改的属性值可能不一样，在redis设置缓存的时候，只能是哪个最后设置的，charInfo 修改的属性值才会生效。比如A修改exp属性，B修改gold属性。

A接口先设置缓存，B后设置。这时候，只有gold属性值才会被真正的修改。因为在B获取到的charInfo里没有修改charInfo.exp. 说白了，就是不是修改的同一个对象。

所以这次我们将角色信息专门定义了一个char对象，提供一个get和一个set接口。这样，不论是那个地方对charInfo 的修改，都是针对同一个对象的修改。

char对象定义放在data服务器，其他服务器例如chat服务器，要获取charInfo ,就需要rpc调用data服务器的get方法获取charInfo. 如果在chat服务器里有对charInfo进行修改，则一定要rpc调用data服务器的set方法，重新设置charInfo. 如果data是单个的服务器就没有必要。不过一般至少有三个data服务器。

玩家在登陆的时候，分配一个data服务器给当前玩家。该玩家的信息就保存在这个data服务器的session里。其他data服务器不会有。这也是为什么其他非data服务器对charInfo 修改一定要远程rpc set一下. 因为在其他非data服务器下对charInfo 的修改，都修改的不是一个不同的对象了。一个服务器一个session，一个charInfo保存在一个服务器的session，这样就好理解点了。

实现chat服务器chatRemote.js

chat服务器会接受connector的远程调用，完成channel维护中的用户的加入以及离开。

这里大家需要再次了解这两个模块的API ChannelService和Channel：

ChannelService

　　　　创建和维护本地服务的信道。

API	说明
createChannel(name)	ChannelService.prototype.createChannel() 根据信道名称创建信道，如果该信道已存在则返回已存在的信道
getChannel(name,create)	ChannelService.prototype.getChannel() name:信道名称，create:如果为true，并且信道不存在时，则创建新的信道。根据信道名称获取信道
destroyChannel(name)	ChannelService.prototype.destroyChannel() 根据信道名称，删除信道
pushMessageByUids(route, msg, uids, cb)	ChannelService.prototype.pushMessageByUids() route：消息路由；msg：发送到客户端的消息；uids：接收消息的客户端列表，格式 [{uid: userId, sid: frontendServerId}]；cb：回调函数 cb(err)。根据uids将消息推送给客户端，如果uids中的sid未指定，则忽略相应的客户端
broadcast(stype,route, msg, opts, cb)	ChannelService.prototype.broadcast() stype：前端服务的类型;route：路由;msg：消息;opts：广播参数;cb：回调函数。广播消息到所有连接的客户端。

Channel

API	说明
add(uid,sid)	Channel.prototype.add() uid:用户编号；sid：用户连接到的前端服务id。添加指定用户到信道。
leave(uid,sid)	Channel.prototype.leave() uid:用户编号；sid：用户连接到的前端服务id。从信道中移除用户。
getMembers()	Channel.prototype.getMembers() 获得信道中的成员
getMember(uid)	Channel.prototype.getMember() 根据uid获取成员信息
destroy()	Channel.prototype.destroy() 销毁信道
pushMessage(route,msg,cb)	Channel.prototype.pushMessage() route：消息路由，msg：要推送的消息，cb：回调函数。将消息推送给信道的所有成员。

module.exports = function(app) {
  return new ChatRemote(app);
};
var ChatRemote = function(app) {
  this.app = app;
  this.channelService = app.get('channelService');
};
/**
 * Add user into chat channel.
 *
 * @param {String} uid unique id for user
 * @param {String} sid server id
 * @param {String} name channel name
 * @param {boolean} flag channel parameter
 *
 */
ChatRemote.prototype.add = function(uid, sid, name, flag, cb) {
  var channel = this.channelService.getChannel(name, flag);
  var username = uid.split('*')[0];
  var param = {
    route: 'onAdd',
    user: username
  };
  channel.pushMessage(param);
  if( !! channel) {
    channel.add(uid, sid);
  }
  cb(this.get(name, flag));
};
/**
 * Get user from chat channel.
 *
 * @param {Object} opts parameters for request
 * @param {String} name channel name
 * @param {boolean} flag channel parameter
 * @return {Array} users uids in channel
 *
 */
ChatRemote.prototype.get = function(name, flag) {
  var users = [];
  var channel = this.channelService.getChannel(name, flag);
  if( !! channel) {
    users = channel.getMembers();
  }
  for(var i = 0; i < users.length; i++) {
    users[i] = users[i].split('*')[0];
  }
  return users;
};
/**
 * Kick user out chat channel.
 *
 * @param {String} uid unique id for user
 * @param {String} sid server id
 * @param {String} name channel name
 *
 */
ChatRemote.prototype.kick = function(uid, sid, name, cb) {
  var channel = this.channelService.getChannel(name, false);
  // leave channel
  if( !! channel) {
    channel.leave(uid, sid);
  }
  var username = uid.split('*')[0];
  var param = {
    route: 'onLeave',
    user: username
  };
  channel.pushMessage(param);
  cb();
};

可以看到上面代码中的add和kick分别对应着加入和离开channel

实现chat服务器chatHandler.js

chat服务器执行聊天逻辑，维护channel信息，一个房间就是一个channel，一个channel里有多个用户，当有用户发起聊天的时候，就会将其内容广播到整个channel。

var chatRemote = require('../remote/chatRemote');
module.exports = function(app) {
  return new Handler(app);
};
var Handler = function(app) {
  this.app = app;
};
var handler = Handler.prototype;
/**
 * Send messages to users
 *
 * @param {Object} msg message from client
 * @param {Object} session
 * @param  {Function} next next stemp callback
 *
 */
handler.send = function(msg, session, next) {
  var rid = session.get('rid');
  var username = session.uid.split('*')[0];
  var channelService = this.app.get('channelService');
  var param = {
    route: 'onChat',
    msg: msg.content,
    from: username,
    target: msg.target
  };
  channel = channelService.getChannel(rid, false);
  //the target is all users
  if(msg.target == '*') {
    channel.pushMessage(param);
  }
  //the target is specific user
  else {
    var tuid = msg.target + '*' + rid;
    var tsid = channel.getMember(tuid)['sid'];
    channelService.pushMessageByUids(param, [{
      uid: tuid,
      sid: tsid
    }]);
  }
  next(null, {
    route: msg.route
  });
};