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

07.1.1.8.2 数据仓库、缓存策略与同步

所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.1 原生移动开发 / 07.1.1 Android / 07.1.1.8 Room 与数据层

本节要解决的问题

本节聚焦数据层架构:Repository 与单一数据源、内存加磁盘双层缓存、缓存失效与 TTL、分页缓存、离线优先写入、增量同步与幂等重试、冲突解决,以及 Room 与 WorkManager 协作的后台同步。面试常从“界面数据从哪来”一路追问到断网可用、冲突收敛与后台任务可靠性。版本前提:Room 2.6+/2.7、Kotlin 协程与 Flow、WorkManager;版本敏感处标「待确认」。

07.1.1.8.2-001 Repository 层在数据架构中的职责是什么?

一句话结论

Repository 是数据访问的统一出口:对内组合本地数据库与远程接口,对外向界面层提供稳定的数据入口,屏蔽数据来源与刷新细节。

概念解释

界面 ViewModel 不直接调 DAO 或 API,而是依赖 Repository 抽象。Repository 决定数据从本地读还是远程拉、何时刷新、如何缓存与转换。它承接数据层规则:合并多数据源、处理错误状态、暴露可观察数据流,使界面只关心状态展示。

原理流程

ViewModel → Repository 接口 → 本地 DAO / 远程 API
  → 转换与合并 → 暴露 Flow / suspend 结果

代码或图示

class NoteRepository(
    private val dao: NoteDao,
    private val api: NoteApi
) {
    fun observeNotes(): Flow<List<Note>> = dao.observeAll()
    suspend fun refresh() { /* 远程拉取并落库 */ }
}

常见误区

  • Repository 变成纯转发层,业务规则仍堆在 ViewModel。
  • Repository 直接暴露 DAO/API 类型,界面绕过仓库规则直连数据源。

追问

  • Repository 应该是接口还是类?答:中型以上项目定义接口便于测试替换;简单项目可直接用类,注入 fake 实现。
  • 一个 Repository 对应一张表吗?答:通常按业务聚合划分,可跨多个 DAO 与 API,粒度以用例为准。

07.1.1.8.2-002 什么是单一数据源(SSOT)?为什么本地数据库常作为 SSOT?

一句话结论

SSOT 指同一份数据在应用内只有一份权威副本,其他派生视图都从它读取;移动端常用本地 Room 表作为 SSOT,远程 API 是更新来源而非展示副本。

概念解释

以本地库为 SSOT 时,界面观察数据库 Flow,远程数据先写库再由库驱动界面刷新。这样多页面、多次进入都读到一致状态,断网也能展示;远程响应只负责更新本地权威副本,不直接回灌界面列表。

原理流程

远程响应 → 写入本地库(SSOT)→ 库变更 → Flow 发射 → 所有界面刷新

代码或图示

fun observe(): Flow<List<Note>> = dao.observeAll() // 界面只观察本地

suspend fun sync() {
    val remote = api.fetchNotes()
    dao.upsertAll(remote.map { it.toEntity() }) // 写权威副本
}

常见误区

  • 远程结果直接塞 ViewModel 的内存列表,与本地库两份状态互相覆盖。
  • 多个 Repository 各自缓存一份内存数据,页面之间状态不一致。

追问

  • 哪些数据不适合做 SSOT 落库?答:一次性临时状态、纯 UI 交互态、大体积二进制文件,放内存或文件缓存即可。
  • SSOT 一定是数据库吗?答:不是,内存单例、文件、远程都可作为权威源;选择取决于可持久化要求与一致性需求。

07.1.1.8.2-003 Repository 如何组合本地 DAO 与远程 API?

一句话结论

典型组合:读路径先返回本地观察流,后台触发远程刷新并写回本地;写路径按离线优先先落本地再排队同步,Repository 统一编排两条数据源。

概念解释

Repository 在协程中协调:Flow 观察本地保证即时展示,suspend 方法负责远程拉取与入库。远程失败不丢弃本地缓存,错误状态单独上报。两条源的优先级、刷新时机、重试策略都收敛在仓库层,避免每个界面各写一套。

原理流程

读:本地 Flow 即时展示 → 后台 sync() 拉远程 → 入库 → Flow 再发射
  写:本地暂存 → 同步队列 → 远程提交 → 更新本地状态

代码或图示

fun observe(): Flow<List<Note>> = dao.observeAll()

suspend fun fetchRemote() = runCatching {
    api.fetch().also { dao.upsertAll(it.toEntities()) }
}

常见误区

  • 读路径先等远程响应再展示,离线或弱网白屏。
  • 远程成功后用内存集合替代库数据,破坏 SSOT。

追问

  • 本地缓存为空时如何提示?答:仓库流携带加载/空/错误状态,区分“首次加载中”与“无数据”。
  • API 与 DAO 方法签名如何对齐?答:Repository 做 DTO 到实体映射,DAO 不感知网络模型。

07.1.1.8.2-004 领域模型、DTO、实体在 Repository 层如何转换?

一句话结论

DTO 对应接口契约,实体对应本地表,领域模型是业务用例语义;Repository 在边界做单向映射,避免三种模型互相渗透。

概念解释

网络层解析 DTO,仓库层把 DTO 转实体入库;界面需要领域模型时由实体转领域对象。字段命名、可空性、嵌套结构在每层独立演进,映射显式写在扩展函数中并可单测。实体不进入 API 签名,DTO 不直接落表。

原理流程

DTO → 映射 → Entity(入库)→ 映射 → Domain/UI 模型(展示)

代码或图示

data class NoteDto(val id: Long, val title: String, val body: String)
data class NoteEntity(val id: Long, val title: String, val content: String)

fun NoteDto.toEntity() = NoteEntity(id, title, content = body)

常见误区

  • 一套类同时加序列化注解和 @Entity,网络改动牵动数据库迁移。
  • 映射逻辑散落界面层,字段变更要多处修改。

追问

  • 简单项目能否减少模型层?答:字段语义一致时 DTO 与实体可合并;出现分歧再拆分。
  • 领域模型需要持久化吗?答:领域模型描述业务行为,持久化交给实体;二者职责不同。

07.1.1.8.2-005 Repository 应该暴露 Flow 还是 suspend 函数?

一句话结论

可观察的数据用 Flow 持续推送状态;一次性动作(提交、刷新、删除)用 suspend 函数;两者按数据是否随时间变化来选择。

概念解释

列表、详情等会被本地变更或远程刷新更新的数据,返回 Flow 让收集方订阅;点击保存、手动刷新等动作是单次请求,用 suspend 并返回结果或异常。Flow 适合 SSOT 观察,suspend 适合命令式操作,混合使用时仓库对外语义清晰。

原理流程

状态型数据:Flow<List<T>>,收集期持续更新
  命令型操作:suspend fun action(...): Result<T>

代码或图示

fun observeById(id: Long): Flow<Note?> = dao.observeById(id)

suspend fun save(note: Note): Result<Unit> = runCatching {
    dao.upsert(note.toEntity())
}

常见误区

  • 用 suspend 函数返回一次性列表,后续本地变更界面得不到更新。
  • 把写操作包成 Flow,收集时机与操作触发关系混乱。

追问

  • Flow 如何表达加载状态?答:用包装状态类(Loading/Success/Error)或组合 remote-mediator 模式,在流内携带状态。
  • suspend 方法抛异常还是返回 Result?答:按团队约定;Repository 可统一捕获转为 Result,由界面决定提示方式。

07.1.1.8.2-006 为什么业务规则不应该散落在 ViewModel 直接调用 DAO/API?

一句话结论

规则下沉到 Repository 后可复用、可测试、可替换;散落在 ViewModel 会导致多页面行为不一致、难以单测,且数据源细节泄漏到界面层。

概念解释

“保存前校验、刷新失败回退、缓存键选择、合并去重”等规则属于数据层职责。ViewModel 只编排界面状态与用户交互,不重复实现规则。仓库集中管理后,换数据源、加缓存、做测试 Fake 都只改一处。

原理流程

规则集中:Repository 实现校验/合并/刷新
  ViewModel:调用仓库方法 → 维护界面状态

代码或图示

// 反例:ViewModel 直接拼 DAO + API + 去重规则
// 正例:Repository 内部完成,ViewModel 只调 observe()/save()

常见误区

  • 多个 ViewModel 各自写“先查本地再拉远程”,逻辑漂移。
  • 界面层直接依赖 Retrofit Service,数据来源无法在测试中替换。

追问

  • 哪些规则可以留在 ViewModel?答:与交互流程相关的编排(弹窗确认、导航、表单校验顺序)属于界面层。
  • 仓库规则如何测试?答:注入 Fake DAO/API,用例验证刷新、失败回退与合并行为。

07.1.1.8.2-007 Repository 接口放在哪一层?实现如何注入?

一句话结论

接口定义在依赖被依赖方的一侧(通常是数据层或 domain 层),实现放在数据实现模块;通过 DI 容器把实现绑定到接口。

概念解释

方向上:界面层依赖仓库接口,不依赖实现细节。多模块工程中,接口可下沉到公共/domain 模块,Room/Retrofit 实现在数据模块。DI(Hilt/Koin)在配置处完成绑定,测试时替换为 Fake 实现。

原理流程

interface NoteRepository(接口层)
  └─ class NoteRepositoryImpl(数据实现)
  DI 绑定:接口 ← 实现

代码或图示

// 接口模块
interface NoteRepository { fun observe(): Flow<List<Note>> }

// 数据模块实现
class NoteRepositoryImpl(/* dao, api */) : NoteRepository

常见误区

  • 接口与实现放在同一模块同一包,依赖倒置形同虚设。
  • 界面层直接 new 仓库实现,测试无法替换数据源。

追问

  • 单模块项目需要拆接口吗?答:规模小可不拆;预留接口有助于后续测试与替换。
  • DI 绑定放在哪个模块?答:实现所在模块提供绑定声明,容器聚合时加载。

07.1.1.8.2-008 多数据源合并时如何决定数据优先级?

一句话结论

按“数据权威性 + 新鲜度 + 业务语义”决定:本地 SSOT 作为展示基准,远程成功后覆盖本地;冲突字段按版本号或合并规则裁决,而不是简单后到先得。

概念解释

合并前先明确各源角色:本地是可离线读取的权威副本,远程是更新来源;缓存与实时数据按 TTL/时间戳比较。字段级冲突走版本或 LWW 规则,整体刷新与局部更新分开处理。优先级规则显式写在仓库层,避免隐式覆盖。

原理流程

多源数据 → 比对版本/时间戳 → 按规则合并字段
  → 写入 SSOT → 统一发射

代码或图示

fun merge(local: Note, remote: Note): Note =
    if (remote.version >= local.version) remote else local

常见误区

  • 远程空列表覆盖本地已有数据(分页/筛选条件不一致导致)。
  • 用响应到达顺序判断新旧,网络乱序下误覆盖更新记录。

追问

  • 远程部分字段为空要不要覆盖本地?答:区分“空值即清除”与“空值即缺省”,按接口语义处理,通常缺省不覆盖。
  • 合并规则放服务端还是端侧?答:强一致字段以服务端为准;端侧只做展示合并与冲突兜底。

07.1.1.8.2-009 Repository 如何处理“本地有缓存、远程更新失败”的场景?

一句话结论

远程失败时保留本地缓存继续展示,把错误作为状态上报,不清除已有数据;待网络恢复后由同步任务重试,缓存不因为一次失败而失效。

概念解释

刷新失败不等于数据无效:本地缓存仍是可读副本。仓库在 runCatching 中隔离远程异常,流继续发射本地数据,错误状态单独暴露给界面提示。重试交给同步机制(WorkManager/协程重试),而不是删除缓存强迫重新加载。

原理流程

sync() 远程失败 → 捕获异常 → 保留本地数据 → 上报 Error 状态
  → 网络恢复后任务重试拉取

代码或图示

suspend fun refresh() {
    runCatching { api.fetch() }
        .onSuccess { dao.upsertAll(it.toEntities()) }
        .onFailure { stateFlow.emit(State.Error(it)) }
}

常见误区

  • 远程失败后清空内存缓存或库表,用户看到空页面。
  • 异常直接冒泡导致界面崩溃,本地数据也未展示。

追问

  • 缓存过期但远程不可用时展示什么?答:展示过期缓存并标注“可能不是最新”,优于空页面;敏感数据场景另定策略。
  • 失败重试由谁触发?答:网络恢复回调、定时任务或用户下拉刷新,避免在界面层无限循环重试。

07.1.1.8.2-010 空数据与加载中状态在仓库层如何表达?

一句话结论

用显式状态包装区分加载中、成功(含空列表)、错误;空集合是成功结果,不能与“加载中”或“加载失败”混为一谈。

概念解释

Flow 裸列表无法表达“正在首次加载”。仓库暴露状态流:Loading 表示请求进行中,Success(data) 承载结果(data 可为空),Error(throwable) 携带失败原因。界面按状态渲染骨架、列表、空态、错误提示。

原理流程

State.Loading → State.Success(列表,可能为空) / State.Error(异常)

代码或图示

sealed interface UiState<out T> {
    data object Loading : UiState<Nothing>
    data class Success<T>(val data: T) : UiState<T>
    data class Error(val cause: Throwable) : UiState<Nothing>
}

常见误区

  • 用空列表表示加载中,界面无法区分“真的没有”与“还在加载”。
  • 错误后状态停留在 Loading,骨架屏一直不消失。

追问

  • 刷新时要不要先显示 Loading?答:后台刷新可保留旧数据只更新指示器;首次加载才全屏 Loading。
  • 状态放仓库还是 ViewModel?答:仓库提供原始结果与异常,状态映射可在 ViewModel 组合,按团队分层约定。

07.1.1.8.2-011 Repository 层如何做缓存键与作用域划分?

一句话结论

缓存按业务实体 + 账号 + 筛选条件构造键,作用域分为全局单例、会话级、页面级;不同作用域的生命周期与清理时机不同。

概念解释

同一实体在不同用户、不同筛选条件下数据不同,缓存键必须包含维度。全局缓存跨页面复用,会话级随登录态清理,页面级随离开销毁。键设计混乱会出现串号:A 页面看到 B 条件的数据,或登出后残留上一用户数据。

原理流程

缓存键 = 实体类型 + 账号 ID + 查询条件(筛选/分页游标)
  作用域:全局 / 会话 / 页面

代码或图示

data class CacheKey(val entity: String, val accountId: String, val filter: String)

常见误区

  • 缓存键只用实体名,不同账号/条件互相覆盖。
  • 全局缓存持有页面级大数据,退出页面后不释放。

追问

  • 键里能放完整查询对象吗?答:可派生稳定字符串;注意排序、分页等维度是否纳入,避免等价条件产生重复缓存。
  • 会话级缓存何时清?答:登出、切换账号、会话失效时统一清理并重建。

07.1.1.8.2-012 薄 Repository 与厚 Repository 的取舍?

一句话结论

薄仓库只做数据源转发与映射,厚仓库承载缓存、合并、同步规则;取舍取决于业务复杂度与团队分层约定,核心是规则有明确归属。

