罗罗编程学习记录
本页内容 展开查看

07.2.2.5 原生模块、原生组件与线程模型

所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.2 跨平台移动开发 / 07.2.2 React Native

本节要解决的问题

  • TurboModule 的 TS 规范怎么写,Codegen 怎么把它变成双端绑定?
  • Android 与 iOS 两端的原生模块实现分别长什么样,线程语义是什么?
  • 跨边界能传哪些数据类型,回调、Promise、二进制怎么处理?
  • Fabric 原生组件怎么定义 props、事件、命令,与旧 ViewManager 差在哪?
  • 原生事件怎么发往 JS,为什么要批量、要在卸载时取消监听?
  • 用 JSI HostObject 自研绑定什么场景才值得,风险在哪?

版本前提:本页以 RN 0.70+ 为基线,新架构(TurboModules / Fabric / Codegen)在 RN 0.76 后逐步默认开启,具体默认开关、API 名、字段名随版本变化,标注待确认。Codegen 与架构演进详见 07.2.2.1。

覆盖范围

知识域 关键内容
TurboModule TS 规范、Codegen、Android/iOS 双端实现、懒加载
数据边界 可序列化类型、回调/Promise、二进制、对象数组
线程模型 模块线程、UI 线程、JS 线程、回调切线程
事件 事件发射、批量、监听取消、生命周期
Fabric 组件 props、事件、命令、measure、ComponentDescriptor
自研绑定 JSI HostObject 场景与风险、调试与单测

题号索引

题号区间 主题
001-004 TurboModule TS 规范、Codegen 签名对齐、Android 实现、iOS 实现
005-007 参数类型映射、回调与 Promise、二进制数据
008-010 线程语义、回调切线程、事件发射与批量
011-013 Fabric 原生组件 props/事件/命令、ViewManager 与 ComponentDescriptor、measure
014-016 JSI HostObject 自研绑定、权限生命周期销毁、原生调试与单测
017-018 旧 NativeModule → TurboModule、旧 ViewManager → Fabric 迁移
019-020 综合题:原生模块线上崩溃排查、原生组件封装决策

07.2.2.5-001 TurboModule 的 TS 规范怎么写?

一句话结论

TurboModule 用一个 TS 文件声明模块接口:继承 TurboModule,列出方法签名,再用 TurboModuleRegistry.getEnforcing 拿到模块实例;Codegen 读这个规范生成双端绑定。

概念解释

规范文件(通常命名 Native*.ts)是 JS 与原生之间的契约。它只声明类型,不实现逻辑:方法签名、参数类型、返回值。Codegen 在构建期读这个文件,生成 C++ 绑定与 Android/iOS 侧的抽象类,原生实现必须继承这些抽象类。

这与旧架构的差别在于:旧架构靠手写桥接,签名是字符串约定;新架构签名是编译期契约,不一致会在构建期报错。

原理流程

NativeFoo.ts(TS 规范)
  → Codegen 扫描 package.json 的 codegenConfig
  → 生成:C++ 绑定 + Android 抽象类 + iOS 协议
  → 原生实现继承抽象类
  → JS 侧 import 规范类型

代码或图示

// 示意:TurboModule 规范
import type { TurboModule } from 'react-native';
import { TurboModuleRegistry } from 'react-native';

export interface Spec extends TurboModule {
  getDeviceId(): string;
  setBrightness(value: number): Promise<boolean>;
  addListener(eventName: string): void;
}

export default TurboModuleRegistry.getEnforcing<Spec>('DeviceInfo');

常见误区

  • 以为规范文件就是实现:它只是类型声明,原生实现另写。
  • 以为规范可以随便改:改了规范必须重新 Codegen,原生实现要同步。

追问

  • codegenConfig 配置什么?答:模块名、类型、源码目录、Android 包名等(字段以版本为准)。
  • 规范写错会怎样?答:构建期 Codegen 报错或原生抽象类不匹配,属于早失败。

07.2.2.5-002 Codegen 怎么保证签名对齐?

一句话结论

Codegen 从 TS 规范生成 C++ 与平台侧的绑定代码,原生实现必须继承生成的抽象类;签名不一致会在编译期暴露,而不是运行时崩溃。

概念解释

Codegen 的产物分三层:JS 侧类型、C++ 绑定、Android/iOS 抽象类。JS 侧 import 规范类型,调用时类型安全;C++ 层把 JS 调用转发到平台实现;Android/iOS 侧生成抽象类,原生实现继承它。

