从No.js看Node.js原理

本文转载自微信公众号「编程杂技」，作者theanarkh。转载本文请联系编程杂技公众号。

创新互联公司-专业网站定制、快速模板网站建设、高性价比特克斯网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式特克斯网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖特克斯地区。费用合理售后完善，10年实体公司更值得信赖。

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

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

 
 
 
    
  
  
  
  1. // 拿到一个全局变量，这个就是我们在js里对应的全局变量 
    2. 
  
  
  
  2.       Local global =  context->Global(); 
  
  
  
  3.       // 定义一个字符串对象 
    4. 
  
  
  
  4.       Local key = String::NewFromUtf8(isolate, "TCP", NewStringType::kNormal, strlen("TCP")).ToLocalChecked(); 
    5. 
  
  
  
  5.       Local cbdata = String::NewFromUtf8(isolate, "dummy", NewStringType::kNormal, strlen("dummy")).ToLocalChecked(); 
    6. 
  
  
  
  6.       // 定义一个函数                    
    7. 
  
  
  
  7.       Local func = Function::New(context, 
    8. 
  
  
  
  8.                         // 执行func时会调用Invoke，cbdata是入参 
    9. 
  
  
  
  9.                         Invoke, 
    10. 
  
  
  
  10.                         cbdata).ToLocalChecked();    
    11. 
  
  
  
  11.       // 把函数注册到全局变量，这样我们在js里就可以使用key该函数了                                     
    12. 
  
  
  
  12.       Maybe ignore = global->Set(context, key, func); 
    13. 
  
  
  
  13.       // 打开文件 
    14. 
  
  
  
  14.       int fd = open(argv[1], O_RDONLY); 
    15. 
  
  
  
  15.       struct stat info; 
    16. 
  
  
  
  16.       // 取得文件信息 
    17. 
  
  
  
  17.       fstat(fd, &info); 
    18. 
  
  
  
  18.       // 分配内存保存文件内容 
    19. 
  
  
  
  19.       char *ptr = (char *)malloc(info.st_size + 1); 
    20. 
  
  
  
  20.       // 读取文件搭配ptr，Mac os的read函数定义第二个参数是void * 
    21. 
  
  
  
  21.       read(fd, (void *)ptr, info.st_size); 
    22. 
  
  
  
  22.       // 要执行的js代码 
    23. 
  
  
  
  23.       Local source = String::NewFromUtf8(isolate, ptr, 
    24. 
  
  
  
  24.                           NewStringType::kNormal, 
    25. 
  
  
  
  25.                           info.st_size).ToLocalChecked(); 
    26. 
 
 
 
    上面代码主要分为几个部分。
    1 从context中获取全局变量。
    2 定义一个新功能，并注入到全局变量，这样我们就可以在JS里访问了。
    3 打开一个文件并且读取进来，交给V8编译执行。下面我们看重点，即我们自定义的功能。从注释里我们看到我们给注入了一个TCP的全局变量。他的值是一个函数。当我们在JS里执行TCP这个函数的时候，就会执行我们自定义的C++函数，并传入实参。我们定义的函数是Invoke，我们看看实现。
    

     
 
 
      
  
  
  
    1. static void Invoke(const FunctionCallbackInfo& info) { 
      2. 
  
  
  
    2.   Isolate * isolate = info.GetIsolate(); 
      3. 
  
  
  
    3.   // 新建一个函数模版，模版函数是TCPServer::NewTCPServer 
      4. 
  
  
  
    4.   Local Server = FunctionTemplate::New(isolate, TCPServer::NewTCPServer); 
      5. 
  
  
  
    5.   Local tcpServerString = String::NewFromUtf8(isolate, "TCPServer", NewStringType::kNormal, strlen("TCPServer")).ToLocalChecked(); 
      6. 
  
  
  
    6.   // 函数名 
      7. 
  
  
  
    7.   Server ->SetClassName(tcpServerString); 
      8. 
  
  
  
    8.   // 预留一个指针空间，保存一些自定义的上下文 
      9. 
  
  
  
    9.   Server->InstanceTemplate()->SetInternalFieldCount(1); 
      10. 
  
  
  
    10.  
      11. 
  
  
  
    11.   // 设置TCPServer的原型方法 
      12. 
  
  
  
    12.   SetProtoMethod(isolate, Server, "socket", TCPServer::TCPServerSocket); 
      13. 
  
  
  
    13.   SetProtoMethod(isolate, Server, "bind", TCPServer::TCPServerBind); 
      14. 
  
  
  
    14.   SetProtoMethod(isolate, Server, "listen", TCPServer::TCPServerListen); 
      15. 
  
  
  
    15.   SetProtoMethod(isolate, Server, "accept", TCPServer::TCPServerAccept); 
      16. 
  
  
  
    16.   //SetProtoMethod(isolate, Server, "setsockopt", TCPServer::TCPServerSetsockopt); 
      17. 
  
  
  
    17.   info.GetReturnValue().Set(Server->GetFunction(isolate->GetCurrentContext()).ToLocalChecked()); 
      18. 
  
  
  
    18. } 
      19. 
 
 
 
    上面代码看起来很复杂，主要是对V8 API的使用。在V8里，我们自定义的函数格式如下
    

     
 
 
      
  
  
  
    1. static void func(const FunctionCallbackInfo& info) { 
      2. 
  
  
  
    2.     info.GetReturnValue().Set(返回值); 
      3. 
  
  
  
    3. } 
      4. 
 
 
 
    入参是FunctionCallbackInfo,函数的返回值通过info.GetReturnValue().Set函数设置。即我们在JS层拿到的内容。上面代码翻译成JS如下。
    

     
 
 
      
  
  
  
    1. function Invoke() { 
      2. 
  
  
  
    2.     return Server; 
      3. 
  
  
  
    3. } 
      4. 
  
  
  
    4.  
      5. 
  
  
  
    5. // --- 
      6. 
  
  
  
    6. function Server() { 
      7. 
  
  
  
    7.     TCPServer.NewTCPServer(this); 
      8. 
  
  
  
    8. } 
      9. 
  
  
  
    9.  
      10. 
  
  
  
    10. Server.prototype.socket = function socket() { 
      11. 
  
  
  
    11.     return this[0].socket(); 
      12. 
  
  
  
    12. } 
      13. 
  
  
  
    13.  
      14. 
  
  
  
    14. // --- 
      15. 
  
  
  
    15. class TCPServer(){ 
      16. 
  
  
  
    16.     constructor(target) { 
      17. 
  
  
  
    17.         target[0] = this; 
      18. 
  
  
  
    18.         this.persistent_handle_ = target; 
      19. 
  
  
  
    19.     } 
      20. 
  
  
  
    20.  
      21. 
  
  
  
    21.     static NewTCPServer(target) { 
      22. 
  
  
  
    22.         new TCPServer(target); 
      23. 
  
  
  
    23.     } 
      24. 
  
  
  
    24.  
      25. 
  
  
  
    25.     socket() {} 
      26. 
  
  
  
    26.     bind() {} 
      27. 
  
  
  
    27.     ... 
      28. 
  
  
  
    28. } 
      29. 
 
 
 
    可以看到，执行Invoke后拿到一个函数TCPServer。然后我们执行new TCPServer，JS代码如下（server.js）
    

     
 
 
      
  
  
  
    1. const Server = TCP(); 
      2. 
  
  
  
    2. const server = new Server('127.0.0.1', 8989); 
      3. 
  
  
  
    3. server.socket(); 
      4. 
  
  
  
    4. server.bind(); 
      5. 
  
  
  
    5. server.listen(); 
      6. 
  
  
  
    6. while(1) { 
      7. 
  
  
  
    7.     server.accept(); 
      8. 
  
  
  
    8. } 
      9. 
 
 
 
    当我们执行new Server的时候。V8首先会创建一个对象obj，然后执行TCPServer.NewTCPServer。并传入obj对象。
    

     
 
 
      
  
  
  
    1. static void NewTCPServer(const FunctionCallbackInfo& info) { 
      2. 
  
  
  
    2.     String::Utf8Value ip_address(info.GetIsolate(), info[0]); 
      3. 
  
  
  
    3.     int port = info[1].As()->Value(); 
      4. 
  
  
  
    4.     // info.This()就是obj 
      5. 
  
  
  
    5.     new TCPServer(info.GetIsolate(),info.This(), *ip_address, port); 
      6. 
  
  
  
    6. } 
      7. 
  
  
  
    7.  
      8. 
  
  
  
    8. // 在this中保存object，析构C++对象的时候需要重置object[0] 
      9. 
  
  
  
    9. TCPServer(Isolate* isolate, Local object, char * ip, int port): _isolate(isolate),persistent_handle_(isolate, object), _ip(ip), _port(port) { 
  
  
  
    10.    // obj[0]=this 
      11. 
  
  
  
    11.    object->SetAlignedPointerInInternalField(0, static_cast(this)); 
      12. 
  
  
  
    12. } 
      13. 
 
 
 
      NewTCPServer同样创建一个对象this，然后通过obj[0]=this关联起来，这是核心逻辑，一会我们会看到有什么用。接下来我们执行一系列网络编程的函数，不过原理是一样的，我们就分析server.socket()。因为server是一个Server实例。所以server.socket() 对应的函数是Server.prototype.socket。这个函数会从this中取出真正对象（TCPServer实例）的socket函数。然后执行它。
      

       
 
 
        
  
  
  
      1. // 执行真正对象的socket函数 
        2. 
  
  
  
      2. static void TCPServerSocket(const FunctionCallbackInfo& info) { 
        3. 
  
  
  
      3.   GetTCPServer(info.Holder())->Socket(); 
        4. 
  
  
  
      4. } 
        5. 
  
  
  
      5.  
        6. 
  
  
  
      6. // 取出真正的对象，即obj[0] 
        7. 
  
  
  
      7. static TCPServer * GetTCPServer(Local object) { 
  
  
  
      8.     return reinterpret_cast((*reinterpret_cast*>(&object))->GetAlignedPointerFromInternalField(0)); 
        9. 
  
  
  
      9.  } 
        10. 
 
 
 
        从中我们可以看到Server函数是一个透传的作用。他主要用于适配V8的协议。真正的逻辑是在它关联的对象中实现的。其余的实现如下。
        

         
 
 
          
  
  
  
        1. int Socket() { 
          2. 
  
  
  
        2.     listerFd = socket(AF_INET, SOCK_STREAM, 0); 
          3. 
  
  
  
        3.     return listerFd; 
          4. 
  
  
  
        4. } 
          5. 
  
  
  
        5.  
          6. 
  
  
  
        6. int Bind() {     
          7. 
  
  
  
        7.     struct sockaddr_in serv_addr; 
          8. 
  
  
  
        8.     memset(&serv_addr, 0, sizeof(serv_addr)); 
          9. 
  
  
  
        9.     serv_addr.sin_family = AF_INET; 
          10. 
  
  
  
        10.     serv_addr.sin_addr.s_addr = inet_addr(_ip); 
          11. 
  
  
  
        11.     serv_addr.sin_port = htons(_port); 
          12. 
  
  
  
        12.     return bind(listerFd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)); 
          13. 
  
  
  
        13. } 
          14. 
  
  
  
        14.  
          15. 
  
  
  
        15. int Listen() { 
          16. 
  
  
  
        16.     return listen(listerFd, 512); 
          17. 
  
  
  
        17. } 
          18. 
  
  
  
        18.  
          19. 
  
  
  
        19. int Accept() { 
          20. 
  
  
  
        20.     int clientFd = accept(listerFd, nullptr, nullptr); 
          21. 
  
  
  
        21.     // 返回ok，然后关闭TCP连接 
          22. 
  
  
  
        22.     const char * rsp = "connect ok"; 
          23. 
  
  
  
        23.     write(clientFd, rsp, sizeof(rsp)); 
          24. 
  
  
  
        24.     close(clientFd); 
          25. 
  
  
  
        25.     return 0; 
          26. 
  
  
  
        26. } 
          27. 
  
  
  
        27.  
          28. 
  
  
  
        28. int Setsockopt(int level, int optionName, const void *optionValue, socklen_t option_len) { 
          29. 
  
  
  
        29.     return setsockopt(listerFd, level, optionName, optionValue, option_len); 
          30. 
  
  
  
        30. } 
          31. 
  
  
  
        31.  
          32. 
  
  
  
        32. int Close() { 
          33. 
  
  
  
        33.     return close(listerFd); 
          34. 
  
  
  
        34. } 
          35. 
 
 
 
        都是对socket网络编程的封装。最后我们通过No server.js启动服务器，全部代码执行完后，最后阻塞在accept。
        

         
 
 
          
  
  
  
        1. while(1) { 
          2. 
  
  
  
        2.     server.accept(); 
          3. 
  
  
  
        3. } 
          4. 
 
 
 
        这时候我们启动客户端。
        

         
 
 
          
  
  
  
        1. const net = require('net'); 
          2. 
  
  
  
        2.  
          3. 
  
  
  
        3. function handle() { 
          4. 
  
  
  
        4.     setTimeout(() => { 
          5. 
  
  
  
        5.         const socket = net.connect({host: '127.0.0.1', port: 8989 }); 
          6. 
  
  
  
        6.         socket.on('connect', () => { 
          7. 
  
  
  
        7.             console.log('ok'); 
          8. 
  
  
  
        8.             socket.destroy(); 
          9. 
  
  
  
        9.             handle(); 
          10. 
  
  
  
        10.         }); 
          11. 
  
  
  
        11.     }, 1000); 
          12. 
  
  
  
        12. } 
          13. 
  
  
  
        13. handle(); 
          14. 
 
 
 
        我们会看到不断输出ok，因为一直在断连重连。至此我们通过拓展V8完成了一个服务器的开发。
        后记：本文通过拓展V8实现一个简单的朴素版TCP服务器来了如何拓展V8，而Node.js正是用了这种方式。再封装一下操作系统的文件、网络、进程、线程、IPC等等，我们也可以实现一个Node.js。当然，这是理论上。No.js仓库https://github.com/theanarkh/No.js
                    
        
                当前题目：从No.js看Node.js原理
                
        
                转载注明：http://www.csdahua.cn/qtweb/news45/512195.html
            
        
            
        
                网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
        
            
        
                广告
                
            
        
            
        
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                快上网
            
        
        
        
        
            
        成都快上网为您推荐相关内容
        
            
        
        
    
    
        
        
        
            
        电子商务知识
        
            
        
        
        
        
            
        行业网站建设
        
            
        
        
    
        


        
    
        
        四川成都做网站　　 　成都未宇聚　　 　都江堰做网站　　 　西信服务器托管　　 　无边发光字厂家　　 　南充机房托管　　 　网站推广公司　　 　视频运营　　 　达州网站制作　　 　成都口碑营销公司　　 　鸿艺文化　　 　成都网络营销　　 　云服务器　　 　营山母婴护理中心　　 　seo网络营销推广　　 　成都免费做网站公司　　 　成都网站建设公司　　 　凯亚自动化控制　　 　成都翻译公司　　 　app开发