概念解释

薄 Repository 适合数据源简单、规则少的模块,实现轻、易读;复杂业务(多源合并、离线队列、冲突解决)需要厚仓库集中承载。过度增厚会让仓库变成大泥球;过薄则规则上移到 ViewModel。判断标准:规则是否被多个用例复用。

原理流程

简单 CRUD:薄仓库(转发 + 映射)
  复杂同步/合并:厚仓库(规则 + 缓存 + 重试)

代码或图示

薄:API/DAO 调用 → 类型转换 → 返回
  厚:缓存策略 + 合并去重 + 队列同步 + 状态管理

常见误区

  • 仓库什么都往里塞,变成无法测试的上帝类。
  • 仓库只做透传,规则散落各 ViewModel,行为不一致。

追问

  • 厚仓库如何拆分?答:按职责拆缓存器、同步器、合并器,Repository 编排它们;或按业务子域拆多个仓库。
  • 业务规则能放 UseCase 层吗?答:可以,UseCase 编排仓库与业务流程,仓库专注数据访问;分层按项目规模选择。

07.1.1.8.2-013 内存缓存与磁盘缓存各自承担什么?

一句话结论

内存缓存承担高频读取的活跃数据,追求低延迟;磁盘/数据库缓存承担持久化与离线可读,容量更大但访问更慢。

概念解释

内存命中省去数据库查询与反序列化,适合当前页面与近期浏览数据;磁盘缓存解决进程重建、离线打开与容量问题。结构化关系数据落 Room,大体积文件(图片、附件)落文件缓存。两层配合:先查内存,未命中再读磁盘,回源后回填两层。

原理流程

读:内存 → 磁盘/库 → 远程回源
  写:更新磁盘 SSOT → 回填内存

代码或图示

fun get(id: Long): Note? = memory[id] ?: dao.findById(id)?.also { memory[id] = it }

常见误区

  • 全部数据驻留内存,列表滚动与进程内存压力失控。
  • 只做内存缓存,进程重建后离线数据全丢。

追问

  • 内存缓存放仓库还是单例?答:按作用域;跨页面共享用单例持有,页面级随 ViewModel 销毁。
  • 磁盘缓存一定是数据库吗?答:结构化数据用库,二进制与原始文件用目录缓存。

07.1.1.8.2-014 为什么不把全部数据放内存缓存?

一句话结论

设备内存有限,全量驻留会触发 LMK 杀进程、增大 GC 压力;且进程重建后内存不保留,无法支撑离线场景。

概念解释

移动端堆内存有上限,大列表全量缓存导致 OOM 或系统回收。内存只保留活跃与热点数据,冷数据落磁盘;按容量与最近使用淘汰。全量内存方案在低端设备与长列表场景首先暴露稳定性问题。

原理流程

内存容量上限 → 超阈值淘汰冷数据
  冷数据保留在磁盘 → 再次访问时回载

代码或图示

// 超过容量淘汰最久未使用项
if (memory.size > MAX) memory.removeOldest()

常见误区

  • 用 MutableMap 无限累积读取过的对象。
  • 以为内存缓存不会被系统回收,忽略进程被杀场景。

追问

  • 多少数据适合进内存?答:按单条大小、页面停留与设备内存评估;列表通常只缓存当前页与相邻页。
  • 全量场景怎么办?答:分页加载 + 磁盘/数据库分页,不追求全量驻留。

07.1.1.8.2-015 内存缓存用什么数据结构?弱引用与强引用怎么选?

一句话结论

常用 LRU 结构(链表 + 哈希)按访问顺序淘汰;强引用持有对象防止被回收,弱引用仅做快速副本、允许 GC 回收,命中率要求高的场景用强引用加容量上限。

概念解释

强引用缓存的对象不会被 GC 回收,必须主动淘汰;弱引用映射在内存紧张时自动清理,重建成本低但命中率波动。配置缓存、大图片适合弱引用或软引用语境;核心业务数据用强引用 LRU 并控制容量。

原理流程

强引用:容量上限 + LRU 淘汰,命中率可控
  弱引用:GC 可回收,重建时从磁盘/库回载

代码或图示

val lru = object : LinkedHashMap<Long, Note>(16, 0.75f, true) {
    override fun removeEldestEntry(e: Map.Entry<Long, Note>) = size > MAX
}

常见误区

  • 弱引用缓存当作强缓存使用,空值频繁回源导致性能抖动。
  • 强引用缓存无上限,对象随业务增长持续累积。

追问

  • Kotlin/Android 有现成 LRU 吗?答:LruCache(Android 框架)或自定义 LinkedHashMap;按缓存对象类型选择。
  • 缓存对象为何要不可变?答:避免一处修改污染缓存副本;可变对象被多个读取方共享会产生隐蔽状态问题。

07.1.1.8.2-016 磁盘缓存与 Room 表如何分工?

一句话结论

Room 存可查询、可关联、需一致性的结构化数据;文件缓存存大体积二进制与原始响应,结构化索引/元数据可放库表。

概念解释

关系型表适合列表记录、过滤排序、事务与观察;图片、视频、附件按文件路径存储,库里只记路径与元数据。原始 JSON 响应作为调试/回源缓存可落文件,但业务数据以解析后的库记录为准。

原理流程

结构化记录 → Room 表(可查询/事务/Flow 观察)
  二进制 → 文件目录(库表存路径、大小、校验值)

代码或图示

@Entity data class Media(
    @PrimaryKey val id: Long,
    val filePath: String,
    val checksum: String
)

常见误区

  • 把大字段序列化进单行记录,列表查询读取冗余大对象。
  • 文件散落缓存目录无元数据记录,清理与去重困难。

追问

  • 网络响应体缓存放哪?答:可作为短期原始缓存落文件;需要结构化展示的数据仍解析入库。
  • 磁盘缓存怎么清容量?答:按 LRU/过期时间清理文件,并同步删除库中元数据。

07.1.1.8.2-017 Flow 的 distinctUntilChanged 为什么必要?

一句话结论

distinctUntilChanged 过滤连续重复发射,避免相同状态触发下游重复重组、重算与界面刷新;SSOT 流在表变更时可能发射等价内容。

概念解释

Room 表写入后观察查询重新执行,即使内容未变也会发射一次;下游若做重计算或界面重组,重复等价流造成浪费。distinctUntilChanged 按内容比较过滤相邻重复项,配合数据类值比较保证“相同才去重”。

原理流程

上游发射 → 与上一条比较 → 相同丢弃,不同放行

代码或图示

dao.observeAll()
    .distinctUntilChanged()
    .map { it.toUi() }

常见误区

  • 缓存对象可变,equals 不可靠导致去重失效。
  • 对需要保留每一次刷新信号的场景错误去重,丢失刷新事件。

追问

  • 自定义类型如何参与比较?答:data class 自动按字段比较;普通类需实现 equals/hashCode 或指定比较器。
  • distinctUntilChanged 与 stateIn 的关系?答:先去重再转状态流,下游只收到变化后的最新值。

07.1.1.8.2-018 stateIn 与 shareIn 在仓库层怎么用?

一句话结论

stateIn 把冷流转为持有最新值的状态流,适合单消费者共享的界面状态;shareIn 配置多个消费者共享上游,适合广播式数据。

概念解释

仓库暴露的观察流若被多个收集方复用,直接每次收集都会重新订阅上游;stateIn(scope, Started.Eagerly/Lazily, initial) 持有最新状态。shareIn 控制订阅启动时机与 replay 缓存。注意作用域选择:仓库级用全局 scope,页面级用 ViewModel scope。

原理流程

冷流 → stateIn/shareIn → 共享上游 + 持有最新值

代码或图示

val notes: StateFlow<List<Note>> = dao.observeAll()
    .stateIn(appScope, SharingStarted.WhileSubscribed(5000), emptyList())

常见误区

  • 用全局 scope 持有页面级流,页面离开后仍订阅数据库。
  • stateIn 初始值与真实空态不符,界面首帧闪烁。

追问

  • WhileSubscribed 有什么用?答:最后一个收集者退出后延迟停止上游,兼顾省流与快速重订。
  • StateFlow 能发送重复值吗?答:会与当前值比较去重,相同值不再分发。

07.1.1.8.2-019 Flow 收集与生命周期如何绑定,避免泄漏?

一句话结论

界面收集 Flow 绑定到 Lifecycle/ViewModel 作用域,在销毁时自动取消订阅;仓库流持有长作用域时,必须保证收集方退出后上游可停止。

概念解释

Activity/Fragment 用 repeatOnLifecycle 等方式在 STARTED 以上收集,离开页面取消订阅;ViewModel 用 viewModelScope 收集。数据库观察流若不随界面取消,会持续监听写库并持有界面引用。仓库共享流的启动策略与 replay 也要配合生命周期。

原理流程

Lifecycle STARTED → 收集流
  STOPPED/DESTROYED → 取消订阅,释放引用

代码或图示

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        repository.observe().collect { render(it) }
    }
}

常见误区

  • 在 GlobalScope 收集仓库流,进程内长期持有界面引用。
  • 只取消 ViewModel 收集,仓库侧共享上游未按订阅数停止。

追问

  • ViewModel 里收集为什么用 viewModelScope?答:ViewModel 清除时自动取消,避免配置变更外的泄漏。
  • 仓库流需要感知生命周期吗?答:仓库提供流与作用域参数;生命周期绑定属于界面层职责。

07.1.1.8.2-020 内存缓存失效后如何回源重建?

一句话结论

缓存未命中或失效时,按“磁盘/库 → 远程”顺序回源,成功后回填内存与磁盘;重建过程对界面表现为加载状态,失败保留兜底数据。

概念解释

失效触发包括主动淘汰、过期、写穿透清理。回源路径分层:先查持久层,未命中再请求远程;回填顺序先写权威持久层,再更新内存。重建期间并发请求应合并(避免同一键重复回源),结果就绪后统一分发。

原理流程

缓存未命中 → 查磁盘 → 仍无 → 远程回源
  → 写磁盘 → 回填内存 → 分发结果

代码或图示

suspend fun ensure(id: Long): Note {
    memory[id]?.let { return it }
    dao.findById(id)?.let { memory[id] = it; return it }
    return api.detail(id).toEntity().also { dao.upsert(it); memory[id] = it }
}

常见误区

  • 缓存空值也缓存,导致回源失败后一直不重试。
  • 并发多个请求同时回源同一键,重复网络请求。

追问

  • 空结果要不要缓存?答:短期可缓存避免抖动,设置较短 TTL;并区分“确认不存在”与“查询失败”。
  • 回源合并怎么做?答:用挂起锁或 Flow 共享在途请求,首个完成后其他方取同一结果。

07.1.1.8.2-021 缓存击穿、穿透、雪崩在端侧如何理解?

一句话结论

击穿指热点键失效瞬间并发回源;穿透指查询不存在数据反复打远程;雪崩指大量缓存同时过期导致回源洪峰;端侧通过 TTL 抖动、空值缓存、在途合并缓解。

概念解释

与服务端缓存概念对应到移动端:列表刷新、多页面同时进入可造成同一批缓存过期并发回源。不存在的数据反复查询属于穿透;批量同 TTL 同时失效属于雪崩。端侧量级通常较小,但弱网与后台任务叠加时仍需控制并发回源。

原理流程

热点失效 → 在途请求合并(击穿)
  不存在 → 短期空值缓存(穿透)
  批量过期 → TTL 加随机抖动、分批刷新(雪崩)

代码或图示

val ttl = BASE_TTL + Random.nextLong(0, JITTER)

常见误区

  • 所有条目同一固定时刻过期,进入页面集中打远程。
  • 不缓存空结果,坏 ID 反复触发网络请求。

追问

  • 端侧需要布隆过滤器吗?答:一般不需要;用空值短期缓存即可。
  • 后台刷新如何避免雪崩?答:错开任务调度、限制并发同步数、按需分页回源。

07.1.1.8.2-022 缓存大小与淘汰策略(LRU)怎么设计?

一句话结论

按内存上限配置容量,LRU 淘汰最久未访问条目;配合 TTL 清理过期项,定期扫描剔除冷数据,淘汰顺序兼顾访问时间与容量。

概念解释

LRU 依据访问记录保留热点;纯 LRU 不区分过期时间,需叠加 TTL。淘汰策略可按条目大小加权(图片缓存按字节数),写入与淘汰在单线程或加锁下执行,避免并发修改结构。容量阈值按设备内存与业务类型分层设定。

原理流程

写入/访问 → 更新顺序
  超容量 → 淘汰 LRU 尾部;过期项定期清理

代码或图示

class LruCache<K, V>(private val maxSize: Int) {
    private val map = LinkedHashMap<K, V>(16, 0.75f, true)
    @Synchronized fun put(k: K, v: V) { map[k] = v; trim() }
    private fun trim() { while (map.size > maxSize) map.remove(map.keys.first()) }
}

常见误区

  • 只按条目数淘汰,大图片缓存实际字节数失控。
  • 淘汰与读取并发修改 map,结构损坏或异常。

追问

  • LRU 与 LFU 怎么选?答:端侧热点变化快,LRU 足够;访问频次差异大的场景可考虑 LFU。
  • 淘汰后磁盘数据还在吗?答:内存淘汰不删磁盘;磁盘缓存另有容量与过期清理策略。

07.1.1.8.2-023 图片/文件缓存与结构化数据缓存有何不同?

一句话结论

图片文件按字节容量管理、按 URL/键去重、支持解码复用;结构化数据按记录管理、可查询关联、走事务与观察流。两者元数据与内容分开存储。

概念解释

图片缓存关注尺寸、格式、解码内存与磁盘大小,常由专用图片库管理;结构化缓存关注一致性、查询条件、版本与失效。文件缓存清理按 LRU 与容量,结构化清理按业务规则与 TTL。元数据(路径、大小、校验值)可入库便于对账。

原理流程

图片:URL 键 → 文件 + 解码缓存,按字节限额
  结构化:记录入库,按查询条件检索与同步

代码或图示

data class FileMeta(val key: String, val path: String, val size: Long, val ttl: Long)

常见误区

  • 把图片原始字节塞进数据库字段,读写与迁移成本高。
  • 文件缓存只清内存不删磁盘,长期占满存储。

追问

  • 图片库缓存策略要自己实现吗?答:常规直接用成熟图片库的磁盘/内存缓存;自定义需求再扩展。
  • 文件缓存如何去重?答:URL 或内容校验值作为键,相同内容共享一份文件。

07.1.1.8.2-024 双层缓存不一致时以谁为准?

一句话结论

以持久层(磁盘/数据库)为权威基准,内存只是加速副本;发现不一致时回读持久层重建内存,并修正合并写入顺序。

概念解释

不一致来源:内存被改未穿透写库、进程重建内存清空、并发写入顺序错位。修复原则:读时持久层为准,内存未命中回载;写操作先持久层后内存,避免内存领先。定期校验可发现残留脏缓存。

原理流程

读:持久层为准,内存副本可重建
  写:先写库 → 再更新内存;异常时从库回载对齐

代码或图示