如果规范改了方法签名,生成的抽象类跟着变,原生实现没改就编译失败。这把"签名漂移"从运行时崩溃提前到编译期。

原理流程

TS 规范 → Codegen
  ├─ JS:类型导出
  ├─ C++:绑定代码(JSI 注册)
  ├─ Android:抽象类(Java/Kotlin)
  └─ iOS:协议与基类(ObjC/Swift)
原生实现继承 → 编译期对齐

代码或图示

产物 作用
JS 类型 JS 侧类型检查
C++ 绑定 JSI 注册与转发
Android 抽象类 Kotlin/Java 继承
iOS 协议 ObjC/Swift 实现

常见误区

  • 以为 Codegen 只生成文档:它生成参与编译的代码。
  • 以为改原生实现可以不改规范:规范是真相,实现必须匹配。

追问

  • Codegen 产物要不要进版本库?答:生成目录通常不纳入版本管理,由构建重新生成。
  • 规范里支持哪些类型?答:布尔、数值、字符串、对象、数组、回调、Promise,具体以 Codegen 支持矩阵为准。

07.2.2.5-003 Android 端 TurboModule 怎么实现?

一句话结论

Android 端用 Kotlin/Java 继承 Codegen 生成的抽象类,实现方法,再在包的注册类里登记;方法默认在模块自己的线程执行,需要 UI 操作要显式切主线程。

概念解释

Android 侧实现:继承 Codegen 生成的 NativeFooSpec 抽象类,实现每个方法。方法参数按规范类型接收,返回值直接返回(同步)或通过 Promise 回调(异步)。模块通过 ReactPackage 或新架构的注册机制登记给 RN。

线程语义:模块方法默认在 NativeModules 线程(不是 UI 线程)执行;要更新 UI 必须切到主线程(runOnUiThread);要回调 JS 线程,用 Promise 或事件机制。

原理流程

Kotlin 实现类继承 NativeFooSpec
  → 实现每个方法
  → 注册到 ReactPackage
  → 运行时:JS 调用 → JSI → 模块线程执行方法
  → 需要 UI:切主线程
  → 异步结果:Promise 回 JS 线程

代码或图示

// 示意:Android TurboModule 实现(类名/方法以生成代码为准)
class FooModule(context: ReactApplicationContext) : NativeFooSpec(context) {
  override fun getDeviceId(): String {
    return Build.MODEL
  }
  override fun setBrightness(value: number, promise: Promise) {
    // 模块线程,要切主线程做 UI 操作
    promise.resolve(true)
  }
  override fun getName(): String = "DeviceInfo"
}

常见误区

  • 以为模块方法在主线程执行:默认在模块线程,UI 操作要切。
  • 以为 Promise 回调自动在 JS 线程:Promise 由 RN 调度回 JS 线程,但中间实现仍在模块线程。

追问

  • 怎么切主线程?答:用 reactApplicationContext.currentActivity?.runOnUiThread 或 Handler。
  • 模块初始化在什么时候?答:TurboModule 首次访问时创建(懒加载),构造函数里不要做重活。

07.2.2.5-004 iOS 端 TurboModule 怎么实现?

一句话结论

iOS 端用 ObjC/Swift 实现 Codegen 生成的协议,方法在指定线程队列执行;需要 UI 操作切到主队列,异步结果通过 Promise 回调。

概念解释

iOS 侧:实现 Codegen 生成的 NativeFooSpec 协议(ObjC),或用 Swift 桥接。方法按规范签名实现,返回值直接返回或通过 RCTPromiseResolveBlock / RCTPromiseRejectBlock 回调。模块通过 RCTBridgeModule 或新架构注册机制登记。

线程语义:模块方法默认在 JS 线程对应的队列(或指定队列)执行;要操作 UIView 必须切主队列(dispatch_async(dispatch_get_main_queue()))。

原理流程

ObjC/Swift 实现类实现 NativeFooSpec 协议
  → 实现每个方法
  → 注册到模块列表
  → 运行时:JS 调用 → JSI → 指定队列执行
  → 需要 UI:切主队列
  → 异步结果:Promise resolve/reject

代码或图示

// 示意:iOS TurboModule 实现(类名以生成代码为准)
@interface FooModule : NSObject <NativeFooSpec>
@end

@implementation FooModule
RCT_EXPORT_MODULE()

