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

04.8.4.2 Arrow、结果类型、缓存、重试与日志

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.8 Kotlin / 04.8.4 常用库与序列化

本节要解决的问题

本节聚焦 Kotlin 后端在函数式错误处理与运行期横切能力上的落地:Arrow 的 Either/Option/Raise 与 typed error DSL、与异常体系的边界、Kotlin Result 的局限,指数退避加抖动的重试、Caffeine 与协程缓存及击穿处理,以及结构化日志、slf4j 桥接与 MDC 在协程上下文的传递。版本基线为 Arrow 1.x;具体 API 与坐标以官方文档当前版本为准,通用缓存/重试理论见 04.4 与 09 分册,本节只讲 Kotlin 库落地。

04.8.4.2-001 Arrow 库在 Kotlin 后端的定位是什么?

一句话结论

Arrow 是 Kotlin 的函数式工具集,提供类型级错误处理(Either/Option/Raise)、函数组合与数据类型扩展;后端用它把错误作为类型显式建模,替代部分异常控制流。

概念解释

Arrow 核心模块提供代数数据类型与扩展函数,不改变 Kotlin 语言本身。后端典型用途:领域错误用 sealed 类型 + Either 表达,可选值用 Option,配合 Raise DSL 写链式短路逻辑。库版本与 Kotlin 版本兼容范围以官方文档为准。

原理流程

  1. 引入 arrow-core 等模块依赖。
  2. 领域错误定义为 sealed 层级。
  3. 业务函数返回 Either<Error, Value> 或进入 Raise 作用域。
  4. 组合层按类型分支处理成功/失败。

代码或图示

// 依赖坐标与版本以官方当前文档为准
// implementation("io.arrow-kt:arrow-core")

常见误区

  • 以为 Arrow 是协程或框架:它是函数式工具库,不提供运行容器或 Web 框架。
  • 全工程强制函数式风格:按需使用错误处理与数据类型,不必改造全部代码风格。

追问

  • Arrow 有哪些核心模块?答:core(数据类型与扩展)、fx(Raise 等作用域能力)等,模块划分以当前版本为准。
  • 与 Kotlin 标准库能力重叠吗?答:部分重叠(nullable、Result),Arrow 提供更强的类型组合与错误分型。

04.8.4.2-002 Either 类型的结构是怎样的?

一句话结论

Either<out A, out B> 是二元联合类型:Left<A> 表示失败/左侧值,Right<B> 表示成功/右侧值;一个实例只持有其中一侧。

概念解释

Either 把两种可能结果编码进类型,调用方必须显式处理两侧。约定 Left 承载错误、Right 承载成功值。它不是异常:失败是普通值,不抛栈、不中断线程。

原理流程

  1. 函数返回 Either<Error, Value>。
  2. 成功构造 Right(value),失败构造 Left(error)。
  3. 组合函数按一侧映射或短路。
  4. 边界处折叠为具体响应/默认值。

代码或图示

sealed class LoginError
data class NotFound(val userId: Long) : LoginError()

fun findUser(id: Long): Either<LoginError, User> =
    if (id > 0) Right(User(id)) else Left(NotFound(id))

常见误区

  • 把 Either 当 nullable 用:左侧是显式错误类型,不是 null 占位。
  • 左右侧语义颠倒:约定 Left 错误、Right 成功,团队内保持一致。

追问

  • Either 能携带多个错误吗?答:单侧单值;多错误聚合需组合器或自定义集合类型。
  • Either 是协变的吗?答:类型参数按声明处 out 定义,子类型关系以 Arrow 源码为准。

04.8.4.2-003 Option 与 nullable 类型如何对比?

一句话结论

Option<out A> 表示有值 Some<A> 或无值 None;Kotlin nullable(A?)是语言内建的可空类型。Option 提供函数式组合操作,nullable 由语言空安全支持。

概念解释

两者都表达缺失,但模型不同:nullable 是类型系统标记,Option 是代数数据类型。Option 可与 Either 组合、在函数式链中统一处理;nullable 配合 ?.、?: 语法更轻量。后端多数场景 nullable 足够,Option 用于函数式流水线一致性。

原理流程

  1. 可能缺失的值建模为 T? 或 Option<T>。
  2. 缺失时分别为 null 或 None。
  3. 组合操作映射/取默认值。
  4. 边界处取值并处理缺失。

代码或图示

// nullable
val name: String? = repo.find(id)?.name

// Option
val opt: Option<String> = Option.fromNullable(name)

常见误区

  • 把所有 nullable 改成 Option:增加包装成本,语言空安全已覆盖大部分场景。
  • Option 与 nullable 混用不转换:组合链类型不一致,需显式互转。

追问

  • Option 有哪些常用操作?答:map、flatMap、getOrElse、orNull 等,API 以 Arrow 版本为准。
  • Option 能携带原因吗?答:不能,缺失无信息;需要失败原因用 Either。

04.8.4.2-004 Raise DSL 是什么?

一句话结论

Raise 是 Arrow 1.x 的作用域式错误处理模型:在 Raise 上下文内用 raise 提前返回错误,链式调用按错误短路,免去手动嵌套 Either 映射。

概念解释

传统 Either 链用 flatMap 逐层串接,嵌套深;Raise 作用域内函数可直接 raise(error) 中断当前计算,等价于返回 Left。作用域结束后整体得到 Either 结果。它是 typed error 的 DSL 载体。

原理流程

  1. 进入 raise/either 作用域。
  2. 步骤函数在作用域内运行,失败调用 raise。
  3. raise 立即短路,错误传出作用域。
  4. 作用域结果折叠为 Either 或取值。

代码或图示

val result: Either<LoginError, User> = either {
    val user = findUser(id).bind()
    val profile = loadProfile(user).bind()
    profile
}

常见误区

  • 在普通函数里直接调 raise:需先进入 Raise 作用域,否则接收者不可用。
  • 把 Raise 当异常机制:它是返回值短路,不抛 JVM 异常。

追问

  • Raise 与 either{} 块关系?答:either { } 提供 Raise 上下文并把结果封装为 Either,具体 API 以 Arrow 版本为准。
  • 作用域内能返回 Right 吗?答:块内普通返回值即右侧成功值。

04.8.4.2-005 either{} 块的短路语义是什么?

一句话结论

either { } 内任一 bind() 得到 Left 或调用 raise,块立即短路返回该 Left;后续步骤不再执行,类似异常中断但以值形式传递错误。

概念解释

短路由 Raise 上下文实现:bind 检测左侧值后从作用域返回。链上步骤只在前序成功时继续。短路不展开栈,错误沿返回值传播。组合顺序即短路顺序。

原理流程

  1. 块内第一步 bind 成功,取值继续。
  2. 第二步 bind 到 Left。
  3. 作用域短路,返回该 Left。
  4. 后续代码不执行。

代码或图示

either {
    val a = stepA().bind()   // Left → 短路
    val b = stepB(a).bind()  // 不执行
    b
}

常见误区

  • 假设短路后还会执行清理逻辑:资源释放需在作用域外或用作用域管理函数。
  • 短路错误被后续 map 覆盖:顺序上先短路先返回。

追问

  • 短路后如何恢复?答:作用域外用 handleError/getOrElse 处理 Left,或进入新作用域重试。
  • 多个错误如何保留?答:默认短路只保留首个错误;聚合场景用专门组合器。

04.8.4.2-006 Left 表示错误、Right 表示成功的约定为什么这样定?

一句话结论

约定来自 Either 惯用传统:右侧是"正确/主流"结果,映射操作默认作用于 Right;Left 是需要单独处理的异常分支。团队内统一约定可避免两侧混淆。

概念解释

map/flatMap 默认聚焦右侧成功值,左侧错误透传。这一约定让链式组合只关心成功路径,错误在边界统一处理。虽然类型上 Either 两侧任意,但工程约定必须固定。

原理流程

  1. 成功值构造 Right。
  2. 映射函数默认作用于 Right。
  3. Left 沿链透传。
  4. 边界折叠处理左侧。

代码或图示

Right(value) → 链式 map/flatMap 继续
Left(error)  → 透传到边界处理

常见误区

  • 业务上把成功放 Left:默认映射操作失效,需要反向处理。
  • 跨模块两侧约定不一致:组合时语义错位。

追问

  • 有右偏的 Either 实现吗?答:Arrow Either 为右偏,操作默认映射右侧;以库实现为准。
  • 如何翻转两侧?答:swap 类操作可交换左右,具体 API 以版本为准。

04.8.4.2-007 Either 的 map 与 flatMap 如何链式组合?

一句话结论

map 变换右侧成功值,flatMap 连接返回 Either 的下一步;左侧错误透传,链上任一失败即停在该 Left。

概念解释

map 输入 (B -> C) 把 Either<A, B> 变为 Either<A, C>;flatMap 输入 (B -> Either<A, C>) 串联两步可能失败的计算。两者都不触碰 Left。Raise DSL 用 bind 替代手写 flatMap 嵌套。

原理流程

  1. 初始 Either 进入链。
  2. Right 经 map/flatMap 继续变换。
  3. Left 直接透传。
  4. 最终 Either 由边界处理。

代码或图示

val result: Either<LoginError, Profile> =
    findUser(id)
        .map { it.toDto() }
        .flatMap { loadProfile(it.id) }

常见误区

  • 步骤返回普通值却用 flatMap:值变换用 map 即可。
  • 链中混用不同错误类型:左侧类型需统一为共同 sealed 父类型。

追问

  • map 函数抛异常怎么办?答:map 内不捕获异常;需要转 Either 用 catch 类组合器。
  • 链上错误类型如何统一?答:定义 sealed 错误层级,各步骤 Left 为其子类。

04.8.4.2-008 Either 的 getOrElse 与 handleError 如何恢复?

一句话结论

getOrElse 在 Left 时提供默认值,handleError 对左侧错误做映射/恢复;恢复后回到右侧值或转换错误类型,在边界把 Either 落地为普通值。

概念解释

恢复策略分两类:给默认值(兜底)、根据错误类型转换为另一结果。handleError 类似 map 作用于左侧。恢复点应靠近边界,避免业务深处吞错。

原理流程

  1. Either 到达边界。
  2. Left 进入恢复分支:默认值或错误映射。
  3. Right 直接取值。
  4. 得到普通业务结果返回上层。

代码或图示

val name: String = profile.getOrElse { "anonymous" }

val recovered: Either<OtherError, Profile> =
    profile.handleErrorWith { e -> e.toOther().left() }

常见误区

  • 业务深处到处 getOrElse 吞错:错误上下文丢失,应沿类型向上传播到决策点。
  • 恢复不区分错误类型:可重试错误与不可重试错误被同一兜底处理。

追问

  • 恢复后能再失败吗?答:handleErrorWith 可返回新的 Either,形成恢复链。
  • 默认值是否合理?答:按业务语义,关键路径不应静默兜底。

04.8.4.2-009 Option 的 map、flatMap、getOrElse 如何使用?

一句话结论

map 变换有值内容,flatMap 连接返回 Option 的计算,getOrElse 缺失时给默认值;None 沿链透传。

概念解释

Option 组合规则与 Either 右侧类似,只是左侧恒为缺失。嵌套可选值用 flatMap 拍平;需要记录缺失原因时升级为 Either。Option 链末尾通常转 nullable 或给默认值。

原理流程

  1. 初始 Option 有值或 None。
  2. map/flatMap 仅在有值时继续。
  3. None 透传。
  4. getOrElse 取默认值收尾。

代码或图示

val city: String =
    user.flatMap { it.address }.map { it.city }.getOrElse("unknown")

常见误区

  • Option 链中需要区分"不存在"与"查询失败":Option 不携带原因,应换 Either。
  • 反复 Option.fromNullable 包装:链入口统一转换即可。

追问

  • Option 能遍历集合取值吗?答:配合集合序列操作(如 sequence)聚合,见后续聚合题。
  • Option 与 List 有何关系?答:Option 可视为至多一个元素的集合,部分组合操作同构。

04.8.4.2-010 Option 与 nullable 如何互相转换?

一句话结论

Option.fromNullable(t) 把 nullable 包成 Option,option.orNull() 把 Option 转回 nullable;转换边界明确,避免在链中混合两种模型。

概念解释

进入函数式链前把 nullable 转为 Option,退出链后转回 nullable 交语言空安全处理。混合使用时在分界点显式转换,类型才能对齐。转换不改变值本身,只换包装。

原理流程

  1. 外部 nullable 进入:fromNullable 包装。
  2. Option 链组合处理。
  3. 边界 orNull 转回 nullable。
  4. 上层按 ?: 处理空值。

代码或图示

val opt: Option<String> = Option.fromNullable(raw)
val back: String? = opt.orNull()

常见误区

  • 链中直接把 null 当 Option 传:类型不匹配,编译错误。
  • 转换后丢失空值来源信息:需要原因时用 Either。

追问

  • 空集合与 None 等价吗?答:语义不同,None 表示单值缺失,空集合表示多值为空。
  • 转换有性能开销吗?答:包装对象分配轻微,热路径按基准评估。

04.8.4.2-011 raise、ensure、ensureNotNull 分别做什么?

一句话结论

raise(error) 直接短路返回错误;ensure(condition) 不满足时 raise 指定错误;ensureNotNull(value) 为空时 raise 错误并把值收窄为非空。

概念解释

三者是 Raise 作用域内的断言式短路工具。ensure 校验布尔条件,ensureNotNull 校验可空值并智能转换类型。它们把参数校验与错误短路写在同一作用域,避免 if 嵌套。

原理流程

  1. 进入 Raise 作用域。
  2. ensure 检查条件,失败 raise。
  3. ensureNotNull 检查 null,失败 raise,成功后类型收窄。
  4. 通过后继续后续步骤。

代码或图示

either<ValidationError, User> {
    ensure(name.isNotBlank()) { ValidationError.BlankName }
    val age = ensureNotNull(age) { ValidationError.MissingAge }
    User(name, age)
}

常见误区

  • 在作用域外调用 ensure:接收者不可用。
  • ensureNotNull 后仍按可空类型使用:编译器收窄后按非空处理。

追问

  • 校验错误类型如何定义?答:sealed 类列举各校验场景,与业务错误同层级管理。
  • ensure 与 if 抛异常区别?答:ensure 短路返回 Left,不抛 JVM 异常。

04.8.4.2-012 typed error 与异常的边界在哪里?

一句话结论

typed error 是作为返回值类型一部分的显式错误(Either/Raise),调用方必须处理;异常是控制流旁路,未声明可抛出,沿调用栈传播。边界在于错误是否在签名中可见、是否强制处理。

概念解释

typed error 进返回类型,编译期可检查分支;异常不进签名(Kotlin 无受检异常),调用方可能遗漏处理。跨层设计:领域可预期错误用 typed error,不可预期/系统故障走异常并在边界兜底。

原理流程

  1. 判断错误是否业务可预期。
  2. 可预期:返回 Either/Raise,签名暴露。
  3. 不可预期:抛异常,边界捕获转 typed error。
  4. 上层按类型分支处理。

