nodejs 实践：express 最佳实践，三 express 解析

nodejs 发展很快，从 npm 上面的包托管数量就可以看出来。不过从另一方面来看，也是反映了 nodejs 的基础不稳固，需要开发者创造大量的轮子来解决现实的问题。

知其然，并知其所以然这是程序员的天性。所以把常用的模块拿出来看看，看看高手怎么写的，学习其想法，让自己的技术能更近一步。

引言

前面一篇文章都已经研究过 express 3.x 中的核心框架 connect 的代码，这一阵来看看 express 3.x 和 express 4.x 的核心代码是怎样，特别关注两个部分：

1. express 3.x 中 connect 的使用。
2. express 4.x 中 的流程

解析

要使用 express 首先要明白几个概念：

• application (3.x)
• subApplication (3.x)
• router (3.x)
• middleware (3.x)
• route (3.x)
• layer (4.x)

首先 application 就是指的一个 express 实例，这个实例可以有自己环境变量等，而 subApplication 是指的 application 下面又会嵌套 一个 express 实例对像。

每一个 application 中都只有一个 router 路由对像，这个对像管理这个 application 下面有所有的 subApplication, middleware 和 route.

subApplication 不说了， middleware 的表现形式在 express 中有三种: fn(req, res, next)，fn(err, req, res, next), fn(req, res)。

第一种是正常的中间件：你对数据进行处理，然后调用 next 调用下一个中间件。

而第二种是错识中间件： 你出错口才调用它，而且必须是 四个参数，不能多也不能少。

第三种也是对数据进行处理，但是没有 next 说明数据到里结束。

route 就指的某个具体的路由，就是比如：get, post, delete, put, all等方法，这类方法能新建一个路由的对像。

layer 是 4.x 新出来的概念，这个也简单，就是方法的执行体。所谓的执行体，在 3.x中， subApplication 调用 handle,　route调用　handle，　middleware 调用自己，而在 4.x 中，这些都变成了 layer ，统一起来了。 请求来了， 就遍历 layer 看看哪个 layer匹配了路由，然后执行 layer.handle_request 方法。

上面说了这么多就是说 一个 application 就是由 subApplication, middleware, route 组成的， 这些才是真正的有执行体的地方， 下面说下， 这几个部分怎样加入到一个 application 中去的。

subApplication 加到入到 application 一般是调用 use 方法:

var userCenterApp = express()

var app = express()

app.use('/user', userCenterApp);

// app.use(subApplication);

在上面代码中， /user 是指的 子应用的 挂载点，可以理解成，这个子应用的所有的方法，都是在 /user 这个 url 之下执行的。

如果没有第一个参数， 那是个子应用的挂载点默认是 / 可以理解成根应用。

这其中，当子应用挂载成功到父应用上时，子应用会发出一个 mount 事件，express 会在默认情况下，把父应用的 settings, engines 等设置都拷过来。

  this.on('mount', function onmount(parent) {
    // inherit trust proxy
    if (this.settings[trustProxyDefaultSymbol] === true
      && typeof parent.settings['trust proxy fn'] === 'function') {
      delete this.settings['trust proxy'];
      delete this.settings['trust proxy fn'];
    }

    // inherit protos
    // 复制属性到 子 express 的 request 和 response 中去
    setPrototypeOf(this.request, parent.request)
    setPrototypeOf(this.response, parent.response)
    setPrototypeOf(this.engines, parent.engines)
    setPrototypeOf(this.settings, parent.settings)
  });

如果你需要子应用与父应用有不同的设置，可以监听这个事件，可以这样做:

var subApp = express();

subApp.on('mount', function(parent) {
  // dosomething
  delete parent.locals.settings; // 不继承父 App 的设置
  Object.assign(app.locals, parent.locals);
})

通常我们都不对 subApplication 进行设置，直接把父级 locals 变量直接合并过来。

middleWare 加入到 application 中也是使用 use 方法：

var app = express();

app.use(function(req, res, next) {
//正常使用
})

app.use(function(next, req, res, next) {
//错误处理
})

app.use(function(req, res) {
// 到此为止
})

app.use('/user', function(req, res, next) {
//针对　/user 下的所有请求都调用此处方法
})

一般来说　错误处理中间件都会放在所有的中间件的最后面，这会有两个处理中间件，一个是针对客户端不可知路由，一个是针对服务器错误。

app.all('*', function clientError(req, res, next) {
  res.rend('404');
})

