pomelo之application的创建于初始化

最新推荐文章于 2020-09-10 15:21:41 发布
最新推荐文章于 2020-09-10 15:21:41 发布
阅读量1.2k 收藏
点赞数
分类专栏： pomelo 文章标签： pomelo


这一篇来写pomelo的application的创建过程。。当然例子还是以官方的chat。。。。主要是来分析下面这段代码：

[javascript] view plain copy print ?
  1. var app = pomelo.createApp();  
var app = pomelo.createApp();

我们首先来看看pomelo的定义吧：

[javascript] view plain copy print ?
  1. var fs = require('fs');  
  2. var path = require('path');  
  3. var application = require('./application');  
  4.   
  5.   
  6. /** 
  7.  * Expose `createApplication()`. 
  8.  * 
  9.  * @module 
  10.  */  
  11. //这里相当于是进行命名  
  12. var Pomelo = module.exports = {};  
  13.   
  14. /** 
  15.  * Framework version. 
  16.  */  
  17.   
  18. Pomelo.version = '0.4';  
  19.   
  20. /** 
  21.  * Event definitions that would be emitted by app.event 
  22.  */  
  23. Pomelo.events = require('./util/events');  
  24.   
  25. /** 
  26.  * auto loaded components 
  27.  */  
  28.  //用于保存组件  
  29. Pomelo.components = {};  
  30.   
  31. /** 
  32.  * auto loaded filters 
  33.  */  
  34.  //用于保存filter  
  35. Pomelo.filters = {};  
  36.   
  37. /** 
  38.  * connectors 
  39.  */  
  40.  //connector对象  
  41. Pomelo.connectors = {};  
  42. //connector对象的get方法  
  43. Pomelo.connectors.__defineGetter__('sioconnector', function() {  
  44.   return require('./connectors/sioconnector');  
  45. });  
  46. //超级connector的get方法  
  47. Pomelo.connectors.__defineGetter__('hybridconnector', function() {  
  48.   return require('./connectors/hybridconnector');  
  49. });  
  50.   
  51. /** 
  52.  * schedulers 
  53.  */  
  54.  //定义调度器  
  55. Pomelo.schedulers = {};  
  56. Pomelo.schedulers.__defineGetter__('direct', function() {  
  57.   var m = require('./scheduler/direct');  
  58.   return m;  
  59. });  
  60.   
  61. Pomelo.schedulers.__defineGetter__('buffer', function() {  
  62.   return require('./scheduler/buffer');  
  63. });  
  64.   
  65. /** 
  66.  * global channel manager 
  67.  */  
  68. Pomelo.connectors.__defineGetter__('redisGlobalChannelManager', function() {  
  69.   return require('./common/manager/redisGlobalChannelManager');  
  70. });  
  71.   
  72. //用self来指向当前的作用域  
  73. var self = this;  
  74.   
  75. /** 
  76.  * Create an pomelo application. 
  77.  * 
  78.  * @return {Application} 
  79.  * @memberOf Pomelo 
  80.  * @api public 
  81.  */  
  82.  //创建application对象  
  83. Pomelo.createApp = function (opts) {  
  84.   var app = application;  
  85.   app.init(opts);  //初始化函数  
  86.   self.app = app;  
  87.   return app;  
  88. };  
  89.   
  90. /** 
  91.  * Get application 
  92.  */  
  93.  //相当于是为Pomelo对象添加一个属性，app，它是一个对象，就存在一个get方法，用于返回当前的app对象  
  94. Object.defineProperty(Pomelo, 'app', {  
  95.   get:function () {  
  96.     return self.app;  
  97.   }  
  98. });  
  99.   
  100. /** 
  101.  * Auto-load bundled components with getters. 
  102.  */  
  103.  //用于在components文件夹中读取组件，然后保存到components对象里面去  
  104. fs.readdirSync(__dirname + '/components').forEach(function (filename) {  
  105.   if (!/\.js$/.test(filename)) {  
  106.     return;  
  107.   }  
  108.   var name = path.basename(filename, '.js');  
  109.   
  110.   function load() {  
  111.     return require('./components/' + name);  
  112.   }  
  113.   Pomelo.components.__defineGetter__(name, load);//例如执行Pomelo.components.aa,其实会得到require("./components/aa");的值  
  114.   Pomelo.__defineGetter__(name, load);  
  115. });  
  116.   
  117. //用于读取filter对象  
  118. fs.readdirSync(__dirname + '/filters/handler').forEach(function (filename) {  
  119.   if (!/\.js$/.test(filename)) {  
  120.     return;  
  121.   }  
  122.   var name = path.basename(filename, '.js');  
  123.   
  124.   function load() {  
  125.     return require('./filters/handler/' + name);  
  126.   }  
  127.   Pomelo.filters.__defineGetter__(name, load);  
  128.   Pomelo.__defineGetter__(name, load);  
  129. });  