代码或图示

业务校验/外部失败:Either<DomainError, T>
程序缺陷/系统故障:异常 → 边界捕获转换

常见误区

  • 所有错误都抛异常:调用方无法从签名预知失败分支。
  • 把 NPE、数组越界等程序错误包成 typed error:属于缺陷,应修复而非业务建模。

追问

  • HTTP 状态码属于哪类?答:对外响应是 typed error 的映射结果;内部先建模领域错误,边界转状态码。
  • typed error 能完全替代异常吗?答:不能,运行期缺陷与未预期故障仍由异常体系处理。

04.8.4.2-013 Raise 作用域内抛出普通异常会怎样?

一句话结论

Raise 作用域不把普通 JVM 异常自动转为 Left;异常按协程/调用栈正常传播,除非用捕获组合器(如 catch/nonFatal)显式转为错误值。

概念解释

raise 是返回值短路,与 throw 是两套机制。作用域内未捕获异常会打断作用域并向上抛。需要把异常纳入 typed error 链时,在步骤内用捕获函数包裹第三方调用。

原理流程

  1. 作用域内调用可能抛异常的代码。
  2. 未捕获异常正常抛出,不经过 Left。
  3. 若有捕获组合器,异常被转为 Either。
  4. 未转换则传播到作用域外。

代码或图示

either {
    // 直接调用抛异常的库:异常直接传出作用域
    val v = riskyCall()
    v.bind()
}

常见误区

  • 以为 Raise 自动吞异常:普通 throw 不被转换。
  • 在作用域内 try/catch 后不转类型:局部处理与 typed 链割裂。

追问

  • 如何把异常转为 Raise 错误?答:用库提供的捕获/nonFatal 组合器包裹,映射为领域错误;具体 API 以 Arrow 版本为准。
  • 协程中异常如何传播?答:随协程作用域规则传播,与 Either 链衔接需显式捕获。

04.8.4.2-014 Either 与 Kotlin Result 如何选型?

一句话结论

需要错误类型分型、跨层组合与显式分支选 Either;只在局部包装可抛操作、错误以 Throwable 承载时用 Result。Either 错误是领域类型,Result 只能持 Throwable。

概念解释

Result 是标准库的成功/失败包装,失败侧固定为 Throwable;Either 左侧可为任意领域错误类型。Either 组合链与 Raise DSL 表达力更强;Result 与 runCatching 配合快速包裹异常。后端领域层优先 Either,工具局部可用 Result。

原理流程

  1. 评估错误是否需要类型分型。
  2. 需要领域错误层级 → Either。
  3. 仅包装异常 → Result。
  4. 边界处两类结果互相转换。

代码或图示

Either<DomainError, T>:错误可分型、可组合
Result<T>:失败为 Throwable,局部使用

常见误区

  • 把 Result 当跨层返回类型:错误被压成异常类型,分型能力弱。
  • Either 链中混入 Result 不转换:模型不一致。

追问

  • Result 有组合方法吗?答:有 map/组合扩展,但失败侧类型受限;能力对比以标准库版本为准。
  • 两者能互转吗?答:可在边界捕获 Throwable 映射 Either,反之把 Left 包装异常。

04.8.4.2-015 错误类型建模为什么常用 sealed class?

一句话结论

sealed class/interface 封闭错误层级,编译器可穷尽匹配分支,新增错误类型时强制补充处理;领域错误按场景分组为子类型,携带必要上下文。

概念解释

错误类型应表达"哪类失败、带什么信息"。sealed 层级让 when 表达式穷尽检查,遗漏分支编译报错。子数据类携带错误上下文(缺失字段、上游错误码)。避免用字符串错误码贯穿类型层。

原理流程

  1. 定义错误基类 sealed。
  2. 各失败场景建数据子类携带上下文。
  3. 业务函数返回 Either<Err, T>。
  4. 边界 when 穷尽匹配映射响应。

代码或图示

sealed class OrderError {
    data class InvalidQuantity(val qty: Int) : OrderError()
    data class OutOfStock(val sku: String) : OrderError()
    data class PaymentDeclined(val reason: String) : OrderError()
}

常见误区

  • 错误只用一个字符串枚举:上下文丢失,分支无法区分细节。
  • 错误层级过深过细:按处理方式分组,避免爆炸式子类。

追问

  • 错误如何携带上游异常?答:子类可持有 Throwable 引用用于日志,不直接对外暴露堆栈。
  • 新增错误类型影响哪些地方?答:穷尽 when 处编译提示补充分支,这正是 sealed 的价值。

04.8.4.2-016 Either 嵌套如何扁平化?

一句话结论

嵌套 Either 用 flatMap/flatten 拍平一层;多层嵌套说明步骤类型设计可优化,应在组合时统一左侧错误类型,避免 Either<E1, Either<E2, T>> 结构。

概念解释

map 只变换右侧可能产生嵌套;flatMap 直接返回 Either 避免套娃。嵌套让错误处理与映射层级混乱。聚合多个步骤时优先 Raise bind,天然保持单层 Either。

原理流程

  1. 识别嵌套结构 Either<E, Either<F, T>>。
  2. 用 flatten 或 flatMap 拍平。
  3. 统一左侧错误为共同父类型。
  4. 得到单层 Either。

代码或图示

val nested: Either<E, Either<F, T>> = ...
val flat: Either<EF, T> = nested.flatten().handleError { ... }

常见误区

  • 多层 map 叠加不拍平:调用方处理层级过深。
  • 左侧错误类型不一致:拍平前先映射到共同 sealed 类型。

追问

  • Raise 链会产生嵌套 Either 吗?答:bind 短路模型保持单层,减少套娃。
  • 嵌套 Option 同理吗?答:Option.flatMap 拍平嵌套 Option。

04.8.4.2-017 如何聚合 List 为整体结果?

一句话结论

用序列组合器遍历列表:全部 Right 收集为值列表,任一 Left 则短路返回首个错误;需要保留全部错误时用聚合收集所有 Left。

概念解释

常见两种语义:短路(首个失败即失败)与累积(收集全部错误)。Arrow 提供 sequence/traverse 类组合器按 Either 遍历集合。选择语义取决于业务:全部校验通过才继续,或汇总所有校验错误。

原理流程

  1. 列表元素为 Either。
  2. 短路组合:遇 Left 即返回。
  3. 累积组合:收集所有 Left 与右侧值。
  4. 输出聚合 Either 或错误集合。

代码或图示

// 示意:全部成功才收集(API 名称以 Arrow 版本为准)
val all: Either<Err, List<Item>> = items.traverse { validate(it) }

常见误区

  • 业务要汇总全部错误却用短路组合:后续错误被丢弃。
  • 累积结果不区分成功/失败分组:处理时遗漏部分成功项。

追问

  • 并行聚合 Either?答:Either 本身无并行语义;协程并行收集后再聚合结果,见并行组合题。
  • 空列表聚合结果?答:成功侧为空列表,按组合器约定处理。

04.8.4.2-018 多个 Either 如何并行组合?

一句话结论

Either 是纯值类型不含并发;并行执行各依赖用协程发起,收集各自结果后再用组合器合并为整体 Either。顺序组合与并行组合分开处理。

概念解释

函数式组合器按顺序串联;并行场景先在协程作用域并发调用,得到多个 Either,再 zip/聚合。并行失败时其他任务取消或结果保留按业务设计。不要在 Either 链内隐式起协程。

原理流程

  1. 协程作用域内并发调用各步骤。
  2. 收集 N 个 Either 结果。
  3. 组合器按全成功/错误聚合合并。
  4. 输出整体 Either。

代码或图示

runTest {
    val a = async { repoA.load() }
    val b = async { repoB.load() }
    val merged = listOf(a.await(), b.await()).sequence()
}

常见误区

  • 以为 Either 组合器自带并行:组合器只按值顺序处理。
  • 并行任务异常未纳入 Either:协程异常单独传播,需捕获转换。

追问

  • 并行下部分失败如何处理?答:按业务选择快速失败或收集失败集合;取消策略与资源释放配套。
  • 并行聚合与缓存/重试如何配合?答:各依赖独立重试/缓存后再聚合,见后续专题。

04.8.4.2-019 Either 在返回类型上的传播规则是什么?

一句话结论

Either 沿调用链向上传播:步骤返回的 Left 不经处理不会自动变成功;每层函数返回类型必须声明错误侧类型,调用方按类型分支或继续 bind。

概念解释

错误不会被框架吞掉:函数签名 Either<E, T> 表明可能失败。上层要么 bind 继续传同类错误,要么 handleError 转换/兜底。传播在类型层可见,编译期检查遗漏分支。

原理流程

  1. 内层函数返回 Left。
  2. 中层 bind 透传或映射错误。
  3. 上层收到 Either 后分支处理。
  4. 边界折叠为响应/默认值。

代码或图示

fun service(): Either<ServiceError, Dto> =
    repo.find(id).mapLeft { it.toServiceError() }

常见误区

  • 中层函数把 Either 吞成 null/默认值:错误上下文中断传播。
  • 错误侧类型逐层扩大不收敛:边界处理逻辑膨胀。

追问

  • 跨模块错误类型如何映射?答:模块间定义自身错误层级,边界处 mapLeft 转换为对外错误。
  • 不处理 Left 会怎样?答:类型上仍是 Either,调用方必须分支或取值,不会静默变成功。

04.8.4.2-020 nonFatal 捕获解决什么问题?

一句话结论

nonFatal 类判断把可恢复的异常与致命错误(如 JVM 退出、虚拟机错误)区分开,捕获组合器只包装非致命异常,避免把致命错误当作普通业务失败处理。

概念解释

Throwable 包含致命类型(虚拟机级错误)不应被业务捕获。捕获转换为 Either 时先过滤致命异常。具体判定集合与 API 名称以 Arrow 版本为准,不确定处标待确认。

原理流程

  1. 第三方调用抛出 Throwable。
  2. nonFatal 判断是否可恢复。
  3. 非致命转为 Left 错误。
  4. 致命异常继续向上传播。

代码或图示

// 示意:捕获并过滤(API 以 Arrow 当前版本为准)
val result: Either<Err, T> = Either.catch { risky() }.mapLeft { toDomain(it) }

常见误区

  • catch 所有 Throwable 包括致命错误:可能掩盖 JVM 级问题。
  • 把异常类型原样暴露给上层:应映射为领域错误。

追问

  • OutOfMemoryError 属于哪类?答:致命错误,不应在业务捕获清单内。
  • 捕获后异常堆栈还保留吗?答:错误子类可持有 cause 供日志记录。

04.8.4.2-021 option{} 块如何使用?

一句话结论

option { } 作用域内把可空值按 Option 模型组合:遇到 null 短路为 None,整体产出 Option;与 either{} 对应,用于纯缺失场景。

概念解释

option 作用域内 bind/取值在缺失时短路。链中多个可选值依赖时,块内串联避免嵌套 flatMap。不需要失败原因时用 Option 链,需要原因再升级 Either。

原理流程

  1. 进入 option 作用域。
  2. 各可选步骤 bind,None 即短路。
  3. 全部有值则组合为 Some。
  4. 输出 Option 结果。

代码或图示

val address: Option<Address> = option {
    val u = user.bind()
    val a = u.address.bind()
    a
}

常见误区

  • 在 option 块里区分失败原因:Option 不携带原因,应用 either。
  • 块内抛异常未处理:异常照常传播,不转 None。

追问

  • option 与 nullable 空安全哪个优先?答:简单局部用 ?./?:;多步组合用 option 块。
  • option 块 API 稳定性?答:以 Arrow 1.x 当前文档为准。

04.8.4.2-022 Raise 与依赖注入/上下文如何配合?

一句话结论

Raise 是函数作用域上下文,不替代 DI;依赖仍由容器/构造器注入,Raise 只在业务函数内部组织错误短路。作用域上下文与协程上下文是两套机制。

概念解释

DI 解决对象装配,Raise 解决函数内错误传播。构造器注入依赖后,业务函数在 Raise 块中调用依赖方法。不要把 Raise 接收者当服务定位器使用。

原理流程

  1. DI 容器装配依赖实例。
  2. 业务类构造器接收依赖。
  3. 方法内进入 either/raise 作用域调用依赖。
  4. 错误沿 Either 返回。

代码或图示

class UserService(private val repo: UserRepository) {
    fun get(id: Long): Either<Err, User> = either {
        repo.find(id).bind()
    }
}

常见误区

  • 在 Raise 作用域里取容器实例:混淆作用域上下文与 DI 容器。
  • 依赖方法本身抛异常未适配:进入 Raise 链前先捕获转换。

追问

  • Raise 接收者能跨函数传递吗?答:作为扩展接收者在同作用域函数间传递,具体作用域规则以库文档为准。
  • 协程上下文与 Raise 冲突吗?答:不冲突,Raise 是值级错误模型,协程上下文管理调度与作业。

04.8.4.2-023 Either 与协程如何结合?

一句话结论

挂起函数可返回 Either;协程负责调度与并发,Either 负责结果类型。在协程作用域内调用挂起步骤,bind 短路逻辑与协程取消、异常传播分别处理。

概念解释

Either 不含挂起能力,挂起步骤在协程内执行。组合挂起的 Either 步骤时,顺序链在协程作用域内 await;并行收集后聚合。协程取消与未捕获异常走协程机制,不混入 Either Left。

原理流程

  1. 挂起函数声明 suspend fun ...: Either<E, T>。
  2. 协程作用域内调用并 bind。
  3. 成功值继续,Left 短路。
  4. 协程异常单独捕获处理。

代码或图示

suspend fun order(id: Long): Either<Err, Order> = either {
    val user = userService.find(id).bind()
    val cart = cartService.load(user).bind()
    cart.toOrder()
}

常见误区

  • 把协程取消异常当业务 Left:CancellationException 不应纳入领域错误。
  • Either 链内阻塞调用挂起函数:保持挂起签名,不阻塞调度器。

追问

  • 挂起函数抛异常如何转 Either?答:在函数内捕获 nonFatal 异常映射 Left,再返回 Either。
  • 并行 Either 步骤如何组织?答:async 并发后聚合,见并行组合题。

04.8.4.2-024 错误恢复后如何重新进入 Raise 作用域?

一句话结论

在作用域外拿到 Left 后,可通过新的 either/raise 块调用恢复逻辑,把恢复结果再次纳入类型链;恢复步骤自身也可能失败,返回新的 Either。

概念解释

恢复不是在原短路点继续执行,而是基于错误值开启新计算。恢复策略(默认值、降级调用、重试)在新作用域组织。原作用域已短路结束,资源按作用域规则释放。

原理流程

  1. 原作用域返回 Left。
  2. 边界识别错误类型。
  3. 新作用域执行恢复步骤,可再次失败。
  4. 恢复结果进入上层链。

代码或图示

val result = service.find(id)
    .recover { err -> either { fallback().bind() } }

