http server原始碼解析

duan777發表於2021-02-24
HTTPServer原始碼

本文主要過下http生成服務和處理請求的主要流程，其他功能並未涉及。

使用例子

const http = require('http');

http.createServer((req, res) => {
  res.end('hello word');
}).listen(8080);

例子中從生成服務，到接收請求，最後響應請求，其中主要的工作有4部分，分別是：

  • 呼叫http.createServer來生成一個服務
  • 呼叫listen函式監聽埠
  • 接收請求，生成req和res物件
  • 執行業務函式，執行res.end響應請求

http.createServer和listen

// lib/http.js
function createServer(opts, requestListener) {
  return new Server(opts, requestListener);
}

// lib/_http_server.js
function Server(options, requestListener) {
  if (typeof options === 'function') {
    requestListener = options;
    options = {};
  }
  // ...
  if (requestListener) {
    // 當req和res物件都生成好以後，就會觸發request事件，讓業務函式對請求進行處理
    this.on('request', requestListener);
  }

  // connection事件可以在net Server類中看到，當三次握手完成後，就會觸發這個事件
  this.on('connection', connectionListener);
}
ObjectSetPrototypeOf(Server.prototype, net.Server.prototype);
ObjectSetPrototypeOf(Server, net.Server);

function connectionListener(socket) {
  // 這裡就是執行connectionListenerInternal函式並傳入this和socket引數
  defaultTriggerAsyncIdScope(
    getOrSetAsyncId(socket), connectionListenerInternal, this, socket
  );
}

// connection事件觸發後的回撥函式，這個函式將在“解析生成req、res物件”板塊進行講解
function connectionListenerInternal(server, socket) {
  // ...
}

呼叫http.createServer函式時，會返回一個Server例項，Server是從net Server類繼承而來的。因此，http Server例項也就具備監聽埠生成服務，與客戶端通訊的能力。前面例子中呼叫的listen函式，實際上就是net Server中的listen。

在例項Server物件的過程中，會分別監聽request和connection這兩個事件。

  • connection：這裡監聽的就是net中的connection事件，當客戶端發起請求，TCP三次握手連線成功時，服務端就會觸發connection事件。connection事件的回撥函式connectionListenerInternal將在下一個板塊進行講解。
  • request：當req和res物件都初始成功以後，就會發布request事件，前面程式碼中我們可以看到request事件的回撥函式requestListener就是開發者呼叫http.createServer時傳入的回撥函式，這個回撥函式會接收req和res兩個物件。

生成req、res物件

當客戶端TCP請求與服務端連線成功後，服務端就會觸發connection事件，此時就會例項一個http-parser用來解析客戶端請求，當客戶端資料解析成功後，就會生成一個req物件，接下來我們先來看下req物件生成過程。

// lib/_http_server.js
function Server(options, requestListener) {
  // ...
  // 客戶端與服務端三次握手完成，觸發connection事件
  this.on('connection', connectionListener);
}

function connectionListener(socket) {
  // 這裡就是執行connectionListenerInternal函式並傳入this和socket引數
  defaultTriggerAsyncIdScope(
    getOrSetAsyncId(socket), connectionListenerInternal, this, socket
  );
}

/**
 * @param {http Server} server
 * @param {net Socket} socket
 */
function connectionListenerInternal(server, socket) {
  // ...
  // parsers.alloc函式執行會使用返回一個free list分配的HTTPParser物件
  const parser = parsers.alloc();
  // 請求解析器初始化工作
  parser.initialize(
    HTTPParser.REQUEST,
    new HTTPServerAsyncResource('HTTPINCOMINGMESSAGE', socket),
    server.maxHeaderSize || 0,
    server.insecureHTTPParser === undefined ?
      isLenient() : server.insecureHTTPParser,
    server.headersTimeout || 0,
  );
  parser.socket = socket;
  socket.parser = parser;
  // ...
}

// lib/_http_common.js
const parsers = new FreeList('parsers', 1000, function parsersCb() {
  // 這裡使用http-parser庫來作為請求解析器
  const parser = new HTTPParser();
  cleanParser(parser);
  // ...
  return parser;
});

http Server中使用http-parser例項來作為客戶端請求的解析器。值得注意的是，這裡使用了free list資料結構來分配parser物件。

// lib/internal/freelist.js
class FreeList {
  constructor(name, max, ctor) {
    this.name = name;
    this.ctor = ctor;
    this.max = max;
    this.list = [];
  }

  // 需要物件，分配一個物件
  alloc() {
    return this.list.length > 0 ?
      this.list.pop() :
      // 這裡的ctor是例項FreeList物件時，傳入的統一新增物件的方法
      ReflectApply(this.ctor, this, arguments);
  }

  // 物件用完，釋放物件
  free(obj) {
    if (this.list.length < this.max) {
      this.list.push(obj);
      return true;
    }
    return false;
  }
}