var fs = require('fs');
var path = require('path');
var application = require('./application');


/**
 * Expose `createApplication()`.
 *
 * @module
 */
//这里相当于是进行命名
var Pomelo = module.exports = {};

/**
 * Framework version.
 */

Pomelo.version = '0.4';

/**
 * Event definitions that would be emitted by app.event
 */
Pomelo.events = require('./util/events');

/**
 * auto loaded components
 */
 //用于保存组件
Pomelo.components = {};

/**
 * auto loaded filters
 */
 //用于保存filter
Pomelo.filters = {};

/**
 * connectors
 */
 //connector对象
Pomelo.connectors = {};
//connector对象的get方法
Pomelo.connectors.__defineGetter__('sioconnector', function() {
  return require('./connectors/sioconnector');
});
//超级connector的get方法
Pomelo.connectors.__defineGetter__('hybridconnector', function() {
  return require('./connectors/hybridconnector');
});

/**
 * schedulers
 */
 //定义调度器
Pomelo.schedulers = {};
Pomelo.schedulers.__defineGetter__('direct', function() {
  var m = require('./scheduler/direct');
  return m;
});

Pomelo.schedulers.__defineGetter__('buffer', function() {
  return require('./scheduler/buffer');
});

/**
 * global channel manager
 */
Pomelo.connectors.__defineGetter__('redisGlobalChannelManager', function() {
  return require('./common/manager/redisGlobalChannelManager');
});

//用self来指向当前的作用域
var self = this;

/**
 * Create an pomelo application.
 *
 * @return {Application}
 * @memberOf Pomelo
 * @api public
 */
 //创建application对象
Pomelo.createApp = function (opts) {
  var app = application;
  app.init(opts);  //初始化函数
  self.app = app;
  return app;
};

/**
 * Get application
 */
 //相当于是为Pomelo对象添加一个属性，app，它是一个对象，就存在一个get方法，用于返回当前的app对象
Object.defineProperty(Pomelo, 'app', {
  get:function () {
    return self.app;
  }
});

/**
 * Auto-load bundled components with getters.
 */
 //用于在components文件夹中读取组件，然后保存到components对象里面去
fs.readdirSync(__dirname + '/components').forEach(function (filename) {
  if (!/\.js$/.test(filename)) {
    return;
  }
  var name = path.basename(filename, '.js');

  function load() {
    return require('./components/' + name);
  }
  Pomelo.components.__defineGetter__(name, load);//例如执行Pomelo.components.aa,其实会得到require("./components/aa");的值
  Pomelo.__defineGetter__(name, load);
});

//用于读取filter对象
fs.readdirSync(__dirname + '/filters/handler').forEach(function (filename) {
  if (!/\.js$/.test(filename)) {
    return;
  }
  var name = path.basename(filename, '.js');

  function load() {
    return require('./filters/handler/' + name);
  }
  Pomelo.filters.__defineGetter__(name, load);
  Pomelo.__defineGetter__(name, load);
});
其实本身pomelo的定义还是很简单的，无非就是定义了一些名字，然后加载了一些组件，这里其实可以将pomelo对象看成已是一个资源的管理。。。

这里大量用到了如下的方法：

[javascript] view plain copy print ?
  1. Pomelo.connectors.__defineGetter__('redisGlobalChannelManager', function() {  
  2.   return require('./common/manager/redisGlobalChannelManager');  
  3. });  
Pomelo.connectors.__defineGetter__('redisGlobalChannelManager', function() {
  return require('./common/manager/redisGlobalChannelManager');
});
这种用法其实就是定义一下这个属性的获取方法，当Pomelo.connectors.redisGlobalChannelManager的方式访问这个属性的时候，会直接调用换进去的函数，得到返回值。。。

我们重点来分析如下代码：

[javascript] view plain copy print ?
  1.  //创建application对象  
  2. Pomelo.createApp = function (opts) {  
  3.   var app = application;  
  4.   app.init(opts);  //初始化函数  
  5.   self.app = app;  
  6.   return app;  
  7. };  
 //创建application对象