- (NSString *)getDeviceId {
  return [[UIDevice currentDevice] model];
}
@end

常见误区

  • 以为 iOS 模块方法在主线程:默认在指定队列,UI 操作要切主队列。
  • 以为 Swift 不能直接实现 Codegen 协议:需要桥接,具体以版本工具链为准。

追问

  • iOS 怎么指定模块方法在哪个队列?答:用协议或宏指定(具体 API 以版本为准)。
  • Swift 下模块注册有什么注意点?答:需要 ObjC 桥接,Codegen 产物要能被 Swift 访问。

07.2.2.5-005 跨边界能传哪些数据类型?

一句话结论

跨边界支持布尔、数值、字符串、对象(字典)、数组、回调、Promise、二进制(ArrayBuffer/typed array);函数、类实例、循环引用不能直接传,要转成可序列化结构。

概念解释

旧架构下所有数据都要序列化成 JSON,所以只能传 JSON 安全类型;新架构 JSI 下可以直接传 JS 值引用,但原生侧仍要按约定解析。类型映射:JS 的 boolean/number/string 对应平台原生类型;JS 对象对应字典/Map;JS 数组对应数组;回调对应函数引用;Promise 对应异步回调。

二进制是特殊情况:旧架构下要 base64 或分包;新架构下 JSI 支持 ArrayBuffer 直接传递,避免拷贝。

原理流程

JS 调用 → JSI/桥 → 原生侧按规范类型解析
  ├─ 基本类型:直接映射
  ├─ 对象:解析字典
  ├─ 数组:解析数组
  ├─ 回调:持有 JS 函数引用
  └─ 二进制:ArrayBuffer(新架构)或 base64(旧)

代码或图示

JS 类型 原生映射 备注
boolean bool 直接
number double/int 直接
string NSString/String 直接
object Dictionary/Map 字段对齐
array NSArray/List 元素类型对齐
function 回调引用 只能异步调用
Promise 异步回调 resolve/reject
ArrayBuffer 二进制缓冲 新架构直接传

常见误区

  • 以为可以直接传 JS 类实例:要转成普通对象,方法不能带过去。
  • 以为回调可以同步调用:回调是 JS 函数,必须在 JS 线程调用。

追问

  • 大对象传输有什么注意点?答:有序列化/拷贝成本,控制体积与频率。
  • 字段不兼容怎么处理?答:契约对齐,新增字段给默认值,向后兼容。

07.2.2.5-006 回调(Callback)与 Promise 怎么用?

一句话结论

回调是一次性的函数引用,原生侧在 JS 线程调用;Promise 是语义化的异步封装,对应 resolve/reject;两者都不能跨线程直接调用,必须调度回 JS 线程。

概念解释

旧架构下,方法签名里的 Callback 参数是一个 JS 函数引用,原生侧持有它,在异步任务完成后调用。Promise 是语法糖:规范里方法返回 Promise<T>,Codegen 生成 resolve/reject 两个 block,原生侧调 resolve 即对应 Promise resolve。

关键约束:持有 JS 函数引用后,只能在 JS 线程调用它;在模块线程直接调用会崩溃或行为未定义。必须用 RN 的调度机制切回 JS 线程。

原理流程

JS 调用异步方法
  → 原生侧持有 callback/Promise
  → 模块线程执行任务
  → 任务完成 → 调度回 JS 线程
  → 在 JS 线程调用 callback / resolve(reject)

代码或图示

机制 用途 调用时机
Callback 单次异步回调 任务完成时
Promise 语义化异步 resolve/reject
事件 多次推送 状态变化时

常见误区

  • 以为可以在模块线程直接调 callback:必须切回 JS 线程。
  • 以为 callback 可以多次调用:规范里是一次性的,多次调用行为未定义。

追问

  • 怎么调度回 JS 线程?答:用 RN 提供的线程调度 API(具体以版本为准)。
  • Promise 与回调怎么选?答:Promise 更语义化,适合单次结果;回调适合需要更多控制的场景。

07.2.2.5-007 二进制数据怎么跨边界传递?

一句话结论

旧架构下二进制要 base64 编码(有膨胀与拷贝成本);新架构 JSI 支持 ArrayBuffer 直接传递,可以零拷贝或低拷贝共享内存。

概念解释

旧架构 JSON 不支持二进制,所以图片、文件流、传感器数据要 base64 编码成字符串,体积膨胀 33% 且多次拷贝。新架构 JSI 提供 ArrayBuffer 类型,原生侧可以直接访问 JS 侧的内存块,或把原生内存暴露给 JS。