常见误区

  • 假设 raise 后块内后续代码可恢复执行:短路已退出,需新作用域。
  • 恢复逻辑吞掉原始错误:保留原错误用于日志与追溯。

追问

  • 重试属于恢复吗?答:是恢复策略的一种,按可重试错误分类后在新作用域/循环中执行。
  • 恢复后错误类型变化如何处理?答:mapLeft 统一为新错误层级。

04.8.4.2-025 测试中如何构造 Either 用例?

一句话结论

成功用例直接构造 Right(value),失败用例构造 Left(domainError);测试断言两侧分支,mock 依赖返回预设 Either,覆盖成功、各类错误与恢复路径。

概念解释

Either 是普通值,测试构造直接明确。依赖 mock 返回固定 Either 模拟成功/失败分支。断言检查右侧值或左侧错误类型与上下文。错误分支测试不依赖真实抛异常。

原理流程

  1. mock 依赖返回 Right 或 Left。
  2. 调用被测函数。
  3. 断言结果侧与内容。
  4. 覆盖恢复与短路路径。

代码或图示

every { repo.find(1) } returns Right(User(1, "Ann"))
every { repo.find(2) } returns Left(NotFound(2))

service.find(1) shouldBe Right(...)
service.find(2) shouldBe Left(NotFound(2))

常见误区

  • 只测 Right 分支:错误与恢复路径无覆盖。
  • 断言 Left 不查错误子类/上下文:错误细节丢失。

追问

  • Either 相等性如何断言?答:数据类错误与值实现 equals,直接 shouldBe 比较。
  • 测试需要模拟异常转 Either 吗?答:覆盖捕获转换分支时,mock 抛异常并断言 Left 映射结果。

04.8.4.2-026 JVM 受检异常在 Kotlin 中是什么状态?

一句话结论

Kotlin 没有受检异常:函数签名不声明可抛出的异常类型,异常按非受检方式传播;JVM 字节码层面仍可存在受检异常标记,但 Kotlin 编译器不强制捕获。

概念解释

Java 的 throws 约束在 Kotlin 类型系统中不强制。调用可能抛异常的代码不需要声明或捕获。这与 typed error 形成对比:异常失败不在签名可见,typed error 在返回类型显式建模。

原理流程

  1. Kotlin 函数调用 JVM 方法。
  2. 异常抛出沿栈传播。
  3. 编译器不检查是否捕获。
  4. 边界 try/catch 或转 Either。

代码或图示

Java:throws 声明 + 编译期检查
Kotlin:无受检异常,运行期传播

常见误区

  • 以为 Kotlin 接口方法能声明受检异常:语言不支持受检声明。
  • 依赖调用方记得捕获异常:未捕获异常在运行期暴露。

追问

  • Kotlin 调用 Java 受检方法要捕获吗?答:语言层面不强制,但实际异常仍需处理。
  • 跨 JVM 互操作注意什么?答:Java 侧按其受检规则理解 Kotlin 抛出的异常。

04.8.4.2-027 什么时候抛异常,什么时候返回 Either?

一句话结论

可预期、需调用方分支处理的业务失败返回 typed error;程序缺陷、不可预期的系统故障抛异常。边界处把异常转换为对外错误模型。

概念解释

判断标准:失败是否属于正常业务流程的一部分。参数非法、外部服务拒绝、资源缺失等可预期 → Either;空指针、状态不一致、编程错误 → 异常。混用会导致错误处理混乱。

原理流程

  1. 列举可能失败场景。
  2. 业务可预期 → 领域错误 + Either。
  3. 缺陷/故障 → 异常并记录。
  4. 对外边界统一转换响应错误。

代码或图示

可预期:校验失败、上游 4xx、未找到 → Either
缺陷:非法状态、类型错误、OOM → 异常

常见误区

  • 用异常做流程控制(循环/分支跳转):性能与可读性差。
  • 外部超时也建模为普通领域错误:应区分可重试系统错误与业务拒绝。

追问

  • 数据库连接失败算哪类?答:系统故障异常,边界捕获后映射为对外 5xx 错误。
  • 校验失败为什么不用异常?答:它是正常分支,签名暴露便于调用方处理与测试。

04.8.4.2-028 异常跨进程/跨边界如何传播?

一句话结论

异常不跨进程传播:跨服务/跨边界时序列化为错误响应(错误码、消息);进程内异常沿调用栈到边界被捕获,转换为 typed error 或响应错误模型。

概念解释

JVM 异常对象只在进程内存有效。对外边界把异常类型与消息映射为可传输错误结构。上层收到的是错误值而非异常对象。跨进程错误再由消费方按错误码处理。

原理流程

  1. 进程内异常抛出到边界。
  2. 边界捕获并分类。
  3. 序列化为错误响应(码、消息、traceId)。
  4. 消费方解析错误码进入本地处理链。

代码或图示

进程内:Exception → 边界捕获 → 错误响应 DTO
跨进程:错误码 + 消息 → 消费方解析 → 本地错误类型

常见误区

  • 把异常堆栈直接对外暴露:安全与信息泄露风险。
  • 跨进程依赖异常类型匹配:类型不在线程/进程间传递,按错误码协议对接。

追问

  • 错误响应模型在哪层定义?答:API 契约层定义 DTO,领域错误在服务层映射。
  • 跨进程重试/超时由谁处理?答:调用方按错误分类决策,见重试专题。

04.8.4.2-029 如何用 try/catch 把第三方库异常转为 Either?

一句话结论

在调用点用 try/catch(或库捕获组合器)包裹第三方调用,按异常类型映射为领域 Left;保留 cause 供日志,不在 Left 中暴露堆栈给业务上层。

概念解释

第三方库多抛异常,进入 typed 链前需要适配层。捕获后区分可恢复/不可恢复,映射对应领域错误。捕获范围最小化,不吞掉致命异常。

原理流程

  1. 包裹第三方调用。
  2. catch 匹配异常类型。
  3. 映射为领域错误 Left。
  4. 未匹配/致命异常继续传播。

代码或图示

fun call(): Either<GatewayError, Response> = try {
    Right(gateway.request())
} catch (e: IOException) {
    Left(GatewayError.Unavailable(e))
}

常见误区

  • catch(Throwable) 全吞:致命错误被掩盖。
  • 映射丢失原始异常:日志无法追溯根因,应保留 cause 引用。

追问

  • 超时异常映射为哪类错误?答:可重试的系统错误,与业务拒绝分开建模。
  • 捕获后需要日志吗?答:在适配层记录或由上层统一记录,避免重复打日志。

04.8.4.2-030 未捕获异常在协程中如何表现?

一句话结论

协程中未捕获异常按作用域规则传播:父作用域收到子协程异常,通常取消兄弟协程并向上抛出;结构化并发下异常不会静默吞掉,需在作用域内捕获或处理。

概念解释

协程异常传播与线程不同:子协程失败冒泡到父 Job,父作用域取消。SupervisorJob 可隔离子失败。进入 Either 链的挂起函数应在内部捕获转换,避免异常打断作用域。

原理流程

  1. 协程内代码抛出异常。
  2. 异常沿 Job 父子链传播。
  3. 普通作用域取消兄弟协程。
  4. 作用域异常处理器/上层捕获。

代码或图示

runCatching {
    scope.launch { risky() }
}.onFailure { /* 处理未捕获异常 */ }

常见误区

  • 以为 launch 的异常被静默忽略:未捕获会传播取消作用域。
  • 在 Either 函数内不捕获:异常绕过 Left 链向上冒泡。

追问

  • SupervisorJob 行为区别?答:子失败不影响兄弟,按隔离需求选择。
  • CancellationException 要捕获吗?答:不应作为业务错误捕获,取消需正常传播。

04.8.4.2-031 异常与错误日志应在什么时机记录?

一句话结论

异常在边界捕获点记录上下文与堆栈;typed error 在决策点按需记录,避免每个短路步骤重复打日志。日志记录点与错误处理职责分离。

概念解释

Either 链中途的 Left 不立刻打日志,避免错误在传播路径重复记录;边界根据错误等级决定日志内容。异常日志含堆栈,typed error 日志含错误类型与上下文。

原理流程

  1. 步骤产生 typed error 沿链传播。
  2. 边界分类错误等级。
  3. 异常在捕获点记录堆栈与上下文。
  4. 日志附带 traceId 与关键业务标识。

代码或图示

中途 Left:不重复日志
边界:按错误级别记录类型/上下文/traceId
异常:捕获点记录堆栈

常见误区

  • 每步 bind 失败都打日志:同一错误多条重复记录。
  • 日志只打消息不带错误类型:排查无法归类。

追问

  • 可重试错误需要日志吗?答:记录重试次数与最终结果,避免每次重试刷屏。
  • 日志记录在映射前还是后?答:保留原始错误上下文,映射后记录领域错误与 cause。

04.8.4.2-032 错误信息不可序列化时如何建模?

一句话结论

对外可传输的错误用可序列化数据类(错误码、消息、上下文字段);不可序列化的内部细节(异常对象、连接句柄)不进错误模型,仅在日志侧保留。

概念解释

领域错误分层:内部错误类型可持 Throwable;对外 DTO 只含可序列化字段。跨进程/持久化的错误模型必须纯数据。异常 cause 不随响应外发,日志侧关联 traceId 追溯。

原理流程

  1. 内部领域错误持上下文与 cause。
  2. 边界映射为可序列化错误 DTO。
  3. DTO 含稳定错误码与展示消息。
  4. 内部细节留在日志与监控。

代码或图示

// 内部:可持 cause
data class DbError(val cause: Throwable) : OrderError()

// 对外:纯数据
data class ErrorResponse(val code: String, val message: String)

常见误区

  • 把异常类名/堆栈写进响应模型:不可序列化且泄露内部信息。
  • 错误模型含运行期句柄:跨进程传输失败。

追问

  • 错误消息国际化放哪层?答:响应 DTO 错误码,消息在展示层翻译;内部日志保留原文。
  • 错误码如何版本化?答:对外契约管理,新增错误码不破坏既有消费方。

04.8.4.2-033 Kotlin Result 类型有哪些设计约束?

一句话结论

Result<T> 是成功值与失败 Throwable 的包装,失败侧固定为 Throwable;它面向包装可抛操作,设计上不提供领域错误分型与丰富的链式错误映射。

概念解释

Result 由 runCatching 产出,封装成功值或捕获异常。其 API 偏局部容错,错误只能是 Throwable。作为跨层返回类型时,调用方仍需拆解异常类型,组合能力弱于 Either。

原理流程

  1. runCatching 执行块捕获异常。
  2. 成功包装为 success,失败包装 failure。
  3. map/组合操作处理两侧。
  4. 边界 getOrThrow/getOrElse 取值。

代码或图示

val result: Result<User> = runCatching { repo.find(1) }

常见误区

  • 期待 Result 携带业务错误枚举:失败侧只接受 Throwable。
  • 在热路径过度包装 Result:分配与异常捕获成本需评估。

追问

  • Result 与 Arrow Either 能互转吗?答:边界处捕获/解包互相映射。
  • 标准库 Result API 随版本变化吗?答:以当前 Kotlin 标准库文档为准。

04.8.4.2-034 Result 作为普通返回值有什么历史限制?

一句话结论

早期 Kotlin 版本对 Result 作为公开函数返回类型有编译器限制(如不允许普通位置使用、需要特殊注解),目的是避免与受检异常语义混淆;当前版本允许范围以标准库文档为准,标待确认。

概念解释

Result 最初设计为内联使用的容错包装,作为跨模块公开返回值曾受限。现代工程若要跨层传递失败信息,Either 的领域错误分型更合适。具体编译器限制随版本放宽,落地前核对当前文档。

原理流程

  1. 确认当前 Kotlin 版本对 Result 位置的规则。
  2. 公开返回类型评估是否合法。
  3. 受限或分型不足时改用 Either。
  4. 局部容错保留 runCatching。

代码或图示

待确认:当前 Kotlin 版本对 Result 作为 public 返回类型的具体约束

常见误区

  • 照搬旧博客写法:版本规则已变,以当前编译器行为为准。
  • 用 Result 做跨层契约:错误分型与限制都不如 Either。

追问

  • 如何验证限制是否存在?答:写最小公开返回 Result 的函数编译验证,以编译器报错为准。
  • 内联函数内使用 Result 有何不同?答:内联场景不受部分位置限制,具体规则查标准库文档。

04.8.4.2-035 Result 为什么没有错误类型分型?

一句话结论

Result 失败侧类型固定为 Throwable,无法在类型层面区分业务错误种类;要按错误类型分支,只能运行期 instanceof 判断,编译期不检查穷尽性。

概念解释

Typed error 的价值是错误种类进入类型签名;Result 把失败统一压成异常对象,丢失领域分型。sealed 错误层级配合 Either 才能让编译器检查分支覆盖。Result 适合"成功/失败"二元容错,不适合复杂错误决策。

原理流程

  1. Result.failure 持 Throwable。
  2. 分支时运行期判断异常类型。
  3. 新增错误类型无编译提醒。
  4. 复杂错误映射在边界手工完成。

代码或图示

result.exceptionOrNull()?.let { ex ->
    when (ex) { /* 运行期类型判断 */ }
}

常见误区

  • 给 Throwable 加业务枚举字段伪装分型:类型层仍不可见,不如 Either sealed。
  • 依赖异常 message 字符串判断错误:脆弱且不可穷尽。

追问

  • 局部容错后如何升级为 Either?答:解包 Result,按异常类型映射领域错误 Left。
  • 标准库未来会增强 Result 分型吗?答:以官方演进为准,不臆测路线。

04.8.4.2-036 Result 的链式组合能力有什么不足?

一句话结论

Result 提供基础 map/flatMap,但失败侧固定 Throwable,跨步骤组合时无法按领域错误类型短路与聚合;复杂多步流程组合可读性与类型安全弱于 Either/Raise。

概念解释

Result 链中失败始终是异常包装,步骤间错误类型无法统一为 sealed 层级。需要错误映射、聚合、恢复策略时,仍要拆包判断异常类型。Either 的 flatMap 与 Raise bind 为领域错误设计,组合更直接。

原理流程

  1. Result 链逐步 map/flatMap。
  2. 失败侧保持 Throwable。
  3. 错误分支需运行期拆包判断。
  4. 复杂流程嵌套与类型检查不足。

代码或图示

// Result 链:失败侧不可分型
runCatching { a() }.map { b(it) }.flatMapCatching { c(it) }

常见误区

  • 多步业务流程全用 Result 串联:错误决策点难以类型化表达。
  • 把异常类型判断散落在链中:应在边界统一映射。

追问

  • Result 有 zip 类组合吗?答:标准库组合能力有限,多结果聚合可借助扩展库,以当前版本为准。
  • 局部步骤用 Result、跨层用 Either 可行吗?答:可在边界转换,注意模型分界清晰。

04.8.4.2-037 runCatching 与协程如何配合?

一句话结论

runCatching 捕获块内抛出的非受检异常;在协程中包裹挂起调用时,注意不要吞掉 CancellationException,取消信号应正常传播。

