引言
在web开发中，一个简化的处理流程就是：客户端发起请求，然后服务端进行处理，最后返回相关数据。不管对于哪种语言哪种框架，除去细节的处理，简化后的模型都是一样的。客户端要发起请求，首先需要一个标识，通常情况下是URL，通过这个标识将请求发送给服务端的某个具体处理程序，在这个过程中，请求可能会经历一系列全局处理，比如验证、授权、URL解析等，然后定位到某个处理程序进行业务处理，最后将生成的数据返回客户端，客户端将数据结合视图模版呈现出合适的样式。这个过程涉及到的模块比较多，本文只探讨前半部分，也就是从客户端请求到服务器端处理程序的过程，也可以叫做路由（其实就是如何定位到服务端处理程序的过程）。 为了作为对比，先简单介绍一下asp.net webform和asp.net mvc是如何实现路由的。 asp.net webform比较特殊，由于是postback原理，定位处理程序的过程与mvc是不一样的，对URL的格式没有严格的要求，url是直接对应后台文件的，aspx中的服务器表单默认是发送到对应的aspx.cs文件，它的定位是借助aspx页面中的两个隐藏域（__EVENTTARGET和__EVENTARGUMENT）以及IPostBackEventHandler接口来实现的，通过这两样东西就可以直接定位到某个具体方法中，通常是某个控件的某个事件处理程序。也就是说，在webform中，url仅能将请求定位到类中，要定位到真正的处理程序（方法）中，还需借助其他手段。 asp.net mvc与webform不同，url不再对应到后台文件，那么就必须通过某种手段来解析url，mvc中的后台处理程序称为Action，位于Controller类中，为了使url能够定位到action，mvc中的url有比较严格的格式要求，在url中需要包含controller和action，这样后台就可以通过反射来动态生成controller实例然后调用对应的action。也就是说，在mvc中完全依靠url来实现后台处理程序的定位。 通过上面两种方式的分析，我们发现url是不是指向文件是无所谓的，但最终都是要根据其定位到某个具体的处理程序，也就是url到handler有个路由处理过程，只不过不同的框架有不同的处理方法。在express框架的使用过程中，隐隐约约感觉其路由过程如下图所示： 到底是不是这样呢？
源码分析
我们知道，在使用express的时候，我们可以通过如下的方式来注册路由：
app.get("/",function(req,res){
res.send("hello啊");
});从表面上看，get方法可以将url中的path与后台处理程序关联起来，为了弄清楚这个过程，我们可以到application.js文件中查看源码。第一次看了一眼，发现里面居然没有这个方法，app.get()，app.post()等都没找到，仔细再一看，发现了如下方法：
methods.forEach(function(method){
app[method] = function(path){
if ('get' == method && 1 == arguments.length) return this.set(path); //get的特殊处理，只有一个参数时会获取app.settings[path]
this.lazyrouter();
var route = this._router.route(path);
route[method].apply(route, slice.call(arguments, 1)); //取出第二个参数，即：处理程序，传入route[method]方法中
return this;
};
});原来，这些方法都是动态添加的。methods是一个数组，里面存放了一系列web请求方法，以上方法通过对其进行遍历，给app添加了与请求方法同名的一系列方法，即：app.get()、app.post()、app.put()等，在这些方法中，首先通过调用lazyrouter实例化一个Router对象，然后调用this._router.route方法实例化一个Route对象，最后调用route[method]方法并传入对应的处理程序完成path与handler的关联。 在这个方法中需要注意以下几点：
- lazyrouter方法只会在首次调用时实例化Router对象，然后将其赋值给app._router字段
- 要注意Router与Route的区别，Router可以看作是一个中间件容器，不仅可以存放路由中间件（Route），还可以存放其他中间件，在lazyrouter方法中实例化Router后会首先添加两个中间件：query和init；而Route仅仅是路由中间件，封装了路由信息。Router和Route都各自维护了一个stack数组，该数组就是用来存放中间件和路由的。
这里先声明一下，本文提到的路由容器(Router)代表“router/index.js”文件的到导出对象，路由中间件(Route)代表“router/route.js”文件的导出对象，app代表“application.js”的导出对象。 Router和Route的stack是有差别的，这个差别主要体现在存放的layer（layer是用来封装中间件的一个数据结构）不太一样， 由于Router.stack中存放的中间件包括但不限于路由中间件，而只有路由中间件的执行才会依赖与请求method，因此Router.stack里的layer没有method属性，而是将其动态添加（layer的定义中没有method字段）到了Route.stack的layer中；layer.route字段也是动态添加的，可以通过该字段来判断中间件是否是路由中间件。 可以通过两种方式添加中间件：app.use和app[method],前者用来添加非路由中间件，后者添加路由中间件，这两种添加方式都在内部调用了Router的相关方法来实现：
//添加非路由中间件
proto.use = function use(fn) {
/* 此处略去部分代码 */
callbacks.forEach(function (fn) {
if (typeof fn !== 'function') {
throw new TypeError('Router.use() requires middleware function but got a ' + gettype(fn));
}
// add the middleware
debug('use %s %s', path, fn.name || '<anonymous>');
////实例化layer对象并进行初始化
var layer = new Layer(path, {
sensitive: this.caseSensitive,
strict: false,
end: false
}, fn);
//非路由中间件，该字段赋值为undefined
layer.route = undefined;
this.stack.push(layer);
}, this);
return this;
};
//添加路由中间件
proto.route = function(path){
//实例化路由对象
var route = new Route(path);
//实例化layer对象并进行初始化
var layer = new Layer(path, {
sensitive: this.caseSensitive,
strict: this.strict,
end: true
}, route.dispatch.bind(route));
//指向刚实例化的路由对象（非常重要），通过该字段将Router和Route关联来起来
layer.route = route;
this.stack.push(layer);
return route;
};对于路由中间件，路由容器中的stack（Router.stack）里面的layer通过route字段指向了路由对象，那么这样一来，Router.stack就和Route.stack发生了关联，关联后的示意模型如下图所示： 在运行过程中，路由容器（Router）只会有一个实例，而路由中间件会在每次调用app.route、app.use或app[method]的时候生成一个路由对象，在添加路由中间件的时候路由容器相当于是一个代理，Router[method]实际上是在内部调用了Route[method]来实现路由添加的，路由容器中有一个route方法，相当于是路由对象创建工厂。通过添加一个个的中间件，在处理请求的时候会按照添加的顺序逐个调用，如果遇到路由中间件，会逐个调用该路由对象中stack数组里存放的handler，这就是express的流式处理，是不是有点类似asp.net中的管道模型，调用过程如下图所示：
我们可以做个测试，在终端执行"express －e expresstest"命令(需要先安装express和express-generator)，然后在"expresstest/app.js"文件中添加下面代码：
//添加非路由中间件
app.use('/test',function(req,res,next){console.log("app.use('/test') handler1");next()},function(req,res,next){console.log("app.use('/test') handler2");next()});
var r = app.route('/test'); //创建路由对象，并通过route[method]来添加路由中间件
r.get(function(req,res,next){
console.log("route.get('/test') handler1");
next();
}).get(function(req,res,next){
console.log("route.get('/test') handler2");
next();
});
/* 还可以这么写，直接传入多个function
r.get(function(req,res,next){
console.log("route.get('/test') handler1");
next();
},function(req,res,next){
console.log("route.get('/test') handler2");
next();
});
*/
/*
或者这么写，直接传入function数组，可以是多维数组
r.get([function(req,res,next){
console.log("route.get('/test') handler1");
next();
},[function(req,res,next){
console.log("route.get('/test') handler2");
next();
},function(req,res,next){
console.log("route.get('/test') handler3");
next();
}]]);
*/
app.get('/test',function(req,res,next){ //通过app[method]来添加路由中间件
console.log("app.get('/test') handler1");
next();
}).get('/test',function(req,res){
console.log("app.get('/test') handler2");
res.end();
});在终端中输入"cd expresstest"、“npm start"来启动express，然后在浏览器中输入"http://localhost:3000/test”，我们发现在终端中输出的内容与我们之前分析的完全一致，如下图所示： 在示例中，我们通过app[method]和route[method]这两种方式来添加了路由中间件，从源码中可以看出这里有个很大的区别，app[method]方法中有这么一句代码：var route = this._router.route(path);，this._router.route()方法内部会实例化一个Route并返回，也就是说，每次调用app[method]都会重新创建一个新的Route对象，后面的处理程序就会添加到这个新Route对象的stack中，虽然可以通过链式写法来添加路由中间件，但每个处理程序都不在一个stack中(不过这样也不影响程序的执行)；而route[method]则不同，该方法添加完路由中间件后会返回自身，在路由对象上调用method方法会把所有的处理程序全部添加在该对象的stack中，不过在使用route[method]之前需要先手动实例化一个Route对象。route[method]方法的处理手段与app[method]有所不同，不仅可以同时处理多个function参数，并且通过这句代码：var callbacks = utils.flatten([].slice.call(arguments));可以将arguments中的多位数组转换为一维数组，这样就使得参数的传入变得非常灵活。
中间件的添加主要依靠application.js、router/index.js和router/route.js这三个文件的导出对象(app,Router,Route)相互调用完成的，从三个文件的require上来看，app依赖Router,Router依赖Route，下面是app.use的代码：
app.use = function use(fn) {
var offset = 0; //该变量用来在arguments中定位handler的起始位置，在没有传入path的时候，handler是arguments的第一个元素，所以为0
var path = '/'; //没有传入path参数的时候，默认为"/"
// default path to '/'
// disambiguate app.use([fn])
if (typeof fn !== 'function') {
var arg = fn;
while (Array.isArray(arg) && arg.length !== 0) { //如果第一个参数是数组的话，取出数组第一个元素
arg = arg[0];
}
// first arg is the path
if (typeof arg !== 'function') { //如果arg不是function，将其作为path来处理
offset = 1;
path = fn;
}
}
var fns = flatten(slice.call(arguments, offset)); //从参数中取出处理函数列表
if (fns.length === 0) {
throw new TypeError('app.use() requires middleware functions');
}
// setup router
this.lazyrouter(); //实例化Router，并将其赋值给this._router
var router = this._router;
fns.forEach(function (fn) { //遍历参数中的function，逐个调用router.use，从这个地方可以看出，app.use()中可以传入多个function，将其都添加到stack中
// non-express app
if (!fn || !fn.handle || !fn.set) {
return router.use(path, fn);
}
debug('.use app under %s', path);
fn.mountpath = path;
fn.parent = this;
// restore .app property on req and res
router.