适用场景:图片处理、音频流、文件读写、加密数据。选型上,小数据 base64 无所谓,大数据必须用 ArrayBuffer。

原理流程

旧架构:
  JS 二进制 → base64 字符串 → 桥 → 原生解码
新架构:
  JS ArrayBuffer → JSI 直接传递 → 原生访问内存

代码或图示

方式 成本 适用
base64 膨胀 33% + 多次拷贝 小数据
ArrayBuffer 低拷贝/零拷贝 大数据

常见误区

  • 以为新架构下二进制还是 base64:JSI 支持 ArrayBuffer,按规范类型声明即可。
  • 以为 ArrayBuffer 可以跨线程自由访问:内存访问要注意线程安全与生命周期。

追问

  • Codegen 里怎么声明二进制参数?答:用 ArrayBuffer 或 UInt8Array 类型(具体以 Codegen 支持矩阵为准)。
  • 大文件传输建议?答:避免在 JS 与原生间传,直接在原生侧读写文件路径。

07.2.2.5-008 RN 原生模块的线程语义是什么?

一句话结论

三个关键线程:JS 线程(执行 JS 与 React 渲染)、UI 线程(平台主线程,操作原生视图)、模块线程(执行原生模块方法);跨线程必须显式调度,不能直接跨线程访问 UI 或调 JS 回调。

概念解释

旧架构三线程:JS 线程、Shadow 线程、UI 线程(详见 07.2.2.1)。新架构把 Shadow 线程并入 C++ 核心,但模块线程语义不变:模块方法默认在模块自己的线程执行,要操作 UI 切 UI 线程,要回调 JS 切 JS 线程。

常见错误:在模块线程直接改 UI(崩溃)、直接调 JS 回调(行为未定义)、在 JS 线程做阻塞的原生调用(卡死 JS)。

原理流程

JS 线程:JS 执行、React 渲染、事件回调
UI 线程:原生视图操作、绘制
模块线程:原生模块方法执行
跨线程:
  模块 → UI:runOnUiThread / dispatch_async
  模块 → JS:Promise / 事件调度

代码或图示

线程 职责 禁止
JS 线程 JS 执行、渲染 阻塞的原生调用
UI 线程 视图操作、绘制 耗时任务
模块线程 模块方法 直接操作 UI、直接调 JS 回调

常见误区

  • 以为模块方法在主线程:默认在模块线程。
  • 以为回调自动在 JS 线程:Promise 由 RN 调度,但中间实现仍要切。

追问

  • 怎么验证当前在哪个线程?答:加日志打印线程名或用调试器。
  • 模块方法做网络请求在哪个线程?答:在模块线程,不要阻塞 JS。

07.2.2.5-009 为什么原生模块回调必须切回 JS 线程?

一句话结论

JS 函数只能在 JS 线程上执行,因为 JS 运行时是单线程的;在模块线程直接调用 JS 函数会破坏运行时状态,导致崩溃或数据竞争。

概念解释

JS 运行时(Hermes/JSC)是单线程的:所有 JS 代码、React 渲染、事件回调都在同一个线程上跑。原生侧持有的 JS 函数引用,只能在这个线程上调用。如果在模块线程直接调用,就会在另一个线程上跑 JS 代码,与 JS 线程同时操作运行时,导致未定义行为。

RN 提供了调度机制:模块线程完成后,通过 runOnJS 或 Promise 机制把回调调度回 JS 线程执行。

原理流程

模块线程:任务完成
  → 不能直接调 JS 函数
  → 调度到 JS 线程队列
  → JS 线程空闲时取出执行

代码或图示

错误:
  模块线程 → 直接调用 JS callback() → 崩溃
正确:
  模块线程 → 调度到 JS 线程 → JS callback()

常见误区

  • 以为持有 JS 函数引用就能在任意线程调:必须在 JS 线程。
  • 以为同步调用可以省一次调度:同步调用仍在 JS 线程,不能在模块线程。

追问

  • 新架构下这个约束变了吗?答:JSI 也是单线程运行时,约束不变。
  • 怎么调度回 JS 线程?答:用 RN 提供的 API(具体以版本为准)。

07.2.2.5-010 原生事件怎么发射,为什么要批量与取消监听?

一句话结论

