1.簡介

Expres是基于Node.js平臺，快速、開放、極簡的web開發框架。（Expres中文官網首頁原話）。之所以引用這句話，是因為這句話簡單明了的告知了大家，它到底是什么。基于Node的一個開發框架，目的是給web開發提供了方便。今天我們就用測試用例開發的模式，一步步追蹤Express路由系統源碼是怎么實現的。

整體代碼感知

本次實踐項目，完整目錄結構如下(以下會直接說某個文件的內容)：

Express
  |--lib
  |   |-express.js（主文件）
  |   |-application.js（相當于中轉站直接訪問路由信息）
  |   |-Router（路由，中間件）
  |       |-index.js
  |       |-layer.js
  |       |-route.js
  |
  |--test
  |   |-getTest.js
  |   |-routerTest.js
  |   |-middleTest.js

測試用例一（簡單服務）

var express = require('express');
var app = express();

app.get('/', function (req, res) {
  res.send('Hello World!');
});

var server = app.listen(3000, function () {
  console.log('server started on port 3000');
});

以上代碼是Express官網入門的一個最簡單的實例，簡單的搭建了一個服務，并且訪問根目錄的時候，會返回Hello World！我們可以看到app是引用后的express執行得到的一個對象（說明express是一個函數），并且在該對象上有get和listen兩個方法。主文件express.js，結構如下:

const app = require('./application');
function createApplication(){
   return app;
}
module.exports = createApplication;

application.js中應該具有一個對象，并且該對象上面有兩個方法.首先有一個存放路由的數組，默認有一個對象，我定義為兜底對象，就是當輸入的路由信息并不存在的時候，執行該對象的handler。到此，兩個文件執行完畢，我們就實現最簡單的服務搭建以及get路由功能。

let router = [
    {
        path:'*',
        method:'*',
        handler(req,res){
            res.end('Not Found');
        }
    }

];
let http = require('http');
const app = {
    get(path,handler){
        router.push({
            method:'get',
            path,
            handler
        });
    },
    listen(){
        const server = http.createServer(function(req,res){
            for(let i=0;i<router.length;i++){
                let {path,method,handler} = router[i];
                if(path == req.url && method == req.method.toLowerCase()){
                    return handler(req,res);
                }
            }
            router[0].handler(req,res);
        });
        server.listen.apply(server,arguments);
    }
}
module.exports  = app;

測試用例二（路由）

app.get('/',function(req,res,next){
    console.log(1);
    next();
},function(req,res,next){
    console.log(11);
    next();
}).get('/',function(req,res,next){
    console.log(2);
    next();
}).get('/',function(req,res,next){
    console.log(3);
    res.end('ok');
}).get('/',function(err,req,res,next){
    res.end('catch: '+err);
});
app.listen(3000);

此測試用例，包含的信息薛薇有點廣泛了，在此用例實現中，我們開啟了express中完整路由的實現之路。下圖為路由系統的實現。

1111.jpg

Router是一個大的路由系統，存放在stack數組中，stack中的每一項稱之為每一個層（layer），每一層中又存放了一個route信息，同樣的，在每一個route中，也有一個stack，stack中存放的也是一個個的層。外層的Router只是辨別路徑，如果路徑匹配直接進來，內層的route辨別方法，執行相對應的handler。這么設計是因為，有的時候一個路由有多個請求方法，比如/person,可以get，也可以post,那么在外層，我們直接匹配路徑就行了，等進入里面的route再尋找具體的handler。為了方便擴展，我們把application.js中返回的對象，定義為一個類，同時引入methods這個包，支持多種請求方式。

methods.forEach(function(method){
    Application.prototype[method] = function(){
       this.lazyrouter();
       this._router[method].apply(this._router,slice.call(arguments));
       return this;
    }
});

其中this.lazyrouter()即生成router對象，本質就是調用router對象里面的方法。在有請求進來的時候，直接調用self._router.handle(req,res,done)，即router的handle方法。在router里面，引入layer和route。

Router.prototype.route = function(path){
    const route = new Route(path);
    const layer = new Layer(path,route.dispatch.bind(route));
    layer.route = route;
    this.stack.push(layer);
    return route;
}

path就是請求的路徑，在這一層的layer中比較重要的就是只匹配路徑，具體執行就交給了route對象的dispatch方法。router中的handle方法，就是一層層的匹配路徑，如下：

Router.prototype.handle = function(req,res,out){
    let idx=0,self=this;
    let {pathname} = url.parse(req.url,true);
    function next(err){
        if(idx >= self.stack.length){
            return out(err);
        }
        let layer = self.stack[idx++];
        if(layer.match(pathname) && layer.route&&layer.route._handles_method(req.method.toLowerCase())){
            if(err){
                layer.handle_error(err,req,res,next);
            }else{
                layer.handle_request(req,res,next);
            }
        }else{
            next();
        }
    }
    next();
}

當所有的都未匹配到，就走out，即我們定義的404。
設計很不錯的地方，我覺得在于route的dispatch方法，也是最終執行的方法。

Route.prototype.dispatch = function(req,res,out){
    let idx = 0,self=this;
    function next(err){
        if(err){
            return out(err);
        }
        if(idx >= self.stack.length){
            return out(err);
        }
        let layer = self.stack[idx++];
        if(layer.method == req.method.toLowerCase()){
            layer.handle_request(req,res,next);
        }else{
            next();
        }
    }
    next();
}

該方法中，不斷執行next，如果執行完了直接走out，此時的next其實代表的就是router種的下一個路由匹配。二者剛好無縫銜接。設計很精妙。

測試用例三（中間件）

app.use(function(req,res,next){
    console.log(11111);
    next('wrong');
});
app.get('/',function(req,res,next){
    res.end('1');
});
const person = express.Router();
person.use(function(req,res,next){
    console.log(22222);
    next();
});
person.use('/2',function(req,res,next){
    res.end('2');
});
app.use('/person',person);
app.use(function(err,req,res,next){
    res.end('catch '+err);
});
app.listen(3000,function(){
    console.log('server started at port 3000');
});

對于中間件，其實跟路由信息是存放于相同的位置的，但是不同的是，中間件可以沒有path，這里又出現了二級路由的概念。即我們可以通過上述代碼直接訪問/person/2.

proto.use = function(handler){
  let path = '/',router= this._router;
  if(typeof handler != 'function'){
      path = handler;
      handler = arguments[1];
  }
  let layer = new Layer(path,handler);
  layer.route = undefined;
  this.stack.push(layer);
  return this;
}

跟路由的區別是layer的route是undefined，并且在handle的時候我們需要根據中間件的路徑添加或刪除信息，拼成路徑尋找相應的handler。

  if(!layer.route){
    let removed = layer.path;
    req.url = req.url.slice(0,removed.length);
    if(req.url == ''){
        req.url = '/';
        slashAdded = true;
    }
    layer.handle_request(req,res,next)
}else if(layer.route._handles_method(req.method)){
    layer.handle_request(req,res,next);
}else{
    next(err);
}

其中的錯誤，也很好處理。在調用next的時候，傳入錯誤信息，檢測到錯誤信息，就直接跳到含有四個參數的處理函數即可，因為只有錯誤處理中間件才有四個參數。

Layer.prototype.handle_error = function (err,req,res,next) {
    if(this.handler.length !=4){
        return next(err);
    }
    this.handler(err,req,res,next);
}

參考

1. 從express源碼中探析其路由機制
2. express官網