Node中完整的 node addon 实现流程
iamgeek · 93浏览 · 发布于2022-09-23 +关注

这篇文章主要介绍了Node中完整的node addon实现流程,文章围绕主题展开详细的内容介绍,具有一定的参考价值,需要的小伙伴可以参考一下


背景介绍

为什么要写 node addon

试想这样一种场景:我们想在 js 层实现某个业务场景,但是这套业务逻辑已经有存在的 C++ 版本了,这个时候我们有两个选择

  • 重新实现一套在 JS 版本的业务场景

  • 使用 node addon 桥接 C++ 版本代码

对比以上两种方案,显然,使用 addon 不用去写过重的业务逻辑,是一种成本更低的方案

node addon 是什么

  • node addon,即为 node 插件 / 扩展,插件是用 C++ 编写的动态链接共享对象。

    • 动态链接共享对象,即动态链接库

    • 链接库:库文件的二进制版本,即将库文件进行编译、打包操作后得到二进制文件,无法独立运行,必须等待其他程序调用才会被载入内存中。

    • 静态链接:无论缺失的地址位于其他目标文件还是链接库,链接库都会逐个找到各目标文件中缺失的地址。采用此链接方式生成的可执行文件,可以独立载入内存运行。

    • 动态链接:链接器先从所有目标文件中找到部分缺失的地址,然后将所有目标文件组织成一个可执行文件。这样生成的可执行文件,仍缺失部分函数和变量地址,待文件执行时,需连同所有的链接库文件一起载入内存,再由链接器完成剩余的地址修复工作,才能正常执行

    • 静态链接库:在生成可执行文件之前完成所有链接操作,使用的库文件是静态链接库,后缀名 .a .lib

    • 动态链接库:将部分链接操作推迟到程序执行时才进行,使用的库文件是动态链接库,后缀名:.so .dll .dylib

  • 插件提供了 JavaScript 和 C/C++ 库之间的接口。

  • require 函数可以将插件加载为普通的 Node.js 模块。

  • 通俗点来讲,是一个能够桥接 c++ 和 js 的中间转换层

可通过 NODE-API、NAN、或者使用底层 v8 库来实现【官方建议使用 NODE-API】

  • node-api:构建原生插件的 api,独立于 JS 运行时,此 API 是跨 Node.js  版本稳定的应用程序二进制接口,它旨在将插件与底层 JavaScript 引擎中的更改隔离开来,并允许为一个主要版本编译的模块

  • nan(Native Abstractions for Node.js):是一个 Node.js 原生模块抽象接口集。它提供了一套 API

  • 底层 V8:就是我们熟悉的 Chrome V8

addon 实现方式的变迁

Chrome V8 API

1、是啥:即使用 Node 自身各种 API 以及 Chrome V8 的 API

2、存在的问题

这些写好的代码只能在特定的 Node 版本下编译,因为其中各种 API、函数声明等的变化会很大,举个例子

Handle<Value> Echo(const Arguments& args);    // 0.10.x
void Echo(FunctionCallbackInfo<value>& args); // 6.x

NAN 时代

1、是啥:

  • Native Abstractions for Node.js,即 Node.js 原生模块抽象接口集

  • 代码只需要随着 NAN 的升级做改变,它会帮我们兼容各个版本

2、存在的问题

  • 一次写好的代码在不用版本的 Node.js 下也需要重新编译,如果版本不符合,Node.js 就无法正常载入一个 C++ 扩展

    • NAN 的封装方式是使用了一堆宏,在不同的 Node 版本下使用不同的宏变量、函数等,所以针对用户使用不同的 Node 版本,是需要进行重新编译的

符合 ABI 的 N-API

1、是啥

  • 自从 2017 年 Node.js v8.0.0 发布之后,Node.js 推出了全新的用于开发 C++ 原生模块的接口-> N-API

  • 与 NAN 相比,它把 Node.js 的所有底层数据结构全部黑盒化,抽象成 N-API 中的接口;不同版本的 Node.js 使用同样的接口,这些接口稳定且 ABI 化。只要 ABI 版本号一致,编译好的 C++ 扩展就可以直接使用,而不需要重新编译

    • ABI 化:(Application Binary Interface)应用程序二进制接口;可以理解为一种约定,是 API 的编译版本;ABI 允许编译好的目标代码在使用兼容 ABI 的系统中无需改动就能运行;一套完整的 ABI 可以让程序在所有支持该 ABI 的系统上运行,无需对程序进行修改

    • API:(Application programming interface),应用编程接口

  • 主要收益:消除了 Nodejs 版本之间的差异

2、N-API 的使用姿势

  • 提供头文件 node_api.h

  • 使用文档:nodejs.org/api/n-api.h…