原生侧通过事件发射器向 JS 发送命名事件,JS 侧用 DeviceEventEmitter.addListener 订阅;事件是多次推送,组件卸载必须取消监听,否则泄漏与越界回调。

概念解释

事件与回调/Promise 的区别:事件是多次推送(传感器、位置、状态变化),回调是一次性。原生侧构造事件名与数据,通过事件通道发送;JS 侧订阅,收到后回调。

两个要点:一是事件数据要可序列化(旧架构)或按 JSI 值传递(新架构);二是 JS 侧订阅后必须在卸载时移除,否则组件已销毁但回调还在跑,导致内存泄漏或状态更新到已卸载组件。

原理流程

原生侧:构造事件名 + 数据 → 事件发射器发送
JS 侧:DeviceEventEmitter.addListener(eventName, callback)
  → 收到事件 → callback
  → 卸载时:remove() 取消订阅

代码或图示

useEffect(() => {
  const sub = DeviceEventEmitter.addListener('onLocation', (data) => {
    // 处理
  });
  return () => sub.remove(); // 必须取消
}, []);

常见误区

  • 订阅后不取消:内存泄漏、卸载后回调。
  • 事件数据传原生对象:只能传可序列化结构。

追问

  • 事件与回调怎么选?答:单次结果用回调/Promise,多次推送用事件。
  • 事件名两端怎么对齐?答:统一常量,避免拼写不一致收不到。

07.2.2.5-011 Fabric 原生组件怎么定义 props、事件、命令?

一句话结论

Fabric 原生组件用 TS 规范声明 props(含事件回调)、命令,Codegen 生成 ComponentDescriptor;原生侧实现 props 应用、事件发射、命令处理。

概念解释

新架构 Fabric 组件规范(Native*.tsx)声明:props 类型(包括事件回调如 onChange)、命令(Commands)。Codegen 生成 ComponentDescriptor,负责创建 shadow 节点、应用 props、发射事件、响应命令。

与旧 ViewManager 的差别:props 是不可变快照,事件是 props 里的函数引用,命令是同步下发的操作。

原理流程

NativeFoo.tsx(props + 命令规范)
  → Codegen 生成 ComponentDescriptor
  → 原生侧:
    ├─ createShadowNode
    ├─ setProps(应用属性)
    ├─ emitEvent(发射事件)
    └─ receiveCommand(处理命令)

代码或图示

// 示意:Fabric 组件规范
import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
import type { ViewProps, HostComponent } from 'react-native';

export interface NativeProps extends ViewProps {
  text: string;
  onChange?: (event: { value: string }) => void;
}

export default codegenNativeComponent<NativeProps>('CustomView') as HostComponent<NativeProps>;

常见误区

  • 以为 props 是双向绑定:props 是 JS → 原生单向,原生 → JS 靠事件。
  • 以为命令可以异步:命令是同步下发,原生侧立即处理。

追问

  • 事件怎么从原生发往 JS?答:通过 ComponentDescriptor 的事件发射器,调用 props 里的回调。
  • 命令用于什么?答: imperative 操作,如 focus、scrollTo、清空输入。

07.2.2.5-012 ViewManager 与 ComponentDescriptor 的差异是什么?

一句话结论

旧 ViewManager 是手动注册属性 setter 与事件,新 ComponentDescriptor 由 Codegen 生成,props 不可变、类型安全、事件与命令规范化;旧组件通过 Interop 兼容。

概念解释

旧 ViewManager:手写 @ReactProp 注解声明属性 setter,事件通过 receiveEvent 手动发送,类型靠约定。新 ComponentDescriptor:Codegen 生成,props 是不可变快照,事件是 props 里的函数引用,命令是类型化的接口。

差异的本质:旧架构是"命令式 setter",新架构是"声明式 props"。迁移时旧组件通过 Interop 包装成 Fabric 组件,长期建议按新规范重写。

原理流程

旧:ViewManager
  → 手写 @ReactProp setter
  → receiveEvent 手动发事件
  → 类型靠约定
新:ComponentDescriptor
  → Codegen 生成
  → props 不可变快照
  → 事件 = props 里的回调
  → 命令 = 类型化接口

代码或图示

维度 旧 ViewManager 新 ComponentDescriptor
属性声明 手写注解 Codegen 生成
props 可变性 可变 不可变快照
事件 receiveEvent 手动 props 回调
命令 手动字符串 类型化
类型安全 运行时 编译期