這部分運用到free list資料結構。使用該資料結構目的是減少物件新建銷燬所帶來的效能消耗，它會維護一個長度固定的佇列，佇列中的所有物件大小都相同。當需要使用物件的時候，會優先從佇列中獲取空閒的物件，如果佇列中已經沒有可用的物件，就會新建一個與佇列中存放的物件大小相同的物件，供程式使用。物件使用完後，不會直接銷燬，而是會將物件壓入佇列中，直到後面被推出使用。

瞭解free list後，我們繼續來看下客戶端請求的解析。

// lib/_http_common.js
const parsers = new FreeList('parsers', 1000, function parsersCb() {
  const parser = new HTTPParser();

  cleanParser(parser);

  // 為這些事件繫結回撥函式
  parser[kOnHeaders] = parserOnHeaders;
  parser[kOnHeadersComplete] = parserOnHeadersComplete;
  parser[kOnBody] = parserOnBody;
  parser[kOnMessageComplete] = parserOnMessageComplete;

  return parser;
});

http-parser在解析客戶端請求也是基於事件來對資料進行處理：

  • kOnHeaders：不斷解析請求頭
  • kOnHeadersComplete：請求頭解析完成
  • kOnBody：不斷解析請求體
  • kOnMessageComplete：請求體解析完成

TCP在進行資料傳輸的過程中，會將超出緩衝區剩餘空間大小的資料進行拆包，使得同一個請求資料包可能分多次傳送給服務端。這裡kOnHeaders和kOnBody就是用於拼接被拆分的資料，組合同一個請求的資料。

當請求頭解析完成以後，會執行kOnHeadersComplete回撥函式，在這個回撥函式中會生成req物件。

// lib/_http_common.js
const { IncomingMessage } = require('_http_incoming');
// 請求頭解析完成後執行的回撥函式
function parserOnHeadersComplete(versionMajor, versionMinor, headers, method, url, statusCode, statusMessage, upgrade, shouldKeepAlive) {
  const parser = this;
  const { socket } = parser;
  // ...
  // 絕大多數情況下socket.server[kIncomingMessage]等於IncomingMessage
  const ParserIncomingMessage = (socket && socket.server && socket.server[kIncomingMessage]) || IncomingMessage;
  const incoming = parser.incoming = new ParserIncomingMessage(socket);
  // ...
  return parser.onIncoming(incoming, shouldKeepAlive);
}

// lib/_http_incoming.js
function IncomingMessage(socket) {
  // ...
}

kOnHeadersComplete回撥中例項出來的IncomingMessage物件就是req物件。回撥最後會執行parser.onIncoming函式，生成res物件。

// lib/_http_server.js
function connectionListenerInternal(server, socket) {
  // ...
  // 這個就是kOnHeadersComplete回撥最後執行的函式
  parser.onIncoming = FunctionPrototypeBind(parserOnIncoming, undefined, server, socket, state);
  // ...
}

// 第四個引數就是req物件，req物件是在parser.onIncoming(incoming, shouldKeepAlive)函式執行的時候傳入的incoming物件
function parserOnIncoming(server, socket, state, req, keepAlive) {
  // ...
  ArrayPrototypePush(state.incoming, req);

  // 例項res物件
  const res = new server[kServerResponse](req);

  if (socket._httpMessage) {
    ArrayPrototypePush(state.outgoing, res);
  }

  // ...
  // 這個事件會在呼叫res.end的時候觸發
  res.on('finish', FunctionPrototypeBind(resOnFinish, undefined, req, res, socket, state, server));
  // ...
    server.emit('request', req, res); // 釋出request事件，執行createServer函式呼叫傳入的業務處理函式
  // ...
}

// 這裡的ServerResponse繼承於OutgoingMessage類，後續將會介紹到
this[kServerResponse] = options.ServerResponse || ServerResponse;

當req和res物件都初始成功並存放後，就會執行createServer函式呼叫傳入的業務處理函式。
當req生成後，邊會執行parserOnIncoming生成res物件，同時會在res物件中註冊finish事件，當業務程式碼執行res.end的時候，就會觸發這個事件。當req和res物件都準備好後，就會發布request事件，同時將req和res物件傳入。request事件的回撥函式就是業務程式碼呼叫http.createServer時傳入的回撥函式。

res.end執行

const http = require('http');

http.createServer((req, res) => {
  res.end('hello word');
}).listen(8080);

當業務處理完成後，業務程式碼中主動呼叫res.end()函式，響應客戶端請求，接下來我們看下。

// lib/_http_server.js
function ServerResponse(req) {
  FunctionPrototypeCall(OutgoingMessage, this);
  // ...
}

ObjectSetPrototypeOf(ServerResponse.prototype, OutgoingMessage.prototype);
ObjectSetPrototypeOf(ServerResponse, OutgoingMessage);

ServerResponse類是從OutgoingMessage類繼承的。業務中使用的res.end方法也是在OutgoingMessage中進行定義的，下面我們看下OutgoingMessage類實現。

