从No.js看Node.js原理

开发 前端
本文通过实现一个类Node.js的JS运行时No.js,去理解Node.js的本质。No.js是我之前写的一个JS运行时,概念上是这么说,但是它算不上真正的运行时,它只是个demo,但是它让你看到如果你有兴趣,你也可以写个Node.js。

 [[410265]]

本文转载自微信公众号「编程杂技」,作者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的基本用法。

  1. #include <stdio.h> 
  2. #include <stdlib.h> 
  3. #include <string.h> 
  4. #include "include/libplatform/libplatform.h" 
  5. #include "include/v8.h" 
  6.  
  7. int main(int argc, char* argv[]) { 
  8.   // Initialize V8. 
  9.   v8::V8::InitializeICUDefaultLocation(argv[0]); 
  10.   v8::V8::InitializeExternalStartupData(argv[0]); 
  11.   std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform(); 
  12.   v8::V8::InitializePlatform(platform.get()); 
  13.   v8::V8::Initialize(); 
  14.  
  15.   v8::Isolate::CreateParams create_params; 
  16.   create_params.array_buffer_allocator = 
  17.       v8::ArrayBuffer::Allocator::NewDefaultAllocator(); 
  18.   // 创建一个Isolate,表示一个隔离的实例 
  19.   v8::Isolate* isolate = v8::Isolate::New(create_params); 
  20.   { 
  21.     v8::Isolate::Scope isolate_scope(isolate); 
  22.     // 定义一个HandleScope 管理下面的handle内存的分配和释放 
  23.     v8::HandleScope handle_scope(isolate); 
  24.     // 创建一个上下文,js里访问的东西来自context 
  25.     v8::Local<v8::Context> context = v8::Context::New(isolate); 
  26.     v8::Context::Scope context_scope(context); 
  27.     // 定义我们要执行的代码 
  28.     v8::Local<v8::String> source = v8::String::NewFromUtf8(isolate, "'Hello' + ', World!'",v8::NewStringType::kNormal).ToLocalChecked(); 
  29.     // 编译脚本 
  30.     v8::Local<v8::Script> script = v8::Script::Compile(context, source).ToLocalChecked(); 
  31.     // 执行脚本 
  32.     v8::Local<v8::Value> result = script->Run(context).ToLocalChecked(); 
  33.     // 输出结果 
  34.     v8::String::Utf8Value utf8(isolate, result); 
  35.     printf("%s\n", *utf8); 
  36.   } 
  37.  
  38.   // Dispose the isolate and tear down V8. 
  39.   isolate->Dispose(); 
  40.   v8::V8::Dispose(); 
  41.   v8::V8::ShutdownPlatform(); 
  42.   delete create_params.array_buffer_allocator; 
  43.   return 0; 

我们看代码很多,但是大部分的根据V8文档就行,最核心的是context和脚本的定义,我们看到这里的context是V8提供的内容,然后执行的JS脚本也平平无奇。下面我们要做的事情就是拓展这个context,给他注入一下新功能,相应地,在JS里也就能访问V8内置变量之外的变量,我们看看怎么搞。

  1. // 拿到一个全局变量,这个就是我们在js里对应的全局变量 
  2.       Local<Object> global =  context->Global(); 
  3.       // 定义一个字符串对象 
  4.       Local<Value> key = String::NewFromUtf8(isolate, "TCP", NewStringType::kNormal, strlen("TCP")).ToLocalChecked(); 
  5.       Local<Value> cbdata = String::NewFromUtf8(isolate, "dummy", NewStringType::kNormal, strlen("dummy")).ToLocalChecked(); 
  6.       // 定义一个函数                    
  7.       Local<Function> func = Function::New(context, 
  8.                         // 执行func时会调用Invoke,cbdata是入参 
  9.                         Invoke, 
  10.                         cbdata).ToLocalChecked();    
  11.       // 把函数注册到全局变量,这样我们在js里就可以使用key该函数了                                     
  12.       Maybe<bool> ignore = global->Set(context, key, func); 
  13.       // 打开文件 
  14.       int fd = open(argv[1], O_RDONLY); 
  15.       struct stat info; 
  16.       // 取得文件信息 
  17.       fstat(fd, &info); 
  18.       // 分配内存保存文件内容 
  19.       char *ptr = (char *)malloc(info.st_size + 1); 
  20.       // 读取文件搭配ptr,Mac os的read函数定义第二个参数是void * 
  21.       read(fd, (void *)ptr, info.st_size); 
  22.       // 要执行的js代码 
  23.       Local<String> source = String::NewFromUtf8(isolate, ptr, 
  24.                           NewStringType::kNormal, 
  25.                           info.st_size).ToLocalChecked(); 

上面代码主要分为几个部分。

1 从context中获取全局变量。

2 定义一个新功能,并注入到全局变量,这样我们就可以在JS里访问了。

3 打开一个文件并且读取进来,交给V8编译执行。下面我们看重点,即我们自定义的功能。从注释里我们看到我们给注入了一个TCP的全局变量。他的值是一个函数。当我们在JS里执行TCP这个函数的时候,就会执行我们自定义的C++函数,并传入实参。我们定义的函数是Invoke,我们看看实现。

  1. static void Invoke(const FunctionCallbackInfo<Value>& info) { 
  2.   Isolate * isolate = info.GetIsolate(); 
  3.   // 新建一个函数模版,模版函数是TCPServer::NewTCPServer 
  4.   Local<FunctionTemplate> Server = FunctionTemplate::New(isolate, TCPServer::NewTCPServer); 
  5.   Local<String> tcpServerString = String::NewFromUtf8(isolate, "TCPServer", NewStringType::kNormal, strlen("TCPServer")).ToLocalChecked(); 
  6.   // 函数名 
  7.   Server ->SetClassName(tcpServerString); 
  8.   // 预留一个指针空间,保存一些自定义的上下文 
  9.   Server->InstanceTemplate()->SetInternalFieldCount(1); 
  10.  
  11.   // 设置TCPServer的原型方法 
  12.   SetProtoMethod(isolate, Server, "socket", TCPServer::TCPServerSocket); 
  13.   SetProtoMethod(isolate, Server, "bind", TCPServer::TCPServerBind); 
  14.   SetProtoMethod(isolate, Server, "listen", TCPServer::TCPServerListen); 
  15.   SetProtoMethod(isolate, Server, "accept", TCPServer::TCPServerAccept); 
  16.   //SetProtoMethod(isolate, Server, "setsockopt", TCPServer::TCPServerSetsockopt); 
  17.   info.GetReturnValue().Set(Server->GetFunction(isolate->GetCurrentContext()).ToLocalChecked()); 

上面代码看起来很复杂,主要是对V8 API的使用。在V8里,我们自定义的函数格式如下

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

入参是FunctionCallbackInfo<Value>,函数的返回值通过info.GetReturnValue().Set函数设置。即我们在JS层拿到的内容。上面代码翻译成JS如下。

  1. function Invoke() { 
  2.     return Server; 
  3.  
  4. // --- 
  5. function Server() { 
  6.     TCPServer.NewTCPServer(this); 
  7.  
  8. Server.prototype.socket = function socket() { 
  9.     return this[0].socket(); 
  10.  
  11. // --- 
  12. class TCPServer(){ 
  13.     constructor(target) { 
  14.         target[0] = this; 
  15.         this.persistent_handle_ = target; 
  16.     } 
  17.  
  18.     static NewTCPServer(target) { 
  19.         new TCPServer(target); 
  20.     } 
  21.  
  22.     socket() {} 
  23.     bind() {} 
  24.     ... 

可以看到,执行Invoke后拿到一个函数TCPServer。然后我们执行new TCPServer,JS代码如下(server.js)

  1. const Server = TCP(); 
  2. const server = new Server('127.0.0.1', 8989); 
  3. server.socket(); 
  4. server.bind(); 
  5. server.listen(); 
  6. while(1) { 
  7.     server.accept(); 

当我们执行new Server的时候。V8首先会创建一个对象obj,然后执行TCPServer.NewTCPServer。并传入obj对象。

  1. static void NewTCPServer(const FunctionCallbackInfo<Value>& info) { 
  2.     String::Utf8Value ip_address(info.GetIsolate(), info[0]); 
  3.     int port = info[1].As<Uint32>()->Value(); 
  4.     // info.This()就是obj 
  5.     new TCPServer(info.GetIsolate(),info.This(), *ip_address, port); 
  6.  
  7. // 在this中保存object,析构C++对象的时候需要重置object[0] 
  8. TCPServer(Isolate* isolate, Local<Object> object, char * ip, int port): _isolate(isolate),persistent_handle_(isolate, object), _ip(ip), _port(port) { 
  9.    // obj[0]=this 
  10.    object->SetAlignedPointerInInternalField(0, static_cast<void*>(this)); 

NewTCPServer同样创建一个对象this,然后通过obj[0]=this关联起来,这是核心逻辑,一会我们会看到有什么用。接下来我们执行一系列网络编程的函数,不过原理是一样的,我们就分析server.socket()。因为server是一个Server实例。所以server.socket() 对应的函数是Server.prototype.socket。这个函数会从this中取出真正对象(TCPServer实例)的socket函数。然后执行它。

  1. // 执行真正对象的socket函数 
  2. static void TCPServerSocket(const FunctionCallbackInfo<Value>& info) { 
  3.   GetTCPServer(info.Holder())->Socket(); 
  4.  
  5. // 取出真正的对象,即obj[0] 
  6. static TCPServer * GetTCPServer(Local<Object> object) { 
  7.     return reinterpret_cast<TCPServer *>((*reinterpret_cast<v8::Local<Object>*>(&object))->GetAlignedPointerFromInternalField(0)); 
  8.  } 

从中我们可以看到Server函数是一个透传的作用。他主要用于适配V8的协议。真正的逻辑是在它关联的对象中实现的。其余的实现如下。

  1. int Socket() { 
  2.     listerFd = socket(AF_INET, SOCK_STREAM, 0); 
  3.     return listerFd; 
  4.  
  5. int Bind() {     
  6.     struct sockaddr_in serv_addr; 
  7.     memset(&serv_addr, 0, sizeof(serv_addr)); 
  8.     serv_addr.sin_family = AF_INET; 
  9.     serv_addr.sin_addr.s_addr = inet_addr(_ip); 
  10.     serv_addr.sin_port = htons(_port); 
  11.     return bind(listerFd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)); 
  12.  
  13. int Listen() { 
  14.     return listen(listerFd, 512); 
  15.  
  16. int Accept() { 
  17.     int clientFd = accept(listerFd, nullptr, nullptr); 
  18.     // 返回ok,然后关闭TCP连接 
  19.     const char * rsp = "connect ok"
  20.     write(clientFd, rsp, sizeof(rsp)); 
  21.     close(clientFd); 
  22.     return 0; 
  23.  
  24. int Setsockopt(int levelint optionName, const void *optionValue, socklen_t option_len) { 
  25.     return setsockopt(listerFd, level, optionName, optionValue, option_len); 
  26.  
  27. int Close() { 
  28.     return close(listerFd); 

都是对socket网络编程的封装。最后我们通过No server.js启动服务器,全部代码执行完后,最后阻塞在accept。

  1. while(1) { 
  2.     server.accept(); 

这时候我们启动客户端。

  1. const net = require('net'); 
  2.  
  3. function handle() { 
  4.     setTimeout(() => { 
  5.         const socket = net.connect({host: '127.0.0.1', port: 8989 }); 
  6.         socket.on('connect', () => { 
  7.             console.log('ok'); 
  8.             socket.destroy(); 
  9.             handle(); 
  10.         }); 
  11.     }, 1000); 
  12. handle(); 

我们会看到不断输出ok,因为一直在断连重连。至此我们通过拓展V8完成了一个服务器的开发。

后记:本文通过拓展V8实现一个简单的朴素版TCP服务器来了如何拓展V8,而Node.js正是用了这种方式。再封装一下操作系统的文件、网络、进程、线程、IPC等等,我们也可以实现一个Node.js。当然,这是理论上。No.js仓库https://github.com/theanarkh/No.js

 

责任编辑:武晓燕 来源: 编程杂技
相关推荐

2021-11-06 18:40:27

js底层模块

2013-11-01 09:34:56

Node.js技术

2015-03-10 10:59:18

Node.js开发指南基础介绍

2011-09-08 13:46:14

node.js

2011-09-02 14:47:48

Node

2011-11-01 10:30:36

Node.js

2011-09-09 14:23:13

Node.js

2012-10-24 14:56:30

IBMdw

2011-11-10 08:55:00

Node.js

2021-12-25 22:29:57

Node.js 微任务处理事件循环

2020-05-29 15:33:28

Node.js框架JavaScript

2015-06-23 15:27:53

HproseNode.js

2012-02-03 09:25:39

Node.js

2016-05-18 10:15:25

PythonNode.js

2024-07-08 08:53:52

2021-04-06 10:15:29

Node.jsHooks前端

2020-10-26 08:34:13

Node.jsCORS前端

2021-02-01 15:42:45

Node.jsSQL应用程序

2022-08-28 16:30:34

Node.jsDocker指令

2021-10-04 19:49:23

HTTP模块No.js
点赞
收藏

51CTO技术栈公众号