概念解释

runCatching 是同步容错包装,可包裹挂起函数调用(块内允许挂起)。协程取消异常属于控制流,不应被当作失败结果保留。需要把业务异常转 Either 时,在挂起函数内显式捕获并过滤取消异常。

原理流程

  1. 挂起函数内 runCatching 包裹调用。
  2. 普通异常被包装为 Result.failure。
  3. 取消异常识别后重新抛出。
  4. 结果按 Either/Result 模型返回。

代码或图示

suspend fun load(): Result<Data> = runCatching {
    api.fetch() // 挂起调用
}

常见误区

  • runCatching 吞掉 CancellationException:协程取消被阻断,作用域行为异常。
  • 在 launch 内 runCatching 后不处理失败:异常包装后仍需上报或记录。

追问

  • 如何识别取消异常?答:判断类型为 CancellationException 后重新抛出,具体类以协程库版本为准。
  • runCatching 能捕获 Error 吗?答:按其实现捕获范围确认,致命错误不应纳入业务容错。

04.8.4.2-038 异常与 typed error 的边界总结应如何把握?

一句话结论

进程内部分层:领域与可预期失败用 typed error 沿值传播;不可预期缺陷抛异常;对外边界把两者统一映射为错误响应。边界清晰才能兼顾类型安全与故障兜底。

概念解释

边界分三层:领域内部 typed error,基础设施异常适配,对外响应模型。每层错误模型不混用。typed error 可测试、可穷尽;异常负责程序缺陷与系统故障。日志与监控在边界汇总。

原理流程

  1. 领域函数返回 typed error。
  2. 基础设施适配层捕获异常转领域错误。
  3. 边界把领域错误映射响应 DTO。
  4. 未捕获异常由全局兜底处理。

代码或图示

领域:Either<DomainErr, T>
适配:异常 → DomainErr
边界:DomainErr → ErrorResponse
兜底:未捕获异常 → 5xx + 日志

常见误区

  • 领域层直接抛框架异常:跨层耦合,类型不可见。
  • 边界不做兜底:未捕获异常直接暴露给调用方。

追问

  • 日志在哪一层打?答:适配/边界记录,领域步骤不重复打。
  • 错误监控按什么分类?答:领域错误码 + 异常类型,分别统计业务失败与系统故障。

04.8.4.2-039 重试适用于什么场景,有什么禁忌?

一句话结论

重试适用于瞬时故障(网络抖动、临时不可用、5xx)且操作幂等;禁忌用于非幂等写操作、确定性业务失败(4xx/校验错误)与不可恢复故障。

概念解释

重试是对瞬时失败的恢复策略,不是修复错误的手段。非幂等操作重试可能造成重复下单/扣款。业务拒绝类错误重试无意义且放大负载。重试前先判断错误分类与幂等性。

原理流程

  1. 调用失败取得错误分类。
  2. 瞬时 + 幂等 → 进入重试。
  3. 业务失败/非幂等 → 直接返回错误。
  4. 超过预算仍失败 → 上报并降级。

代码或图示

可重试:连接超时、503、限流退避后恢复
不重试:参数错误、业务拒绝、重复提交风险

常见误区

  • 对所有失败无脑重试:非幂等写产生重复副作用。
  • 把重试当稳定性主要手段:根因未除,重试只是缓冲。

追问

  • 读操作一定幂等吗?答:多数读幂等,仍需确认是否带副作用。
  • 重试次数配置在哪?答:调用方配置,按依赖与错误类型区分。

04.8.4.2-040 指数退避的退避公式是什么?

一句话结论

指数退避按 delay = base * factor^n 递增等待时间,第 n 次重试前等待随次数指数增长,避免固定间隔持续冲击故障依赖。

概念解释

初始等待短,失败越多等待越长,给下游恢复时间。factor 常见 2 左右,配合上限封顶。退避计算基于重试次数,不包含抖动。具体参数按依赖容量与 SLA 调整。

原理流程

  1. 首次失败记录重试计数。
  2. 第 n 次等待 base * factor^n。
  3. 等待时间不超过上限。
  4. 到达次数上限停止重试。

代码或图示

delay(n) = min(base * 2^n, maxDelay)
示例:base=100ms, factor=2 → 100, 200, 400, 800ms(封顶)

常见误区

  • 退避不封顶:下游长时间故障时等待无限增长。
  • 固定间隔重试:故障恢复期间持续施压,加剧雪崩。

追问

  • 初始间隔怎么定?答:按下游响应时间与超时预算评估,从较小值开始。
  • 指数退避与超时预算关系?答:总等待 + 调用时间不超过整体超时预算。

04.8.4.2-041 抖动(jitter)解决什么问题?

一句话结论

抖动在退避等待上加入随机量,避免大量客户端在同一时刻同步重试(惊群),把重试时刻打散到时间窗口内。

概念解释

纯指数退避下各客户端按相同节奏重试,故障恢复瞬间集中打向依赖。jitter 在退避区间内随机取值,错开重试时刻。常见策略:全抖动(0 到退避值)或均衡抖动(半基线 + 半随机)。

原理流程

  1. 计算指数退避基线。
  2. 按抖动策略在区间内随机取值。
  3. 等待随机后的时长再重试。
  4. 多客户端重试时刻分散。

代码或图示

无抖动:所有客户端 200ms 后同时重试
加抖动:等待在 [0, 200ms] 区间随机分布

常见误区

  • 去掉 jitter 只留指数退避:同步重试问题未解决。
  • 抖动范围过大:单次重试等待不可控,拉长整体延迟。

追问

  • 抖动随机源需要固定种子吗?答:生产用随机源;测试中固定时间/虚拟时间验证退避序列。
  • 抖动会影响退避单调性吗?答:随机化后单次间隔不严格递增,整体趋势仍随次数增长。

04.8.4.2-042 最大重试次数与超时预算如何设定?

一句话结论

重试次数与单次超时共同受整体超时预算约束:总预算 ≈ 调用耗时 + 退避等待累计;次数上限防止无限重试,整体超时切断超出预算的链路。

概念解释

重试不是独立参数,要与调用超时、上游 SLA 一起算。次数过多叠加退避会让请求长尾严重。先定整体超时预算,再反推可承受的重试次数与单次超时。

原理流程

  1. 确定链路整体超时预算。
  2. 估算单次调用耗时与退避累计。
  3. 反推最大重试次数。
  4. 整体超时作为兜底切断。

代码或图示

预算 = 单次超时 × (次数+1) + 退避等待累计
超出预算:停止重试,返回降级/错误

常见误区

  • 只配重试次数不配整体超时:长尾请求拖垮线程。
  • 重试次数按经验拍脑袋:应结合下游恢复时间与预算计算。

追问

  • 重试期间上游已超时怎么办?答:整体超时优先,重试随请求取消停止。
  • 不同依赖重试预算不同吗?答:按依赖关键性与 SLA 分别配置。

04.8.4.2-043 哪些错误分类为可重试?

一句话结论

网络瞬时错误、连接失败、限流(429)、服务端 5xx、超时等可重试;参数错误(4xx)、业务拒绝、确定性数据冲突不可重试。分类在适配层明确映射。

概念解释

可重试错误具有"稍后可能成功"的特征;不可重试错误重试结果不变。错误分类决定是否进入重试链。上游错误码与本地异常类型都要映射到分类枚举。

原理流程

  1. 调用失败取得错误类型/状态码。
  2. 分类器判断可重试性。
  3. 可重试进入退避循环。
  4. 不可重试直接返回错误。

代码或图示

可重试:IOException、503、429、Timeout
不可重试:400、404、业务规则拒绝、校验失败

常见误区

  • 把 404 当瞬时错误重试:确定性失败,重试无意义。
  • 不区分 500 与业务 5xx:部分 5xx 是确定性配置错误,需结合日志判断。

追问

  • 限流响应如何配合重试?答:读取 Retry-After 类头信息调整退避,具体协议按依赖约定。
  • 分类规则放哪层?答:客户端适配层统一判断,业务层只看到分类后的错误。

04.8.4.2-044 Arrow 提供哪些重试能力?

一句话结论

Arrow 提供重试相关组合器(如 retry/retryOnce 类 API),按策略重复执行可恢复计算;具体函数名、策略配置与模块归属以 Arrow 1.x 当前文档为准,不臆造坐标。

概念解释

重试组合器包裹一段可能失败的计算,按错误分类、退避与次数策略重复执行。返回最终成功值或最后一次错误。策略(次数、退避、抖动、错误过滤)作为参数配置。

原理流程

  1. 定义重试策略:次数、退避、抖动、可重试错误判断。
  2. 组合器包裹计算块。
  3. 失败按策略等待并重试。
  4. 成功返回值,耗尽返回错误。

代码或图示

// 示意:重试策略包裹调用(API 名称以 Arrow 文档为准)
val result = retry(
    policy = RetryPolicy(maxRetries = 3, backoff = ExponentialBackoff)
) {
    gateway.request()
}

常见误区

  • 未核对当前版本 API 名称:不同 Arrow 版本重试模块可能调整。
  • 重试组合器内做非幂等写:重复副作用风险。

追问

  • 重试能力在哪个模块?答:以官方文档模块划分(core/fx 或独立重试模块)为准。
  • 没有现成组合器怎么办?答:在协程作用域内手写退避循环,错误分类与预算自行控制。

04.8.4.2-045 重试与协程 delay、虚拟时间如何配合?

一句话结论

重试等待用协程 delay 挂起等待,不阻塞线程;测试中用 runTest 虚拟时间推进退避,无需真实等待即可验证重试次数与间隔。

概念解释

挂起重试循环在协程内 delay 等待,释放线程。测试调度器虚拟时间让退避瞬间推进,断言重试序列。重试逻辑必须是挂起安全的,等待可被取消。

原理流程

  1. 协程内失败后计算退避时长。
  2. delay(backoff) 挂起等待。
  3. 虚拟时间测试中推进到期。
  4. 再次执行调用。

代码或图示

runTest {
    val result = service.callWithRetry()
    // 虚拟时间下立即验证重试后的结果
}

常见误区

  • 重试等待用 Thread.sleep:阻塞线程,协程取消无法及时响应。
  • 测试真实等待退避时长:用虚拟时间替代。

追问

  • 重试等待可被取消吗?答:delay 响应协程取消,请求取消时重试停止。
  • 退避序列如何断言?答:测试调度器记录等待时长,核对指数与抖动分布。

04.8.4.2-046 重试前需要重置哪些状态?

一句话结论

重试应重新发起独立请求:连接、请求体、临时状态不复用上次失败残留;有状态的客户端需确认失败后连接可用,必要时重建。

概念解释

失败可能留下半完成请求或损坏连接。重试不是简单重放同一对象,而是构造新的调用上下文。请求体若含非幂等标识,需保证重试使用同一幂等键而非重复提交。

原理流程

  1. 首次调用失败。
  2. 清理/重建连接与临时状态。
  3. 构造新的请求上下文。
  4. 按退避后再次调用。

代码或图示

失败 → 连接状态检查/重建 → 新请求上下文 → 重试

常见误区

  • 复用失败的连接对象:半损坏状态导致后续重试异常。
  • 重试重复生成新业务标识:应保留原幂等键。

追问

  • 无状态 HTTP 客户端需要重置吗?答:客户端实例通常可复用,请求对象每次新建。
  • 重试中事务回滚了吗?答:本地事务在失败时已回滚,重试开启新事务。

04.8.4.2-047 重试过程如何观测与记录指标?

一句话结论

记录重试次数、最终成功/失败、退避等待与错误分类;指标区分首次成功与重试后成功,日志避免每次重试刷屏,最终结果汇总上报。

概念解释

可观测性回答"重试是否在兜底、哪些依赖频繁重试"。指标按依赖/错误类型统计重试率;日志记录首次失败原因与最终结果。重试中间过程采样记录,避免日志膨胀。

原理流程

  1. 每次失败记录错误分类。
  2. 累计重试次数与等待时长。
  3. 成功/失败上报指标。
  4. 日志在最终结果点汇总上下文。

代码或图示

指标:retry.count、retry.successAfterRetry、retry.exhausted
日志:首次错误 + 重试次数 + 最终结果

常见误区

  • 每次重试打完整错误日志:同一请求多条重复堆栈。
  • 只记录最终失败:看不到依赖瞬时故障频率。

追问

  • 重试指标按什么维度聚合?答:依赖、操作、错误类型;按监控看板需求设计。
  • 重试次数过高说明什么?答:下游不稳定或错误分类过宽,需排查根因而非加次数。

04.8.4.2-048 熔断与重试的边界是什么?

一句话结论

重试处理单次瞬时失败,熔断在依赖持续故障时快速失败、停止调用以保护下游与自身;两者配合:重试兜底抖动,熔断阻断持续性故障。

概念解释

重试在短时间内重复尝试;熔断器统计失败率,打开后直接拒绝调用,给下游恢复时间。故障期无限重试会压垮依赖。熔断状态(关闭/打开/半开)独立于重试策略。

原理流程

  1. 单次失败先走重试策略。
  2. 持续失败累计触发熔断。
  3. 熔断打开期间直接快速失败。
  4. 半开状态放行探测请求验证恢复。

代码或图示

单次抖动:重试
持续故障:熔断打开 → 快速失败 → 半开探测

常见误区

  • 只加重试不加熔断:下游故障时请求全部阻塞在重试等待中。
  • 熔断打开仍让重试循环进入:应先经过熔断判断。

追问

  • 熔断状态存在哪里?答:按客户端实例/作用域维护,跨实例一致性有限;具体实现见 09 分册流量治理。
  • 熔断与超时关系?答:熔断减少无效调用,超时切断单次等待,两者互补。

04.8.4.2-049 如何防护重试风暴?

一句话结论

控制重试次数与退避抖动、设置整体超时、配合熔断与并发上限;避免多层调用各自盲目重试导致请求放大。

概念解释

重试风暴来自多服务链式重试:每层重试放大请求量。防护手段:限制重试预算、抖动打散、熔断快速失败、入口并发控制。重试策略在调用边界统一评审。

原理流程

  1. 单层重试有次数/预算上限。
  2. 抖动分散时刻。
  3. 熔断阻断持续故障。
  4. 链路上层不叠加无界重试。

代码或图示

防护:次数上限 + 退避抖动 + 整体超时 + 熔断 + 并发限流

常见误区

  • 每个下游客户端都配最大重试:链路相乘放大请求。
  • 故障期重试仍全量放行:缺乏熔断兜底。

追问

  • 上下游重试如何协调?答:上游超时预算大于下游重试总时长,避免上游先超时下游仍重试。
  • 重试风暴监控看什么?答:依赖请求量、失败率、等待线程数异常增长。

04.8.4.2-050 幂等键如何配合重试?

一句话结论

写操作重试携带稳定幂等键,下游按键去重:重复请求返回首次结果而不重复执行副作用;重试安全的前提是操作可幂等且键贯穿重试链。

概念解释