Pomelo.createApp = function (opts) {
  var app = application;
  app.init(opts);  //初始化函数
  self.app = app;
  return app;
};
由于application的定义比较长，就不一次性列出来，先来看看它的init方法。。。。
[javascript] view plain copy print ?
  1. Application.init = function(opts) {  
  2.   opts = opts || {};  
  3.   this.loaded = [];       // loaded component list  
  4.   //用于保存所有的组件  
  5.   this.components = {};   // name -> component map  
  6.   
  7.   //调用set方法保存的参数将会保存在这个地方  
  8.   this.settings = {};     // collection keep set/get  
  9.   this.set('base', opts.base);  
  10.   //事件对象  
  11.   this.event = new EventEmitter();  // event object to sub/pub events  
  12.   
  13.   // current server info  
  14.   this.serverId = null;   // current server id  
  15.   this.serverType = null; // current server type  
  16.   this.curServer = null;  // current server info  
  17.   
  18.   // global server infos  
  19.   this.master = null;         // master server info  
  20.   //用于保存所有的server，id与info的键值对  
  21.   this.servers = {};          // current global server info maps, id -> info  
  22.   this.serverTypeMaps = {};   // current global type maps, type -> [info]  
  23.   this.serverTypes = [];      // current global server type list  
  24.   
  25.   appUtil.defaultConfiguration(this);   //默认配置  
  26.   
  27.   this.state = STATE_INITED;  //将当前的状态修改为已经初始化  
  28.   logger.info('application inited: %j', this.getServerId());  
  29. };  
Application.init = function(opts) {
  opts = opts || {};
  this.loaded = [];       // loaded component list
  //用于保存所有的组件
  this.components = {};   // name -> component map

  //调用set方法保存的参数将会保存在这个地方
  this.settings = {};     // collection keep set/get
  this.set('base', opts.base);
  //事件对象
  this.event = new EventEmitter();  // event object to sub/pub events

  // current server info
  this.serverId = null;   // current server id
  this.serverType = null; // current server type
  this.curServer = null;  // current server info

  // global server infos
  this.master = null;         // master server info
  //用于保存所有的server，id与info的键值对
  this.servers = {};          // current global server info maps, id -> info
  this.serverTypeMaps = {};   // current global type maps, type -> [info]
  this.serverTypes = [];      // current global server type list

  appUtil.defaultConfiguration(this);   //默认配置

  this.state = STATE_INITED;  //将当前的状态修改为已经初始化
  logger.info('application inited: %j', this.getServerId());
};
刚开始启动的视乎，没有参数传进来，opts就是null，代码本身也很简单吧，可以当做是对application对象的一些属性的声明和初始化。。。

这里主要是要看一下defaultConfiguration部分干了些什么。。。

我们来看看它的定义吧：

[javascript] view plain copy print ?
  1. module.exports.defaultConfiguration = function (app) {  
  2.   var args = parseArgs(process.argv);  //这里process.argv保存的是运行使用的命令，是一个数组例如[ 'node', '/home/fjs/Desktop/pomelo/game-server/app.js' ]  
  3.   /* 
  4.   [ '/usr/local/bin/node', 
  5.   '/home/fjs/Desktop/pomelo/game-server/app.js', 
  6.   'env=development', 
  7.   'id=chat-server-2', 
  8.   'host=127.0.0.1', 
  9.   'port=6051', 
  10.   'serverType=chat' ] 
  11. */  
  12.   
  13.   //最后args如以下形式：  
  14.   //master { main: '/home/fjs/Desktop/pomelo/game-server/app.js' }  
  15.   
  16.   /*{ main: '/home/fjs/Desktop/pomelo/game-server/app.js', 
  17.   env: 'development', 
  18.   id: 'connector-server-1', 
  19.   host: '127.0.0.1', 
  20.   port: 4050, 
  21.   clientPort: 3050, 
  22.   frontend: 'true', 
  23.   serverType: 'connector' }*/  
  24.   
  25.   setupEnv(app, args);    //设置当前环境的配置，是开发，部署等  
  26.   loadMaster(app);    //加载master服务器的配置  
  27.   loadServers(app);   //加载server的配置  
  28.   processArgs(app, args);  
  29.   configLogger(app);  
  30. };  
