国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

express 源碼閱讀(全)

Steven / 3017人閱讀

摘要:每個請求都會對應(yīng)一個響應(yīng)。一個響應(yīng)主要包括狀態(tài)行響應(yīng)頭消息體,將常用的數(shù)據(jù)封裝為類,在上面的代碼中就是該類的一個對象。執(zhí)行測試用例,報錯,提示不存在。目前在中,一個路由是由三個部分構(gòu)成路徑方法和處理函數(shù)。

1. 簡介

這篇文章主要的目的是分析理解express的源碼,網(wǎng)絡(luò)上關(guān)于源碼的分析已經(jīng)數(shù)不勝數(shù),這篇文章準(zhǔn)備另辟蹊徑,仿制一個express的輪子,通過測試驅(qū)動的開發(fā)方式不斷迭代,正向理解express的代碼。

文章中的express源碼是參考官網(wǎng)最新版本(v4.15.4),文章的整體思路是參考早期創(chuàng)作的另一篇文章,這篇算是其升級版本。

如果你準(zhǔn)備通過本文學(xué)習(xí)express的基本原理,前提條件最好有一定的express使用經(jīng)驗,寫過一兩個基于express的應(yīng)用程序,否則對于其背后的原理理解起來難以產(chǎn)生共鳴,不易掌握。

代碼鏈接:https://github.com/WangZhecha...

2. 框架初始化

在仿制express框架前,首先完成兩件事。

確認(rèn)需求。

確認(rèn)結(jié)構(gòu)。

首先確認(rèn)需求,從express的官方網(wǎng)站入手。網(wǎng)站有一個Hello world 的事例程序,想要仿制express,該程序肯定需要通過測試,將改代碼復(fù)制保存到測試目錄test/index.js

const express = require("express")
const app = express()

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

app.listen(3000, function () {
  console.log("Example app listening on port 3000!")
})

接下來,確認(rèn)框架的名稱以及目錄結(jié)構(gòu)。框架的名稱叫做expross。目錄結(jié)構(gòu)如下:

expross
  |
  |-- lib
  |    | 
  |    |-- expross.js
  |
  |-- test
  |    |
  |    |-- index.js
  |
  |-- index.js

expross/index.js文件加載lib目錄下的expross.js文件。

module.exports = require("./lib/expross");

通過測試程序前兩行可以推斷lib/expross.js導(dǎo)出結(jié)果應(yīng)該是一個函數(shù),所以在expross.js文件中添加如下代碼:

function createApplication() {
  return {};
}

exports = module.exports = createApplication;

測試程序中包含兩個函數(shù),所以暫時將createApplication函數(shù)體實現(xiàn)如下:

function createApplication() {
    return {
        get: function() {
            console.log("expross().get function");
        },

        listen: function() {
            console.log("expross().listen function");
        }
    }
}

雖然無法得到想要的結(jié)果,但至少可以將測試程序跑通,函數(shù)的核心內(nèi)容可以在接下來的步驟中不斷完善。

至此,初始框架搭建完畢,修改test/index.js文件的前兩行:

const expross = require("../");
const app = expross();

運行node test/index.js查看結(jié)果。

2. 第一次迭代

本節(jié)是expross的第一次迭代,主要實現(xiàn)的目標(biāo)是將當(dāng)前的測試用例功能完整實現(xiàn),一共分兩部分:

實現(xiàn)http服務(wù)器。

實現(xiàn)get路由請求。

實現(xiàn)http服務(wù)器比較簡單,可以參考nodejs官網(wǎng)的實現(xiàn)。

const http = require("http");

