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 版本兼容范围以官方文档为准。
原理流程
- 引入 arrow-core 等模块依赖。
- 领域错误定义为 sealed 层级。
- 业务函数返回 Either<Error, Value> 或进入 Raise 作用域。
- 组合层按类型分支处理成功/失败。
代码或图示
// 依赖坐标与版本以官方当前文档为准
// 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 承载成功值。它不是异常:失败是普通值,不抛栈、不中断线程。
原理流程
- 函数返回 Either<Error, Value>。
- 成功构造 Right(value),失败构造 Left(error)。
- 组合函数按一侧映射或短路。
- 边界处折叠为具体响应/默认值。
代码或图示
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 用于函数式流水线一致性。
原理流程
- 可能缺失的值建模为
T?或Option<T>。 - 缺失时分别为 null 或 None。
- 组合操作映射/取默认值。
- 边界处取值并处理缺失。
代码或图示
// 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 载体。
原理流程
- 进入 raise/either 作用域。
- 步骤函数在作用域内运行,失败调用 raise。
- raise 立即短路,错误传出作用域。
- 作用域结果折叠为 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 检测左侧值后从作用域返回。链上步骤只在前序成功时继续。短路不展开栈,错误沿返回值传播。组合顺序即短路顺序。
原理流程
- 块内第一步 bind 成功,取值继续。
- 第二步 bind 到 Left。
- 作用域短路,返回该 Left。
- 后续代码不执行。
代码或图示
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 两侧任意,但工程约定必须固定。
原理流程
- 成功值构造 Right。
- 映射函数默认作用于 Right。
- Left 沿链透传。
- 边界折叠处理左侧。
代码或图示
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 嵌套。
原理流程
- 初始 Either 进入链。
- Right 经 map/flatMap 继续变换。
- Left 直接透传。
- 最终 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 作用于左侧。恢复点应靠近边界,避免业务深处吞错。
原理流程
- Either 到达边界。
- Left 进入恢复分支:默认值或错误映射。
- Right 直接取值。
- 得到普通业务结果返回上层。
代码或图示
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 或给默认值。
原理流程
- 初始 Option 有值或 None。
- map/flatMap 仅在有值时继续。
- None 透传。
- 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 交语言空安全处理。混合使用时在分界点显式转换,类型才能对齐。转换不改变值本身,只换包装。
原理流程
- 外部 nullable 进入:fromNullable 包装。
- Option 链组合处理。
- 边界 orNull 转回 nullable。
- 上层按
?:处理空值。
代码或图示
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 嵌套。
原理流程
- 进入 Raise 作用域。
- ensure 检查条件,失败 raise。
- ensureNotNull 检查 null,失败 raise,成功后类型收窄。
- 通过后继续后续步骤。
代码或图示
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,不可预期/系统故障走异常并在边界兜底。
原理流程
- 判断错误是否业务可预期。
- 可预期:返回 Either/Raise,签名暴露。
- 不可预期:抛异常,边界捕获转 typed error。
- 上层按类型分支处理。
代码或图示
业务校验/外部失败: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 链时,在步骤内用捕获函数包裹第三方调用。
原理流程
- 作用域内调用可能抛异常的代码。
- 未捕获异常正常抛出,不经过 Left。
- 若有捕获组合器,异常被转为 Either。
- 未转换则传播到作用域外。
代码或图示
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。
原理流程
- 评估错误是否需要类型分型。
- 需要领域错误层级 → Either。
- 仅包装异常 → Result。
- 边界处两类结果互相转换。
代码或图示
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 表达式穷尽检查,遗漏分支编译报错。子数据类携带错误上下文(缺失字段、上游错误码)。避免用字符串错误码贯穿类型层。
原理流程
- 定义错误基类 sealed。
- 各失败场景建数据子类携带上下文。
- 业务函数返回 Either<Err, T>。
- 边界 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。
原理流程
- 识别嵌套结构
Either<E, Either<F, T>>。 - 用 flatten 或 flatMap 拍平。
- 统一左侧错误为共同父类型。
- 得到单层 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 遍历集合。选择语义取决于业务:全部校验通过才继续,或汇总所有校验错误。
原理流程
- 列表元素为 Either。
- 短路组合:遇 Left 即返回。
- 累积组合:收集所有 Left 与右侧值。
- 输出聚合 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 链内隐式起协程。
原理流程
- 协程作用域内并发调用各步骤。
- 收集 N 个 Either 结果。
- 组合器按全成功/错误聚合合并。
- 输出整体 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 转换/兜底。传播在类型层可见,编译期检查遗漏分支。
原理流程
- 内层函数返回 Left。
- 中层 bind 透传或映射错误。
- 上层收到 Either 后分支处理。
- 边界折叠为响应/默认值。
代码或图示
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 版本为准,不确定处标待确认。
原理流程
- 第三方调用抛出 Throwable。
- nonFatal 判断是否可恢复。
- 非致命转为 Left 错误。
- 致命异常继续向上传播。
代码或图示
// 示意:捕获并过滤(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。
原理流程
- 进入 option 作用域。
- 各可选步骤 bind,None 即短路。
- 全部有值则组合为 Some。
- 输出 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 接收者当服务定位器使用。
原理流程
- DI 容器装配依赖实例。
- 业务类构造器接收依赖。
- 方法内进入 either/raise 作用域调用依赖。
- 错误沿 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。
原理流程
- 挂起函数声明
suspend fun ...: Either<E, T>。 - 协程作用域内调用并 bind。
- 成功值继续,Left 短路。
- 协程异常单独捕获处理。
代码或图示
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。
概念解释
恢复不是在原短路点继续执行,而是基于错误值开启新计算。恢复策略(默认值、降级调用、重试)在新作用域组织。原作用域已短路结束,资源按作用域规则释放。
原理流程
- 原作用域返回 Left。
- 边界识别错误类型。
- 新作用域执行恢复步骤,可再次失败。
- 恢复结果进入上层链。
代码或图示
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 模拟成功/失败分支。断言检查右侧值或左侧错误类型与上下文。错误分支测试不依赖真实抛异常。
原理流程
- mock 依赖返回 Right 或 Left。
- 调用被测函数。
- 断言结果侧与内容。
- 覆盖恢复与短路路径。
代码或图示
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 在返回类型显式建模。
原理流程
- Kotlin 函数调用 JVM 方法。
- 异常抛出沿栈传播。
- 编译器不检查是否捕获。
- 边界 try/catch 或转 Either。
代码或图示
Java:throws 声明 + 编译期检查
Kotlin:无受检异常,运行期传播
常见误区
- 以为 Kotlin 接口方法能声明受检异常:语言不支持受检声明。
- 依赖调用方记得捕获异常:未捕获异常在运行期暴露。
追问
- Kotlin 调用 Java 受检方法要捕获吗?答:语言层面不强制,但实际异常仍需处理。
- 跨 JVM 互操作注意什么?答:Java 侧按其受检规则理解 Kotlin 抛出的异常。
04.8.4.2-027 什么时候抛异常,什么时候返回 Either?
一句话结论
可预期、需调用方分支处理的业务失败返回 typed error;程序缺陷、不可预期的系统故障抛异常。边界处把异常转换为对外错误模型。
概念解释
判断标准:失败是否属于正常业务流程的一部分。参数非法、外部服务拒绝、资源缺失等可预期 → Either;空指针、状态不一致、编程错误 → 异常。混用会导致错误处理混乱。
原理流程
- 列举可能失败场景。
- 业务可预期 → 领域错误 + Either。
- 缺陷/故障 → 异常并记录。
- 对外边界统一转换响应错误。
代码或图示
可预期:校验失败、上游 4xx、未找到 → Either
缺陷:非法状态、类型错误、OOM → 异常
常见误区
- 用异常做流程控制(循环/分支跳转):性能与可读性差。
- 外部超时也建模为普通领域错误:应区分可重试系统错误与业务拒绝。
追问
- 数据库连接失败算哪类?答:系统故障异常,边界捕获后映射为对外 5xx 错误。
- 校验失败为什么不用异常?答:它是正常分支,签名暴露便于调用方处理与测试。
04.8.4.2-028 异常跨进程/跨边界如何传播?
一句话结论
异常不跨进程传播:跨服务/跨边界时序列化为错误响应(错误码、消息);进程内异常沿调用栈到边界被捕获,转换为 typed error 或响应错误模型。
概念解释
JVM 异常对象只在进程内存有效。对外边界把异常类型与消息映射为可传输错误结构。上层收到的是错误值而非异常对象。跨进程错误再由消费方按错误码处理。
原理流程
- 进程内异常抛出到边界。
- 边界捕获并分类。
- 序列化为错误响应(码、消息、traceId)。
- 消费方解析错误码进入本地处理链。
代码或图示
进程内:Exception → 边界捕获 → 错误响应 DTO
跨进程:错误码 + 消息 → 消费方解析 → 本地错误类型
常见误区
- 把异常堆栈直接对外暴露:安全与信息泄露风险。
- 跨进程依赖异常类型匹配:类型不在线程/进程间传递,按错误码协议对接。
追问
- 错误响应模型在哪层定义?答:API 契约层定义 DTO,领域错误在服务层映射。
- 跨进程重试/超时由谁处理?答:调用方按错误分类决策,见重试专题。
04.8.4.2-029 如何用 try/catch 把第三方库异常转为 Either?
一句话结论
在调用点用 try/catch(或库捕获组合器)包裹第三方调用,按异常类型映射为领域 Left;保留 cause 供日志,不在 Left 中暴露堆栈给业务上层。
概念解释
第三方库多抛异常,进入 typed 链前需要适配层。捕获后区分可恢复/不可恢复,映射对应领域错误。捕获范围最小化,不吞掉致命异常。
原理流程
- 包裹第三方调用。
- catch 匹配异常类型。
- 映射为领域错误 Left。
- 未匹配/致命异常继续传播。
代码或图示
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 链的挂起函数应在内部捕获转换,避免异常打断作用域。
原理流程
- 协程内代码抛出异常。
- 异常沿 Job 父子链传播。
- 普通作用域取消兄弟协程。
- 作用域异常处理器/上层捕获。
代码或图示
runCatching {
scope.launch { risky() }
}.onFailure { /* 处理未捕获异常 */ }
常见误区
- 以为 launch 的异常被静默忽略:未捕获会传播取消作用域。
- 在 Either 函数内不捕获:异常绕过 Left 链向上冒泡。
追问
- SupervisorJob 行为区别?答:子失败不影响兄弟,按隔离需求选择。
- CancellationException 要捕获吗?答:不应作为业务错误捕获,取消需正常传播。
04.8.4.2-031 异常与错误日志应在什么时机记录?
一句话结论
异常在边界捕获点记录上下文与堆栈;typed error 在决策点按需记录,避免每个短路步骤重复打日志。日志记录点与错误处理职责分离。
概念解释
Either 链中途的 Left 不立刻打日志,避免错误在传播路径重复记录;边界根据错误等级决定日志内容。异常日志含堆栈,typed error 日志含错误类型与上下文。
原理流程
- 步骤产生 typed error 沿链传播。
- 边界分类错误等级。
- 异常在捕获点记录堆栈与上下文。
- 日志附带 traceId 与关键业务标识。
代码或图示
中途 Left:不重复日志
边界:按错误级别记录类型/上下文/traceId
异常:捕获点记录堆栈
常见误区
- 每步 bind 失败都打日志:同一错误多条重复记录。
- 日志只打消息不带错误类型:排查无法归类。
追问
- 可重试错误需要日志吗?答:记录重试次数与最终结果,避免每次重试刷屏。
- 日志记录在映射前还是后?答:保留原始错误上下文,映射后记录领域错误与 cause。
04.8.4.2-032 错误信息不可序列化时如何建模?
一句话结论
对外可传输的错误用可序列化数据类(错误码、消息、上下文字段);不可序列化的内部细节(异常对象、连接句柄)不进错误模型,仅在日志侧保留。
概念解释
领域错误分层:内部错误类型可持 Throwable;对外 DTO 只含可序列化字段。跨进程/持久化的错误模型必须纯数据。异常 cause 不随响应外发,日志侧关联 traceId 追溯。
原理流程
- 内部领域错误持上下文与 cause。
- 边界映射为可序列化错误 DTO。
- DTO 含稳定错误码与展示消息。
- 内部细节留在日志与监控。
代码或图示
// 内部:可持 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。
原理流程
- runCatching 执行块捕获异常。
- 成功包装为 success,失败包装 failure。
- map/组合操作处理两侧。
- 边界 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 的领域错误分型更合适。具体编译器限制随版本放宽,落地前核对当前文档。
原理流程
- 确认当前 Kotlin 版本对 Result 位置的规则。
- 公开返回类型评估是否合法。
- 受限或分型不足时改用 Either。
- 局部容错保留 runCatching。
代码或图示
待确认:当前 Kotlin 版本对 Result 作为 public 返回类型的具体约束
常见误区
- 照搬旧博客写法:版本规则已变,以当前编译器行为为准。
- 用 Result 做跨层契约:错误分型与限制都不如 Either。
追问
- 如何验证限制是否存在?答:写最小公开返回 Result 的函数编译验证,以编译器报错为准。
- 内联函数内使用 Result 有何不同?答:内联场景不受部分位置限制,具体规则查标准库文档。
04.8.4.2-035 Result 为什么没有错误类型分型?
一句话结论
Result 失败侧类型固定为 Throwable,无法在类型层面区分业务错误种类;要按错误类型分支,只能运行期 instanceof 判断,编译期不检查穷尽性。
概念解释
Typed error 的价值是错误种类进入类型签名;Result 把失败统一压成异常对象,丢失领域分型。sealed 错误层级配合 Either 才能让编译器检查分支覆盖。Result 适合"成功/失败"二元容错,不适合复杂错误决策。
原理流程
- Result.failure 持 Throwable。
- 分支时运行期判断异常类型。
- 新增错误类型无编译提醒。
- 复杂错误映射在边界手工完成。
代码或图示
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 为领域错误设计,组合更直接。
原理流程
- Result 链逐步 map/flatMap。
- 失败侧保持 Throwable。
- 错误分支需运行期拆包判断。
- 复杂流程嵌套与类型检查不足。
代码或图示
// Result 链:失败侧不可分型
runCatching { a() }.map { b(it) }.flatMapCatching { c(it) }
常见误区
- 多步业务流程全用 Result 串联:错误决策点难以类型化表达。
- 把异常类型判断散落在链中:应在边界统一映射。
追问
- Result 有 zip 类组合吗?答:标准库组合能力有限,多结果聚合可借助扩展库,以当前版本为准。
- 局部步骤用 Result、跨层用 Either 可行吗?答:可在边界转换,注意模型分界清晰。
04.8.4.2-037 runCatching 与协程如何配合?
一句话结论
runCatching 捕获块内抛出的非受检异常;在协程中包裹挂起调用时,注意不要吞掉 CancellationException,取消信号应正常传播。
概念解释
runCatching 是同步容错包装,可包裹挂起函数调用(块内允许挂起)。协程取消异常属于控制流,不应被当作失败结果保留。需要把业务异常转 Either 时,在挂起函数内显式捕获并过滤取消异常。
原理流程
- 挂起函数内 runCatching 包裹调用。
- 普通异常被包装为 Result.failure。
- 取消异常识别后重新抛出。
- 结果按 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 可测试、可穷尽;异常负责程序缺陷与系统故障。日志与监控在边界汇总。
原理流程
- 领域函数返回 typed error。
- 基础设施适配层捕获异常转领域错误。
- 边界把领域错误映射响应 DTO。
- 未捕获异常由全局兜底处理。
代码或图示
领域:Either<DomainErr, T>
适配:异常 → DomainErr
边界:DomainErr → ErrorResponse
兜底:未捕获异常 → 5xx + 日志
常见误区
- 领域层直接抛框架异常:跨层耦合,类型不可见。
- 边界不做兜底:未捕获异常直接暴露给调用方。
追问
- 日志在哪一层打?答:适配/边界记录,领域步骤不重复打。
- 错误监控按什么分类?答:领域错误码 + 异常类型,分别统计业务失败与系统故障。
04.8.4.2-039 重试适用于什么场景,有什么禁忌?
一句话结论
重试适用于瞬时故障(网络抖动、临时不可用、5xx)且操作幂等;禁忌用于非幂等写操作、确定性业务失败(4xx/校验错误)与不可恢复故障。
概念解释
重试是对瞬时失败的恢复策略,不是修复错误的手段。非幂等操作重试可能造成重复下单/扣款。业务拒绝类错误重试无意义且放大负载。重试前先判断错误分类与幂等性。
原理流程
- 调用失败取得错误分类。
- 瞬时 + 幂等 → 进入重试。
- 业务失败/非幂等 → 直接返回错误。
- 超过预算仍失败 → 上报并降级。
代码或图示
可重试:连接超时、503、限流退避后恢复
不重试:参数错误、业务拒绝、重复提交风险
常见误区
- 对所有失败无脑重试:非幂等写产生重复副作用。
- 把重试当稳定性主要手段:根因未除,重试只是缓冲。
追问
- 读操作一定幂等吗?答:多数读幂等,仍需确认是否带副作用。
- 重试次数配置在哪?答:调用方配置,按依赖与错误类型区分。
04.8.4.2-040 指数退避的退避公式是什么?
一句话结论
指数退避按 delay = base * factor^n 递增等待时间,第 n 次重试前等待随次数指数增长,避免固定间隔持续冲击故障依赖。
概念解释
初始等待短,失败越多等待越长,给下游恢复时间。factor 常见 2 左右,配合上限封顶。退避计算基于重试次数,不包含抖动。具体参数按依赖容量与 SLA 调整。
原理流程
- 首次失败记录重试计数。
- 第 n 次等待
base * factor^n。 - 等待时间不超过上限。
- 到达次数上限停止重试。
代码或图示
delay(n) = min(base * 2^n, maxDelay)
示例:base=100ms, factor=2 → 100, 200, 400, 800ms(封顶)
常见误区
- 退避不封顶:下游长时间故障时等待无限增长。
- 固定间隔重试:故障恢复期间持续施压,加剧雪崩。
追问
- 初始间隔怎么定?答:按下游响应时间与超时预算评估,从较小值开始。
- 指数退避与超时预算关系?答:总等待 + 调用时间不超过整体超时预算。
04.8.4.2-041 抖动(jitter)解决什么问题?
一句话结论
抖动在退避等待上加入随机量,避免大量客户端在同一时刻同步重试(惊群),把重试时刻打散到时间窗口内。
概念解释
纯指数退避下各客户端按相同节奏重试,故障恢复瞬间集中打向依赖。jitter 在退避区间内随机取值,错开重试时刻。常见策略:全抖动(0 到退避值)或均衡抖动(半基线 + 半随机)。
原理流程
- 计算指数退避基线。
- 按抖动策略在区间内随机取值。
- 等待随机后的时长再重试。
- 多客户端重试时刻分散。
代码或图示
无抖动:所有客户端 200ms 后同时重试
加抖动:等待在 [0, 200ms] 区间随机分布
常见误区
- 去掉 jitter 只留指数退避:同步重试问题未解决。
- 抖动范围过大:单次重试等待不可控,拉长整体延迟。
追问
- 抖动随机源需要固定种子吗?答:生产用随机源;测试中固定时间/虚拟时间验证退避序列。
- 抖动会影响退避单调性吗?答:随机化后单次间隔不严格递增,整体趋势仍随次数增长。
04.8.4.2-042 最大重试次数与超时预算如何设定?
一句话结论
重试次数与单次超时共同受整体超时预算约束:总预算 ≈ 调用耗时 + 退避等待累计;次数上限防止无限重试,整体超时切断超出预算的链路。
概念解释
重试不是独立参数,要与调用超时、上游 SLA 一起算。次数过多叠加退避会让请求长尾严重。先定整体超时预算,再反推可承受的重试次数与单次超时。
原理流程
- 确定链路整体超时预算。
- 估算单次调用耗时与退避累计。
- 反推最大重试次数。
- 整体超时作为兜底切断。
代码或图示
预算 = 单次超时 × (次数+1) + 退避等待累计
超出预算:停止重试,返回降级/错误
常见误区
- 只配重试次数不配整体超时:长尾请求拖垮线程。
- 重试次数按经验拍脑袋:应结合下游恢复时间与预算计算。
追问
- 重试期间上游已超时怎么办?答:整体超时优先,重试随请求取消停止。
- 不同依赖重试预算不同吗?答:按依赖关键性与 SLA 分别配置。
04.8.4.2-043 哪些错误分类为可重试?
一句话结论
网络瞬时错误、连接失败、限流(429)、服务端 5xx、超时等可重试;参数错误(4xx)、业务拒绝、确定性数据冲突不可重试。分类在适配层明确映射。
概念解释
可重试错误具有"稍后可能成功"的特征;不可重试错误重试结果不变。错误分类决定是否进入重试链。上游错误码与本地异常类型都要映射到分类枚举。
原理流程
- 调用失败取得错误类型/状态码。
- 分类器判断可重试性。
- 可重试进入退避循环。
- 不可重试直接返回错误。
代码或图示
可重试: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 当前文档为准,不臆造坐标。
概念解释
重试组合器包裹一段可能失败的计算,按错误分类、退避与次数策略重复执行。返回最终成功值或最后一次错误。策略(次数、退避、抖动、错误过滤)作为参数配置。
原理流程
- 定义重试策略:次数、退避、抖动、可重试错误判断。
- 组合器包裹计算块。
- 失败按策略等待并重试。
- 成功返回值,耗尽返回错误。
代码或图示
// 示意:重试策略包裹调用(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 等待,释放线程。测试调度器虚拟时间让退避瞬间推进,断言重试序列。重试逻辑必须是挂起安全的,等待可被取消。
原理流程
- 协程内失败后计算退避时长。
delay(backoff)挂起等待。- 虚拟时间测试中推进到期。
- 再次执行调用。
代码或图示
runTest {
val result = service.callWithRetry()
// 虚拟时间下立即验证重试后的结果
}
常见误区
- 重试等待用 Thread.sleep:阻塞线程,协程取消无法及时响应。
- 测试真实等待退避时长:用虚拟时间替代。
追问
- 重试等待可被取消吗?答:delay 响应协程取消,请求取消时重试停止。
- 退避序列如何断言?答:测试调度器记录等待时长,核对指数与抖动分布。
04.8.4.2-046 重试前需要重置哪些状态?
一句话结论
重试应重新发起独立请求:连接、请求体、临时状态不复用上次失败残留;有状态的客户端需确认失败后连接可用,必要时重建。
概念解释
失败可能留下半完成请求或损坏连接。重试不是简单重放同一对象,而是构造新的调用上下文。请求体若含非幂等标识,需保证重试使用同一幂等键而非重复提交。
原理流程
- 首次调用失败。
- 清理/重建连接与临时状态。
- 构造新的请求上下文。
- 按退避后再次调用。
代码或图示
失败 → 连接状态检查/重建 → 新请求上下文 → 重试
常见误区
- 复用失败的连接对象:半损坏状态导致后续重试异常。
- 重试重复生成新业务标识:应保留原幂等键。
追问
- 无状态 HTTP 客户端需要重置吗?答:客户端实例通常可复用,请求对象每次新建。
- 重试中事务回滚了吗?答:本地事务在失败时已回滚,重试开启新事务。
04.8.4.2-047 重试过程如何观测与记录指标?
一句话结论
记录重试次数、最终成功/失败、退避等待与错误分类;指标区分首次成功与重试后成功,日志避免每次重试刷屏,最终结果汇总上报。
概念解释
可观测性回答"重试是否在兜底、哪些依赖频繁重试"。指标按依赖/错误类型统计重试率;日志记录首次失败原因与最终结果。重试中间过程采样记录,避免日志膨胀。
原理流程
- 每次失败记录错误分类。
- 累计重试次数与等待时长。
- 成功/失败上报指标。
- 日志在最终结果点汇总上下文。
代码或图示
指标:retry.count、retry.successAfterRetry、retry.exhausted
日志:首次错误 + 重试次数 + 最终结果
常见误区
- 每次重试打完整错误日志:同一请求多条重复堆栈。
- 只记录最终失败:看不到依赖瞬时故障频率。
追问
- 重试指标按什么维度聚合?答:依赖、操作、错误类型;按监控看板需求设计。
- 重试次数过高说明什么?答:下游不稳定或错误分类过宽,需排查根因而非加次数。
04.8.4.2-048 熔断与重试的边界是什么?
一句话结论
重试处理单次瞬时失败,熔断在依赖持续故障时快速失败、停止调用以保护下游与自身;两者配合:重试兜底抖动,熔断阻断持续性故障。
概念解释
重试在短时间内重复尝试;熔断器统计失败率,打开后直接拒绝调用,给下游恢复时间。故障期无限重试会压垮依赖。熔断状态(关闭/打开/半开)独立于重试策略。
原理流程
- 单次失败先走重试策略。
- 持续失败累计触发熔断。
- 熔断打开期间直接快速失败。
- 半开状态放行探测请求验证恢复。
代码或图示
单次抖动:重试
持续故障:熔断打开 → 快速失败 → 半开探测
常见误区
- 只加重试不加熔断:下游故障时请求全部阻塞在重试等待中。
- 熔断打开仍让重试循环进入:应先经过熔断判断。
追问
- 熔断状态存在哪里?答:按客户端实例/作用域维护,跨实例一致性有限;具体实现见 09 分册流量治理。
- 熔断与超时关系?答:熔断减少无效调用,超时切断单次等待,两者互补。
04.8.4.2-049 如何防护重试风暴?
一句话结论
控制重试次数与退避抖动、设置整体超时、配合熔断与并发上限;避免多层调用各自盲目重试导致请求放大。
概念解释
重试风暴来自多服务链式重试:每层重试放大请求量。防护手段:限制重试预算、抖动打散、熔断快速失败、入口并发控制。重试策略在调用边界统一评审。
原理流程
- 单层重试有次数/预算上限。
- 抖动分散时刻。
- 熔断阻断持续故障。
- 链路上层不叠加无界重试。
代码或图示
防护:次数上限 + 退避抖动 + 整体超时 + 熔断 + 并发限流
常见误区
- 每个下游客户端都配最大重试:链路相乘放大请求。
- 故障期重试仍全量放行:缺乏熔断兜底。
追问
- 上下游重试如何协调?答:上游超时预算大于下游重试总时长,避免上游先超时下游仍重试。
- 重试风暴监控看什么?答:依赖请求量、失败率、等待线程数异常增长。
04.8.4.2-050 幂等键如何配合重试?
一句话结论
写操作重试携带稳定幂等键,下游按键去重:重复请求返回首次结果而不重复执行副作用;重试安全的前提是操作可幂等且键贯穿重试链。
概念解释
幂等键标识同一业务意图,重试多次提交同一键。下游记录键与首次结果,重复请求直接返回。无幂等键的写操作不应自动重试。键在请求生成时确定,重试复用。
原理流程
- 业务发起写操作生成幂等键。
- 首次调用携带键。
- 重试复用同一键。
- 下游按键去重,重复请求不重复生效。
代码或图示
submit(idempotencyKey, request)
失败重试 → 同 key 再次提交 → 下游返回首次结果
常见误区
- 重试时重新生成业务单号:下游视为新请求,重复生效。
- 幂等键只在客户端生成不传下游:去重无法落地。
追问
- 幂等键有效期多长?答:按下游保留策略,覆盖重试与恢复窗口。
- 读操作需要幂等键吗?答:读天然幂等;带副作用的读接口需单独评估。
04.8.4.2-051 Caffeine 在 Kotlin/JVM 后端如何落地?
一句话结论
Caffeine 是 JVM 高性能内存缓存库,Kotlin 后端通过其 Java API 构建缓存实例,配置过期、容量与淘汰策略;缓存实例作为依赖注入到服务层。
概念解释
Caffeine 提供进程内本地缓存实现,支持 W-TinyLFU 淘汰、异步加载、统计。Kotlin 调用其建造器 API 配置 key/value 与策略。本地缓存不跨实例共享,分布式场景配合远端缓存。
原理流程
- 引入 Caffeine 依赖。
- 建造器配置容量、过期、刷新规则。
- 缓存实例注入服务。
- 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 若可变,被调用方修改会影响缓存中其他读取者。缓存对象应视为不可变快照,或拷贝出入。
原理流程
- 按业务唯一性构造 key。
- value 存放不可变数据快照。
- 加载时组装缓存对象。
- 读取方不修改缓存实例。
代码或图示
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)在下次访问时异步重载,与删除过期不同。过期策略与容量淘汰共同作用。
原理流程
- 配置过期基准时间。
- 写入/访问时更新时间戳。
- 后台清理过期条目。
- 过期后下次访问重新加载。
代码或图示
Caffeine.newBuilder()
.expireAfterAccess(Duration.ofMinutes(5))
.refreshAfterWrite(Duration.ofMinutes(2))
常见误区
- 时效性强的数据不设写过期:陈旧数据长期驻留。
- 访问过期导致热点永不过期:变更数据需配合主动失效。
追问
- 过期与刷新区别?答:过期删除后同步加载;刷新异步更新,旧值短暂可用。
- 如何处理数据主动变更?答:主动失效对应 key,不只依赖 TTL。
04.8.4.2-054 最大容量与淘汰策略如何配置?
一句话结论
maximumSize 限定条目数,Caffeine 按 W-TinyLFU 策略淘汰低频条目;容量按内存预算与热点规模设定,避免缓存撑爆堆内存。
概念解释
缓存容量受 JVM 堆约束。淘汰策略优先保留高频访问条目。设置过小命中率低,过大占用内存。可按权重估算每条目大小调整容量。
原理流程
- 估算热点条目数与单条内存。
- 设定 maximumSize/权重上限。
- 超容量时淘汰低频条目。
- 监控命中率与内存占用调参。
代码或图示
Caffeine.newBuilder()
.maximumWeight(10_000_000)
.weigher { _, v -> (v as Any).toString().length }
常见误区
- 不设容量上限:内存无限增长风险。
- 容量只看条目数忽略 value 大小:大对象场景内存估算失真。
追问
- 淘汰指标能监控吗?答:Caffeine 统计记录 eviction/命中数据,开启统计后读取。
- 热点突变导致频繁淘汰怎么办?答:调整容量或评估本地缓存适用性。
04.8.4.2-055 缓存空值如何防穿透?
一句话结论
对查询不到的结果缓存空标记/空对象并设较短 TTL,避免不存在的 key 反复打到下游;同时区分"空值"与"未缓存",防止空缓存长期掩盖新建数据。
概念解释
缓存穿透指大量查询不存在的数据,缓存不命中全部压到下游。空值缓存用短 TTL 限制空结果停留时间。空对象需与真实值区分,数据新增后能被刷新。
原理流程
- 下游查询返回缺失。
- 缓存空标记 + 短过期。
- 后续相同查询命中空标记,不再打下游。
- 空标记过期后回源查询。
代码或图示
// 空值用特殊标记包装(示意)
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 做并发去重;远端缓存用锁/单飞机制。
原理流程
- 并发请求同 key 未命中。
- 单飞结构按 key 登记进行中的加载任务。
- 首个请求回源,其余等待同一 Deferred。
- 结果完成后全部共享。
代码或图示
并发请求 key=1 ──▶ 仅 1 个回源任务 ──▶ 结果共享等待者
常见误区
- 每个未命中请求独立回源:热点过期瞬间压垮下游。
- 单飞锁粒度太粗:不同 key 被串行化,降低并发。
追问
- 本地缓存单飞如何实现?答:按 key 维护进行中 Deferred/未来值,完成后放入缓存。
- 单飞失败如何处理?答:回源失败应释放登记,允许后续重试;失败结果不长期缓存。
04.8.4.2-057 协程场景下如何缓存挂起计算结果?
一句话结论
缓存挂起函数结果时,值以完成的 Deferred/结果形式缓存,并发访问共享同一挂起任务;避免缓存 suspend 函数引用导致每次调用重新挂起。
概念解释
普通缓存存计算值;协程加载是异步的,需缓存"已完成的异步结果"或进行中任务。加载器挂起执行回源,结果存入缓存。单飞与缓存结合:进行中任务与完成结果都按 key 管理。
原理流程
- 未命中时启动挂起加载任务。
- 进行中任务按 key 登记。
- 完成后结果入缓存。
- 后续命中直接取结果。
代码或图示
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 最终一致。
原理流程
- 读:缓存命中返回,未命中回源回填。
- 写:更新数据库。
- 删除对应缓存条目。
- 其他实例待 TTL 过期或接收失效通知。
代码或图示
读:cache → miss → DB → 回填
写:DB 更新 → 删 cache
常见误区
- 写库失败仍删/更缓存:缓存与库不一致。
- 多实例本地缓存假设实时一致:需失效广播或接受 TTL 窗口。
追问
- 先删缓存再写库有什么风险?答:并发读回填旧值,通常先写库再删缓存。
- 缓存与数据库双写一致性要求高怎么办?答:评估远端缓存 + 失效通知,本地缓存只做热点加速。
04.8.4.2-059 本地缓存与多级缓存如何配合?
一句话结论
本地缓存(Caffeine)挡热点低延迟访问,远端缓存(Redis 类)跨实例共享;多级查询先本地后远端再数据库,各级 TTL 与失效策略分层配置。
概念解释
本地缓存快但不共享、容量受限;远端缓存共享但有网络开销。多级缓存降低数据库压力,也带来一致性层级问题。后端工程按数据热点与一致性要求决定是否引入多级。
原理流程
- 查本地缓存。
- 未命中查远端缓存。
- 再未命中回源数据库。
- 逐级回填。
代码或图示
请求 → 本地缓存 → 远端缓存 → 数据库
回填:DB → 远端 → 本地
常见误区
- 多级缓存各级策略不协调:同一数据过期窗口叠加不一致。
- 本地缓存长时间持有远端已失效数据:缩短本地 TTL 或配失效通知。
追问
- 多级缓存击穿如何防护?答:各级分别单飞,避免穿透到数据库。
- 本节为何不展开远端缓存理论?答:通用缓存架构见 09 分册,本节聚焦 Kotlin 本地库落地。
04.8.4.2-060 缓存监控看哪些指标?
一句话结论
核心指标:命中率/未命中率、加载次数、回填耗时、淘汰数、缓存大小与内存占用;按 key 维度识别热点与异常回源。
概念解释
命中率判断缓存是否有效;未命中突增可能是过期策略问题或流量变化。回填耗时与下游压力相关。淘汰数反映容量是否不足。指标配合业务量趋势分析。
原理流程
- 开启缓存统计。
- 采集命中/未命中/淘汰计数。
- 监控缓存大小与加载耗时。
- 按指标调整容量与 TTL。
代码或图示
hit rate = hits / (hits + misses)
监控:命中率、回填次数、淘汰条目、内存占用
常见误区
- 只看命中率不看未命中绝对量:高命中率下大量回源仍可能压垮下游。
- 不监控缓存大小:容量超限静默淘汰热点。
追问
- Caffeine 统计如何开启?答:建造器启用 recordStats,读取快照指标;具体 API 以库版本为准。
- 命中率低怎么优化?答:检查 TTL、容量、key 设计与数据访问模式。
04.8.4.2-061 远端缓存的序列化要注意什么?
一句话结论
远端缓存值需序列化为存储格式(JSON/二进制),注意类型版本兼容、字段演进与序列化成本;本地缓存存对象引用,无序列化开销。
概念解释
跨进程缓存必须可序列化。格式演进(字段增删、默认值)要兼容旧条目。序列化/反序列化耗时计入缓存访问成本。kotlinx-serialization 等编译期序列化方案可用于缓存值。
原理流程
- value 选择可序列化模型。
- 写入远端时编码。
- 读取时解码为对象。
- 格式变更处理兼容旧条目。
代码或图示
本地:对象引用直接存取
远端:对象 ↔ 序列化格式 ↔ 存储
常见误区
- 缓存含不可序列化引用:远端写入失败。
- 改字段结构不清旧缓存:解码旧格式异常。
追问
- 序列化失败的旧条目如何处理?答:解码异常视为未命中回源,不直接抛出中断请求。
- 二进制格式与 JSON 如何取舍?答:按性能、可读性与跨语言需求评估。
04.8.4.2-062 测试中缓存替身如何处理?
一句话结论
单元测试可用内存 Map 替身缓存接口,验证回填与失效逻辑;缓存本身的策略(过期、淘汰)由缓存库测试覆盖,业务测试只验交互。
概念解释
业务代码依赖缓存抽象接口,测试注入内存实现。过期/淘汰策略是库职责,不在业务单测重复验证。集成测试可接真实缓存实例验证行为。
原理流程
- 定义缓存访问抽象接口。
- 单测注入内存 fake。
- 验证读写、失效调用。
- 集成测试接真实 Caffeine/远端。
代码或图示
interface UserCache {
fun get(id: Long): User?
fun put(id: Long, user: User)
}
常见误区
- 单测启动真实缓存实例验证淘汰策略:混入库职责,反馈慢。
- 业务代码直接依赖具体缓存类:无法替换替身。
追问
- 缓存失效逻辑怎么测?答:fake 记录 remove 调用,断言写库后对应 key 被失效。
- 并发回填在单测如何验证?答:集成/并发测试覆盖,单测验证接口契约。
04.8.4.2-063 缓存与事务的边界如何处理?
一句话结论
事务提交成功后再失效缓存,避免未提交事务回填脏数据;缓存删除不在数据库事务内,回滚后不应误删有效缓存。
概念解释
先写库后删缓存的顺序要考虑事务边界:事务未提交时其他会话读不到新值,此时删缓存可能被旧值回填。事务提交后执行失效动作。跨实例失效通过后续通知/TTL 兜底。
原理流程
- 开启事务写库。
- 事务提交成功。
- 提交后删除/失效缓存。
- 未提交回滚则不动作缓存。
代码或图示
事务内:更新 DB
提交后:失效 cache
回滚:不触碰缓存
常见误区
- 事务内删缓存后回滚:有效缓存被误删,回源可能读到旧库值。
- 异步失效晚于并发读:短暂不一致窗口由 TTL 与策略接受。
追问
- 事务提交钩子在哪里执行?答:按框架事务回调,提交后再触发缓存失效。
- 强一致要求下缓存怎么办?答:关键数据不进缓存或缩短窗口,评估一致性需求。
04.8.4.2-064 空对象缓存与 TTL 抖动有什么作用?
一句话结论
空值短 TTL 配合随机抖动,避免同一批空值同时过期导致集中回源;TTL 抖动把过期时间打散到窗口内。
概念解释
固定 TTL 下批量写入的空值同时失效,形成二次穿透。抖动在基础 TTL 上加减随机区间,过期时刻分散。空值 TTL 本身短,抖动进一步平滑回源峰值。
原理流程
- 空值缓存基础 TTL。
- 过期时间加随机抖动区间。
- 同批空值错峰过期。
- 回源请求分散到时间窗口。
代码或图示
固定 TTL=60s:全部 60s 后同时过期
抖动:60s ± 10s,错峰过期
常见误区
- 正常热数据也加过大抖动:过期行为不可预期。
- 空值 TTL 过长:缺失数据长期不刷新。
追问
- TTL 抖动影响数据一致性吗?答:只调整过期时刻,数据内容不变;窗口内允许短暂陈旧。
- 随机种子在缓存中需要固定吗?答:运行期随机即可,测试中固定时间验证。
04.8.4.2-065 并发回填如何控制?
一句话结论
按 key 单飞合并并发加载,回填任务互斥登记;加载失败释放登记允许重试,成功结果写入缓存。不同 key 并发不互相阻塞。
概念解释
并发回填控制两层:同一 key 只允许一个加载者,其他等待;不同 key 并行加载。加载中状态与完成结果分别管理。失败任务不应长期占据单飞登记。
原理流程
- 未命中检查进行中任务登记。
- 已有任务则等待其结果。
- 无任务则启动加载并登记。
- 完成写入缓存,失败清理登记。
代码或图示
key=1:等待中任务共享
key=2:独立并行加载
常见误区
- 全局锁串行所有回填:并发性能下降。
- 失败任务登记不清理:后续请求永久等待坏结果。
追问
- 回填超时如何处理?答:加载任务受整体超时约束,超时失败并释放单飞。
- 缓存库内置并发加载吗?答:Caffeine 加载器有同步/异步去重能力,协程封装按实现核对。
04.8.4.2-066 Kotlin 后端日志门面选择什么?
一句话结论
JVM 后端通用选择 slf4j 作为日志门面,具体实现(logback 等)按工程生态接入;Kotlin 代码通过门面 API 打日志,不直接绑定实现库。
概念解释
门面隔离日志实现,业务代码依赖门面接口,实现可替换。Kotlin 常用属性委托或门面静态调用打日志。日志框架版本与后端框架(Spring/Ktor 生态)配套,坐标以官方文档为准。
原理流程
- 引入 slf4j 门面依赖。
- 绑定日志实现。
- 类中获取 logger 实例。
- 按级别输出结构化日志。
代码或图示
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、业务标识、错误类型与上下文;消息文本简短,细节放字段,便于机器检索聚合。
概念解释
非结构化文本日志难以按字段过滤。结构化日志把业务标识、错误码、耗时等作为独立字段。字段命名统一约定,避免每条日志随意拼字符串。异常堆栈单独字段记录。
原理流程
- 定义公共字段集合。
- 打日志时传入键值上下文。
- 编码器输出 JSON 结构。
- 日志平台按字段检索聚合。
代码或图示
{
"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 是门面提供的上下文机制。
原理流程
- 请求入口向 MDC 写入上下文字段。
- 同线程后续日志读取 MDC。
- 编码器把字段加入日志结构。
- 请求结束清理 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 或在调度时桥接。
原理流程
- 请求线程 MDC 写入字段。
- 协程挂起切换线程。
- 恢复线程 ThreadLocal 无 MDC。
- 后续日志缺 traceId 等字段。
代码或图示
Thread A:MDC = {traceId}
协程挂起 → Thread B 恢复:MDC 为空
常见误区
- 在同步线程模型下写的 MDC 代码直接搬到协程:切换后上下文丢失。
- 依赖线程池同一线程处理:协程不保证线程亲和。
追问
- 解决方案方向是什么?答:把诊断上下文作为 CoroutineContext 元素,调度恢复时同步到 MDC;具体桥接库以工程选型为准。
- 阻塞线程池模型有此问题吗?答:单线程贯穿请求时 MDC 可用;线程切换同样丢失。
04.8.4.2-070 协程与 ThreadLocal 为什么不天然匹配?
一句话结论
ThreadLocal 绑定线程,协程绑定调度器与 Continuation;协程可在多线程间迁移,ThreadLocal 快照不随恢复传播,需要显式上下文元素携带值。
概念解释
线程是执行载体,协程是逻辑任务。挂起恢复后执行线程可能改变,ThreadLocal 跟随线程而非协程。协程上下文(CoroutineContext)才是随协程传播的状态载体,诊断信息应放这里。
原理流程
- 协程启动时上下文确定。
- 挂起后调度器选择线程恢复。
- ThreadLocal 不复制到新线程。
- 上下文元素随协程传播,恢复时写入对应线程。
代码或图示
ThreadLocal:随线程存活
CoroutineContext:随协程作业存活
常见误区
- 用 ThreadLocal 存协程请求级状态:跨线程丢失。
- 假设
Dispatchers.IO固定线程:线程池复用与切换都可能发生。
追问
- 如何实现上下文元素传播?答:定义实现 CoroutineContext.Element 的类型,随协程构建携带;调度钩子在恢复时同步 MDC。
- 哪些库处理了这个桥接?答:协程日志/诊断库提供上下文桥接,选型与 API 以当前版本为准。
04.8.4.2-071 slf4j 桥接与日志实现如何选择?
一句话结论
业务代码依赖 slf4j 门面,实现按工程生态选择(如 logback);历史遗留日志 API 通过桥接器统一到门面,避免多套日志输出。
概念解释
桥接器把其他日志 API(旧实现/ Jakarta 等)调用重定向到 slf4j,实现类负责实际输出。后端框架自带默认实现时,工程按其约定接入。依赖中排除冲突实现,保证单一输出链路。
原理流程
- 引入 slf4j 门面。
- 绑定日志实现。
- 遗留 API 经桥接器重定向。
- 统一编码器与配置输出。
代码或图示
业务代码 → slf4j 门面 → 日志实现(logback 等)
遗留 API → 桥接器 → slf4j 门面
常见误区
- classpath 多实现并存:输出冲突或告警,需排除多余绑定。
- 桥接器与实现循环引用:按官方依赖说明排除对应模块。
追问
- 如何检查日志链路?答:启动日志查看实际实现绑定,依赖树排查多余桥接/实现。
- 框架默认实现能替换吗?答:可按门面规则换实现,注意配置格式兼容。
04.8.4.2-072 日志级别使用规范是什么?
一句话结论
ERROR 用于需介入的故障,WARN 用于可恢复异常/可疑状态,INFO 记录关键业务节点,DEBUG/TRACE 用于排查细节;生产默认 INFO,避免级别滥用。
概念解释
级别决定输出与告警阈值。业务成功流程用 INFO,瞬时重试/降级用 WARN,系统故障用 ERROR。DEBUG 仅排障开启。级别语义团队统一,避免 ERROR 满天飞失去告警意义。
原理流程
- 判断事件严重程度。
- 按规范选择级别。
- 生产配置输出阈值。
- 告警规则关联 ERROR/WARN。
代码或图示
ERROR:故障需处理
WARN:异常但已恢复/降级
INFO:关键流程节点
DEBUG/TRACE:调试细节
常见误区
- 业务正常分支打 ERROR:告警噪音掩盖真实故障。
- 排障 DEBUG 留在生产默认开启:日志量过大。
追问
- 重试失败用什么级别?答:最终失败 ERROR,中间重试 WARN/DEBUG 按策略。
- 级别能动态调整吗?答:按实现支持的运行期调级能力,生产谨慎开启。
04.8.4.2-073 日志中为什么禁止打印敏感信息?
一句话结论
密码、密钥、证件号、银行卡等敏感数据不得进入日志;日志可能被多系统采集留存,泄露风险高。敏感字段在输出前脱敏或排除。
概念解释
日志访问范围通常大于业务数据库。结构化字段与消息文本都需检查敏感内容。脱敏规则按字段名/类型统一处理,而非靠开发者自觉。合规要求对个人信息最小化记录。
原理流程
- 识别敏感字段清单。
- 日志输出前按规则脱敏/排除。
- 结构化字段不写入敏感原值。
- 定期审计日志样本。
代码或图示
禁止:password、token、idCard、cardNo 原值
允许:脱敏掩码、业务非敏感标识
常见误区
- 异常对象 toString 含敏感字段:堆栈/消息可能带出,需检查异常内容。
- 调试日志临时打印请求体:遗留到生产造成泄露。
追问
- 脱敏规则放哪层?答:日志编码器/序列化层统一处理,业务侧避免传敏感原值。
- 排障需要敏感信息怎么办?答:按合规流程受控查看,不进常规日志。
04.8.4.2-074 异常日志如何记录堆栈?
一句话结论
记录异常时把 Throwable 作为最后一个参数传给日志方法,编码器输出堆栈;只打消息不打堆栈会丢失根因定位信息。
概念解释
日志门面方法支持传入异常对象,输出堆栈轨迹。同一异常在捕获点记录一次,避免多层重复打堆栈。堆栈配合 traceId 与业务上下文字段。
原理流程
- 捕获异常取得 Throwable。
- 日志方法传入异常参数。
- 编码器输出类型、消息与堆栈。
- 上层不再重复记录同一异常。
代码或图示
logger.error("order ${orderId} failed", ex)
常见误区
- 只打
ex.message:堆栈丢失,无法定位代码位置。 - 每层都打同一异常堆栈:日志重复,根因被淹没。
追问
- 业务异常需要打堆栈吗?答:可按级别记录类型与上下文;预期业务失败不必每次全堆栈。
- 堆栈中敏感信息如何处理?答:检查异常消息与类名,必要时脱敏后输出。
04.8.4.2-075 日志与 Either 错误如何配合?
一句话结论
Either 链中途不打日志,错误在边界按类型决定日志级别与字段;日志记录领域错误类型、上下文与 cause,不重复记录每个短路步骤。
概念解释
typed error 沿值传播,日志职责集中在边界。边界识别错误分级:业务拒绝 DEBUG/INFO,可恢复 WARN,系统故障 ERROR。原始 cause 保留在错误对象中供边界记录。
原理流程
- 步骤产出 Left 沿链传播。
- 边界匹配错误类型。
- 按级别输出结构化日志。
- cause 堆栈按需记录。
代码或图示
result.onLeft { err ->
logger.warn { "order failed: ${err.code}, orderId=${err.orderId}" }
}
常见误区
- 每个 bind 失败点打日志:同一错误多条记录。
- 边界只打错误消息不带类型字段:无法聚合统计。
追问
- 错误日志在 service 还是 handler 层打?答:按分层约定,通常在接近对外边界处统一记录。
- 重试中的错误何时记?答:首次失败采样/DEBUG,最终失败汇总记录。
04.8.4.2-076 异步日志对性能有什么影响?
一句话结论
异步日志把写盘操作移出业务线程,降低日志 IO 对请求延迟的影响;但队列满、丢日志策略与崩溃时日志丢失需权衡。
概念解释
同步日志在业务线程阻塞写输出;异步队列先入队由后台线程写。高日志量下异步保护业务吞吐,代价是队列内存与极端情况丢弃策略。后端按日志量级选择实现配置。
原理流程
- 业务线程写日志入队列。
- 后台日志线程消费输出。
- 队列满时按策略阻塞或丢弃。
- 关闭时冲刷剩余日志。
代码或图示
业务线程 → 日志队列 → 后台写盘
常见误区
- 假设异步日志零成本:队列与序列化仍占用 CPU/内存。
- 不配置队列满策略:高峰时阻塞业务或丢日志。
追问
- 崩溃时异步日志会丢吗?答:未冲刷队列可能丢失,关键事件按可靠性要求选择输出方式。
- 日志序列化在哪个线程?答:按实现配置,注意序列化开销位置。
04.8.4.2-077 traceId 如何生成与透传?
一句话结论
请求入口生成或继承上游 traceId,写入 MDC/协程上下文;跨调用通过请求头透传,日志与下游调用携带同一标识,串联整条链路。
概念解释
traceId 是链路关联主键。入口无上游标识则生成,有则继承。上下文随线程/协程传播,出站请求注入请求头。日志、指标、错误按 traceId 关联。
原理流程
- 入口检查上游请求头。
- 无标识则生成 traceId。
- 写入诊断上下文。
- 出站调用透传请求头,日志自动携带。
代码或图示
上游请求头 traceId → 入口继承/生成 → MDC/协程上下文 → 日志 + 下游请求头
常见误区
- 内部生成标识不透传给下游:链路断裂。
- traceId 不随协程上下文传播:异步日志缺失标识。
追问
- traceId 与 span 概念区别?答:trace 标识整条链路,span 标识单次调用;完整链路追踪见 08 分册可观测性。
- 消息队列场景如何透传?答:标识写入消息头,消费侧恢复到上下文。
04.8.4.2-078 测试中断言日志输出怎么做?
一句话结论
测试中替换日志 appender/捕获器收集日志记录,断言级别、消息字段与错误类型;验证关键日志是否输出,而非依赖人工查看控制台。
概念解释
日志是可观测性输出,关键决策点的日志应可测试。测试挂载捕获器收集记录,按级别/字段断言。避免在业务代码为测试暴露 logger,通过日志框架测试扩展接入。
原理流程
- 测试挂载日志捕获器。
- 执行业务用例。
- 收集输出记录。
- 断言级别、消息与上下文字段。
代码或图示
测试 appender 收集记录 → 断言 warn 级别 + orderId 字段
常见误区
- 断言日志完整文本:文案调整导致脆弱测试,断言级别与关键字段。
- 业务代码注入 logger 接口便于测试:可接受,但优先框架测试扩展。
追问
- 异步日志如何在测试中收集?答:同步输出或等待队列冲刷后断言。
- 日志断言覆盖哪些点?答:错误边界、关键降级与重试结果,不逐条断言正常 INFO。
04.8.4.2-079 日志框架在 Ktor/Spring 中接入有何差异?
一句话结论
两者后端 JVM 生态均以 slf4j 为门面,差异在默认实现与配置加载方式;业务代码日志 API 一致,接入配置按各自框架约定。
概念解释
Spring 生态常默认 logback 并随应用配置加载;Ktor 后端按工程依赖接入门面与实现。业务类通过门面打日志,框架差异只体现在依赖装配与配置文件。本节不展开框架细节,见 06 分册。
原理流程
- 框架工程引入门面与实现。
- 配置文件定义输出格式与级别。
- 业务代码门面调用。
- 实现按配置输出。
代码或图示
Ktor/Spring:slf4j 门面 + 各自默认实现装配
业务代码:同一套 logger 调用
常见误区
- 业务代码绑定框架特定日志 API:跨框架不可复用。
- 忽略框架默认实现自带依赖:与手动引入实现冲突。
追问
- 日志配置文件格式随实现不同吗?答:是,按所选实现的配置格式编写。
- 多模块共享日志配置?答:公共配置统一,模块按需调整级别。
04.8.4.2-080 结构化日志的 JSON encoder 如何配置?
一句话结论
日志实现配置 JSON 编码器,输出字段化日志(时间、级别、消息、MDC 字段、异常);字段顺序与命名按团队规范,输出供日志平台解析。
概念解释
编码器决定日志输出格式。JSON 模式把 MDC 与结构化参数转为 JSON 字段。配置包含时间格式、字段名、堆栈输出方式。开发环境可读文本,生产结构化 JSON。
原理流程
- 选择 JSON 编码器实现。
- 配置公共字段与输出模板。
- MDC/上下文字段纳入 JSON。
- 异常序列化为独立字段。
代码或图示
{"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 混用)。新增字段补充规范。
原理流程
- 定义公共与业务字段命名表。
- 各模块按表输出字段。
- 日志平台按字段名聚合。
- 新字段评审后加入规范。
代码或图示
traceId, orderId, userId, errorCode, latencyMs, retryCount
常见误区
- 字段名随开发者习惯起:检索口径分裂。
- 同一概念多字段并存:清理冗余命名。
追问
- 嵌套字段如何命名?答:按层级前缀或对象结构定义,规范中列出示例。
- 字段类型有要求吗?答:标识用字符串,数值用数值类型,避免全字符串序列化。
04.8.4.2-082 启动期关键信息日志应包含什么?
一句话结论
应用启动日志记录版本、环境、关键配置摘要与依赖就绪状态,便于部署后确认实例身份与配置生效;不打印密钥等敏感配置。
概念解释
启动日志回答"哪个实例、什么版本、什么环境、依赖是否就绪"。配置摘要区分敏感与非敏感项。启动失败时定位配置缺失或依赖连接问题。运行期业务日志不与启动信息混杂。
原理流程
- 应用启动读取版本与环境信息。
- 输出非敏感配置摘要。
- 依赖初始化就绪后记录状态。
- 启动失败记录错误上下文。
代码或图示
启动:app=order-service, version=1.2.0, env=prod, db=connected
常见误区
- 启动日志打印全部配置含密钥:敏感信息泄露。
- 依赖未就绪即记启动成功:健康状态与日志不一致。
追问
- 版本信息从哪里读?答:构建元数据/清单文件注入,不硬编码。
- 启动日志级别?答:INFO 记录节点状态,异常 ERROR。
04.8.4.2-083 重复异常日志如何降噪?
一句话结论
高频重复异常按类型采样或聚合记录,保留首次完整堆栈与后续计数,避免同一故障刷爆日志;降噪规则不影响关键故障告警。
概念解释
下游故障时同一异常短时间重复出现,逐条全堆栈日志淹没有效信息。按异常类型/窗口聚合,输出次数与最新样例。告警仍按错误率触发,降噪只影响日志量。
原理流程
- 识别重复异常类型。
- 窗口内计数聚合。
- 首次记录完整堆栈,后续记计数。
- 窗口结束输出汇总。
代码或图示
100 次同一异常 → 1 条完整堆栈 + "occurred=100" 计数
常见误区
- 降噪后完全不留样例:新异常类型无法排查。
- 采样掉关键错误:ERROR 级故障不采样,只压重复 WARN/高频错误。
追问
- 降噪在日志库还是业务层做?答:按实现支持的去重/采样能力,业务层避免重复打。
- 计数如何上报监控?答:错误计数走指标,日志保留样例与上下文。
04.8.4.2-084 日志配置如何外部化?
一句话结论
级别、输出目标、格式由外部配置(配置文件/环境变量/配置中心)管理,不硬编码在代码里;不同环境用不同配置,可在不改代码的前提下调整日志。
概念解释
日志配置随环境变化:开发 DEBUG,生产 INFO。配置外部化支持运行期调整级别与输出。敏感配置不进代码仓库。启动期读取配置初始化日志系统。
原理流程
- 日志实现从配置源读取级别/格式/目标。
- 环境变量或配置中心覆盖默认值。
- 初始化 logger 上下文。
- 运行期按配置输出。
代码或图示
代码:门面调用,不含级别/目标配置
配置:文件/环境变量/配置中心
常见误区
- 代码里写死日志级别与路径:环境切换需改代码。
- 配置含真实密钥:日志配置也属敏感配置管理范围。
追问
- 运行期动态调级别怎么做?答:按实现提供的管理接口/配置中心刷新,能力以实现文档为准。
- 测试环境日志如何隔离?答:测试配置独立输出,不污染生产日志路径。
04.8.4.2-085 协程诊断上下文如何随上下文元素传递?
一句话结论
把 traceId 等诊断信息封装为 CoroutineContext 元素,随协程构建与子协程传播;调度恢复时该元素写入 MDC,使日志在协程切换后仍携带上下文。
概念解释
上下文元素是协程级状态载体,替代 ThreadLocal。元素随 async/launch 父子传播。桥接钩子在线程恢复时把元素值同步到 MDC,结束时清理。具体实现类库按工程选型。
原理流程
- 定义诊断上下文元素。
- 协程构建时携带元素。
- 子协程继承父上下文。
- 调度恢复时同步 MDC,日志读取。
代码或图示
// 示意:上下文元素携带 traceId(实现方式以所选库为准)
// launch(DiagnosticElement(traceId)) { ... }
常见误区
- 只在入口写 MDC 不做上下文元素:线程切换后丢失。
- 子协程未继承上下文:async/launch 默认继承,自定义上下文注意合并规则。
追问
- 上下文元素如何合并?答:同类型元素按上下文规则覆盖,键唯一;具体合并语义以协程库为准。
- 线程池阻塞桥接场景怎么办?答:进入阻塞线程前快照上下文,返回后恢复,注意清理。
04.8.4.2-086 画出一个带缓存、重试与日志的网关调用链。
一句话结论
完整链路:读缓存 → 未命中进入重试策略 → 错误分类 → 退避抖动重试 → 成功回填缓存 → 边界记录日志与指标;各环节错误分类与上下文贯穿。
概念解释
横切能力按顺序组合:缓存挡热点,重试兜底瞬时故障,日志/指标观测全链路。每步失败按类型决定下一步。链路设计要明确缓存失效、重试预算与日志点。
原理流程
- 请求先查本地/远端缓存。
- 未命中走网关调用,包裹重试策略。
- 可重试错误退避重试,耗尽后返回错误。
- 成功结果回填缓存,边界记录指标与日志。
代码或图示
请求 → 缓存命中? ──是→ 返回
└─否→ 重试策略 → 网关调用 → 成功回填缓存 / 失败分类返回
全程:traceId 上下文 + 指标 + 边界日志
常见误区
- 缓存结果不区分错误与空值:失败响应被缓存放大。
- 重试包裹缓存读取:缓存命中不应触发重试。
追问
- 缓存失效后并发回填如何衔接?答:单飞合并回源请求,见缓存专题。
- 链路日志在哪打?答:缓存命中/未命中计数指标化,最终结果边界记录。
04.8.4.2-087 错误如何从底层 Either 向上聚合设计?
一句话结论
底层模块定义自身领域错误,中层 mapLeft 转换为对外错误层级,顶层聚合为统一响应错误;每层错误类型收敛,不把内部异常细节泄漏到边界。
概念解释
错误沿调用链向上传播并逐层翻译:仓储错误 → 领域错误 → API 错误 DTO。每层只暴露自己层级的错误类型。聚合时多来源错误纳入同一 sealed 父类型,边界穷尽匹配。
原理流程
- 底层返回
Either<RepoErr, T>。 - 中层 mapLeft 映射为领域错误。
- 多步骤聚合为整体领域错误。
- 边界映射响应错误码。
代码或图示
repo.find(id)
.mapLeft { it.toDomain() }
.flatMap { orderService.prepare(it) }
.mapLeft { it.toResponse() }
常见误区
- 底层异常类型直接抛到顶层:跨层耦合,边界无法稳定分型。
- 每层错误新增子类不更新上层匹配:穷尽性检查暴露遗漏。
追问
- 跨模块错误映射放哪?答:模块边界适配层,保持内部错误私有。
- 聚合多个底层错误如何合并?答:按业务语义选主错误或收集列表,见聚合题。
04.8.4.2-088 多依赖并行调用时错误如何聚合?
一句话结论
并行收集各依赖 Either,按策略合并:快速失败保留首个错误,或聚合全部错误列表;并行任务的异常先捕获为 Either 再纳入聚合。
概念解释
并行场景错误组合与顺序链不同。需要全部结果时收集所有失败;任一关键失败即中止时快速失败。协程并发启动后 await 收集结果列表,再用序列组合器合并。
原理流程
- 协程作用域并发调用各依赖。
- 各自返回 Either。
- 按策略合并:首个 Left 或错误集合。
- 聚合 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,遗留代码逐步适配。团队约定错误层级、转换点与禁用模式。评审保证风格一致。
原理流程
- 选定引入范围(领域/服务层)。
- 定义错误层级与示例模板。
- 新代码按规范使用。
- 遗留代码按需重构,评审把关。
代码或图示
试点:新服务领域层 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 不替代语言空安全,而是提供类型级组合。评估标准库是否已满足,再引入库依赖。
原理流程
- 识别需求:空值/容错/错误分型/组合。
- 标准库能覆盖则不引 Arrow。
- 需要 typed error 与组合器再引入。
- 依赖范围控制在 core 等必要模块。
代码或图示
nullable:T? + ?. + ?:
局部容错:Result/runCatching
错误分型与组合:Either/Raise(Arrow)
常见误区
- 引入 Arrow 后把所有 nullable 改 Option:无收益的包装。
- 重复造标准库已有能力:先查标准库与扩展。
追问
- Arrow 依赖体积大吗?答:按需引入模块,core 体量按当前版本评估。
- 与其他函数式库冲突吗?答:同类能力选一套,避免多套类型体系并存。
04.8.4.2-091 Either 包装在热路径上有性能开销吗?
一句话结论
Either 是包装对象,每次成功/失败产生左侧/右侧实例与链式分配;热路径高并发下需评估对象分配压力,必要时在边界使用 Either,内部保持直接返回。
概念解释
代数数据类型是堆上包装,flatMap 链产生中间对象。业务请求路径可接受;超高频热循环、字节码级性能敏感场景需基准测试。JVM 逃逸分析可能优化部分分配,以实测为准。
原理流程
- 每次步骤产出 Either 实例。
- 链上 map/flatMap 产生中间包装。
- 边界解包为业务结果。
- 高并发下统计分配与 GC。
代码或图示
链:Either 包装 × 步骤数 → 边界解包
热路径:基准测试分配与延迟
常见误区
- 不测量就断言 Either 很慢:实际开销取决于链长与并发量。
- 在最内层循环强制包装:能在边界聚合的错误不在循环内逐次包装。
追问
- 如何优化分配?答:缩短链、边界使用类型、复用错误实例;按基准决定。
- 热路径能用 Result 替代吗?答:Result 同样有包装,选型先满足错误分型需求再测性能。
04.8.4.2-092 类型级错误与字符串错误码如何取舍?
一句话结论
内部领域流程用类型级 sealed 错误,编译期可穷尽检查;对外契约用稳定字符串错误码,供跨服务/前端消费。两者在边界双向转换。
概念解释
类型错误在编译期保障分支覆盖,不适合跨进程传输;错误码稳定可序列化,丢失分型细节。内部用 sealed 表达语义,边界映射为码。字符串码不应贯穿内部业务逻辑。
原理流程
- 内部定义 sealed 错误层级。
- 边界映射为对外错误码。
- 消费方按码处理。
- 入站错误码反向映射为内部类型。
代码或图示
sealed OrderError
object OutOfStock : OrderError() // 内部类型
// 边界 → "OUT_OF_STOCK"(对外码)
常见误区
- 内部逻辑到处比较错误码字符串:无法穷尽检查,重构脆弱。
- 对外暴露内部异常类名:类型细节泄漏且不可序列化。
追问
- 错误码表谁维护?答:API 契约文档统一管理,新增码不破坏既有消费方。
- 类型错误能自动生成码吗?答:可在映射处集中声明,避免散落字符串。
04.8.4.2-093 错误码与 Either 如何双向转换?
一句话结论
出站:领域错误按映射表转为错误码与消息;入站:外部错误码解析回内部领域错误,未知码归入通用错误类型。映射集中在适配层。
概念解释
双向映射保证内部类型模型与对外契约一致。入站未知码不能直接当成合法类型,需兜底分类。映射表显式维护,新增错误类型同步更新两侧。
原理流程
- 出站:when 穷尽匹配领域错误 → 码/消息。
- 入站:码匹配领域错误子类。
- 未匹配码 → 通用外部错误。
- 映射变更补测试覆盖。
代码或图示
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 自动互通。
原理流程
- 挂起函数内部捕获 nonFatal 异常。
- 成功 Right / 失败 Left 返回。
- 协程作用域聚合多个 Either。
- 边界统一处理错误。
代码或图示
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 分类决定接入哪类观测。新增错误类型同步补指标维度与日志字段。
原理流程
- 错误在边界分类。
- 业务错误计数进指标。
- 关键错误输出结构化日志。
- traceId 关联链路追踪。
代码或图示
领域错误 → 业务指标 + INFO/WARN 日志
系统故障 → 错误指标 + ERROR 日志 + 告警
traceId 贯穿三者
常见误区
- 只打日志不上指标:错误频率趋势不可见。
- 只统计错误计数不带类型维度:无法定位高频错误种类。
追问
- 重试计入哪个指标?答:重试次数、最终失败率分别统计,与首次失败区分。
- 错误日志与指标重复采上下文?答:指标用标签,详细上下文进日志。
04.8.4.2-096 重试与缓存策略如何配置驱动?
一句话结论
重试次数、退避参数、TTL、容量等从配置读取,按环境与依赖分组配置;代码提供策略默认值,配置覆盖,不在代码中写死环境相关数值。
概念解释
策略参数随环境调整(测试短退避、生产保守重试)。配置按依赖/操作分组,支持热更新的项走配置中心。代码封装策略构造,读取配置组装重试/缓存实例。
原理流程
- 定义策略配置结构。
- 配置源提供环境值。
- 代码构造重试策略与缓存实例。
- 调整配置不改业务代码。
代码或图示
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 名称标待确认并在官方文档核对。
原理流程
- 查当前版本迁移指南。
- 替换弃用 API。
- 编译处理警告与类型变化。
- 测试回归错误处理链路。
代码或图示
待确认:当前 Arrow 1.x 各模块最新 API 签名与弃用列表
常见误区
- 照搬 0.x 时代教程:API 已变更,编译不过或行为不符。
- 忽略弃用警告升级:后续大版本移除后被迫紧急改造。
追问
- 如何查版本对应 API?答:官方文档与 API 文档以当前发布版本为准。
- 旧 Either 代码能否兼容新版?答:按迁移指南逐步替换,经典类型通常保留过渡兼容。
04.8.4.2-098 本节涉及的常见依赖坐标应如何说明?
一句话结论
Arrow、Caffeine、协程测试、日志门面等依赖坐标与版本以官方仓库当前发布为准;本节不写死未验证版本号,工程在版本目录中统一登记。
概念解释
依赖坐标随版本演进,臆造编号会误导构建。正确做法:查官方仓库当前版本,在版本目录登记别名与版本段。日志实现、缓存库按工程生态选择。
原理流程
- 查官方仓库/文档当前版本。
- 版本目录登记坐标与版本。
- 模块按别名引入。
- 升级时按兼容矩阵核对。
代码或图示
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 更重要。
原理流程
- 描述现有错误处理痛点。
- 介绍 sealed 错误 + Either/Raise。
- 讲解短路、映射与边界转换。
- 讨论性能、团队接受度与替代方案。
代码或图示
痛点 → 模型选型 → 链路机制 → 边界与可观测 → 落地取舍
常见误区
- 只背 Either 方法名:讲不清设计理由与适用边界。
- 宣称函数式错误处理全面替代异常:实际是分层配合。
追问
- 项目中最复杂的错误场景?答:举例多依赖聚合、错误分类与恢复策略设计。
- 如何向团队推广?答:从核心领域试点,配规范与评审,渐进迁移。
04.8.4.2-100 哪些场景值得引入 Either 这类类型级错误处理?
一句话结论
多步骤业务编排、错误需要分型分支处理、错误需跨层传递且要求编译期穷尽检查的场景值得用;简单局部容错、程序缺陷与纯内部工具用异常/Result 即可。
概念解释
判断标准:失败是否业务可预期、是否需要调用方分型处理、链路是否多步组合。符合则 typed error 收益明显;单点可抛可捕的场景引入 Either 增加包装成本。按边界分层选择。
原理流程
- 列举失败场景与处理方式。
- 可预期 + 多步 + 需分型 → Either/Raise。
- 局部容错 → Result/runCatching。
- 程序缺陷 → 异常边界兜底。
代码或图示
值得 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)
- [ ] 补充本工程错误层级、重试/缓存配置与日志字段规范的实际样例