常见误区

  • 以为旧 ViewManager 不能在新架构用:通过 Interop 包装可用。
  • 以为 Interop 与原生实现性能一致:Interop 多一层转发。

追问

  • 怎么判断旧组件是否值得改?答:按调用频率、是否在滚动/动画路径、是否有同步测量需求排序。
  • 迁移路径?答:先 Interop 跑通,再按规范逐个重写关键组件。

07.2.2.5-013 Fabric 组件的 measure 与布局规格怎么工作?

一句话结论

Fabric 组件可以在规范里声明自定义布局 measure:原生侧提供 measure 函数,根据父约束计算自己的尺寸,替代 Yoga 的默认内容测量。

概念解释

大多数组件尺寸由 Yoga 根据子节点或样式计算;某些原生组件(如视频、地图、WebView)需要原生侧测量内容尺寸。Fabric 规范允许声明 supportsRawValue 或自定义 measure 函数,原生侧根据约束(min/max width/height)返回尺寸。

这与旧架构的 onLayout 不同:measure 是同步的,在布局阶段就能拿到结果;onLayout 是异步回调,在布局完成后通知。

原理流程

Yoga 布局阶段
  → 遇到需要自定义 measure 的组件
  → 调用原生 measure 函数(传入约束)
  → 原生返回尺寸
  → Yoga 继续布局

代码或图示

测量方式 时机 用途
Yoga 默认 布局阶段 大多数组件
自定义 measure 布局阶段同步 需要原生内容测量
onLayout 布局完成后 JS 侧拿尺寸

常见误区

  • 以为 measure 是异步的:Fabric 自定义 measure 在布局阶段同步执行。
  • 以为 measure 可以依赖子节点:measure 函数只能根据约束与 props 计算。

追问

  • 哪些组件需要自定义 measure?答:内容尺寸由原生决定的,如视频、地图、WebView、富文本。
  • measure 成本高吗?答:在布局阶段同步执行,要轻量,避免阻塞布局。

07.2.2.5-014 用 JSI HostObject 自研绑定什么场景才值得?

一句话结论

当 Codegen 生成的绑定不够用(如需要动态属性、高频对象、原生对象直接暴露给 JS),才用 JSI HostObject 自研绑定;代价是要自己管理生命周期、线程安全与 GC 引用。

概念解释

JSI HostObject 让原生侧把一个 C++ 对象暴露给 JS:JS 侧拿到的对象,属性读写实际由 C++ 实现。适用场景:需要动态属性(不像 Codegen 那样静态签名)、需要把原生对象直接传给 JS(如相机帧、传感器数据)、高频调用需要绕过 Codegen 的开销。

风险:HostObject 是 C++ 对象,生命周期由 JSI GC 管理,要正确处理 finalize;跨线程访问要加锁;调试困难;容易内存泄漏。

原理流程

C++ 类继承 HostObject
  → 重写 get/set/方法调用
  → 在 JSI runtime 注册
  → JS 侧 import 后拿到对象
  → JS 访问属性 → C++ 实现

代码或图示

场景 是否值得自研
静态签名模块 用 Codegen
动态属性对象 值得 HostObject
高频大数据流 值得 HostObject
一次性工具模块 不值得

常见误区

  • 以为自研绑定性能更好:Codegen 已经走 JSI,自研的收益有限。
  • 忽略生命周期管理:HostObject finalize 不当会泄漏。

追问

  • HostObject 的 GC 怎么工作?答:JS 侧不再引用时,JSI 触发 finalize,原生侧释放资源。
  • 跨线程访问 HostObject 要注意什么?答:加锁,或设计成不可变。

07.2.2.5-015 原生模块的权限、生命周期与销毁怎么管理?

一句话结论

原生模块要在适当的生命周期点申请权限、初始化资源、在宿主销毁时释放;模块生命周期与 Surface/宿主绑定,不清理会泄漏。

概念解释

生命周期点:模块构造时(懒加载首次访问)、宿主销毁时(Surface 关闭、App 退出)。资源(传感器、相机、数据库连接)要在不再使用时释放。权限要在运行时按平台要求申请(Android 6+ 动态权限、iOS Info.plist 声明)。

常见错误:模块构造时做重活(拖慢首次访问)、不释放资源(传感器持续耗电、相机不释放)、权限申请时机不对。

原理流程

模块构造(懒加载首次访问)
  → 轻量初始化
  → 按需申请权限
  → 持有资源
宿主销毁 / 模块不再使用
  → 释放资源
  → 取消事件订阅