fun refreshFromDb(id: Long) { dao.findById(id)?.let { memory[id] = it } }

常见误区

  • 以内存为最新,库滞后导致其他页面读到旧数据。
  • 写内存成功但写库失败,状态显示已保存实际未落库。

追问

  • 不一致如何检测?答:关键操作后比对内存与库版本/时间戳;启动时做一致性扫描。
  • 临时内存态与持久数据分开?答:是,交互态不进持久层,避免把 UI 状态当业务缓存。

07.1.1.8.2-025 多页面共享同一份缓存数据怎么做?

一句话结论

把共享缓存提升到仓库/单例作用域,通过共享 Flow 或 LRU 缓存被多个页面订阅;写入经同一仓库入口,保证各页面看到一致状态。

概念解释

多页面各自缓存会重复占用内存且状态分叉。共享层持有 SSOT 流,页面收集同一 StateFlow;任何修改走仓库写方法更新权威源,流自动分发。作用域跟随应用生命周期,注意不要把页面专属数据提升为全局共享。

原理流程

仓库单例持有共享 Flow/缓存
  页面 A、B 订阅同一上游
  写入 → 更新 SSOT → 所有订阅方刷新

代码或图示

// 仓库单例内
val sharedNotes: StateFlow<List<Note>> = dao.observeAll()
    .stateIn(appScope, SharingStarted.WhileSubscribed(5000), emptyList())

常见误区

  • 每个 ViewModel 各自维护一份内存副本,返回首页数据回退。
  • 全局共享缓存携带页面筛选条件,跨页面串数据。

追问

  • 共享流 replay 多少合适?答:状态流保留最新值即可;广播事件类按需配置 replay。
  • 页面私有数据如何隔离?答:留在 ViewModel/页面作用域,不进入全局仓库缓存。

07.1.1.8.2-026 缓存对象的不可变性与线程安全?

一句话结论

缓存对象应不可变或拷贝后修改,避免一处改动污染副本;缓存容器在并发访问下加同步或使用线程安全结构。

概念解释

可变对象被内存缓存与多个读取方共享,任意一方修改都会影响其他方。不可变值配合 copy() 派生新对象;LRU/Map 的读写在多线程下需要锁或并发映射。Room 查询本身线程安全,但仓库内存缓存需自行保证。

原理流程

不可变对象 → 修改走 copy → 新对象入缓存
  容器并发:同步方法 / 线程安全映射

代码或图示

data class Note(val id: Long, val title: String)
val updated = note.copy(title = newTitle)

常见误区

  • 缓存返回可变引用,界面直接改字段导致缓存被污染。
  • 多线程同时读写普通 HashMap,出现丢项或结构异常。

追问

  • 缓存要深拷贝吗?答:不可变对象无需拷贝;可变对象返回前拷贝或限制修改入口。
  • 线程安全粒度多大?答:单缓存实例加锁即可;避免长锁阻塞 IO 线程。

07.1.1.8.2-027 缓存失效有哪几种触发方式?

一句话结论

主动失效(写穿透、登出、用户刷新)、被动过期(TTL 到期)、容量淘汰(LRU)三类,分别应对数据变更、时间衰减与内存压力。

概念解释

写操作后让相关键/列表失效,避免读到旧值;TTL 到期视为可能过期,下次访问回源;容量超限淘汰冷条目。三种方式互补:主动失效保证新鲜度,被动过期兜底,淘汰策略控制资源。

原理流程

写入 → 主动失效相关缓存
  时间到期 → 被动过期标记
  容量超限 → LRU 淘汰

代码或图示

suspend fun update(note: Note) {
    dao.upsert(note.toEntity())
    memory.remove(note.id) // 写穿透失效
}

常见误区

  • 只靠 TTL,写后长时间展示旧数据。
  • 主动失效范围算错,关联列表残留脏缓存。

追问

  • 列表缓存与条目缓存如何联动失效?答:条目变更后失效对应列表快照;关联面广时直接刷新列表流。
  • 失效是删除还是标记过期?答:可先标记过期保留兜底展示,后台回源后替换;纯内存场景直接删除。

07.1.1.8.2-028 TTL 怎么设置才合理?

一句话结论

按数据更新频率、业务对新鲜度的要求与弱网成本设定:变化快的短 TTL,稳定数据长 TTL;配合主动失效与随机抖动避免同时过期。

概念解释

TTL 过长数据陈旧,过短回源频繁。可按实体类型分级:会话/配置类长 TTL,动态列表短 TTL,详情缓存中等。时间戳与 TTL 存在记录或元数据中;首次加载、下拉刷新可绕过 TTL 强制回源。

原理流程

数据类别 → 新鲜度要求 → TTL 区间 + 随机抖动
  强制刷新入口绕过 TTL

代码或图示

data class CacheEntry<T>(val value: T, val expireAt: Long) {
    fun expired(now: Long) = now > expireAt
}

常见误区

  • 所有数据共用一个 TTL,热点数据陈旧或稳定数据浪费流量。
  • TTL 存在内存,进程重建后全部视为永久有效。

追问

  • TTL 到期必须删数据吗?答:可展示过期兜底,标注非最新;后台刷新替换。
  • 服务端推送变更如何缩短 TTL?答:推送/写穿透直接失效相关缓存,不等 TTL。

07.1.1.8.2-029 主动失效与被动过期如何配合?

一句话结论

主动失效处理已知变更,被动过期兜底未知变更;两者结合保证“写后即新”与“时间衰减”双保险。

概念解释

本地写、远程推送、关联数据更新触发主动清理;长时间未被通知的数据靠 TTL 被动兜底。主动失效避免等待过期,被动过期防止漏通知导致永久脏数据。失效粒度:条目级、列表级、会话级按需组合。

原理流程

已知变更 → 主动失效
  未通知变更 → TTL 被动过期
  兜底:启动/进入页面校验

代码或图示

fun onLocalChange(id: Long) { memory.invalidate(id); listCache.invalidate() }

常见误区

  • 只做被动过期,写入后界面长时间旧数据。
  • 只做主动失效,消息丢失后脏数据永久残留。

追问

  • 失效范围如何计算?答:按外键/关联关系映射受影响列表;复杂关联直接整体刷新列表。
  • 后台推送如何接入失效?答:推送到达后调用仓库失效方法,刷新对应缓存与流。

07.1.1.8.2-030 写操作后如何让相关缓存失效?

一句话结论

写入权威源后,清理或重建受影响的条目缓存与关联列表缓存;按数据依赖关系确定失效范围,避免遗漏关联视图。

概念解释

新增/更新/删除一条记录后,单条缓存与包含它的列表快照都可能过期。失效方法按实体关系编排:清条目、清相关列表、必要时触发后台刷新。写入先落库再失效内存,防止失效后回载到旧值。

原理流程

写库成功 → 失效条目缓存 → 失效关联列表 → 流重新发射

代码或图示

suspend fun delete(id: Long) {
    dao.deleteById(id)
    memory.remove(id)
    listCache.invalidate()
}

常见误区

  • 只清条目不清列表,列表仍展示已删记录。
  • 先清缓存后写库,写库失败时空窗期回载出旧数据。

追问

  • 关联跨多个仓库怎么办?答:通过领域事件或统一写入口广播变更,各仓库失效自身缓存。
  • 大列表失效后立即全量重建吗?答:可先清快照,下次访问按需分页回源。

07.1.1.8.2-031 TTL 存在哪里?如何避免每次查询比对时间?

一句话结论

TTL 时间戳随缓存条目或库元数据持久化;读取时按条目判断是否过期,避免全局扫描;过期判断只在访问路径与定期清理任务中执行。

概念解释

把 expireAt 与条目绑定,命中缓存时比较当前时间即可;不需要每次查询遍历全部缓存。磁盘缓存把过期时间存库表列,清理任务按时间戳批量扫描。内存重建从持久层读取元数据,不丢失 TTL。

原理流程

条目携带 expireAt → 访问时单条判断
  清理任务:批量扫描过期项

代码或图示

@Entity data class CacheMeta(
    @PrimaryKey val key: String,
    val expireAt: Long
)

常见误区

  • TTL 只存内存,进程重启后永久有效。
  • 每次查询全表扫描过期时间,增加无谓 IO。

追问

  • 访问时发现过期如何处理?答:标记过期并触发回源;可先返回过期兜底值,后台刷新替换。
  • 元数据与内容不一致怎么清?答:定期对账删除无内容或无元数据的残留项。

07.1.1.8.2-032 过期数据在什么场景下可以先展示再刷新?

一句话结论

非强一致、可容忍短暂陈旧的展示场景,先渲染过期缓存并后台刷新替换;涉及金额、权限、最新状态等强一致数据必须等新数据或明确标注。

概念解释

先展示过期数据可避免白屏与重复加载感,刷新成功后更新界面。代价是用户看到短暂旧值;强业务字段(余额、订单状态、授权)不适合先旧后新。策略按页面与字段分级,并在界面标注数据时效。

原理流程

缓存过期 → 先展示旧值 → 后台回源 → 成功替换 / 失败保留旧值

代码或图示

fun observe(): Flow<Result<Note>> = flow {
    localCached?.let { emit(Result.stale(it)) }
    emit(Result.Success(api.fetch().toEntity()))
}

常见误区

  • 所有场景都先旧后新,敏感字段展示错误状态。
  • 刷新失败仍保留旧值且不提示,用户误以为最新。

追问

  • 如何标识 stale 状态?答:状态包装携带 isStale 标记,界面可显示“更新中/缓存数据”。
  • 强一致字段怎么取?答:关键详情接口等待响应,失败走错误态或受控兜底。

07.1.1.8.2-033 缓存版本号与数据结构升级如何兼容?

一句话结论

缓存结构变更时带版本标识,旧版本缓存按策略失效重建;序列化 schema 演进要兼容旧格式读取,避免升级后解析失败。

概念解释

缓存键或元数据带 schema 版本号,应用升级后识别旧版本条目并清理。JSON/实体字段增删要可缺省,类型变化提供迁移或失效。数据库结构走 Room 迁移流程;文件缓存格式变更时按版本目录隔离。

原理流程

缓存条目带 schemaVersion
  版本不匹配 → 失效重建;兼容读取 → 映射到新结构

代码或图示

data class CacheEntry<T>(val schemaVersion: Int, val value: T, val expireAt: Long)

常见误区

  • 改了序列化字段但旧缓存反序列化失败,页面崩溃。
  • 新旧缓存混在同一命名空间,解析类型错乱。

追问

  • 结构大改怎么过渡?答:旧版本整体清空重建,或按版本目录隔离后逐步迁移。
  • 数据库缓存升级走哪套机制?答:Room Migration 与 schema 校验,详见 07.1.1.8.1。

07.1.1.8.2-034 如何避免缓存脏数据长期残留?

一句话结论

通过 TTL 兜底、主动失效、定期清理任务与启动对账组合,定期淘汰过期与孤儿缓存;敏感操作后校验本地与远程一致性。

概念解释

脏数据来源:漏失效、推送丢失、写失败回滚。单靠 TTL 可能周期过长,需要清理任务扫描过期项、孤儿文件与无主记录;启动时对账发现残留并修复。长期残留还会占满存储,容量清理不可少。

原理流程

主动失效 + TTL 兜底
  → 定期清理任务扫过期/孤儿
  → 启动对账修复不一致

代码或图示

@Query("DELETE FROM cache_meta WHERE expireAt < :now")
suspend fun purgeExpired(now: Long)

常见误区

  • 只写入不清理,缓存无限膨胀。
  • 清理任务只删元数据不删文件,磁盘残留。

追问

  • 孤儿记录怎么识别?答:外键无主、文件不存在、关联账号已切换;定时扫描并清除。
  • 脏数据发现后如何补偿?答:标记待同步/待刷新,下次在线时重新拉取对账。

07.1.1.8.2-035 下拉刷新与 TTL 过期的关系是什么?

一句话结论

下拉刷新是用户主动强制回源,绕过 TTL 直接拉取远程;TTL 是自动过期判断,两者触发路径不同,刷新结果回写权威源后刷新缓存。

概念解释

进入页面按 TTL 决定是否需要后台刷新;下拉刷新明确表示用户要最新数据,无论缓存是否过期都请求远程。刷新成功更新库与内存,失败保留当前数据并提示。手动刷新也可顺带重置 TTL 水位线。

原理流程

进入页面:按 TTL 判断后台刷新
  下拉刷新:强制远程拉取 → 入库 → 替换缓存

代码或图示

suspend fun pullToRefresh() = runCatching {
    api.fetch().also { dao.upsertAll(it.toEntities()) }
}

常见误区

  • 下拉刷新仍受 TTL 拦截,用户拉了却没真正请求。
  • 刷新失败清空现有列表,体验比不刷新更差。

追问

  • 刷新中列表如何展示?答:保留旧数据 + 刷新指示器;不切全屏 Loading。
  • 自动刷新频率怎么控?答:按 TTL 与网络状态调度,避免每次进入页面都强制请求。

07.1.1.8.2-036 多用户切换时缓存如何隔离与清理?

一句话结论

缓存键纳入账号 ID,登出或切换账号时按账号维度清理内存缓存、数据库会话数据与文件缓存,避免上一用户数据残留给新用户。

概念解释

共享设备多账号场景下,缓存、草稿、未同步队列都必须按账号隔离。切换流程:停止当前收集 → 清理该账号缓存层 → 加载新账号数据。数据库可按账号分表/加账号列;文件缓存目录按账号隔离,清退时整目录删除。

原理流程

登出/切换 → 停止订阅 → 清理账号 A 内存 + 库 + 文件
  → 加载账号 B 数据,缓存键带 B 的 ID

代码或图示

fun switchAccount(accountId: String) {
    cache.invalidateAll()
    dao.clearForAccount(oldAccountId)
    fileDir(accountId).deleteRecursively()
}

常见误区

  • 只切登录态不清缓存,新用户看到上一用户的列表。
  • 未同步草稿随登出被清,用户本地修改丢失;需先同步或显式保留。

追问

  • 数据库能否整库重建?答:可在登出后删除库文件重建,简单彻底;账号数据量大时按账号列清理更高效。
  • 多账号同时在线怎么办?答:缓存键带账号,会话数据隔离;后台同步按当前活跃账号调度。

07.1.1.8.2-037 RemoteMediator 在分页架构中的角色是什么?

一句话结论

RemoteMediator 在本地分页源到达边界或需要刷新时触发远程拉取,把远程数据写入本地库,由 PagingSource 提供分页展示,实现本地为 SSOT 的分页缓存。

概念解释

纯远程分页每次加载请求网络;加 RemoteMediator 后,数据库是分页 SSOT,mediator 监听页码加载信号,缺页时访问远程 API 并入库。刷新、追加、前置加载都由 mediator 协调,网络失败不影响已加载的本地页。

原理流程

Paging 列表 → 本地 PagingSource 取页
  → 边界缺页 → RemoteMediator 拉远程 → 入库 → 列表更新

代码或图示

