通過源碼解析 Node.js 中一個 HTTP 請求到響應(yīng)的歷程

qqlcbb 發(fā)布于2019-08-19 18:14 / 939人閱讀

摘要：請求的來到在中，若要收到一個請求，首先需要創(chuàng)建一個類的實例，然后監(jiān)聽它的事件。不斷解析推入的請求體數(shù)據(jù)。處理具體解析完畢的請求。比較繞，以一個簡化的圖示來總結(jié)這部分邏輯響應(yīng)該請求到了響應(yīng)時，事情已經(jīng)簡單許多了，傳入的已經(jīng)獲取到了。

如果大家使用 Node.js 寫過 web 應(yīng)用，那么你一定使用過 http 模塊。在 Node.js 中，起一個 HTTP server 十分簡單，短短數(shù)行即可：

"use stirct"
const { createServer } = require("http")

createServer(function (req, res) {
  res.writeHead(200, { "Content-Type": "text/plain" })
  res.end("Hello World
")
})
.listen(3000, function () { console.log("Listening on port 3000") })

$ curl localhost:3000
Hello World

就這么簡單，因為 Node.js 把許多細(xì)節(jié)都已在源碼中封裝好了，主要代碼在 lib/_http_*.js 這些文件中，現(xiàn)在就讓我們照著上述代碼，看看從一個 HTTP 請求的到來直到響應(yīng)，Node.js 都為我們在源碼層做了些什么。

HTTP 請求的來到

在 Node.js 中，若要收到一個 HTTP 請求，首先需要創(chuàng)建一個 http.Server 類的實例，然后監(jiān)聽它的 request 事件。由于 HTTP 協(xié)議屬于應(yīng)用層，在下層的傳輸層通常使用的是 TCP 協(xié)議，所以 net.Server 類正是 http.Server 類的父類。具體的 HTTP 相關(guān)的部分，是通過監(jiān)聽 net.Server 類實例的 connection 事件封裝的：

// lib/_http_server.js
// ...

function Server(requestListener) {
  if (!(this instanceof Server)) return new Server(requestListener);
  net.Server.call(this, { allowHalfOpen: true });

  if (requestListener) {
    this.addListener("request", requestListener);
  }

  // ...
  this.addListener("connection", connectionListener);

  // ...
}
util.inherits(Server, net.Server);

這時，則需要一個 HTTP parser 來解析通過 TCP 傳輸過來的數(shù)據(jù)：

// lib/_http_server.js
const parsers = common.parsers;
// ...

function connectionListener(socket) {
  // ...
  var parser = parsers.alloc();
  parser.reinitialize(HTTPParser.REQUEST);
  parser.socket = socket;
  socket.parser = parser;
  parser.incoming = null;
  // ...
}

值得一提的是，parser 是從一個“池”中獲取的，這個“池”使用了一種叫做 free list（wiki）的數(shù)據(jù)結(jié)構(gòu)，實現(xiàn)很簡單，個人覺得是為了盡可能的對 parser 進(jìn)行重用，并避免了不斷調(diào)用構(gòu)造函數(shù)的消耗，且設(shè)有數(shù)量上限（http 模塊中為 1000）：

// lib/freelist.js
"use strict";

exports.FreeList = function(name, max, constructor) {
  this.name = name;
  this.constructor = constructor;
  this.max = max;
  this.list = [];
};


exports.FreeList.prototype.alloc = function() {
  return this.list.length ? this.list.pop() :
                            this.constructor.apply(this, arguments);
};


exports.FreeList.prototype.free = function(obj) {
  if (this.list.length < this.max) {
    this.list.push(obj);
    return true;
  }
  return false;
};

由于數(shù)據(jù)是從 TCP 不斷推入的，所以這里的 parser 也是基于事件的，很符合 Node.js 的核心思想。使用的是 http-parser 這個庫：

// lib/_http_common.js
// ...
const binding = process.binding("http_parser");
const HTTPParser = binding.HTTPParser;
const FreeList = require("internal/freelist").FreeList;
// ...

var parsers = new FreeList("parsers", 1000, function() {
  var parser = new HTTPParser(HTTPParser.REQUEST);
  // ...
  parser[kOnHeaders] = parserOnHeaders;
  parser[kOnHeadersComplete] = parserOnHeadersComplete; 
  parser[kOnBody] = parserOnBody; 
  parser[kOnMessageComplete] = parserOnMessageComplete;
  parser[kOnExecute] = null; 

  return parser;
});
exports.parsers = parsers;

// lib/_http_server.js
// ...

function connectionListener(socket) {
  parser.onIncoming = parserOnIncoming;
}

所以一個完整的 HTTP 請求從接收到完全解析，會挨個經(jīng)歷 parser 上的如下事件監(jiān)聽器：

parserOnHeaders：不斷解析推入的請求頭數(shù)據(jù)。

parserOnHeadersComplete：請求頭解析完畢，構(gòu)造 header 對象，為請求體創(chuàng)建 http.IncomingMessage 實例。

parserOnBody：不斷解析推入的請求體數(shù)據(jù)。

parserOnExecute：請求體解析完畢，檢查解析是否報錯，若報錯，直接觸發(fā) clientError 事件。若請求為 CONNECT 方法，或帶有 Upgrade 頭，則直接觸發(fā) connect 或 upgrade 事件。

parserOnIncoming：處理具體解析完畢的請求。

所以接下來，我們的關(guān)注點自然是 parserOnIncoming 這個監(jiān)聽器，正是這里完成了最終 request 事件的觸發(fā)，關(guān)鍵步驟代碼如下：

// lib/_http_server.js
// ...

function connectionListener(socket) {
  var outgoing = [];
  var incoming = [];
  // ...
  
  function parserOnIncoming(req, shouldKeepAlive) {
    incoming.push(req);
    // ...
    var res = new ServerResponse(req);
    
    if (socket._httpMessage) { // 這里判斷若為真，則說明 socket 正在被隊列中之前的 ServerResponse 實例占用
      outgoing.push(res);
    } else {
      res.assignSocket(socket);
    }
    
    res.on("finish", resOnFinish);
    function resOnFinish() {
      incoming.shift();
      // ...
      var m = outgoing.shift();
      if (m) {
        m.assignSocket(socket);
      }
    }
    // ...
    self.emit("request", req, res);
  }
}

可以看出，對于同一個 socket 發(fā)來的請求，源碼中分別維護(hù)了兩個隊列，用于緩沖 IncomingMessage 實例和對應(yīng)的 ServerResponse 實例。先來的 ServerResponse 實例先占用 socket ，監(jiān)聽其 finish 事件，從各自隊列中釋放該 ServerResponse 實例和對應(yīng)的 IncomingMessage 實例。

比較繞，以一個簡化的圖示來總結(jié)這部分邏輯：

響應(yīng)該 HTTP 請求

到了響應(yīng)時，事情已經(jīng)簡單許多了，傳入的 ServerResponse 已經(jīng)獲取到了 socket。http.ServerResponse 繼承于一個內(nèi)部類 http.OutgoingMessage，當(dāng)我們調(diào)用 ServerResponse#writeHead 時，Node.js 為我們拼湊好了頭字符串，并緩存在 ServerResponse 實例內(nèi)部的 _header 屬性中：

// lib/_http_outgoing.js
// ...

OutgoingMessage.prototype._storeHeader = function(firstLine, headers) {
  // ...
  if (headers) {
    var keys = Object.keys(headers);
    var isArray = Array.isArray(headers);
    var field, value;

    for (var i = 0, l = keys.length; i < l; i++) {
      var key = keys[i];
      if (isArray) {
        field = headers[key][0];
        value = headers[key][1];
      } else {
        field = key;
        value = headers[key];
      }

      if (Array.isArray(value)) {
        for (var j = 0; j < value.length; j++) {
          storeHeader(this, state, field, value[j]);
        }
      } else {
        storeHeader(this, state, field, value);
      }
    }
  }
  // ...
  this._header = state.messageHeader + CRLF; 
}

緊接著在調(diào)用 ServerResponse#end 時，將數(shù)據(jù)拼湊在頭字符串后，添加對應(yīng)的尾部，推入 TCP ，具體的寫入操作在內(nèi)部方法 ServerResponse#_writeRaw 中：

// lib/_http_outgoing.js
// ...

OutgoingMessage.prototype.end = function(data, encoding, callback) {
  // ...
  if (this.connection && data)
    this.connection.cork();
    
  var ret;
  if (data) {
    this.write(data, encoding);
  }
  
  if (this._hasBody && this.chunkedEncoding) {
    ret = this._send("0
" + this._trailer + "
", "binary", finish);
  } else {
    ret = this._send("", "binary", finish);
  }
  
  if (this.connection && data)
    this.connection.uncork();
    
  // ...
  return ret;
}

OutgoingMessage.prototype._writeRaw = function(data, encoding, callback) {
  if (typeof encoding === "function") {
    callback = encoding;
    encoding = null;
  }

  var connection = this.connection;
  // ...
  return connection.write(data, encoding, callback);
};

最后

到這，一個請求就已經(jīng)通過 TCP ，發(fā)回給客戶端了。其實本文中，只涉及到了一條主線進(jìn)行解析，源碼中還考慮了更多的情況，如超時，socket 被占用時的緩存，特殊頭，上游突然出現(xiàn)問題，更高效的已寫頭的查詢等等。非常值得一讀。

參考：

https://github.com/nodejs/node/blob/master/lib/_http_common.js

https://github.com/nodejs/node/blob/master/lib/_http_outgoing.js

https://github.com/nodejs/node/blob/master/lib/_http_server.js