3、node-addon-api 是啥?

  • 可以理解为是对 N-API 更进一步的封装,更加便于我们开发

  • 举个例子

// N-API
#include <assert.h>
#include <node_api.h>
static napi_value Method(napi_env env, napi_callback_info info) {
  napi_status status;
  napi_value world;
  status = napi_create_string_utf8(env, "world", 5, &world);
  assert(status == napi_ok);
  return world;
}
  #define DECLARE_NAPI_METHOD(name, func)                                        \
  { name, 0, func, 0, 0, 0, napi_default, 0 }
  static napi_value Init(napi_env env, napi_value exports) {
  napi_status status;
  napi_property_descriptor desc = DECLARE_NAPI_METHOD("hello", Method);
  status = napi_define_properties(env, exports, 1, &desc);
  assert(status == napi_ok);
  return exports;
}
  NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
   // node-addon-api
#include <napi.h>
  Napi::String Method(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  return Napi::String::New(env, "world");
}
  Napi::Object Init(Napi::Env env, Napi::Object exports) {
  exports.Set(Napi::String::New(env, "hello"),
              Napi::Function::New(env, Method));
  return exports;
}
  NODE_API_MODULE(hello, Init)

编码阶段

如何写出正确的 addon 逻辑

  • demo.h

demo.cc 

1、熟悉 C++ 基础语法

宏的定义:#define 是定义一个宏的指令(预编译指令),它用来将一个标识符定义为一个字符串,该标识符被称为宏,被定义的字符串被称为替换文本,

  • 简单的宏定义和带参数的宏定义

  • 当宏出现在一个文件中时,在该文件后续出现的所有宏都将被替换为 《替换文本》

  • 常用于条件编译情况下,比如版本号的不同而编译不同的逻辑

// 简单的宏定义
#define PI 1415926  // 宏名 字符串
 // 带参数的宏定义
#define A(x) x   // 宏名(参数表) 宏体
    • public:可被子类继承或在类外内访问

    • private:仅限类内部使用,不可被继承和访问

    • protected: 可被子类继承,但不能在类外访问

    • 公有继承:继承父类 public 和 protected 的方法和变量,不能访问 private

    • 私有继承:继承父类的 public 和 protected 的方法和变量作为私有成员,不能被该类的子类再次访问

    • 保护继承:继承父类 public 和 protected 成员作为保护成员

    • 公有继承、私有继承、保护继承

    • 公有、私有、受保护的成员

// test.h
class Test : public B {  // private || protected
    public:
  private:
  protected:
    int pro = 1;
}
// 类外
#include "test.h"
Test test;   // 实例化 Test 类
std::cout << test.pro << std::endl;  // error -> 不可在类外被访问
  • 构造函数和析构函数

    • 构造函数:类的构造函数是类的一种特殊的成员函数,它会在每次创建类的新对象时执行。类似于 JS 中的 constructor; 可自己实现,也可使用编译器生成的默认构造函数,即与类名相同的函数;

    • 析构函数:类的析构函数是类的一种特殊的成员函数,它会在每次删除所创建的对象时执行。析构函数的名称与类的名称是完全相同的,只是在前面加了个波浪号(~)作为前缀,它不会返回任何值,也不能带有任何参数。析构函数有助于在跳出程序(比如关闭文件、释放内存等)前释放资源。

  • 虚函数、纯虚函数是啥

    • virtual:虚函数关键字,子类可选择自己实现或使用父类原有方法

    • = 0:纯虚函数关键字,子类必须自己实现,如果不实现,编译阶段将会报错

    • override:是一个覆盖虚函数的标识符

2、熟悉 addon 语法

1、如何让 js require?无后缀情况下的 .js -> .json -> .node

  • 在 js 中,使用 commonJs 语法即可让该模块被其他模块 require,addon 中则也是类似的想法

  • 在 addon 中,提供了 NODE_API_MODULE 宏方法,用这个方法即可实现外部 require 效果,方法接收两个参数,即模块名字和导出的方法

  • 具体实现?

Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
  return Link::Init(env, exports);
}
NODE_API_MODULE(link, InitAll);