@ExperimentalPagingApi
class NoteRemoteMediator(
    private val api: NoteApi,
    private val dao: NoteDao,
    private val db: AppDatabase
) : RemoteMediator<Int, NoteEntity>() { /* load() 实现 */ }

常见误区

  • 把 mediator 当普通缓存策略,未理解本地库才是分页数据源。
  • 远程数据入库与本地删除顺序不当,出现重复或空洞页。

追问

  • mediator 与 PagingSource 谁先被调用?答:先读本地源;本地无页或到达边界时 mediator 触发远程。
  • 版本基线:Paging 3 与 Room 集成 API 以当前依赖版本为准(待确认)。

07.1.1.8.2-038 PagingSource 与 RemoteMediator 如何分工?

一句话结论

PagingSource 负责从本地(或远程)取一页数据并提供加载键;RemoteMediator 负责在本地不足时补远程数据,两者一个管“读页”,一个管“补源”。

概念解释

PagingSource 描述如何按键取页与上一页/下一页键,Room 可直接生成;RemoteMediator 处理网络拉取、写库、加载状态与错误。离线架构下 PagingSource 挂 Room,mediator 负责远端同步;纯远程场景可不用 mediator。

原理流程

PagingSource:查询本地页 + 提供 next/prev key
  RemoteMediator:远程补页 → 写库 → 状态回传

代码或图示

@Query("SELECT * FROM Note ORDER BY createdAt DESC")
fun pagingSource(): PagingSource<Int, NoteEntity>

常见误区

  • 把远程分页逻辑写进 PagingSource,又叠加 mediator,加载路径重复。
  • 混淆两者返回类型:Source 返回 LoadResult.Page,Mediator 返回 MediatorResult。

追问

  • 远程直连分页需要 mediator 吗?答:不需要,PagingSource 直接调 API 即可;有本地缓存才用 mediator。
  • 两个组件的状态如何合并?答:Paging 收集分页数据流,mediator 状态通过自定义状态流单独暴露给界面。

07.1.1.8.2-039 分页缓存的页码或游标如何持久化?

一句话结论

分页水位(最后一页游标、刷新时间)存入库表或配置存储;重启进程后从持久化水位继续,避免从头翻页或重复拉取。

概念解释

键分页记录最后一条的时间戳/ID;页码分页记录当前页号。水位线与账号、查询条件绑定。远程拉取成功后推进水位,失败不推进以便重试。纯展示页码可在内存,跨进程/重启需要持久化。

原理流程

远程拉取成功 → 记录 lastKey/lastPage
  重启 → 读水位 → 从断点继续追加

代码或图示

@Entity data class PageCursor(
    @PrimaryKey val queryKey: String,
    val lastKey: String?,
    val updatedAt: Long
)

常见误区

  • 水位只在内存,进程重建后重复拉取第一页。
  • 拉取失败也推进水位,漏掉中间页。

追问

  • 游标与筛选条件如何绑定?答:不同查询条件各存一条水位,键含条件哈希。
  • 水位过期如何重置?答:下拉刷新或 TTL 到期后清空水位,重新拉首页。

07.1.1.8.2-040 网络分页失败后本地分页如何表现?

一句话结论

已加载的本地页继续展示,追加失败上报错误状态而不崩溃;失败页保留重试入口,不破坏已渲染列表。

概念解释

分页边界请求失败时,mediator 返回 Error 结果,界面在列表底部展示错误与重试。本地库已有数据不受影响,用户可继续浏览已加载内容。重试成功后补入后续页;失败不回滚已入库数据。

原理流程

追加请求失败 → MediatorResult.Error
  → 列表保留已加载页 → 底部错误态 + 重试

代码或图示

is MediatorResult.Error -> { /* 暴露错误状态给列表底部 */ }

常见误区

  • 网络失败清空整个列表,用户回到空页面。
  • 错误未暴露,列表静默停住且无重试入口。

追问

  • 首页加载失败怎么办?答:展示错误页与重试;本地有缓存时先展示缓存再标注刷新失败。
  • 失败重试会重复入库吗?答:靠幂等键与主键冲突策略避免重复记录。

07.1.1.8.2-041 边界请求(append/prepend)如何触发?

一句话结论

列表滚动到接近尾部触发 append 加载下一页,头部插入场景触发 prepend 加载上一页;触发条件由 Paging 库根据已加载键与剩余项判断。

概念解释

Paging 监听滚动位置与已加载范围,到达边界时向 Source/Mediator 请求对应方向的页。append 是常见向下翻页;prepend 用于时间线顶部加载更早或更新的记录。方向由加载键与 LoadType 区分。

原理流程

滚动接近尾部 → LoadType.APPEND → 取下一页
  顶部加载 → LoadType.PREPEND → 取上一页

代码或图示

when (loadType) {
    LoadType.APPEND -> loadNextPage(key)
    LoadType.PREPEND -> loadPrevPage(key)
    LoadType.REFRESH -> loadFirstPage()
}

常见误区

  • 边界判断在界面层手写,与 Paging 内置触发重复请求。
  • prepend 与 append 键方向搞反,翻页顺序错乱。

追问

  • 距离底部多少项触发?答:由 Paging 预取配置决定;可通过预取距离参数调整。
  • 同一方向重复触发怎么防重?答:加载中状态锁,进行中的边界请求不重复发起。

07.1.1.8.2-042 数据库作为分页 SSOT 时刷新流程是什么?

一句话结论

刷新时先拉远程首页,成功后清空/替换本地对应数据集,再由本地 PagingSource 重新发射首页列表;失败保留旧本地数据并上报错误。

概念解释

SSOT 刷新不直接把远程结果塞 UI 列表,而是写库驱动流更新。替换策略按业务:全量覆盖对应查询集,或按主键 upsert 加墓碑删除。刷新期间界面展示刷新指示器,旧数据可先保留。

原理流程

REFRESH → 远程首页 → 写库(替换/upsert + 墓碑)
  → 本地源重新查询 → 列表刷新

代码或图示

suspend fun refresh() {
    val remote = api.firstPage()
    db.withTransaction {
        dao.clearActive()
        dao.upsertAll(remote.toEntities())
    }
}

常见误区

  • 远程结果直接更新内存列表,与库不一致。
  • 先清库后拉远程,远程失败导致本地数据被清空。

追问

  • 全量覆盖与 upsert 怎么选?答:列表成员可能被远程移除时用墓碑/清除;只追加更新用 upsert。
  • 刷新期间翻页键如何处理?答:重置到首页键,旧追加页失效重建。

07.1.1.8.2-043 RemoteMediator 的状态如何传递给界面?

一句话结论

mediator 把加载中、成功、失败状态写入仓库暴露的状态流,界面收集后渲染刷新指示器、底部加载与错误重试。

概念解释

MediatorResult.Success/Error 描述远程补页结果;加载中状态在 load() 开始与结束时更新。状态与分页数据流分离:列表数据来自 PagingData,加载/错误状态来自独立 StateFlow。界面按状态组合渲染。

原理流程

mediator load() → 更新 stateFlow(Loading/Success/Error)
  → 界面收集 → 指示器/底部错误/重试

代码或图示

private val _syncState = MutableStateFlow<SyncState>(SyncState.Idle)
val syncState: StateFlow<SyncState> = _syncState.asStateFlow()

常见误区

  • 状态只在 mediator 局部变量里,界面拿不到加载/错误信息。
  • 用分页数据本身判断加载状态,空列表与加载中混淆。

追问

  • 状态分方向区分吗?答:可按 REFRESH/APPEND/PREPEND 分别记录,避免顶部刷新与底部加载互相覆盖。
  • 状态如何防止泄漏到其他页面?答:状态流作用域跟随仓库/页面,离开后停止更新。

07.1.1.8.2-044 分页数据失效后如何重新拉取首页?

一句话结论

失效后使本地对应数据集与分页缓存失效,触发 REFRESH 加载类型,重新从远程首页拉取并写库;Paging 实例可通过 invalidate 让源重新生成。

概念解释

数据大改(登出、切换筛选、账号变更、长 TTL 过期)后,旧分页键与缓存不再可信。流程:清除/标记失效本地数据 → 使 PagingSource 失效 → 触发 REFRESH → mediator 拉首页。刷新成功前避免沿用旧键追加。

原理流程

失效本地数据集 → source.invalidate()
  → REFRESH 拉首页 → 入库 → 重建分页状态

代码或图示

@Query("SELECT * FROM Note WHERE userId = :uid ORDER BY createdAt DESC")
fun sourceByUser(uid: Long): PagingSource<Int, NoteEntity>

常见误区

  • 只清内存分页缓存,本地库旧记录仍被源读出。
  • 未 invalidate 旧 Source,列表沿用旧键与旧快照。

追问

  • 筛选条件变更如何分页重建?答:新条件对应新 Source/查询键,旧列表销毁重建。
  • 失效后远程不可用怎么办?答:展示残留本地数据并标注陈旧,恢复后再 REFRESH。

07.1.1.8.2-045 什么是离线优先(offline-first)?

一句话结论

离线优先指应用始终先以本地持久数据为可读可写基准,网络只负责同步与更新;断网可完整使用,联网后再把本地变更提交到远程。

概念解释

与“先联网拿数据、失败才读缓存”相反,离线优先把本地库作为一等公民:读直接读库,写先落本地再排队同步。网络是优化层而非前置条件。代价是需要处理冲突、同步队列与数据一致性,但换来了弱网可用性与稳定体验。

原理流程

读:本地库直接返回
  写:本地落库 + 入队 → 联网后同步远程

代码或图示

suspend fun save(note: Note) {
    dao.upsert(note.toEntity().copy(syncState = SyncState.PENDING))
    syncQueue.enqueue(note.id)
}

常见误区

  • 离线优先只是“加个缓存”,写路径仍先请求远程,断网不能提交。
  • 本地变更无状态标记,无法区分已同步与待同步记录。

追问

  • 哪些业务适合离线优先?答:笔记、待办、草稿、社交 feed 等容忍短暂本地副本的场景;实时强一致交易类需谨慎。
  • 离线优先与 SSOT 关系?答:本地库是离线优先的 SSOT,远程是同步目标。

07.1.1.8.2-046 离线优先的写入流程:先写本地还是先请求远程?

一句话结论

先写本地权威副本并标记待同步,再异步提交远程;本地写成功即给用户反馈,远程结果回写同步状态与服务端标识。

概念解释

先远程会让断网/弱网下写入失败;先本地保证操作可完成。流程:构造本地实体(本地临时 ID)→ 入库 PENDING → 入同步队列 → 任务联网提交 → 成功后更新远端 ID 与状态,失败按策略重试。本地先展示新记录。

原理流程

本地入库(PENDING) → 入队 → 同步任务提交远程
  → 成功:绑定 remoteId / 标记 SYNCED
  → 失败:保留 PENDING,稍后重试

代码或图示

@Entity data class LocalNote(
    @PrimaryKey val localId: String,
    val remoteId: Long?,
    val content: String,
    val syncState: String
)

常见误区

  • 先调远程,成功才写本地,离线时操作直接失败。
  • 本地记录未生成稳定临时 ID,后续重试与关联找不到记录。

追问

  • 本地写失败怎么办?答:本地库异常属于硬错误,直接提示用户,不进入同步队列。
  • 远端生成的 ID 如何回填?答:同步成功后按临时 ID 更新本地记录的 remoteId 与状态。

07.1.1.8.2-047 本地变更队列(outbox)如何设计?

一句话结论

outbox 表记录待同步的变更操作(增/改/删),同步任务按序取出执行,成功后移除或标记完成;它把用户操作与网络提交解耦。

概念解释

每条本地变更生成一条队列记录:操作类型、目标实体、载荷、重试次数、时间戳。队列持久化,进程重建不丢。同步器按顺序消费,保证操作先后;幂等设计避免重复提交。队列与实体状态配合,形成可追溯的待办链。

原理流程

写本地 → 入 outbox(OP_ADD/UPDATE/DELETE)
  → 同步器取出 → 提交远程 → 成功出队 / 失败重试计数

代码或图示

@Entity data class SyncOp(
    @PrimaryKey(autoGenerate = true) val id: Long,
    val entityType: String,
    val entityId: String,
    val action: String,
    val payload: String,
    val retries: Int,
    val createdAt: Long
)

常见误区

  • 队列只存内存,进程杀后未同步操作丢失。
  • 同实体多条变更未合并,逐条重复提交产生冗余请求。

追问

  • 队列顺序如何保证?答:按 createdAt/id 排序消费;同实体操作先合并再提交。
  • 失败操作无限重试吗?答:设重试上限与退避,超限转人工/待修复状态。

07.1.1.8.2-048 离线期间产生的多条变更如何排队与合并?

一句话结论

同一实体的连续变更在入队与同步前合并为最新状态,避免逐条重放;不同实体按操作序排队,保留必要的删除/更新语义。

概念解释

离线编辑多次同一笔记,远程只需要最终内容;队列合并把多次 UPDATE 折叠为一条。删除与新增的顺序不能随意合并:先删后建、先建后删语义不同,需保留操作历史或按规则裁决。合并在本地状态层完成,同步载荷取最终值。

原理流程

连续本地变更 → 同实体合并(取最终值/保留删除语义)
  → 入队 → 按序同步

代码或图示

// 合并:同一 entityId 的待更新操作折叠为一条
fun mergeOps(ops: List<SyncOp>): List<SyncOp>

常见误区

  • 不合并导致离线一分钟产生几十条重复请求。
  • 合并时丢掉删除操作,已删记录又被远程恢复。

追问

  • 合并后历史修改要保留吗?答:多数同步场景只传最终态;需要版本历史的业务另记变更日志。
  • 冲突期间如何合并?答:先按本地状态提交,远端冲突走版本/合并规则处理。

07.1.1.8.2-049 网络恢复后如何触发同步?

一句话结论

监听网络状态变化或由后台任务周期扫描待同步队列,网络可用时启动同步;触发源包括网络回调、WorkManager 约束任务、进入前台与手动刷新。

概念解释

不能依赖用户每次手动下拉:注册网络可用性回调,恢复时检查 outbox 并调度同步;WorkManager 带网络约束的任务兜底,进程重建后仍能执行。触发后先合并队列、再按序提交,避免重复并发同步。

原理流程

网络恢复 / 周期任务 / 回前台 → 检查 PENDING 队列
  → 加同步锁 → 批量提交 → 推进状态

代码或图示

// 网络恢复回调中调度
lifecycleScope.launch { syncDispatcher.syncPending() }

常见误区

  • 只在 App 前台监听网络,后台恢复后不同步。
  • 多个触发源并发执行同步,同一操作重复提交。

追问

  • 网络状态监听覆盖后台吗?答:前台用回调;后台可靠同步交给 WorkManager 约束任务。
  • 同步锁怎么实现?答:单实例标志位或数据库标记,进行中跳过新触发。

07.1.1.8.2-050 离线优先下界面如何展示“待同步”状态?

一句话结论

记录上携带同步状态(待同步/同步中/已同步/失败),界面用标记、图标或文案区分;用户能感知本地修改尚未上传,但不阻断使用。

概念解释

