作者:shihuaping0918@163.com，转载请注明作者
以https://github.com/NetEase/chatofpomelo/tree/master/game-server服务器为例子来说明配置读取是怎么完成的，chatofpomelo是pomelo做为聊天服务器的例子。它的入口点是app.js。代码内容如下：
var pomelo = require('pomelo');
var routeUtil = require('./app/util/routeUtil');
/**
* Init app for client.
*/
var app = pomelo.createApp();
//这一行也关注一下
app.set('name', 'chatofpomelo');
// 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);
});
从代码中看，都是通过app.set添加配置——这是pomelo比较不同的地方，常见的配置都是分成多个文件，然后通过include方式集中到一个文件。或者就只有一个文件。但是pomelo的配置可以零散的这配一点，那配一点。app.set这个函数的定义在application.js里面，内容如下:
/**
* Assign `setting` to `val`, or return `setting`'s value.
*
* Example:
*
* app.set('key1', 'value1');
* app.get('key1'); // 'value1'
* app.key1; // undefined
*
* app.set('key2', 'value2', true);
* app.get('key2'); // 'value2'
* app.key2; // 'value2'
*
* @param {String} setting the setting of application
* @param {String} val the setting's value
* @param {Boolean} attach whether attach the settings to application
* @return {Server|Mixed} for chaining, or the setting value
* @memberOf Application
*/
Application.set = function (setting, val, attach) {
if (arguments.length === 1) {
return this.settings[setting];
}
this.settings[setting] = val;
if(attach) {
this[setting] = val;
}
return this;
};
这个函数的注释写得是非常 的详细了，相对我前面刚分析的那些c代码来说，那些代码是基本没注释。从代码中可以看出来，实际上是把配置加到了settings里去了。settings的初始化是setttings={}，也就是初始是个空对象。
到这里配置的设置就分析完了，pomelo就是这么简单直接。配置的key是connectorConfig，value是一个js对象。下面看一下它是在哪里读取的。它一定是在Application.start里面读取的。
/**
* Start application. It would load the default components and start all the loaded components.
*
* @param {Function} cb callback function
* @memberOf Application
*/
Application.start = function(cb) {
this.startTime = Date.now();
if(this.state > STATE_INITED) {
utils.invokeCallback(cb, new Error('application has already start.'));
return;
}
var self = this;
appUtil.startByType(self, function() { // 先调startByType
appUtil.loadDefaultComponents(self); //然后startByType回调从这开始
var startUp = function() {
appUtil.optComponents(self.loaded, Constants.RESERVED.START, function(err) {
self.state = STATE_START;
if(err) {
utils.invokeCallback(cb, err);
} else {
logger.info('%j enter after start...', self.getServerId());
self.afterStart(cb);
}
});
};
var beforeFun = self.lifecycleCbs[Constants.LIFECYCLE.BEFORE_STARTUP];
if(!!beforeFun) {
beforeFun.call(null, self, startUp);
} else {
startUp();
}
});
};
appUtil.startByType这一篇不涉及，就直接看回调了，回调第一行就是appUtil.loadDefaultComponents，这个函数会去读设置。但是这个函数有个非常不好的行为，就是字符常量基本都是硬编码，也就是大家常说的，在代码里写死。如果不来看代码，谁也不知道这个配置就一定是要叫这个名字。
/**
* Load default components for application.
*/
module.exports.loadDefaultComponents = function(app) {
var pomelo = require('../pomelo');
// load system default components
if (app.serverType === Constants.RESERVED.MASTER) {
app.load(pomelo.master, app.get('masterConfig'));
} else {
app.load(pomelo.proxy, app.get('proxyConfig'));
if (app.getCurServer().port) {
app.load(pomelo.remote, app.get('remoteConfig'));
}
if (app.isFrontend()) {
app.load(pomelo.connection, app.get('connectionConfig'));
//就是它，在这里被加载了
app.load(pomelo.connector, app.get('connectorConfig'));
app.load(pomelo.session, app.get('sessionConfig'));
// compatible for schedulerConfig
if(app.get('schedulerConfig')) {
app.load(pomelo.pushScheduler, app.get('schedulerConfig'));
} else {
app.load(pomelo.pushScheduler, app.get('pushSchedulerConfig'));
}
}
app.load(pomelo.backendSession, app.get('backendSessionConfig'));
app.load(pomelo.channel, app.get('channelConfig'));
app.load(pomelo.server, app.get('serverConfig'));
}
app.load(pomelo.monitor, app.get('monitorConfig'));
};
分析到这里还没完成，因为只分析到了配置被读出来，读出来以后的行为还没有分析到。也就是说这个配置到底用来干什么？这就要看app.load了。app.load第一个参数叫pomelo.connector，这个东西实际上是用__defineGetter__来做了一次函数的封装，它实际上是一个函数。__defineGetter__不是标准里面的。
/**
* Load component
*
* @param {String} name (optional) name of the component
* @param {Object} component component instance or factory function of the component
* @param {[type]} opts (optional) construct parameters for the factory function
* @return {Object} app instance for chain invoke
* @memberOf Application
*/
Application.load = function(name, component, opts) {
if(typeof name !== 'string') { //name是函数
opts = component; //参数移位
component = name; //参数移位
name = null;
if(typeof component.name === 'string') {
name = component.name;
}
}
if(typeof component === 'function') { //移位后component是函数
component = component(this, opts);
}
if(!name && typeof component.name === 'string') {
name = component.name;
}
if(name && this.components[name]) {
// ignore duplicat component
logger.warn('ignore duplicate component: %j', name);
return;
}
this.loaded.push(component);
if(name) {
// components with a name would get by name throught app.components later.
this.components[name] = component;
}
return this;
};
所以在load这个函数里，name传进来实际是个函数，对这个函数做调用，把opts作为参数传进去。这样就实现了模块的加载。
以pomelo.connector为例解释一下模块加载的过程，上面讲到了pomelo.connector实际上是函数，这是怎么实现的呢？首先到pomelo.js里去搜索，肯定是找不到.connector的。因为它是通过下面这几行代码添加进去的。在components目录下有一个文件叫connector.js
/**
* Auto-load bundled components with getters.
*/
fs.readdirSync(__dirname + '/components').forEach(function (filename) {
if (!/\.js$/.test(filename)) {
return;
}
//对于connector.js，返回connector
var name = path.basename(filename, '.js');
//这个bind下面再讲
var _load = load.bind(null, './components/', name);
Pomelo.components.__defineGetter__(name, _load);
//看这里，__defineGetter__设置了，当访问pomelo.getter的时候，
//调_load函数
Pomelo.__defineGetter__(name, _load);
});
从代码中可以看出来，当pomelo.connector被访问时，会被调用一个_load函数。
下面再来看看这个load函数做了什么？load函数实际上是执行了require，加载模块。
function load(path, name) {
if (name) {
return require(path + name);
}
return require(path);
}
但是_load呢，是load.bind的结果。实际是把this指针设为null了。
bind的说明:https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/bind
这里的require会返回一个函数，require('connector')会返回函数。看代码吧，conpoment/connector.js里有一句话。
module.exports = function(app, opts) {
return new Component(app, opts);
};
这个函数才是app.load真正调用的函数，也就是pomelo.connector返回的值，也就是require返回的值。
所以app.load(pomelo.connector, app.get('connectorConfig'));这行代码实际上是加载component/connector模块，然后执行模块exports的函数，将配置传进去，从而创建component。这个过程我是觉得已经讲得很详细了，各位观众能不能理解就不好说了。
