本文主要过下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连接，至此这个客户端请求就处理完成了。

最新文章

1. AngularJS的学习--ng-show/ng-hide/ng-if和ng-switch
2. CF460 A. Vasya and Socks
3. kafka原理存储
4. codevs 1506 传话
5. 350. Intersection of Two Arrays II
6. 关于AVD无法使用问题
7. 在 ASP.NET MVC 应用中使用 NInject 注入 ASMX 类型的 Web Service
8. 【.NET】单例模式标准写法
9. 转载 Memcached BinaryProtocol incr指令内存泄露的bug
10. Early 80386 CPUs
11. 用CSS指定外部链接的样式
12. 轻量级集群管理软件-ClusterShell
13. openvpn搭建和使用
14. IdentityServer-Setup and Overview
15. 【JavaScript】浅析IIFE（立即执行函数表达式）的作用
16. soft nofile
17. FLV文件格式官方规范详解
18. spring配置datasource
19. P2471 [SCOI2007]降雨量
20. Codeforces Round #257 (Div. 2) E题：Jzzhu and Apples 模拟

热门文章

1. C++泛型基础学习
2. cassandra权威指南读书笔记--引言概要
3. 2019牛客国庆集训派对day2
4. Educational Codeforces Round 91 (Rated for Div. 2) D. Berserk And Fireball
5. 2019牛客多校 Round4
6. Codeforces Round #135 (Div. 2) D. Choosing Capital for Treeland
7. Codeforces Round #540 (Div. 3) C. Palindromic Matrix (大模拟)
8. 牛客练习赛70 A.重新排列 (,字符串思维)
9. 在异步或子线程中show窗体的时候要用MethodInvoker委托，要不然show不出来
10. [笔记]吞吐量（TPS）、QPS、并发数、响应时间（RT）概念