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。
概念解释
迁移步骤:
- 读旧模块实现,列出所有暴露方法与参数。
- 写 TS 规范,对齐方法签名。
- 跑 Codegen,生成抽象类。
- 原生实现改为继承抽象类,方法体不变。
- JS 侧从
NativeModules.Foo改为 import 规范。 - 测试所有方法、异步、线程。
- 灰度。
过渡期:旧模块可走 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 侧换用新组件。
概念解释
迁移步骤:
- 读旧 ViewManager,列出所有 @ReactProp 与事件。
- 写 TS 组件规范(props 包括事件回调)。
- Codegen 生成 ComponentDescriptor。
- 原生实现:setProps 替代 @ReactProp、事件用 props 回调、命令用 receiveCommand。
- JS 侧换用 codegenNativeComponent 生成的组件。
- 测试渲染、事件、命令、布局。
过渡期旧组件通过 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 边界、线程问题、生命周期还是原生逻辑;然后用版本、机型、场景复现,最后修复并补回归测试。
概念解释
原生模块线上崩溃的常见根因:
- 线程问题:模块线程直接操作 UI、直接调 JS 回调。
- 生命周期:模块已销毁还回调、资源未释放。
- 类型边界:参数类型不匹配、null 未处理。
- 权限:权限被拒后未降级。
- 并发:多线程访问未加锁。
排查顺序:先看堆栈还原(是哪类异常),再看版本与机型分布,再看是否集中在特定场景,最后复现。
原理流程
线上崩溃上报
→ 用符号文件还原堆栈
→ 分类:
├─ 线程异常? → 查模块线程是否直接 UI/JS 回调
├─ 生命周期? → 查销毁后是否还回调
├─ 类型错误? → 查参数 null、类型不匹配
├─ 权限? → 查权限被拒路径
└─ 并发? → 查多线程共享资源
→ 复现 → 修复 → 补测试
代码或图示
判定树:
崩溃堆栈
→ 线程相关?(CalledFromWrongThreadException 等)
├─ 是 → 模块线程直接操作 UI/JS
└─ 否 → NullPointerException / 参数错误?
├─ 是 → 参数 null、类型不匹配
└─ 否 → 资源相关? → 生命周期、权限、并发
常见误区
- 只看 JS 侧错误:原生崩溃不在 JS 错误捕获范围。
- 不修回归测试:下次还会崩。
追问
- 怎么区分 JS 异常与原生崩溃?答:JS 异常由 JS 运行时捕获,原生崩溃由平台崩溃监控捕获。
- 崩溃栈还原需要什么?答:符号文件 / sourcemap 按版本归档。
07.2.2.5-020 综合题:什么时候该写原生组件,什么时候该用纯 JS?
一句话结论
判断标准:需要复用平台原生控件(相机、地图、WebView)、需要原生渲染性能(视频、长列表复杂项)、需要原生能力深度集成时写原生组件;纯 JS 能解决的不要为了"高性能"写原生。
概念解释
决策维度:
- 是否有现成原生控件:相机、地图、WebView、视频播放器,直接封装原生。
- 是否有渲染性能需求:复杂自定义绘制、高频动画、GPU 密集,原生更合适。
- 是否需要原生能力深度集成:传感器、蓝牙、系统级 API。
- 维护成本:原生组件要双端维护,业务组件用纯 JS 可跨端。
常见错误:把简单 UI 用原生写一遍(维护成本高)、用纯 JS 做复杂原生控件(性能差)。
原理流程
需求
→ 是否有现成原生控件? → 是 → 封装原生组件
→ 是否有渲染性能需求? → 是 → 原生组件
→ 是否需要原生能力深度集成? → 是 → 原生模块/组件
→ 否 → 纯 JS 实现
代码或图示
| 场景 | 选型 |
|---|---|
| 相机、地图、WebView | 原生组件 |
| 视频播放器 | 原生组件 |
| 普通列表项 UI | 纯 JS |
| 自定义绘制(Canvas) | 评估原生 vs Skia |
| 传感器、蓝牙 | 原生模块 |
| 网络、存储 | 原生模块或 JS 库 |
常见误区
- 为了"性能"把简单 UI 写成原生:维护成本翻倍。
- 用纯 JS 做复杂原生控件:性能不达标。
追问
- 原生组件与原生模块怎么选?答:有 UI 用组件,无界面能力用模块。
- 自研原生组件的维护成本?答:双端实现、版本升级、Codegen 维护,要评估。