代码或图示

生命周期点 要做的事
构造 轻量初始化
首次方法调用 申请权限、初始化资源
宿主销毁 释放资源、取消订阅

常见误区

  • 构造函数里做重活:拖慢首次访问。
  • 不释放资源:传感器、相机、数据库连接泄漏。

追问

  • 怎么知道模块要销毁?答:监听宿主生命周期(具体 API 以版本为准)。
  • 权限申请失败怎么处理?答:给 JS 侧明确的错误码,业务侧降级。

07.2.2.5-016 原生侧怎么调试与单元测试?

一句话结论

原生侧调试用平台 IDE(Android Studio / Xcode)attach 进程打断点;单元测试用平台原生测试框架(JUnit / XCTest),把原生模块/组件逻辑与 JS 边界隔离测试。

概念解释

调试:用 Android Studio / Xcode attach 到运行中的 App,在原生代码打断点,看变量与调用栈。测试:把原生模块的核心逻辑写成纯平台类,用 JUnit / XCTest 单测;与 JS 的边界用 mock 或集成测试覆盖。

常见误区:只测 JS 侧、不测原生逻辑;原生模块的边界条件(错误码、线程、生命周期)容易出 bug。

原理流程

调试:
  Android Studio / Xcode → attach 进程 → 断点
测试:
  原生逻辑 → JUnit / XCTest 单测
  边界 → 集成测试 / E2E

代码或图示

测试对象 工具
原生模块逻辑 JUnit / XCTest
原生组件渲染 平台 UI 测试
JS 与原生边界 集成测试 / E2E

常见误区

  • 以为单测 JS 就够:原生逻辑有自己的边界条件。
  • 在调试器里 attach 发布包:发布包不能调试。

追问

  • 怎么测原生模块的线程行为?答:用平台测试框架的线程测试能力,或集成测试观察。
  • 崩溃栈怎么还原?答:靠符号文件 / sourcemap,按版本归档。

07.2.2.5-017 旧 NativeModule 怎么迁移到 TurboModule?

一句话结论

迁移路径:先写 TS 规范(对照旧实现)→ 跑 Codegen → 让原生实现继承生成的抽象类 → 改 JS 侧 import 规范 → 测试 → 灰度;过渡期旧模块可走 Interop。

概念解释

迁移步骤:

  1. 读旧模块实现,列出所有暴露方法与参数。
  2. 写 TS 规范,对齐方法签名。
  3. 跑 Codegen,生成抽象类。
  4. 原生实现改为继承抽象类,方法体不变。
  5. JS 侧从 NativeModules.Foo 改为 import 规范。
  6. 测试所有方法、异步、线程。
  7. 灰度。

过渡期:旧模块可走 Interop 包装成 TurboModule,不必一次性全改。

原理流程

旧模块(@ReactMethod + NativeModules)
  → 写 TS 规范
  → Codegen 生成抽象类
  → 原生实现继承
  → JS 侧 import 规范
  → 测试 + 灰度

代码或图示

步骤 动作
1 写 TS 规范
2 Codegen
3 原生实现继承
4 JS 侧改 import
5 测试
6 灰度

常见误区

  • 不写规范直接改原生:Codegen 没有契约。
  • 迁移后不做全量测试:签名细微差异会出 bug。

追问

  • 旧模块能继续用吗?答:通过 Interop 可用,长期建议重写。
  • 迁移优先级怎么排?答:按调用频率、是否在启动路径、是否有线程问题排序。

07.2.2.5-018 旧 ViewManager 怎么迁移到 Fabric 组件?

一句话结论

迁移路径:先写 TS 组件规范(props、事件、命令)→ Codegen 生成 ComponentDescriptor → 原生实现改为 props 应用、事件发射、命令处理 → JS 侧换用新组件。

概念解释

迁移步骤:

  1. 读旧 ViewManager,列出所有 @ReactProp 与事件。
  2. 写 TS 组件规范(props 包括事件回调)。
  3. Codegen 生成 ComponentDescriptor。
  4. 原生实现:setProps 替代 @ReactProp、事件用 props 回调、命令用 receiveCommand。
  5. JS 侧换用 codegenNativeComponent 生成的组件。
  6. 测试渲染、事件、命令、布局。

过渡期旧组件通过 Interop 包装。

原理流程

