connect和express出自同一作者TJ Holowaychuk。从依赖性看，express基于connect；但从2个项目的git提交历史来看，实际上先有express项目（2009-6-27），2010-5-27 前后connect从express项目分化出来（express 0.12.0）。所以两者有相同的中间件机制，不同的是express拥有子路由、view模板等web应用框架内容。

Connect Usage

  1. var connect = require('connect');
  2. var app = connect();
  4. // gzip/deflate outgoing responses
  5. var compression = require('compression');
  6. app.use(compression());
  8. // store session state in browser cookie
  9. var cookieSession = require('cookie-session');
  10. app.use(cookieSession({
  11.     keys: ['secret1', 'secret2']
  12. }));
  14. // parse urlencoded request bodies into req.body
  15. var bodyParser = require('body-parser');
  16. app.use(bodyParser.urlencoded({extended: false}));
  18. // respond to all requests
  19. app.use(function(req, res){
  20.   res.end('Hello from Connect!\n');
  21. });
  23. //create node.js http server and listen on port
  24. app.listen(3000);


源码解析

源码非常简单，尾递归调用。next 方法不断的取出stack中的“中间件”函数进行调用，同时把next 本身传递给“中间件”作为第三个参数，每个中间件约定的固定形式为 (req, res, next) => {}, 这样每个“中间件“函数中只要调用 next 方法即可传递调用下一个中间件。
之所以说是”尾递归“是因为递归函数的最后一条语句是调用函数本身，所以每一个中间件的最后一条语句需要是next()才能形成”尾递归“，否则就是普通递归，”尾递归“相对于普通”递归“的好处在于节省内存空间，不会形成深度嵌套的函数调用栈。尾调用优化(opens new window)
增加中间件：

  1. module.exports = createServer;
  3. function createServer() {
  4.   function app(req, res, next){
  5.       app.handle(req, res, next); // 执行中间件
  6.     }
  7.   merge(app, proto);
  8.   merge(app, EventEmitter.prototype);
  9.   app.route = '/';
  10.   app.stack = [];
  11.   return app;
  12. }
  14. // 增加中间件
  15. proto.use = function use(route, fn) {
  16.   var handle = fn;
  17.   var path = route;
  19.   // 核心就这一句，往数组中增加一项
  20.   this.stack.push({ route: path, handle: handle });
  21.   return this;
  22. };

处理中间件：

  1. proto.handle = function handle(req, res, out) {
  2.   var index = 0;
  3.   var protohost = getProtohost(req.url) || '';
  4.   var removed = '';
  5.   var slashAdded = false;
  6.   var stack = this.stack;
  8.   // final function handler
  9.   var done = out || finalhandler(req, res, {
  10.     env: env,
  11.     onerror: logerror
  12.   });
  14.   // store the original URL
  15.   req.originalUrl = req.originalUrl || req.url;
  17.   function next(err) {
  18.     if (slashAdded) {
  19.       req.url = req.url.substr(1);
  20.       slashAdded = false;
  21.     }
  23.     if (removed.length !== 0) {
  24.       req.url = protohost + removed + req.url.substr(protohost.length);
  25.       removed = '';
  26.     }
  28.      // 遍历stack，拿到下一个layer
  29.     var layer = stack[index++];
  31.     // all done
  32.     if (!layer) {
  33.       defer(done, err);
  34.       return;
  35.     }
  37.     // route data
  38.     var path = parseUrl(req).pathname || '/';
  39.     var route = layer.route;
  41.     // 错误处理
  42.     // skip this layer if the route doesn't match
  43.     if (path.toLowerCase().substr(0, route.length) !== route.toLowerCase()) {
  44.       return next(err);
  45.     }
  46.     // skip if route match does not border "/", ".", or end
  47.     var c = path.length > route.length && path[route.length];
  48.     if (c && c !== '/' && c !== '.') {
  49.       return next(err);
  50.     }
  52.     // trim off the part of the url that matches the route
  53.     if (route.length !== 0 && route !== '/') {
  54.       removed = route;
  55.       req.url = protohost + req.url.substr(protohost.length + removed.length);
  57.       // ensure leading slash
  58.       if (!protohost && req.url[0] !== '/') {
  59.         req.url = '/' + req.url;
  60.         slashAdded = true;
  61.       }
  62.     }
  64.     // 匹配到layer，执行handle函数
  65.     call(layer.handle, route, err, req, res, next);
  66.   }
  68.   next(); // 开始next
  69. };
  71. function call(handle, route, err, req, res, next) {
  72.   var arity = handle.length;
  73.   var error = err;
  74.   var hasError = Boolean(err);
  76.   try {
  77.     if (hasError && arity === 4) {
  78.       handle(err, req, res, next); // 处理错误next
  79.       return;
  80.     } else if (!hasError && arity < 4) {
  81.       // 执行handle函数。
  82.       // next函数是其参数，如果要传递下一个，执行next函数
  83.       handle(req, res, next);
  84.       return;
  85.     }
  86.   } catch (e) {
  87.     error = e;
  88.   }
  90.   // 继续next
  91.   next(error);
  92. }