.8-浅析express源码之请求处理流程(1)
这一节就讲从一个请求到来，express内部是如何将其转交给合适的路由，路由又是如何调用中间件的。
以express-generator为例，关键代码如下：
// app.js
app.use('/', indexRouter);
app.use('/users', usersRouter);
// indexRouter
router.get('/', function(req, res, next) {
console.log('first middleware');
next();
},(req,res,next)=>{
res.render('index', { title: 'Express' });
});
// usersRouter
router.get('/', function(req, res, next) {
res.send('respond with a resource');
});
在两个路由的JS中，两次router.get调用会分别生成2个path层级的layer对象，中间件函数为内部方法route.dispatch，push进了router的stack数组中，并挂载了2个route对象。而这两个route对象根据后面的中间件函数数量又独立生成了对应的内部layer，仅处理中间件函数，同时push到了route的stack中。
在最外层的app.js中，调用app.use，传入挂载路径与返回的router对象，由于router对象没有set方法，不是express应用，所以直接走的router.use方法。在use方法里，生成了两个Layer对象，路径为app.use的第一个参数，fn为返回的router函数对象。
最最后，2个Layer对象会被push进app的内部独立router对象中。示意图如下：
提前简单说一下涉及的四个模块app、router、layer、route。
1、app => 主要负责全局配置参数读取，所有的方法最终都会指向后面的工具模块，本身不做事
2、router => 所有app应用内部会有一个默认的router对象，该router对象上stack数组中的Layer主要根据路径把请求分发给处理对应路径的自定义router。而自定义的router上layer对象也不会直接处理请求，而是再次根据路径把请求分发给对应的route对象。route对象会遍历stack数组，依次取出layer调用中间件处理请求。
3、layer => 请求分发对象，虽然说3个参数分别为路径、配置参数、处理函数，但是在实际情况中只会单独处理一件事。
4、route => 最底层的对象，负责处理请求。
这时候，假设有一个'/'根路径的get请求过来了。
app.handle
入口函数就是第一节就见过，但是一直没有管的app.hanle：
function createApplication() {
var app = function(req, res, next) {
app.handle(req, res, next);
};
// mixin && init
return app;
}
app.handle = function handle(req, res, callback) {
var router = this._router;
// 单app应用时为默认的finalhandler
var done = callback || finalhandler(req, res, {
env: this.get('env'),
onerror: logerror.bind(this)
});
// no routes
if (!router) {
debug('no routes defined on app');
done();
return;
}
router.handle(req, res, done);
};
这里假设只有一个app应用，请求进来后封装了一个默认的callback，然后调用了router模块的handle方法。
router.handle
这个函数太长了，分几段来说吧。
proto.handle = function handle(req, res, out) {
var self = this;
debug('dispatching %s %s', req.method, req.url);
var idx = 0;
// 获取请求地址的protocol + host
var protohost = getProtohost(req.url) || ''
var removed = '';
// 标记斜杠
var slashAdded = false;
var paramcalled = {};
// 应付OPTIONS方式的请求
var options = [];
// 获取本地的layer数组
var stack = self.stack;
// manage inter-router variables
var parentParams = req.params;
var parentUrl = req.baseUrl || '';
var done = restore(out, req, 'baseUrl', 'next', 'params');
// 挂载next方法
req.next = next;
// options请求的默认返回
if (req.method === 'OPTIONS') {
done = wrap(done, function(old, err) {
if (err || options.length === 0) return old(err);
sendOptionsResponse(res, options, old);
});
}
// setup basic req values
req.baseUrl = parentUrl;
req.originalUrl = req.originalUrl || req.url;
// next()...
}
函数在最开始还是整理参数，这里的restore没看懂具体作用，暂时跳过这里。
总结来说第一部分做了以下事情：
1、获取协议+基本地址的字符串
2、获取stack数组，里面装的是layer对象
3、定义标记变量
4、对OPTIONS请求做特殊处理
5、done方法是所有layer跑完后的最终回调，此时需要还原url
对于OPTIONS方式的请求，若没有做特殊处理，则会返回一个默认的响应。而在servlet中，则有一个特殊的doOptions的方法专门来设置Allow请求头响应，感觉差不多。
接下来调用一个next方法，该方法会被挂载到req上面，这是第一次调用：
proto.handle = function handle(req, res, out) {
// ...
next();
function next(err) {
// next('route')不会被当成错误
var layerError = err === 'route' ?
null :
err;
// 去掉斜杠
if (slashAdded) {
req.url = req.url.substr(1);
slashAdded = false;
}
// 还原被更改的req.url
if (removed.length !== 0) {
req.baseUrl = parentUrl;
req.url = protohost + removed + req.url.substr(protohost.length);
removed = '';
}
// 退出路由的信号
if (layerError === 'router') {
setImmediate(done, null)
return
}
// 所有的layer都遍历完毕
if (idx >= stack.length) {
setImmediate(done, layerError);
return;
}
// 获取请求的pathname
var path = getPathname(req);
if (path == null) {
return done(layerError);
}
// 寻找下一个匹配的layer
var layer;
var match;
var route;
// ...more code
}
// ...
}
这一部分主要做了下列事情：
1、判断是否有err定义layerError变量，其中next('route')会被忽略
2、根据slashAdded变量决定是否需要切割一下url，还原完整的url（二级路由匹配）
3、除了route，router字符串似乎在next中也有特殊意义？
下面开始真正的匹配layer，如下：
while (match !== true && idx < stack.length) {
// 取出一个layer
layer = stack[idx++];
// 检测layer是否匹配该路径
match = matchLayer(layer, path);
route = layer.route;
// ...
}
这里涉及到了Layer对象的原型方法，matchLayer(layer, path)实际上就是layer.match(path)。
以假设条件看一下match的匹配过程：
// app.use('/',indexRouter)满足fast_slash条件
Layer.prototype.match = function match(path) {
var match
if (path != null) {
// layer匹配路径为/时 匹配所有
if (this.regexp.fast_slash) {
this.params = {}
this.path = ''
return true
}
// layer匹配路径为*时 匹配所有:param
// 调用decodeURIComponent转义path
if (this.regexp.fast_star) {
this.params = { '0': decode_param(path) }
this.path = path
return true
}
// 用生成的正则解析
match = this.regexp.exec(path)
}
// 路径不匹配 返回false
if (!match) {
this.params = undefined;
this.path = undefined;
return false;
}
// 其余情况下匹配的路径
// 后面讨论...
return true;
}
由于假设请求路径为'/'，所以这里会跳过match阶段，直接返回true。
继续看代码：
while (match !== true && idx < stack.length) {
// 取出一个layer
layer = stack[idx++];
match = matchLayer(layer, path);
route = layer.route;
// 报错
if (typeof match !== 'boolean') layerError = layerError || match;
// Layer未匹配
if (match !== true) continue;
// app内部router对象的layer不存在route
if (!route) continue;
// 处理错误
if (layerError) {
// routes do not match with a pending error
match = false;
continue;
}
// ...处理外部router对象上的layer
}
需要注意的是，这里的匹配是对app的内部路由上的Layer进行遍历，而这些layer是没有route对象挂载的，仅仅是用来分发外部路由，因此这里会continue直接跳过后面的流程。
由于已经匹配到对应的Layer，所以while循环跳出，继续下面的流程：
// 根据配置参数处理参数合并
req.params = self.mergeParams ?
mergeParams(layer.params, parentParams) :
layer.params;
// 获取layer匹配的path => ''
var layerPath = layer.path;
// this should be done for the layer
self.process_params(layer, paramcalled, req, res, function(err) {
// ...trim_prefix(layer, layerError, layerPath, path)
});
在生成路由会有一个合并参数的选项，决定是否将父路由的参数合并到子路由，默认为false。
接下来获取layer匹配的path后，调用了另外一个方法，而这个方法主要是处理/path:prarms这种形式的参数，所以跳过。
而回调的trim_prefix函数内容也直接跳过，后面讲，直接进入layer.handle_request函数：
Layer.prototype.handle_request = function handle(req, res, next) {
// 这里的handle是router函数对象
var fn = this.handle;
// 错误处理中间件有4个参数
if (fn.length > 3) {
return next();
}
// 调用具体外部路由的handle方法
try {
fn(req, res, next);
} catch (err) {
next(err);
}
};
这里从app的内部路由handle方法跳到了外部路由的handle中，再走一遍流程。
由于req、res始终是一个，所以大部分的都可以跳过，这里挑不同的地方来讲：
1、stack
var stack = self.stack;
由于换了router，所以stack也换成了外部路由的stack，里面装的是有route挂载的layer。
2、while循环的后半段
// 获取请求的方式
var method = req.method;
var has_method = route._handles_method(method);
// OPTIONS请求特殊处理
if (!has_method && method === 'OPTIONS') {
appendMethods(options, route._options());
}
// 如果route未处理该方式请求 直接跳过
if (!has_method && method !== 'HEAD') {
match = false;
continue;
}
Route.prototype._handles_method = function _handles_method(method) {
// router.all
if (this.methods._all) {
return true;
}
var name = method.toLowerCase();
// head默认视为get请求
if (name === 'head' && !this.methods['head']) {
name = 'get';
}
// 判断route是否有处理该请求方式的中间件
return Boolean(this.methods[name]);
};
// route[METHODS]
var layer = Layer('/', {}, handle);
layer.method = method;
this.methods[method] = true;
这里做了一个提前判断，在调用app[METHODS]、router[METHODS]时，最后指向底层的route[METHODS]。除了生成一个layer对象，还会同时将route的本地属性methods对象上对应方式的键设为true，表示这个route有处理对应请求方式的layer。
在跳过process_params、trim_prefix后，还是回到了handle_request方法。
然而，这里的layer对应的handle并不指向中间件函数，而是route.dispatch.bind(route)，如下：
// router.get('/',fn1,fn2)...
var layer = new Layer(path, {
sensitive: this.caseSensitive,
strict: this.strict,
end: true
}, route.dispatch.bind(route));
真正的中间件函数是在layer.route上，所以这个是另外一个分发方法，负责把对应方式的请求转给对应的route。
Route.prototype.dispatch = function dispatch(req, res, done) {
var idx = 0;
var stack = this.stack;
if (stack.length === 0) {
return done();
}
// 格式化请求方式
var method = req.method.toLowerCase();
if (method === 'head' && !this.methods['head']) {
method = 'get';
}
// 最终匹配的route
req.route = this;
next();
function next(err) {
// signal to exit route
if (err && err === 'route') return done();
// err...
// 依次取出route对象stack中的layer
var layer = stack[idx++];
// err...
if (err) {
layer.handle_error(err, req, res, next);
} else {
// 又是这个方法
layer.handle_request(req, res, next);
}
}
};
这个dispatch与handle方法十分类似，依次取出layer并再次调用其handle_request方法，这里的layer里面的handle是最终处理响应请求的中间件函数。
在文档中指出，需要执行中间件的第三个参数next中间件才会继续走下去，从这里也能看出，调用next后回到dispatch方法，会从stack上取出下一个layer，然后继续执行中间件函数，直到所有的layer都过了一遍，会调用回调函数done，这个方法就是最初router.handle里面的next函数，开始下一轮读取。
当内部路由上的layer都过完，请求就处理完毕，接下来会调用最终回调，简单看一下比较复杂，后面单独讲。
完结。