旧 ViewManager(@ReactProp + receiveEvent)
  → 写 TS 组件规范
  → Codegen 生成 ComponentDescriptor
  → 原生实现 props/事件/命令
  → JS 侧换用
  → 测试

代码或图示

旧 新
@ReactProp setter setProps
receiveEvent props 回调
receiveCommand(字符串) 类型化命令
手写注册 Codegen

常见误区

  • 以为 props 是双向的:props 是 JS → 原生单向。
  • 迁移后不验证布局:自定义 measure 行为可能不同。

追问

  • 旧组件 Interop 能用多久?答:过渡期工具,长期建议重写。
  • 怎么验证迁移后渲染一致?答:截图对比两端,重点看 props 默认值与事件时序。

07.2.2.5-019 综合题:原生模块线上偶发崩溃,怎么排查?

一句话结论

按"先还原堆栈、再分层定位":用崩溃监控拿原生堆栈与符号文件还原,确认是 JS 边界、线程问题、生命周期还是原生逻辑;然后用版本、机型、场景复现,最后修复并补回归测试。

概念解释

原生模块线上崩溃的常见根因:

  1. 线程问题:模块线程直接操作 UI、直接调 JS 回调。
  2. 生命周期:模块已销毁还回调、资源未释放。
  3. 类型边界:参数类型不匹配、null 未处理。
  4. 权限:权限被拒后未降级。
  5. 并发:多线程访问未加锁。

排查顺序:先看堆栈还原(是哪类异常),再看版本与机型分布,再看是否集中在特定场景,最后复现。

原理流程

线上崩溃上报
  → 用符号文件还原堆栈
  → 分类:
    ├─ 线程异常? → 查模块线程是否直接 UI/JS 回调
    ├─ 生命周期? → 查销毁后是否还回调
    ├─ 类型错误? → 查参数 null、类型不匹配
    ├─ 权限? → 查权限被拒路径
    └─ 并发? → 查多线程共享资源
  → 复现 → 修复 → 补测试

代码或图示

判定树:
崩溃堆栈
  → 线程相关?(CalledFromWrongThreadException 等)
    ├─ 是 → 模块线程直接操作 UI/JS
    └─ 否 → NullPointerException / 参数错误?
       ├─ 是 → 参数 null、类型不匹配
       └─ 否 → 资源相关? → 生命周期、权限、并发

常见误区

  • 只看 JS 侧错误:原生崩溃不在 JS 错误捕获范围。
  • 不修回归测试:下次还会崩。

追问

  • 怎么区分 JS 异常与原生崩溃?答:JS 异常由 JS 运行时捕获,原生崩溃由平台崩溃监控捕获。
  • 崩溃栈还原需要什么?答:符号文件 / sourcemap 按版本归档。

07.2.2.5-020 综合题:什么时候该写原生组件,什么时候该用纯 JS?

一句话结论

判断标准:需要复用平台原生控件(相机、地图、WebView)、需要原生渲染性能(视频、长列表复杂项)、需要原生能力深度集成时写原生组件;纯 JS 能解决的不要为了"高性能"写原生。

概念解释

决策维度:

  1. 是否有现成原生控件:相机、地图、WebView、视频播放器,直接封装原生。
  2. 是否有渲染性能需求:复杂自定义绘制、高频动画、GPU 密集,原生更合适。
  3. 是否需要原生能力深度集成:传感器、蓝牙、系统级 API。
  4. 维护成本:原生组件要双端维护,业务组件用纯 JS 可跨端。

常见错误:把简单 UI 用原生写一遍(维护成本高)、用纯 JS 做复杂原生控件(性能差)。

原理流程

需求
  → 是否有现成原生控件? → 是 → 封装原生组件
  → 是否有渲染性能需求? → 是 → 原生组件
  → 是否需要原生能力深度集成? → 是 → 原生模块/组件
  → 否 → 纯 JS 实现

代码或图示

场景 选型
相机、地图、WebView 原生组件
视频播放器 原生组件
普通列表项 UI 纯 JS
自定义绘制(Canvas) 评估原生 vs Skia
传感器、蓝牙 原生模块
网络、存储 原生模块或 JS 库

常见误区

  • 为了"性能"把简单 UI 写成原生:维护成本翻倍。
  • 用纯 JS 做复杂原生控件:性能不达标。

追问

  • 原生组件与原生模块怎么选?答:有 UI 用组件,无界面能力用模块。
  • 自研原生组件的维护成本?答:双端实现、版本升级、Codegen 维护,要评估。