幂等键标识同一业务意图,重试多次提交同一键。下游记录键与首次结果,重复请求直接返回。无幂等键的写操作不应自动重试。键在请求生成时确定,重试复用。

原理流程

  1. 业务发起写操作生成幂等键。
  2. 首次调用携带键。
  3. 重试复用同一键。
  4. 下游按键去重,重复请求不重复生效。

代码或图示

submit(idempotencyKey, request)
失败重试 → 同 key 再次提交 → 下游返回首次结果

常见误区

  • 重试时重新生成业务单号:下游视为新请求,重复生效。
  • 幂等键只在客户端生成不传下游:去重无法落地。

追问

  • 幂等键有效期多长?答:按下游保留策略,覆盖重试与恢复窗口。
  • 读操作需要幂等键吗?答:读天然幂等;带副作用的读接口需单独评估。

04.8.4.2-051 Caffeine 在 Kotlin/JVM 后端如何落地?

一句话结论

Caffeine 是 JVM 高性能内存缓存库,Kotlin 后端通过其 Java API 构建缓存实例,配置过期、容量与淘汰策略;缓存实例作为依赖注入到服务层。

概念解释

Caffeine 提供进程内本地缓存实现,支持 W-TinyLFU 淘汰、异步加载、统计。Kotlin 调用其建造器 API 配置 key/value 与策略。本地缓存不跨实例共享,分布式场景配合远端缓存。

原理流程

  1. 引入 Caffeine 依赖。
  2. 建造器配置容量、过期、刷新规则。
  3. 缓存实例注入服务。
  4. get 时加载、命中返回缓存值。

代码或图示

val cache: Cache<Long, User> = Caffeine.newBuilder()
    .expireAfterWrite(Duration.ofMinutes(10))
    .maximumSize(10_000)
    .build()

常见误区

  • 把本地缓存当分布式共享缓存:多实例各持一份,一致性有限。
  • 缓存实例散落各处创建:应单例装配统一配置。

追问

  • Caffeine 坐标与版本?答:以 Maven 仓库当前版本为准;本批不写死版本号。
  • Kotlin 有专用缓存封装吗?答:部分库在 Caffeine 上做协程封装,见协程缓存题。

04.8.4.2-052 缓存 key 与 value 如何设计?

一句话结论

key 应唯一标识缓存数据且不可变,含必要维度(标识 + 分区/版本);value 存不可变快照,避免外部修改污染缓存内容。

概念解释

key 设计要区分不同业务维度,避免不同数据碰撞。value 若可变,被调用方修改会影响缓存中其他读取者。缓存对象应视为不可变快照,或拷贝出入。

原理流程

  1. 按业务唯一性构造 key。
  2. value 存放不可变数据快照。
  3. 加载时组装缓存对象。
  4. 读取方不修改缓存实例。

代码或图示

data class UserKey(val tenantId: Long, val userId: Long)
// value:User 快照,字段只读

常见误区

  • key 只用部分标识:多租户/多环境数据碰撞。
  • value 用可变集合直接缓存:外部改写污染缓存。

追问

  • key 需要实现 equals/hashCode 吗?答:自定义 key 必须正确实现相等性,或用记录类型/字符串组合。
  • value 过大如何处理?答:评估容量与序列化成本,大对象拆分缓存或不缓存。

04.8.4.2-053 缓存过期策略有哪些?

一句话结论

常见按写入后时间(expireAfterWrite)、最后访问时间(expireAfterAccess)过期;可选刷新机制在过期前异步刷新。策略按数据时效性要求选择。

概念解释

write 过期保证数据不超过最大年龄;access 过期保留热点数据,长期未访问淘汰。刷新(refreshAfterWrite)在下次访问时异步重载,与删除过期不同。过期策略与容量淘汰共同作用。

原理流程

  1. 配置过期基准时间。
  2. 写入/访问时更新时间戳。
  3. 后台清理过期条目。
  4. 过期后下次访问重新加载。

代码或图示

Caffeine.newBuilder()
    .expireAfterAccess(Duration.ofMinutes(5))
    .refreshAfterWrite(Duration.ofMinutes(2))

常见误区

  • 时效性强的数据不设写过期:陈旧数据长期驻留。
  • 访问过期导致热点永不过期:变更数据需配合主动失效。

追问

  • 过期与刷新区别?答:过期删除后同步加载;刷新异步更新,旧值短暂可用。
  • 如何处理数据主动变更?答:主动失效对应 key,不只依赖 TTL。

04.8.4.2-054 最大容量与淘汰策略如何配置?

一句话结论

maximumSize 限定条目数,Caffeine 按 W-TinyLFU 策略淘汰低频条目;容量按内存预算与热点规模设定,避免缓存撑爆堆内存。

概念解释

缓存容量受 JVM 堆约束。淘汰策略优先保留高频访问条目。设置过小命中率低,过大占用内存。可按权重估算每条目大小调整容量。

原理流程

  1. 估算热点条目数与单条内存。
  2. 设定 maximumSize/权重上限。
  3. 超容量时淘汰低频条目。
  4. 监控命中率与内存占用调参。

代码或图示

Caffeine.newBuilder()
    .maximumWeight(10_000_000)
    .weigher { _, v -> (v as Any).toString().length }

常见误区

  • 不设容量上限:内存无限增长风险。
  • 容量只看条目数忽略 value 大小:大对象场景内存估算失真。

追问

  • 淘汰指标能监控吗?答:Caffeine 统计记录 eviction/命中数据,开启统计后读取。
  • 热点突变导致频繁淘汰怎么办?答:调整容量或评估本地缓存适用性。

04.8.4.2-055 缓存空值如何防穿透?

一句话结论

对查询不到的结果缓存空标记/空对象并设较短 TTL,避免不存在的 key 反复打到下游;同时区分"空值"与"未缓存",防止空缓存长期掩盖新建数据。

概念解释

缓存穿透指大量查询不存在的数据,缓存不命中全部压到下游。空值缓存用短 TTL 限制空结果停留时间。空对象需与真实值区分,数据新增后能被刷新。

原理流程

  1. 下游查询返回缺失。
  2. 缓存空标记 + 短过期。
  3. 后续相同查询命中空标记,不再打下游。
  4. 空标记过期后回源查询。

代码或图示

// 空值用特殊标记包装(示意)
sealed class CacheValue<out T>
data class Hit<T>(val value: T) : CacheValue<T>()
object Miss : CacheValue<Nothing>()

常见误区

  • 空值 TTL 与正常值相同:缺失数据长期不被刷新。
  • 不缓存空值:恶意/批量不存在查询穿透下游。

追问

  • 布隆过滤器适用场景?答:大规模不存在 key 拦截,属额外组件,见 09 分册。
  • 空值缓存与缓存击穿防护区别?答:穿透防不存在 key,击穿防热点 key 失效并发回填。

04.8.4.2-056 热点 key 击穿(stampede)如何处理?

一句话结论

单个热点 key 过期瞬间大量并发同时回源(击穿);用单飞(singleflight)合并同一 key 的并发加载,只放一个请求回源,其余等待结果。

概念解释

缓存失效瞬间并发请求都未命中,同时打向下游。合并加载让同一 key 只有一个回填任务,其他协程等待同一结果。本地缓存按 key 做并发去重;远端缓存用锁/单飞机制。

原理流程

  1. 并发请求同 key 未命中。
  2. 单飞结构按 key 登记进行中的加载任务。
  3. 首个请求回源,其余等待同一 Deferred。
  4. 结果完成后全部共享。

代码或图示

并发请求 key=1 ──▶ 仅 1 个回源任务 ──▶ 结果共享等待者

常见误区

  • 每个未命中请求独立回源:热点过期瞬间压垮下游。
  • 单飞锁粒度太粗:不同 key 被串行化,降低并发。

追问

  • 本地缓存单飞如何实现?答:按 key 维护进行中 Deferred/未来值,完成后放入缓存。
  • 单飞失败如何处理?答:回源失败应释放登记,允许后续重试;失败结果不长期缓存。

04.8.4.2-057 协程场景下如何缓存挂起计算结果?

一句话结论

缓存挂起函数结果时,值以完成的 Deferred/结果形式缓存,并发访问共享同一挂起任务;避免缓存 suspend 函数引用导致每次调用重新挂起。

概念解释

普通缓存存计算值;协程加载是异步的,需缓存"已完成的异步结果"或进行中任务。加载器挂起执行回源,结果存入缓存。单飞与缓存结合:进行中任务与完成结果都按 key 管理。

原理流程

  1. 未命中时启动挂起加载任务。
  2. 进行中任务按 key 登记。
  3. 完成后结果入缓存。
  4. 后续命中直接取结果。

代码或图示

suspend fun get(id: Long): User =
    cache.getOrSuspend(id) { repo.find(id) ?: miss() }

常见误区

  • 缓存 suspend () -> T 函数引用:调用方仍各自挂起执行,未共享结果。
  • 缓存未完成的 Deferred 异常状态:失败任务需可重试,不长期驻留。

追问

  • Caffeine 有异步加载支持吗?答:有 AsyncCache 类 API 提供 CompletableFuture 集成;协程适配需桥接,具体以库版本为准。
  • 协程缓存库有哪些?答:社区有基于 Caffeine 的协程封装,选型按工程依赖评估。

04.8.4.2-058 缓存一致性与失效更新策略如何选择?

一句话结论

常见策略:更新数据库后失效缓存(Cache-Aside),读取时回源;写入时更新缓存需考虑并发与多实例。本地缓存多实例间不自动同步,主动失效需广播或短 TTL 兜底。

概念解释

Cache-Aside:读先查缓存,未命中回源回填;写先更新库再删缓存。写后更新缓存在并发下易脏读。本地缓存各实例独立,删缓存只影响本实例,其他实例靠 TTL 最终一致。

原理流程

  1. 读:缓存命中返回,未命中回源回填。
  2. 写:更新数据库。
  3. 删除对应缓存条目。
  4. 其他实例待 TTL 过期或接收失效通知。

代码或图示

读:cache → miss → DB → 回填
写:DB 更新 → 删 cache

常见误区

  • 写库失败仍删/更缓存:缓存与库不一致。
  • 多实例本地缓存假设实时一致:需失效广播或接受 TTL 窗口。

追问

  • 先删缓存再写库有什么风险?答:并发读回填旧值,通常先写库再删缓存。
  • 缓存与数据库双写一致性要求高怎么办?答:评估远端缓存 + 失效通知,本地缓存只做热点加速。

04.8.4.2-059 本地缓存与多级缓存如何配合?

一句话结论

本地缓存(Caffeine)挡热点低延迟访问,远端缓存(Redis 类)跨实例共享;多级查询先本地后远端再数据库,各级 TTL 与失效策略分层配置。

概念解释

本地缓存快但不共享、容量受限;远端缓存共享但有网络开销。多级缓存降低数据库压力,也带来一致性层级问题。后端工程按数据热点与一致性要求决定是否引入多级。

原理流程

  1. 查本地缓存。
  2. 未命中查远端缓存。
  3. 再未命中回源数据库。
  4. 逐级回填。

代码或图示

请求 → 本地缓存 → 远端缓存 → 数据库
回填:DB → 远端 → 本地

常见误区

  • 多级缓存各级策略不协调:同一数据过期窗口叠加不一致。
  • 本地缓存长时间持有远端已失效数据:缩短本地 TTL 或配失效通知。

追问

  • 多级缓存击穿如何防护?答:各级分别单飞,避免穿透到数据库。
  • 本节为何不展开远端缓存理论?答:通用缓存架构见 09 分册,本节聚焦 Kotlin 本地库落地。

04.8.4.2-060 缓存监控看哪些指标?

一句话结论

核心指标:命中率/未命中率、加载次数、回填耗时、淘汰数、缓存大小与内存占用;按 key 维度识别热点与异常回源。

概念解释

命中率判断缓存是否有效;未命中突增可能是过期策略问题或流量变化。回填耗时与下游压力相关。淘汰数反映容量是否不足。指标配合业务量趋势分析。

原理流程

  1. 开启缓存统计。
  2. 采集命中/未命中/淘汰计数。
  3. 监控缓存大小与加载耗时。
  4. 按指标调整容量与 TTL。

代码或图示

hit rate = hits / (hits + misses)
监控:命中率、回填次数、淘汰条目、内存占用

常见误区

  • 只看命中率不看未命中绝对量:高命中率下大量回源仍可能压垮下游。
  • 不监控缓存大小:容量超限静默淘汰热点。

追问

  • Caffeine 统计如何开启?答:建造器启用 recordStats,读取快照指标;具体 API 以库版本为准。
  • 命中率低怎么优化?答:检查 TTL、容量、key 设计与数据访问模式。

04.8.4.2-061 远端缓存的序列化要注意什么?

一句话结论

远端缓存值需序列化为存储格式(JSON/二进制),注意类型版本兼容、字段演进与序列化成本;本地缓存存对象引用,无序列化开销。

概念解释

跨进程缓存必须可序列化。格式演进(字段增删、默认值)要兼容旧条目。序列化/反序列化耗时计入缓存访问成本。kotlinx-serialization 等编译期序列化方案可用于缓存值。

原理流程

  1. value 选择可序列化模型。
  2. 写入远端时编码。
  3. 读取时解码为对象。
  4. 格式变更处理兼容旧条目。

代码或图示

本地:对象引用直接存取
远端:对象 ↔ 序列化格式 ↔ 存储

常见误区

  • 缓存含不可序列化引用:远端写入失败。
  • 改字段结构不清旧缓存:解码旧格式异常。

追问

  • 序列化失败的旧条目如何处理?答:解码异常视为未命中回源,不直接抛出中断请求。
  • 二进制格式与 JSON 如何取舍?答:按性能、可读性与跨语言需求评估。

04.8.4.2-062 测试中缓存替身如何处理?

一句话结论

单元测试可用内存 Map 替身缓存接口,验证回填与失效逻辑;缓存本身的策略(过期、淘汰)由缓存库测试覆盖,业务测试只验交互。

概念解释

业务代码依赖缓存抽象接口,测试注入内存实现。过期/淘汰策略是库职责,不在业务单测重复验证。集成测试可接真实缓存实例验证行为。

原理流程

  1. 定义缓存访问抽象接口。
  2. 单测注入内存 fake。
  3. 验证读写、失效调用。
  4. 集成测试接真实 Caffeine/远端。

代码或图示

interface UserCache {
    fun get(id: Long): User?
    fun put(id: Long, user: User)
}

常见误区

  • 单测启动真实缓存实例验证淘汰策略:混入库职责,反馈慢。
  • 业务代码直接依赖具体缓存类:无法替换替身。

追问

  • 缓存失效逻辑怎么测?答:fake 记录 remove 调用,断言写库后对应 key 被失效。
  • 并发回填在单测如何验证?答:集成/并发测试覆盖,单测验证接口契约。

04.8.4.2-063 缓存与事务的边界如何处理?

一句话结论

