深入学习 Node.js Http

GET / HTTP/1.1
Host: www.baidu.com
Connection: keep-alive
Cache-Control: max-age=0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.110 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8

HTTP/1.1 200 OK
Server: bfe/1.0.8.18
Date: Thu, 30 Mar 2017 12:28:00 GMT
Content-Type: text/html; charset=utf-8
Connection: keep-alive
Cache-Control: private
Expires: Thu, 30 Mar 2017 12:27:43 GMT

var parsers = new FreeList('parsers', 1000, function() {
  var parser = new HTTPParser(HTTPParser.REQUEST);
  //...
}

class FreeList {
  constructor(name, max, ctor) {
    this.name = name; // 管理的对象名称
    this.ctor = ctor; // 管理对象的构造函数
    this.max = max; // 存储对象的最大值
    this.list = []; // 存储对象的数组
  }

  alloc() {
    return this.list.length ?
      this.list.pop() :
      this.ctor.apply(this, arguments);
  }

  free(obj) {
    if (this.list.length < this.max) {
      this.list.push(obj);
      return true;
    }
    return false;
  }
}

function IncomingMessage(socket) {
  Stream.Readable.call(this);

  this.socket = socket;
  this.connection = socket;

  this.httpVersion = null;
  this.complete = false;
  this.trailers = {}; 
  this.headers = {}; // 解析后的请求头
  this.rawHeaders = []; // 原始的头部信息

  // request (server) only
  this.url = ''; // 请求url地址
  this.method = null; // 请求地址
}
util.inherits(IncomingMessage, Stream.Readable);

function ServerResponse(req) {
  OutgoingMessage.call(this);

  if (req.method === 'HEAD') this._hasBody = false;

  this.sendDate = true;
  this._sent100 = false;
  this._expect_continue = false;

  if (req.httpVersionMajor < 1 || req.httpVersionMinor < 1) {
    this.useChunkedEncodingByDefault = chunkExpression.test(req.headers.te);
    this.shouldKeepAlive = false;
  }
}
util.inherits(ServerResponse, OutgoingMessage);

const http = require("http");

const server = http.createServer((req, res) => {
  res.end("Hello Semlinker!");
});

server.listen(3000, () => {
  console.log("server listen on 3000");
});

function createServer(requestListener) {
  return new Server(requestListener);
}

function Server(options, requestListener) {
  if (!(this instanceof Server)) return new Server(options, requestListener);

  if (typeof options === 'function') {
    requestListener = options;
    options = {};
  } else if (options == null || typeof options === 'object') {
    options = util._extend({}, options);
  }

  net.Server.call(this, { allowHalfOpen: true });

  if (requestListener) {
    this.on('request', requestListener);
  }

  this.on('connection', connectionListener);
  this.timeout = 2 * 60 * 1000; // 设置超时时间
}
util.inherits(Server, net.Server);

(req, res) => {
  res.end("Hello Semlinker!");
}

function connectionListener(socket) {
  defaultTriggerAsyncIdScope(
    getOrSetAsyncId(socket), connectionListenerInternal, this, socket
  );
}

function connectionListenerInternal(server, socket) {
  httpSocketSetup(socket);

  if (socket.server === null)
    socket.server = server;
  
  if (server.timeout && typeof socket.setTimeout === 'function')
    socket.setTimeout(server.timeout);
  socket.on('timeout', socketOnTimeout); // 处理超时情况

  var parser = parsers.alloc(); // 获取parser对象
  parser.reinitialize(HTTPParser.REQUEST);
  parser.socket = socket;
  socket.parser = parser;
  parser.incoming = null;

  var state = {
    outgoing: [],
    incoming: [], 
    //...
  };
  parser.onIncoming = parserOnIncoming.bind(undefined, server, socket, state);
}

var parsers = new FreeList('parsers', 1000, function() {
  var parser = new HTTPParser(HTTPParser.REQUEST);

  parser._headers = [];
  parser._url = '';
  parser._consumed = false;

  parser.socket = null;
  parser.incoming = null;
  parser.outgoing = null;
  
  parser[kOnHeaders] = parserOnHeaders;
  parser[kOnHeadersComplete] = parserOnHeadersComplete;
  parser[kOnBody] = parserOnBody;

  return parser;
});

const { methods, HTTPParser } = process.binding('http_parser');

function parserOnIncoming(server, socket, state, req, keepAlive) {
  state.incoming.push(req); // 缓冲IncomingMessage实例

  var res = new server[kServerResponse](req);

  if (socket._httpMessage) {
    state.outgoing.push(res); // 缓冲ServerResponse实例
  } else {
    res.assignSocket(socket);
  }

  // 判断请求头是否包含expect字段且http协议的版本为1.1
  if (req.headers.expect !== undefined &&
      (req.httpVersionMajor === 1 && req.httpVersionMinor === 1)) {
    // continueExpression: /(?:^|\W)100-continue(?:$|\W)/i
    // Expect: 100-continue
    if (continueExpression.test(req.headers.expect)) {
      res._expect_continue = true;

      if (server.listenerCount('checkContinue') > 0) {
        server.emit('checkContinue', req, res);
      } else {
        res.writeContinue();
        server.emit('request', req, res);
      }
    } else if (server.listenerCount('checkExpectation') > 0) {
      server.emit('checkExpectation', req, res);
    } else {
      // HTTP协议中的417Expectation Failed 状态码表示客户端错误，意味着服务器无法满足
      // Expect请求消息头中的期望条件。
      res.writeHead(417);
      res.end();
    }
  } else {
    server.emit('request', req, res);
  }
  return 0;  
}

const http = require("http");

http.get('http://jsonplaceholder.typicode.com/users', (res) => {
  console.log(`Got response: ${res.statusCode}`);
  let data = '';

  res.on('data', (chunk) => {
    data += chunk;
  });

  res.on('end', () => {
    console.log(JSON.parse(data));
  });
}).on('error', (e) => {
  console.log(`Got error: ${e.message}`);
});