module.exports.defaultConfiguration = function (app) {
  var args = parseArgs(process.argv);  //这里process.argv保存的是运行使用的命令，是一个数组例如[ 'node', '/home/fjs/Desktop/pomelo/game-server/app.js' ]
  /*
  [ '/usr/local/bin/node',
  '/home/fjs/Desktop/pomelo/game-server/app.js',
  'env=development',
  'id=chat-server-2',
  'host=127.0.0.1',
  'port=6051',
  'serverType=chat' ]
*/

  //最后args如以下形式：
  //master { main: '/home/fjs/Desktop/pomelo/game-server/app.js' }

  /*{ main: '/home/fjs/Desktop/pomelo/game-server/app.js',
  env: 'development',
  id: 'connector-server-1',
  host: '127.0.0.1',
  port: 4050,
  clientPort: 3050,
  frontend: 'true',
  serverType: 'connector' }*/

  setupEnv(app, args);    //设置当前环境的配置，是开发，部署等
  loadMaster(app);    //加载master服务器的配置
  loadServers(app);   //加载server的配置
  processArgs(app, args);
  configLogger(app);
};
代码还是很简单吧，先是获取当前的执行命令，例如：node app.js，

然后对其进行一些处理，将一些参数处理出来，这里可能要分为两种，毕竟有master服务器和非master服务器。。。他们解析出来的结果在上面的注释都已经标了出来。。。

接下来就是设置环境，例如是development或者production。。。

然后载入Master服务器的配置，然后载入普通server的配置。。。

这里我们就选一个出来看看吧，看看普通server的配置是怎么进行载入的。。。

[javascript] view plain copy print ?
  1. var loadServers = function(app) {  
  2.   app.loadConfig('servers', app.getBase() + '/config/servers.json');  //载入server类型的服务器的配置  
  3.   var servers = app.get('servers');   //获取刚刚载入的配置信息  
  4.   var serverMap = {}, slist, i, l, server;  
  5.   for(var serverType in servers) {   //遍历serve的类型，chat，gate，connector  
  6.     slist = servers[serverType];  
  7.     for(i=0, l=slist.length; i<l; i++) {    //遍历当前这种类型的server  
  8.       server = slist[i];  
  9.       server.serverType = serverType;  
  10.       serverMap[server.id] = server;   //将这些server保存到serverMap里面去  
  11.   
  12.       if(server.wsPort) {  
  13.         logger.warn('wsPort is deprecated, ' +  
  14.                     'use clientPort and frontend instead.');  
  15.       }  
  16.     }  
  17.   }  
  18.   
  19.   app.set('__serverMap__', serverMap);  //将所有的server保存到app域里去  
  20. };  
var loadServers = function(app) {
  app.loadConfig('servers', app.getBase() + '/config/servers.json');  //载入server类型的服务器的配置
  var servers = app.get('servers');   //获取刚刚载入的配置信息
  var serverMap = {}, slist, i, l, server;
  for(var serverType in servers) {   //遍历serve的类型，chat，gate，connector
    slist = servers[serverType];
    for(i=0, l=slist.length; i<l; i++) {    //遍历当前这种类型的server
      server = slist[i];
      server.serverType = serverType;
      serverMap[server.id] = server;   //将这些server保存到serverMap里面去

      if(server.wsPort) {
        logger.warn('wsPort is deprecated, ' +
                    'use clientPort and frontend instead.');
      }
    }
  }

  app.set('__serverMap__', serverMap);  //将所有的server保存到app域里去
};
代码还是很简单的吧，首先载入配置文件，然后遍历其中server类型，然后将他们用键值对管理起来就完事了。。。

额。。

最后还有一个  processArgs(app, args);

[javascript] view plain copy print ?
  1. var processArgs = function(app, args){  
  2.   var serverType = args.serverType || 'master';   //如果没有serverType，那么就是master服务器了  
  3.   var serverId = args.id || app.getMaster().id;    //获取服务器的id  
  4.   
  5.   app.set('main', args.main, true);    //将运行信息保存起来，  
  6.     //master { main: '/home/fjs/Desktop/pomelo/game-server/app.js' }  
  7.   
  8.   /*{ main: '/home/fjs/Desktop/pomelo/game-server/app.js', 
  9.   env: 'development', 
  10.   id: 'connector-server-1', 
  11.   host: '127.0.0.1', 
  12.   port: 4050, 
  13.   clientPort: 3050, 
  14.   frontend: 'true', 
  15.   serverType: 'connector' }*/  
  16.   app.set('serverType', serverType, true);  
  17.   app.set('serverId', serverId, true);  
  18.   
  19.  if(serverType !== 'master') {  //保存当前服务器类型  
  20.     app.set('curServer', args, true);  
  21.   } else {  
  22.     app.set('curServer', app.getMaster(), true);     
  23.   }  
  24. };  
