Node.js C++插件实践指南

简介

熟悉Node.js的人都知道，Node.js是基于C++开发的一个JavaScript运行时，既然Node.js是用C++开发的，那么我能否将C++代码引入到Node.js中呢，这当然是可以的，这项技术被称为C++模块。官方对Node.js C++模块解释如下

Node.JS插件是使用C++编写的动态链接库，可以被Node.JS以require的形式载入，在使用时就像Node.js原生模块一样。主要被用于在Node.js的JavaScript和C或者C++库之间建立起桥梁的关系。

动态链接库，即window平台的.dll文件，linux下的.so文件。只不过Node.js模块导出的是.node文件。

动态链接库提供了一种方法，使进程可以调用不属于其可执行代码的函数，函数的可执行代码位于一个.dll (window)或.so (linux)文件中，该文件包含一个或多个已被编译、链接并与使用它们的进程分开存储的函数。说到动态链接库，不得不提一下静态链接库，静态链接库是指在编译阶段就把相关的函数库（静态库）链接，合成一个可执行文件。

那么，为什么需要C++模块?

JavaScript是基于异步，单线程的语言，对于一些异步任务非常占优势，但对于一些计算密集型的任务，也有明显的劣势（也许这是脚本语言的缺点）。换句话说使用JavaScript解释器执行JavaScript代码的效率通常是比直接执行一个C++编译好的二进制文件效率要低。除此之外，其实很多开源库是基于C++写的，比如图像处理库（ImageMagick），像我们团队使用的图像处理库，也是基于C++编写（用JavaScript写，性能达不到要求），所以对于一些问题使用C++来实现，效率和性能能有显著的提升，何乐而不为呢。

因此本文从C++插件基本原理以及几种编写方式来向读者介绍如何将C++代码加载到JavaScript中（编写Node.js C++模块）

原理浅析

前面提到，Node.js的C++模块是以动态链接库存在的(.node)，那么Node.JS是如何加载C++模块的呢。首先Node.js的一个模块时一个遵循CommonJS规范书写的JavaScript源文件(.js)，也可能是一个C++模块二进制文件(.node)，这些文件通过Node.js中的 require() 函数被引入并使用。

在Node.js中引入C++模块的本质就是在Node.js运行时引入一个动态链接库的过程。在Node.js中通过 require() 函数加载模块，无论是Node.js模块还是C++模块。那么知道这个函数怎么实现的就知道怎么加载模块的。

为了揭开require的正面目，我们翻开Node.js的源码(Node.js Github)

在lib/internal/modules/cjs/loader.js，我们可以找到Module实现的JavaScript代码

function Module(id = '', parent) { // Class Module
  this.id = id; // 模块id
  this.path = path.dirname(id);
  this.exports = {}; //
  this.parent = parent;
  updateChildren(parent, this, false);
  this.filename = null;
  this.loaded = false;
  this.children = [];
}

Module._cache = ObjectCreate(null); // Object.create()
Module._pathCache = ObjectCreate(null); // 模块缓存
Module._extensions = ObjectCreate(null); // 对于文件名的处理

let wrap = function(script) {
  // 用下面的wrapper包裹相应的js脚本
  return Module.wrapper[0] + script + Module.wrapper[1];
};

const wrapper = [
  '(function (exports, require, module, __filename, __dirname) { ', 
  '\n});'
];

继续往下翻，找到 require() 的实现

Module.prototype.require = function(id) {
 // ...
 return Module._load(id, this, /* isMain */ false);
 // ... 
};

Module._load = function(request, parent, isMain) {
  // 省略了大部分代码...
  const filename = Module._resolveFilename(request, parent, isMain);
  // 模块在缓存中，则从缓存中加载
  const cachedModule = Module._cache[filename]; 
  if (cachedModule !== undefined) {
    return cachedModule.exports;
  }
  // 内建模块
  const mod = loadNativeModule(filename, request);
  if (mod && mod.canBeRequiredByUsers) return mod.exports;

  // 其他模块的处理
  const module = new Module(filename, parent);

  if (isMain) {
    process.mainModule = module;
    module.id = '.';
  }
  
  Module._cache[filename] = module;
  // ...
  module.load(filename); // 委托到load这个函数
  return module.exports;
};

从上面的代码中可以看到模块的加载规则

1. 如果模块在缓存里，则直接读缓存里的
2. 如果的内建模块，则使用loadNativeModule加载模块
3. 其他情况使用Module.proptype.load函数来加载模块

Module.prototype.load = function(filename) {
  // 省略。。。
  const extension = findLongestRegisteredExtension(filename);
  // 终于到重点了，对每一种扩展，使用不同的函数来处理
  Module._extensions[extension](this, filename);
  this.loaded = true;
  // 省略。。。
};

看到Module._extensions[extension](this, filename);这一行，对.js/.node/.json文件分别处理，让我们将目光放到Module._extensions的实现上

Module.prototype._compile = function(content, filename) {
  // 省略。。。
  const dirname = path.dirname(filename);
  const require = makeRequireFunction(this, redirects);
  let result;
  /* 
  就是用上面的wrapper对content进行包裹，并将对应的参数传进去，所以这就是我们能在Node.js中直接使用require(), __filename, __dirname的原因
  const wrapper = [
  '(function (exports, require, module, __filename, __dirname) { ',
  '\n});'
  ];
  */
  const compiledWrapper = wrapSafe(filename, content, this);
  const exports = this.exports;
  const thisValue = exports;
  const module = this;

  result = compiledWrapper.call(thisValue, exports, require, module,
                                  filename, dirname);
  return result;
};
// Native extension for .js
Module._extensions['.js'] = function(module, filename) {
  // 省略。。。
  const content = fs.readFileSync(filename, 'utf8');
  module._compile(content, filename); // 将wrapper的内容扔到vm模块里去执行
};


// Native extension for .json
Module._extensions['.json'] = function(module, filename) {
  const content = fs.readFileSync(filename, 'utf8');
  // 省略。。。
  module.exports = JSONParse(stripBOM(content));
};


// Native extension for .node
Module._extensions['.node'] = function(module, filename) {
  // 省略。。。
  return process.dlopen(module, path.toNamespacedPath(filename));
};

可以看到，对.node文件的处理是使用process.dlopen函数，但这个函数使用C++实现的（类似于C++插件的编写形式），在src/node_process_methods.cc下能找到这个函数的定义。

env->SetMethodNoSideEffect(target, "cwd", Cwd); //process.cwd()
env->SetMethod(target, "dlopen", binding::DLOpen); // process.dlopen()
env->SetMethod(target, "reallyExit", ReallyExit);
env->SetMethodNoSideEffect(target, "uptime", Uptime);
env->SetMethod(target, "patchProcessObject", PatchProcessObject);

是不是觉得很熟悉，这些的都是process上的方法，我们重点关注binding::DLOpen函数的实现，在src/node_binding.cc下

void DLOpen(const FunctionCallbackInfo& args) { // 里面涉及的V8数据类型，后面会介绍，其实这也算是一个C++插件
  Environment* env = Environment::GetCurrent(args);
  auto context = env->context();

  CHECK_NULL(thread_local_modpending);
  // 对照着上面的process.dlopen(module, filename)
  if (args.Length() < 2) {
    env->ThrowError("process.dlopen needs at least 2 arguments.");
    return;
  }

  int32_t flags = DLib::kDefaultFlags;
  if (args.Length() > 2 && !args[2]->Int32Value(context).To(&flags)) {
    return env->ThrowTypeError("flag argument must be an integer.");
  }

  Local