（十二）nodejs循序渐进-高性能游戏服务器框架pomelo之创建一个游戏聊天服务器

男娘i 2022-12-23 00:57 807阅读 0赞

上个章节我们简单介绍了下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专栏][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:

<table> 
 <tbody> 
  <tr> 
   <td>API</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>route(serverType, routeFunc)</td> 
   <td> <p>&nbsp;Application.route(); serverType:服务类型;routeFunc:路由功能函数,如：routeFunc(session, msg, app, cb)</p> <p>未指定的服务类型设置路由功能。如：</p> <p>app.route('area', routeFunc);</p> <p>var routeFunc = function(session, msg, app, cb) { </p> <p>　　// all request to area would be route to the first area server</p> <p>　　var areas = app.getServersByType('area');</p> <p>　　cb(null, areas[0].id);</p> <p>}</p> </td> 
  </tr> 
 </tbody> 
</table>

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

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

app.set('connectorConfig', opts);

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

## **实现 *gate.gateHandler*** ##

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

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

其中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 ** ###

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

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

### **Channel** ###

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

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。

这里面是发送消息（给房间内所有人和指定用户）

## ** ** ##

**10.运行**

到此这个聊天服务器实现就完成， 打开命令行工具，执行没有错误信息，基本就成功了！

cd game-server目录
    pomelo start

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BieW13OGl3bQ_size_16_color_FFFFFF_t_70][]

进入webserver 执行node app

![20201123151217706.png][]

浏览器输入[http://localhost:3001/][http_localhost_3001]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BieW13OGl3bQ_size_16_color_FFFFFF_t_70 1][]

登录用户信息：

![20201123152507384.png][]

登录其他用户，互发消息：

![20201123152539604.png][]

源码资源可通过 [此链接][Link 1] 下载（目前仅限关注的粉丝下载）

[nginx_apache]: https://blog.csdn.net/pbymw8iwm/category_10218065.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BieW13OGl3bQ_size_16_color_FFFFFF_t_70]: /images/20221120/f6ae9e9aa830453d83552de54a9d2c22.png
[20201123151217706.png]: /images/20221120/62a84ee99ca545cd84a68e0e72b405ff.png
[http_localhost_3001]: http://localhost:3001/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BieW13OGl3bQ_size_16_color_FFFFFF_t_70 1]: /images/20221120/8813cfa7406c4fb9a67d6b28377d0c69.png
[20201123152507384.png]: /images/20221120/d0e1ba191f264520a57fd8ada5d09922.png
[20201123152539604.png]: /images/20221120/0bd1bba9ece24a5199ba8ea71cc4403b.png
[Link 1]: https://download.csdn.net/download/pbymw8iwm/13183552