状态枚举随实体暴露给 UI:PENDING 显示待同步,SYNCING 显示上传中,FAILED 显示失败可重试,SYNCED 无标记。状态来自本地库而非内存,重建后仍可正确展示。失败记录可提供手动重试入口。

原理流程

实体 syncState → UI 映射标记
  PENDING/SYNCING/SYNCED/FAILED 各有展示

代码或图示

enum class SyncState { PENDING, SYNCING, SYNCED, FAILED }

fun SyncState.label(): String = when (this) {
    SyncState.PENDING -> "待同步"
    SyncState.SYNCING -> "上传中"
    SyncState.SYNCED -> ""
    SyncState.FAILED -> "同步失败"
}

常见误区

  • 不区分状态,用户以为已上传实际仍在本地。
  • 失败记录静默 PENDING,用户看不到也无法重试。

追问

  • 同步中状态会闪烁吗?答:短任务可只显示待同步;长任务再展示上传中,避免状态频繁切换。
  • 状态放实体还是 UI 模型?答:持久化字段在实体,展示文案映射到 UI 层。

07.1.1.8.2-051 读路径如何保证离线也能打开?

一句话结论

读路径完全以本地持久层为基准,首帧先读库渲染;远程只在后台刷新并回写库,断网时本地数据完整可读。

概念解释

界面启动收集本地 Flow,不等待远程响应。本地为空时展示空态/骨架,后台尝试拉取;历史数据进程重建后仍在库中。读路径不直接依赖 API 可用性,网络错误只影响刷新,不阻塞打开。

原理流程

进入页面 → 读本地库 → 渲染
  → 后台远程刷新 → 写库 → Flow 更新

代码或图示

fun observe(id: Long) = dao.observeById(id) // 不先调 API

常见误区

  • 读路径先挂远程请求,断网白屏后才读缓存。
  • 本地无缓存时把“加载中”当空数据展示。

追问

  • 离线读到陈旧数据怎么办?答:标注缓存时效;关键页面提供手动刷新。
  • 本地库损坏读不出?答:走损坏检测与恢复流程,不能把异常当空列表。

07.1.1.8.2-052 离线优先与纯缓存(先网络后落库)的区别是什么?

一句话结论

纯缓存以远程为权威、本地只是提速副本;离线优先以本地为权威、远程为同步目标,两者读写入径与一致性方向相反。

概念解释

纯缓存:无网络即无数据,写以远程为准;离线优先:本地可读可写,断网不阻塞,联网后同步。纯缓存实现简单,适合内容型只读场景;离线优先需要 outbox、冲突与重试机制,适合可写业务。

原理流程

纯缓存:远程 → 落库提速,本地可丢弃
  离线优先:本地权威 → 队列同步远程,冲突需裁决

代码或图示

纯缓存写:API 成功 → 写库
  离线优先写:写库 PENDING → 队列 → API → 回填状态

常见误区

  • 自称离线优先,实际写路径仍是远程优先。
  • 纯缓存场景照搬 outbox,增加不必要复杂度。

追问

  • 怎么判断项目该选哪种?答:看离线可写需求、弱网比例与冲突容忍度;只读 feed 用缓存即可。
  • 两者能混合吗?答:可按业务域区分:可写模块离线优先,只读模块纯缓存。

07.1.1.8.2-053 本地草稿与已同步数据如何区分?

一句话结论

用同步状态与本地/远端标识区分草稿:未提交的本地记录带临时 ID 与 PENDING 状态,已同步记录有 remoteId 与 SYNCED 状态;草稿可单独列表管理。

概念解释

草稿是用户尚未提交或未同步完成的本地内容,不应混入已发布集合。实体上同时保留 localId、remoteId、syncState;查询已发布数据过滤 SYNCED,草稿页查 PENDING/FAILED。清空缓存时草稿按策略保留或提示。

原理流程

localId 临时 + remoteId null + PENDING → 草稿
  remoteId 存在 + SYNCED → 已同步记录

代码或图示

@Query("SELECT * FROM Note WHERE syncState = 'PENDING' OR syncState = 'FAILED'")
fun drafts(): Flow<List<LocalNote>>

常见误区

  • 草稿与正式记录混在同一列表,未提交内容被当成已发布。
  • 登出/清缓存误删未同步草稿,用户丢失内容。

追问

  • 草稿自动保存怎么触发?答:输入节流后写本地库,不依赖联网。
  • 提交后草稿转正式记录?答:同步成功回填 remoteId 并改状态,记录从草稿列表消失。

07.1.1.8.2-054 离线场景下冲突预检怎么做?

一句话结论

本地提交前带上版本号/时间戳与远端预期值,服务端校验是否已变更;预检不通过走冲突合并流程,避免盲目覆盖远端更新。

概念解释

离线期间远端可能被其他设备修改。本地记录保存基线版本,同步时随请求发送;服务端比对当前版本,不一致返回冲突。预检在同步阶段而非输入阶段完成,界面可先本地编辑,提交时再裁决。

原理流程

本地保存基线版本 → 同步请求带版本
  → 服务端比对:一致则提交,不一致返回冲突

代码或图示

data class UpdateRequest(
    val remoteId: Long,
    val baseVersion: Int,
    val content: String
)

常见误区

  • 不带版本直接覆盖,把其他设备的修改冲掉。
  • 冲突预检放输入时联网阻断,失去离线编辑意义。

追问

  • 预检失败本地要回滚吗?答:不回滚本地草稿,保留待合并状态,等用户或规则处理冲突。
  • 多字段冲突如何预检?答:按记录版本粗粒度检测;字段级冲突在合并阶段细分。

07.1.1.8.2-055 全量同步与增量同步怎么选?

一句话结论

数据量小、结构简单或版本差异大时全量拉取;数据量大、变更稀疏时增量同步,按游标/时间戳只拉变化部分。

概念解释

全量简单可靠但流量与耗时高,适合首装、大版本升级、缓存失效重建;增量节省资源,但需要水位线、墓碑与漏拉补偿。多数端侧采用“首装全量 + 日常增量”的组合,冲突与删除同步在增量中单独处理。

原理流程

首次/重建:全量拉取写入
  日常:按 lastToken 增量拉变更(新增/更新/删除)

代码或图示

// 增量接口:带游标
@GET("notes/changed")
suspend fun changed(@Query("cursor") cursor: String?): ChangePage

常见误区

  • 大表长期走全量,每次同步流量与数据库写入放大明显。
  • 增量未处理删除与漏拉,端侧残留脏记录。

追问

  • 什么时候强制全量?答:schema 升级、水位丢失、增量接口不可用、长时间未同步后重建。
  • 全量后本地未同步变更怎么办?答:先上传本地待同步变更,再全量覆盖,避免新改被冲掉。

07.1.1.8.2-056 lastSyncToken/游标如何生成与持久化?

一句话结论

游标由服务端返回(时间戳、版本号、不透明字符串),端侧按账号与业务集持久化;成功拉取后推进游标,失败不推进,下次从断点续拉。

概念解释

游标可以是 epoch 时间戳、递增版本号或服务端不透明编码。端侧不自行解析语义,只原样保存回传。持久化到库表/配置,与查询条件、账号绑定。游标推进以服务端确认成功为准,避免漏数据。

原理流程

首次 cursor=null → 拉首页 → 响应 nextCursor 持久化
  下次请求带游标 → 成功后更新为新游标

代码或图示

@Entity data class SyncCursor(
    @PrimaryKey val scope: String,
    val token: String?,
    val syncedAt: Long
)

常见误区

  • 游标存在内存,重启后从头重复拉取。
  • 拉取失败也保存新游标,跳过中间变更。

追问

  • 时间戳时钟不准怎么办?答:优先服务端版本号/不透明游标;时间戳方案需服务端时钟基准。
  • 多集合游标怎么管?答:按业务 scope 分别存储,互不覆盖。

07.1.1.8.2-057 增量同步按时间戳还是版本号?

一句话结论

版本号(单调递增/向量版本)比客户端时间戳可靠;时间戳实现简单但受时钟与乱序影响,版本号由服务端统一生成,冲突判断更准确。

概念解释

时间戳依赖记录修改时间,时钟回拨、多设备时钟不一致会导致漏判;版本号每次服务端写入递增,比较直观。复杂协作场景可用版本向量追踪多端修改。端侧保存基线版本,同步时比对。

原理流程

服务端写入 → 版本号 +1
  端侧比对版本号判断新旧与冲突

代码或图示

data class Note(
    val remoteId: Long,
    val version: Int,
    val content: String
)

常见误区

  • 用设备本地时间做修改时间,离线多端比较不可靠。
  • 时间戳精度不足,同一秒多次修改顺序判断错误。

追问

  • 时间戳方案如何缓解?答:服务端记录修改时间,端侧不使用本地时钟;配合版本号兜底。
  • 版本号丢失怎么补偿?答:走全量对账重建本地基线。

07.1.1.8.2-058 服务端删除(软删除/墓碑)如何同步到端侧?

一句话结论

增量流携带墓碑记录(删除标记与对象 ID),端侧收到后把对应本地记录标记删除或移除;不能只同步新增/更新而漏掉删除。

概念解释

服务端软删除记录以“墓碑”形式出现在变更流中:对象存在但标记已删。端侧同步墓碑后,从可见列表移除;硬删除则直接按 ID 删本地记录。墓碑需要保留一段时间供增量遍历,过期后清理。

原理流程

变更流 → 墓碑事件(ID, deletedAt)
  → 本地标记删除/移除记录 → 可见列表过滤

代码或图示

data class ChangeEvent(
    val id: Long,
    val deleted: Boolean,
    val version: Int
)

// 端侧:deleted=true → 标记 removed,不展示

常见误区

  • 增量只拉新增更新,已删记录长期残留在端侧。
  • 本地有待同步修改的记录收到墓碑,未提示冲突就被删。

追问

  • 本地有未提交修改时收到墓碑怎么办?答:属于冲突,保留本地待合并记录并提示,不直接抹掉。
  • 墓碑保存多久?答:覆盖增量游标窗口即可,过期由服务端清理。

07.1.1.8.2-059 同步任务如何记录水位线与断点?

一句话结论

按业务集记录最后成功同步的游标/时间与批次状态,断点持久化;任务中断后从水位续跑,已完成批次不重复处理。

概念解释

水位线包括拉取游标、处理批次号、各实体同步进度。任务开始读取水位,处理成功一批推进一格;崩溃重启后从最近水位继续。进行中状态与已完成状态分开,避免把未完成批次当成功。

原理流程

读水位 → 拉批次 → 处理入库 → 推进水位
  中断重启 → 从水位续跑 → 幂等去重

代码或图示

@Entity data class SyncCheckpoint(
    @PrimaryKey val scope: String,
    val cursor: String?,
    val lastBatch: Long,
    val updatedAt: Long
)

常见误区

  • 水位在批次全部失败后也推进,漏掉变更。
  • 只记整体水位,未细分实体,恢复后无法定位断点。

追问

  • 水位与 outbox 状态如何配合?答:拉取水位管远端变更下载;outbox 管本地上传,两条线分别记录。
  • 回退水位可以吗?答:用于补偿重拉;配合幂等避免重复写入。

07.1.1.8.2-060 增量同步漏拉数据怎么补偿?

一句话结论

通过定期全量对账、游标校验与版本比对发现缺失记录,重拉缺失区间;幂等写入保证补偿不产生重复。

概念解释

漏拉来源:游标异常、离线超时、接口分页丢失。补偿机制:周期性全量/差异对账,比对远程列表与本地记录;版本号落后的记录重新拉取;缺失 ID 补拉。补偿任务独立于日常增量,低频执行。

原理流程

周期对账 → 比对 ID/版本集合 → 发现缺失/落后 → 补拉区间
  → 幂等 upsert 入库

代码或图示

suspend fun reconcile() {
    val remoteIds = api.allIds()
    val localIds = dao.allIds()
    val missing = remoteIds - localIds
    missing.forEach { dao.upsert(api.detail(it).toEntity()) }
}

常见误区

  • 只靠增量不做对账,漏拉数据永久残留。
  • 补偿重拉未幂等,重复记录或覆盖本地修改。

追问

  • 对账成本高怎么降频?答:低频(每天/每周)后台任务,按账号分批执行。
  • 本地待同步记录参与对账吗?答:跳过 PENDING 记录,避免被远程旧版本覆盖。

07.1.1.8.2-061 同步频率与省电如何平衡?

一句话结论

按业务实时性分级:前台按需刷新、后台周期任务带网络/充电约束、事件驱动触发;避免高频轮询耗电与耗流量。

概念解释

同步频率越高频越新鲜,但唤醒与网络开销越大。策略:前台用户操作触发,后台用 WorkManager 周期任务(间隔受系统限制),推送/网络恢复作为事件触发。批量合并请求,限制并发与同步时长。

原理流程

前台:操作/进入页面触发
  后台:约束任务周期扫描 + 事件驱动
  批量合并请求,空闲/充电时执行重任务

代码或图示

Constraints(
    requiredNetworkType = NetworkType.CONNECTED,
    requiresBatteryNotLow = true
)

常见误区

  • 短间隔轮询,后台频繁唤醒设备。
  • 后台同步不约束网络,弱网反复重试耗电。

追问

  • 周期任务最小间隔?答:受系统调度限制,具体最小值按 WorkManager 版本与设备确认(待确认)。
  • 实时性高的场景怎么办?答:用推送通知驱动增量拉取,而非缩短轮询间隔。

07.1.1.8.2-062 分页拉取在同步任务中如何避免重复?

一句话结论

按游标分页拉取并记录断点,每页幂等入库;重复拉取同一页靠主键/唯一约束去重,已处理页不重复提交。

概念解释

同步分页可能因重试重复获取同一页:本地 upsert 以主键/远端 ID 冲突覆盖,不新增重复行;删除类操作幂等执行。批次处理记录已完成游标,恢复后跳过已处理区间。

原理流程

分页游标 → 拉页 → 幂等 upsert/删除 → 推进游标
  重试重复页 → 唯一键去重,结果幂等

代码或图示

@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun upsertAll(records: List<LocalNote>)

常见误区

  • 用自增本地 ID 做远程记录去重,重复提交产生多行。
  • 分页重试从第一页重拉,批量重复写入放大。

追问

  • 幂等键用什么?答:远端唯一 ID;本地新建记录在同步成功后回填。
  • 重复页里有更新怎么办?答:按版本号判断是否覆盖,旧版本不冲掉新版本。

07.1.1.8.2-063 多设备变更如何在增量流中体现?

一句话结论

增量流包含所有端产生的变更(含其他设备),按服务端版本排序;端侧拉取后应用这些变更,版本落后的本地记录按冲突规则处理。

概念解释

服务端是多端变更的汇聚点:任何设备的增改删都进入变更历史。端侧增量拉取全局变更流,而不仅是本机操作。其他设备删除、修改的记录通过墓碑/版本更新到达;本地未同步修改与之冲突时进入合并流程。

原理流程

设备 A/B 写入 → 服务端变更历史
  端侧增量遍历历史 → 应用他端变更 → 检测本地冲突

