从No.js看Node.js原理-清一色财经

本文通过实现一个类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"
intmain(intargc,char*argv[]){
//InitializeV8.
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::CreateParamscreate_params;
create_params.array_buffer_allocator=
v8::ArrayBuffer::Allocator::NewDefaultAllocator();
//创建一个Isolate，表示一个隔离的实例
v8::Isolate*isolate=v8::Isolate::New(create_params);
{
v8::Isolate::Scopeisolate_scope(isolate);
//定义一个HandleScope管理下面的handle内存的分配和释放
v8::HandleScopehandle_scope(isolate);
//创建一个上下文，js里访问的东西来自context
v8::Local<v8::Context>context=v8::Context::New(isolate);
v8::Context::Scopecontext_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::Utf8Valueutf8(isolate,result);
printf("%s\n",*utf8);
}
//DisposetheisolateandteardownV8.
isolate->Dispose();
v8::V8::Dispose();
v8::V8::ShutdownPlatform();
deletecreate_params.array_buffer_allocator;
return0;
}

我们看代码很多，但是大部分的根据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);
//打开文件
intfd=open(argv[1],O_RDONLY);
structstatinfo;
//取得文件信息
fstat(fd,&info);
//分配内存保存文件内容
char*ptr=(char*)malloc(info.st_size+1);
//读取文件搭配ptr，Macos的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，我们看看实现。

staticvoidInvoke(constFunctionCallbackInfo<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里，我们自定义的函数格式如下

staticvoidfunc(constFunctionCallbackInfo<Value>&info){
info.GetReturnValue().Set(返回值);
}

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

functionInvoke(){
returnServer;
}
//---
functionServer(){
TCPServer.NewTCPServer(this);
}
Server.prototype.socket=functionsocket(){
returnthis[0].socket();
}
//---
classTCPServer(){
constructor(target){
target[0]=this;
this.persistent_handle_=target;
}
staticNewTCPServer(target){
newTCPServer(target);
}
socket(){}
bind(){}
...
}

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

constServer=TCP();
constserver=newServer('127.0.0.1',8989);
server.socket();
server.bind();
server.listen();
while(1){
server.accept();
}

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

staticvoidNewTCPServer(constFunctionCallbackInfo<Value>&info){
String::Utf8Valueip_address(info.GetIsolate(),info[0]);
intport=info[1].As<Uint32>()->Value();
//info.This()就是obj
newTCPServer(info.GetIsolate(),info.This(),*ip_address,port);
}
//在this中保存object，析构C++对象的时候需要重置object[0]
TCPServer(Isolate*isolate,Local<Object>object,char*ip,intport):_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函数
staticvoidTCPServerSocket(constFunctionCallbackInfo<Value>&info){
GetTCPServer(info.Holder())->Socket();
}
//取出真正的对象，即obj[0]
staticTCPServer*GetTCPServer(Local<Object>object){
returnreinterpret_cast<TCPServer*>((*reinterpret_cast<v8::Local<Object>*>(&object))->GetAlignedPointerFromInternalField(0));
}

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

intSocket(){
listerFd=socket(AF_INET,SOCK_STREAM,0);
returnlisterFd;
}
intBind(){
structsockaddr_inserv_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);
returnbind(listerFd,(structsockaddr*)&serv_addr,sizeof(serv_addr));
}
intListen(){
returnlisten(listerFd,512);
}
intAccept(){
intclientFd=accept(listerFd,nullptr,nullptr);
//返回ok，然后关闭TCP连接
constchar*rsp="connectok";
write(clientFd,rsp,sizeof(rsp));
close(clientFd);
return0;
}
intSetsockopt(intlevel,intoptionName,constvoid*optionValue,socklen_toption_len){
returnsetsockopt(listerFd,level,optionName,optionValue,option_len);
}
intClose(){
returnclose(listerFd);
}

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

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

这时候我们启动客户端。

constnet=require('net');
functionhandle(){
setTimeout(()=>{
constsocket=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

©本文为清一色官方代发，观点仅代表作者本人，与清一色无关。清一色对文中陈述、观点判断保持中立，不对所包含内容的准确性、可靠性或完整性提供任何明示或暗示的保证。本文不作为投资理财建议，请读者仅作参考，并请自行承担全部责任。文中部分文字/图片/视频/音频等来源于网络，如侵犯到著作权人的权利，请与我们联系（微信/QQ:1074760229）。转载请注明出处：清一色财经