事务提交成功后再失效缓存,避免未提交事务回填脏数据;缓存删除不在数据库事务内,回滚后不应误删有效缓存。

概念解释

先写库后删缓存的顺序要考虑事务边界:事务未提交时其他会话读不到新值,此时删缓存可能被旧值回填。事务提交后执行失效动作。跨实例失效通过后续通知/TTL 兜底。

原理流程

  1. 开启事务写库。
  2. 事务提交成功。
  3. 提交后删除/失效缓存。
  4. 未提交回滚则不动作缓存。

代码或图示

事务内:更新 DB
提交后:失效 cache
回滚:不触碰缓存

常见误区

  • 事务内删缓存后回滚:有效缓存被误删,回源可能读到旧库值。
  • 异步失效晚于并发读:短暂不一致窗口由 TTL 与策略接受。

追问

  • 事务提交钩子在哪里执行?答:按框架事务回调,提交后再触发缓存失效。
  • 强一致要求下缓存怎么办?答:关键数据不进缓存或缩短窗口,评估一致性需求。

04.8.4.2-064 空对象缓存与 TTL 抖动有什么作用?

一句话结论

空值短 TTL 配合随机抖动,避免同一批空值同时过期导致集中回源;TTL 抖动把过期时间打散到窗口内。

概念解释

固定 TTL 下批量写入的空值同时失效,形成二次穿透。抖动在基础 TTL 上加减随机区间,过期时刻分散。空值 TTL 本身短,抖动进一步平滑回源峰值。

原理流程

  1. 空值缓存基础 TTL。
  2. 过期时间加随机抖动区间。
  3. 同批空值错峰过期。
  4. 回源请求分散到时间窗口。

代码或图示

固定 TTL=60s:全部 60s 后同时过期
抖动:60s ± 10s,错峰过期

常见误区

  • 正常热数据也加过大抖动:过期行为不可预期。
  • 空值 TTL 过长:缺失数据长期不刷新。

追问

  • TTL 抖动影响数据一致性吗?答:只调整过期时刻,数据内容不变;窗口内允许短暂陈旧。
  • 随机种子在缓存中需要固定吗?答:运行期随机即可,测试中固定时间验证。

04.8.4.2-065 并发回填如何控制?

一句话结论

按 key 单飞合并并发加载,回填任务互斥登记;加载失败释放登记允许重试,成功结果写入缓存。不同 key 并发不互相阻塞。

概念解释

并发回填控制两层:同一 key 只允许一个加载者,其他等待;不同 key 并行加载。加载中状态与完成结果分别管理。失败任务不应长期占据单飞登记。

原理流程

  1. 未命中检查进行中任务登记。
  2. 已有任务则等待其结果。
  3. 无任务则启动加载并登记。
  4. 完成写入缓存,失败清理登记。

代码或图示

key=1:等待中任务共享
key=2:独立并行加载

常见误区

  • 全局锁串行所有回填:并发性能下降。
  • 失败任务登记不清理:后续请求永久等待坏结果。

追问

  • 回填超时如何处理?答:加载任务受整体超时约束,超时失败并释放单飞。
  • 缓存库内置并发加载吗?答:Caffeine 加载器有同步/异步去重能力,协程封装按实现核对。

04.8.4.2-066 Kotlin 后端日志门面选择什么?

一句话结论

JVM 后端通用选择 slf4j 作为日志门面,具体实现(logback 等)按工程生态接入;Kotlin 代码通过门面 API 打日志,不直接绑定实现库。

概念解释

门面隔离日志实现,业务代码依赖门面接口,实现可替换。Kotlin 常用属性委托或门面静态调用打日志。日志框架版本与后端框架(Spring/Ktor 生态)配套,坐标以官方文档为准。

原理流程

  1. 引入 slf4j 门面依赖。
  2. 绑定日志实现。
  3. 类中获取 logger 实例。
  4. 按级别输出结构化日志。

代码或图示

private val logger = LoggerFactory.getLogger(javaClass)
logger.info("order created {}", orderId)

常见误区

  • 业务代码直接引用日志实现类:绑定具体实现,替换困难。
  • 多个日志实现共存:输出混乱,类路径冲突需排除。

追问

  • Kotlin 有委托获取 logger 的库吗?答:有社区封装(如 logback 扩展/ kotlin-logging 类库),选型按工程依赖。
  • 门面与实现桥接如何配置?答:按 slf4j 绑定规则接入实现,具体桥接依赖见工程构建配置。

04.8.4.2-067 结构化日志的 JSON 字段如何组织?

一句话结论

结构化日志以键值对/JSON 输出固定字段:级别、消息、traceId、业务标识、错误类型与上下文;消息文本简短,细节放字段,便于机器检索聚合。

概念解释

非结构化文本日志难以按字段过滤。结构化日志把业务标识、错误码、耗时等作为独立字段。字段命名统一约定,避免每条日志随意拼字符串。异常堆栈单独字段记录。

原理流程

  1. 定义公共字段集合。
  2. 打日志时传入键值上下文。
  3. 编码器输出 JSON 结构。
  4. 日志平台按字段检索聚合。

代码或图示

{
  "level": "WARN",
  "msg": "payment declined",
  "orderId": "1001",
  "errorCode": "PAYMENT_DECLINED"
}

常见误区

  • 把所有上下文拼进消息字符串:无法按字段查询。
  • 日志字段命名各模块不一:检索口径混乱。

追问

  • 敏感字段能进日志吗?答:禁止密码、证件号等敏感信息,按脱敏规则处理。
  • 嵌套上下文如何表达?答:结构化字段支持嵌套对象,层级按日志格式规范定义。

04.8.4.2-068 MDC 的作用与字段传递机制是什么?

一句话结论

MDC(映射诊断上下文)把请求级键值上下文附加到日志输出,基于 ThreadLocal 存储;同一线程内日志自动携带 MDC 字段,实现请求链路关联。

概念解释

MDC 在请求入口放入 traceId、用户标识等,日志编码器输出时读取 ThreadLocal 字段。线程切换后 ThreadLocal 不自动传递,这是 MDC 与协程场景的核心问题。MDC 是门面提供的上下文机制。

原理流程

  1. 请求入口向 MDC 写入上下文字段。
  2. 同线程后续日志读取 MDC。
  3. 编码器把字段加入日志结构。
  4. 请求结束清理 MDC。

代码或图示

MDC.put("traceId", traceId)
logger.info("processing order")
MDC.clear()

常见误区

  • 请求结束不清理 MDC:线程复用时上下文串到下一个请求。
  • MDC 字段跨线程手动拷贝遗漏:异步上下文丢失。

追问

  • MDC 与日志框架实现绑定吗?答:slf4j MDC 门面对接底层实现 MDC,桥接按工程配置。
  • MDC 能存结构化对象吗?答:通常存字符串键值,复杂结构序列化为字段。

04.8.4.2-069 MDC 在协程上下文丢失的原因是什么?

一句话结论

MDC 基于 ThreadLocal,协程可在不同线程间切换,ThreadLocal 不随协程上下文迁移;线程切换后新线程的 MDC 为空,日志丢失请求上下文。

概念解释

线程池复用线程,协程挂起恢复后可能在另一线程执行。ThreadLocal 值留在原线程,新线程读不到 MDC。普通 MDC 机制不感知协程调度模型,需要把上下文纳入 CoroutineContext 或在调度时桥接。

原理流程

  1. 请求线程 MDC 写入字段。
  2. 协程挂起切换线程。
  3. 恢复线程 ThreadLocal 无 MDC。
  4. 后续日志缺 traceId 等字段。

代码或图示

Thread A:MDC = {traceId}
协程挂起 → Thread B 恢复:MDC 为空

常见误区

  • 在同步线程模型下写的 MDC 代码直接搬到协程:切换后上下文丢失。
  • 依赖线程池同一线程处理:协程不保证线程亲和。

追问

  • 解决方案方向是什么?答:把诊断上下文作为 CoroutineContext 元素,调度恢复时同步到 MDC;具体桥接库以工程选型为准。
  • 阻塞线程池模型有此问题吗?答:单线程贯穿请求时 MDC 可用;线程切换同样丢失。

04.8.4.2-070 协程与 ThreadLocal 为什么不天然匹配?

一句话结论

ThreadLocal 绑定线程,协程绑定调度器与 Continuation;协程可在多线程间迁移,ThreadLocal 快照不随恢复传播,需要显式上下文元素携带值。

概念解释

线程是执行载体,协程是逻辑任务。挂起恢复后执行线程可能改变,ThreadLocal 跟随线程而非协程。协程上下文(CoroutineContext)才是随协程传播的状态载体,诊断信息应放这里。

原理流程

  1. 协程启动时上下文确定。
  2. 挂起后调度器选择线程恢复。
  3. ThreadLocal 不复制到新线程。
  4. 上下文元素随协程传播,恢复时写入对应线程。

代码或图示

ThreadLocal:随线程存活
CoroutineContext:随协程作业存活

常见误区

  • 用 ThreadLocal 存协程请求级状态:跨线程丢失。
  • 假设 Dispatchers.IO 固定线程:线程池复用与切换都可能发生。

追问

  • 如何实现上下文元素传播?答:定义实现 CoroutineContext.Element 的类型,随协程构建携带;调度钩子在恢复时同步 MDC。
  • 哪些库处理了这个桥接?答:协程日志/诊断库提供上下文桥接,选型与 API 以当前版本为准。

04.8.4.2-071 slf4j 桥接与日志实现如何选择?

一句话结论

业务代码依赖 slf4j 门面,实现按工程生态选择(如 logback);历史遗留日志 API 通过桥接器统一到门面,避免多套日志输出。

概念解释

桥接器把其他日志 API(旧实现/ Jakarta 等)调用重定向到 slf4j,实现类负责实际输出。后端框架自带默认实现时,工程按其约定接入。依赖中排除冲突实现,保证单一输出链路。

原理流程

  1. 引入 slf4j 门面。
  2. 绑定日志实现。
  3. 遗留 API 经桥接器重定向。
  4. 统一编码器与配置输出。

代码或图示

业务代码 → slf4j 门面 → 日志实现(logback 等)
遗留 API → 桥接器 → slf4j 门面

常见误区

  • classpath 多实现并存:输出冲突或告警,需排除多余绑定。
  • 桥接器与实现循环引用:按官方依赖说明排除对应模块。

追问

  • 如何检查日志链路?答:启动日志查看实际实现绑定,依赖树排查多余桥接/实现。
  • 框架默认实现能替换吗?答:可按门面规则换实现,注意配置格式兼容。

04.8.4.2-072 日志级别使用规范是什么?

一句话结论

ERROR 用于需介入的故障,WARN 用于可恢复异常/可疑状态,INFO 记录关键业务节点,DEBUG/TRACE 用于排查细节;生产默认 INFO,避免级别滥用。

概念解释

级别决定输出与告警阈值。业务成功流程用 INFO,瞬时重试/降级用 WARN,系统故障用 ERROR。DEBUG 仅排障开启。级别语义团队统一,避免 ERROR 满天飞失去告警意义。

原理流程

  1. 判断事件严重程度。
  2. 按规范选择级别。
  3. 生产配置输出阈值。
  4. 告警规则关联 ERROR/WARN。

代码或图示

ERROR:故障需处理
WARN:异常但已恢复/降级
INFO:关键流程节点
DEBUG/TRACE:调试细节

常见误区

  • 业务正常分支打 ERROR:告警噪音掩盖真实故障。
  • 排障 DEBUG 留在生产默认开启:日志量过大。

追问

  • 重试失败用什么级别?答:最终失败 ERROR,中间重试 WARN/DEBUG 按策略。
  • 级别能动态调整吗?答:按实现支持的运行期调级能力,生产谨慎开启。

04.8.4.2-073 日志中为什么禁止打印敏感信息?

一句话结论

密码、密钥、证件号、银行卡等敏感数据不得进入日志;日志可能被多系统采集留存,泄露风险高。敏感字段在输出前脱敏或排除。

概念解释

日志访问范围通常大于业务数据库。结构化字段与消息文本都需检查敏感内容。脱敏规则按字段名/类型统一处理,而非靠开发者自觉。合规要求对个人信息最小化记录。

原理流程

  1. 识别敏感字段清单。
  2. 日志输出前按规则脱敏/排除。
  3. 结构化字段不写入敏感原值。
  4. 定期审计日志样本。

代码或图示

禁止:password、token、idCard、cardNo 原值
允许:脱敏掩码、业务非敏感标识

常见误区

  • 异常对象 toString 含敏感字段:堆栈/消息可能带出,需检查异常内容。
  • 调试日志临时打印请求体:遗留到生产造成泄露。

追问

  • 脱敏规则放哪层?答:日志编码器/序列化层统一处理,业务侧避免传敏感原值。
  • 排障需要敏感信息怎么办?答:按合规流程受控查看,不进常规日志。

04.8.4.2-074 异常日志如何记录堆栈?

一句话结论

记录异常时把 Throwable 作为最后一个参数传给日志方法,编码器输出堆栈;只打消息不打堆栈会丢失根因定位信息。

概念解释

日志门面方法支持传入异常对象,输出堆栈轨迹。同一异常在捕获点记录一次,避免多层重复打堆栈。堆栈配合 traceId 与业务上下文字段。

原理流程

  1. 捕获异常取得 Throwable。
  2. 日志方法传入异常参数。
  3. 编码器输出类型、消息与堆栈。
  4. 上层不再重复记录同一异常。

代码或图示

logger.error("order ${orderId} failed", ex)

常见误区

  • 只打 ex.message:堆栈丢失,无法定位代码位置。
  • 每层都打同一异常堆栈:日志重复,根因被淹没。

追问

  • 业务异常需要打堆栈吗?答:可按级别记录类型与上下文;预期业务失败不必每次全堆栈。
  • 堆栈中敏感信息如何处理?答:检查异常消息与类名,必要时脱敏后输出。

04.8.4.2-075 日志与 Either 错误如何配合?

一句话结论

Either 链中途不打日志,错误在边界按类型决定日志级别与字段;日志记录领域错误类型、上下文与 cause,不重复记录每个短路步骤。

概念解释

typed error 沿值传播,日志职责集中在边界。边界识别错误分级:业务拒绝 DEBUG/INFO,可恢复 WARN,系统故障 ERROR。原始 cause 保留在错误对象中供边界记录。

原理流程

  1. 步骤产出 Left 沿链传播。
  2. 边界匹配错误类型。
  3. 按级别输出结构化日志。
  4. cause 堆栈按需记录。

代码或图示

result.onLeft { err ->
    logger.warn { "order failed: ${err.code}, orderId=${err.orderId}" }
}

常见误区

  • 每个 bind 失败点打日志:同一错误多条记录。
  • 边界只打错误消息不带类型字段:无法聚合统计。

追问

  • 错误日志在 service 还是 handler 层打?答:按分层约定,通常在接近对外边界处统一记录。
  • 重试中的错误何时记?答:首次失败采样/DEBUG,最终失败汇总记录。

04.8.4.2-076 异步日志对性能有什么影响?