代码或图示

// 变更事件含来源设备与版本
data class ChangeEvent(val id: Long, val origin: String, val version: Int)

常见误区

  • 只同步本机产生的操作,漏掉他端变更。
  • 他端修改直接覆盖本地未提交编辑,未做冲突检测。

追问

  • 离线期间他端变更如何感知?答:联网后增量拉取变更历史并应用。
  • 多端同时编辑同一记录?答:按版本/合并规则裁决,必要时用户介入。

07.1.1.8.2-064 同步失败的记录如何分类重试?

一句话结论

按失败原因分类:网络/超时类可退避重试,校验/权限类不盲目重试,冲突类进入合并流程;记录重试次数与原因,超限转待修复。

概念解释

失败类型决定策略:瞬时网络错误自动重试;请求体错误、资源不存在、权限不足属于永久失败,需人工或业务修复;版本冲突走合并。队列记录错误码、重试计数、下次可重试时间,分类调度避免无效重试。

原理流程

失败 → 分类:瞬时(退避重试) / 永久(停重试) / 冲突(合并)
  → 更新重试计数与状态

代码或图示

sealed class SyncFailure {
    data class Transient(val cause: Throwable) : SyncFailure()
    data class Permanent(val code: String) : SyncFailure()
    data class Conflict(val remote: Note) : SyncFailure()
}

常见误区

  • 所有失败都无限重试,永久错误反复打远程。
  • 失败原因不记录,线上无法定位是网络还是业务拒绝。

追问

  • 重试上限后状态是什么?答:FAILED/待修复,界面可见可手动重试。
  • 权限失效如何处理?答:停止同步,引导重新登录或授权。

07.1.1.8.2-065 幂等键如何设计保证重复同步不产生脏数据?

一句话结论

每条本地变更生成稳定幂等键(实体 ID + 操作类型 + 基线版本),远程按键去重;重复提交同一操作只生效一次。

概念解释

网络重试、任务重跑会重复发送请求,服务端凭幂等键识别重复。键应稳定可复现:本地临时 ID 在回填 remoteId 后可映射;同实体合并后的最终操作对应同一键。新增、更新、删除分别按主键与操作语义去重。

原理流程

本地操作生成 idempotencyKey
  → 远程按键去重:首次生效,重复请求返回原结果

代码或图示

data class SyncRequest(
    val idempotencyKey: String, // localId + action + baseVersion
    val action: String,
    val payload: String
)

常见误区

  • 每次重试重新生成随机键,服务端无法识别重复。
  • 幂等键只含实体 ID,更新与删除操作互相混淆。

追问

  • 本地 ID 回填后键怎么延续?答:同步成功建立 localId↔remoteId 映射,后续操作按映射生成键。
  • 幂等键服务端保留多久?答:覆盖重试窗口即可,过期后新操作按新版本处理。

07.1.1.8.2-066 重试退避策略在端侧同步中怎么落地?

一句话结论

瞬时失败用指数退避加随机抖动控制重试节奏,结合网络约束与重试上限;失败操作记录下次可重试时间,避免密集重试耗电。

概念解释

退避间隔随失败次数指数增长(如 1s、2s、4s),加抖动避免多设备同时重试同步。WorkManager 可配置退避策略;自管队列则按 nextRetryAt 调度。超过上限转永久失败状态。

原理流程

失败 N 次 → 间隔 = base * 2^N + 抖动
  → 到点重试;超限停止

代码或图示

fun backoffMs(retries: Int): Long =
    (1000L shl minOf(retries, 6)) + Random.nextLong(0, 500)

常见误区

  • 固定间隔立即重试,弱网下持续打请求。
  • 退避不加抖动,批量设备在同一时刻集中重试。

追问

  • WorkManager 退避怎么配?答:BackoffPolicy.EXPONENTIAL 与初始间隔;具体参数按版本确认(待确认)。
  • 用户手动重试是否受退避限制?答:手动触发可立即尝试,但仍受永久失败分类约束。

07.1.1.8.2-067 端云冲突产生的根本原因是什么?

一句话结论

同一记录在多端/离线窗口内被独立修改,本地基线与服务端当前版本不一致,导致两份变更无法按简单覆盖合并。

概念解释

冲突本质是并发修改缺乏及时同步:离线编辑期间他端或服务端数据已变,端侧提交的基线版本过期。读写分离、网络分区、多设备在线都会放大冲突。解决前提是检测到版本/基线不一致,再选择合并策略。

原理流程

基线版本 V1 → 离线本地改
  期间服务端被他端改为 V2
  → 本地提交基于 V1,与 V2 冲突

代码或图示

本地: V1 + 修改 A
远端: V1 → V2 + 修改 B
  合并点: A 与 B 是否可兼容

常见误区

  • 把网络错误当成冲突,或把冲突当成普通失败重试。
  • 不记录基线版本,提交时无法判断是否过期。

追问

  • 单设备离线也会冲突吗?答:会,若服务端被其他入口(Web/管理端)修改。
  • 冲突频率高说明什么?答:同步窗口过长或协作模型需要缩短离线周期。

07.1.1.8.2-068 Last-Write-Wins(LWW)如何实现?时钟问题怎么处理?

一句话结论

LWW 以修改时间戳较新者为准;可信实现依赖服务端统一时钟与版本号,客户端本地时钟不可信,不能直接用设备时间裁决。

概念解释

LWW 比较两条变更的时间,新值覆盖旧值。端侧时钟可能回拨、不同步,本地时间排序不可靠;服务端记录权威修改时间/版本,冲突时以服务端序列为准。LWW 实现简单,但会静默丢弃较早一方的修改。

原理流程

两条变更 → 比较权威时间/版本 → 较新者覆盖
  本地时钟仅作展示,不参与裁决

代码或图示

fun <T : Versioned> lww(a: T, b: T): T =
    if (a.version >= b.version) a else b

常见误区

  • 用设备本地时间做 LWW 比较,时钟偏差导致旧值覆盖新值。
  • LWW 丢弃修改无记录,用户不知情。

追问

  • LWW 适合哪些字段?答:偏好设置、状态覆盖等单值语义字段;协作编辑类字段易丢改。
  • 时间戳相同怎么办?答: tie-break 用版本号或来源优先级,规则显式定义。

07.1.1.8.2-069 版本号/乐观锁如何检测冲突?

一句话结论

本地保存基线版本,提交时带上基线版本,服务端比对当前版本:一致则提交并递增版本,不一致返回冲突,由端侧走合并。

概念解释

乐观锁不提前加锁,提交时检测版本是否过期。服务端记录当前版本号;请求带 baseVersion,匹配才写入。冲突检测明确、可回传远端当前值,便于字段合并。相比 LWW,乐观锁暴露冲突而非静默覆盖。

原理流程

本地基于 V1 编辑 → 提交 baseVersion=1
  服务端当前 V2 → 拒绝并返回 V2 数据
  → 端侧合并 A 与 B

代码或图示

data class CommitRequest(val baseVersion: Int, val content: String)

// 服务端伪逻辑:if (currentVersion != baseVersion) throw Conflict()

常见误区

  • 提交不带基线版本,服务端无法检测过期。
  • 冲突后直接用本地值强推,绕过乐观锁覆盖远端。

追问

  • 版本号在哪里维护?答:服务端递增,端侧只读比对;本地版本用于下次提交基线。
  • 乐观锁失败频率高怎么办?答:缩短同步窗口、改字段级合并或引导实时协作。

07.1.1.8.2-070 字段级合并与整记录合并怎么选?

一句话结论

字段互不干扰时按字段合并各取所长;语义强相关或结构复杂的记录整体以一方为准;选择取决于字段独立性与业务可理解性。

概念解释

字段级合并:不同字段被不同端修改时各保留新值,适合松散结构(标题与描述分别编辑)。整记录合并:整条记录以本地或远端为准,避免拼装出矛盾内容。字段冲突无法自动裁决时,转用户介入或按策略覆盖。

原理流程

变更按字段 diff → 可兼容字段各自保留
  → 同字段冲突 → 整记录策略 / 用户选择

代码或图示

data class MergedNote(
    val title: String,   // 取较新
    val content: String  // 取较新
)

常见误区

  • 强相关字段被分别覆盖,拼出语义矛盾的记录。
  • 字段合并规则不透明,用户无法追踪哪方修改被保留。

追问

  • 自动合并结果要提示用户吗?答:冲突字段建议展示合并结果与来源;关键记录需用户确认。
  • 合并记录如何记版本?答:合并后由服务端生成新版本,本地回填基线。

07.1.1.8.2-071 冲突解决后本地与远程如何收敛?

一句话结论

冲突裁决后以确定结果写入权威源,同步双方基线版本,本地清除冲突标记;收敛后本地与远程指向同一版本,不再重复触发冲突。

概念解释

合并/选择结果提交到服务端,成功后更新本地记录的 remoteId、版本号与状态为 SYNCED。未被选中的修改按规则丢弃或归档。收敛过程要保证结果回写库,而不是只改内存;后续同步基于新基线进行,避免旧冲突反复出现。

原理流程

裁决结果 → 提交服务端 → 回填版本/remoteId
  → 本地状态 SYNCED → 冲突标记清除 → 双方一致

代码或图示

suspend fun resolve(conflict: LocalNote, chosen: Note) {
    dao.upsert(chosen.toEntity().copy(syncState = SyncState.SYNCED.name))
}

常见误区

  • 界面选了保留远端,本地仍残留待同步修改,下次提交又冲突。
  • 收敛只更新内存状态,库中记录版本未回填。

追问

  • 收敛失败怎么办?答:结果保留为待提交,状态回到 PENDING/冲突,稍后重试。
  • 被丢弃的修改要备份吗?答:关键业务可归档变更历史,便于找回。

07.1.1.8.2-072 哪些业务适合端侧优先,哪些适合服务端优先?

一句话结论

容忍短暂本地副本、离线可编辑的业务适合端侧优先;强一致、实时共享、金额与权限类业务以服务端为准,端侧只做展示与受控提交。

概念解释

端侧优先:笔记、待办、草稿、个人偏好、离线列表;写本地排队同步,允许合并与冲突。服务端优先:交易、库存、协作编辑、授权状态,以服务端响应为准,本地不做权威副本。混合场景按字段划分:展示缓存本地可先读,关键写入等服务端确认。

原理流程

端侧优先:本地权威 → 队列同步 → 冲突合并
  服务端优先:请求服务端 → 结果落库展示

代码或图示

笔记/草稿:离线优先
  订单/余额:服务端优先,本地只读缓存

常见误区

  • 把交易类记录当离线草稿,本地修改脱离服务端约束。
  • 协作场景假设本地副本可长期保留,覆盖他端实时变更。

追问

  • 混合业务怎么分层?答:拆字段:可离线字段走本地优先,强一致字段提交时等服务端结果。
  • 端侧优先一定弱一致吗?答:通过版本检测与合并收敛到最终一致,不是无限期分歧。

07.1.1.8.2-073 合并冲突如何提示用户介入?

一句话结论

自动规则无法裁决时,把本地版本与远端版本并排列出,让用户选择保留哪份或手动合并;未解决前记录保持冲突状态。

概念解释

冲突提示要展示双方内容、来源与时间,而不是只报“同步失败”。用户选择后结果进入收敛流程;支持字段级选择时逐项确认。介入入口可在列表角标、详情冲突横幅或通知中,避免阻塞首次使用。

原理流程

检测冲突 → 展示本地/远端 diff → 用户选择/合并
  → 提交裁决 → 收敛状态

代码或图示

data class ConflictView(
    val local: Note,
    val remote: Note,
    val resolved: ResolvedChoice?
)

常见误区

  • 冲突静默自动覆盖,用户不知道自己的修改被替换。
  • 提示只写“网络错误”,用户无法理解需要处理冲突。

追问

  • 多久未处理冲突会怎样?答:保留待处理状态,可按策略提醒;不自动丢弃任一方。
  • 多字段冲突如何展示?答:按字段对照展示,标注哪端较新,逐项或整体选择。

07.1.1.8.2-074 冲突记录如何留痕与审计?

一句话结论

冲突事件、双方版本、裁决结果与操作人记录到变更日志,便于追溯“哪次修改被保留/丢弃”;日志与业务记录分开存储。

概念解释

审计留痕包括:冲突发生时间、基线版本、本地与远端快照摘要、裁决方式(自动/用户选择)、最终结果。日志不影响主流程读写,可本地暂存后随同步上报。关键业务需要回溯修改来源与责任时,审计记录是依据。

原理流程

冲突产生 → 记录快照/版本 → 裁决后记录结果
  → 日志本地暂存 → 随同步上报服务端

代码或图示

@Entity data class ConflictLog(
    @PrimaryKey(autoGenerate = true) val id: Long,
    val entityId: String,
    val localVersion: Int,
    val remoteVersion: Int,
    val resolution: String,
    val createdAt: Long
)

常见误区

  • 只保留当前记录,丢弃修改后无历史可查。
  • 审计日志与业务表混写,拖慢主流程。

追问

  • 日志保留多久?答:按合规与容量要求定期清理或上报后移除本地。
  • 自动合并要留痕吗?答:要,记录合并规则与被覆盖方摘要。

07.1.1.8.2-075 并发编辑同一记录的典型场景与处理?

一句话结论

典型场景包括多设备同时编辑、离线长窗口修改、Web 与 App 并发提交;处理链路是版本检测、字段 diff、自动合并或用户裁决,最终收敛到同一版本。

概念解释

并发编辑不一定冲突:修改不同字段可自动合并;同字段并发修改才需裁决。流程上先比对基线与当前版本,计算变更范围,可兼容则合并,不可兼容挂起待处理。高频冲突说明同步周期过长或协作模型需要实时锁/评论式编辑。

原理流程

并发提交 → 版本比对 → 字段 diff
  → 不相交:自动合并;相交:裁决/介入

代码或图示

本地改 title;远端改 content → 字段不相交 → 自动合并
  双方改 content → 同字段冲突 → 待裁决

常见误区

  • 把所有并发都当冲突弹提示,打断可自动合并的场景。
  • 同字段冲突也静默覆盖,丢失一方修改。

追问

  • 实时协作怎么做?答:用 OT/CRDT 或服务端实时推送,比端侧离线合并更适合多人同时编辑。
  • 冲突率高如何优化?答:缩短同步间隔、提示用户其他端在编辑、关键内容加锁定机制。

07.1.1.8.2-076 时间戳不可信时用什么替代方案?

一句话结论

优先用服务端单调版本号、版本向量或不透明变更游标;本地只存基线版本,裁决由服务端序列完成,不依赖设备时钟。

概念解释

设备时钟可被用户调整、存在回拨与偏移,本地时间不能作为权威顺序。替代方案:服务端递增版本号检测过期;版本向量追踪多端并发;不透明游标代表变更历史位置。端侧记录基线版本用于下次提交比对。

原理流程

服务端变更序列 → 版本号/向量/游标
  端侧存基线 → 提交时比对,不用本地时钟排序

代码或图示

data class Versioned(val version: Int, val baseVersion: Int)