// lib/_http_outgoing.js
function OutgoingMessage() {
  // ...
  this._header = null;
  // ...
}

OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
  //...
  if (chunk) {
    // ...
    write_(this, chunk, encoding, null, true);
  }

  // 訂閱finish事件，回撥函式是res.end呼叫時傳入的callback
  if (typeof callback === 'function')
    this.once('finish', callback);

  // ...
    // 使用write_將響應資料寫入響應請求的內容中，然後執行_send繫結finish函式，當資料響應完成後，就會觸發執行這個finish函式
    const finish = FunctionPrototypeBind(onFinish, undefined, this);
    this._send('', 'latin1', finish);
}

function write_(msg, chunk, encoding, callback, fromEnd) {
  // ...
  len = Buffer.byteLength(chunk, encoding);
  // ...
  if (!msg._header) {
    if (fromEnd) {
      msg._contentLength = len;
    }
  }
  //...
  // 業務程式碼中呼叫res.end，_header為null，_implicitHeader函式在lib/_http_server.js中被重寫，_implicitHeader執行會將一個header+CRLF賦值給msg._header
  if (!msg._header) {
    msg._implicitHeader();
  }
  // ...
    ret = msg._send(chunk, encoding, callback);
  // ...
}

OutgoingMessage.prototype._send = function _send(data, encoding, callback) {
  if (!this._headerSent) {
    if (typeof data === 'string' &&
        (encoding === 'utf8' || encoding === 'latin1' || !encoding)) {
      // _implicitHeader函式生成為_header賦值響應頭+CRLF，因此這裡的data最終的值為響應頭+CRLF+響應體
      data = this._header + data;
    } else {
      const header = this._header;
      ArrayPrototypeUnshift(this.outputData, {
        data: header,
        encoding: 'latin1',
        callback: null
      });
    }
    this._headerSent = true;
  }
  return this._writeRaw(data, encoding, callback);
};

OutgoingMessage.prototype._writeRaw = _writeRaw;
function _writeRaw(data, encoding, callback) {
  const conn = this.socket;
  // ...

  if (conn && conn._httpMessage === this && conn.writable) {
    // ...
    // 將響應的內容新增到響應緩衝區，並寫出返回給使用者，當寫出成功以後執行回撥函式
    return conn.write(data, encoding, callback);
  }
  // ...
}

res.end在執行的時候，主要流程有兩個：

  • 呼叫write_函式，首先會生成響應頭，然後將響應頭存放到_header中，後續再生成響應內容，將響應內容（響應頭+CRLF+響應體）通過socket寫出響應給使用者。
  • 呼叫res._send，向socket.write中寫入finish回撥函式，當服務端的響應內容完全寫出的時候執行finish函式，finish函式內部會發布finish事件。程式中有兩處監聽了finish事件：
    • parserOnIncoming函式中生成res物件後，會在上面監聽finish事件；
    • res.end函式中訂閱了一次finish事件，這裡的回撥函式主要是業務程式碼呼叫res.end時傳入的回撥函式。
// 響應頭內容處理
// lib/_http_server.js
ServerResponse.prototype._implicitHeader = function _implicitHeader() {
  this.writeHead(this.statusCode);
};

ServerResponse.prototype.writeHead = writeHead;
function writeHead(statusCode, reason, obj) {
  // ...
  this._storeHeader(statusLine, headers);
  // ...
}

// lib/_http_outgoing.js
OutgoingMessage.prototype._storeHeader = _storeHeader;
function _storeHeader(firstLine, headers) {
  // ...
    this._last = true;
  // ...
  this._header = header + CRLF;
  this._headerSent = false;
  // ...
}

_implicitHeader執行會將響應頭+CRLF內容存放到res._header中，此時響應頭已經處理完，等到需要使用socket.write響應請求的時候，再取出來同響應體一同返回給客戶端。

// lib/_http_server.js
function parserOnIncoming(server, socket, state, req, keepAlive) {
  // 注意這裡也訂閱了res物件中的finish事件
  res.on('finish',
         FunctionPrototypeBind(resOnFinish, undefined,
                               req, res, socket, state, server));
}

function resOnFinish(req, res, socket, state, server) {
  // 清除state中存放的req物件
  ArrayPrototypeShift(state.incoming);
  clearRequestTimeout(req);
  clearIncoming(req);
  // 關閉res
  process.nextTick(emitCloseNT, res);
  // 關閉socket連線
  if (res._last) {
    if (typeof socket.destroySoon === 'function') {
      socket.destroySoon();
    } else {
      socket.end(); // socket斷開連線
    }
  }
}

function emitCloseNT(self) {
  self.destroyed = true;
  self._closed = true;
  self.emit('close');
}

當finish事件觸發，程式會首先將緩衝的req和res物件刪除，然後關閉socket連線，至此這個客戶端請求就處理完成了。

相關文章