一句话结论

异步日志把写盘操作移出业务线程,降低日志 IO 对请求延迟的影响;但队列满、丢日志策略与崩溃时日志丢失需权衡。

概念解释

同步日志在业务线程阻塞写输出;异步队列先入队由后台线程写。高日志量下异步保护业务吞吐,代价是队列内存与极端情况丢弃策略。后端按日志量级选择实现配置。

原理流程

  1. 业务线程写日志入队列。
  2. 后台日志线程消费输出。
  3. 队列满时按策略阻塞或丢弃。
  4. 关闭时冲刷剩余日志。

代码或图示

业务线程 → 日志队列 → 后台写盘

常见误区

  • 假设异步日志零成本:队列与序列化仍占用 CPU/内存。
  • 不配置队列满策略:高峰时阻塞业务或丢日志。

追问

  • 崩溃时异步日志会丢吗?答:未冲刷队列可能丢失,关键事件按可靠性要求选择输出方式。
  • 日志序列化在哪个线程?答:按实现配置,注意序列化开销位置。

04.8.4.2-077 traceId 如何生成与透传?

一句话结论

请求入口生成或继承上游 traceId,写入 MDC/协程上下文;跨调用通过请求头透传,日志与下游调用携带同一标识,串联整条链路。

概念解释

traceId 是链路关联主键。入口无上游标识则生成,有则继承。上下文随线程/协程传播,出站请求注入请求头。日志、指标、错误按 traceId 关联。

原理流程

  1. 入口检查上游请求头。
  2. 无标识则生成 traceId。
  3. 写入诊断上下文。
  4. 出站调用透传请求头,日志自动携带。

代码或图示

上游请求头 traceId → 入口继承/生成 → MDC/协程上下文 → 日志 + 下游请求头

常见误区

  • 内部生成标识不透传给下游:链路断裂。
  • traceId 不随协程上下文传播:异步日志缺失标识。

追问

  • traceId 与 span 概念区别?答:trace 标识整条链路,span 标识单次调用;完整链路追踪见 08 分册可观测性。
  • 消息队列场景如何透传?答:标识写入消息头,消费侧恢复到上下文。

04.8.4.2-078 测试中断言日志输出怎么做?

一句话结论

测试中替换日志 appender/捕获器收集日志记录,断言级别、消息字段与错误类型;验证关键日志是否输出,而非依赖人工查看控制台。

概念解释

日志是可观测性输出,关键决策点的日志应可测试。测试挂载捕获器收集记录,按级别/字段断言。避免在业务代码为测试暴露 logger,通过日志框架测试扩展接入。

原理流程

  1. 测试挂载日志捕获器。
  2. 执行业务用例。
  3. 收集输出记录。
  4. 断言级别、消息与上下文字段。

代码或图示

测试 appender 收集记录 → 断言 warn 级别 + orderId 字段

常见误区

  • 断言日志完整文本:文案调整导致脆弱测试,断言级别与关键字段。
  • 业务代码注入 logger 接口便于测试:可接受,但优先框架测试扩展。

追问

  • 异步日志如何在测试中收集?答:同步输出或等待队列冲刷后断言。
  • 日志断言覆盖哪些点?答:错误边界、关键降级与重试结果,不逐条断言正常 INFO。

04.8.4.2-079 日志框架在 Ktor/Spring 中接入有何差异?

一句话结论

两者后端 JVM 生态均以 slf4j 为门面,差异在默认实现与配置加载方式;业务代码日志 API 一致,接入配置按各自框架约定。

概念解释

Spring 生态常默认 logback 并随应用配置加载;Ktor 后端按工程依赖接入门面与实现。业务类通过门面打日志,框架差异只体现在依赖装配与配置文件。本节不展开框架细节,见 06 分册。

原理流程

  1. 框架工程引入门面与实现。
  2. 配置文件定义输出格式与级别。
  3. 业务代码门面调用。
  4. 实现按配置输出。

代码或图示

Ktor/Spring:slf4j 门面 + 各自默认实现装配
业务代码:同一套 logger 调用

常见误区

  • 业务代码绑定框架特定日志 API:跨框架不可复用。
  • 忽略框架默认实现自带依赖:与手动引入实现冲突。

追问

  • 日志配置文件格式随实现不同吗?答:是,按所选实现的配置格式编写。
  • 多模块共享日志配置?答:公共配置统一,模块按需调整级别。

04.8.4.2-080 结构化日志的 JSON encoder 如何配置?

一句话结论

日志实现配置 JSON 编码器,输出字段化日志(时间、级别、消息、MDC 字段、异常);字段顺序与命名按团队规范,输出供日志平台解析。

概念解释

编码器决定日志输出格式。JSON 模式把 MDC 与结构化参数转为 JSON 字段。配置包含时间格式、字段名、堆栈输出方式。开发环境可读文本,生产结构化 JSON。

原理流程

  1. 选择 JSON 编码器实现。
  2. 配置公共字段与输出模板。
  3. MDC/上下文字段纳入 JSON。
  4. 异常序列化为独立字段。

代码或图示

{"ts":"2026-01-01T10:00:00Z","level":"INFO","msg":"...","traceId":"..."}

常见误区

  • 编码器配置与 MDC 字段不匹配:上下文字段不出现在 JSON。
  • 开发与生产格式不一致:排障时对照困难,可按环境区分。

追问

  • JSON 日志体积更大怎么办?答:控制字段数量与日志级别,权衡可观测性与成本。
  • 编码器版本与实现绑定吗?答:按所选日志实现文档配置。

04.8.4.2-081 日志字段命名有什么约定?

一句话结论

字段名统一小写蛇形或团队约定风格,业务标识、错误码、耗时等字段名全工程一致;公共字段(级别、时间、traceId)遵循日志平台约定。

概念解释

命名一致才能跨模块聚合查询。字段语义在团队规范中定义:orderId、userId、errorCode、latencyMs 等。避免同义不同名(orderId/order_id 混用)。新增字段补充规范。

原理流程

  1. 定义公共与业务字段命名表。
  2. 各模块按表输出字段。
  3. 日志平台按字段名聚合。
  4. 新字段评审后加入规范。

代码或图示

traceId, orderId, userId, errorCode, latencyMs, retryCount

常见误区

  • 字段名随开发者习惯起:检索口径分裂。
  • 同一概念多字段并存:清理冗余命名。

追问

  • 嵌套字段如何命名?答:按层级前缀或对象结构定义,规范中列出示例。
  • 字段类型有要求吗?答:标识用字符串,数值用数值类型,避免全字符串序列化。

04.8.4.2-082 启动期关键信息日志应包含什么?

一句话结论

应用启动日志记录版本、环境、关键配置摘要与依赖就绪状态,便于部署后确认实例身份与配置生效;不打印密钥等敏感配置。

概念解释

启动日志回答"哪个实例、什么版本、什么环境、依赖是否就绪"。配置摘要区分敏感与非敏感项。启动失败时定位配置缺失或依赖连接问题。运行期业务日志不与启动信息混杂。

原理流程

  1. 应用启动读取版本与环境信息。
  2. 输出非敏感配置摘要。
  3. 依赖初始化就绪后记录状态。
  4. 启动失败记录错误上下文。

代码或图示

启动:app=order-service, version=1.2.0, env=prod, db=connected

常见误区

  • 启动日志打印全部配置含密钥:敏感信息泄露。
  • 依赖未就绪即记启动成功:健康状态与日志不一致。

追问

  • 版本信息从哪里读?答:构建元数据/清单文件注入,不硬编码。
  • 启动日志级别?答:INFO 记录节点状态,异常 ERROR。

04.8.4.2-083 重复异常日志如何降噪?

一句话结论

高频重复异常按类型采样或聚合记录,保留首次完整堆栈与后续计数,避免同一故障刷爆日志;降噪规则不影响关键故障告警。

概念解释

下游故障时同一异常短时间重复出现,逐条全堆栈日志淹没有效信息。按异常类型/窗口聚合,输出次数与最新样例。告警仍按错误率触发,降噪只影响日志量。

原理流程

  1. 识别重复异常类型。
  2. 窗口内计数聚合。
  3. 首次记录完整堆栈,后续记计数。
  4. 窗口结束输出汇总。

代码或图示

100 次同一异常 → 1 条完整堆栈 + "occurred=100" 计数

常见误区

  • 降噪后完全不留样例:新异常类型无法排查。
  • 采样掉关键错误:ERROR 级故障不采样,只压重复 WARN/高频错误。

追问

  • 降噪在日志库还是业务层做?答:按实现支持的去重/采样能力,业务层避免重复打。
  • 计数如何上报监控?答:错误计数走指标,日志保留样例与上下文。

04.8.4.2-084 日志配置如何外部化?

一句话结论

级别、输出目标、格式由外部配置(配置文件/环境变量/配置中心)管理,不硬编码在代码里;不同环境用不同配置,可在不改代码的前提下调整日志。

概念解释

日志配置随环境变化:开发 DEBUG,生产 INFO。配置外部化支持运行期调整级别与输出。敏感配置不进代码仓库。启动期读取配置初始化日志系统。

原理流程

  1. 日志实现从配置源读取级别/格式/目标。
  2. 环境变量或配置中心覆盖默认值。
  3. 初始化 logger 上下文。
  4. 运行期按配置输出。

代码或图示

代码:门面调用,不含级别/目标配置
配置:文件/环境变量/配置中心

常见误区

  • 代码里写死日志级别与路径:环境切换需改代码。
  • 配置含真实密钥:日志配置也属敏感配置管理范围。

追问

  • 运行期动态调级别怎么做?答:按实现提供的管理接口/配置中心刷新,能力以实现文档为准。
  • 测试环境日志如何隔离?答:测试配置独立输出,不污染生产日志路径。

04.8.4.2-085 协程诊断上下文如何随上下文元素传递?

一句话结论

把 traceId 等诊断信息封装为 CoroutineContext 元素,随协程构建与子协程传播;调度恢复时该元素写入 MDC,使日志在协程切换后仍携带上下文。

概念解释

上下文元素是协程级状态载体,替代 ThreadLocal。元素随 async/launch 父子传播。桥接钩子在线程恢复时把元素值同步到 MDC,结束时清理。具体实现类库按工程选型。

原理流程

  1. 定义诊断上下文元素。
  2. 协程构建时携带元素。
  3. 子协程继承父上下文。
  4. 调度恢复时同步 MDC,日志读取。

代码或图示

// 示意:上下文元素携带 traceId(实现方式以所选库为准)
// launch(DiagnosticElement(traceId)) { ... }

常见误区

  • 只在入口写 MDC 不做上下文元素:线程切换后丢失。
  • 子协程未继承上下文:async/launch 默认继承,自定义上下文注意合并规则。

追问

  • 上下文元素如何合并?答:同类型元素按上下文规则覆盖,键唯一;具体合并语义以协程库为准。
  • 线程池阻塞桥接场景怎么办?答:进入阻塞线程前快照上下文,返回后恢复,注意清理。

04.8.4.2-086 画出一个带缓存、重试与日志的网关调用链。

一句话结论

完整链路:读缓存 → 未命中进入重试策略 → 错误分类 → 退避抖动重试 → 成功回填缓存 → 边界记录日志与指标;各环节错误分类与上下文贯穿。

概念解释

横切能力按顺序组合:缓存挡热点,重试兜底瞬时故障,日志/指标观测全链路。每步失败按类型决定下一步。链路设计要明确缓存失效、重试预算与日志点。

原理流程

  1. 请求先查本地/远端缓存。
  2. 未命中走网关调用,包裹重试策略。
  3. 可重试错误退避重试,耗尽后返回错误。
  4. 成功结果回填缓存,边界记录指标与日志。

代码或图示

请求 → 缓存命中? ──是→ 返回
              └─否→ 重试策略 → 网关调用 → 成功回填缓存 / 失败分类返回
                     全程:traceId 上下文 + 指标 + 边界日志

常见误区

  • 缓存结果不区分错误与空值:失败响应被缓存放大。
  • 重试包裹缓存读取:缓存命中不应触发重试。

追问

  • 缓存失效后并发回填如何衔接?答:单飞合并回源请求,见缓存专题。
  • 链路日志在哪打?答:缓存命中/未命中计数指标化,最终结果边界记录。

04.8.4.2-087 错误如何从底层 Either 向上聚合设计?

一句话结论

底层模块定义自身领域错误,中层 mapLeft 转换为对外错误层级,顶层聚合为统一响应错误;每层错误类型收敛,不把内部异常细节泄漏到边界。

概念解释

错误沿调用链向上传播并逐层翻译:仓储错误 → 领域错误 → API 错误 DTO。每层只暴露自己层级的错误类型。聚合时多来源错误纳入同一 sealed 父类型,边界穷尽匹配。

原理流程

  1. 底层返回 Either<RepoErr, T>。
  2. 中层 mapLeft 映射为领域错误。
  3. 多步骤聚合为整体领域错误。
  4. 边界映射响应错误码。

代码或图示

repo.find(id)
    .mapLeft { it.toDomain() }
    .flatMap { orderService.prepare(it) }
    .mapLeft { it.toResponse() }

常见误区

  • 底层异常类型直接抛到顶层:跨层耦合,边界无法稳定分型。
  • 每层错误新增子类不更新上层匹配:穷尽性检查暴露遗漏。

追问

  • 跨模块错误映射放哪?答:模块边界适配层,保持内部错误私有。
  • 聚合多个底层错误如何合并?答:按业务语义选主错误或收集列表,见聚合题。

04.8.4.2-088 多依赖并行调用时错误如何聚合?

一句话结论

并行收集各依赖 Either,按策略合并:快速失败保留首个错误,或聚合全部错误列表;并行任务的异常先捕获为 Either 再纳入聚合。

概念解释

并行场景错误组合与顺序链不同。需要全部结果时收集所有失败;任一关键失败即中止时快速失败。协程并发启动后 await 收集结果列表,再用序列组合器合并。

原理流程

  1. 协程作用域并发调用各依赖。
  2. 各自返回 Either。
  3. 按策略合并:首个 Left 或错误集合。
  4. 聚合 Either 返回上层。

代码或图示

val results = listOf(async { a() }, async { b() }).awaitAll()
val merged: Either<Errs, List<T>> = results.sequenceEither()

常见误区

  • 并行任务异常未捕获:协程作用域取消,不走 Either 聚合。
  • 快速失败后其他任务结果丢弃:注意资源取消与清理。

追问

  • 部分成功如何处理?答:按业务决定返回成功项 + 失败集合,或整体失败。
  • 并行超时如何控制?答:整体超时约束各任务,超时错误纳入聚合。

04.8.4.2-089 函数式错误处理风格与团队接受度如何平衡?

一句话结论

按团队基础渐进引入:核心领域层用 Either/Raise 建模可预期错误,外围保持惯用风格;统一错误建模规范与示例,避免半套风格混用。

概念解释