常见误区

  • 用 System.currentTimeMillis() 生成修改时间参与冲突裁决。
  • 设备时区/时钟变更后,列表按本地时间排序错乱。

追问

  • 展示时间用什么?答:展示用服务端下发时间,本地仅做相对时间渲染。
  • 版本向量适合什么场景?答:多端并发历史复杂、需要判断因果顺序的协作数据;简单记录用单调版本号即可。

07.1.1.8.2-077 多进程下本地缓存如何避免不一致?

一句话结论

单写者收敛写入:数据库访问集中到主进程,子进程通过 IPC 通知变更;缓存按进程隔离,跨进程变更靠事件重新加载,不假设内存缓存实时共享。

概念解释

每个进程有独立内存空间,内存缓存不跨进程可见;数据库文件虽共享,但观察流不跨进程通知。多进程直写容易出现锁竞争与状态分叉。常规做法:数据读写在主进程,子进程只做轻量任务,需要数据时经 Binder/广播请求结果。

原理流程

子进程变更 → IPC 通知主进程
  → 主进程写库 → 本地观察流刷新
  子进程内存缓存失效后按需回载

代码或图示

进程 A:写库 + 持有缓存
  进程 B:不直开库,IPC 请求/接收变更事件

常见误区

  • 多进程各自维护内存缓存,互相不知道对方写入。
  • 子进程直连数据库写,文件锁等待与损坏风险上升。

追问

  • 必须子进程读写数据库怎么办?答:单写者模型,写请求转发主进程;读可受控多进程并配合失效事件。
  • 跨进程缓存一致性如何验证?答:测试双进程写入后检查各方重读结果与通知链路。

07.1.1.8.2-078 并发写同一表如何加锁与排队?

一句话结论

数据库层事务与文件锁保证写入串行;应用层用单写队列或协程互斥锁把对同一实体/表的修改排队,避免交错写入产生半成品状态。

概念解释

SQLite 写操作串行化,并发写入可能等待或报 BUSY。应用层把本地变更放进有序队列逐个提交,配合数据库事务保证一组写入原子。同一记录的并发修改用互斥锁隔离;不同记录可按调度器并发,但写库连接仍受底层约束。

原理流程

并发变更 → 写队列/互斥锁 → 串行提交
  数据库事务:一组写入要么全成要么全回滚

代码或图示

private val mutex = Mutex()
suspend fun update(block: Note.() -> Note) = mutex.withLock {
    val current = dao.require(id)
    dao.upsert(block(current))
}

常见误区

  • 无锁先读后写,两个协程基于旧值覆盖。
  • 事务内做网络/长计算,锁持有过久阻塞其他写入。

追问

  • 锁粒度多大?答:按实体或业务聚合加锁,避免全局锁阻塞全部写入。
  • BUSY 错误如何处理?答:重试退避或缩小事务;必要时调整底层超时配置(按版本确认)。

07.1.1.8.2-079 数据一致性校验在启动时做什么?

一句话结论

启动时检查数据库可打开、记录计数与关键索引正常、待同步队列状态完整、孤儿与重复记录可识别;发现问题走修复或重建流程。

概念解释

启动校验不等同于全量对账:轻量检查库完整性、版本基线、状态字段一致性;重校验放后台任务。校验内容:表可访问、PENDING 记录是否有对应实体、remoteId 唯一性、缓存元数据与文件匹配。异常按严重程度提示或修复。

原理流程

进程启动 → 轻量完整性检查
  → 后台重校验:孤儿/重复/版本对账
  → 异常记录并修复/上报

代码或图示

suspend fun validate() {
    dao.countByState(SyncState.PENDING)
    dao.findOrphans()
    dao.findDuplicateRemoteIds()
}

常见误区

  • 启动主线程做全表扫描,拖慢首启。
  • 校验只看能不能打开库,忽略状态字段与孤儿数据。

追问

  • 校验失败能自动修复吗?答:低风险项自动清理;涉及用户数据的修复需确认或备份后执行。
  • 校验结果上报吗?答:关键异常随监控上报,便于发现设备侧数据问题。

07.1.1.8.2-080 脏数据、孤儿记录如何扫描与清理?

一句话结论

按外键关系扫描无主记录、按唯一性约束找重复、按时间与状态识别过期脏数据;清理前备份标记,分批删除并同步删除关联文件。

概念解释

孤儿记录:外键指向不存在父行;重复记录:同一 remoteId 多行;脏数据:状态矛盾、过期缓存、残留草稿。扫描用 SQL 关联查询定位,清理分批执行避免长事务。文件缓存与库元数据联动删除,避免磁盘残留。

原理流程

扫描:无主 / 重复 / 过期
  → 标记待清理 → 分批删除库记录 + 关联文件

代码或图示

SELECT c.* FROM child c LEFT JOIN parent p ON c.parentId = p.id
WHERE p.id IS NULL

常见误区

  • 只删库记录不删文件,磁盘占用持续增长。
  • 一次性大批量删除,事务过长阻塞读写。

追问

  • 误删如何兜底?答:先软删除标记,观察期后物理清理;关键数据先导出备份。
  • 扫描频率怎么定?答:启动轻量检查 + 后台周期任务,避免每次进入页面全扫。

07.1.1.8.2-081 数据库损坏(corruption)如何检测与恢复?

一句话结论

打开/查询时捕获数据库异常并校验完整性,损坏后按策略恢复:从备份重建库、重新拉取远程数据,或走破坏性兜底;不可恢复的本地数据需明确提示用户。

概念解释

损坏来源:异常断电、磁盘问题、多进程竞争、版本不兼容。检测靠打开异常、PRAGMA integrity_check 类校验与查询失败统计。恢复路径:备份文件恢复 → 远程全量重建 → 兜底清空。用户未同步的本地草稿需单独提示可能丢失。

原理流程

打开/查询异常 → 完整性校验
  → 备份恢复 / 远程重建 / 兜底重建
  → 记录损坏事件上报

代码或图示

runCatching { dao.validate() }.onFailure { corruption ->
    backup.restore() ?: rebuildFromRemote()
}

常见误区

  • 损坏后反复打开同一坏库,异常持续崩溃。
  • 直接删除重建,未提醒用户本地未同步内容可能丢失。

追问

  • 如何降低损坏概率?答:单进程访问、事务规范、避免进程强杀时大写入;定期备份。
  • integrity_check 何时跑?答:后台或异常后触发,不在主路径每次执行。

07.1.1.8.2-082 缓存清理策略:容量上限、过期清理、卸载清理如何配合?

一句话结论

三层清理:容量超限时 LRU 淘汰冷数据,TTL 到期被动清理,应用卸载/系统回收由系统与目录约定处理;主动清理覆盖过期、孤儿与超量三类。

概念解释

容量上限控制内存与磁盘总量;过期清理保证新鲜度;卸载后私有目录随应用移除,外部/媒体缓存需按系统规则清理。定期任务扫描超容量与过期项,文件与元数据同步删除。清理策略要可配置,避免误删未同步草稿。

原理流程

超容量 → LRU 淘汰
  过期 → TTL 清理
  卸载 → 系统移除私有目录

代码或图示

@Query("DELETE FROM cache_meta WHERE expireAt < :now OR size > :budget")
suspend fun purge(now: Long, budget: Long)

常见误区

  • 只清内存不清磁盘,缓存目录无限膨胀。
  • 清理逻辑误删 PENDING 草稿与未同步记录。

追问

  • 外部存储缓存怎么清?答:遵循分区存储,私有外部目录随卸载;媒体集合内容需主动删除。
  • 清理前要统计什么?答:各实体占用大小、过期比例、孤儿文件数量,指导阈值调整。

07.1.1.8.2-083 备份恢复后本地数据如何与远程对账?

一句话结论

恢复备份后以服务端为基准做差异对账:比对版本与 ID 集合,补齐远程有而本地无的记录,处理本地恢复出的过期/冲突数据。

概念解释

备份可能是某历史时点快照,恢复后与当前服务端存在时差。对账流程:拉取远程 ID/版本清单,比对本地;缺失补拉,落后记录按版本更新,本地独有未同步变更走冲突判定。对账期间标记数据为“待校验”,避免直接当最新使用。

原理流程

恢复备份 → 拉远程清单 → 比对 ID/版本
  → 补缺失 / 更新落后 / 处理独有变更

代码或图示

suspend fun reconcileAfterRestore() {
    val remote = api.idVersionMap()
    dao.allLocal().forEach { local ->
        val remoteVer = remote[local.remoteId]
        // 比对版本,缺失补拉,落后更新
    }
}

常见误区

  • 恢复后直接用备份快照展示,未发现期间服务端新增/删除数据。
  • 备份恢复出的过期记录覆盖了服务端新版本。

追问

  • 对账期间离线怎么办?答:先展示恢复数据并标注未校验,联网后补对账。
  • 本地独有的未同步记录怎么处理?答:保留并重新纳入同步队列,不被对账删除。

07.1.1.8.2-084 长表数据归档与删除策略?

一句话结论

按时间/业务生命周期把冷数据归档到历史表或导出存储,活跃表只保留近期数据;归档先搬后删,保证可回溯且不拖慢在线查询。

概念解释

长表累积后索引维护、查询与备份成本上升。策略:设定保留窗口(如近 90 天),超期数据批量迁移到归档表/文件存储,活跃表删除。归档批次控制事务大小;删除前确认引用与统计口径。高频查询字段与归档条件匹配索引。

原理流程

选归档批次 → 写入归档存储 → 校验完整 → 删活跃表记录

代码或图示

INSERT INTO note_archive SELECT * FROM note WHERE createdAt < :cutoff;
DELETE FROM note WHERE createdAt < :cutoff;

常见误区

  • 直接删除历史数据,无归档无法回溯。
  • 归档未完成就删源记录,中途失败丢数据。

追问

  • 归档数据还能检索吗?答:按产品需要提供历史查询入口;不常访问可导出压缩存储。
  • 归档任务何时跑?答:后台低峰期分批执行,避免影响在线读写。

07.1.1.8.2-085 数据迁移后如何校验残留与重复?

一句话结论

迁移后比对记录数、主键/唯一键、关联完整性与抽样内容,检查旧列残留、重复 remoteId 与孤儿外键;通过校验后再移除旧结构。

概念解释

迁移不只看建表成功:校验新旧表行数一致、关键字段映射正确、唯一约束无冲突、子表外键均有父行。残留检查包括旧列/旧表是否清理、缓存元数据是否同步。校验脚本纳入迁移测试与发布检查。

原理流程

迁移执行 → 行数/唯一性/外键校验
  → 抽样比对内容 → 无残留重复 → 清理旧结构

代码或图示

@Query("SELECT remoteId, COUNT(*) c FROM Note GROUP BY remoteId HAVING c > 1")
fun duplicates(): List<IdCount>

常见误区

  • 只验证应用能打开页面,不核对数据条数与映射。
  • 旧表/旧列残留占用空间且混淆后续查询。

追问

  • 校验发现重复怎么处理?答:按版本保留最新/有效记录,合并冗余后再清理。
  • 校验纳入 CI 吗?答:迁移测试自动跑结构与数据校验,线上发布前人工复核抽样。

07.1.1.8.2-086 同步状态字段如何避免与业务字段耦合?

一句话结论

同步状态、远端 ID、重试次数等技术元数据放在独立列或关联元数据表,与业务字段分离;业务模型不感知同步细节。

概念解释

把 syncState、remoteId、version、retries 视为数据访问技术属性,与业务内容分开设。业务实体映射到领域模型时剥离这些字段;元数据变更不影响业务校验与展示。独立元数据表还支持一个业务实体挂多条同步记录。

原理流程

业务表:内容字段
  元数据:remoteId/version/syncState/retries
  领域模型只暴露业务字段

代码或图示

@Entity data class NoteSyncMeta(
    @PrimaryKey val localId: String,
    val remoteId: Long?,
    val version: Int,
    val syncState: String,
    val retries: Int
)

常见误区

  • 同步字段散落在业务实体各处,业务逻辑依赖同步状态。
  • 元数据随业务序列化发给服务端,泄漏内部状态。

追问

  • 单表混合可以吗?答:小项目可同表分列;规模大或一对多元数据时独立表更清晰。
  • 领域模型如何剥离?答:映射层只取业务字段,元数据由仓库内部维护。

07.1.1.8.2-087 WorkManager 为什么适合做后台同步任务?

一句话结论

WorkManager 提供持久化任务队列、进程重建后存活、约束条件与重试策略,适合需要可靠执行的后台同步;比直接起协程或定时线程更可控。

概念解释

任务进入 WorkManager 队列后,应用退出、进程重建、设备重启后仍按约束调度。它统一封装 JobScheduler/AlarmManager 等底层机制,支持约束、退避、链式与观察任务状态。同步这种“最终要执行”的后台操作比临时协程更可靠。

原理流程

构造 WorkRequest + 约束 → 入队
  → 系统满足条件调度 → Worker 执行同步
  → 结果/状态可观察

代码或图示

val request = OneTimeWorkRequestBuilder<SyncWorker>()
    .setConstraints(Constraints(requiredNetworkType = NetworkType.CONNECTED))
    .build()
WorkManager.getInstance(context).enqueue(request)

常见误区

  • 用普通协程做后台同步,进程被杀后任务丢失。
  • 以为 WorkManager 保证实时执行,实际受系统调度与约束影响。

追问

  • WorkManager 版本基线?答:当前依赖版本 API 以官方文档为准(待确认)。
  • 适合高频即时任务吗?答:不适合;实时性高的用推送触发 + 前台任务,WorkManager 负责兜底与批量同步。

07.1.1.8.2-088 一次性任务与周期任务如何选择?

一句话结论

明确触发的同步(写操作后、网络恢复、手动刷新)用一次性任务;定期巡检与低频补偿用周期任务;周期任务不保证精确间隔。

概念解释

一次性任务执行一次后结束,适合事件驱动的增量上传/拉取。周期任务按系统允许的最小间隔重复执行,适合对账、过期清理、兜底同步。两者可组合:事件任务即时处理,周期任务扫尾遗漏。周期任务间隔受系统调度限制,不能当作精确定时器。

原理流程

事件 → OneTimeWorkRequest
  巡检/兜底 → PeriodicWorkRequest

代码或图示

val periodic = PeriodicWorkRequestBuilder<SyncWorker>(15, TimeUnit.MINUTES).build()

常见误区

  • 用周期任务承载每次本地写入的即时同步,延迟不可控。
  • 周期任务间隔设得过短,被系统合并或耗电。

追问

  • 周期任务最小间隔?答:受系统版本与设备限制,具体下限以 WorkManager 文档为准(待确认)。
  • 如何避免重复周期任务?答:用唯一命名 + 替换/保留策略入队。

07.1.1.8.2-089 同步任务的约束(网络、充电、空闲)如何配置?

一句话结论

按任务性质配置网络类型、电量、充电、存储等约束;约束不满足时任务等待,避免弱网、低电量时执行重同步。

概念解释

