从No.js看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

很赞哦!（7626）