egg的生命周期是怎样触发的?

　　以前在对egg进行换壳tcp时，看到加载了各种配置，到触发生命周期方法。然而改完过了几个月就忘记了，还是记录一下吧，以免下次忘记的时候翻翻。

 　　egg在load了plugin、config、extend后，最后会有一个loadCustomAgent(loadCustomApp)方法，很关键的一个方法，主要是用来启动app.js里的configWillLoad、configDidLoad、willReady等一系列生命周期方法。

　　以Agent为例，在初始化Agent实例的时候，会实例化一个Lifecycle实例，Lifecycle又实例化两个Ready实例：

get-ready就像一个搅局者，混进了各个类里面，为类注入ready方法。还有ready-callback实属是对get-ready的封装（这肯定是阿里的人写的。一看npm，果然!）

前期准备做好后，开始：

// egg-core/lib/loader/mixin/custom.js

loadCustomAgent() {
    this[LOAD_BOOT_HOOK]('agent');
    this.lifecycle.triggerConfigWillLoad();
  },

this[LOAD_BOOT_HOOK]在各个加载路径下找到agent.js，并把导出对象加在lifecycle的 this[BOOT_HOOKS] = []里，伪代码：

const agentObj = require('xxx/agent.js');
lifecycle.boot_hooks.push(agentObj);


// 假设agent.js如以下内容
'use strict';
class AppBootHook {
  constructor(app) {
    this.app = app;
  }
  configWillLoad() {}

  async didLoad() {}

  async willReady() {}

  async didReady() {}

  async serverDidReady() {}
}
module.exports = AppBootHook;

push进来之后，再调用lifecycle.init()，新建一个个agent实例，保存在lifecycle.boots数组：

// egg-core/lib/lifecycle.js
init() {
    assert(this[INIT] === false, 'lifecycle have been init');
    this[INIT] = true;
    this[BOOTS] = this[BOOT_HOOKS].map(t => new t(this.app));
  }

最后，终于触发 this.lifecycle.triggerConfigWillLoad()，同步调用configWillLoad、configDidLoad方法:

// egg-core/lib/lifecycle.js

triggerConfigWillLoad() {
    for (const boot of this[BOOTS]) {
      if (boot.configWillLoad) {
        boot.configWillLoad();
      }
    }
    this.triggerConfigDidLoad();
  }

关键来了，上一步触发了configDidLoad，接下来触发didLoad方法，代码是这样的：

// egg-core/lib/lifecycle.js

  triggerDidLoad() {
    debug('register didLoad');
    for (const boot of this[BOOTS]) {
      const didLoad = boot.didLoad && boot.didLoad.bind(boot);
      if (didLoad) {
        this[REGISTER_READY_CALLBACK]({
          scope: didLoad,
          ready: this.loadReady,
          timingKeyPrefix: 'Did Load',
          scopeFullName: boot.fullPath + ':didLoad',
        });
      }
    }
  }

boot.fullPath是该agent.js的全路径；

再到REGISTER_READY_CALLBACK方法：

// egg-core/lib/lifecycle.js

  [REGISTER_READY_CALLBACK]({ scope, ready, timingKeyPrefix, scopeFullName }) {

    const done = ready.readyCallback(scopeFullName);
    process.nextTick(() => {
      utils.callFn(scope).then(() => {
        done();
      }, err => {
        done(err);
      });
    });
  }

调用了loadReady.readyCallBack方法，传入一个全路径标识符，去ready-callback找吧：

// ready-callback/lib/ready.js

  readyCallback(name, opt) {

    opt = Object.assign({}, defaults, this.opt, opt);
    const cacheKey = uuid.v1();
    opt.name = name || cacheKey;
    const timer = setTimeout(() => this.emit('ready_timeout', opt.name), opt.timeout);
    
    const cb = once(err => {
      if (err != null && !(err instanceof Error)) {
        err = new Error(err);
      }
      clearTimeout(timer);
      // won't continue to fire after it's error
      if (this.isError === true) return;
      // fire callback after all register
      setImmediate(() => this.readyDone(cacheKey, opt, err));
    });
    
    debug('[%s] Register task id `%s` with %j', cacheKey, opt.name, opt);
    cb.id = opt.name;
    this.cache.set(cacheKey, cb);
    return cb;
  }

只传入了一个路径标识，没有传函数执行体，所以这个函数肯定是用来控制流程的。来了个once模块，传入回调，搭配wrappy模块，作用是保证只执行一次传入的回调。

返回后，注册process.nextTick microtask:

// egg-core/lib/lifecycle.js

  [REGISTER_READY_CALLBACK]({ scope, ready, timingKeyPrefix, scopeFullName }) {

    const done = ready.readyCallback(scopeFullName);
    process.nextTick(() => {
      utils.callFn(scope).then(() => {
        done();
      }, err => {
        done(err);
      });
    });
  }

此时，同步代码执行完毕，事件循环转到下一阶段，开始执行process.nextTick的任务，里面的任务就是didLoad方法，didLoad是异步方法，执行完成didLoad方法，再执行done，done就是上面的传入once的方法体：

// ready-callback/lib/ready.js    

        const cb = once(err => {
      if (err != null && !(err instanceof Error)) {
        err = new Error(err);
      }
      clearTimeout(timer);
      // won't continue to fire after it's error
      if (this.isError === true) return;
      // fire callback after all register
      setImmediate(() => this.readyDone(cacheKey, opt, err));
    });

再次异步调用readyDone方法：

// ready-callback/lib/ready.js

  readyDone(id, opt, err) {
    this.cache.delete(id);

    this.emit('ready_stat', {
      id: opt.name,
      remain: getRemain(this.cache),
    });

    if (this.cache.size === 0) {
      this.ready(true);
    }
    return this;
  }

如果发现此时，已经没有didLoad方法了，即this.cache.size === 0，就触发ready方法，而在lifecycle里，实例化loadReady时，早就注册了ready方法：

// egg-core/lib/lifecycle.js
    this.loadReady.ready(err => {
      debug('didLoad done');
      if (err) {
        this.ready(err);
      } else {
        this.triggerWillReady();
      }
    });

此时，ready方法触发，执行域是在ilfecycle，调用triggerWillReady方法，继续往下走生命周期方法，这样就串起来了。

总结来说，egg同阶段的生命周期方法都是异步调用（通过process.nextTick调用），只有等最后那个异步方法调用完成，才触发下一个阶段。

其实可以做的更简单直观点，相当于各个模块之间dependency，执行有个先后顺序。