2、定义一个类以及注册方法

  • 在 js 中的效果即为 class A { //.... }

Napi::Object Link::Init(Napi::Env env, Napi::Object exports) {
  Napi::Function func =
      DefineClass(
                env, "Demo",
          {
            InstanceMethod("add", &Demo::Add),
          }
    );
   auto constructor = Napi::Persistent(func);
  constructor.SuppressDestruct();
   exports.Set("Demo", func);
  return exports;
}

3、函数的接收参数

  • 在 addon 中


    • 也是从 info[0] 中去拿到这个对象,然后用 object.Get(key) 方法拿到对应的参数

    • 定义好每个参数的类型接收

    • 统一在 CallbackInfo 中接收:github.com/nodejs/node…

    • 接收多个参数:

    • 接收一个对象


// 1、定义好参数接收
Napi::Object Link::Init(Napi::Env env, Napi::Object exports) {}
 // 2、在 CallbackInfo 中接收
Napi::Value Link::TagSync(const Napi::CallbackInfo &info) {
  string bizId = info[0].As<Napi::String>();
  auto tags = info[1].As<Napi::Array>();
}
ApplicationInfo applicationInfo = ParseValueAsApplicationInfo(info[0]);
 kwai::link::ApplicationInfo ParseValueAsApplicationInfo(Napi::Value value) {
  kwai::link::ApplicationInfo applicationInfo;
  auto object = value.As<Napi::Object>();
   applicationInfo.app_id = GetObjectValueAsInt32(object, "appId");
  return applicationInfo;
}
 int32_t GetObjectValueAsInt32(Napi::Object object, std::string keyName) {
  if (object.Get(keyName).IsNumber()) {
    return object.Get(keyName).ToNumber().Int32Value();
  }
   return 0;
}

4、函数的返回值

  • 类型约束:在函数前约束,类型可写 addon 类型或者原生 C++ 类型

  • 和 js 一样,写个 return 就可以了

5、env

  • 是什么


    • 可以理解为是 node addon 运行时的请求环境

    • Env 对象通常由 Node.js 运行时或 node-addon-api 基础结构创建和传递

  • 怎么用:github.com/nodejs/node…


    • 类型声明:Napi::Env

    • 取值:info.Env()

  • 为什么需要构建这个环境

3、熟悉业务逻辑

有了上面两个知识储备后,下一步我们就要根据实际的业务场景,去写 addon 逻辑了

如何向外暴露方法

这个例子可结合上面的 demo.cc 和 demo.h 来一起看

Value runSimpleAsyncWorker(const CallbackInfo& info) {
  int runTime = info[0].As<Number>();
  Function callback = info[1].As<Function>();
  SimpleAsyncWorker* asyncWorker = new SimpleAsyncWorker(callback, runTime);
  asyncWorker->Queue();
  std::string msg =
      "SimpleAsyncWorker for " + std::to_string(runTime) + " seconds queued.";
  return String::New(info.Env(), msg.c_str());
};
 Object Init(Env env, Object exports) {
  exports["runSimpleAsyncWorker"] = Function::New(
      env, runSimpleAsyncWorker, std::string("runSimpleAsyncWorker"));
  return exports;
}
 NODE_API_MODULE(addon, Init)

编译阶段

编译流程

使用 node-gyp 来构建,最终产出 .node 文件

1、第一步安装所需依赖

npm i node-gyp -g

2、第二步配置 binding.gyp

{
    "targets": [
            {
                "target_name": "demo",
                "cflags!": [ "-fno-exceptions" ],
                "cflags_cc!": [
                        "-Wc++11-extensions"
                ],
                "sources": [        
        "./src/simple_async_worker.cc",
                        "./src/addon.cc",
                ],
                "include_dirs": [
                        "<!@(node -p \"require('node-addon-api').include\")",
                        "./",
                ],
                'defines': [ 'NAPI_DISABLE_CPP_EXCEPTIONS' ],
                "conditions": [
                        [
                                'OS=="mac"',
                                {
                                        "link_settings": {
                    "libraries": [
                        # 可引入一个静态库
                    ]
                                        },
                                        "xcode_settings": {
                                                "OTHER_CFLAGS": [ "-std=c++17", "-fexceptions", ],
                                        },
                                        'defines': [
                                                'MACOS',
                                        ],
                                        "cflags_cc": [
                                                "-std=c++17"
                                        ]
                                }
                        ],
                ]
        },
],
}

3、执行 node-gyp rebuild 命令即可生成 require 方法可引入的 .node 文件

结语

根据以上步骤,可实现一个极为简单的 node addon 扩展,但是在实际开发过程中,会面临更多的问题解决,欢迎讨论~

到此这篇关于Node中完整的 node addon 实现流程的文章就介绍到这了


相关推荐

RN开发环境的npm私库本地debug调试

manongba · 573浏览 · 2019-05-09 17:03:46
你不知道的浏览器渲染原理

追忆似水年华 · 1102浏览 · 2019-05-09 22:47:56
基于iview的router常用控制方式

追忆似水年华 · 762浏览 · 2019-06-03 10:39:21
编程小知识之 JavaScript 文件读取

manongba · 608浏览 · 2019-06-10 09:16:16
10个省时间的 PyCharm 技巧 赶快收藏!

· 565浏览 · 2019-06-10 09:32:01
加载中

0评论

评论
努力追求卓越,极致,这么一个GEEK人,希望可以跟大家认识,交流一下。
分类专栏
小鸟云服务器
扫码进入手机网页