函数式风格有学习成本,全量改造风险高。落地路径:新代码在关键边界使用 typed error,遗留代码逐步适配。团队约定错误层级、转换点与禁用模式。评审保证风格一致。

原理流程

  1. 选定引入范围(领域/服务层)。
  2. 定义错误层级与示例模板。
  3. 新代码按规范使用。
  4. 遗留代码按需重构,评审把关。

代码或图示

试点:新服务领域层 Either
推广:错误映射规范 + 代码评审
遗留:随改动逐步适配

常见误区

  • 强制所有代码函数式化:抵触情绪与改造风险。
  • 规范不统一:部分 Either 部分异常混用,边界混乱。

追问

  • 团队不熟悉 Raise DSL 怎么办?答:先用 Either map/flatMap 基础组合,再引入作用域 DSL。
  • 如何评审 typed error 用法?答:检查错误类型是否领域化、边界是否清晰、未吞错。

04.8.4.2-090 Arrow 能力与 Kotlin 标准库如何对照?

一句话结论

标准库覆盖 nullable、Result、集合操作等基础能力;Arrow 补充代数数据类型(Either/Option)、Raise 作用域与函数式组合器。按需引入,不为单个工具过度依赖。

概念解释

简单空值用 ?/?: 足够;多步可失败流程与错误分型用 Either。Arrow 不替代语言空安全,而是提供类型级组合。评估标准库是否已满足,再引入库依赖。

原理流程

  1. 识别需求:空值/容错/错误分型/组合。
  2. 标准库能覆盖则不引 Arrow。
  3. 需要 typed error 与组合器再引入。
  4. 依赖范围控制在 core 等必要模块。

代码或图示

nullable:T? + ?. + ?:
局部容错:Result/runCatching
错误分型与组合:Either/Raise(Arrow)

常见误区

  • 引入 Arrow 后把所有 nullable 改 Option:无收益的包装。
  • 重复造标准库已有能力:先查标准库与扩展。

追问

  • Arrow 依赖体积大吗?答:按需引入模块,core 体量按当前版本评估。
  • 与其他函数式库冲突吗?答:同类能力选一套,避免多套类型体系并存。

04.8.4.2-091 Either 包装在热路径上有性能开销吗?

一句话结论

Either 是包装对象,每次成功/失败产生左侧/右侧实例与链式分配;热路径高并发下需评估对象分配压力,必要时在边界使用 Either,内部保持直接返回。

概念解释

代数数据类型是堆上包装,flatMap 链产生中间对象。业务请求路径可接受;超高频热循环、字节码级性能敏感场景需基准测试。JVM 逃逸分析可能优化部分分配,以实测为准。

原理流程

  1. 每次步骤产出 Either 实例。
  2. 链上 map/flatMap 产生中间包装。
  3. 边界解包为业务结果。
  4. 高并发下统计分配与 GC。

代码或图示

链:Either 包装 × 步骤数 → 边界解包
热路径:基准测试分配与延迟

常见误区

  • 不测量就断言 Either 很慢:实际开销取决于链长与并发量。
  • 在最内层循环强制包装:能在边界聚合的错误不在循环内逐次包装。

追问

  • 如何优化分配?答:缩短链、边界使用类型、复用错误实例;按基准决定。
  • 热路径能用 Result 替代吗?答:Result 同样有包装,选型先满足错误分型需求再测性能。

04.8.4.2-092 类型级错误与字符串错误码如何取舍?

一句话结论

内部领域流程用类型级 sealed 错误,编译期可穷尽检查;对外契约用稳定字符串错误码,供跨服务/前端消费。两者在边界双向转换。

概念解释

类型错误在编译期保障分支覆盖,不适合跨进程传输;错误码稳定可序列化,丢失分型细节。内部用 sealed 表达语义,边界映射为码。字符串码不应贯穿内部业务逻辑。

原理流程

  1. 内部定义 sealed 错误层级。
  2. 边界映射为对外错误码。
  3. 消费方按码处理。
  4. 入站错误码反向映射为内部类型。

代码或图示

sealed OrderError
object OutOfStock : OrderError()  // 内部类型
// 边界 → "OUT_OF_STOCK"(对外码)

常见误区

  • 内部逻辑到处比较错误码字符串:无法穷尽检查,重构脆弱。
  • 对外暴露内部异常类名:类型细节泄漏且不可序列化。

追问

  • 错误码表谁维护?答:API 契约文档统一管理,新增码不破坏既有消费方。
  • 类型错误能自动生成码吗?答:可在映射处集中声明,避免散落字符串。

04.8.4.2-093 错误码与 Either 如何双向转换?

一句话结论

出站:领域错误按映射表转为错误码与消息;入站:外部错误码解析回内部领域错误,未知码归入通用错误类型。映射集中在适配层。

概念解释

双向映射保证内部类型模型与对外契约一致。入站未知码不能直接当成合法类型,需兜底分类。映射表显式维护,新增错误类型同步更新两侧。

原理流程

  1. 出站:when 穷尽匹配领域错误 → 码/消息。
  2. 入站:码匹配领域错误子类。
  3. 未匹配码 → 通用外部错误。
  4. 映射变更补测试覆盖。

代码或图示

fun OrderError.toCode(): String = when (this) {
    is OutOfStock -> "OUT_OF_STOCK"
    is PaymentDeclined -> "PAYMENT_DECLINED"
}

常见误区

  • 映射散落在业务代码各处:边界维护困难。
  • 入站忽略未知码:错误处理走错分支。

追问

  • 映射表如何测试?答:参数化遍历全部领域错误与码,保证双向闭合。
  • 错误码带 HTTP 状态吗?答:状态码在 API 层按错误类别映射,领域错误不感知 HTTP。

04.8.4.2-094 Either 与响应式/协程错误处理如何结合?

一句话结论

协程挂起函数返回 Either,在结构化并发内捕获异常转为 Left;响应式流的错误信号按各自操作符处理,与 Either 是不同错误通道,转换需在边界明确。

概念解释

协程错误走异常传播 + 可捕获转换;Either 是值级结果。混合使用时:挂起步骤内部捕获异常产出 Either,并行聚合 Either。响应式框架的 onError 通道不与 Either 自动互通。

原理流程

  1. 挂起函数内部捕获 nonFatal 异常。
  2. 成功 Right / 失败 Left 返回。
  3. 协程作用域聚合多个 Either。
  4. 边界统一处理错误。

代码或图示

suspend fun call(): Either<Err, T> =
    Either.catch { api.fetch() }.mapLeft { toErr(it) }

常见误区

  • 协程异常绕过 Either 链冒泡:未在步骤内捕获。
  • 把 CancellationException 包成 Left:取消信号应正常传播。

追问

  • 响应式 Flux 错误如何转 Either?答:在边界取首元素/捕获错误转换,具体按响应式库操作符。
  • 协程与 Either 组合谁负责并发?答:协程负责调度并发,Either 负责结果分型。

04.8.4.2-095 可观测性中日志、指标与错误类型如何配合?

一句话结论

错误类型驱动分级:领域错误进业务指标,系统故障进错误日志与告警;traceId 串联日志、指标与链路追踪。三者按错误分类互补,不重复采集同一信息。

概念解释

指标回答频率与趋势,日志回答具体上下文,追踪回答链路位置。typed error 分类决定接入哪类观测。新增错误类型同步补指标维度与日志字段。

原理流程

  1. 错误在边界分类。
  2. 业务错误计数进指标。
  3. 关键错误输出结构化日志。
  4. traceId 关联链路追踪。

代码或图示

领域错误 → 业务指标 + INFO/WARN 日志
系统故障 → 错误指标 + ERROR 日志 + 告警
traceId 贯穿三者

常见误区

  • 只打日志不上指标:错误频率趋势不可见。
  • 只统计错误计数不带类型维度:无法定位高频错误种类。

追问

  • 重试计入哪个指标?答:重试次数、最终失败率分别统计,与首次失败区分。
  • 错误日志与指标重复采上下文?答:指标用标签,详细上下文进日志。

04.8.4.2-096 重试与缓存策略如何配置驱动?

一句话结论

重试次数、退避参数、TTL、容量等从配置读取,按环境与依赖分组配置;代码提供策略默认值,配置覆盖,不在代码中写死环境相关数值。

概念解释

策略参数随环境调整(测试短退避、生产保守重试)。配置按依赖/操作分组,支持热更新的项走配置中心。代码封装策略构造,读取配置组装重试/缓存实例。

原理流程

  1. 定义策略配置结构。
  2. 配置源提供环境值。
  3. 代码构造重试策略与缓存实例。
  4. 调整配置不改业务代码。

代码或图示

data class RetryConfig(val maxRetries: Int, val baseDelayMs: Long, val maxDelayMs: Long)

常见误区

  • 退避/TTL 硬编码在业务代码:环境调整需改代码。
  • 配置无默认值:缺失时启动失败或行为不确定。

追问

  • 配置变更需要重启吗?答:按刷新能力评估;静态策略随实例初始化,动态策略需支持热更新。
  • 不同依赖策略不同怎么组织?答:按依赖名分组配置项,代码按操作选取。

04.8.4.2-097 Arrow 1.x API 演进有哪些注意点?

一句话结论

Arrow 1.x 从旧版 Either 扩展风格向 Raise 新模型演进,部分 API 标记弃用;升级时对照迁移指南,核对当前版本函数名与模块归属,不沿用旧博客写法。

概念解释

大版本内 API 可能调整:Raise 取代部分经典 Either 嵌套写法,模块划分变化。工程升级时查 changelog 与迁移文档,编译期弃用警告逐项处理。不确定的 API 名称标待确认并在官方文档核对。

原理流程

  1. 查当前版本迁移指南。
  2. 替换弃用 API。
  3. 编译处理警告与类型变化。
  4. 测试回归错误处理链路。

代码或图示

待确认:当前 Arrow 1.x 各模块最新 API 签名与弃用列表

常见误区

  • 照搬 0.x 时代教程:API 已变更,编译不过或行为不符。
  • 忽略弃用警告升级:后续大版本移除后被迫紧急改造。

追问

  • 如何查版本对应 API?答:官方文档与 API 文档以当前发布版本为准。
  • 旧 Either 代码能否兼容新版?答:按迁移指南逐步替换,经典类型通常保留过渡兼容。

04.8.4.2-098 本节涉及的常见依赖坐标应如何说明?

一句话结论

Arrow、Caffeine、协程测试、日志门面等依赖坐标与版本以官方仓库当前发布为准;本节不写死未验证版本号,工程在版本目录中统一登记。

概念解释

依赖坐标随版本演进,臆造编号会误导构建。正确做法:查官方仓库当前版本,在版本目录登记别名与版本段。日志实现、缓存库按工程生态选择。

原理流程

  1. 查官方仓库/文档当前版本。
  2. 版本目录登记坐标与版本。
  3. 模块按别名引入。
  4. 升级时按兼容矩阵核对。

代码或图示

arrow-core:io.arrow-kt 组(版本以官方当前为准)
caffeine:com.github.ben-manes.caffeine 组(版本以仓库为准)
slf4j-api:org.slf4j 组(实现另选)

常见误区

  • 文档中写死过时版本号:升级后误导。
  • 处理器/库版本与 Kotlin 不配套:构建或运行报错。

追问

  • 坐标写错如何排查?答:依赖解析失败先核对 group/artifact 拼写与仓库。
  • 版本目录如何登记?答:见 04.8.3.1 版本目录专题。

04.8.4.2-099 面试中讲函数式错误处理应从什么切入点?

一句话结论

先讲问题背景(异常旁路、错误不可见),再讲选型(Either/Raise vs Result/异常),给出领域错误建模与边界转换实例,最后谈性能、团队落地与取舍。

概念解释

回答结构:痛点 → 类型模型 → 链式/短路机制 → 与异常边界 → 工程落地。结合实际项目错误层级、日志指标配合。能说清什么场景值得用、什么场景不必上类型级错误,比背 API 更重要。

原理流程

  1. 描述现有错误处理痛点。
  2. 介绍 sealed 错误 + Either/Raise。
  3. 讲解短路、映射与边界转换。
  4. 讨论性能、团队接受度与替代方案。

代码或图示

痛点 → 模型选型 → 链路机制 → 边界与可观测 → 落地取舍

常见误区

  • 只背 Either 方法名:讲不清设计理由与适用边界。
  • 宣称函数式错误处理全面替代异常:实际是分层配合。

追问

  • 项目中最复杂的错误场景?答:举例多依赖聚合、错误分类与恢复策略设计。
  • 如何向团队推广?答:从核心领域试点,配规范与评审,渐进迁移。

04.8.4.2-100 哪些场景值得引入 Either 这类类型级错误处理?

一句话结论

多步骤业务编排、错误需要分型分支处理、错误需跨层传递且要求编译期穷尽检查的场景值得用;简单局部容错、程序缺陷与纯内部工具用异常/Result 即可。

概念解释

判断标准:失败是否业务可预期、是否需要调用方分型处理、链路是否多步组合。符合则 typed error 收益明显;单点可抛可捕的场景引入 Either 增加包装成本。按边界分层选择。

原理流程

  1. 列举失败场景与处理方式。
  2. 可预期 + 多步 + 需分型 → Either/Raise。
  3. 局部容错 → Result/runCatching。
  4. 程序缺陷 → 异常边界兜底。

代码或图示

值得 Either:下单编排、多依赖聚合、领域校验分支
不必上:单点工具方法、内部缺陷、简单空值判断

常见误区

  • 所有返回值都包 Either:类型噪音大,热路径成本上升。
  • 该分型的错误只用异常:调用方遗漏分支处理。

追问

  • 边界模块如何起步?答:先在服务返回类型引入领域 Either,控制器/ handler 做映射。
  • 如何衡量引入收益?答:遗漏错误分支减少、错误处理路径可测、边界日志指标清晰。

参考来源

  • Arrow 官方文档:Either、Option、Raise 与 typed error 模型,https://arrow-kt.io/docs/
  • Kotlin 官方文档:标准库 Result 与 runCatching 行为说明,https://kotlinlang.org/docs/standard-library.html
  • Caffeine 官方文档:缓存配置、过期、容量与统计,https://github.com/ben-manes/caffeine
  • SLF4J 官方文档:门面、MDC 与桥接机制,https://www.slf4j.org/manual.html
  • kotlinx-coroutines 官方文档:协程上下文、调度与测试虚拟时间,https://kotlinlang.org/docs/coroutines-guide.html

待整理清单

  • [ ] 核对 Arrow 1.x 当前重试模块 API 名称、策略参数与模块归属(见 04.8.4.2-044)
  • [ ] 核对 Kotlin 当前版本对 Result 作为公开返回类型的具体约束(见 04.8.4.2-034)
  • [ ] 核对协程 MDC 上下文桥接的社区库与 API(见 04.8.4.2-069、04.8.4.2-085)
  • [ ] 核对 Caffeine AsyncCache 与协程封装的当前可用能力(见 04.8.4.2-057)
  • [ ] 补充本工程错误层级、重试/缓存配置与日志字段规范的实际样例