app.use(function serverError(err, req, res, next) {
  res.rend('404);
})

router 加入到 application 中也是使用 use 方法:

var router = express.Router()

var app = express();

router.get('/app', fn);

app.use(router);　// 挂载到　根目录　/ 下
app.use('/user', router);　// 挂载到　/user 下

route　加入到 application 中有两种方法：app, router

// 通过 app 使用

// 这样使用
app.get('/user', fn1, fn2)
app.post('/user', fn3, fn4)
app.delet('/user', fn5, fn6)

// 也可以这样使用
var route = app.route('/user');

route.get(fn1, fn2)
     .post(fn3, fn4)
     .delete(fn5, fn6)

在 router 中，也可以这样使用:

var router = express.Router()

router.get('/user', fn1, fn2)
router.post('/user', fn3, fn4)

// 另一种写法
var route = router.route('/user')

route.get(fn1, fn2)
     .post(fn3, fn4)

前面 route 中的 fn*,其实也是中间件，遵守中间件的使用方法。

而 express 中核心的路由循环，就在 _router.handle 中，如下：

proto.handle = function handle(req, res, out) {
  var self = this;

  // some thing
  next();

  function next(err) {
    var layer;
    var match;
    var route;

    // 在这里每次请求会遍历所有下一个路由，直到 match 成功后，会跳出循环
    while (match !== true && idx < stack.length) {
      layer = stack[idx++];
      match = matchLayer(layer, path); // 这是核心方法
      route = layer.route;

      if (typeof match !== 'boolean') {
        // hold on to layerError
        layerError = layerError || match;
      }

      if (match !== true) {
        continue;
      }

      // 没有route 的 layer， 会匹配 match === true, 然后再下面再执行
      if (!route) {
        // process non-route handlers normally
        continue;
      }

      if (layerError) {
        // routes do not match with a pending error
        match = false;
        continue;
      }

      var method = req.method

      // 如果有路由，则看看有没有该方法如　get post　方法。
      var has_method = route._handles_method(method);


      // build up automatic options response
      if (!has_method && method === 'OPTIONS') {
        appendMethods(options, route._options());
      }

      // don't even bother matching route
      if (!has_method && method !== 'HEAD') {

        match = false;
        continue;
      }
    }

    // no match
    if (match !== true) {
      return done(layerError);
    }
    // store route for dispatch on change
    if (route) {
      req.route = route;
    }

    // this should be done for the layer
    self.process_params(layer, paramcalled, req, res, function (err) {
      if (err) {
        return next(layerError || err);
      }

      if (route) {
        return layer.handle_request(req, res, next);
      }
      //　移除多余的匹配
      trim_prefix(layer, layerError, layerPath, path);
    });
  }

  function trim_prefix(layer, layerError, layerPath, path) {

    // somenthing
    if (layerError) {
      layer.handle_error(layerError, req, res, next);
    } else {
      layer.handle_request(req, res, next);
    }
  }

流程就在，是否匹配路由，是否route中有方法，然后执行相应的方法上面。

调用流程： app() ===> app.handle ===> this._router.handle ===> if layer.match(path) ==> layer.handle_request

而 app.use 方法就是调用 _router.use 方法：

// app.use
 fns.forEach(function (fn) {
    // non-express app
    if (!fn || !fn.handle || !fn.set) { // 如果只是一个函数，直接加入到 route 中
      return router.use(path, fn);
    }

    // 下面针对的是一个子 express 的应用，就是指有 handle 的应用

    debug('.use app under %s', path);
    fn.mountpath = path;
    fn.parent = this;

    // restore .app property on req and res
    router.use(path, function mounted_app(req, res, next) { //对所有的第三方的请求进行处理
      var orig = req.app;
      fn.handle(req, res, function (err) {
        setPrototypeOf(req, orig.request) // 这里每次都把属性复制过来，就是怕第三方的把属性给改了，之后让框架崩溃
        setPrototypeOf(res, orig.response)
        next(err);
      });
    });

router.use 方法

proto.use = function use(fn) {
  var offset = 0;
  var path = '/';

  var callbacks = flatten(slice.call(arguments, offset));

  for (var i = 0; i < callbacks.length; i++) {
    var fn = callbacks[i];

    var layer = new Layer(path, {
      sensitive: this.caseSensitive,
      strict: false,
      end: false
    }, fn);

    layer.route = undefined; // 这个layer是没有路由的

    this.stack.push(layer);
  }

  return this;
};

总结

把 express 中的 middleware， application, router, route 概念弄清楚了，express 的用法也就清楚了。

另外，我在解析 express 代码时，也运行了 express 的代码， 同时打断点进行调试，并且在关键的地方也有注释，如果有需要，也可以从这个地址进行下查看：

study-express

看代码主要是弄清楚具体的流程，和实现思想，给自己的架构添加想法。

下一篇要讲讲，express 中的最佳实践，包括项目规划， 目录结构，中间件使用，错误中间件，promise,co,await/await,限流，重写，子域名等。