從No.js看Node.js原理
作者：theanarkh
本文通過實現一個類Node.js的JS運行時No.js，去理解Node.js的本質。No.js是我之前寫的一個JS運行時，概念上是這么說，但是它算不上真正的運行時，它只是個demo，但是它讓你看到如果你有興趣，你也可以寫個Node.js。
本文轉載自微信公眾號「編程雜技」，作者theanarkh。轉載本文請聯系編程雜技公眾號。
越來越多同學在使用Node.js，大家也不同程度地理解Node.js是什么。比如Node.js是由V8、Libuv、JS組成的，Node.js底層是C\C++，Node.js不是語言是運行時。本文通過實現一個類Node.js的JS運行時No.js，去理解Node.js的本質。No.js是我之前寫的一個JS運行時，概念上是這么說，但是它算不上真正的運行時，它只是個demo，但是它讓你看到如果你有興趣，你也可以寫個Node.js。
首先我們看看V8的基本用法。
- #include <stdio.h>
- #include <stdlib.h>
- #include <string.h>
- #include "include/libplatform/libplatform.h"
- #include "include/v8.h"
- int main(int argc, char* argv[]) {
- // Initialize V8.
- v8::V8::InitializeICUDefaultLocation(argv[0]);
- v8::V8::InitializeExternalStartupData(argv[0]);
- std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();
- v8::V8::InitializePlatform(platform.get());
- v8::V8::Initialize();
- v8::Isolate::CreateParams create_params;
- create_params.array_buffer_allocator =
- v8::ArrayBuffer::Allocator::NewDefaultAllocator();
- // 創建一個Isolate，表示一個隔離的實例
- v8::Isolate* isolate = v8::Isolate::New(create_params);
- {
- v8::Isolate::Scope isolate_scope(isolate);
- // 定義一個HandleScope 管理下面的handle內存的分配和釋放
- v8::HandleScope handle_scope(isolate);
- // 創建一個上下文，js里訪問的東西來自context
- v8::Local<v8::Context> context = v8::Context::New(isolate);
- v8::Context::Scope context_scope(context);
- // 定義我們要執行的代碼
- v8::Local<v8::String> source = v8::String::NewFromUtf8(isolate, "'Hello' + ', World!'",v8::NewStringType::kNormal).ToLocalChecked();
- // 編譯腳本
- v8::Local<v8::Script> script = v8::Script::Compile(context, source).ToLocalChecked();
- // 執行腳本
- v8::Local<v8::Value> result = script->Run(context).ToLocalChecked();
- // 輸出結果
- v8::String::Utf8Value utf8(isolate, result);
- printf("%s\n", *utf8);
- }
- // Dispose the isolate and tear down V8.
- isolate->Dispose();
- v8::V8::Dispose();
- v8::V8::ShutdownPlatform();
- delete create_params.array_buffer_allocator;
- return 0;
- }
我們看代碼很多，但是大部分的根據V8文檔就行，最核心的是context和腳本的定義，我們看到這里的context是V8提供的內容，然后執行的JS腳本也平平無奇。下面我們要做的事情就是拓展這個context，給他注入一下新功能，相應地，在JS里也就能訪問V8內置變量之外的變量，我們看看怎么搞。
- // 拿到一個全局變量，這個就是我們在js里對應的全局變量
- Local<Object> global = context->Global();
- // 定義一個字符串對象
- Local<Value> key = String::NewFromUtf8(isolate, "TCP", NewStringType::kNormal, strlen("TCP")).ToLocalChecked();
- Local<Value> cbdata = String::NewFromUtf8(isolate, "dummy", NewStringType::kNormal, strlen("dummy")).ToLocalChecked();
- // 定義一個函數
- Local<Function> func = Function::New(context,
- // 執行func時會調用Invoke，cbdata是入參
- Invoke,
- cbdata).ToLocalChecked();
- // 把函數注冊到全局變量，這樣我們在js里就可以使用key該函數了
- Maybe<bool> ignore = global->Set(context, key, func);
- // 打開文件
- int fd = open(argv[1], O_RDONLY);
- struct stat info;
- // 取得文件信息
- fstat(fd, &info);
- // 分配內存保存文件內容
- char *ptr = (char *)malloc(info.st_size + 1);
- // 讀取文件搭配ptr，Mac os的read函數定義第二個參數是void *
- read(fd, (void *)ptr, info.st_size);
- // 要執行的js代碼
- Local<String> source = String::NewFromUtf8(isolate, ptr,
- NewStringType::kNormal,
- info.st_size).ToLocalChecked();
上面代碼主要分為幾個部分。
1 從context中獲取全局變量。
2 定義一個新功能，并注入到全局變量，這樣我們就可以在JS里訪問了。
3 打開一個文件并且讀取進來，交給V8編譯執行。下面我們看重點，即我們自定義的功能。從注釋里我們看到我們給注入了一個TCP的全局變量。他的值是一個函數。當我們在JS里執行TCP這個函數的時候，就會執行我們自定義的C++函數，并傳入實參。我們定義的函數是Invoke，我們看看實現。
- static void Invoke(const FunctionCallbackInfo<Value>& info) {
- Isolate * isolate = info.GetIsolate();
- // 新建一個函數模版，模版函數是TCPServer::NewTCPServer
- Local<FunctionTemplate> Server = FunctionTemplate::New(isolate, TCPServer::NewTCPServer);
- Local<String> tcpServerString = String::NewFromUtf8(isolate, "TCPServer", NewStringType::kNormal, strlen("TCPServer")).ToLocalChecked();
- // 函數名
- Server ->SetClassName(tcpServerString);
- // 預留一個指針空間，保存一些自定義的上下文
- Server->InstanceTemplate()->SetInternalFieldCount(1);
- // 設置TCPServer的原型方法
- SetProtoMethod(isolate, Server, "socket", TCPServer::TCPServerSocket);
- SetProtoMethod(isolate, Server, "bind", TCPServer::TCPServerBind);
- SetProtoMethod(isolate, Server, "listen", TCPServer::TCPServerListen);
- SetProtoMethod(isolate, Server, "accept", TCPServer::TCPServerAccept);
- //SetProtoMethod(isolate, Server, "setsockopt", TCPServer::TCPServerSetsockopt);
- info.GetReturnValue().Set(Server->GetFunction(isolate->GetCurrentContext()).ToLocalChecked());
- }
上面代碼看起來很復雜，主要是對V8 API的使用。在V8里，我們自定義的函數格式如下
- static void func(const FunctionCallbackInfo<Value>& info) {
- info.GetReturnValue().Set(返回值);
- }
入參是FunctionCallbackInfo<Value>,函數的返回值通過info.GetReturnValue().Set函數設置。即我們在JS層拿到的內容。上面代碼翻譯成JS如下。
- function Invoke() {
- return Server;
- }
- // ---
- function Server() {
- TCPServer.NewTCPServer(this);
- }
- Server.prototype.socket = function socket() {
- return this[0].socket();
- }
- // ---
- class TCPServer(){
- constructor(target) {
- target[0] = this;
- this.persistent_handle_ = target;
- }
- static NewTCPServer(target) {
- new TCPServer(target);
- }
- socket() {}
- bind() {}
- ...
- }
可以看到，執行Invoke后拿到一個函數TCPServer。然后我們執行new TCPServer，JS代碼如下（server.js）
- const Server = TCP();
- const server = new Server('127.0.0.1', 8989);
- server.socket();
- server.bind();
- server.listen();
- while(1) {
- server.accept();
- }
當我們執行new Server的時候。V8首先會創建一個對象obj，然后執行TCPServer.NewTCPServer。并傳入obj對象。
- static void NewTCPServer(const FunctionCallbackInfo<Value>& info) {
- String::Utf8Value ip_address(info.GetIsolate(), info[0]);
- int port = info[1].As<Uint32>()->Value();
- // info.This()就是obj
- new TCPServer(info.GetIsolate(),info.This(), *ip_address, port);
- }
- // 在this中保存object，析構C++對象的時候需要重置object[0]
- TCPServer(Isolate* isolate, Local<Object> object, char * ip, int port): _isolate(isolate),persistent_handle_(isolate, object), _ip(ip), _port(port) {
- // obj[0]=this
- object->SetAlignedPointerInInternalField(0, static_cast<void*>(this));
- }
NewTCPServer同樣創建一個對象this，然后通過obj[0]=this關聯起來，這是核心邏輯，一會我們會看到有什么用。接下來我們執行一系列網絡編程的函數，不過原理是一樣的，我們就分析server.socket()。因為server是一個Server實例。所以server.socket() 對應的函數是Server.prototype.socket。這個函數會從this中取出真正對象（TCPServer實例）的socket函數。然后執行它。
- // 執行真正對象的socket函數
- static void TCPServerSocket(const FunctionCallbackInfo<Value>& info) {
- GetTCPServer(info.Holder())->Socket();
- }
- // 取出真正的對象，即obj[0]
- static TCPServer * GetTCPServer(Local<Object> object) {
- return reinterpret_cast<TCPServer *>((*reinterpret_cast<v8::Local<Object>*>(&object))->GetAlignedPointerFromInternalField(0));
- }
從中我們可以看到Server函數是一個透傳的作用。他主要用于適配V8的協議。真正的邏輯是在它關聯的對象中實現的。其余的實現如下。
- int Socket() {
- listerFd = socket(AF_INET, SOCK_STREAM, 0);
- return listerFd;
- }
- int Bind() {
- struct sockaddr_in serv_addr;
- memset(&serv_addr, 0, sizeof(serv_addr));
- serv_addr.sin_family = AF_INET;
- serv_addr.sin_addr.s_addr = inet_addr(_ip);
- serv_addr.sin_port = htons(_port);
- return bind(listerFd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
- }
- int Listen() {
- return listen(listerFd, 512);
- }
- int Accept() {
- int clientFd = accept(listerFd, nullptr, nullptr);
- // 返回ok，然后關閉TCP連接
- const char * rsp = "connect ok";
- write(clientFd, rsp, sizeof(rsp));
- close(clientFd);
- return 0;
- }
- int Setsockopt(int level, int optionName, const void *optionValue, socklen_t option_len) {
- return setsockopt(listerFd, level, optionName, optionValue, option_len);
- }
- int Close() {
- return close(listerFd);
- }
都是對socket網絡編程的封裝。最后我們通過No server.js啟動服務器，全部代碼執行完后，最后阻塞在accept。
- while(1) {
- server.accept();
- }
這時候我們啟動客戶端。
- const net = require('net');
- function handle() {
- setTimeout(() => {
- const socket = net.connect({host: '127.0.0.1', port: 8989 });
- socket.on('connect', () => {
- console.log('ok');
- socket.destroy();
- handle();
- });
- }, 1000);
- }
- handle();
我們會看到不斷輸出ok，因為一直在斷連重連。至此我們通過拓展V8完成了一個服務器的開發。
后記：本文通過拓展V8實現一個簡單的樸素版TCP服務器來了如何拓展V8，而Node.js正是用了這種方式。再封裝一下操作系統的文件、網絡、進程、線程、IPC等等，我們也可以實現一個Node.js。當然，這是理論上。No.js倉庫https://github.com/theanarkh/No.js
責任編輯：武曉燕
來源：
編程雜技
