码迷,mamicode.com
首页 > 其他好文 > 详细

koa中间件分析

时间:2015-01-11 21:30:20      阅读:563      评论:0      收藏:0      [点我收藏+]

标签:

转载请注明: TheViper http://www.cnblogs.com/TheViper 

另外可以参考http://purplebamboo.github.io/2014/05/24/koa-source-analytics-3/,作者用简单的方式造了一个山寨koa.

koa是什么?

koa是从2013年11月开始发布,更新的。和express相比,koa太年轻了.但它(用文档上的话说)通过组合不同的 generator,可以免除重复繁琐的回调函数嵌套,并极大地提升常用错误处理效率。Koa 不在内核方法中绑定任何中间件,仅仅提供了一个轻量优雅的函数。

严格的说koa并不是完整的web框架,实际使用的时候,开发者根据自己的需要,需要用到其他的中间件。

koa只是提供了一种不同于connect的中间件解决方案,另外再加上一些对request,response的简单封装。这个看它的api就看的出来。比如,对请求/login?name=a&pwd=b,直接用koa的api,只能取url,query(name=a&pwd=b),它不像其他的框架,会进行进一步的封装,将请求的参数封装成键值形式。这时,需要用其他中间件如koa-bodyparser来完成。

还可能用到其他的中间件,具体参见https://github.com/koajs/koa/wiki,比如,

var path = require(‘path‘)
var route= require(‘koa-route‘);//路由
var koa = require(‘koa‘);
var gzip = require(‘koa-gzip‘);//gzip压缩
var staticCache = require(‘koa-static-cache‘);//在响应中添加对静态文件缓存的header
var json = require(‘koa-json‘);//返回json格式的响应
var bodyParser = require(‘koa-bodyparser‘);//解析请求参数
var app = koa();

var user_controller=require(‘./app/controllers/userController‘);

app.use(staticCache(path.join(__dirname, ‘public‘), {
  maxAge:24 * 60 * 60
}))
app.use(bodyParser());
app.use(gzip());
app.use(route.post(‘/login‘, new user_controller().login));
app.use(json({pretty: false}));

app.listen(8000);

下面分析koa中间件的实现。

使用方式

var koa = require(‘koa‘);
var app = koa();
//添加中间件1
app.use(function *(next){
  var start = new Date;
  console.log("start=======1111");
  yield next;
  console.log("end=======1111");
  var ms = new Date - start;
  console.log(‘%s %s - %s‘, this.method, this.url, ms);
});
//添加中间件2
app.use(function *(){
  console.log("start=======2222");
  this.body = ‘Hello World‘;
  console.log("end=======2222");
});

app.listen(3000);
/*
start=======1111
start=======2222
end=======2222
end=======1111
GET / - 10
start=======1111
start=======2222
end=======2222
end=======1111
GET /favicon.ico - 5
*/

app.use()来添加中间件。use函数接受一个generator function。这个generator function就是一个中间件。generator function有一个参数next。这个next是下一个中间件generator function的对应generator对象。yield next;调用下一个中间件的代码。具体的,

application.js

app.callback = function(){
  var mw = [respond].concat(this.middleware);
  var gen = compose(mw);
  var fn = co.wrap(gen);
  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).catch(ctx.onerror);
  }
};
app.listen = function(){
  debug(‘listen‘);
  var server = http.createServer(this.callback());
  return server.listen.apply(server, arguments);
};

listen()时,执行callback(),里面返回function(req,res)回调,然后是对node原生的监听listen().也就是说,上面代码相当于

var http = require("http");

http.createServer(function(request, response) {
    res.statusCode = 404;
    var ctx = self.createContext(req, res);
    onFinished(res, ctx.onerror);
    fn.call(ctx).catch(ctx.onerror);
}).listen(8888);

下面开始分析回调,

app.use = function(fn){
  assert(fn && ‘GeneratorFunction‘ == fn.constructor.name, ‘app.use() requires a generator function‘);
  debug(‘use %s‘, fn._name || fn.name || ‘-‘);
  this.middleware.push(fn);
  return this;
};

app.use只是把回调的generator function添加到middleware数组。注意,中间件必须是generator function。比如koa-json

module.exports = function(opts){
  。。。。。。。。。
  return function *filter(next){
    yield *next;
    。。。。。。。
  }
};

这也是编写中间件的格式。在启动文件中koa-json()返回generator function。

继续说callback()回调

app.callback = function(){
  var mw = [respond].concat(this.middleware);
  var gen = compose(mw);
  var fn = co.wrap(gen);
  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).catch(ctx.onerror);
  }
};

首先将response添加到middleware中间件数组中,response也被写出了generator function形式。注意数组中中间件的顺序,后面可以看到这样做的目的。然后compose(mw)用到了koa-compose模块。

function compose(middleware){
  return function *(next){
    var i = middleware.length;
    var prev = next || noop();
    var curr;

    while (i--) {
      curr = middleware[i];
      prev = curr.call(this, prev);
    }

    yield *prev;
  }
}

可以看到compose的作用就是向每个中间件的next参数,按照它们在数组中的顺序,传入下一个中间件的generator function,有点像链表。compose(mw)返回generator.

然后co.wrap(gen);,新点的koa用的是co 4.x,co 4.x基于promise,添加了wrap()方法,该方法是将generator function变成promise供co使用。

老点的koa如0.8.1,在这里是var fn = co(gen);

回调里面self.createContext(req, res);,将node原生的request,response传入koa,封装。

onFinished(res, ctx.onerror);,onFinished是当请求关闭,完成或出现错误时,专门封装的的模块,这里不作讨论。

fn.call(ctx).catch(ctx.onerror);,开始执行co(gen)()。

co分析中说到co内部有第一次的gen.next().后面异步操作成功后才会执行next(),但上面源码却找不到像next()的语句。为什么呢?

原因在于yield语句针对的对象。如果是yield generator function,那代码会单步进入,如果单步进入后仍然有yield generator function,继续单步进入。,无需用gen.next(),代码会自动单步进入。如果有yield非函数,比如yield ‘end‘,那相当于在那设置了一个断点,代码会暂时停在那。这时需要gen.next()才会继续执行下面的代码。

co分析中的例子因为里面有yield ‘start’,yield ‘end‘等语句,所以就需要多个gen.next()才能让程序执行完。

下面是一个全是yield generator function的例子,是把前面的改了一下

function* run1() {
console.log("step in child generator1")
console.log("step out child generator1")
}

function* run() {
console.log("step in child generator")
var b=yield *run1();
console.log("step out child generator")
}
function* start() {
  yield *run();
  return ‘over‘;
}
var it = start();
console.log(it.next());

结果

技术分享

可以看到只用了一个next()就将所有的generator function都执行完了。

明白了这个再重新看compose,它是从数组最后的中间件开始,只要遇到yield,就单步进入,因为所有中间件都是以generator function的形式存在的,所以只要有第一次next(),就会执行到底,也就是执行到没有yield next语句的中间件,然后又原路返回。具体的就像

技术分享

来源:http://purplebamboo.github.io/2014/05/24/koa-source-analytics-3/

注意compose()里面yield *prev,此时i=0,prev就是*response()。

function *respond(next) {
  yield *next;
  .............
}

可以看到yield *next在最前面,就会单步进入下一个中间件。..。后面的过程,上面的图说的很清楚。

不得不说,从compose到co,代码一点都不复杂,但组合起来,就是一个非常巧妙的设计!

koa中间件分析

标签:

原文地址:http://www.cnblogs.com/TheViper/p/4216003.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!