07.2.2.6 状态管理、导航与数据层
所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.2 跨平台移动开发 / 07.2.2 React Native
本节要解决的问题
- 状态管理到底选 Redux Toolkit、Zustand、Jotai、Context 还是 MobX?决策依据是什么?
- 为什么 Context 一更新整棵树重渲染,选择器(selector)在其中到底解决了什么?
- React Navigation 的嵌套栈与原生导航栈是什么关系,深链、Universal Link、路由守卫怎么落地?
- 请求层为什么要统一封装拦截器、重试、超时与取消,而不是在业务里直接 fetch?
- 本地缓存用 AsyncStorage、MMKV 还是 SQLite?缓存策略与失效机制怎么设计?
- 登录态与 token 刷新在并发请求下怎么避免"刷新风暴"?
- 数据层为什么要分 UI、状态、仓库、数据源四层,而不是组件里直接发请求?
版本前提:本页涉及的第三方库(Redux Toolkit、Zustand、Jotai、MobX、React Navigation、axios、MMKV、AsyncStorage、WatermelonDB 等)均独立演进,API 名与默认行为以各库最新文档为准;凡涉及具体 API、字段名、默认开关处均标注「待确认」,落地前需按项目实际版本核对。
覆盖范围
| 知识域 | 关键内容 |
|---|---|
| 状态管理方案 | Redux Toolkit、Zustand、Jotai、Context、MobX 的取舍与选择器、重渲染控制 |
| 跨组件与跨页通信 | 事件总线、全局 store、ref 共享、导航参数透传的边界 |
| 导航体系 | React Navigation 的 Stack/Tab/Drawer 嵌套、原生导航栈、深链与 Universal Link、路由守卫、页面懒加载 |
| 请求层 | fetch/axios 封装、拦截器、重试与超时、取消、错误归一化 |
| 本地数据 | AsyncStorage/MMKV/SQLite/ORM 取舍、缓存策略、TTL 与失效 |
| 一致性与登录态 | 乐观更新、冲突合并、token 刷新、错误分层、数据层分层 |
题号索引
| 题号区间 | 主题 |
|---|---|
| 001-005 | 状态管理方案取舍、选择器、Context 重渲染、跨组件通信 |
| 006-010 | React Navigation 结构、嵌套栈、深链、路由守卫、页面懒加载 |
| 011-014 | 请求层封装、重试超时取消、错误归一化、登录态与 token 刷新 |
| 015-018 | 本地缓存方案取舍、缓存策略与失效、乐观更新、数据层分层 |
| 019-020 | 离线优先综合题、电商 App 数据层设计综合题 |
07.2.2.6-001 Redux Toolkit、Zustand、Jotai、Context、MobX 怎么选?
一句话结论
没有银弹,决策依据是「状态粒度、更新频率、团队熟悉度、调试与时间旅行需求」。大型复杂应用、需要严格单向数据流与可追踪性选 Redux Toolkit;中小型、偏好极简 API 与细粒度订阅选 Zustand;原子化、渲染性能敏感选 Jotai;低频、穿透式传递(主题、用户配置)用 Context;团队已熟悉 OOP/响应式且接受可变模型选 MobX。
概念解释
Redux Toolkit(RTK)在经典 Redux 之上提供了 slice、immutable 更新工具(Immer)、序列化中间件与 RTK Query,它强制单向数据流:action → reducer → store → 视图,调试工具链(时间旅行、action 日志)最成熟,但样板代码与心智成本仍在。Zustand 用一个或多个 hook store 替代 provider,组件通过 selector 订阅切片,不存在 provider 嵌套,API 极小,重渲染只在选中的切片变化时触发。Jotai 把状态拆成原子(atom),组件订阅哪个原子就只对哪个原子变化敏感,适合大量独立 UI 状态(输入框、开关、弹窗可见性)。Context 本质是「依赖注入容器」而非状态管理:任何 value 变化都会让所有消费组件重渲染,不适合高频更新。MobX 用 observable + 响应式依赖收集,写法接近 OOP,运行时自动追踪依赖并精确更新,但可变模型与调试工具不如 Redux 直观。
原理流程
状态变化触发链路:
方案A:dispatch(action) → reducer 纯函数 → 新 store → 订阅组件对比后重渲染(RTK)
方案B:setState(partial) → store 内部更新 → 对该切片订阅的组件重渲染(Zustand)
方案C:atom.set(v) → 依赖该 atom 的组件重渲染(Jotai)
方案D:context value 变化 → 所有 useContext 的组件无条件重渲染
代码或图示
| 维度 | RTK | Zustand | Jotai | Context | MobX |
|---|---|---|---|---|---|
| 样板代码 | 中 | 极少 | 少 | 少 | 中 |
| 重渲染控制 | selector 浅比较 | selector + shallow | 原子级 | 全量消费 | 依赖收集 |
| 时间旅行调试 | 强 | 弱 | 弱 | 无 | 弱 |
| 异步方案 | thunk / RTK Query | 自由写 | 自由写 | 自由写 | action / flow |
| 适用规模 | 大型复杂 | 中小到大型 | UI 状态密集 | 低频穿透 | 熟悉 OOP 团队 |
常见误区
- 误区:把所有状态都塞全局 store;正解:组件局部状态(useState/useReducer)仍是首选,全局只放跨页共享、真跨组件状态。
- 误区:Context 包一层 Provider 就是状态管理库;正解:Context 不带更新订阅切片,高频更新场景必须配合外部 store 或拆分多个 Context。
追问
- Q:RTK Query 与手写 fetch 封装的差异?A:RTK Query 内置缓存、失效、重试、乐观更新,代价是把请求语义也纳入 store 体系,适合接口形态稳定的业务。
- Q:Zustand 怎么避免 selector 返回新引用导致的重渲染?A:用
useStore(selector, shallow)或 selector 只返回原始值,避免每次返回新对象(具体 API 以版本为准,待确认)。
07.2.2.6-002 Context 为什么一更新就整树重渲染,怎么破?
一句话结论
Context 的 value 一旦变化,所有消费它的组件都会重渲染,无论它们实际用到了 value 的哪一部分;要破这个局,要么把 value 拆小并配合 memo,要么改用外部 store + useSyncExternalStore,要么把高频状态从 Context 里剥离。
概念解释
React 在渲染期调用 useContext 时会记录依赖的 Context 对象,只要 Provider 的 value 引用变化,React 就会调度所有消费组件重渲染。React 无法知道消费组件用了 value 的哪个字段——这是设计上的简化。常见错误是把 { user, theme, locale } 三个完全无关的对象放进同一个 Context,任何一个字段更新都会触发整棵消费树。
外部 store 之所以能做到「切片订阅」,是因为组件自己通过 useSyncExternalStore 注册了对 store 的订阅,并在 store 变化时用 selector 计算快照,只有快照引用变化才重渲染——这是 React 官方提供的外部 store 一致性接口。
原理流程
Context 方案:
<Provider value={v}> ──v 变化──▶ 所有 useContext(Context) 组件重渲染
外部 store 方案:
store.set(patch) ──▶ 订阅者回调 ──▶ 跑 selector 取快照
├─ 快照未变 ──▶ 不重渲染
└─ 快照变了 ──▶ 只重渲染该组件
代码或图示
// 示意:错误用法 —— value 是每次渲染新建的对象
<AppContext.Provider value={{ user, theme }}>{children}</AppContext.Provider>
// 即使 user/theme 都没变,value 引用每次都变,消费组件全部重渲染
// 修正:拆 Context + useMemo 固定 value
<UserContext.Provider value={user}>{children}</UserContext.Provider>
<ThemeContext.Provider value={theme}>{children}</ThemeContext.Provider>
常见误区
- 误区:给 Provider 外面包一层
React.memo就能阻止整树重渲染;正解:memo 挡的是父组件重渲染,挡不住 value 引用变化带来的消费方重渲染。 - 误区:把主题、登录用户、国际化文案全塞一个 Context;正解:按更新频率拆 Context,低频 Context 穿透高频树。
追问
- Q:useSyncExternalStore 解决了什么?A:解决外部 store 在并发渲染下可能读到撕裂快照的问题,是 React 18 官方推荐的外部 store 接入方式(具体 API 以 React 版本为准)。
- Q:什么时候 Context 仍然是正确选择?A:低频、全局、穿透式的配置(主题、地区、是否暗色),且消费方对重渲染不敏感。
07.2.2.6-003 Zustand 的 selector 与浅比较机制是什么?
一句话结论
Zustand 的 hook 允许组件只订阅 store 的某个切片,selector 返回值变化才触发重渲染;当 selector 返回新对象/数组时必须用浅比较(shallow)或返回原始值,否则会陷入"每次渲染都重渲染"的陷阱。
概念解释
Zustand 内部用 Object.is 比较 selector 上次返回值与本次返回值。如果 selector 写 useStore(s => ({ a: s.a, b: s.b })),每次都会返回一个新对象,Object.is 永远不等,组件就会在任何 store 更新时都重渲染。解决办法是要么分别选择:const a = useStore(s => s.a); const b = useStore(s => s.b),要么用官方提供的 shallow 比较器:useStore(s => ({ a: s.a, b: s.b }), shallow)。
这与 Redux 的 useSelector 默认浅比较一脉相承:只要切片内部结构没有变化,浅比较认为切片相等。
原理流程
store 任意字段 set
├─ 对每个订阅者:调用 selector(state) 取 nextSlice
├─ 与 prevSlice 用 Object.is 比较
│ ├─ 相等 ──▶ 跳过
│ └─ 不等 ──▶ 若传入比较器则用比较器;否则标记需要重渲染
└─ 触发对应组件更新
代码或图示
// 示意:错误写法 —— selector 返回新对象,任何 store 更新都重渲染
const user = useUserStore(s => ({ name: s.name, id: s.id }));
// 修正一:分两次选择
const name = useUserStore(s => s.name);
const id = useUserStore(s => s.id);
// 修正二:用 shallow 比较(API 以版本为准)
import { shallow } from 'zustand/shallow';
const user = useUserStore(s => ({ name: s.name, id: s.id }), shallow);
常见误区
- 误区:selector 只在 store 变化时才被调用;正解:每次 store 更新所有订阅者的 selector 都会执行,selector 本身要轻量,不要在里面做复杂计算。
- 误区:Zustand 天然不会重渲染;正解:selector 写法不当比 Context 还容易触发重渲染。
追问
- Q:selector 里做 map/filter 怎么办?A:把结果放到 store 里缓存,或用
useMemo在组件里计算,不要在 selector 里每次返回新数组。 - Q:Zustand 中间件怎么加日志与持久化?A:通过
create( persist( middleware(...) ) )组合,具体 API 以官方文档为准。
07.2.2.6-004 跨组件、跨页面通信有哪些方式,边界在哪?
一句话结论
按"耦合方向"分四类:父子用 props/回调,兄弟用共同父组件或提升状态,跨页面用全局 store 或导航参数,完全无关联的模块用事件总线。事件总线是最后手段,因为它会破坏数据流可追踪性。
概念解释
跨页面在 RN 中特指"两个不同路由下的页面实例"。它们之间没有 React 树的父子关系,props 传递不到。可选方案:
- 全局状态(Zustand/RTK):可追踪、可持久化,但要避免把临时 UI 状态塞进去。
- 导航参数:通过
navigation.setParams或 navigate 时传参,适合"从 A 跳 B,B 返回 A 时带回结果"。 - 事件总线(
DeviceEventEmitter、Node 风格 EventEmitter):适合原生 → JS 推送(传感器、SDK 回调),但 JS 内部模块间滥用会让数据流变成蜘蛛网。 - URL 深链参数:从外部唤起 App 时,参数是天然的全局通信载体。
原理流程
场景1:子组件改父组件状态 ── props 回调
场景2:兄弟组件同步 ── 状态提升到共同父组件
场景3:页面A → 页面B 返回结果 ── navigation.navigate('B', { onResult }) 或 setParams
场景4:完全无关模块广播 ── 全局 store / 事件总线(慎用)
代码或图示
| 场景 | 推荐方案 | 不推荐 |
|---|---|---|
| 父子传值 | props | 事件总线 |
| 兄弟同步 | 状态提升 | 全局 store |
| 跨页返回结果 | 导航参数 / setParams | 事件总线 |
| 原生 SDK 推送 | DeviceEventEmitter | 全局 store |
| 全局登录用户 | 全局 store | URL 参数 |
常见误区
- 误区:事件总线是万能解;正解:监听与发射点分散,调试时很难追踪"谁改了我的状态"。
- 误区:把导航参数当作全局存储;正解:离开页面参数就被销毁,不能依赖它做持久化。
追问
- Q:原生模块怎么主动通知 JS?A:通过
DeviceEventEmitter或 TurboModule 暴露的事件订阅 API(具体 API 以版本为准),JS 侧必须在卸载时 removeListener。 - Q:两个页面都在导航栈里同时存活,怎么通知?A:用全局 store 让两个页面各自订阅同一切片,避免直接调用对方的 navigation。
07.2.2.6-005 Redux 的中间件、thunk、saga 有什么区别?
一句话结论
中间件是 dispatch 与 reducer 之间的拦截器链;thunk 让 action 可以是函数并在里面做异步;saga 用 Generator 把异步流程写成可中断的"协程",适合复杂编排(轮询、并发取消、重试)。中小型项目 thunk 足够,复杂业务流程才上 saga。
概念解释
Redux 中间件签名是 store => next => action => ...,可以在 action 到达 reducer 之前做日志、埋点、节流、异步。thunk 中间件识别 typeof action === 'function',把 dispatch 与 getState 注入进去,让开发者在函数里发请求、再 dispatch 真正的 action。RTK 默认包含 thunk,且 RTK Query 已经覆盖了大多数服务端缓存场景。
saga 把异步副作用写成 Generator:takeEvery、takeLatest、race、fork 这些 effect 让"等待某个 action 然后并发请求然后取消"这种流程可以声明式表达,且可以用单元测试模拟 effect 执行流。代价是心智成本高,Generator 调试不如 async/await 直观。
原理流程
dispatch(action)
→ 中间件链:logger → thunk / saga → ...
→ 若 thunk:执行 action(dispatch, getState),内部再 dispatch 真正的 action
→ 若 saga:监听到匹配 action,启动对应 Generator,effect 由 saga 解释器执行
→ reducer 纯函数计算新 state
代码或图示
| 维度 | thunk | saga | RTK Query |
|---|---|---|---|
| 写法 | async/await 函数 | Generator effect | 声明式 endpoints |
| 复杂编排 | 手写 | takeLatest/race/fork 内建 | 有限 |
| 测试 | 普通异步测试 | effect 断言测试 | 自动 |
| 适用 | 大多数异步 | 复杂流程编排 | 接口驱动型业务 |
常见误区
- 误区:saga 是 Redux 的必备组件;正解:大多数业务 thunk 加 RTK Query 已足够。
- 误区:在 thunk 里写死所有业务逻辑;正解:thunk 只做"发请求 → dispatch action",业务规则放 selector 或工具函数。
追问
- Q:Redux 为什么要求 action 可序列化?A:中间件链与时间旅行调试依赖 action 能被记录与重放,塞函数/Promise 进去会破坏调试工具。
- Q:saga 怎么处理并发请求取消?A:用
takeLatest自动取消前一次,或手动fork+cancel任务(具体 API 以版本为准)。
07.2.2.6-006 React Navigation 的整体结构与原生导航栈是什么关系?
一句话结论
React Navigation 是 JS 侧的导航状态机,它通过 react-native-screens 把每个 Stack 屏幕映射为平台原生 ViewController/Activity,从而在手势、转场动画、返回行为上贴近原生;它不是"在 JS 里画一个假导航栏"。
概念解释
React Navigation 的核心是一个嵌套的导航器树:NavigationContainer 持有全局状态,下面可以挂 Stack、Tab、Drawer、Native Stack 等导航器。每个导航器维护自己的路由栈(route name + params + key)。JS 侧维护的是"路由状态",真正的视图切换通过 react-native-screens 渲染成原生屏幕组件(iOS 上对应 UINavigationController 的 push/pop,Android 上对应 Fragment/Activity 转场)。
@react-navigation/native-stack 直接使用原生导航栈,性能与手势体验最佳;@react-navigation/stack(JS stack)是纯 JS 实现的转场动画,可定制性强但性能与手势不如原生栈。
原理流程
navigation.navigate('Detail', { id })
→ 导航器状态更新:栈 [Home, Detail]
→ NavigationContainer 重渲染
→ Screens 渲染器:用 react-native-screens 挂载 Detail 屏幕
→ iOS:UINavigationController push 一个新 VC;Android:Fragment/转场动画
→ 返回手势/返回键:原生侧触发 → 通知 JS 栈 pop
代码或图示
| 导航器 | 实现 | 适用 |
|---|---|---|
| native-stack | 原生 VC/Activity 栈 | 主页面栈,性能与手势最佳 |
| stack(JS) | JS 实现转场 | 需要完全自定义动画 |
| bottom-tabs | JS | 底部 Tab |
| drawer | JS | 侧滑菜单 |
| native-drawer | 原生 | 侧滑性能敏感 |
常见误区
- 误区:React Navigation 就是一个 JS 路由表;正解:它背后是原生导航栈的映射,转场与手势由原生提供。
- 误区:所有页面都该用 native-stack;正解:模态、自定义复杂转场仍可能用 JS stack。
追问
- Q:为什么推荐 native-stack?A:它复用原生导航的转场、边缘返回手势、状态栏行为,JS 只负责路由状态。
- Q:嵌套导航器时谁来处理返回?A:默认由最内层的导航器先消费返回事件,未消费才冒泡到外层,具体行为以版本为准。
07.2.2.6-007 Stack/Tab/Drawer 嵌套有哪些常见坑?
一句话结论
嵌套导航器的核心坑是「导航状态归属」与「返回事件冒泡」:Tab 里的某个 Stack 想要返回,要先 pop 内层 Stack 再切 Tab,直接 navigation.goBack 不会按预期走。
概念解释
典型结构是 NavigationContainer → Stack(主) → Tab(首页) → Stack(首页内部)。当用户在 Tab 内的详情页按返回时,JS 栈的行为是:先尝试 pop 内层 Stack,内层栈只有一个页面时就冒泡到 Tab,Tab 不会自动切到第一个 tab——这与用户预期"返回到首页 Tab"可能不一致。
另一个坑是 navigation.navigate 与 navigation.push 的差异:navigate 会复用已存在的同名路由(在栈中向上找),push 总是新加一个实例。详情页无限 push 同一个 Detail 是常见 bug。
原理流程
返回事件触发:
├─ 内层 Stack 栈深 > 1 → pop
├─ 内层 Stack 栈深 = 1 → 冒泡到 Tab
│ └─ Tab 默认不切;需自定义 tabBarOnPress 或用 getParent() 主动切
└─ 冒泡到最外层 Stack → pop
代码或图示
// 示意:从深层 Tab Stack 跳回首页 Tab 的正确写法
navigation.getParent()?.jumpTo('HomeTab');
// 或更直接:
navigation.navigate('MainStack', { screen: 'HomeTab' });
常见误区
- 误区:Tab 嵌套 Stack 时,Tab 切换会保留 Stack 状态;正解:默认保留,但要确认配置项(
unmountOnBlur之类的开关以版本为准),否则会出现"切 Tab 后列表状态还在但数据已过期"。 - 误区:
navigate('Detail')每次都新起一个页面;正解:它会复用栈中已有的 Detail,要 push 新实例必须用push。
追问
- Q:怎么自定义 Android 实体返回键行为?A:用
BackHandler订阅,根据当前路由状态决定是 pop、切 Tab 还是退出 App。 - Q:Tab 切换时如何避免重新请求数据?A:保留屏幕组件挂载(默认行为),配合数据层缓存,不要用
unmountOnBlur。
07.2.2.6-008 深链与 Universal Link 怎么配置与匹配?
一句话结论
深链分三层:自定义 URL Scheme(如 myapp://detail/123)、Android App Link / iOS Universal Link(从网页直接唤起 App)、路由内路径解析。三层都要配置,且匹配优先级与回退行为必须明确。
概念解释
自定义 Scheme 简单,但任何 App 都能注册同名 Scheme,安全性低。Universal Link / App Link 要求 App 在 apple-app-site-association(iOS)或 assetlinks.json(Android)里声明域名与路径映射,用户在浏览器点 https://m.example.com/detail/123 时系统会校验域名归属并直接打开 App,未安装则回退网页。
在 RN 内部,NavigationContainer 的 prefixes 配置接收 Scheme 与 Universal Link 域名,config 把路径映射到路由名与参数。
原理流程
外部 https://m.example.com/detail/123
→ iOS/Android 校验关联文件 → 唤起 App
→ NavigationContainer 收到 initialURL / linking 事件
→ 用 linking.config 映射:/detail/:id → Detail 路由,params { id: 123 }
→ 导航器 stack push Detail
代码或图示
// 示意:linking 配置(字段以版本为准)
const linking = {
prefixes: ['myapp://', 'https://m.example.com'],
config: {
screens: {
Home: 'home',
Detail: 'detail/:id',
},
},
};
常见误区
- 误区:只配置了 prefixes 就以为 Universal Link 生效;正解:还必须在服务端部署
apple-app-site-association/assetlinks.json,且经过系统校验。 - 误区:深链直接打开目标页就完事;正解:目标页需要登录态时要做路由守卫(见下一题),未登录要先跳登录再回跳。
追问
- Q:App 已在后台时深链怎么处理?A:系统会触发 deep link 事件,
NavigationContainer通过linking接收并导航,需要监听initialUrl与后续 url 事件(具体 API 以版本为准)。 - Q:Universal Link 打不开怎么办?A:排查关联文件是否 HTTPS、是否被 CDN 缓存、路径是否覆盖、App 中 Associated Domains 配置是否正确。
07.2.2.6-009 路由守卫与登录态拦截怎么落地?
一句话结论
不要在每个页面里写 if (!user) navigation.replace('Login');正确做法是把导航器按"未登录栈 / 已登录栈"切成两个根 Stack,登录态变化时整体切换,路由自然守卫。
概念解释
守卫的本质是"根据全局状态决定渲染哪棵导航树"。如果登录用户渲染 MainStack,未登录用户渲染 LoginStack,那么未登录用户根本看不到 MainStack 里的任何路由,自然不存在"漏一个页面没拦"的问题。深链进入时也按同一逻辑判断:未登录 → 存下目标路径 → 跳登录 → 登录成功后按存储路径回跳。
这种"条件渲染导航树"是 React Navigation 官方推荐模式,避免在每个页面散写判断。
原理流程
user 状态变化:
├─ null → <NavigationContainer><LoginStack /></NavigationContainer>
└─ 存在 → <NavigationContainer><MainStack /></NavigationContainer>
深链 /detail/123 且未登录:
1. 拦截器保存待回跳路径
2. 渲染 LoginStack
3. 登录成功 → 渲染 MainStack → 按保存路径 navigate
代码或图示
// 示意:条件渲染根导航器(API 以版本为准)
const isLoggedIn = useAuthStore(s => s.isLoggedIn);
return (
<NavigationContainer linking={linking}>
{isLoggedIn ? <MainStack /> : <LoginStack />}
</NavigationContainer>
);
常见误区
- 误区:用
navigation.addListener('beforeRemove')拦所有路由;正解:那是阻止用户主动离开某页(如未保存表单),不是登录守卫。 - 误区:登录成功后直接
replace('Home');正解:要检查是否有待回跳路径,有则回跳,否则回首页,否则用户会觉得"我点的链接去哪了"。
追问
- Q:Token 过期与未登录怎么区分?A:未登录是用户态为 null;token 过期是有用户但 access token 失效,走请求层 401 刷新,刷新失败再登出。
- Q:多角色权限怎么拦?A:在 MainStack 内部再按角色条件渲染子 Stack,不要在每个页面里判断
role !== 'admin'。
07.2.2.6-010 页面级代码分割与懒加载在 RN 里怎么做?
一句话结论
RN 没有 Web 那样的"运行时按需下载 chunk",但可以通过 React.lazy + Suspense 在 JS 包内做组件级拆分(首次渲染时才加载模块),真正的"分包下载"需要 Metro 配置 + 自建更新体系,不是开箱即用。
概念解释
Metro 默认把所有 JS 打进一个 bundle。React.lazy 依赖 ESM 动态 import(),Metro 支持按 import 切分模块,但这只影响"加载时机"(模块在首次引用时才执行),不影响 bundle 大小——所有模块仍打进同一个产物。在新架构 + 并发渲染下,Suspense 可以与 React.lazy 配合做页面级占位。
真正的"分包加载"需要两个条件:一是把 JS 拆成多个 bundle(Metro 可以配置多个 entry,但组织成本高);二是在运行时动态加载远程 bundle(这与 OTA 热更新体系强相关,见 07.2.2.8),且受平台合规约束。
原理流程
开发模式:
React.lazy(() => import('./Detail'))
→ Metro 把 Detail 模块打入主 bundle
→ 首次渲染 Detail 时才执行模块代码(而非启动时)
生产分包(需要自建):
主 bundle + 子 bundle(远程)
→ 主包启动 → 路由到子包页面时动态加载远程 bundle
→ 受 OTA 合规约束
代码或图示
| 方案 | 是否减小主 bundle | 是否减小启动耗时 | 合规 |
|---|---|---|---|
| React.lazy | 否 | 略(延迟执行) | 无 |
| Metro 多 entry | 是 | 是 | 无 |
| 远程 bundle 加载 | 是 | 是 | 受 OTA 规则约束(待确认) |
常见误区
- 误区:
React.lazy能像 Web 一样减小包体积;正解:Metro 仍会把模块打进 bundle,只是延迟执行。 - 误区:新架构下 Suspense 可以直接等数据;正解:数据获取需要结合支持 Suspense 的库(如 React Query),且新架构支持矩阵以官方为准。
追问
- Q:启动慢但首屏不需要的大模块怎么处理?A:用
require()在交互回调里延迟引入,配合InteractionManager.runAfterInteractions(具体 API 以版本为准)。 - Q:远程 bundle 加载风险?A:版本不匹配、下载失败、平台合规,必须有兜底回退到主包。
07.2.2.6-011 fetch/axios 封装与拦截器应该长什么样?
一句话结论
统一封装一个 request 函数,承担 baseURL、header 注入、token 附加、错误归一化、loading 状态、上报;业务侧只调用 api.get<T>(path, params),不允许业务代码直接 fetch 或 axios.create。
概念解释
封装的核心价值是「错误路径只写一次」:401 刷新、403 跳登录、5xx 上报、网络错误降级、业务错误码(如 code !== 0)归一化,这些逻辑散在业务里一定会漂移。拦截器分请求拦截器(加 token、埋点)与响应拦截器(解包 data、识别错误、统一 Toast)。
fetch 原生不支持超时(要用 AbortController 手动包)、不支持请求/响应拦截器、错误只有 network 错误才 reject(HTTP 404/500 都 resolve),所以一般用 axios 或自封装 fetch。axios 在 RN 中可用,但其默认 adapter 与取消 API 在不同版本上有差异(CancelToken 已 deprecated,推荐 AbortController,待确认)。
原理流程
业务调用 api.get('/detail', { id })
→ 请求拦截器:注入 token、traceId、loading
→ 实际 HTTP 请求
→ 响应拦截器:
├─ HTTP 2xx 且业务 code === 0 → 返回 data
├─ 401 → 进入 token 刷新队列
├─ 业务错误码 → 抛归一化 ApiError + Toast
└─ 网络错误 → 抛 NetworkError + 降级提示
代码或图示
// 示意:统一封装(API 以实际版本为准)
api.interceptors.request.use(cfg => {
cfg.headers.Authorization = `Bearer ${auth.getAccessToken()}`;
return cfg;
});
api.interceptors.response.use(
resp => resp.data.code === 0 ? resp.data.data : Promise.reject(new ApiError(resp.data)),
err => handleError(err)
);
常见误区
- 误区:拦截器里直接
navigation.replace('Login');正解:拦截器不应该直接依赖导航,应该通过事件或 store 通知导航层。 - 误区:把所有错误都 Toast 出来;正解:分页加载失败、静默轮询失败不该打断用户,错误分级处理。
追问
- Q:axios 在 RN 中用什么 adapter?A:默认用基于 XHR 的 adapter,因为 RN 没有 Node http 模块,具体以 axios 文档为准。
- Q:怎么取消请求?A:用
AbortController(axios 新版支持),在页面卸载时 abort,避免 setState on unmounted 警告。
07.2.2.6-012 重试、超时与取消怎么设计?
一句话结论
超时用 AbortController 统一控制,重试只对幂等请求(GET/部分 DELETE)做且要有指数退避与最大次数,取消在页面卸载、组件卸载、重复请求发出时触发。三者都要在请求层统一实现,不要业务里各自写。
概念解释
重试最常见的坑是「非幂等请求也重试」:POST 下单重试一次可能产生两笔订单。所以重试白名单必须按 method 与接口语义配置。指数退避(1s、2s、4s)避免对故障服务造成雪崩。
取消的典型场景:用户在详情页快速点进另一个商品,前一个请求回来时组件已卸载,setState 会报警告或操作已销毁的 store;输入框联想搜索时,慢的请求后到会覆盖快的请求结果,要用「最后一次请求生效」策略。
原理流程
发出请求:
1. AbortController 启动超时定时器(如 10s)
2. 若请求失败且 method 幂等且未超过最大次数 → 退避后重试
3. 页面卸载 / 新请求发出 → controller.abort()
4. abort 触发 reject,业务层识别 abort 不报错
代码或图示
| 场景 | 重试 | 超时 | 取消 |
|---|---|---|---|
| GET 列表 | 可重试 | 10-15s | 页卸载取消 |
| POST 下单 | 不重试 | 10s | 不取消(事务已发起) |
| 搜索联想 | 不重试(用最后一次) | 5s | 新输入取消旧请求 |
| 上传 | 不重试 | 长超时 | 不取消 |
常见误区
- 误区:超时时间越短越好;正解:弱网下短超时会导致大量误杀,要按接口语义分级。
- 误区:所有失败都重试三次;正解:401、403、参数错误(4xx 除 408/429)都不该重试。
追问
- Q:怎么避免请求竞态?A:为每个请求生成 requestId,响应回来时校验是否是最新 id,过期响应直接丢弃。
- Q:上传下载怎么处理?A:用原生模块(如 RNFS、社区上传库),进度回调走事件,不走 axios。
07.2.2.6-013 AsyncStorage、MMKV、SQLite 怎么选?
一句话结论
KV 级、小数据、需要跨端一致选 AsyncStorage;对性能与同步读写敏感选 MMKV;结构化查询、关系数据、大数据量选 SQLite(或 ORM 封装)。三者不是互斥,可以在同一项目里分层使用。
概念解释
AsyncStorage 是 RN 官方推荐的异步 KV 存储,底层 Android 用 RocksDB/legacy 实现(版本不同实现不同,待确认),iOS 用原生序列化,API 全异步,容量小、适合存用户配置、token、缓存索引。它不适合存大 JSON,因为每次读写都要序列化整串。
MMKV 是腾讯开源的 mmap 存储,内存映射文件,读写直接操作内存页,异步但接近同步性能,支持加密(AES),适合高频小数据(登录态、开关、KV 缓存)。缺点是查询能力弱,只能按 key 取。
SQLite 是真正的关系型数据库,支持事务、索引、复杂查询,适合离线数据(聊天记录、离线购物车、本地缓存列表)。在 RN 中常见方案是 react-native-quick-sqlite、op-sqlite(WASM 性能路径)或 WatermelonDB(ORM 封装)。
原理流程
数据特征 → 选型:
├─ key-value,小,高频读写 → MMKV
├─ key-value,跨端一致,低频 → AsyncStorage
├─ 结构化,需要查询/事务 → SQLite / WatermelonDB
└─ 大文件(图片、视频) → 文件系统(documentDir / cacheDir)
代码或图示
| 维度 | AsyncStorage | MMKV | SQLite |
|---|---|---|---|
| 数据模型 | KV | KV | 表/关系 |
| 性能 | 一般 | 高(mmap) | 取决于查询 |
| 查询能力 | 无 | 无 | SQL |
| 事务 | 无 | 无 | 有 |
| 适用 | 配置、token | 高频小数据 | 离线数据 |
常见误区
- 误区:把整个列表 JSON 序列化存 AsyncStorage;正解:列表数据走 SQLite 或内存缓存,AsyncStorage 只存索引。
- 误区:MMKV 是同步 API 所以阻塞 JS 线程;正解:MMKV 读写在 JS 线程确实是同步操作,但因为是 mmap 所以很快,超大批量写入仍要注意。
追问
- Q:敏感信息怎么存?A:token 用 MMKV 加密或原生 Keychain/Keystore 封装,不要明文存 AsyncStorage。
- Q:WatermelonDB 的优势?A:它在 SQLite 之上提供响应式查询(
observe),UI 层订阅后数据变化自动重渲染,适合离线优先 App。
07.2.2.6-014 缓存策略与失效机制怎么设计?
一句话结论
按数据"新鲜度要求"分级:强实时数据(价格、库存)不缓存或短 TTL;准实时数据(首页 feed)用 TTL + 后台刷新;弱实时数据(用户资料、字典)用长 TTL + 主动失效。失效分 TTL、版本号、标签失效、主动刷新四种。
概念解释
缓存三层:内存(页面/store)→ 磁盘(MMKV/SQLite/AsyncStorage)→ 网络。命中内存直接用,命中磁盘先渲染再后台刷新(stale-while-revalidate),未命中走网络。
失效策略:
- TTL:固定时间过期,最简单。
- 版本号:App 发版时缓存结构变了,统一丢弃旧缓存。
- 标签失效:比如"商品详情页"缓存挂
product:123标签,商品更新时让该标签下所有缓存失效。 - 主动刷新:页面聚焦(
AppState/useFocusEffect)时重新拉一次。
原理流程
请求 /detail/123:
1. 内存有? → 立即返回
2. 磁盘有且未过期? → 立即返回 + 后台静默刷新
3. 磁盘有但已过期? → 返回旧数据(loading 骨架可选)+ 强制刷新
4. 都没有 → loading → 网络 → 写内存/磁盘
代码或图示
| 数据类型 | TTL | 失效策略 |
|---|---|---|
| 价格/库存 | 0-30s | 不缓存或短 TTL |
| 首页 feed | 1-5min | 后台刷新 + 下拉刷新 |
| 用户资料 | 1h | 标签失效 |
| 字典/枚举 | 24h | 版本号失效 |
常见误区
- 误区:缓存永不过期;正解:用户会永远看到旧数据,必须有 TTL 或主动失效。
- 误区:把缓存当离线数据库用;正解:缓存是性能优化,离线数据要走 SQLite 并设计同步协议。
追问
- Q:stale-while-revalidate 的风险?A:用户看到旧数据后突然跳变,关键页面(价格、库存)不适用。
- Q:怎么批量失效?A:用标签,每个资源类型一个标签,写操作时在响应拦截器里让对应标签失效。
07.2.2.6-015 乐观更新与冲突合并怎么做?
一句话结论
乐观更新是"先改本地 UI 再发请求",失败时回滚;冲突合并用于多端并发写同一资源,按字段合并或按版本号拒绝。两者都要在数据层统一实现,不能散在业务里。
概念解释
典型场景:点赞按钮点击后立即变成已赞,再发请求;请求失败则回滚并 Toast。实现上是先更新 store,再发请求,catch 里把 store 改回旧值。复杂场景(文章编辑)需要保存快照,回滚时用快照还原。
冲突合并:多端同时编辑同一商品标题,A 端改完 B 端再改会覆盖 A 的修改。解法一是向量时钟/版本号(后端返回 version,写时带 version,不一致则 409);二是字段级合并(只提交改动字段,后端按字段 merge)。
原理流程
乐观更新:
1. 记录旧值快照
2. 立即 set 新值到 store(UI 先变)
3. 发请求
├─ 成功 → 用服务端返回值校准
└─ 失败 → 回滚到快照 + Toast + 上报
冲突合并:
写请求带 version
├─ version 一致 → 写入成功,version +1
└─ version 不一致 → 409,提示用户或自动合并
代码或图示
| 操作 | 乐观更新 | 回滚 |
|---|---|---|
| 点赞/取消 | 立即切换 | 失败切回 |
| 购物车数量 | 立即改数 | 失败改回 |
| 文章编辑 | 不乐观 | 保存草稿 |
| 下单 | 不乐观 | 按钮 loading |
常见误区
- 误区:所有操作都乐观更新;正解:涉及钱、不可逆操作(下单、删除)不能乐观。
- 误区:乐观更新失败后只 Toast 不回滚;正解:UI 与服务端状态不一致比慢一点更糟。
追问
- Q:乐观更新期间用户又改了怎么办?A:用队列合并:第一次失败回滚,第二次操作基于最新 store 重新发起,不要直接覆盖。
- Q:离线场景的乐观更新?A:操作先入本地队列,网络恢复后按序重放,失败按业务规则处理。
07.2.2.6-016 登录态与 token 刷新怎么避免"刷新风暴"?
一句话结论
access token 短时效(如 15min),refresh token 长时效;401 时所有并发请求进入等待队列,只发一次刷新请求,刷新成功后重放队列,刷新失败则统一登出。
概念解释
没有队列会发生什么:页面同时发 5 个请求,access token 过期,5 个请求都 401,每个都去调 refresh,refresh token 被用了多次,服务端可能让 refresh token 失效(旋转 refresh token 模型),结果全部登出。
正确做法是一个「刷新单例」:模块级 refreshing Promise 标志,第一个 401 触发刷新,其他 401 把请求挂到这个 Promise 上等待。刷新成功后用新 token 重放;刷新失败(refresh 也过期)则清空登录态、跳登录。
原理流程
请求A 401 → 发现 refreshing === null
→ 创建 refreshing = refreshToken()
→ 请求B 401 → 发现 refreshing 已存在 → await refreshing
→ refreshing 成功:
用新 token 重放 A、B
→ refreshing 失败:
清登录态 → 跳登录 → A、B reject
代码或图示
// 示意:刷新队列(伪代码)
let refreshingPromise: Promise<string> | null = null;
function refresh() {
if (!refreshingPromise) {
refreshingPromise = api.refreshToken().finally(() => { refreshingPromise = null; });
}
return refreshingPromise;
}
// 响应拦截器 401 分支:await refresh() → 重放原请求
常见误区
- 误区:refresh token 也存 MMKV 就行;正解:refresh token 是高敏凭据,原生侧 Keychain/Keystore 封装更安全。
- 误区:刷新成功后直接让原请求用新 token 重发;正解:要重发,不是把新 token 塞回原响应,因为原请求已经被服务端拒绝。
追问
- Q:refresh token 也要过期怎么办?A:refresh token 有自己的有效期,过期即登出,不要静默续期无限制。
- Q:多端登录怎么处理?A:服务端按设备管理 refresh token,某端登出不影响其他端,刷新时校验设备 id。
07.2.2.6-017 错误分层与降级怎么做?
一句话结论
错误分四层:网络错误(断网、超时)、HTTP 错误(4xx/5xx)、业务错误(code !== 0)、JS 错误。每层处理方式不同,降级也分级:页面级骨架、组件级占位、操作级 Toast、全局白屏兜底。
概念解释
不分级的错误处理会导致两个极端:要么所有错误都弹 Toast 吵死用户,要么所有错误都静默导致数据不一致。正确做法是在请求层把错误归一化成 ApiError(带 kind 字段),业务侧按 kind 决定怎么处理。
降级的目标是"不要让一个模块的失败拖垮整个 App":商品详情页推荐区失败不应该影响详情主体;首页 Feed 失败应该展示缓存 + 重试按钮,而不是白屏。
原理流程
错误归类:
NetworkError → 弱网提示,自动重试
HttpError(4xx) → 401 走刷新,403 跳登录,其他 Toast
HttpError(5xx) → 上报,Toast 或静默
BusinessError → 按 code 处理(弹窗、跳页、静默)
降级:
组件级失败 → 组件内展示占位/重试
页面级失败 → 整页错误态 + 重试
全局失败 → ErrorBoundary 兜底 UI
代码或图示
| 错误类型 | 用户感知 | 处理 |
|---|---|---|
| 断网 | 提示 | 重试按钮 |
| 超时 | 弱提示 | 自动重试 |
| 5xx | 静默或 Toast | 上报 |
| 业务错误码 | 按业务 | Toast/弹窗 |
| JS 异常 | 白屏 | ErrorBoundary |
常见误区
- 误区:catch 住所有错误就不报了;正解:错误被用户看到的同时必须上报,否则线上出问题无法定位。
- 误区:降级 UI 与正常 UI 长得一样;正解:降级要明确告知用户"这是缓存/失败态",避免误导。
追问
- Q:ErrorBoundary 为什么抓不到异步错误?A:它只能捕获渲染期同步错误与生命周期错误,网络请求错误要在请求层处理。
- Q:弱网怎么实测?A:用模拟器/真机网络节流工具,或用代理拦截延迟,专门跑降级路径。
07.2.2.6-018 数据层为什么要分 UI、状态、仓库、数据源四层?
一句话结论
分层让"数据从哪来"和"UI 怎么展示"解耦:组件不直接发请求,仓库(Repository)统一协调远程与本地数据源,状态层把仓库数据接到 store,UI 只消费状态。这样换 API、加缓存、做离线都不用改组件。
概念解释
典型分层:
- UI 层:组件,调用
useXxxQuery或 hook,不关心数据来源。 - 状态层:store / React Query cache,管理 loading、error、data。
- 仓库层:
UserRepository,对外暴露getDetail(id),内部决定先读缓存还是发请求。 - 数据源层:
RemoteUserDataSource(HTTP)、LocalUserDataSource(SQLite/MMKV),每个数据源只懂一种存储。
好处是测试时可以 mock 仓库,UI 不用动;加离线支持时只改仓库,不动 UI。
原理流程
组件 → useDetail(id)
→ 状态层:查缓存 / loading
→ Repository.getDetail(id)
├─ LocalDataSource 命中 → 内存/磁盘数据
└─ RemoteDataSource 拉取 → 写 Local → 返回
→ 数据回到状态层 → 组件重渲染
代码或图示
UI 组件(只消费 hook)
↑
状态层(store / React Query)
↑
仓库层(协调缓存与远程)
↑
数据源层(HTTP / SQLite / MMKV)
常见误区
- 误区:在组件里
useEffect直接fetch;正解:那是脚手架阶段的写法,项目一大就散。 - 误区:仓库层暴露太多接口;正解:仓库按业务聚合(User、Order、Product),不要按数据源拆分。
追问
- Q:React Query / SWR 这种库在分层里处于什么位置?A:它本身就是状态层 + 缓存层,仓库层退化为"queryFn",适合中小项目。
- Q:大型项目还需要手写仓库吗?A:如果服务端接口多变、需要离线与合并,手写仓库更可控;接口稳定用 React Query 足够。
07.2.2.6-019 离线优先 App 的数据同步怎么设计?
一句话结论
离线优先的核心是"UI 永远读本地数据,网络只负责同步":所有写操作先入本地队列,网络恢复后按序重放;读操作直接读 SQLite,UI 不阻塞在网络上。冲突按业务规则处理(最后写入胜出 / 字段合并 / 提示用户)。
概念解释
这是一个从根上不同于"在线优先 + 失败降级"的架构:在线优先是先写网络、失败再存本地;离线优先是先写本地、网络是后台同步。好处是弱网与离线时 UI 完全不卡,代价是要设计操作队列、重试、冲突合并、版本号。
实现上常见栈:WatermelonDB(SQLite 响应式)+ 操作队列 + 后端增量同步 API(基于 updated_at 或版本号)。
原理流程
用户操作:
1. 立即写本地 SQLite(UI 立即响应)
2. 操作入 outbox 队列(带 id、payload、attempts)
3. 网络恢复 / App 回到前台 → 队列 worker 按序重放
├─ 成功 → 出队
├─ 失败可重试 → 退避重试
└─ 冲突 → 按业务规则 merge / 标记人工处理
读:UI observe SQLite → 同步完成后 SQLite 变 → UI 自动更新
代码或图示
| 决策 | 在线优先 | 离线优先 |
|---|---|---|
| UI 响应 | 网络慢则卡 | 永远立即 |
| 离线 | 不可用 | 可用 |
| 写冲突 | 即时 | 同步时处理 |
| 复杂度 | 低 | 高 |
常见误区
- 误区:离线优先 = 离线时也能正常用,联网后数据自动一致;正解:冲突处理是业务问题,技术栈只能提供机制。
- 误区:所有操作都该进 outbox;正解:读操作不需要 outbox,写操作中"读已提交数据"的操作也不进。
追问
- Q:outbox 重放失败超过最大次数怎么办?A:标记为"需要人工处理",在设置页提供"待同步"列表让用户看到并重试。
- Q:怎么测离线?A:真机飞行模式操作 → 恢复网络 → 观察 outbox 重放,包括中途切换网络、App 杀死重启。
07.2.2.6-020 综合题:设计一个电商 App 的状态与数据层
一句话结论
按"页面局部状态用组件 state、跨页共享用 Zustand、服务端数据用 React Query 类库 + 仓库层、本地持久化用 SQLite + MMKV"组合;登录态用根导航器条件渲染守卫;请求层统一处理 token 刷新、重试、错误归一化;长列表用分页缓存 + 失效标签。
概念解释
这道题考察的是把前面所有知识点拼成一张图。不要上来就说"用 Redux",而要按"数据属于谁"分层:
- 临时 UI 状态(弹窗、输入框、开关):
useState。 - 跨页共享(购物车数量、登录用户、主题):Zustand。
- 服务端数据(商品、订单、用户资料):React Query 管理缓存与失效,queryFn 走仓库。
- 持久化:MMKV 存 token 与开关,SQLite 存购物车与浏览历史。
- 导航:native-stack 主栈 + Tab,未登录渲染 LoginStack,深链接 linking 配置。
- 请求层:axios 实例 + 拦截器(token、401 队列、错误归一化、上报)。
原理流程
架构图:
UI 组件
├─ useState / 局部 hook
├─ useAuthStore(Zustand,跨页)
└─ useProductQuery(id)(React Query,服务端缓存)
↓ queryFn
ProductRepository
├─ LocalProductSource(SQLite 购物车/历史)
└─ RemoteProductSource(axios 实例)
↓ 拦截器
token 注入 / 401 刷新队列 / 错误归一化 / 上报
代码或图示
| 数据类型 | 状态管理 | 持久化 |
|---|---|---|
| 弹窗可见性 | useState | 无 |
| 登录用户 | Zustand | MMKV(加密) |
| 商品详情 | React Query | 内存缓存 |
| 购物车 | Zustand + SQLite | SQLite |
| 首页 Feed | React Query | 内存 + 磁盘 |
| 浏览历史 | SQLite | SQLite |
常见误区
- 误区:一上来就选 Redux;正解:先问团队规模、状态复杂度、调试需求,再选方案。
- 误区:所有数据都走 React Query;正解:本地操作(购物车数量加减)是状态,不是服务端查询,应该用 store。
追问
- Q:购物车数量在 Tab 角标要实时变,怎么做?A:购物车数据放 Zustand,Tab 角标订阅该切片,加购时改 store,角标自动更新;同时后台同步到服务端。
- Q:怎么设计灰度与回滚?A:请求层按版本号上报,监控看板按版本对比错误率;出问题时远程开关关闭某接口或降级策略,不需要发版(开关存在 MMKV 并由配置中心下发)。