const hostname = "127.0.0.1";
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader("Content-Type", "text/plain");
  res.end("Hello World
");
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

參考該案例,實現(xiàn)exprosslisten函數(shù)。

listen: function(port, cb) {
    var server = http.createServer(function(req, res) {
        console.log("http.createServer...");
    });

    return server.listen(port, cb);
}

當(dāng)前listen函數(shù)包含了兩個參數(shù),但是http.listen有很多重載函數(shù),為了和http.listen一致,可以將函數(shù)設(shè)置為http.listen的“代理”,這樣可以保持expross().listenhttp.listen的參數(shù)統(tǒng)一。

listen: function(port, cb) {
    var server = http.createServer(function(req, res) {
        console.log("http.createServer...");
    });

      //代理
    return server.listen.apply(server, arguments);
}

listen函數(shù)中,我們攔截了所有http請求,每次http請求都會打印http.createServer ...,之所以攔截http請求,是因為expross需要分析每次http請求,根據(jù)http請求的不同來處理不同的業(yè)務(wù)邏輯。

在底層:

一個http請求主要包括請求行、請求頭和消息體,nodejs將常用的數(shù)據(jù)封裝為http.IncomingMessage類,在上面的代碼中req就是該類的一個對象。

每個http請求都會對應(yīng)一個http響應(yīng)。一個http響應(yīng)主要包括狀態(tài)行、響應(yīng)頭、消息體,nodejs將常用的數(shù)據(jù)封裝為http.ServerResponse類,在上面的代碼中res就是該類的一個對象。

不僅僅是nodejs,基本上所有的http服務(wù)框架都會包含request和response兩個對象,分別代表著http的請求和響應(yīng),負(fù)責(zé)服務(wù)端和瀏覽器的交互。

在上層:

服務(wù)器后臺代碼根據(jù)http請求的不同,綁定不同的邏輯。在真正的http請求來臨時,匹配這些http請求,執(zhí)行與之對應(yīng)的邏輯,這個過程就是web服務(wù)器基本的執(zhí)行流程。

對于這些http請求的管理,有一個專有名詞 —— “路由管理”,每個http請求就默認(rèn)為一個路由,常見的路由區(qū)分策略包括URL、HTTP請求名詞等等,但不僅僅限定這些,所有的http請求頭上的參數(shù)其實都可以進(jìn)行判斷區(qū)分,例如使用user-agent字段判斷移動端。

不同的框架對于路由的管理規(guī)則略有不同,但不管怎樣,都需要一組管理http請求和業(yè)務(wù)邏輯映射的函數(shù),測試用例中的get函數(shù)就是路由管理中的一個函數(shù),主要負(fù)責(zé)添加get請求。

既然知道路由管理的重要,這里就創(chuàng)建一個router數(shù)組,負(fù)責(zé)管理所有路由映射。參考express框架,抽象出每個路由的基本屬性:

path 請求路徑,例如:/books、/books/1。

method 請求方法,例如:GET、POST、PUT、DELETE。

handle 處理函數(shù)。

var router = [{
    path: "*",
    method: "*",
    handle: function(req, res) {
        res.writeHead(200, {"Content-Type": "text/plain"});
        res.end("404");
    }
}];

修改listen函數(shù),將http請求攔截邏輯改為匹配router路由表,如果匹配成功,執(zhí)行對應(yīng)的handle函數(shù),否則執(zhí)行router[0].handle函數(shù)。

listen: function(port, cb) {
    var server = http.createServer(function(req, res) {
        
        for(var i=1,len=router.length; i

實現(xiàn)get路由請求非常簡單,該函數(shù)主要是添加get請求路由,只需要將其信息加入到router數(shù)組即可。

get: function(path, fn) {
    router.push({
        path: path,
        method: "GET",
        handle: fn
    });
}

執(zhí)行測試用例,報錯,提示res.send不存在。該函數(shù)并不是nodejs原生函數(shù),這里在res上臨時添加函數(shù)send,負(fù)責(zé)發(fā)送相應(yīng)到瀏覽器。

listen: function(port, cb) {
    var server = http.createServer(function(req, res) {
        if(!res.send) {
            res.send = function(body) {
                res.writeHead(200, {
                    "Content-Type": "text/plain"
                });
                res.end(body);
            };
        }

        ......
    });

    return server.listen.apply(server, arguments);
}

在結(jié)束這次迭代之前,拆分整理一下程序目錄:

創(chuàng)建application.js文件,將createApplication函數(shù)中的代碼轉(zhuǎn)移到該文件,expross.js文件只保留引用。

var app = require("./application");

function createApplication() {
    return app;
}

exports = module.exports = createApplication;

整個目錄結(jié)構(gòu)如下:

expross
  |
  |-- lib
  |    | 
  |    |-- expross.js
  |    |-- application.js
  |
  |-- test
  |    |
  |    |-- index.js
  |
  |-- index.js

最后,運行node test/index.js,打開瀏覽器訪問http://127.0.0.1:3000/

3. 第二次迭代

本節(jié)是expross的第二次迭代,主要的目標(biāo)是構(gòu)建一個初步的路由系統(tǒng)。根據(jù)上一節(jié)的改動,目前的路由是用一個router數(shù)組進(jìn)行描述管理,對于router的操作有兩個,分別是在application.get函數(shù)和application.listen函數(shù),前者用于添加,后者用來處理。

按照面向?qū)ο蟮姆庋b法則,接下來將路由系統(tǒng)的數(shù)據(jù)和路由系統(tǒng)的操作封裝到一起定義一個 Router類負(fù)責(zé)整個路由系統(tǒng)的主要工作。

var Router = function() {
    this.stack = [{
        path: "*",
        method: "*",
        handle: function(req, res) {
            res.writeHead(200, {
                "Content-Type": "text/plain"
            });
            res.end("404");
        }
    }];
};


Router.prototype.get = function(path, fn) {
    this.stack.push({
        path: path,
        method: "GET",
        handle: fn
    });
};


Router.prototype.handle = function(req, res) {
    for(var i=1,len=this.stack.length; i

修改原有的application.js文件的內(nèi)容。

var http = require("http");
var Router = require("./router");


exports = module.exports = {
    _router: new Router(),

    get: function(path, fn) {
        return this._router.get(path, fn);
    },

    listen: function(port, cb) {
        var self = this;

        var server = http.createServer(function(req, res) {
            if(!res.send) {
                res.send = function(body) {
                    res.writeHead(200, {
                        "Content-Type": "text/plain"
                    });
                    res.end(body);
                };
            }

            return self._router.handle(req, res);
        });

        return server.listen.apply(server, arguments);
    }
};

這樣以后路由方面的操作只和Router本身有關(guān),與application分離,使代碼更加清晰。

這個路由系統(tǒng)正常運行時沒有問題的,但是如果路由不斷的增多,this.stack數(shù)組會不斷的增大,匹配的效率會不斷降低,為了解決效率的問題,需要仔細(xì)分析路由的組成成分。

目前在expross中,一個路由是由三個部分構(gòu)成:路徑、方法和處理函數(shù)。前兩者的關(guān)系并不是一對一的關(guān)系,而是一對多的關(guān)系,如:

GET books/1
PUT books/1
DELETE books/1

如果將路徑一樣的路由整合成一組,顯然效率會提高很多,于是引入Layer的概念。

這里將Router系統(tǒng)中this.stack數(shù)組的每一項,代表一個Layer。每個Layer內(nèi)部含有三個變量。

path,表示路由的路徑。

handle,代表路由的處理函數(shù)。

route,代表真正的路由。

整體結(jié)構(gòu)如下圖所示:

------------------------------------------------
|     0     |     1     |     2     |     3     |      
------------------------------------------------
| Layer     | Layer     | Layer     | Layer     |
|  |- path  |  |- path  |  |- path  |  |- path  |
|  |- handle|  |- handle|  |- handle|  |- handle|
|  |- route |  |- route |  |- route |  |- route |
------------------------------------------------
                  router 內(nèi)部

這里先創(chuàng)建Layer類。

function Layer(path, fn) {
    this.handle = fn;
    this.name = fn.name || "";
    this.path = path;
}


//簡單處理
Layer.prototype.handle_request = function (req, res) {
  var fn = this.handle;

  if(fn) {
      fn(req, res);
  }
};


//簡單匹配
Layer.prototype.match = function (path) {
    if(path === this.path || path === "*") {
        return true;
    }
    
    return false;
};

再次修改Router類。

var Router = function() {
    this.stack = [new Layer("*", function(req, res) {
        res.writeHead(200, {
            "Content-Type": "text/plain"
        });
        res.end("404");        
    })];
};


Router.prototype.handle = function(req, res) {
    var self = this;

    for(var i=1,len=self.stack.length; i

運行node test/index.js,訪問http://127.0.0.1:3000/一切看起來很正常,但是上面的代碼忽略了路由的屬性method。這樣的結(jié)果會導(dǎo)致如果測試用例存在問題:

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

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

程序無法分清PUT和GET的區(qū)別。

所以需要繼續(xù)完善路由系統(tǒng)中的Layer類中的route屬性,這個屬性才是真正包含method屬性的路由。

route的結(jié)構(gòu)如下:

------------------------------------------------
|     0     |     1     |     2     |     3     |      
------------------------------------------------
| item      | item      | item      | item      |
|  |- method|  |- method|  |- method|  |- method|
|  |- handle|  |- handle|  |- handle|  |- handle|
------------------------------------------------
                  route 內(nèi)部

創(chuàng)建Route類。

var Route = function(path) {
    this.path = path;
    this.stack = [];

    this.methods = {};
};

Route.prototype._handles_method = function(method) {
    var name = method.toLowerCase();
    return Boolean(this.methods[name]);
};

Route.prototype.get = function(fn) {
    var layer = new Layer("/", fn);
    layer.method = "get";

    this.methods["get"] = true;
    this.stack.push(layer);

    return this;
};

Route.prototype.dispatch = function(req, res) {
    var self = this,
        method = req.method.toLowerCase();

    for(var i=0,len=self.stack.length; i

在上面的代碼中,并沒有定義前面結(jié)構(gòu)圖中的item對象,而是使用了Layer對象進(jìn)行替代,主要是為了方便快捷,從另一種角度看,其實二者是存在很多共同點的。另外,為了利于理解,代碼中只實現(xiàn)了GET方法,其他方法的代碼實現(xiàn)是類似的。

既然有了Route類,接下來就改修改原有的Router類,將route集成其中。

Router.prototype.handle = function(req, res) {
    var self = this,
        method = req.method;

    for(var i=0,len=self.stack.length; i

運行node test/index.js,一切看起來和原來一樣。

這節(jié)內(nèi)容主要是創(chuàng)建一個完整的路由系統(tǒng),并在原始代碼的基礎(chǔ)上引入了Layer和Route兩個概念,并修改了大量的代碼,在結(jié)束本節(jié)前總結(jié)一下目前的信息。

首先,當(dāng)前程序的目錄結(jié)構(gòu)如下:

expross
  |
  |-- lib
  |    | 
  |    |-- expross.js
  |    |-- application.js
  |    |-- router
  |          |
  |          |-- index.js
  |          |-- layer.js
  |          |-- route.js
  |
  |-- test
  |    |
  |    |-- index.js
  |
  |-- index.js

接著,總結(jié)一下當(dāng)前expross各個部分的工作。

application代表一個應(yīng)用程序,expross是一個工廠類負(fù)責(zé)創(chuàng)建application對象。Router代表路由組件,負(fù)責(zé)應(yīng)用程序的整個路由系統(tǒng)。組件內(nèi)部由一個Layer數(shù)組構(gòu)成,每個Layer代表一組路徑相同的路由信息,具體信息存儲在Route內(nèi)部,每個Route內(nèi)部也是一個Layer對象,但是Route內(nèi)部的Layer和Router內(nèi)部的Layer是存在一定的差異性。

Router內(nèi)部的Layer,主要包含path、route屬性。

Route內(nèi)部的Layer,主要包含method、handle屬性。

如果一個請求來臨,會現(xiàn)從頭至尾的掃描router內(nèi)部的每一層,而處理每層的時候會先對比URI,相同則掃描route的每一項,匹配成功則返回具體的信息,沒有任何匹配則返回未找到。

最后,整個路由系統(tǒng)的結(jié)構(gòu)如下:

 --------------
| Application  |                                 ---------------------------------------------------------
|     |        |        ----- -----------        |     0     |     1     |     2     |     3     |  ...  |
|     |-router | ----> |     | Layer     |       ---------------------------------------------------------
 --------------        |  0  |   |-path  |       | Layer     | Layer     | Layer     | Layer     |       |
  application          |     |   |-route | ----> |  |- method|  |- method|  |- method|  |- method|  ...  |
                       |-----|-----------|       |  |- handle|  |- handle|  |- handle|  |- handle|       |
                       |     | Layer     |       ---------------------------------------------------------
                       |  1  |   |-path  |                                  route
                       |     |   |-route |       
                       |-----|-----------|       
                       |     | Layer     |
                       |  2  |   |-path  |
                       |     |   |-route |
                       |-----|-----------|
                       | ... |   ...     |
                        ----- ----------- 
                             router
3. 第三次迭代

本節(jié)是expross的第三次迭代,主要的目標(biāo)是繼續(xù)完善路由系統(tǒng),主要工作有部分:

豐富接口,目前只支持get接口。

增加路由系統(tǒng)的流程控制。

當(dāng)前expross框架只支持get接口,具體的接口是由expross提供的,內(nèi)部調(diào)用Router.get接口,而其內(nèi)部是對Route.get的封裝。

HTTP顯然不僅僅只有GET這一個方法,還包括很多,例如:PUT、POST、DELETE等等,每個方法都多帶帶寫一個處理函數(shù)顯然是冗余的,因為函數(shù)的內(nèi)容除了和函數(shù)名相關(guān)外,其他都是一成不變的。根據(jù)JavaScript腳本語言語言的特性,這里可以通過HTTP的方法列表動態(tài)生成函數(shù)內(nèi)容。

想要動態(tài)生成函數(shù),首先需要確定函數(shù)名稱。函數(shù)名就是nodejs中HTTP服務(wù)器支持的方法名稱,可以在官方文檔中獲取,具體參數(shù)是http.METHODS。這個屬性是在v0.11.8新增的,如果nodejs低于該版本,需要手動建立一個方法列表,具體可以參考nodejs代碼。

express框架HTTP方法名的獲取封裝到另一個包,叫做methods,內(nèi)部給出了低版本的兼容動詞列表。

function getBasicNodeMethods() {
  return [
    "get",
    "post",
    "put",
    "head",
    "delete",
    "options",
    "trace",
    "copy",
    "lock",
    "mkcol",
    "move",
    "purge",
    "propfind",
    "proppatch",
    "unlock",
    "report",
    "mkactivity",
    "checkout",
    "merge",
    "m-search",
    "notify",
    "subscribe",
    "unsubscribe",
    "patch",
    "search",
    "connect"
  ];
}

知道所支持的方法名列表數(shù)組后,剩下的只需要一個for循環(huán)生成所有的函數(shù)即可。

所有的動詞處理函數(shù)的核心內(nèi)容都在Route中。

http.METHODS.forEach(function(method) {
    method = method.toLowerCase();
    Route.prototype[method] = function(fn) {
        var layer = new Layer("/", fn);
        layer.method = method;

        this.methods[method] = true;
        this.stack.push(layer);

        return this;
    };
});

接著修改Router。

http.METHODS.forEach(function(method) {
    method = method.toLowerCase();
    Router.prototype[method] = function(path, fn) {
        var route = this.route(path);
        route[method].call(route, fn);

        return this;
    };
});

最后修改application.js的內(nèi)容。這里改動較大,重新定義了一個Application類,而不是使用字面量直接創(chuàng)建。

function Application() {
    this._router = new Router();
}


Application.prototype.listen = function(port, cb) {
    var self = this;

    var server = http.createServer(function(req, res) {
        self.handle(req, res);
    });

    return server.listen.apply(server, arguments);
};


Application.prototype.handle = function(req, res) {
    if(!res.send) {
        res.send = function(body) {
            res.writeHead(200, {
                "Content-Type": "text/plain"
            });
            res.end(body);
        };
    }

    var router = this._router;
    router.handle(req, res);
};

接著增加HTTP方法函數(shù)。

http.METHODS.forEach(function(method) {
    method = method.toLowerCase();
    Application.prototype[method] = function(path, fn) {
        this._router[method].apply(this._router, arguments);
        return this;
    };
});

因為導(dǎo)出的是Application類,所以修改expross.js文件。

var Application = require("./application");

function createApplication() {
    var app = new Application();
    return app;
}

運行node test/index.js,走起。

如果你仔細(xì)研究路由系統(tǒng)的源碼,會發(fā)現(xiàn)route本身的定義并不是像文字描述那樣。例如:

增加兩個同樣路徑的路由:

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

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

結(jié)果并不是想象中類似下面的結(jié)構(gòu):

                          ---------------------------------------------------------
 ----- -----------        |     0     |     1     |     2     |     3     |  ...  |
|     | Layer     |       ---------------------------------------------------------
|  0  |   |-path  |       | Layer     | Layer     | Layer     | Layer     |       |
|     |   |-route | ----> |  |- method|  |- method|  |- method|  |- method|  ...  |
|-----|-----------|       |  |- handle|  |- handle|  |- handle|  |- handle|       |
|     | Layer     |       ---------------------------------------------------------
|  1  |   |-path  |                                  route
|     |   |-route |       
|-----|-----------|       
|     | Layer     |
|  2  |   |-path  |
|     |   |-route |
|-----|-----------|
| ... |   ...     |
 ----- ----------- 
      router

而是如下的結(jié)構(gòu):

 ----- -----------        -------------
|     | Layer     | ----> | Layer     |
|  0  |   |-path  |       |  |- method|   route
|     |   |-route |       |  |- handle|
|-----|-----------|       -------------
|     | Layer     |       -------------      
|  1  |   |-path  | ----> | Layer     |
|     |   |-route |       |  |- method|   route     
|-----|-----------|       |  |- handle|        
|     | Layer     |       -------------
|  2  |   |-path  |       -------------  
|     |   |-route | ----> | Layer     |
|-----|-----------|       |  |- method|   route
| ... |   ...     |       |  |- handle| 
 ----- -----------        -------------
    router            

之所以會這樣是因為路由系統(tǒng)存在這先后順序的關(guān)系,如果你前面的描述結(jié)構(gòu)很有可能會丟失路由順序這個屬性。既然這樣,那Route的用處是在哪?

因為在express框架中,Route存儲的是真正的路由信息,可以當(dāng)做多帶帶的成員使用,如果想要真正前面的所描述的結(jié)果描述,你需要這樣創(chuàng)建你的代碼:

var router = express.Router();

router.route("/users/:user_id")
.get(function(req, res, next) {
  res.json(req.user);
})
.put(function(req, res, next) {
  // just an example of maybe updating the user
  req.user.name = req.params.name;
  // save user ... etc
  res.json(req.user);
})
.post(function(req, res, next) {
  next(new Error("not implemented"));
})
.delete(function(req, res, next) {
  next(new Error("not implemented"));
});

而不是這樣:

var app = expross();

app.get("/users/:user_id", function(req, res) {
    
})

.put("/users/:user_id", function(req, res) {
    
})

.post("/users/:user_id", function(req, res) {
    
})

.delete("/users/:user_id", function(req, res) {
    
});

理解了Route的使用方法,接下來就要討論剛剛提到的順序問題。在路由系統(tǒng)中,路由的處理順序非常重要,因為路由是按照數(shù)組的方式存儲的,如果遇見兩個同樣的路由,同樣的方法名,不同的處理函數(shù),這時候前后聲明的順序?qū)⒅苯佑绊懡Y(jié)果(這也是express中間件存在順序相關(guān)的原因),例如下面的例子:

app.get("/", function(req, res) {
    res.writeHead(200, {"Content-Type": "text/plain"});
    res.end("first");
});

app.get("/", function(req, res) {
    res.writeHead(200, {"Content-Type": "text/plain"});
    res.end("second");
});

上面的代碼如果執(zhí)行會發(fā)現(xiàn)永遠(yuǎn)都返回first,但是有的時候會根據(jù)前臺傳來的參數(shù)動態(tài)判斷是否執(zhí)行接下來的路由,怎樣才能跳過first進(jìn)入second?這就涉及到路由系統(tǒng)的流程控制問題。

流程控制分為主動和被動兩種模式。

對于expross框架來說,路由綁定的處理邏輯、用戶設(shè)置的路徑參數(shù)這些都是不可靠的,在運行過程中很有可能會發(fā)生異常,被動流程控制就是當(dāng)這些異常發(fā)生的時候,expross框架要擔(dān)負(fù)起捕獲這些異常的工作,因為如果不明確異常的發(fā)生位置,會導(dǎo)致js代碼無法繼續(xù)運行,并且無法準(zhǔn)確的報出故障。

主動流程控制則是處理函數(shù)內(nèi)部的操作邏輯,以主動調(diào)用的方式來跳轉(zhuǎn)路由內(nèi)部的執(zhí)行邏輯。

目前express通過引入next參數(shù)的方式來解決流程控制問題。next是處理函數(shù)的一個參數(shù),其本身也是一個函數(shù),該函數(shù)有幾種使用方式:

執(zhí)行下一個處理函數(shù)。執(zhí)行next()

報告異常。執(zhí)行next(err)

跳過當(dāng)前Route,執(zhí)行Router的下一項。執(zhí)行next("route")

跳過整個Router。執(zhí)行next("router")

接下來,我們嘗試實現(xiàn)以下這些需求。

首先修改最底層的Layer對象,該對象的handle_request函數(shù)是負(fù)責(zé)調(diào)用路由綁定的處理邏輯,這里添加next參數(shù),并且增加異常捕獲功能。

Layer.prototype.handle_request = function (req, res, next) {
  var fn = this.handle;

  try {
    fn(req, res, next);
  } catch (err) {
    next(err);
  }
};

接下來修改Route.dispath函數(shù)。因為涉及到內(nèi)部的邏輯跳轉(zhuǎn),使用for循環(huán)按部就班不太合適,這里使用了類似遞歸的方式。

Route.prototype.dispatch = function(req, res, done) {
    var self = this,
        method = req.method.toLowerCase(),
        idx = 0, stack = self.stack;

    function next(err) {
        //跳過route
        if(err && err === "route") {
            return done();
        }

        //跳過整個路由系統(tǒng)
        if(err && err === "router") {
            return done(err);
        }

        //越界
        if(idx >= stack.length) {
            return done(err);
        }

        //不等枚舉下一個
        var layer = stack[idx++];
        if(method !== layer.method) {
            return next(err);
        }

        if(err) {
            //主動報錯
            return done(err);
        } else {
            layer.handle_request(req, res, next);
        }
    }

    next();
};

整個處理過程本質(zhì)上還是一個for循環(huán),唯一的差別就是在處理函數(shù)中用戶主動調(diào)用next函數(shù)的處理邏輯。

如果用戶通過next函數(shù)返回錯誤、routerouter這三種情況,目前統(tǒng)一拋給Router處理。

因為修改了dispatch函數(shù),所以調(diào)用該函數(shù)的Router.route函數(shù)也要修改,這回直接改徹底,以后無需根據(jù)參數(shù)的個數(shù)進(jìn)行調(diào)整。

Router.prototype.route = function route(path) {
    ...
    
    //使用bind方式
    var layer = new Layer(path, route.dispatch.bind(route));
    
    ...
};

接著修改Router.handle的代碼,邏輯和Route.dispatch類似。

Router.prototype.handle = function(req, res, done) {
    var self = this,
        method = req.method,
        idx = 0, stack = self.stack;

    function next(err) {
        var layerError = (err === "route" ? null : err);

        //跳過路由系統(tǒng)
        if(layerError === "router") {
            return done(null);
        }

        if(idx >= stack.length || layerError) {
            return done(layerError);
        }

        var layer = stack[idx++];
        //匹配,執(zhí)行
        if(layer.match(req.url) && layer.route &&
            layer.route._handles_method(method)) {
            return layer.handle_request(req, res, next);
        } else {
            next(layerError);
        }
    }

    next();
};

修改后的函數(shù)處理過程和原來的類似,不過有一點需要注意,當(dāng)發(fā)生異常的時候,會將結(jié)果返回給上一層,而不是執(zhí)行原有this.stack第0層的代碼邏輯。

最后增加expross框架異常處理的邏輯。

在之前,可以移除原有this.stack的初始化代碼,將

var Router = function() {
    this.stack = [new Layer("*", function(req, res) {
        res.writeHead(200, {
            "Content-Type": "text/plain"
        });
        res.end("404");        
    })];
};

改為

var Router = function() {
    this.stack = [];
};

然后,修改Application.handle函數(shù)。

Application.prototype.handle = function(req, res) {
  
    ...
    
    var done = function finalhandler(err) {
        res.writeHead(404, {
            "Content-Type": "text/plain"
        });

        if(err) {
            res.end("404: " + err);    
        } else {
            var msg = "Cannot " + req.method + " " + req.url;
            res.end(msg);    
        }
    };

    var router = this._router;
    router.handle(req, res, done);
};

這里簡單的將done函數(shù)處理為返回404頁面,其實在express框架中,使用的是一個多帶帶的npm包,叫做finalhandler

簡單的修改一下測試用例證明一下成果。

var expross = require("../");
var app = expross();

app.get("/", function(req, res, next) {
    next();
})

.get("/", function(req, res, next) {
    next(new Error("error"));
})

.get("/", function(req, res) {
    res.send("third");
});

app.listen(3000, function() {
    console.log("Example app listening on port 3000!");
});

運行node test/index.js,訪問http://127.0.0.1:3000/,結(jié)果顯示:

404: Error: error

貌似目前一切都很順利,不過還有一個需求目前被忽略了。當(dāng)前處理函數(shù)的異常全部是由框架捕獲,返回的信息只能是固定的404頁面,對于框架使用者顯然很不方便,大多數(shù)時候,我們都希望可以捕獲錯誤,并按照一定的信息封裝返回給瀏覽器,所以expross需要一個返回錯誤給上層使用者的接口。

目前和上層對接的處理函數(shù)的聲明如下:

function process_fun(req, res, next) {
  
}

如果增加一個錯誤處理函數(shù),按照nodejs的規(guī)則,第一個參數(shù)是錯誤信息,定義應(yīng)該如下所示:

function process_err(err, req, res, next) {
  
}

因為兩個聲明的第一個參數(shù)信息是不同的,如果區(qū)分傳入的處理函數(shù)是處理錯誤的函數(shù)還是處理正常的函數(shù),這個是expross框架需要搞定的關(guān)鍵問題。

javascript中,F(xiàn)unction.length屬性可以獲取傳入函數(shù)指定的參數(shù)個數(shù),這個可以當(dāng)做區(qū)分二者的關(guān)鍵信息。

既然確定了原理,接下來直接在Layer類上增加一個專門處理錯誤的函數(shù),和處理正常信息的函數(shù)區(qū)分開。

//錯誤處理
Layer.prototype.handle_error = function (error, req, res, next) {
  var fn = this.handle;

  //如果函數(shù)參數(shù)不是標(biāo)準(zhǔn)的4個參數(shù),返回錯誤信息
  if(fn.length !== 4) {
    return next(error);
  }

  try {
    fn(error, req, res, next);
  } catch (err) {
    next(err);
  }
};

接著修改Route.dispatch函數(shù)。

Route.prototype.dispatch = function(req, res, done) {
    var self = this,
        method = req.method.toLowerCase(),
        idx = 0, stack = self.stack;

    function next(err) {
    
        ...

        if(err) {
            //主動報錯
            layer.handle_error(err, req, res, next);
        } else {
            layer.handle_request(req, res, next);
        }
    }

    next();
};

當(dāng)發(fā)生錯誤的時候,Route會一直向后尋找錯誤處理函數(shù),如果找到則返回,否則執(zhí)行done(err),將錯誤拋給Router。

對于Router.handle的修改,因為涉及到一些中間件的概念,完整的錯誤處理將推移到下一節(jié)完成。

本節(jié)的內(nèi)容基本上完成,包括HTTP相關(guān)的動作接口的添加、路由系統(tǒng)的流程跳轉(zhuǎn)以及Route級別的錯誤響應(yīng)等等,涉及到路由系統(tǒng)剩下的一點內(nèi)容暫時放到以后講解。

4. 第四次迭代

本節(jié)是expross的第四次迭代,主要的目標(biāo)是建立中間件機(jī)制并繼續(xù)完善路由系統(tǒng)的功能。

在express中,中間件其實是一個介于web請求來臨后到調(diào)用處理函數(shù)前整個流程體系中間調(diào)用的組件。其本質(zhì)是一個函數(shù),內(nèi)部可以訪問修改請求和響應(yīng)對象,并調(diào)整接下來的處理流程。

express官方給出的解釋如下:

Express 是一個自身功能極簡,完全是由路由和中間件構(gòu)成一個的 web 開發(fā)框架:從本質(zhì)上來說,一個 Express 應(yīng)用就是在調(diào)用各種中間件。

中間件(Middleware) 是一個函數(shù),它可以訪問請求對象(request object (req)), 響應(yīng)對象(response object (res)), 和 web 應(yīng)用中處于請求-響應(yīng)循環(huán)流程中的中間件,一般被命名為 next 的變量。

中間件的功能包括:

執(zhí)行任何代碼。

修改請求和響應(yīng)對象。

終結(jié)請求-響應(yīng)循環(huán)。

調(diào)用堆棧中的下一個中間件。

如果當(dāng)前中間件沒有終結(jié)請求-響應(yīng)循環(huán),則必須調(diào)用 next() 方法將控制權(quán)交給下一個中間件,否則請求就會掛起。

Express 應(yīng)用可使用如下幾種中間件:

應(yīng)用級中間件

路由級中間件

錯誤處理中間件

內(nèi)置中間件

第三方中間件

使用可選則掛載路徑,可在應(yīng)用級別或路由級別裝載中間件。另外,你還可以同時裝在一系列中間件函數(shù),從而在一個掛載點上創(chuàng)建一個子中間件棧。

官方給出的定義其實已經(jīng)足夠清晰,一個中間件的樣式其實就是上一節(jié)所提到的處理函數(shù),只不過并沒有正式命名。所以對于代碼來說Router類中的this.stack屬性內(nèi)部的每個handle都是一個中間件,根據(jù)使用接口不同區(qū)別了應(yīng)用級中間件路由級中間件,而四個參數(shù)的處理函數(shù)就是錯誤處理中間件

接下來就給expross框架添加中間件的功能。

首先是應(yīng)用級中間件,其使用方法是Application類上的兩種方式:Application.use 和 Application.METHOD (HTTP的各種請求方法),后者其實在前面的小節(jié)里已經(jīng)實現(xiàn)了,前者則是需要新增的。

在前面的小節(jié)里的代碼已經(jīng)說明Application.METHOD內(nèi)部其實是Router.METHOD的代理,Application.use同樣如此。

Application.prototype.use = function(fn) {
    var path = "/",
        router = this._router;

    router.use(path, fn);

    return this;
};

因為Application.use支持可選路徑,所以需要增加處理路徑的重載代碼。

Application.prototype.use = function(fn) {
    var path = "/",
        router = this._router;

    //路徑掛載
    if(typeof fn !== "function") {
        path = fn;
        fn = arguments[1];
    }

    router.use(path, fn);

    return this;
};

其實express框架支持的參數(shù)不僅僅這兩種,但是為了便于理解剔除了一些旁枝末節(jié),便于框架的理解。

接下來實現(xiàn)Router.use函數(shù)。

Router.prototype.use = function(fn) {
    var path = "/";

    //路徑掛載
    if(typeof fn !== "function") {
        path = fn;
        fn = arguments[1];
    }

    var layer = new Layer(path, fn);
    layer.route = undefined;

    this.stack.push(layer);

    return this;
};

內(nèi)部代碼和Application.use差不多,只不過最后不再是調(diào)用Router.use,而是直接創(chuàng)建一個Layer對象,將其放到this.stack數(shù)組中。

在這里段代碼里可以看到普通路由和中間件的區(qū)別。普通路由放到Route中,且Router.route屬性指向Route對象,Router.handle屬性指向Route.dispatch函數(shù);中間件的Router.route屬性為undefined,Router.handle指向中間件處理函數(shù),被放到Router.stack數(shù)組中。

對于路由級中間件,首先按照要求導(dǎo)出Router類,便于使用。

exports.Router = Router;

上面的代碼添加到expross.js文件中,這樣就可以按照下面的使用方式創(chuàng)建一個多帶帶的路由系統(tǒng)。

var app = express();
var router = express.Router();

router.use(function (req, res, next) {
  console.log("Time:", Date.now());
});

現(xiàn)在問題來了,如果像上面的代碼一樣創(chuàng)建一個新的路由系統(tǒng)是無法讓路由系統(tǒng)內(nèi)部的邏輯生效的,因為這個路由系統(tǒng)沒法添加到現(xiàn)有的系統(tǒng)中。

一種辦法是增加一個專門添加新路由系統(tǒng)的接口,是完全是可行的,但是我更欣賞express框架的辦法,這可能是Router叫做路由級中間件的原因。express將Router定義成一個特殊的中間件,而不是一個多帶帶的類。

這樣將多帶帶創(chuàng)建的路由系統(tǒng)添加到現(xiàn)有的應(yīng)用中的代碼非常簡單通用:

var router = express.Router();

// 將路由掛載至應(yīng)用
app.use("/", router);

這確實是一個好方法,現(xiàn)在就來將expross修改成類似的樣子。

首先創(chuàng)建一個原型對象,將現(xiàn)有的Router方法轉(zhuǎn)移到該對象上。

var proto = {};

proto.handle = function(req, res, done) {...};
proto.route = function route(path) {...};
proto.use = function(fn) { ... };

http.METHODS.forEach(function(method) {
    method = method.toLowerCase();
    proto[method] = function(path, fn) {
        var route = this.route(path);
        route[method].call(route, fn);

        return this;
    };
});

然后創(chuàng)建一個中間件函數(shù),使用Object.setPrototypeOf函數(shù)設(shè)置其原型,最后導(dǎo)出一個生成這些過程的函數(shù)。

module.exports = function() {
    function router(req, res, next) {
        router.handle(req, res, next);
    }

    Object.setPrototypeOf(router, proto);

    router.stack = [];
    return router;
};

修改測試用例,測試一下效果。

app.use(function(req, res, next) {
    console.log("Time:", Date.now());
    next();
});

app.get("/", function(req, res, next) {
    res.send("first");
});


router.use(function(req, res, next) {
    console.log("Time: ", Date.now());
    next();
});

router.use("/", function(req, res, next) {
    res.send("second");
});

app.use("/user", router);

app.listen(3000, function() {
    console.log("Example app listening on port 3000!");
});

結(jié)果并不理想,原有的應(yīng)用程序還有兩個地方需要修改。

首先是邏輯處理問題。原有的Router.handle函數(shù)中并沒有處理中間件的情況,需要進(jìn)一步修改。

proto.handle = function(req, res, done) {
    
    ...
    
    function next(err) {
        
        ...
        
        //注意這里,layer.route屬性
        if(layer.match(req.url) && layer.route &&
            layer.route._handles_method(method)) {
            layer.handle_request(req, res, next);
        } else {
            layer.handle_error(layerError, req, res, next);
        }
    }

    next();
};

改成:

proto.handle = function(req, res, done) {

    ...

    function next(err) {
        
        ...
        
        //匹配,執(zhí)行
        if(layer.match(path)) {
            if(!layer.route) {
                //處理中間件
                layer.handle_request(req, res, next);    
            } else if(layer.route._handles_method(method)) {
                //處理路由
                layer.handle_request(req, res, next);
            }    
        } else {
            layer.handle_error(layerError, req, res, next);
        }
    }

    next();
};

其次是路徑匹配的問題。原有的單一路徑被拆分成為不同中間的路徑組合,這里判斷需要多步進(jìn)行,因為每個中間件只是匹配自己的路徑是否通過,不過相對而言目前涉及的匹配都是全等匹配,還沒有涉及到類似express框架中的正則匹配,算是非常簡單了。

想要實現(xiàn)匹配邏輯就要清楚的知道哪段路徑和哪個處理函數(shù)匹配,這里定義三個變量:

req.originalUrl 原始請求路徑。

req.url 當(dāng)前路徑。

req.baseUrl 父路徑。

主要修改Router.handle函數(shù),該函數(shù)主要負(fù)責(zé)提取當(dāng)前路徑段,便于和事先傳入的路徑進(jìn)行匹配。

proto.handle = function(req, res, done) {
    var self = this,
        method = req.method,
        idx = 0, stack = self.stack,
        removed = "", slashAdded = false;


    //獲取當(dāng)前父路徑
    var parentUrl = req.baseUrl || "";
    //保存父路徑
    req.baseUrl = parentUrl;
    //保存原始路徑
    req.orginalUrl = req.orginalUrl || req.url;


    function next(err) {
        var layerError = (err === "route" ? null : err);

        //如果有移除,復(fù)原原有路徑
        if(slashAdded) {
            req.url = "";
            slashAdded = false;
        }


        //如果有移除,復(fù)原原有路徑信息
        if(removed.length !== 0) {
            req.baseUrl = parentUrl;
            req.url = removed + req.url;
            removed = "";
        }


        //跳過路由系統(tǒng)
        if(layerError === "router") {
            return done(null);
        }


        if(idx >= stack.length || layerError) {
            return done(layerError);
        }

        //獲取當(dāng)前路徑
        var path = require("url").parse(req.url).pathname;

        var layer = stack[idx++];
        //匹配,執(zhí)行
        if(layer.match(path)) {

            //處理中間件
            if(!layer.route) {
                //要移除的部分路徑
                removed = layer.path;

                //設(shè)置當(dāng)前路徑
                req.url = req.url.substr(removed.length);
                if(req.url === "") {
                    req.url = "/" + req.url;
                    slashAdded = true;
                }

                //設(shè)置當(dāng)前路徑的父路徑
                req.baseUrl = parentUrl + removed;

                //調(diào)用處理函數(shù)
                layer.handle_request(req, res, next);    
            } else if(layer.route._handles_method(method)) {
                //處理路由
                layer.handle_request(req, res, next);
            }    
        } else {
            layer.handle_error(layerError, req, res, next);
        }
    }

    next();
};

這段代碼主要處理兩種情況:

第一種,存在路由中間件的情況。如:

router.use("/1", function(req, res, next) {
    res.send("first user");
});

router.use("/2", function(req, res, next) {
    res.send("second user");
});

app.use("/users", router);

這種情況下,Router.handle順序匹配到中間的時候,會遞歸調(diào)用Router.handle,所以需要保存當(dāng)前的路徑快照,具體路徑相關(guān)信息放到req.url、req.originalUrl 和req.baseUrl 這三個參數(shù)中。

第二種,非路由中間件的情況。如:

app.get("/", function(req, res, next) {
    res.send("home");
});

app.get("/books", function(req, res, next) {
    res.send("books");
});

這種情況下,Router.handle內(nèi)部主要是按照棧中的次序匹配路徑即可。

改好了處理函數(shù),還需要修改一下Layer.match這個匹配函數(shù)。目前創(chuàng)建Layer可能會有三種情況:

不含有路徑的中間件。path屬性默認(rèn)為/

含有路徑的中間件。

普通路由。如果path屬性為*,表示任意路徑。

修改原有Layer是構(gòu)造函數(shù),增加一個fast_star 標(biāo)記用來判斷path是否為*。

function Layer(path, fn) {
  this.handle = fn;
  this.name = fn.name || "";
  this.path = undefined;

  //是否為*
  this.fast_star = (path === "*" ? true : false);
  if(!this.fast_star) {
    this.path = path;
  }
}

接著修改Layer.match匹配函數(shù)。

Layer.prototype.match = function(path) {

  //如果為*,匹配
  if(this.fast_star) {
    this.path = "";
    return true;
  }

  //如果是普通路由,從后匹配
  if(this.route && this.path === path.slice(-this.path.length)) {
    return true;
  }

  if (!this.route) {
    //不帶路徑的中間件
    if (this.path === "/") {
      this.path = "";
      return true;
    }

    //帶路徑中間件
    if(this.path === path.slice(0, this.path.length)) {
      return true;
    }
  }
  
  return false;
};

代碼中一共判斷四種情況,根據(jù)this.route區(qū)分中間件和普通路由,然后分開判斷。

express除了普通的中間件外還要一種錯誤中間件,專門用來處理錯誤信息。該中間件的聲明和上一小節(jié)最后介紹的錯誤處理函數(shù)是一樣的,同樣是四個參數(shù)分別是:err、 req、 res和 next。

目前Router.handle中,當(dāng)遇見錯誤信息的時候,會直接通過回調(diào)函數(shù)返回錯誤信息,顯示錯誤頁面。

if(idx >= stack.length || layerError) {
    return done(layerError);
}

這里需要修改策略,將其改為繼續(xù)調(diào)用下一個中間件,直到碰到錯誤中間件為止。

//沒有找到
if(idx >= stack.length) {
    return done(layerError);
}

原有這一塊的代碼只保留判斷枚舉是否完成,將錯誤判斷轉(zhuǎn)移到最后執(zhí)行處理函數(shù)的位置。之所以這樣做是因為不管是執(zhí)行處理函數(shù),或是執(zhí)行錯誤處理都需要進(jìn)行路徑匹配操作和路徑分析操作,所以放到后面正好合適。

//處理中間件
if(!layer.route) {

    ...

    //調(diào)用處理函數(shù)
    if(layerError)
        layer.handle_error(layerError, req, res, next);
    else
        layer.handle_request(req, res, next);
    
} else if(layer.route._handles_method(method)) {
    //處理路由
    layer.handle_request(req, res, next);
}    

到此為止,expross的錯誤處理部分算是基本完成了。

路由系統(tǒng)和中間件兩個大的概念算是全部講解完畢,當(dāng)然還有很多細(xì)節(jié)沒有完善,在剩下的文字里如果有必要會繼續(xù)完善。

下一節(jié)主要的內(nèi)容是介紹前后端交互的兩個重要成員:request和response。express在nodejs的基礎(chǔ)之上進(jìn)行了豐富的擴(kuò)展,所以很有必要仿制一下。

5. 第五次迭代

本節(jié)是expross的第五次迭代,主要的目標(biāo)是封裝request和response兩個對象,方便使用。

其實nodejs已經(jīng)給我們提供這兩個默認(rèn)的對象,之所以要封裝是因為豐富一下二者的接口,方便框架使用者,目前框架在response對象上已經(jīng)有一個接口:

if(!res.send) {
    res.send = function(body) {
        res.writeHead(200, {
            "Content-Type": "text/plain"
        });
        res.end(body);
    };
}

如果需要繼續(xù)封裝,也要類似的結(jié)構(gòu)在代碼上添加顯然會給人一種很亂的感覺,因為request和response的原始版本是nodejs提供給框架的,框架獲取到的是兩個對象,并不是類,要想在二者之上提供另一組接口的辦法有很多,歸根結(jié)底就是將新的接口加到該對象上或者加到該對象的原型鏈上,目前的代碼選擇了前者,express的代碼選擇了后者。

首先建立兩個文件:request.js 和 response.js,二者分別導(dǎo)出req和res對象。

//request.js
var http = require("http");

var req = Object.create(http.IncomingMessage.prototype);

module.exports = req;


//response.js
var http = require("http");

var res = Object.create(http.ServerResponse.prototype);

module.exports = res;

二者文件的代碼都是創(chuàng)建一個對象,分別指向nodejs提供的request和response兩個對象的原型,以后expross自定的接口可以統(tǒng)一掛載到這兩個對象上。

接著修改Application.handle函數(shù),因為這個函數(shù)里面有新鮮出爐的request和response。思路很簡單,就是將二者的原型指向我們自建的req和res。因為req和res對象的原型和request和response的原型相同,所以并不影響原有nodejs的接口。

var request = require("./request");
var response = require("./response");

...

Application.prototype.handle = function(req, res) {

    Object.setPrototypeOf(req, request);
    Object.setPrototypeOf(res, response);


    ...
};

這里將原有的res.send轉(zhuǎn)移到了response.js文件中。

res.send = function(body) {
    this.writeHead(200, {
        "Content-Type": "text/plain"
    });
    this.end(body);
};

注意函數(shù)中不在是res.writeHead和res.end,而是this.writeHead和this.end。

在整個路由系統(tǒng)中,Router.stack每一項其實都是一個中間件,每個中間件都有可能用到req和res這兩個對象,所以代碼中修改nodejs原生提供的request和response對象的代碼放到了Application.handle中,這樣做并沒有問題,但是有一種更好的方式,expross框架將這部分代碼封裝成了一個內(nèi)部中間件。

為了確保框架中每個中間件接收這兩個參數(shù)的正確性,需要將該內(nèi)部中間放到Router.stack的首項。這里將原有Application的構(gòu)造函數(shù)中的代碼去掉,不再是直接創(chuàng)建Router()路由系統(tǒng),而是用一種惰性加載的方式,動態(tài)創(chuàng)建。

去除原有Application構(gòu)造函數(shù)的代碼。

function Application() {}

添加惰性初始化函數(shù)。

Application.prototype.lazyrouter = function() {
    if(!this._router) {
        this._router = new Router();

        this._router.use(middleware.init());
    }
};

因為是惰性初始化,所以在使用this._router對象前,一定要先調(diào)用該函數(shù)動態(tài)創(chuàng)建this._router對象。類似如下代碼:

//獲取router
this.lazyrouter();
router = this._router;

接下來創(chuàng)建一個叫middleware文件夾,專門放內(nèi)部中間件的文件,再創(chuàng)建一個init.js文件,放置Application.handle中用來初始化res和req的代碼。

var request = require("../request");
var response = require("../response");

exports.init = function expressInit(req, res, next) {
    //request文件可能用到res對象
    req.res = res;

    //response文件可能用到req對象
    res.req = req;

    //修改原始req和res原型
    Object.setPrototypeOf(req, request);
    Object.setPrototypeOf(res, response);

    //繼續(xù)
    next();
};

修改原有的Applicaton.handle函數(shù)。

Application.prototype.handle = function(req, res) {

    ...

    // 這里無需調(diào)用lazyrouter,因為listen前一定調(diào)用了.use或者.METHODS方法。
    // 如果二者都沒有調(diào)用,沒有必要創(chuàng)建路由系統(tǒng)。this._router為undefined。
    var router = this._router;
    if(router) {
        router.handle(req, res, done);
    } else {
        done();
    }
};

運行node test/index.js走起……

express框架中,request和response兩個對象有很多非常好用的函數(shù),不過大部分和框架結(jié)構(gòu)無關(guān),并且這些函數(shù)內(nèi)部過于專研細(xì)節(jié),對框架本身的理解沒有多少幫助。不過接下來有一個方面需要仔細(xì)研究一下,那就是前后端參數(shù)的傳遞,express如何獲取并分類這些參數(shù)的,這一點還是需要略微了解。

默認(rèn)情況下,一共有三種參數(shù)獲取方式。

req.query 代表查詢字符串。

req.params 代表路徑變量。

req.body 代表表單提交變量。

req.query 是最常用的方式,例如:

// GET /search?q=tobi+ferret
req.query.q
// => "tobi ferret"

// GET /shoes?order=desc&shoe[color]=blue&shoe[type]=converse
req.query.order
// => "desc"

req.query.shoe.color
// => "blue"

req.query.shoe.type
// => "converse"

后臺獲取這些參數(shù)最簡單的方式就是通過nodejs自帶的querystring模塊分析URL。express使用的是另一個npm包,qs。并且將其封裝為另一個內(nèi)部中間件,專門負(fù)責(zé)解析查詢字符串,默認(rèn)加載。

req.params 是另一種從URL獲取參數(shù)的方式,例如:

//路由規(guī)則  /user/:name
// GET /user/tj
req.params.name
// => "tj"

這是一種express框架規(guī)定的參數(shù)獲取方式,對于批量處理邏輯非常實用。在expross中并沒有實現(xiàn),因為路徑匹配問題過于細(xì)節(jié)化,如果對此感興趣可以研究研究path-to-regexp模塊,express也是在其上的封裝。

req.body 是獲取表單數(shù)據(jù)的方式,但是默認(rèn)情況下框架是不會去解析這種數(shù)據(jù),直接使用只會返回undefined。如果想要支持需要添加其他中間件,例如 body-parser 或 multer。

本小節(jié)主要介紹了request和response兩個對象,并且講解了一下現(xiàn)有expross框架中獲取參數(shù)的方式,整體上并沒有太深入的仿制,主要是這方面內(nèi)容涉及的細(xì)節(jié)過多,只可意會。研究了也就僅僅知道而已,并不能帶來多少積累,除非重頭再造一次輪子。

6. 第六次迭代

本小節(jié)是第六次迭代,主要的目的是介紹一下expresss是如何集成現(xiàn)有的渲染引擎的。與渲染引擎有關(guān)的事情涉及到下面幾個方面:

如何開發(fā)或綁定一個渲染引擎。

如何注冊一個渲染引擎。

如何指定模板路徑。

如何渲染模板引擎。

express通過app.engine(ext, callback) 方法即可創(chuàng)建一個你自己的模板引擎。其中,ext 指的是文件擴(kuò)展名、callback 是模板引擎的主函數(shù),接受文件路徑、參數(shù)對象和回調(diào)函數(shù)作為其參數(shù)。

//下面的代碼演示的是一個非常簡單的能夠渲染 “.ntl” 文件的模板引擎。

var fs = require("fs"); // 此模板引擎依賴 fs 模塊
app.engine("ntl", function (filePath, options, callback) { // 定義模板引擎
  fs.readFile(filePath, function (err, content) {
    if (err) return callback(new Error(err));
    // 這是一個功能極其簡單的模板引擎
    var rendered = content.toString().replace("#title#", ""+ options.title +"")
    .replace("#message#", "

"+ options.message +"

"); return callback(null, rendered); }) });

為了讓應(yīng)用程序可以渲染模板文件,還需要做如下設(shè)置:

//views, 放模板文件的目錄
app.set("views", "./views")
//view engine, 模板引擎
app.set("view engine", "jade")

一旦 view engine 設(shè)置成功,就不需要顯式指定引擎,或者在應(yīng)用中加載模板引擎模塊,Express 已經(jīng)在內(nèi)部加載。下面是如何渲染頁面的方法:

app.get("/", function (req, res) {
  res.render("index", { title: "Hey", message: "Hello there!"});
});

要想實現(xiàn)上述功能,首先在Application類中定義兩個變量,一個存儲app.set 和 app.get 這兩個方法存儲的值,另一個存儲模板引擎中擴(kuò)展名和渲染函數(shù)的對應(yīng)關(guān)系。

function Application() {
    this.settings = {};
    this.engines = {};
}

然后是實現(xiàn)app.set函數(shù)。

Application.prototype.set = function(setting, val) {
      if (arguments.length === 1) {
      // app.get(setting)
      return this.settings[setting];
    }
  
    this.settings[setting] = val;
    return this;
};

代碼中不僅僅實現(xiàn)了設(shè)置,如何傳入的參數(shù)只有一個等價于get函數(shù)。

接著實現(xiàn)app.get函數(shù)。因為現(xiàn)在已經(jīng)有了一個app.get方法用來設(shè)置路由,所以需要在該方法上進(jìn)行重載。

http.METHODS.forEach(function(method) {
    method = method.toLowerCase();
    Application.prototype[method] = function(path, fn) {
        if(method === "get" && arguments.length === 1) {
            // app.get(setting)
            return this.set(path);
        }

        ...
    };
});

最后實現(xiàn)app.engine進(jìn)行擴(kuò)展名和引擎函數(shù)的映射。

Application.prototype.engine = function(ext, fn) {
    // get file extension
    var extension = ext[0] !== "."
      ? "." + ext
      : ext;

    // store engine
    this.engines[extension] = fn;

    return this;
};

擴(kuò)展名當(dāng)做key,統(tǒng)一添加“.”。

到此設(shè)置模板引擎相關(guān)信息的函數(shù)算是完成,接下來就是最重要的渲染引擎函數(shù)的實現(xiàn)。

res.render = function(view, options, callback) {
      var app = this.req.app;
    var done = callback;
    var opts = options || {};
    var self = this;

    //如果定義回調(diào),則返回,否則渲染
    done = done || function(err, str) {
        if(err) {
            return req.next(err);
        }

        self.send(str);
    };

    //渲染
    app.render(view, opts, done);
};

渲染函數(shù)一共有三個參數(shù),view表示模板的名稱,options是模板渲染的變量,callback是渲染成功后的回調(diào)函數(shù)。

函數(shù)內(nèi)部直接調(diào)用render函數(shù)進(jìn)行渲染,渲染完成后調(diào)用done回調(diào)。

接下來創(chuàng)建一個view.js文件,主要功能是負(fù)責(zé)各種模板引擎和框架間的隔離,保持對內(nèi)接口的統(tǒng)一性。

function View(name, options) {
    var opts = options || {};

    this.defaultEngine = opts.defaultEngine;
    this.root = opts.root;

    this.ext = path.extname(name);
    this.name = name;


    var fileName = name;
    if (!this.ext) {
      // get extension from default engine name
      this.ext = this.defaultEngine[0] !== "."
        ? "." + this.defaultEngine
        : this.defaultEngine;

      fileName += this.ext;
    }


    // store loaded engine
    this.engine = opts.engines[this.ext];

    // lookup path
    this.path = this.lookup(fileName);
}

View類內(nèi)部定義了很多屬性,主要包括引擎、根目錄、擴(kuò)展名、文件名等等,為了以后的渲染做準(zhǔn)備。

View.prototype.render = function render(options, callback) {
    this.engine(this.path, options, callback);
};

View的渲染函數(shù)內(nèi)部就是調(diào)用一開始注冊的引擎渲染函數(shù)。

了解了View的定義,接下來實現(xiàn)app.render模板渲染函數(shù)。

Application.prototype.render = function(name, options, callback) {
    var done = callback;
    var engines = this.engines;
    var opts = options;

    view = new View(name, {
      defaultEngine: this.get("view engine"),
      root: this.get("views"),
      engines: engines
    });


    if (!view.path) {
      var err = new Error("Failed to lookup view "" + name + """);
      return done(err);
    }


    try {
      view.render(options, callback);
    } catch (e) {
      callback(e);
    }
};

還有一些細(xì)節(jié)沒有在教程中展示出來,可以參考github上傳的案例代碼。

貌似一切搞定,修改測試用例,嘗試一下。

var fs = require("fs"); // 此模板引擎依賴 fs 模塊
app.engine("ntl", function (filePath, options, callback) { // 定義模板引擎
  fs.readFile(filePath, function (err, content) {
    if (err) return callback(new Error(err));
    // 這是一個功能極其簡單的模板引擎
    var rendered = content.toString().replace("#title#", ""+ options.title +"")
    .replace("#message#", "

"+ options.message +"

"); return callback(null, rendered); }); }); app.set("views", "./test/views"); // 指定視圖所在的位置 app.set("view engine", "ntl"); // 注冊模板引擎 app.get("/", function(req, res, next) { res.render("index", { title: "Hey", message: "Hello there!"}); });

運行node test/index.js,查看效果。

上面的代碼是自己注冊的引擎,如果想要和現(xiàn)有的模板引擎結(jié)合還需要在回調(diào)函數(shù)中引用模板自身的渲染方法,當(dāng)然為了方便,express框架內(nèi)部提供了一個默認(rèn)方法,如果模板引擎導(dǎo)出了該方法,則表示該模板引擎支持express框架,無需使用app.engine再次封裝。

該方法聲明如下:

 __express(filePath, options, callback)

可以參考ejs模板引擎的代碼,看看它們是如何寫的:

//該行代碼在lib/ejs.js文件的355行左右
exports.__express = exports.renderFile;

express框架是如何實現(xiàn)這個默認(rèn)加載的功能的呢?很簡單,只需要在View的構(gòu)造函數(shù)中加一個判斷即可。

if (!opts.engines[this.ext]) {
  // load engine
  var mod = this.ext.substr(1);
  opts.engines[this.ext] = require(mod).__express;
}

代碼很簡單,如果沒有找到引擎對應(yīng)的渲染函數(shù),那就嘗試加載__express函數(shù)。

后記

至此,算是結(jié)束本篇文章了。其實還有很多內(nèi)容可以寫,但是寫的有些煩了,篇幅太長了,大概有一萬三千多字,后面有點應(yīng)付了事的感覺。

簡單的說一下還有哪里沒有介紹。

關(guān)于Application。

如果稍微看過expross代碼的人都會發(fā)現(xiàn),Application并不是想我寫的這樣是一個類,而是一個中間件,一個對象,該對象使用了mixin方法的多繼承手段,express.js文件中的createApplication函數(shù)算是整個框架的切入點。

關(guān)于Router.handle。

這個函數(shù)可以說是整個express框架的核心,如果理解了該函數(shù),整個框架基本上就掌握了。我在仿制的時候舍棄了很多細(xì)節(jié),在這里個函數(shù)里面內(nèi)部有兩個個關(guān)鍵點沒說。一、處理URL形式的參數(shù),這里涉及對params參數(shù)的提取過程。其中有一個restore函數(shù)使用高階函數(shù)的方法做了緩存,仔細(xì)體會很有意思。二、setImmediate異步返回,之所以要使用異步處理,是因為下面的代碼需要運行,包括路徑相關(guān)的

文章版權(quán)歸作者所有,未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為,您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址:http://specialneedsforspecialkids.com/yun/88474.html

相關(guān)文章

  • express源碼閱讀

    摘要:函數(shù)表示增加一個路由,函數(shù)表示監(jiān)聽服務(wù)器。內(nèi)部創(chuàng)建一個叫做的類,并為該類添加兩個方法,和。建立類,并將原來內(nèi)的代碼移動到類中。內(nèi)部在寫代碼之前,先梳理一下上面所有的概念之間的關(guān)系和。代表一個應(yīng)用程序。修改原有的函數(shù)。 express源碼閱讀 簡介:這篇文章的主要目的是分析express的源碼,但是網(wǎng)絡(luò)上express的源碼評析已經(jīng)數(shù)不勝數(shù),所以本文章另辟蹊徑,準(zhǔn)備仿制一個express...

    liangdas 評論0 收藏0
  • 前端最實用書簽(持續(xù)更新)

    摘要:前言一直混跡社區(qū)突然發(fā)現(xiàn)自己收藏了不少好文但是管理起來有點混亂所以將前端主流技術(shù)做了一個書簽整理不求最多最全但求最實用。 前言 一直混跡社區(qū),突然發(fā)現(xiàn)自己收藏了不少好文但是管理起來有點混亂; 所以將前端主流技術(shù)做了一個書簽整理,不求最多最全,但求最實用。 書簽源碼 書簽導(dǎo)入瀏覽器效果截圖showImg(https://segmentfault.com/img/bVbg41b?w=107...

    sshe 評論0 收藏0
  • vue仿追書神器,vue小說項目源碼

    摘要:一點閱讀器源自追書神器,免費使用目前已初步開發(fā)完成項目地址歡迎,,推薦一個之前用文章類閱讀寫的一點閱讀微信小程序一點文章已上線,可以再微信搜索一點文章體驗在線體驗地址點擊這里體驗服務(wù)器太,渲染慢部分效果截圖一點閱讀器優(yōu)勢一點閱讀器追書神 vue-reader 一點閱讀器!API源自追書神器,免費使用!目前已初步開發(fā)完成! Github項目地址:https://github.com/An...

    justCoding 評論0 收藏0

發(fā)表評論

0條評論

最新活動
閱讀需要支付1元查看
<