requiredNetworkType 控制联网要求;requiresBatteryNotLow、requiresCharging 控制电量条件;requiresDeviceIdle 要求设备空闲。批量大同步可放宽到充电/空闲时执行,增量上传保持联网即可。约束越严,执行时机越靠后,需在可靠性与时效间取舍。

原理流程

WorkRequest 声明约束 → 系统评估
  满足才调度;不满足保持排队

代码或图示

Constraints(
    requiredNetworkType = NetworkType.UNMETERED,
    requiresCharging = true,
    requiresBatteryNotLow = true
)

常见误区

  • 约束过严,任务长期不执行,待同步数据积压。
  • 后台大同步要求空闲却在用户使用时触发,体验差。

追问

  • 约束能运行时修改吗?答:重新构造任务按唯一策略替换旧任务。
  • 网络约束区分 WiFi/移动数据?答:NetworkType.UNMETERED 对应计费网络外,可按业务选择。

07.1.1.8.2-090 WorkManager 与协程/Flow 如何配合?

一句话结论

继承 CoroutineWorker 在协程环境执行同步,可直接调用挂起仓库方法;任务状态通过 WorkInfo Flow 观察,结果回传仓库状态流。

概念解释

CoroutineWorker 的 doWork() 是挂起函数,内部走协程调度,可调用 suspend 仓库与 DAO。任务进度用 setProgress 更新,结果用 Result.success/failure/retry 返回。界面收集 WorkManager 的 getWorkInfoByIdFlow 或仓库暴露的状态流,不阻塞 Worker 线程。

原理流程

CoroutineWorker.doWork() → 调 suspend 同步方法
  → Result 回传 → WorkInfo 状态流 → 界面观察

代码或图示

class SyncWorker(ctx: Context, params: WorkerParameters) : CoroutineWorker(ctx, params) {
    override suspend fun doWork(): Result {
        return runCatching { syncRepository.syncPending() }
            .fold(onSuccess = { Result.success() }, onFailure = { Result.retry() })
    }
}

常见误区

  • Worker 里阻塞主线程或用 runBlocking 包裹协程。
  • 把任务状态只存在 Worker 局部,界面拿不到进度与结果。

追问

  • Worker 能访问 DI 容器吗?答:可通过 Application/容器获取注入;Hilt 对 Worker 有集成支持(见 07.1.1.10.1)。
  • 长时间同步如何避免被系统中断?答:超长任务评估前台服务 Worker;普通增量同步控制批次大小。

07.1.1.8.2-091 同步任务如何保证不重复执行?

一句话结论

用唯一任务名加去重策略避免重复入队,任务内加同步锁与幂等判断;进行中任务不重复启动,重试由 WorkManager 统一管理。

概念解释

同一同步任务多次触发(网络恢复 + 回前台)时,用 enqueueUniqueWork 配合 KEEP/REPLACE/APPEND 策略避免多份排队。Worker 内检查是否已有同步在跑,幂等键保证重复提交不产生脏数据。任务完成状态记录,避免残留队列重复消费。

原理流程

唯一任务名 → 去重策略
  Worker 内:在途锁 + 幂等提交

代码或图示

WorkManager.getInstance(context).enqueueUniqueWork(
    "sync_notes", ExistingWorkPolicy.KEEP, request
)

常见误区

  • 每次触发都 enqueue 普通请求,队列里堆积多个同步任务。
  • 任务未做幂等,重试造成重复记录或重复操作。

追问

  • KEEP 与 REPLACE 怎么选?答:已有任务在跑用 KEEP 不打断;需要新参数时 REPLACE。
  • 并发同步锁放哪?答:仓库单例标志位或数据库标记,跨任务可见。

07.1.1.8.2-092 任务失败重试与退避策略如何配置?

一句话结论

Result.retry() 配合 BackoffPolicy.EXPONENTIAL 与初始退避间隔自动重试;永久失败返回 Result.failure(),不再自动重试。

概念解释

瞬时错误返回 retry,WorkManager 按指数退避重新调度;永久错误(校验失败、权限拒绝)返回 failure,任务结束并保留状态。退避间隔与策略在 WorkRequest 上配置,重试次数由系统策略与失败类型共同决定。

原理流程

瞬时失败 → Result.retry() → 指数退避后重试
  永久失败 → Result.failure() → 停止自动重试

代码或图示

val request = OneTimeWorkRequestBuilder<SyncWorker>()
    .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
    .build()

常见误区

  • 永久失败也返回 retry,任务反复执行耗电。
  • 退避间隔过短,弱网下密集重试。

追问

  • 重试上限是多少?答:WorkManager 自动重试策略与次数按版本/系统确认(待确认);业务层可另记重试计数。
  • 失败后用户手动重试?答:重新入队唯一任务,绕过退避立即尝试。

07.1.1.8.2-093 同步任务进度与结果如何回传界面?

一句话结论

Worker 通过 setProgress 更新进度、Result 返回最终结果;界面收集 WorkInfo 流或仓库聚合的状态流,展示上传/同步状态与错误。

概念解释

WorkManager 把任务状态(ENQUEUED/RUNNING/SUCCEEDED/FAILED)与进度暴露为 Flow;仓库可把 Worker 状态映射为自身同步状态。进度适合大批量同步展示条数;结果成功/失败更新列表数据。回传链路不经过界面直接持有 Worker 引用。

原理流程

Worker.setProgress / Result
  → WorkInfo Flow
  → 仓库状态映射 → 界面收集渲染

代码或图示

WorkManager.getInstance(context)
    .getWorkInfoByIdFlow(request.id)
    .collect { info -> /* 映射状态 */ }

常见误区

  • 界面直接读 Worker 内部变量,任务重建后状态丢失。
  • 进度只在 Worker 内更新,界面无感知。

追问

  • 跨页面同步状态怎么共享?答:仓库持有状态流,作用域跟随应用;各页面收集同一状态。
  • 大批次进度如何平滑?答:按批次更新进度,避免每条记录刷一次界面。

07.1.1.8.2-094 应用退出后同步任务能否继续?

一句话结论

WorkManager 任务可在应用进程退出后由系统调度继续执行;但任务执行依赖进程被系统重新拉起,时效性不保证,超长任务需前台服务支撑。

概念解释

任务持久化在队列中,应用关闭后符合约束时系统重新创建进程执行 Worker。进程重建时 Worker 重新实例化,状态从队列与持久化数据恢复。后台执行时长受系统限制;需要持续长时间传输的场景用前台服务并展示通知。

原理流程

应用退出 → 任务留在队列
  → 系统满足约束 → 重建进程执行 Worker

代码或图示

WorkManager 持久化队列 → 进程重建 → doWork() 重新执行

常见误区

  • 假设退出后任务立刻继续,实际可能延迟到下次调度。
  • 把长时间文件传输放普通后台 Worker,被系统限制中断。

追问

  • 设备重启后任务还在吗?答:在,WorkManager 队列持久化,重启后按约束调度。
  • 如何保证即时完成?答:前台可见场景用前台服务;后台兜底才依赖 WorkManager。

07.1.1.8.2-095 多任务依赖与链式同步怎么编排?

一句话结论

WorkManager 支持任务链与并行组合:先上传本地变更,再拉取远程增量,最后更新状态;用 beginWith/then 或 OneTimeWorkRequest 组合编排依赖顺序。

概念解释

链式任务按依赖顺序执行:前置成功才执行后续;并行任务组可同时入队。同步编排可拆为:上传 outbox → 拉取变更 → 对账刷新。任务间通过数据库/文件传递数据,而非 Worker 直接传内存对象。失败中断链并可重试对应环节。

原理流程

上传本地 → 拉取增量 → 对账刷新
  前置成功 → 后置执行;失败按策略重试/中断

代码或图示

WorkManager.getInstance(context)
    .beginWith(uploadRequest)
    .then(fetchRequest)
    .then(reconcileRequest)
    .enqueue()

常见误区

  • 任务间通过静态内存传数据,进程重建后丢失。
  • 链中某步永久失败,后续任务仍按预期执行导致状态错乱。

追问

  • 并行任务怎么组合?答:listOf(requestA, requestB) 并行入队,汇合后再链后续。
  • 链状态如何观察?答:收集各任务 WorkInfo 或链根任务状态汇总。

07.1.1.8.2-096 同步任务如何处理进程重建与状态恢复?

一句话结论

任务状态持久化在 WorkManager 队列,业务进度落在数据库水位与 outbox;Worker 重建后从持久化状态续跑,不依赖内存变量。

概念解释

进程被杀后 Worker 实例与内存变量销毁,恢复靠两层:WorkManager 记录任务排队/运行状态;业务层记录已处理批次、游标、PENDING 队列。重启执行时读持久化水位继续,已完成项靠幂等跳过。中间态要可识别,避免重复提交或漏处理。

原理流程

进程重建 → Worker 重新实例化
  → 读水位/outbox → 从断点续跑 → 幂等去重

代码或图示

override suspend fun doWork(): Result {
    val pending = syncRepository.pendingOps()
    pending.forEach { /* 续跑,幂等提交 */ }
    return Result.success()
}

常见误区

  • 同步进度只存内存,重建后从头重跑或丢失。
  • 重建后未判断上次是否完成,重复执行整批操作。

追问

  • 进行中状态如何持久化?答:数据库标记 SYNCING,崩溃后启动时回滚中断的 SYNCING 记录为 PENDING。
  • 任务参数怎么恢复?答:从输入数据或数据库查询重建,不依赖 Worker 内存字段。

07.1.1.8.2-097 WorkManager 与前台服务、JobScheduler 的关系是什么?

一句话结论

WorkManager 是统一封装层,按系统版本选择 JobScheduler/AlarmManager 等底层实现;需要长时前台可见任务时直接用前台服务,或用支持前台的 Worker。

概念解释

WorkManager 屏蔽系统差异:现代设备走 JobScheduler,旧版本走其他调度机制。后台受限任务交给它;持续上传下载、需要通知可见的长任务用前台服务。两者可配合:前台任务做实时传输,WorkManager 做后台兜底。

原理流程

WorkManager → 按版本选底层调度(JobScheduler 等)
  长任务 → 前台服务 / 前台 Worker + 通知

代码或图示

后台兜底:WorkManager 队列
  长时传输:Foreground Service,通知可见

常见误区

  • 用普通后台 Worker 执行长时间任务,被系统限制后中断。
  • 重复造调度逻辑,没用 WorkManager 已封装的兼容能力。

追问

  • 前台 Worker 是什么?答:Worker 可提升为前台服务并展示通知,适合受限时长内的关键传输;具体 API 按版本确认(待确认)。
  • 三者如何选?答:可靠后台同步用 WorkManager;长时可见操作用前台服务;一般不直接手写 JobScheduler。

07.1.1.8.2-098 同步任务里如何避免与界面查询竞争?

一句话结论

同步写入走数据库事务与单写队列,界面读取观察本地快照;长批次拆小事务,避免读写互相长时间阻塞,冲突由版本与幂等处理。

概念解释

同步批量写库时,界面 Flow 查询可能等待写锁。控制方式:分批小事务、避免长事务持有连接、写入后刷新观察流;读路径不阻塞同步,写路径不无限占用。必要时读一致性按快照隔离理解,避免界面与Worker 互相改同一内存状态。

原理流程

同步:分批事务写库
  界面:收集本地流读快照
  竞争:小批次 + 单写队列 + 幂等

代码或图示

pending.chunked(100).forEach { batch ->
    db.withTransaction { dao.upsertAll(batch) }
}

常见误区

  • 单事务写整批数据,界面查询长时间阻塞。
  • Worker 与界面同时修改同一内存对象,状态互相覆盖。

追问

  • 读写锁冲突报错怎么办?答:缩短事务、拆分批次、必要时重试;检查是否多进程直写。
  • 同步期间列表卡顿怎么定位?答:看数据库锁等待与事务时长,拆分写入批次。

07.1.1.8.2-099 如何监控同步成功率与延迟?

一句话结论

埋点记录同步触发、成功/失败、耗时、重试次数与失败原因,聚合成功率、延迟分布与积压量;异常失败分类上报辅助排查。

概念解释

监控指标:任务触发次数、成功率、失败原因分布、单次同步耗时、待同步队列长度、重试次数。关键场景:首装同步、离线积压上传、对账任务。埋点在 Worker 与仓库层打标,后台聚合看趋势;本地积压过多或失败率升高及时告警。

原理流程

触发/成功/失败/耗时/重试 → 埋点上报
  → 聚合:成功率、延迟 P50/P95、积压量

代码或图示

data class SyncMetric(
    val scope: String,
    val success: Boolean,
    val durationMs: Long,
    val retries: Int,
    val reason: String?
)

常见误区

  • 只记录崩溃,不统计普通失败与延迟,积压不可见。
  • 埋点携带敏感业务数据,需脱敏后上报。

追问

  • 本地积压怎么观察?答:监控 PENDING 队列长度与停留时长,超阈值告警。
  • 延迟按什么口径?答:从操作产生到同步完成的端到端时长,区分等待调度与实际执行。

07.1.1.8.2-100 设计一个完整的离线优先同步流程(场景综合)?

一句话结论

综合流程:本地库为 SSOT,写入先落 PENDING 入队,WorkManager 按约束同步,幂等提交并回填远端标识,增量拉取变更与墓碑,版本冲突按规则合并,失败分类重试,全程状态可观察可对账。

概念解释

完整链路覆盖读、写、同步、冲突、补偿:读路径观察本地;写路径本地入库排队;后台任务上传 outbox、拉取增量、应用墓碑;版本不一致走字段合并或用户介入;失败退避重试与对账兜底;状态与指标贯穿界面与监控。

原理流程

读:本地 Flow 展示
写:本地 PENDING → outbox
同步:上传 → 拉增量/墓碑 → 写库
冲突:版本比对 → 自动合并/介入
补偿:周期对账 + 幂等重试 + 状态监控

代码或图示

suspend fun sync() {
    val pending = syncRepo.pendingOps()
    pending.forEach { op -> api.commit(op.toRequest()).onSuccess { syncRepo.bindRemote(op, it) } }
    val changes = api.changed(cursorRepo.token())
    changes.applyTo(dao)
    cursorRepo.advance(changes.nextCursor)
}

常见误区

  • 链路只做上传不拉增量,他端变更与删除感知不到。
  • 缺少对账兜底与状态可见性,离线积压成为黑盒。

追问

  • 首装流程怎么走?答:全量拉取入库,建立基线游标与版本,之后转增量。
  • 流程中哪些环节可独立替换?答:同步调度器、冲突策略、缓存层均可按业务替换,Repository 编排保持稳定。

参考来源

待整理清单

  • [ ] 核对工程中 Paging 3、WorkManager、Room 的具体依赖版本与 API 基线。
  • [ ] 确认 WorkManager 周期任务最小间隔、前台 Worker 支持在当前版本的行为。
  • [ ] 补充本项目各业务集的同步频率、TTL 与冲突策略约定。
  • [ ] 整理离线草稿保留策略与登出清理规则的实际业务要求。
  • [ ] 确认增量同步游标、墓碑保留窗口与对账周期的服务端约定。