var processArgs = function(app, args){
  var serverType = args.serverType || 'master';   //如果没有serverType，那么就是master服务器了
  var serverId = args.id || app.getMaster().id;    //获取服务器的id

  app.set('main', args.main, true);    //将运行信息保存起来，
    //master { main: '/home/fjs/Desktop/pomelo/game-server/app.js' }

  /*{ main: '/home/fjs/Desktop/pomelo/game-server/app.js',
  env: 'development',
  id: 'connector-server-1',
  host: '127.0.0.1',
  port: 4050,
  clientPort: 3050,
  frontend: 'true',
  serverType: 'connector' }*/
  app.set('serverType', serverType, true);
  app.set('serverId', serverId, true);

 if(serverType !== 'master') {  //保存当前服务器类型
    app.set('curServer', args, true);
  } else {
    app.set('curServer', app.getMaster(), true);   
  }
};
其实这个名字有点唬人，并没有执行什么命令，无非是设置了一些参数而已，。。。。。


好了，那么整个application的创建过程就差不多了，其实这部分最主要的事情还是将配置文件load进来。。。


下一篇来分析一下启动过程吧。。。。

lisaem
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
课程7：EF初始化数据库，插入初始化数据【附源码】
成长的足迹
05-02 1503
本文是《.Net Core从零学习搭建权限管理系统》教程专栏的课程（点击链接，跳转到专栏主页，欢迎订阅，持续更新…）专栏介绍：以实战为线索，基于.Net 7 + REST + Vue、前后端分离，不依赖任何第三方框架，从零一步一步讲解权限管理系统搭建。专栏适用于人群：Web后端开发人员本课程内容：1、如何采用EF对数据库初始化，插入默认数据。2、Web API注入数据库上下文，方便后续开发。在上一个课程，我们已经创建好模型，在正式开发API接口之前，为了方便我们调试，我们要对数据库进行初始化。
pomelo 框架第一部分 pomelo框架基础
ai_milk的博客
03-02 1385
pomelo 框架第一部分 项目地址: https://github.com/NetEase/chatofpomelo-websocket.git 一、pomelo.js pomelo.js中的初始化 Pomelo.connectors = {}; Pomelo.connectors.__defineGetter__('sioconnector', load.bind(null, './connectors/sioconnector')); Pomelo.connectors.__defineGetter_
pomelo 初始化配置...
weixin_34009794的博客
01-05 131
在创建app的时候会初始化master和server以及log配置.. /** * Initialize application configuration. */ module.exports.defaultConfiguration = function(app) { var args = parseArgs(process.argv); setupEnv(app,...
Pomelo Application
嘿嘿
04-03 431
应用程序配置，如何配置Pomelo框架？ Pomelo可以配置各个组件的选项，加载配置文件，开启Pomelo的特性等，这些配置都是在game-server/app.js文件中进行的。实际上在Pomelo的应用中有两个app.js，一个是在game-server目录下，一个是在web-server目录下。game-server下的app.js是整个游戏服务器的入口和配置点。web-server下的...
创建pomelo工程
过客2019
02-25 874
进入dos命令行窗口npm install pomelo@2.x -gd:\work\pomelo init xxxx通信方式：1 websocket1在xxxx目录下面，就多了game-server和web-server然后在game-server和web-server执行 npm install -d启动：d:\work\xxxx\game-server目录下：执行 node appd:\wo...
创建pomelo_demo
guiziwen的专栏
01-17 691
创建pomelo_demo 创建一个pomeloDemo这样的一个文件夹，然后在cmd下切换到这个目录下，输入： [plain] view plaincopy pomelo init pomelo_demo   这是在pomeloDemo目录下就会有一个pomelo_demo的工程目录，然后我们把cmd路径切换到pomel
pomelo源码分析.docx
11-28
初始化过程主要由`application.js`中的`Initapp`函数实现，该函数负责加载基础配置并进行必要的初始化操作。 ##### 2.3 默认配置(defaultConfiguration) `apputil.js`中的`defaultConfiguration`函数负责设置...
pomelo-config-reader-demo
06-04
3. `server.js`或类似的启动脚本：初始化Pomelo服务器，并使用配置读取器加载配置。 4. `app.js`或`application.js`：Pomelo应用的核心配置文件，可能包含如何使用配置读取器的示例代码。 5. `README.md`：可能包含...
Pomelo聊天服务搭建（二）
wleng的博客
08-11 1802
chatofpomelo源码分析 在进行客户端和服务端的分析之前，我们先来看一下pomelo对于服务器的配置 development和production为启动时设置的环境，根据 pomelo start -e|-env development|production 中的参数，启动后选择不同的服务设置。 id:表示对应服务器的名字(同一类服务器命名应易于辨别) host:...
【Pomelo源码分析】2016-09-21 程序入口（app.js, pomelo.js, application.js）
u010334580的博客
09-21 1729
Pomelo程序入口，app.js、pomelo.js、application.js文件的源码分析
pomelo + mysql 学习（四）程序入口app.js
gjyhit的专栏
05-29 801
进入app/util文件夹，修改routeUtil.jsvar exp = module.exports; exp.connector = function(session, msg, app, cb){ if(!session){ cb(new Error('fail to route to connector server for session is empty')); retu...
Pomelo App
JunChow
11-20 467
应用程序配置，如何配置Pomelo框架？ Pomelo可以配置各个组件的选项，加载配置文件，开启Pomelo的特性等，这些配置都是在game-server/app.js文件中进行的。实际上在Pomelo的应用中有两个app.js，一个是在game-server目录下，一个是在web-server目录下。game-server下的app.js是整个游戏服务器的入口和配置点。web-s...
Pomelo 应用程序配置
awhlmcyn的博客
09-10 573
创建Pomelo应用后，可以在game-server/app.js文件中对应用做一些配置。包括配置每个组件选项配置、加载配置文件、启用／禁用Pomelo特性等框架配置。 app.js文件 app.configure()- 配置服务器 访问上下文变量 禁用／启用特性 加载配置文件 加载组件 配置路由 配置过滤器 配置模块 服务器配置文件 1.app.js文件 app.js文件是Pomelo应用的入口点。在这个文件中，首先需要使用pomelo.createApp()方法来创建一个应用类..
pomelo程序如何使用pomelo-sync
weixin_30776863的博客
08-04 383
新版本的pomelo里增强了支持用户自行扩展的能力。用户只用在app.use(plugin, opts)就可以了，具体请看pomelo的application.js里的use函数。需要这个plugin里有components成员。use函数里，pomelo将plugin的componets所指的组件load起来，并将opts传给这个plugin的components。 pomel...
pomelo应用程序配置
疯狂的程序员
03-26 604
在这部分，我们来介绍如何配置框架。我们知道在pomelo中，可以配置各个组件的选项，加载配置文件，开启pomelo的特性等等。这一切配置都是在game-server/app.js中进行的。实际上，在pomelo的应用中有两个app.js,一个在game-server目录下，一个在web-server目录下。其中game-server下的app.js是整个游戏服务器的入口和配置点，而web-serv...
pomelo使用采坑记(学习使用部署相关)
tqy的博客
10-20 3830
pomelo学习、使用和部署pomelo推送方式频道推送直接推送bearcat集成remote和handler集成非pomelo框架的service、util等的集成bearcat优势默认路由规则采坑未进行用户Id绑定的多服务器远程调用路由配置log按照时间日期服务器分割按服务器和天分割按服务端和小时分割按天分割IDEA调式服务器配置IDEA配置步骤分布式部署ssh方式非ssh方式 pomelo推...
Pomelo框架总结
嘿嘿
04-05 1916
Pomelo框架总结 A fast,scalable,distributed game server framework for Node.js 联系我 Pomelo交流群 @老顽童-NextZeus 微信群 BJ NodeJS Club @老顽童 适用场景 多人游戏：手游，社交游戏，网页游戏，MMORPG ,ARPG 实时应用：聊天，消息推送，等等 特点 高性能：基于Node.js...
Pomelo框架下的分布式游戏服务器模块化设计与性能优化
本文主要探讨了"基于Pomelo框架的分布式游戏服务器设计"这一主题，针对现代游戏服务器面临的高性能、易用性和可扩展性挑战，提出了一种创新的解决方案。首先，文章强调了模块化设计的重要性，通过将游戏服务器系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值