[[410265]]

本文轉(zhuǎn)載自微信公眾號「編程雜技」，作者theanarkh。轉(zhuǎn)載本文請聯(lián)系編程雜技公眾號。

越來越多同學(xué)在使用Node.js，大家也不同程度地理解Node.js是什么。比如Node.js是由V8、Libuv、JS組成的，Node.js底層是C\C++，Node.js不是語言是運(yùn)行時。本文通過實(shí)現(xiàn)一個類Node.js的JS運(yùn)行時No.js，去理解Node.js的本質(zhì)。No.js是我之前寫的一個JS運(yùn)行時，概念上是這么說，但是它算不上真正的運(yùn)行時，它只是個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(); 
  // 創(chuàng)建一個Isolate，表示一個隔離的實(shí)例 
  v8::Isolate* isolate = v8::Isolate::New(create_params); 
  { 
    v8::Isolate::Scope isolate_scope(isolate); 
    // 定義一個HandleScope 管理下面的handle內(nèi)存的分配和釋放 
    v8::HandleScope handle_scope(isolate); 
    // 創(chuàng)建一個上下文，js里訪問的東西來自context 
    v8::Local<v8::Context> context = v8::Context::New(isolate); 
    v8::Context::Scope context_scope(context); 
    // 定義我們要執(zhí)行的代碼 
    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(); 
    // 執(zhí)行腳本 
    v8::Local<v8::Value> result = script->Run(context).ToLocalChecked(); 
    // 輸出結(jié)果 
    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; 
} 

我們看代碼很多，但是大部分的根據(jù)V8文檔就行，最核心的是context和腳本的定義，我們看到這里的context是V8提供的內(nèi)容，然后執(zhí)行的JS腳本也平平無奇。下面我們要做的事情就是拓展這個context，給他注入一下新功能，相應(yīng)地，在JS里也就能訪問V8內(nèi)置變量之外的變量，我們看看怎么搞。

// 拿到一個全局變量，這個就是我們在js里對應(yīng)的全局變量 
      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(); 
      // 定義一個函數(shù)                    
      Local<Function> func = Function::New(context, 
                        // 執(zhí)行func時會調(diào)用Invoke，cbdata是入?yún)?nbsp;
                        Invoke, 
                        cbdata).ToLocalChecked();    
      // 把函數(shù)注冊到全局變量，這樣我們在js里就可以使用key該函數(shù)了                                     
      Maybe<bool> ignore = global->Set(context, key, func); 
      // 打開文件 
      int fd = open(argv[1], O_RDONLY); 
      struct stat info; 
      // 取得文件信息 
      fstat(fd, &info); 
      // 分配內(nèi)存保存文件內(nèi)容 
      char *ptr = (char *)malloc(info.st_size + 1); 
      // 讀取文件搭配ptr，Mac os的read函數(shù)定義第二個參數(shù)是void * 
      read(fd, (void *)ptr, info.st_size); 
      // 要執(zhí)行的js代碼 
      Local<String> source = String::NewFromUtf8(isolate, ptr, 
                          NewStringType::kNormal, 
                          info.st_size).ToLocalChecked(); 

上面代碼主要分為幾個部分。

1 從context中獲取全局變量。

2 定義一個新功能，并注入到全局變量，這樣我們就可以在JS里訪問了。

3 打開一個文件并且讀取進(jìn)來，交給V8編譯執(zhí)行。下面我們看重點(diǎn)，即我們自定義的功能。從注釋里我們看到我們給注入了一個TCP的全局變量。他的值是一個函數(shù)。當(dāng)我們在JS里執(zhí)行TCP這個函數(shù)的時候，就會執(zhí)行我們自定義的C++函數(shù)，并傳入實(shí)參。我們定義的函數(shù)是Invoke，我們看看實(shí)現(xiàn)。

static void Invoke(const FunctionCallbackInfo<Value>& info) { 
  Isolate * isolate = info.GetIsolate(); 
  // 新建一個函數(shù)模版，模版函數(shù)是TCPServer::NewTCPServer 
  Local<FunctionTemplate> Server = FunctionTemplate::New(isolate, TCPServer::NewTCPServer); 
  Local<String> tcpServerString = String::NewFromUtf8(isolate, "TCPServer", NewStringType::kNormal, strlen("TCPServer")).ToLocalChecked(); 
  // 函數(shù)名 
  Server ->SetClassName(tcpServerString); 
  // 預(yù)留一個指針空間，保存一些自定義的上下文 
  Server->InstanceTemplate()->SetInternalFieldCount(1); 
 
  // 設(shè)置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()); 
} 

上面代碼看起來很復(fù)雜，主要是對V8 API的使用。在V8里，我們自定義的函數(shù)格式如下

static void func(const FunctionCallbackInfo<Value>& info) { 
    info.GetReturnValue().Set(返回值); 
} 

入?yún)⑹荈unctionCallbackInfo<Value>,函數(shù)的返回值通過info.GetReturnValue().Set函數(shù)設(shè)置。即我們在JS層拿到的內(nèi)容。上面代碼翻譯成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() {} 
    ... 
} 

可以看到，執(zhí)行Invoke后拿到一個函數(shù)TCPServer。然后我們執(zhí)行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(); 
} 

當(dāng)我們執(zhí)行new Server的時候。V8首先會創(chuàng)建一個對象obj，然后執(zhí)行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，析構(gòu)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同樣創(chuàng)建一個對象this，然后通過obj[0]=this關(guān)聯(lián)起來，這是核心邏輯，一會我們會看到有什么用。接下來我們執(zhí)行一系列網(wǎng)絡(luò)編程的函數(shù)，不過原理是一樣的，我們就分析server.socket()。因?yàn)閟erver是一個Server實(shí)例。所以server.socket() 對應(yīng)的函數(shù)是Server.prototype.socket。這個函數(shù)會從this中取出真正對象（TCPServer實(shí)例）的socket函數(shù)。然后執(zhí)行它。

// 執(zhí)行真正對象的socket函數(shù) 
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函數(shù)是一個透傳的作用。他主要用于適配V8的協(xié)議。真正的邏輯是在它關(guān)聯(lián)的對象中實(shí)現(xiàn)的。其余的實(shí)現(xiàn)如下。

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，然后關(guān)閉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網(wǎng)絡(luò)編程的封裝。最后我們通過No server.js啟動服務(wù)器，全部代碼執(zhí)行完后，最后阻塞在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，因?yàn)橐恢痹跀噙B重連。至此我們通過拓展V8完成了一個服務(wù)器的開發(fā)。

后記：本文通過拓展V8實(shí)現(xiàn)一個簡單的樸素版TCP服務(wù)器來了如何拓展V8，而Node.js正是用了這種方式。再封裝一下操作系統(tǒng)的文件、網(wǎng)絡(luò)、進(jìn)程、線程、IPC等等，我們也可以實(shí)現(xiàn)一個Node.js。當(dāng)然，這是理論上。No.js倉庫https://github.com/theanarkh/No.js