.8-浅析express源码之请求处理流程(1)

2018-06-24 01:59:16来源:未知 阅读 ()

新老客户大回馈,云服务器低至5折

  这一节就讲从一个请求到来,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都过完,请求就处理完毕。正常情况下,会结束响应。接下来会调用最终回调,简单看一下比较复杂,后面单独讲

  完结。

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:小程序打包代码包过大的解决方法

下一篇:Javascript的console[&#39;&#39;]几种常用输入方法