本文原创，转载请注明出处https://i.cnblogs.com/EditPosts.aspx?postid=5710639
我们大家都知道，当koa接到请求经过中间件时，当执行到 yield next 语句时，Koa 暂停了该中间件，继续执行下一个符合请求的中间件('downstrem')，然后控制权再逐级返回给上层中间件('upstream')。我们下面分析其原理。
一、中间件级联
当我们使用app.use()注册中间件时，它只是将各个中间件压进一个队列，但是这些中间件又是怎么级联的呢？
/**
* Expose compositor.
*/ module.exports = compose; /**
* Compose `middleware` returning
* a fully valid middleware comprised
* of all those which are passed.
*
* @param {Array} middleware
* @return {Function}
* @api public
*/
/**
* middleware为中间件数组
* compose函数将中间件数组中的中间件级联起来
*/
function compose(middleware){
return function *(next){
//noop()返回一个空的generator对象
if (!next) next = noop(); var i = middleware.length;
// 将后一个中间件generator对象当做参数传递给前一个中间件
// 最后next为第一个generator对象
while (i--) {
next = middleware[i].call(this, next);
}
// 最后用yield*将next generator对象引进来
return yield *next;
}
} /**
* Noop.
*
* @api private
*/ function *noop(){}
看了上述代码和注释大家应该明白了，原来koa中的中间件是通过generator对象参数传递的方式级联的。下面我们研究他们的执行过程。
二、执行过程
1.大致过程
// 创建server并监听端口
app.listen = function(){
debug('listen');
var server = http.createServer(this.callback());
return server.listen.apply(server, arguments);
}; app.callback = function(){
if (this.experimental) {
console.error('Experimental ES7 Async Function support is deprecated. Please look into Koa v2 as the middleware signature has changed.')
}
var fn = this.experimental
? compose_es7(this.middleware)
: co.wrap(compose(this.middleware));//这里就是我们上面讲的compose()函数
var self = this; if (!this.listeners('error').length) this.on('error', this.onerror); return function(req, res){
res.statusCode = 404;
var ctx = self.createContext(req, res);
onFinished(res, ctx.onerror);
fn.call(ctx).then(function () {
respond.call(ctx);
}).catch(ctx.onerror);
}
};
2.co.wrap()
co.wrap = function (fn) {
createPromise.__generatorFunction__ = fn;
return createPromise;
function createPromise() {
return co.call(this, fn.apply(this, arguments));
}
};
这里相当于调用了co()方法，把我们之前的compose()函数返回的结果函数作为参数传给了它。
3.co()——逆向执行关键
/**
* slice() reference.
*/ var slice = Array.prototype.slice; /**
* Expose `co`.
*/ module.exports = co['default'] = co.co = co; /**
* Wrap the given generator `fn` into a
* function that returns a promise.
* This is a separate function so that
* every `co()` call doesn't create a new,
* unnecessary closure.
*
* @param {GeneratorFunction} fn
* @return {Function}
* @api public
*/ co.wrap = function (fn) {
createPromise.__generatorFunction__ = fn;
return createPromise;
function createPromise() {
return co.call(this, fn.apply(this, arguments));
}
}; /**
* Execute the generator function or a generator
* and return a promise.
*
* @param {Function} fn
* @return {Promise}
* @api public
*/ function co(gen) {
var ctx = this;
var args = slice.call(arguments, 1); // we wrap everything in a promise to avoid promise chaining,
// which leads to memory leak errors.
// see https://github.com/tj/co/issues/180
//返回promise
return new Promise(function(resolve, reject) {
if (typeof gen === 'function') gen = gen.apply(ctx, args);
if (!gen || typeof gen.next !== 'function') return resolve(gen); onFulfilled(); /**
* @param {Mixed} res
* @return {Promise}
* @api private
*/ // promise成功时调用
// 调用resolve()时执行
function onFulfilled(res) {
var ret;
try {
// 调用gen.next，到达一个yield
ret = gen.next(res);
} catch (e) {
return reject(e);
}
// 将gen.next()返回值传入next()函数
next(ret);
return null;
} /**
* @param {Error} err
* @return {Promise}
* @api private
*/ function onRejected(err) {
var ret;
try {
ret = gen.throw(err);
} catch (e) {
return reject(e);
}
next(ret);
} /**
* Get the next value in the generator,
* return a promise.
*
* @param {Object} ret
* @return {Promise}
* @api private
*/ function next(ret) {
// 如果generator函数执行完毕，调用resolve，执行上述fullfilled函数
// 并将ret.value传入
if (ret.done) return resolve(ret.value);
// 将ret.value转换成promise
// 转换函数在下面
var value = toPromise.call(ctx, ret.value);
// 监听promise的成功/失败
if (value && isPromise(value)) return value.then(onFulfilled, onRejected);
return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, '
+ 'but the following object was passed: "' + String(ret.value) + '"'));
}
});
} /**
* Convert a `yield`ed value into a promise.
*
* @param {Mixed} obj
* @return {Promise}
* @api private
*/ function toPromise(obj) {
if (!obj) return obj;
if (isPromise(obj)) return obj;
if (isGeneratorFunction(obj) || isGenerator(obj)) return co.call(this, obj);
if ('function' == typeof obj) return thunkToPromise.call(this, obj);
if (Array.isArray(obj)) return arrayToPromise.call(this, obj);
if (isObject(obj)) return objectToPromise.call(this, obj);
return obj;
} /**
* Convert a thunk to a promise.
*
* @param {Function}
* @return {Promise}
* @api private
*/ function thunkToPromise(fn) {
var ctx = this;
return new Promise(function (resolve, reject) {
fn.call(ctx, function (err, res) {
if (err) return reject(err);
if (arguments.length > 2) res = slice.call(arguments, 1);
resolve(res);
});
});
} /**
* Convert an array of "yieldables" to a promise.
* Uses `Promise.all()` internally.
*
* @param {Array} obj
* @return {Promise}
* @api private
*/ function arrayToPromise(obj) {
return Promise.all(obj.map(toPromise, this));
} /**
* Convert an object of "yieldables" to a promise.
* Uses `Promise.all()` internally.
*
* @param {Object} obj
* @return {Promise}
* @api private
*/ function objectToPromise(obj){
var results = new obj.constructor();
var keys = Object.keys(obj);
var promises = [];
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var promise = toPromise.call(this, obj[key]);
if (promise && isPromise(promise)) defer(promise, key);
else results[key] = obj[key];
}
return Promise.all(promises).then(function () {
return results;
}); function defer(promise, key) {
// predefine the key in the result
results[key] = undefined;
promises.push(promise.then(function (res) {
results[key] = res;
}));
}
} /**
* Check if `obj` is a promise.
*
* @param {Object} obj
* @return {Boolean}
* @api private
*/ function isPromise(obj) {
return 'function' == typeof obj.then;
} /**
* Check if `obj` is a generator.
*
* @param {Mixed} obj
* @return {Boolean}
* @api private
*/ function isGenerator(obj) {
return 'function' == typeof obj.next && 'function' == typeof obj.throw;
} /**
* Check if `obj` is a generator function.
*
* @param {Mixed} obj
* @return {Boolean}
* @api private
*/ function isGeneratorFunction(obj) {
var constructor = obj.constructor;
if (!constructor) return false;
if ('GeneratorFunction' === constructor.name || 'GeneratorFunction' === constructor.displayName) return true;
return isGenerator(constructor.prototype);
} /**
* Check for plain object.
*
* @param {Mixed} val
* @return {Boolean}
* @api private
*/ function isObject(val) {
return Object == val.constructor;
}
注意，我们在写每个中间件时，实际都有yield next；onFulfilled这个函数只在两种情况下被调用，一种是调用co的时候执行，还有一种是当前promise中的所有逻辑都执行完毕后执行
这里我们传入的fn是一个generator对象，根据上述转换函数，将会继续调用co()函数，执行next()时，我们传入的参数ret.val是下一个中间件的generator对象，所以继续调用co()函数，如此递归的执行下去；当到最后一个中间件时，执行完成后，ret.done==true，会再次调用resolve，返回到上一层中间件。
这个过程其实就是递归调用的过程。