07.1.1.10.2 Koin 多模块与架构边界
所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.1 原生移动开发 / 07.1.1 Android / 07.1.1.10 DI 与模块化
本节要解决的问题
本节聚焦 Koin 运行期 DI 在多模块工程中的落地:模块拆分与聚合、可见性与跨模块绑定、作用域与 ViewModel、Compose/Navigation 集成、启动时机与运行期故障排查,并横向对比 Hilt/Koin/手动 DI,最后落到 Gradle 模块边界、动态特性与循环依赖治理。版本基线:Koin 4.x、AGP 8.x、Kotlin 2.x;版本敏感处标「待确认」。
07.1.1.10.2-001 Koin 是什么?与 Hilt 的定位差异?
一句话结论
Koin 是纯 Kotlin 的运行期依赖注入框架,用 DSL 在注册表中声明定义,运行期按类型解析;Hilt 是编译期生成 Dagger 图的方案,两者在解析时机、校验方式与性能模型上不同。
概念解释
Koin 不需要注解处理器与生成代码,模块在 startKoin 时加载进注册表,解析发生在运行期。Hilt 编译期生成组件并校验绑定完整性。Koin 上手轻、无构建期代码生成;Hilt 有编译期保障与更严格的图约束。选型在编译速度、启动开销、可测试性与模块边界之间权衡。
原理流程
Koin:模块 DSL → 运行期注册表 → 按类型/限定符解析
Hilt:注解 → 编译期生成图 → 编译期校验 + 运行期提供
代码或图示
val appModule = module {
single { NoteRepository(get()) }
}
常见误区
- 把 Koin 当成编译期 DI,以为缺失绑定在构建期报错。
- 用 Hilt 的作用域组件概念直接套 Koin,作用域模型并不相同。
追问
- Koin 依赖注解处理器吗?答:不依赖,纯 Kotlin 运行期注册。
- 两者能在同一工程共存吗?答:可以但不推荐混用;过渡期按模块逐步替换。
07.1.1.10.2-002 Koin 模块(module {})如何组织依赖声明?
一句话结论
module { } 是依赖声明容器,内部用 single/factory/viewModel 等 DSL 注册类型定义;模块可独立拆分后通过列表或 includes 聚合。
概念解释
每个模块声明一组相关绑定:网络模块、数据库模块、仓库模块。DSL 内 get() 表示从注册表解析依赖参数。模块本身不创建实例,只保存定义;实例按作用域在需要时创建。拆分模块便于多模块工程按层/功能组织与测试替换。
原理流程
module { single { ApiClient(get()) }; factory { Mapper() } }
→ 定义进入 Koin 注册表
代码或图示
val networkModule = module {
single { OkHttpClient.Builder().build() }
single { NoteApi(get()) }
}
常见误区
- 把模块当成实例容器,以为加载模块就全部 new 出来。
- 一个模块堆砌跨层绑定,失去拆分意义。
追问
- 模块里能写条件分支定义吗?答:可按配置选择实现,但建议在定义层清晰表达;复杂策略用限定符区分。
- 模块可以单例复用吗?答:模块对象被 Koin 加载一次,定义共享。
07.1.1.10.2-003 single、factory、viewModel 分别是什么作用域?
一句话结论
single 在注册表内全局单例复用;factory 每次解析新建实例;viewModel 绑定 Android ViewModel 生命周期并由 ViewModelStore 管理。
概念解释
single 对应应用级共享对象(客户端、仓库、数据库);factory 对应无状态或每次需要新实例的对象;viewModel 定义进入 ViewModel 工厂,随配置变更保留、清除时释放。选择依据是对象状态共享需求与生命周期,不是习惯统一用 single。
原理流程
single:首次创建后缓存复用
factory:每次 get 新建
viewModel:ViewModelStore 持有,onCleared 释放
代码或图示
val vmModule = module {
single { NoteRepository(get(), get()) }
factory { NoteMapper() }
viewModel { HomeViewModel(get()) }
}
常见误区
- 无状态工具类也标 single,无谓常驻。
- 有状态对象用 factory,每次拿到不同实例状态丢失。
追问
- single 是线程安全的吗?答:实例创建与缓存由 Koin 管理,对象内部并发安全仍需自身保证。
- viewModel 定义能注入 single 依赖吗?答:能,按注册表解析。
07.1.1.10.2-004 modules() 与 includes() 如何聚合子模块?
一句话结论
startKoin { modules(...) } 传入顶层模块列表聚合;模块内可用 includes(...) 组合子模块,形成树形模块结构。
概念解释
聚合方式两种:启动时平铺模块列表,或父模块 includes 子模块。includes 便于按功能分包:feature 模块聚合自己的仓库/ViewModel 定义,app 启动加载父模块即带入全部。子模块定义在父模块加载时一并注册进注册表。
原理流程
startKoin.modules(appModule)
appModule.includes(networkModule, dbModule, featureModule)
代码或图示
val appModule = module {
includes(networkModule, databaseModule, noteModule)
}
startKoin {
modules(appModule)
}
常见误区
- 同一模块既被 includes 又出现在 modules 列表,重复注册。
- 子模块依赖的定义未被任何父模块包含,运行期解析不到。
追问
- 模块重复加载会覆盖吗?答:重复定义按 Koin 解析规则处理,可能告警或冲突,应避免(具体行为待确认版本)。
- includes 顺序影响解析吗?答:定义解析在获取实例时进行,模块加载顺序通常不影响 get 解析。
07.1.1.10.2-005 多模块工程中 Koin 模块如何拆分?
一句话结论
按 Gradle 模块与架构层拆分:每个功能/数据模块自带 Koin 定义模块,app 模块聚合入口;接口与实现的绑定放在实现侧模块。
概念解释
数据模块提供仓库与数据源定义,domain 模块只定义接口,feature 模块提供页面 ViewModel 定义。各模块导出自己的 xxxModule,app 启动时聚合。拆分后单个模块可独立测试替换定义,跨模块只依赖接口类型。
原理流程
data 模块:repositoryModule
feature 模块:viewModelModule
app:聚合全部模块
代码或图示
// :data 模块
val dataModule = module { single { NoteRepositoryImpl(get()) } }
// :app 模块
startKoin { modules(appModule, dataModule, featureModule) }
常见误区
- 所有 Koin 定义堆在 app 模块,数据模块无法独立替换。
- 接口定义在 data,domain 反向依赖实现类型。
追问
- 库模块需要自带 Koin 模块吗?答:提供可注入实现的库应自带定义模块,宿主聚合加载。
- 模块拆分粒度怎么定?答:与 Gradle 模块边界对齐,避免一个 Koin 模块跨多个架构层。
07.1.1.10.2-006 模块拆分按什么边界:功能、层还是平台?
一句话结论
优先按架构层与业务功能拆分,平台/共享差异单独隔离;Koin 模块边界应与代码模块和依赖方向一致。
概念解释
层边界:network/db/repository 各自模块;功能边界:笔记、订单等特性模块;平台差异:Android 特有绑定与纯 Kotlin 逻辑分离。拆分目标是让依赖方向清晰、可独立编译测试。混用边界会导致模块间互相渗透。
原理流程
分层:domain / data / presentation
分功能:各 feature 模块
平台:Android 定义与纯 Kotlin 逻辑分离
代码或图示
:domain(接口)← :data(实现 + 绑定)← :feature(ViewModel)
常见误区
- 按页面文件目录拆 Koin 模块,而不是按依赖边界。
- 共享纯 Kotlin 模块混入 Android 组件定义,复用到后端受限。
追问
- 多端复用模块怎么组织?答:纯逻辑放 common 模块,Android 绑定在 android 模块提供。
- 边界争议时以什么为准?答:依赖方向与编译可见性,而非开发习惯。
07.1.1.10.2-007 Koin 模块的加载时机与启动顺序?
一句话结论
模块在 startKoin 调用时加载进注册表;定义注册先于首次解析,启动顺序按传入/includes 列表,实例化在首次获取时惰性发生。
概念解释
startKoin 初始化注册表并加载模块 DSL;此时只注册定义,不立即构造 single 实例。解析(get)发生在业务首次注入时。模块加载顺序影响重复定义的处理,但不影响正常按类型解析。多进程各自执行 startKoin 初始化注册表。
原理流程
startKoin → 加载模块定义
首次 get → 按作用域创建实例
代码或图示
startKoin {
modules(appModule) // 加载定义
}
// 后续:val repo: NoteRepository by inject() // 首次解析创建
常见误区
- 以为 startKoin 会构造全部 single,计入启动对象。
- 在 startKoin 之前调用 inject,注册表尚未初始化。
追问
- 能否在运行期动态加模块?答:Koin 支持加载/卸载模块的 API,测试与动态场景使用(版本 API 待确认)。
- 启动顺序导致问题怎么查?答:先确认模块是否都已加载,再看重复定义告警。
07.1.1.10.2-008 子模块 includes 父模块时的依赖可见性?
一句话结论
Koin 注册表是全局聚合的:模块被加载后,其定义对后续解析可见,不按模块间访问限制;可见性约束主要来自 Gradle 编译依赖与类型导出。
概念解释
与编译期 DI 组件层级不同,Koin 解析在单一注册表按类型查找。模块 A 加载的定义可被模块 B 的解析使用,前提是 B 代码能引用该类型(Gradle 依赖可见)。不存在子模块自动隔离父模块定义的容器层级,作用域隔离由 Koin scope 单独提供。
原理流程
注册表聚合所有已加载模块定义
解析:按类型/限定符全局查找
编译可见性:Gradle dependencies 控制类型是否可引用
代码或图示
val featureModule = module {
viewModel { HomeViewModel(get()) } // get 解析全局仓库定义
}
常见误区
- 误以为 Koin 模块像 Hilt 组件一样有父子访问层级。
- 类型未在 Gradle 依赖中导出,代码引用不到却期待运行期解析。
追问
- 模块间定义冲突如何隔离?答:用限定符或拆分注册表/作用域;全局注册表按类型匹配。
- 可见性问题编译期能发现吗?答:类型不可见在编译期暴露;定义缺失在运行期暴露。
07.1.1.10.2-009 模块重复声明同一绑定会怎样?
一句话结论
同一类型重复定义可能覆盖、告警或解析歧义,具体行为按 Koin 版本规则;工程上应保证一个类型在注册表中只有一个匹配定义。
概念解释
重复来源:多个模块声明同一 single,测试与生产模块叠加。Koin 对重复定义的处理(最后覆盖/报错/告警)随版本不同,不能依赖隐式行为。排查时搜索类型定义位置,去重或用限定符区分多实现。
原理流程
重复类型定义 → 注册表按规则处理
工程规范:单一生产定义 + 限定符区分备选
代码或图示
// 避免:两个模块都 single { NoteRepository(get()) }
常见误区
- 靠“后加载覆盖前一个”的隐式顺序决定实现,行为不可维护。
- 测试模块未卸载/替换,与生产定义叠加。
追问
- 重复定义报错信息是什么?答:按版本为覆盖告警或歧义异常;具体文案待确认。
- 多实现正确做法?答:命名/类型限定符区分,注入点指定 qualifier。
07.1.1.10.2-010 Koin 模块在库模块中如何提供并避免重复加载?
一句话结论
库模块导出自己的定义模块,宿主 app 聚合加载一次;库不自行调用 startKoin,避免注册表重复初始化。
概念解释
可复用库提供 xxxModule 供宿主包含;初始化入口在 app。若库内部也 startKoin,多模块场景会重复初始化注册表。库测试可独立加载自身模块做验证。发布库时文档说明需要包含哪些 Koin 模块。
原理流程
库:导出 featureModule
宿主:startKoin { modules(appModule, featureModule) }
代码或图示
// :library
val libraryModule = module { single { LibraryService() } }
常见误区
- 库模块 Application 里 startKoin,与宿主初始化冲突。
- 宿主忘记包含库模块,运行期 NoBeanDefFound。
追问
- 库如何声明必需依赖定义?答:在文档/模块注释中说明宿主需提供的类型绑定。
- 库测试独立加载怎么做?答:Koin 测试规则加载库模块与 Fake 定义。
07.1.1.10.2-011 依赖定义 DSL:singleOf、factoryOf 等简写是什么?
一句话结论
Koin 提供 singleOf/factoryOf/viewModelOf 等顶层简写,直接引用类构造函数生成定义;完整 DSL 用 lambda 手写组装依赖。
概念解释
singleOf(::NoteRepository) 等价于 single { NoteRepository(get()) },构造参数由 Koin 解析。简写适合标准构造注入;需要配置、条件选择、接口绑定时用 lambda DSL。简写可读性好,复杂组装仍走完整定义。
原理流程
singleOf(::X) → 解析构造参数 → 注册 single 定义
代码或图示
val m = module {
singleOf(::NoteRepository)
viewModelOf(::HomeViewModel)
}
常见误区
- 构造需要手动配置时强行用简写,无法传入构建参数。
- 混淆简写与 lambda 的参数解析方式。
追问
- 简写支持接口绑定吗?答:需要配合 bind 声明;接口映射场景用 lambda 更直观(待确认版本 API)。
- 构造参数复杂时推荐哪种?答:lambda DSL 显式表达组装过程。
07.1.1.10.2-012 模块卸载与重载在测试中怎么做?
一句话结论
Koin 测试中可通过卸载模块/关闭注册表、加载替换定义实现隔离;测试间重置 Koin 避免单例状态残留。
概念解释
测试替换生产定义:加载测试模块提供 Fake;测试结束关闭 Koin 上下文,下一个用例重新初始化。避免跨用例共享 single 状态。具体卸载/重载 API 名称按 Koin 4.x 版本确认(待确认)。
原理流程
测试启动 → 加载生产模块 + Fake 覆盖定义
测试结束 → 关闭/卸载 → 重置注册表
代码或图示
// 测试规则模式;API 按版本核对(待确认)
startKoin { modules(testModule) }
常见误区
- 测试不重置注册表,上一用例单例状态污染下一用例。
- Fake 定义与生产定义类型重复未隔离。
追问
- 能否只替换单个定义?答:按 Koin 覆盖/替换机制提供同类型绑定;具体方式待确认。
- 测试用纯构造注入是否更简单?答:轻量单元测试可直接 new Fake,不启动 Koin。
07.1.1.10.2-013 Koin 注册表结构:定义、实例、作用域分别是什么?
一句话结论
注册表保存类型定义(如何创建)、缓存实例(single 复用对象)与作用域实例(scope 容器内对象);三者分离,定义不随实例销毁。
概念解释
定义是工厂描述;实例按作用域缓存:single 缓存在全局注册表,factory 不缓存,scope 实例挂在对应 scope 容器。解析时先查缓存,未命中按定义创建。理解三层结构有助于排查“对象为何复用/不释放”。
原理流程
Definition(工厂)→ Instance 缓存(single/scope)
get:查缓存 → 未命中 → 按定义创建
代码或图示
注册表
├ 定义:类型 + 创建 lambda
├ 全局实例:single 缓存
└ 作用域实例:各 scope 容器
常见误区
- 把定义和实例混为一谈,以为删实例就移除了类型提供方。
- scope 实例释放后仍被外部引用,形成泄漏。
追问
- single 实例何时清除?答:全局注册表关闭/进程结束;不随页面销毁。
- 注册表能在运行期查看定义吗?答:Koin 诊断 API 可检查已注册定义(待确认版本)。
07.1.1.10.2-014 多模块依赖图如何排查缺失定义?
一句话结论
按报错类型沿注入点反查定义声明位置、模块是否加载、类型是否 Gradle 可见;逐层确认模块聚合链与限定符匹配。
概念解释
排查路径:缺失类型 → 搜索模块定义 → 确认该模块被 startKoin 聚合 → 确认代码模块依赖实现类型 → 核对限定符。常见遗漏:库模块未包含、实现模块未依赖、接口绑定漏写、注入点 qualifier 不一致。
原理流程
NoBeanDefFound 类型
→ 定义存在?模块加载?类型可见?限定符一致?
代码或图示
排查清单:
1. 搜索 single/factory/viewModel 注册该类型
2. 模块是否在 modules()/includes 链中
3. Gradle 依赖是否导出类型
4. 注入点与定义 qualifier 是否相同
常见误区
- 只检查 app 模块定义,遗漏 data/feature 模块。
- 接口类型注册了,注入点拿的是具体实现类型。
追问
- 运行期日志能看到已加载模块吗?答:开启 Koin 日志后可观察模块加载与解析。
- 多模块加载顺序问题?答:先确认定义是否注册,再判断是否重复覆盖。
07.1.1.10.2-015 Koin 依赖可见性规则:按类型解析还是按模块?
一句话结论
Koin 运行期按类型(加限定符)在全局注册表解析,不按“当前属于哪个模块”隔离;编译可见性由 Gradle 依赖单独约束。
概念解释
解析时查找已注册的匹配类型定义,模块只是组织定义的方式。两个模块都加载后互相可见对方定义。代码能否引用类型名取决于 Gradle 依赖:类型不可见在编译期报错,类型未注册在运行期报错。两层约束不要混淆。
原理流程
编译期:Gradle 依赖 → 类型可引用
运行期:注册表 → 类型定义可解析
代码或图示
// 模块 A 定义;模块 B 解析
val repo: NoteRepository by inject()
常见误区
- 期待模块间像私有域一样隔离定义。
- 类型通过反射/字符串引用绕过编译可见性检查。
追问
- 如何实现模块私有依赖?答:不导出类型、在模块内部使用;需要共享才放公共接口模块。
- 与 Hilt 组件可见性差异?答:Hilt 有编译期组件层级;Koin 全局注册表 + scope 容器隔离。
07.1.1.10.2-016 跨模块如何提供接口与实现绑定?
一句话结论
实现侧模块用 Koin 定义把接口绑定到实现类,消费模块只依赖接口类型;通过 bind 或定义返回接口类型完成映射。
概念解释
domain 定义 NoteRepository 接口,data 模块注册实现并绑定接口。消费方注入接口,解析到 data 提供的实现。接口不依赖实现模块;Gradle 上 data 依赖 domain,app 聚合两端。测试可在消费侧提供接口 Fake 定义。
原理流程
domain:interface NoteRepository
data:single<NoteRepository> { NoteRepositoryImpl(get()) }
代码或图示
// data 模块
val repoModule = module {
single<NoteRepository> { NoteRepositoryImpl(get()) }
}
常见误区
- 消费方注入实现类,跨模块依赖具体类型。
- 定义返回实现但注册类型是实现,接口解析不到。
追问
- bind 语法怎么用?答:在定义上声明绑定到接口类型;具体 DSL 按版本确认(待确认)。
- 接口多实现怎么区分?答:限定符注册多个绑定,注入点指定。
07.1.1.10.2-017 模块未加载导致 NoBeanDefFound 怎么排查?
一句话结论
异常指明缺失类型;先确认定义模块是否被聚合加载,再查类型可见性与限定符,最后排除重复覆盖。
概念解释
NoBeanDefFoundException 表示注册表无匹配定义。典型原因:库模块未加入 startKoin 列表、模块在错误的初始化路径加载、类型注册为接口而注入实现、qualifier 不匹配。按“定义存在性 → 模块加载 → 类型/限定符匹配”顺序排查。
原理流程
异常类型 T
→ 搜索 T 定义 → 模块聚合链 → Gradle 可见 → qualifier
代码或图示
NoBeanDefFound: Could not find NoteRepository
检查:dataModule 是否在 modules() 列表
常见误区
- 启动顺序问题误判为类型缺失。
- 注入点用了命名 qualifier,定义未标注同名。
追问
- 如何打印已注册定义?答:开启 Koin 诊断/日志 API 查看注册表内容(待确认版本)。
- 多进程会导致缺失吗?答:子进程未 startKoin 时注册表为空,需在各进程初始化。
07.1.1.10.2-018 构造函数注入与函数注入在 Koin 中如何声明?
一句话结论
Koin 通过定义 lambda 中的 get() 解析构造参数;类构造函数无需 @Inject 注解,工厂 lambda 负责组装。
概念解释
与 Hilt 构造注入不同,Koin 不扫描构造注解;在 single { Xxx(get(), get()) } 中显式写出参数解析。get() 按类型从注册表取依赖。类本身是普通 Kotlin 类,可测试性来自构造参数可见。
原理流程
定义 lambda → get() 解析依赖 → 构造实例
代码或图示
single { NoteRepositoryImpl(api = get(), dao = get()) }
常见误区
- 给类加 @Inject 注解期待 Koin 自动识别,Koin 不处理该注解。
- lambda 内硬编码 new 依赖,绕过注册表解析。
追问
- 构造参数命名解析支持吗?答:Koin 按类型解析;可配合参数名/限定符,具体能力待确认。
- 可选依赖怎么声明?答:用
getOrNull()处理缺失可选绑定。
07.1.1.10.2-019 类型绑定:bind 与接口映射怎么写?
一句话结论
用显式泛型或 bind 把定义注册为接口类型,使注入接口时解析到实现;消费方面向接口获取。
概念解释
single<NoteRepository> { Impl(get()) } 直接以接口类型注册;需要同时保留实现类型获取时用 bind 补充绑定。映射规则在定义模块声明,避免消费方依赖实现。具体 bind DSL 形态按 Koin 版本确认(待确认)。
原理流程
注册类型 = 接口
创建对象 = 实现类
代码或图示
val m = module {
single<NoteRepository> { NoteRepositoryImpl(get()) }
}
常见误区
- 注册实现类型,接口注入时找不到定义。
- 一个定义只绑实现,需要接口与实现双绑时漏写 bind。
追问
- 接口和实现都能 get 到吗?答:按注册类型解析;双绑需显式声明。
- 多接口实现怎么绑?答:分别注册或 bind 到各接口类型。
07.1.1.10.2-020 多实现如何用 qualifier 区分?
一句话结论
Koin 用命名 qualifier(字符串)或类型 qualifier 给定义打标记,注入点指定同一标记解析对应实现。
概念解释
同一接口多个绑定(远程/本地、主/备),不加标记会歧义解析。定义侧 qualifier("remote"),获取侧 by inject(named = "remote")。类型 qualifier 用注解类作为标记,比字符串更类型安全。两侧标记必须一致。
原理流程
定义:qualifier + 类型
注入:相同 qualifier + 类型 → 匹配
代码或图示
val m = module {
single(named("remote")) { RemoteNoteApi() }
single(named("local")) { LocalNoteApi() }
}
val api: NoteApi by inject(named("remote"))
常见误区
- 定义与注入点 qualifier 拼写不一致,运行期找不到。
- 多实现都无标记,解析到不确定的某一个。
追问
- 字符串 qualifier 重构安全吗?答:不安全,重命名需两侧同步;推荐类型 qualifier。
- qualifier 与作用域能叠加吗?答:可以,标记选择实现,作用域决定复用。
07.1.1.10.2-021 Koin 中命名 qualifier 与类型 qualifier 的区别?
一句话结论
命名 qualifier 是字符串标记,简单但无编译期检查;类型 qualifier 用注解/类作为标记,重构更安全,语义更清晰。
概念解释
named("debug") 依赖字符串两侧一致,改名易漏;类型 qualifier 定义一个标记类/注解,定义与注入点引用同一类型符号,IDE 可重构。简单原型可用命名,正式工程优先类型 qualifier。
原理流程
命名:字符串键
类型:标记类/注解类型键
代码或图示
// 类型 qualifier(示意;API 形态按版本确认,待确认)
@Qualifier annotation class RemoteApi
常见误区
- 字符串标记散落各处,重命名时漏改一侧。
- 类型 qualifier 定义位置不当,跨模块不可见。
追问
- Koin 支持 Dagger 风格 @Qualifier 注解吗?答:按版本支持情况确认;通常提供自有 qualifier 机制(待确认)。
- 两种能混用吗?答:避免混用,统一一种风格。
07.1.1.10.2-022 模块依赖方向与 Gradle 边界一致性如何检查?
一句话结论
Koin 定义所在模块必须与 Gradle 依赖方向一致:实现绑定在 data,消费方依赖 domain 接口;检查反向 import 与模块依赖图。
概念解释
边界腐化表现:domain import data 实现、feature 直接依赖数据源细节。检查方式:模块依赖分析、import 扫描、架构 Lint 规则。Koin 定义位置反过来印证分层:绑定实现的模块应是下层实现模块,而非上层 feature。
原理流程
Gradle 依赖方向 ≈ DI 绑定方向
反向 import → 边界违规
代码或图示
允许:feature → domain ← data
禁止:domain → data
常见误区
- Koin 模块放在 app,实现类却被 domain 引用。
- 只看 DI 配置,不检查源码 import 反向依赖。
追问
- 工具如何检查?答:Gradle 依赖报告、模块边界 Lint、ArchUnit 类规则。
- 发现违规怎么拆?答:抽公共接口/事件模块,切断反向环。
07.1.1.10.2-023 Koin 的 scoped 作用域如何定义?
一句话结论
scope { } 定义绑定到某个生命周期容器的实例,实例随 scope 打开创建、关闭释放;与全局 single/factory 区分。
概念解释
Koin scope 是独立的实例容器:在 scope 内注册的定义,实例缓存在该 scope 实例中。scope 绑定到 Android 组件或自定义生命周期。需要页面级共享、离开即释放的对象用 scope,而不是提升为 single。
原理流程
scope 定义 → 打开 scope 容器 → 实例创建并缓存
关闭 scope → 实例释放
代码或图示
val sessionScope = module {
scope<SessionScope> {
scoped { SessionCoordinator(get()) }
}
}
常见误区
- 把页面会话对象注册成 single,跨页面常驻泄漏。
- scope 关闭后外部仍持有实例引用。
追问
- scoped 与 viewModel 区别?答:viewModel 由 ViewModelStore 管理;scope 是通用容器,可绑定任意生命周期。
- 作用域定义需要关联类型吗?答:通过 scope 类型/标记标识容器(按版本 API,待确认)。
07.1.1.10.2-024 scope 与 Android 组件生命周期如何对应?
一句话结论
Koin Android 扩展可把 scope 绑定到 Activity/Fragment 生命周期:创建时打开,销毁时关闭;ViewModel 生命周期由 viewModel 定义单独管理。
概念解释
Activity 级 scope 在 onCreate 打开、onDestroy 关闭;Fragment 类似。对应对象在组件存活期间复用,销毁释放。具体 Koin Android 扩展 API(scope 委托、生命周期回调)按 Koin 4.x 确认(待确认)。不要把 scope 实例挂到长生命周期单例。
原理流程
组件创建 → open scope → scoped 实例复用
组件销毁 → close scope → 释放实例
代码或图示
// 示意:Activity 委托打开/关闭 scope(API 待确认)
class NoteActivity : AppCompatActivity() {
val coordinator: SessionCoordinator by scopeOf<NoteActivity>()
}
常见误区
- scope 未在销毁时关闭,实例常驻。
- 跨组件共享对象错放进组件 scope,其他组件取不到。
追问
- 旋转屏幕 scope 是否保留?答:按绑定的组件生命周期;Activity 重建会重建 scope,需保留状态用 ViewModel。
- 自定义 scope 何时关闭?答:业务流程结束显式 close,避免泄漏。
07.1.1.10.2-025 scoped 实例何时创建与销毁?
一句话结论
scope 内实例在容器打开后首次解析时创建,缓存在该容器;scope 关闭时容器与缓存实例一起释放。
概念解释
创建时机同 single 惰性:首次 get。销毁由 scope close 触发,不是 GC 自动回收。scope 关闭后再通过旧引用访问实例属于泄漏引用。注册在 scope 的 factory 定义仍每次新建,但容器关闭一并清理。
原理流程
open scope → 首次 get 创建缓存
close scope → 丢弃缓存实例
代码或图示
Scope A 打开 → scoped X 实例
Scope A 关闭 → X 不可再用
常见误区
- 以为 scoped 实例像 single 全局存活。
- 忘记 close scope,容器与对象驻留内存。
追问
- scope 内能取 single 吗?答:能,全局定义在 scope 内可解析使用。
- 实例释放需要手动 close 资源吗?答:DI 只丢弃引用,持有的资源(线程/连接)需实现清理。
07.1.1.10.2-026 作用域实例与 single/factory 对比?
一句话结论
single 全局一份常驻;factory 每次新建不缓存;scoped 在对应生命周期容器内一份,容器关闭释放。
概念解释
选择依据:跨页面共享且无生命周期风险用 single;临时无状态用 factory;页面/会话级共享用 scoped。混用典型错误:会话对象用 single 导致跨页面串状态,或状态对象用 factory 每次重置。
原理流程
single:全局缓存
factory:不缓存
scoped:scope 容器缓存
代码或图示
module {
single { AppConfig() }
factory { Mapper() }
scope<CartScope> { scoped { CartSession(get()) } }
}
常见误区
- 三种作用域按习惯全用 single。
- 把需要跨配置保留的状态放进 Activity scope,旋转后丢失。
追问
- 如何判断该用哪种?答:问“对象被谁共享、活多久、是否有可变状态”。
- scoped 实例能被 single 依赖吗?答:长生命周期对象不应持有短生命周期 scope 实例,避免越界引用。
07.1.1.10.2-027 作用域实例的关闭与泄漏防护?
一句话结论
scope 必须在对应生命周期结束时显式关闭,释放缓存实例;外部不长期持有 scope 内对象,防止关闭后残留引用。
概念解释
泄漏路径:scope 未 close、scope 对象被单例/静态字段持有、回调引用 scope 实例。防护:组件生命周期回调关闭 scope;对象不跨作用域传递;必要时 LeakCanary 检查。scope 内对象持有的资源在关闭时清理。
原理流程
生命周期结束 → close scope
禁止:单例/静态引用 scope 对象
代码或图示
override fun onDestroy() {
closeScope()
super.onDestroy()
}
常见误区
- 只打开 scope 不关闭,页面反复进入累积实例。
- 把 scoped 协调器传给单例回调,生命周期倒挂。
追问
- 如何检测 scope 泄漏?答:内存检查工具观察组件销毁后 scope 对象是否残留。
- scope 关闭后能重新打开吗?答:按业务创建新容器;旧实例不复用。
07.1.1.10.2-028 作用域链接(scope link)是什么?
一句话结论
scope 链接允许一个 scope 容器解析另一个 scope 或全局定义,形成作用域层级;具体链接 API 与可见性按 Koin 版本确认(待确认)。
概念解释
类似父子容器:子 scope 可访问父 scope 定义,自身 scoped 实例不泄漏到父级。链接用于组织层级会话:全局 → 会话 → 页面。未链接的 scope 只能解析全局与自身定义。理解链接方向可避免“子 scope 取不到上层对象”的问题。
原理流程
Parent scope ──link── Child scope
Child 可解析 Parent 定义
代码或图示
Global → SessionScope → PageScope
常见误区
- 以为所有 scope 自动互相可见,实际按链接关系解析。
- 链接方向搞反,子对象被父级缓存。
追问
- scope 链接与 Hilt 组件层级类似吗?答:概念相似,实现与 API 不同;不要直接套用注解约定。
- 链接 API 在哪查?答:Koin 4.x 文档 scope 章节(待确认)。
07.1.1.10.2-029 重复获取同一作用域实例会怎样?
一句话结论
同一 scope 容器内重复解析 scoped 定义返回缓存实例;不同 scope 容器各自创建独立实例。
概念解释
scope 实例缓存按容器隔离:同一容器多次 get 同一对象;打开第二个同类 scope 得到新实例。single 则无论哪个 scope 都返回全局缓存。区分容器身份是排查“为何状态被共享/隔离”的关键。
原理流程
Scope1.get(X) → 实例 A
Scope1.get(X) → 复用 A
Scope2.get(X) → 实例 B
代码或图示
val a = scope1.get<SessionCoordinator>()
val b = scope1.get<SessionCoordinator>() // 同一实例
常见误区
- 以为 scoped 像 factory 每次新建。
- 以为跨 scope 共享同一 scoped 实例。
追问
- 如何确认容器身份?答:Koin scope 实例标识/诊断 API;业务上按组件实例对应。
- 单例在 scope 内获取是同一全局实例吗?答:是,single 缓存不随 scope 复制。
07.1.1.10.2-030 作用域内绑定与外部 single 的访问关系?
一句话结论
scope 内可解析全局 single 定义;全局 single 不应反向持有 scope 实例,避免短生命周期对象被长生命周期容器引用。
概念解释
依赖方向遵循长持有短:single 依赖其他 single 或无状态对象,不注入 scoped/viewModel 对象。scope 内协调器可以注入仓库单例。反向引用会造成泄漏与生命周期混乱。设计注入链时检查作用域长短。
原理流程
scope → 可访问 single
single → 不应持有 scope 实例
代码或图示
// 正确:scope 协调器注入仓库单例
scope { scoped { SessionCoordinator(get()) } }
常见误区
- 单例仓库缓存页面 scope 对象引用。
- 全局状态对象持有 Activity scope 上下文。
追问
- 需要单例回调页面 scope 对象怎么办?答:用事件/接口由页面订阅,单例不直接持有引用。
- 作用域倒挂编译期能发现吗?答:Koin 运行期解析,需架构评审与内存检查兜底。
07.1.1.10.2-031 Fragment/Activity 作用域在 Koin 中怎么建?
一句话结论
通过 Koin Android 扩展为组件创建对应 scope,组件销毁关闭;页面级对象注册 scoped,ViewModel 用 viewModel 定义单独管理。
概念解释
Activity scope 服务于该页面协调器;Fragment scope 隔离各 Fragment 会话。视图模型状态走 viewModel 定义由 Store 保留。具体委托属性与生命周期接入 API 按 Koin Android 版本确认(待确认)。不要把 Activity scope 对象传给 Fragment 跨边界持有。
原理流程
Activity/Fragment 创建 → 打开组件 scope
销毁 → 关闭 scope
代码或图示
// 示意结构;委托 API 以版本文档为准
val pageScope = scopeOf<NoteActivity>()
常见误区
- Fragment 直接复用 Activity scope 对象,状态跨 Fragment 串扰。
- 组件 scope 未随销毁关闭。
追问
- Activity 与 Fragment scope 链接吗?答:按 Koin Android 实现约定;层级关系待确认。
- 页面共享状态放哪?答:跨 Fragment 共享用 ViewModel 或 retained 容器。
07.1.1.10.2-032 作用域释放后持有旧实例有什么风险?
一句话结论
外部持有已关闭 scope 的实例会造成内存泄漏,实例可能持有已销毁组件上下文,引发崩溃与状态错误。
概念解释
scope 关闭本意是释放对象;静态字段、单例回调、未注销监听持有旧实例,使组件无法回收。旧实例内的 View/Context 引用导致泄漏与后台访问异常。排查沿旧实例引用链找到长生命周期持有方。
原理流程
scope close → 实例应不可达
长生命周期引用 → 泄漏 + 旧上下文风险
代码或图示
风险链:单例回调 → Activity scope 协调器 → Activity 引用
常见误区
- 注册监听后反注册遗漏,持有 scope 对象。
- 协程/异步回调返回后引用 scope 内状态。
追问
- 如何定位持有链?答:LeakCanary/堆快照查看 GC 引用路径。
- 修复方式?答:断开长生命周期引用,作用域对象改为事件订阅或重新获取。
07.1.1.10.2-033 viewModel { } 定义与 Android 集成?
一句话结论
viewModel { } 在 Koin 中注册 ViewModel 工厂定义,配合 Koin Android 集成由 ViewModelStore 创建与持有 ViewModel 实例。
概念解释
viewModel 定义的生命周期独立于全局 single:实例绑定 ViewModelStore,配置变更保留,onCleared 释放。定义 lambda 用 get() 解析仓库等依赖。Activity/Fragment 通过委托属性获取对应 ViewModel。
原理流程
viewModel 定义 → Koin ViewModel 工厂
→ ViewModelStore 创建/复用实例 → onCleared 释放
代码或图示
val vmModule = module {
viewModel { HomeViewModel(get()) }
}
常见误区
- 把 ViewModel 注册成 single,跨页面共享且不随清除释放。
- viewModel 定义注入 Activity/Fragment 上下文类型依赖。
追问
- viewModel 定义能注入 SavedStateHandle 吗?答:按 Koin Android 集成支持注入;具体方式待确认。
- 多个 ViewModel 共享仓库:仓库 single 即可复用。
07.1.1.10.2-034 getViewModel / by viewModel 如何获取?
一句话结论
在 Activity/Fragment 中用 by viewModel() 委托按类型获取 Koin 创建的 ViewModel;参数与依赖由定义 lambda 解析。
概念解释
委托属性在首次访问时从 Koin ViewModel 工厂获取实例,存入 ViewModelStore。跨配置变更返回同一实例。需要传参时通过定义 lambda 或状态句柄。Compose 场景用对应 koinViewModel() 函数。
原理流程
by viewModel() → Koin 工厂 → Store 复用实例
代码或图示
class HomeActivity : AppCompatActivity() {
val vm: HomeViewModel by viewModel()
}
常见误区
- 普通类里用 viewModel 委托,脱离 ViewModelStore 环境。
- 重复创建 ViewModel 实例,状态不保留。
追问
- 按 key 区分多实例?答:Koin 支持 viewModel key 参数(按版本确认,待确认)。
- ViewModel 构造参数变化后如何更新定义?答:修改 viewModel 定义 lambda 的 get 参数。
07.1.1.10.2-035 ViewModel 作用域与配置变更保留?
一句话结论
ViewModel 实例由 ViewModelStore 持有,旋转等配置变更保留;进程重建后不保留,onCleared 时释放。
概念解释
Koin viewModel 定义遵循 Android ViewModel 生命周期:配置变更不销毁 Store,实例复用;Activity 真正 finish 或进程重建后清除。依赖注入的仓库单例不受影响。需要持久化状态走 SavedStateHandle 或本地库。
原理流程
配置变更 → Store 保留 ViewModel
finish/进程死亡 → onCleared → 释放
代码或图示
@HiltViewModel 类比:Koin viewModel 定义同样绑定 Store
常见误区
- 以为 ViewModel 跨进程/重启存活。
- 在 ViewModel 里持有 View 引用,清除时泄漏。
追问
- 旋转后依赖会重新注入吗?答:实例保留,依赖复用同一注入链解析的对象。
- ViewModel 状态如何持久化?答:SavedStateHandle 保存轻量状态,业务数据落本地库。
07.1.1.10.2-036 跨页面共享 ViewModel 怎么做?
一句话结论
跨 Activity 共享不通过 ViewModelStore;同一 Activity 内多 Fragment 可共享宿主 ViewModel,跨页面共享状态应放仓库/单例或 retained 容器。
概念解释
ViewModel 作用域绑定到 ViewModelStore:Activity 内 Fragment 共享 Activity 的 Store;不同 Activity 各有 Store。跨页面共享业务状态用仓库 single(配合 Flow 状态流),不要把 ViewModel 当全局状态容器。Koin 按 Store 提供实例,跨 Store 不会自动复用。
原理流程
同 Activity 多 Fragment → 取宿主 ViewModel
跨 Activity → 仓库 single + Flow 状态
代码或图示
// Fragment 共享 Activity 作用域 ViewModel
val vm: HomeViewModel by viewModel { this@requireActivity }
常见误区
- 把跨页面状态塞进 ViewModel,第二个页面拿到新实例。
- 单例 ViewModel 持有页面上下文,造成泄漏。
追问
- 导航图作用域 ViewModel 呢?答:Navigation 提供 nav back stack 作用域;Koin 集成按对应 API 获取(待确认)。
- 共享状态放仓库的好处?答:生命周期与页面解耦,可持久化与多端订阅。
07.1.1.10.2-037 viewModel 与 single/factory 的生命周期区别?
一句话结论
viewModel 由 ViewModelStore 管理、页面清除时释放;single 全局常驻;factory 不缓存;三者生命周期边界不可混用。
概念解释
viewModel 服务于页面展示状态,随 Store 清除;single 服务于跨页面共享依赖;factory 服务于临时对象。把页面状态对象注册 single 会跨页面常驻,把仓库注册 factory 每次新建丢失缓存。选型先定对象生命周期。
原理流程
viewModel:Store 生命周期
single:进程生命周期
factory:不缓存
代码或图示
module {
single { NoteRepository(get()) } // 跨页面共享
viewModel { HomeViewModel(get()) } // 页面状态
factory { NoteMapper() } // 临时转换
}
常见误区
- 全用 single 求省事,页面对象常驻。
- 仓库用 factory,缓存与状态每次重置。
追问
- 会话级对象用哪种?答:scoped 绑定会话容器,介于 single 与 viewModel 之间。
- 进程内需要手动释放的单例怎么办?答:显式 close 资源,DI 不替你管理析构。
07.1.1.10.2-038 Koin ViewModel 工厂如何工作?
一句话结论
Koin 为 viewModel 定义生成工厂,在 ViewModelStore 需要实例时从注册表解析依赖并构造 ViewModel;实例由 Store 持有,不由 Koin 全局缓存。
概念解释
工厂 lambda 中 get() 解析仓库等依赖,构造 ViewModel;Store 首次创建后复用,清除时调用 onCleared。Koin Android 集成把工厂接入 ViewModelProvider.Factory。理解工厂链路有助于定位“ViewModel 依赖注入失败”。
原理流程
ViewModelProvider → Koin 工厂 → get 依赖 → 构造 → Store 持有
代码或图示
viewModel { HomeViewModel(repository = get(), savedState = get()) }
常见误区
- 以为 ViewModel 实例缓存在 Koin 全局注册表。
- 工厂 lambda 内直接 new 依赖,绕过注入与测试替换。
追问
- 多构造参数如何解析?答:lambda 内逐个 get 或按命名/类型解析。
- 工厂失败报错指向哪里?答:定位到 viewModel 定义中缺失的依赖类型。
07.1.1.10.2-039 多 ViewModel 依赖同一仓库,实例如何共享?
一句话结论
仓库注册为 single,多个 ViewModel 解析到同一实例;仓库内部状态与缓存因此跨页面共享,需明确这是预期行为。
概念解释
single 缓存使仓库实例全局复用,多个 ViewModel 注入同一对象。如果仓库持有可变会话状态,跨页面可见;不希望共享则拆分有状态部分为 scoped。共享本身不是问题,问题是状态边界未设计。
原理流程
Repo single ──→ VM A 解析同一实例
└─→ VM B 解析同一实例
代码或图示
val repo = single { NoteRepository(get()) }
module { viewModel { ListViewModel(get()) }; viewModel { DetailViewModel(get()) } }
常见误区
- 仓库持有页面级可变状态,被其他页面读到脏数据。
- 误以为每个 ViewModel 拿到独立仓库副本。
追问
- 仓库状态如何对 UI 暴露?答:不可变 Flow/StateFlow,内部可变状态隔离。
- 需要独立仓库实例时?答:factory 或 scoped 定义,按共享需求选择。
07.1.1.10.2-040 Koin 与 Compose 如何集成(koinViewModel)?
一句话结论
Koin 提供 Compose 集成函数在 Composable 中获取注入的 ViewModel,底层仍走 ViewModelStore 与 Koin 工厂。
概念解释
Compose 场景用 koinViewModel()(函数名按 Koin Compose 版本确认,待确认)在 Composable 上下文获取 ViewModel,依赖由 Koin 解析。模块注册与传统视图一致。Compose 预览不启动 Koin,需手动传参或提供预览版。
原理流程
@Composable → koinViewModel() → Store + Koin 工厂
代码或图示
@Composable
fun HomeScreen(vm: HomeViewModel = koinViewModel()) { /* ... */ }
常见误区
- 预览环境调用 koinViewModel,注册表未初始化报错。
- 在 Composable 里直接 by inject 获取带生命周期的长对象,忽略作用域。
追问
- Compose 集成依赖哪个 artifact?答:Koin Android/Compose 坐标按版本文档核对(待确认)。
- 共享 ViewModel 在 Compose 如何取?答:按 NavBackStackEntry/Activity 作用域获取。
07.1.1.10.2-041 Compose 中获取普通依赖的方式?
一句话结论
普通单例/工厂依赖可通过 Koin 委托或 Compose 集成函数获取;页面展示状态优先注入 ViewModel,不在 Composable 直接持有业务仓库。
概念解释
Composable 可注入无状态工具、格式化器等;仓库与业务操作放在 ViewModel,由 ViewModel 注入。直接在 Composable 拿仓库会绕过状态容器,难以测试与生命周期管理。Koin 在 Compose 中的获取 API 按版本确认(待确认)。
原理流程
Composable
├ 展示状态:koinViewModel()
└ 无状态工具:inject/get
代码或图示
@Composable
fun NoteScreen(vm: HomeViewModel = koinViewModel()) {
val formatter: DateFormatter by inject()
}
常见误区
- Composable 直接调仓库方法,状态管理混乱。
- 注入 Activity/Context 类型依赖到 Composable,作用域不当。
追问
- 纯展示组件需要 DI 吗?答:无状态组件靠参数传入,不直接取容器。
- 工具类适合注册什么作用域?答:无状态可 factory 或 single。
07.1.1.10.2-042 Navigation 各路由 ViewModel 如何作用域隔离?
一句话结论
按 Navigation back stack 条目获取 ViewModel,不同路由条目各有 ViewModelStore,状态天然隔离;共享状态沿导航作用域向上归并。
概念解释
每个 NavBackStackEntry 是一个 ViewModelStore 作用域:进入路由创建,返回栈销毁清除。Koin 集成可按 entry 获取 ViewModel。宿主级共享 ViewModel 挂 Activity/导航图作用域。隔离粒度由获取时绑定的 Store 决定。
原理流程
NavEntry A ── Store A ── VM A
NavEntry B ── Store B ── VM B
宿主导航图 ── 共享 Store
代码或图示
// 按导航条目获取(API 形态待确认)
val vm: DetailViewModel = koinViewModel(viewModelStoreOwner = backStackEntry)
常见误区
- 所有路由取 Activity 级 ViewModel,状态跨页面串扰。
- 返回后 ViewModel 未清除,累积实例。
追问
- 跨路由共享一步状态怎么做?答:导航图作用域 ViewModel 或仓库状态流。
- 深层链接重建后 ViewModel 保留吗?答:按 back stack 条目重建规则处理。
07.1.1.10.2-043 共享屏幕状态与导航返回栈是什么关系?
一句话结论
状态归属与返回栈条目绑定:路由内状态随条目销毁;跨路由状态放仓库或更高层 Store;返回栈回退即清理对应作用域。
概念解释
导航返回栈决定页面与 ViewModel 生命周期。设计共享状态时先确定归属层级:条目级、图级、Activity 级、仓库级。层级越高共享范围越大、生命周期越长。状态下放层级过深会导致回退后丢失,上提过浅会跨页串扰。
原理流程
回退条目 → 清除条目 Store
图/Activity Store 保留到对应层级销毁
仓库状态随进程/清理策略保留
代码或图示
状态层级:NavEntry < NavGraph < Activity < Repository(single)
常见误区
- 把向导多步状态放单页 ViewModel,回退一步就丢失。
- 临时表单状态提升到仓库,污染后续会话。
追问
- 表单草稿存哪?答:条目 ViewModel;需要跨进程保存落本地存储。
- 导航图作用域如何获取?答:从图的 NavBackStackEntry 取 Store(待确认 API)。
07.1.1.10.2-044 Compose 预览与测试如何替换 Koin 模块?
一句话结论
预览不依赖真实注册表:组件通过参数接收 ViewModel/依赖;测试中启动 Koin 加载 Fake 模块或直接构造 Fake 注入。
概念解释
可预览设计:ViewModel 作为 Composable 参数默认值走 koinViewModel(),预览传入假实例。测试替换:加载测试模块覆盖接口绑定,或直接 new Fake 传入。避免在预览中初始化全局 Koin。测试间重置注册表防止状态污染。
原理流程
Preview:传 Fake 实例,不 startKoin
Test:startKoin(测试模块) 覆盖绑定
代码或图示
@Composable
fun HomeScreen(vm: HomeViewModel = koinViewModel())
@Preview
@Composable
fun HomePreview() = HomeScreen(vm = PreviewHomeViewModel())
常见误区
- 预览里调用注入函数,缺少注册表崩溃。
- 测试模块与生产模块叠加,Fake 未真正覆盖。
追问
- 覆盖定义的机制?答:同类型绑定替换;具体覆盖规则按 Koin 版本确认(待确认)。
- 不启动 Koin 的单元测试怎么写?答:构造函数直接传 Fake,最直接。
07.1.1.10.2-045 Koin 与 Activity/Fragment 委托属性怎么配合?
一句话结论
by inject() 取普通依赖,by viewModel() 取 ViewModel,委托在组件实例上惰性解析;委托依赖已初始化的全局 Koin 注册表。
概念解释
委托属性首次访问时从 Koin 获取对象;inject 解析 single/factory/scoped 定义,viewModel 走 Store 工厂。组件需在 startKoin 之后使用。Fragment 委托注意在 onViewCreated 后访问 ViewModel 绑定视图。
原理流程
by inject() → 注册表解析
by viewModel() → Store 工厂
代码或图示
class NoteFragment : Fragment() {
val repo: NoteRepository by inject()
val vm: NoteViewModel by viewModel()
}
常见误区
- 在 startKoin 前访问委托,注册表为空。
- Fragment 委托持有视图相关对象,销毁后未释放。
追问
- 委托是惰性的吗?答:首次访问解析;具体实现按版本确认。
- 注入可选依赖?答:
getOrNull()对应委托方式,避免缺失异常。
07.1.1.10.2-046 跨模块 Compose 特性页如何取依赖?
一句话结论
特性模块只依赖接口类型与公共 Koin 模块;实现绑定由下层/宿主模块提供,页面 Composable 通过 ViewModel 或注入获取。
概念解释
feature Compose 模块编译期只能看到 domain 接口,不直接依赖 data 实现。Koin 定义在 data 模块注册接口绑定,宿主聚合加载。页面 ViewModel 由 feature 模块定义,注入仓库接口。跨模块传递实现类会破坏边界。
原理流程
feature Compose 页 → ViewModel → 仓库接口
data 模块 → 接口绑定实现(宿主聚合)
代码或图示
// :feature 模块,只依赖 domain 接口
@Composable
fun NoteDetailScreen(vm: DetailViewModel = koinViewModel())
常见误区
- feature 模块直接 import data 实现类。
- 特性模块自带生产实现绑定,与库复用冲突。
追问
- 特性模块缺少接口定义怎么办?答:先抽 domain 公共接口模块。
- 动态特性页注入时机?答:特性模块加载时注册自身定义,宿主注册表合并(待确认)。
07.1.1.10.2-047 Compose 中作用域关闭时机?
一句话结论
Compose 无传统组件销毁回调,作用域随绑定的 ViewModelStore/导航条目关闭;不要在 Composition 中自建长 scope 而不随生命周期清理。
概念解释
Composable 进入组合获取依赖,离开组合不等于关闭容器。页面级作用域绑定 NavBackStackEntry 或 ViewModelStore,随导航销毁关闭。需要自定义 scope 时用生命周期感知方式打开/关闭。留在 Composition 的引用在离开组合后应可被回收。
原理流程
进入组合 → 获取/打开作用域
导航销毁 → 关闭作用域
代码或图示
Composable 依赖来源:ViewModel(Store) / 仓库 single / 注入工具
常见误区
- 在 Composable 里创建 scope,离开组合后不关闭。
- 把 scope 对象挂到长生命周期单例。
追问
- Compose 副作用里注册监听如何清理?答:DisposableEffect 对应注销。
- 作用域对象泄漏怎么查?答:离开导航后堆快照检查实例是否可达。
07.1.1.10.2-048 startKoin 在什么时候调用?
一句话结论
在 Application onCreate 早期调用 startKoin,注册表初始化完成后再让组件注入;多进程需在各自进程初始化。
概念解释
startKoin 加载模块定义、初始化全局容器。放在 Application.onCreate 保证 Activity/Service/Receiver 使用前就绪。ContentProvider 等早期组件访问注入时要注意初始化顺序。不要在每个组件里重复 startKoin。
原理流程
Application.onCreate → startKoin(modules)
→ 组件生命周期 → 委托解析
代码或图示
class App : Application() {
override fun onCreate() {
super.onCreate()
startKoin { modules(appModule) }
}
}
常见误区
- 在 Activity onCreate 才 startKoin,首个组件注入失败。
- 多进程只在主进程初始化,其他进程注册表为空。
追问
- 能否延迟到首个页面?答:可推迟加载,但所有注入点必须在初始化之后;早期组件风险高。
- 启动耗时敏感怎么办?答:模块定义惰性,实例化在首次使用;startKoin 本身开销需实测。
07.1.1.10.2-049 KoinComponent 接口如何使用?为什么被滥用?
一句话结论
KoinComponent 通过 get()/by inject() 从全局注册表取依赖;它把类耦合到 Koin API,纯逻辑类不应实现该接口。
概念解释
KoinComponent 提供便捷访问入口,常见于 Activity/Fragment。普通仓库/工具类实现它等于硬编码容器,难以脱离 Koin 测试与复用。优先构造函数注入:类不感知容器,依赖作为参数传入。KoinComponent 只放在组装层。
原理流程
KoinComponent.get() → 全局注册表
构造注入:类接收参数,不依赖容器 API
代码或图示
// 不推荐:纯逻辑类耦合 Koin
class NoteMapper : KoinComponent { val api by inject<NoteApi>() }
// 推荐:构造参数
class NoteMapper(private val api: NoteApi)
常见误区
- 每个类都实现 KoinComponent,DI 退化为全局服务定位。
- 纯 Kotlin 库引入 KoinComponent,跨端复用受限。
追问
- 服务定位器与构造注入利弊?答:定位器方便但隐式依赖;构造注入显式、可测试,推荐后者。
- KoinComponent 在测试如何替换?答:需启动/替换注册表;构造注入直接传 Fake。
07.1.1.10.2-050 全局 Koin 注册表与组件级容器是什么关系?
一句话结论
全局注册表保存已加载模块定义与 single 缓存;组件级 scope/ViewModelStore 是附加容器,自身缓存实例但可解析全局定义。
概念解释
全局容器是默认查找范围;scope 容器在其之上提供隔离缓存。ViewModel 实例不在全局注册表常驻。解析顺序:先查当前容器缓存,再按可见范围回退到全局。理解层级有助于判断对象“在哪复用、在哪释放”。
原理流程
解析:当前 scope/Store 缓存 → 全局定义/缓存
代码或图示
GlobalRegistry(定义 + single)
├ Scope 容器(scoped 缓存)
└ ViewModelStore(VM 实例)
常见误区
- 以为组件容器独立隔离所有依赖,全局定义不可见。
- 把 scope 实例误认为存在全局注册表。
追问
- 全局容器何时销毁?答:进程结束;测试中需显式关闭重置。
- 能创建多个独立全局容器吗?答:Koin 多上下文 API 按版本确认(待确认)。
07.1.1.10.2-051 startKoin 模块列表顺序影响解析吗?
一句话结论
定义注册阶段按列表顺序加载;正常按类型解析在首次 get 时进行,顺序一般不影响成功解析;重复定义时顺序可能影响覆盖结果。
概念解释
非重复场景下,模块先后加载不改变类型查找。重复/覆盖定义时,后加载是否覆盖前者取决于 Koin 规则。不应依赖顺序决定实现选择;用 qualifier 或明确的覆盖机制。排查顺序问题前先确认定义是否存在。
原理流程
modules(A, B) → 注册定义
get(T) → 匹配类型/qualifier
重复定义 → 按版本规则处理(待确认)
代码或图示
startKoin { modules(networkModule, dataModule, featureModule) }
常见误区
- 靠调整列表顺序“碰巧”解决歧义,行为不可维护。
- 遗漏某个模块而误以为顺序导致解析失败。
追问
- 测试模块放生产模块之后就是覆盖吗?答:按覆盖规则确认;不能假定顺序覆盖。
- 模块加载失败会中断整个 startKoin 吗?答:按异常类型观察;定义 lambda 错误在解析时抛出。
07.1.1.10.2-052 多进程下 Koin 如何初始化?
一句话结论
每个进程有独立注册表与对象实例;在各进程的 Application 或对应入口初始化 Koin,不能假设主进程单例对其他进程可见。
概念解释
Android 多进程各自加载 Application 并独立内存。主进程 startKoin 不会初始化子进程注册表;子进程访问注入同样需要执行初始化。跨进程共享数据不走 Koin 单例,需 IPC/跨进程存储。进程名判断决定哪些模块在该进程加载。
原理流程
进程 P1:独立注册表 + 独立实例
进程 P2:独立注册表 + 独立实例
共享:IPC / 跨进程数据库
代码或图示
override fun onCreate() {
super.onCreate()
if (isMainProcess()) startKoin { modules(appModule) } else startKoin { modules(serviceModule) }
}
常见误区
- 以为子进程能拿到主进程 single 实例。
- 子进程未初始化,注入点 NoBeanDefFound。
追问
- 如何判断当前进程?答:读取进程名(ActivityManager 或 ApplicationInfo.processName)。
- 多进程单例一致性?答:DI 不提供跨进程单例;共享状态需同步机制。
07.1.1.10.2-053 Koin 启动耗时来自哪里?
一句话结论
启动开销来自模块 DSL 加载、定义注册与早期实例化;single 通常惰性创建,测量时区分注册表初始化与对象构造。
概念解释
startKoin 遍历模块注册定义;依赖对象在首次解析时构造。耗时点:模块数量、定义 lambda 执行、早期页面注入链上对象的构造(客户端、数据库等)。用启动剖析区分“容器初始化”与“业务对象创建”。
原理流程
startKoin:模块遍历 + 定义注册
首次 get:对象构造(重对象在此消耗)
代码或图示
启动阶段耗时拆解:
1. 模块注册
2. 早期注入链构造
3. 重资源初始化(DB/客户端)
常见误区
- 把所有 single 构造时间算到容器头上。
- 在定义 lambda 里做重初始化,首次使用时阻塞主线程。
追问
- 重资源如何延后?答:惰性获取/按需初始化;主线程不做阻塞 IO。
- 如何实测?答:启动剖析打点 startKoin 前后与首个解析点。
07.1.1.10.2-054 延迟加载与 eager 初始化怎么取舍?
一句话结论
Koin 默认惰性创建实例;需要预热的关键对象可在启动显式获取;避免把非必要对象 eager 化拖慢启动。
概念解释
single 首次使用才构造,属于惰性。eager 初始化在启动阶段主动 get 预热常用对象。取舍:首屏必需、构造昂贵且线程安全可预热;后台功能延后。惰性定义减少启动对象,但首次使用有构造延迟。
原理流程
惰性:首次 get 构造
eager:启动阶段显式 get 预热
代码或图示
// 预热示意;具体 eager API 按版本确认(待确认)
startKoin { modules(m); lazyEvaluation() }
常见误区
- 为“保险”把所有依赖 eager,启动对象堆积。
- 首屏阻塞在首次惰性构造上而未预热。
追问
- 预热放主线程还是后台?答:线程安全与资源约束决定;数据库/客户端初始化注意主线程限制。
- 如何统计惰性实例化点?答:日志/打点记录首次 get 时间。
07.1.1.10.2-055 什么情况下不应该用 KoinComponent?
一句话结论
纯逻辑、可复用库、需要脱离容器测试的类不实现 KoinComponent;DI 入口只放在组装层(Activity/Fragment/Application)。
概念解释
KoinComponent 使类依赖全局容器,隐藏依赖、降低可测试性。推荐构造函数注入:依赖显式出现在构造参数,类可独立实例化。框架组件作为 DI 消费入口合理,业务核心不应感知 DI 框架。
原理流程
组装层:KoinComponent/委托
业务层:构造注入,无容器依赖
代码或图示
// 业务类:无 Koin 依赖
class NoteListUseCase(private val repo: NoteRepository)
常见误区
- domain 类实现 KoinComponent,库无法在非 Android 环境复用。
- 隐藏依赖导致单测必须先起 Koin。
追问
- 遗留代码逐步改造怎么做?答:先构造注入替换一个类,再从业务层向上移除 KoinComponent。
- 工具类无依赖需要进 DI 吗?答:无状态可直接使用,不必注册。
07.1.1.10.2-056 NoBeanDefFoundException 常见原因有哪些?
一句话结论
缺失类型未注册、模块未加载、注册类型与注入类型不一致、qualifier 不匹配是四类主因;按类型反查定义与加载链。
概念解释
异常携带缺失类型与 qualifier 信息。排查:搜索类型定义 → 确认模块被聚合 → 核对接口/实现类型 → 核对标记。库模块未包含、测试模块未加载、泛型擦除导致类型不匹配也会触发。
原理流程
缺失类型 T
定义存在?模块加载?类型一致?qualifier 一致?
代码或图示
排查顺序:
1. 全局搜索 single/factory/viewModel 注册 T
2. 模块是否在 includes/modules 链
3. get<T> 与注册泛型是否一致
4. named/类型 qualifier 两侧相同
常见误区
- 注册为实现类,注入点声明接口类型。
- 泛型
Repository<Note>与Repository<Other>解析不匹配。
追问
- 泛型依赖如何注册?答:按完整泛型类型定义;具体泛型匹配规则待确认。
- 异常堆栈指向哪个定义?答:沿注入调用链找到首次 get 的位置。
07.1.1.10.2-057 绑定类型不匹配(接口/实现)报错怎么表现?
一句话结论
注册表按注册类型查找:定义注册为实现而注入接口类型,运行期报缺失;反之可解析但引用类型受限。
概念解释
single { Impl() } 注册的是 Impl 类型;inject<Interface>() 查找 Interface 定义找不到。正确做法 single<Interface> { Impl() }。反向情况:注入 Impl 而注册 Interface,同样不匹配。类型不匹配是运行期异常,编译期不检查 Koin 绑定。
原理流程
注册类型 ≠ 注入类型 → 查找失败
代码或图示
// 错误
single { NoteRepositoryImpl(get()) }
// 注入:by inject<NoteRepository>() → 找不到接口
// 正确
single<NoteRepository> { NoteRepositoryImpl(get()) }
常见误区
- 以为“实现类注册了就能按接口取到”。
- 一个定义既想绑接口又绑实现,漏写双绑。
追问
- 如何防止接口绑定漏写?答:架构评审 + 启动期健全性检查;运行期日志兜底。
- 双绑怎么写?答:bind 声明补充绑定(DSL 待确认版本)。
07.1.1.10.2-058 循环依赖在 Koin 中如何暴露?
一句话结论
运行期构造链形成环时,解析递归无法结束,可能栈溢出或循环异常;Koin 不像编译期 DI 在构建阶段报告环。
概念解释
A 依赖 B,B 依赖 A,构造 lambda 互相 get,解析时递归循环。编译期 DI(Dagger/Hilt)可在生成图时检测环;Koin 运行期才暴露。排查沿构造依赖链找出环,用接口回调、延迟获取、事件解环。
原理流程
get(A) → get(B) → get(A) → 递归
代码或图示
// 环示意
single { A(get()) }
single { B(get()) }
常见误区
- 指望编译期报循环依赖,Koin 不提供该保障。
- 用 lazy/get 延后取对方,掩盖环而未解除设计耦合。
追问
- 如何解环?答:一方依赖接口事件订阅;或抽取第三个无环协调者。
- Koin 有循环检测吗?答:运行期行为按版本确认;不能依赖编译期检测(待确认)。
07.1.1.10.2-059 作用域未关闭导致实例泄漏怎么查?
一句话结论
组件销毁后 scope 内实例仍可达即泄漏;用堆快照查看引用链,定位未关闭 scope 或长生命周期持有方。
概念解释
泄漏路径:scope 未 close、单例/静态引用、未注销监听、异步回调。排查:LeakCanary 或堆转储查看组件销毁后实例 GC 路径。修复:生命周期回调关闭 scope、断开长引用、清理回调注册。
原理流程
组件销毁 → scope 应不可达
快照:仍有强引用 → 沿引用链找持有方
代码或图示
持有链:单例回调 → scope 协调器 → 组件 Context
常见误区
- 只检查 Activity 泄漏,忽略 scope 容器与其内对象。
- 协程 Job 未取消,回调持有旧实例。
追问
- scope 关闭后实例一定回收吗?答:无外部强引用才回收;有引用仍泄漏。
- 如何在测试复现?答:重复进入页面后检查实例数量。
07.1.1.10.2-060 多实现歧义解析怎么处理?
一句话结论
同一接口多实现必须用 qualifier 明确选择;未标记会导致歧义或解析到不确定实现,两侧标记保持一致。
概念解释
远程/本地、主/备等多实现并存,注册表按类型无法区分。定义侧加命名或类型 qualifier,注入点指定相同标记。消除歧义而非依赖“哪个先注册”。代码审查检查多实现是否都有标记。
原理流程
Interface:ImplA(qualifier=remote) / ImplB(qualifier=local)
注入:指定 qualifier → 唯一匹配
代码或图示
single(named("remote")) { RemoteApi() }
single(named("local")) { LocalApi() }
val api: NoteApi by inject(named("remote"))
常见误区
- 多实现无标记,运行期行为不确定。
- 注入点标记与定义拼写不一致。
追问
- 运行期如何发现歧义?答:异常提示多定义匹配;日志可列出同类型定义。
- 配置切换实现怎么做?答:按构建变体/配置选择注册哪一个绑定。
07.1.1.10.2-061 运行期替换定义(测试/调试)怎么做?
一句话结论
测试通过加载替换模块提供同类型 Fake;调试可切换实现绑定;替换需在解析前完成,测试结束重置注册表。
概念解释
替换机制:测试模块注册同接口 Fake 定义;按 Koin 覆盖规则生效。生产代码不依赖调试开关注入。测试隔离:每个用例重新初始化 Koin,避免 single 残留。具体替换/卸载 API 按 Koin 4.x 确认(待确认)。
原理流程
startKoin(生产模块 + 测试模块)
→ Fake 覆盖接口绑定
结束 → 关闭/重置注册表
代码或图示
val testModule = module {
single<NoteRepository> { FakeNoteRepository() }
}
常见误区
- 替换在首次解析之后生效,已缓存实例不更新。
- 测试不重置,上一用例 Fake 污染后续用例。
追问
- 能否只替换一个绑定而保留其余?答:加载最小测试模块覆盖目标接口即可。
- 不启动 Koin 的替代方案?答:构造注入直接传 Fake,更轻量。
07.1.1.10.2-062 Koin 日志与诊断如何开启?
一句话结论
startKoin 配置日志级别后可观察模块加载、定义注册与解析过程;诊断输出用于排查缺失、歧义与重复定义。
概念解释
日志记录模块加载、定义创建、解析查找。开启后定位“模块是否加载、类型是否注册、匹配到哪个定义”。日志 API 与级别名称按 Koin 版本确认(待确认)。生产环境关闭详细日志避免信息泄漏与开销。
原理流程
startKoin { logLevel(...) } → 输出注册/解析过程
代码或图示
startKoin {
modules(appModule)
// 日志配置按版本文档核对(待确认)
}
常见误区
- 生产包保留详细 DI 日志。
- 只看异常堆栈,不打开日志确认注册全貌。
追问
- 如何导出已注册定义清单?答:诊断 API/日志遍历注册表(待确认版本)。
- 日志暴露依赖信息吗?答:避免在发布版输出内部类型与实现细节。
07.1.1.10.2-063 模块加载失败与注册表状态如何排查?
一句话结论
区分模块加载异常与解析期异常:加载期注册失败中断初始化;解析期缺失/不匹配在 get 时抛出;按异常阶段检查注册表。
概念解释
startKoin 阶段:模块 DSL 求值、定义注册;解析阶段:get 时构造对象。加载失败表现为初始化阶段异常;定义缺失/构造错误在使用时暴露。排查先确定异常阶段,再检查对应模块与依赖链。测试可独立加载模块验证。
原理流程
阶段 1:模块加载/注册
阶段 2:解析/构造
代码或图示
排查:
1. 异常发生在 startKoin 还是首次注入
2. 失败模块能否独立加载
3. 构造 lambda 内 get 的依赖是否齐全
常见误区
- 把构造期异常当成模块未加载。
- 单个模块错误导致整体初始化状态不明,未隔离验证。
追问
- 模块能否单独测试加载?答:可以,测试 startKoin 只加载该模块与 Fake 依赖。
- 注册表部分失败后可用吗?答:按异常类型判断;不确定时重置重初始化。
07.1.1.10.2-064 Hilt 与 Koin:编译期 vs 运行期解析的本质差异?
一句话结论
Hilt 由注解处理器在编译期生成依赖图并校验绑定;Koin 运行期在注册表按类型解析,缺失与环到使用时才暴露。
概念解释
Hilt:编译期生成组件代码,绑定不完整、作用域错误、循环依赖在构建阶段报错。Koin:无生成代码,模块 DSL 运行期注册,解析在 get 时进行,问题表现为运行期异常。差异带来不同的保障强度、构建开销与调试方式。
原理流程
Hilt:注解 → KSP/kapt 生成图 → 编译期校验
Koin:DSL → 运行期注册表 → get 时解析
代码或图示
保障时机:
Hilt:构建期
Koin:运行期
常见误区
- 期待 Koin 提供编译期绑定完整性检查。
- 把 Hilt 的 @InstallIn 组件概念直接套到 Koin 模块。
追问
- 两者能否在过渡期间共存?答:技术上可以,边界清晰;长期避免双 DI。
- 编译期校验对大工程价值?答:尽早暴露绑定错误,减少运行期故障。
07.1.1.10.2-065 编译速度对比:注解处理 vs 运行期注册?
一句话结论
Hilt 依赖 KSP/kapt 生成代码增加构建期处理;Koin 无注解处理器,模块 DSL 在运行期求值,增量编译负担更低。
概念解释
Hilt 每次构建处理注解、生成 Dagger 组件代码,kapt 历史上拖慢编译,KSP 改善但仍有生成开销。Koin 不参与构建期图生成,模块是普通 Kotlin 代码。代价是少了编译期校验。编译速度需在实际工程测量,不以框架宣传为准。
原理流程
Hilt 构建:注解处理 + 代码生成
Koin 构建:普通编译,无 DI 生成
代码或图示
构建开销对比维度:增量编译、注解处理器、生成代码量
常见误区
- 断言 Koin 一定更快,忽略模块代码本身与运行期解析开销。
- 把 kapt 旧问题直接套到 KSP 版本(待确认实测)。
追问
- kapt 与 KSP 对 Hilt 构建影响?答:KSP 增量更好;具体版本行为待确认。
- 如何实测?答:对比 clean/incremental 构建时间与处理器耗时。
07.1.1.10.2-066 启动耗时对比:容器初始化与实例查找?
一句话结论
Hilt 生成的组件在运行期提供实例;Koin 需初始化注册表并在解析时按类型查找;两者启动与查找开销需实测,不能凭印象下结论。
概念解释
Hilt 运行期实例由生成工厂提供;Koin 启动加载模块定义、解析时查表。启动成本差异来自容器初始化、定义数量与查找结构。实例化重对象的成本两者都存在。应按首屏启动剖析比较,而非框架概念对比。
原理流程
启动:容器/组件初始化
运行:查找定义 → 构造/缓存实例
代码或图示
测量点:Application onCreate 前后、首屏首个依赖解析
常见误区
- 认为运行期 DI 必然拖慢启动,忽略对象本身构造成本。
- 未区分容器初始化与业务资源初始化。
追问
- Koin 查找是反射吗?答:按实现版本确认;DSL lambda 注册避免部分反射(待确认)。
- 启动优化通用手段?答:延后非必要初始化、重资源后台加载、预热首屏对象。
07.1.1.10.2-067 可测试性对比:替换绑定的方式?
一句话结论
两者都可替换依赖:Hilt 用测试模块/@BindValue 编译期替换;Koin 加载 Fake 模块运行期替换;构造注入在两者中都最易单测。
概念解释
Hilt 测试替换有编译期约束,测试模块绑定类型需匹配;Koin 替换在注册表层,测试间需重置。最轻量的可测试性来自构造函数注入:不启动容器直接传 Fake。DI 框架的测试便利度与业务类是否感知容器相关。
原理流程
Hilt:测试模块替换绑定
Koin:Fake 模块覆盖定义
通用:构造注入直接 new Fake
代码或图示
// 与框架无关的单测
val useCase = NoteListUseCase(FakeNoteRepository())
常见误区
- 业务类耦合容器,单测被迫启动 DI 框架。
- 测试替换未隔离,Fake 残留影响其他用例。
追问
- Hilt 测试替换机制?答:@UninstallModules + 测试模块;@BindValue 注入假对象。
- Koin 测试隔离关键?答:每个用例重置注册表,避免 single 残留。
07.1.1.10.2-068 团队上手成本与样板代码对比?
一句话结论
Koin DSL 直观、无生成概念,上手快;Hilt 概念多(组件、作用域、模块)但有编译期约束;样板量与团队经验共同决定成本。
概念解释
Koin:模块 DSL、委托属性,阅读门槛低;代价是规则靠约定与评审。Hilt:学习组件层级、作用域、注解,但结构由编译器把关。新项目按团队经验、代码规模与校验需求选择;老团队 Java 占比高时迁移成本另算。
原理流程
上手路径:
Koin:写 module → startKoin → inject
Hilt:理解组件/作用域 → 注解 + 模块 → 编译生成
代码或图示
成本维度:学习曲线、样板代码、排错方式、文档成熟度
常见误区
- 只看“少写注解”判断 Koin 成本低,忽略运行期排错成本。
- 小团队强行引入复杂作用域模型,维护成本上升。
追问
- 框架选型评审看什么?答:编译保障、构建/启动实测、可测试性、团队经验、长期维护。
- 能否渐进采用?答:可以从核心模块开始,逐步替换注入方式。
07.1.1.10.2-069 性能:实例查找开销与缓存模型?
一句话结论
查找发生在每次解析:single 命中缓存,factory/scope 按规则创建;查找开销与注册表实现、定义数量相关,应实测而非假设。
概念解释
缓存模型决定对象复用;查找路径决定单次解析成本。Koin 注册表按类型/限定符索引;Hilt 走生成工厂方法。高频调用路径上的依赖应缓存为 single,避免重复构造。性能问题先定位是查找开销还是对象构造开销。
原理流程
解析 → 查缓存 → 命中返回 / 未命中构造
代码或图示
高频对象:single 缓存
临时对象:factory 不缓存
常见误区
- 把昂贵对象注册 factory,高频路径反复构造。
- 单凭框架口碑判断查找性能,无测量数据。
追问
- 查找能加索引缓存吗?答:容器内部实现优化;业务层通过作用域缓存对象。
- 性能瓶颈怎么定位?答:剖析解析点与构造函数耗时。
07.1.1.10.2-070 哪种方案适合多模块大工程?
一句话结论
多模块大工程通常更看重编译期校验与边界约束,Hilt 类编译期 DI 更易治理;Koin 适合轻量、快速迭代或对生成代码敏感的工程,最终按实测与团队情况定。
概念解释
大工程绑定关系复杂,编译期校验能在构建阶段暴露缺失与环;模块边界与作用域由编译器辅助约束。Koin 灵活、无生成代码,但一致性靠评审与运行期测试。选择不是框架崇拜:结合模块数量、历史代码、构建基线与故障代价评估。
原理流程
评估维度:模块规模 / 编译保障 / 构建启动实测 / 测试体系 / 团队
代码或图示
大工程倾向:编译期 DI + 构造注入 + 明确模块边界
常见误区
- 小项目照搬大工程复杂 DI 结构。
- 大工程只用运行期约定,缺少绑定完整性验证手段。
追问
- 已有 Koin 的大工程如何加固?答:启动期健全性检查、模块边界规则、关键路径测试覆盖。
- 混合架构风险?答:两套注入并存增加理解成本,迁移需设清理边界。
07.1.1.10.2-071 哪种方案适合快速原型与插件化场景?
一句话结论
快速原型偏好 Koin 式轻量 DSL、无生成步骤;插件化/动态加载场景需评估运行期注册与类加载隔离,编译期 DI 的生成模型在动态特性下有额外约束。
概念解释
原型阶段变化快,Koin 模块调整不触发注解处理,迭代成本低。插件化按功能动态加载:运行期 DI 可在模块加载时注册定义,但要处理类加载器隔离与实例一致性;编译期 DI 需为动态特性单独配置生成产物。场景选择结合加载机制与团队经验。
原理流程
原型:Koin DSL 快速迭代
动态特性:加载模块 → 注册定义 → 解析使用
代码或图示
评估清单:动态加载方式、类加载隔离、实例一致性、DI 产物可见性
常见误区
- 原型阶段引入过重 DI 结构,后期拆除成本高于迭代收益。
- 假设插件间共享同一全局注册表无隔离问题。
追问
- 动态特性的 DI 定义放哪?答:随特性模块打包,加载时注册;具体机制待确认。
- 插件间通信走 DI 吗?答:走接口/事件通道,DI 只负责本模块组装。
07.1.1.10.2-072 运行期 DI 有哪些风险?
一句话结论
运行期 DI 的主要风险:绑定缺失/类型不匹配到使用时才暴露、循环依赖不被编译期拦截、替换与隔离靠纪律、解析行为难静态审查。
概念解释
风险清单:NoBeanDefFound 只在运行路径触发;接口绑定漏写编译通过;循环依赖运行期递归;多实现歧义靠 qualifier 纪律;测试替换需手动重置。缓解:启动期健全性检查、关键路径测试、模块边界规则、评审绑定约定。风险可被工程实践降低,但不消失。
原理流程
风险暴露点:首次解析 / 特定路径 / 测试替换
缓解:健全性检查 + 测试覆盖 + 评审规则
代码或图示
运行期风险对照:
编译期能拦截 → 运行期才发现
类型绑定 → 需人工核对
循环依赖 → 需运行时/评审发现
常见误区
- 以为测试覆盖主路径就等于绑定全量验证。
- 把运行期框架的灵活性当成无约束优势。
追问
- 启动期如何做健全性检查?答:遍历关键类型 getOrNull 验证定义存在;具体 API 待确认。
- 风险最高的注入点?答:深链路构造与动态特性入口。
07.1.1.10.2-073 编译期 DI 的限制与代价?
一句话结论
编译期 DI 保障强,但有注解处理/代码生成成本、概念模型复杂、动态装配受限,配置错误在构建阶段暴露。
概念解释
代价:构建期处理器与生成代码、学习组件作用域模型、动态条件装配不如运行期灵活。保障:绑定完整性、作用域规则、循环依赖在构建期校验。限制来源:图在编译期固定,运行期按外部输入切换实现的能力受限,需模块/限定符设计。
原理流程
收益:构建期校验
代价:处理器开销 + 概念复杂度 + 装配灵活性
代码或图示
限制场景:运行期按配置选实现、动态加载模块、反射装配
常见误区
- 认为编译期 DI 无任何运行期成本。
- 把编译期校验强度等同于设计正确性。
追问
- 编译期 DI 能换实现吗?答:通过模块替换/限定符/构建变体;纯运行期分支需额外设计。
- 生成代码量影响什么?答:编译时间、方法数、IDE 索引负担。
07.1.1.10.2-074 手动 DI(ServiceLocator / 构造传参)适用场景?
一句话结论
小型工程、纯逻辑库、依赖链简单时手动构造或轻量服务定位器足够;依赖变复杂后手动装配会集中到组装层,需纪律维护。
概念解释
构造传参:依赖显式、可测试,组装点集中在 Application/入口。ServiceLocator:全局静态容器,隐式依赖、难替换。手动 DI 无框架开销,但模块增多后组装代码膨胀、重复接线。选择按依赖规模与团队维护能力,不是非框架即过度设计。
原理流程
入口组装 → 逐层构造传入
ServiceLocator:静态查找(隐式依赖)
代码或图示
// 手动组装
val repo = NoteRepository(NoteApi(), NoteDao())
val vm = HomeViewModel(repo)
常见误区
- 大工程用静态定位器,依赖隐式且测试困难。
- 组装逻辑散落到业务类内部。
追问
- 手动 DI 与框架 DI 边界?答:框架负责注册与解析;手动负责显式传参,核心业务都应构造注入。
- 何时引入框架?答:模块/依赖数量增长、重复接线与替换成本上升时。
07.1.1.10.2-075 三者混合使用的边界与治理?
一句话结论
混合 DI 应设明确边界:业务核心统一构造注入,框架只在组装层使用;避免同一对象经两套容器解析,过渡期设迁移清单与清理节点。
概念解释
混用风险:同一依赖在 Hilt 与 Koin 各注册一份,实例不一致;业务类同时感知两种容器。治理:按模块划定归属,新代码统一方案,旧模块逐步迁移;评审检查跨容器引用。过渡期文档记录每个模块的 DI 方案与替换状态。
原理流程
业务层:构造注入(框架无关)
组装层:单一 DI 容器
迁移:旧模块 → 新方案,逐项清理
代码或图示
治理清单:模块归属表、跨容器引用检查、迁移完成标准
常见误区
- 两套容器各缓存一份单例,状态不一致。
- 混合长期化,无退出节点。
追问
- 混合期如何共享实例?答:以一套为准,另一套通过构造传入,不重复注册。
- 迁移顺序?答:从核心 domain/data 开始,再到 feature 与入口。
07.1.1.10.2-076 api 与 implementation 在模块暴露上的区别?
一句话结论
api 会把依赖传递给下游模块,implementation 只在本模块内部使用;对外暴露的类型才用 api,其余一律 implementation。
概念解释
模块 A api 依赖 B,依赖 A 的 C 也能看到 B 类型;implementation 依赖 B 对 C 不可见。api 扩大传递依赖、增加耦合与重编译范围;implementation 收紧边界。DI 绑定类型若经 api 暴露,下游可直接引用实现,破坏封装。
原理流程
api:A → B 类型传递给 C
implementation:B 仅 A 内部可见
代码或图示
// :domain 只暴露接口
api project(':domain')
// :data 实现细节不传递
implementation project(':data')
常见误区
- 图省事全用 api,模块依赖图膨胀。
- 下游编译需要类型却用 implementation,报不可见错误。
追问
- 如何判断该用哪个?答:本模块公开签名是否出现该依赖类型;出现则 api,否则 implementation。
- api 过多的代价?答:传递依赖广、改动触发大范围重编译、封装泄漏。
07.1.1.10.2-077 依赖模块应该用 api 还是 implementation?
一句话结论
原则:默认 implementation,仅当本模块公开 API 签名使用该模块类型时才 api;DI 实现绑定模块用 implementation,接口模块按需 api。
概念解释
数据实现模块被 domain/feature 间接使用,不应 api 传递实现类。接口模块被上层签名引用,可用 api。仓库依赖判断:查看本模块导出的类、接口、ViewModel 公开方法签名是否暴露依赖类型。收紧 implementation 有利于模块独立编译与替换。
原理流程
公开签名含类型 → api
仅内部使用 → implementation
代码或图示
:feature implementation :data(实现不外露)
:feature api :domain(接口出现在签名)
常见误区
- 把 data 实现模块 api 出去,上层可 new 实现类。
- 为解决编译报错盲目改 api,未收紧边界。
追问
- 第三方库也要区分吗?答:是,库类型出现在公开签名才 api。
- 重构后如何复查?答:依赖报告 + 公开源码 import 扫描。
07.1.1.10.2-078 模块边界如何防止实现类泄漏到上层?
一句话结论
通过 Gradle 依赖收紧、接口隔离与 Lint/架构规则三重约束:上层只依赖接口类型,实现模块不 api 传递,规则拦截反向 import。
概念解释
泄漏路径:api 传递实现、上层直接 import data 类、DI 注册类型暴露实现。防护:依赖配置最小化;domain 定义接口;架构检查规则禁止上层 import 下层实现;代码评审核对公开签名。泄漏一旦发生,上层与实现细节耦合,替换困难。
原理流程
依赖配置 → 接口隔离 → 规则检查 → 评审
代码或图示
禁止:feature import com.example.data.*Impl
允许:feature 依赖 domain 接口
常见误区
- 只靠约定不写规则,边界逐渐腐化。
- DI 模块把实现类型作为公开导出类型。
追问
- 用什么工具检查?答:Gradle 依赖报告、Lint 自定义规则、ArchUnit 类依赖规则。
- 泄漏发现后怎么修?答:抽接口到上层,改依赖配置,删除反向 import。
07.1.1.10.2-079 接口模块与实现模块拆分原则?
一句话结论
接口/契约放上层模块,实现放下层模块;接口模块不依赖实现,实现模块依赖接口;DI 绑定在实现侧注册。
概念解释
domain 模块定义仓库接口与模型,data 模块提供实现与绑定。接口模块可独立编译、被多端复用;实现模块可替换而不改上层。拆分粒度按业务边界,避免每个类一个模块。接口稳定后再沉淀,避免过早抽象。
原理流程
:domain(接口/模型)← :data(实现/绑定)
代码或图示
// :domain
interface NoteRepository { fun notes(): Flow<List<Note>> }
// :data
class NoteRepositoryImpl(private val api: NoteApi) : NoteRepository
常见误区
- 接口模块混入实现细节,失去隔离意义。
- 接口随实现频繁变动,上层被迫跟随修改。
追问
- 接口需要数据模型吗?答:共享模型放契约模块,避免实现模型外泄。
- 多实现如何组织?答:各实现模块依赖同一接口模块,分别提供绑定。
07.1.1.10.2-080 模块循环依赖如何识别?
一句话结论
Gradle 模块循环在构建配置阶段报错;源码层循环依赖通过 import 扫描与模块依赖图识别,表现为 A 依赖 B、B 反向依赖 A。
概念解释
Gradle 不允许工程模块循环依赖,配置即失败。源码逻辑环:模块间通过类引用形成双向依赖,Gradle 配置可能未报但架构已腐化。识别:模块依赖报告、包名 import 检查、架构规则扫描。常见于共享工具被双向引用、跨层直接调用。
原理流程
Gradle 环:配置阶段失败
源码环:依赖图双向边 → 扫描发现
代码或图示
A → B → A:环
拆分:抽 C(公共),A → C,B → C
常见误区
- Gradle 能编译就认为无架构环。
- 循环通过工具类中转,隐蔽难查。
追问
- 环对构建的影响?答:模块无法独立编译,改动触发连锁重编译。
- 工具输出在哪看?答:Gradle 依赖任务报告、模块边界 Lint 结果。
07.1.1.10.2-081 循环依赖治理:抽公共模块、接口与事件?
一句话结论
解环手段:抽取双向共用部分为公共模块,依赖倒置用接口隔离,跨层通信用事件/回调;消除直接双向引用。
概念解释
抽公共:共享模型/工具下沉到 common 模块。接口隔离:上层定义接口,下层实现,依赖方向反转。事件通信:双向调用改为发布事件、对方订阅。治理后依赖图为单向无环。治理需同步调整 DI 绑定位置,避免解环后又通过容器隐式耦合。
原理流程
环 A ↔ B
→ 公共 C / 接口 / 事件
→ 单向:A → C ← B
代码或图示
// 上层定义接口,下层实现
interface EventSink { fun emit(event: NoteEvent) }
常见误区
- 抽公共模块又被双方塞入业务特例,重新变重。
- 用静态事件总线掩盖双向调用,耦合仍在。
追问
- 解环后 DI 怎么放?答:绑定随实现模块,公共模块只暴露契约。
- 如何验证环已消除?答:重复依赖图扫描无双向边。
07.1.1.10.2-082 架构分层:data/domain/presentation 依赖方向?
一句话结论
单向依赖:presentation → domain ← data;domain 不依赖 data 与 presentation,data 实现 domain 接口。
概念解释
domain 包含业务规则、接口与模型,是最内层。presentation(UI/ViewModel)调用 domain 用例;data 实现 domain 仓库接口。依赖方向指向内层。DI 绑定把 data 实现接到 domain 接口,组装在 app 层。分层越界表现为 domain import data/presentation。
原理流程
presentation → domain ← data
代码或图示
:presentation(ViewModel/Compose)
:domain(用例/接口/模型)
:data(数据源/仓库实现/绑定)
常见误区
- domain 依赖 data 的 DAO/API 类型。
- data 反向调用 presentation 接口。
追问
- 用例层放哪?答:domain 内,编排仓库接口。
- 分层与 DI 关系?答:DI 不改变依赖方向,只在组装期把实现接到接口。
07.1.1.10.2-083 Koin 模块位置与模块边界如何保持一致?
一句话结论
Koin 定义所在 Gradle 模块应与绑定归属一致:接口绑定在实现模块,ViewModel 定义在 feature 模块;不在上层模块注册下层实现细节。
概念解释
一致性检查:仓库实现绑定在 data 模块导出的 Koin 模块;页面 ViewModel 定义在 feature。app 只聚合模块。若 Koin 定义全堆在 app,data/feature 无法独立替换与编译验证。模块位置违背边界会放大耦合,重构时连带改动注入配置。
原理流程
实现绑定 → 实现模块
页面装配 → feature 模块
入口 → app 聚合
代码或图示
:data/dataModule:仓库绑定
:feature/featureModule:ViewModel 绑定
:app:startKoin 聚合
常见误区
- app 模块集中注册所有实现,下层模块失去自包含性。
- feature 模块注入 data 具体实现类型。
追问
- 库模块 Koin 定义放哪?答:随库导出,宿主聚合。
- 如何评审一致性?答:按模块核对定义类型与依赖方向。
07.1.1.10.2-084 动态特性模块的 DI 如何加载?
一句话结论
动态特性模块在按需加载时注册自身 Koin 定义,宿主注册表合并;跨模块依赖接口由宿主基础模块提供,具体加载与注册 API 按 Koin 版本确认(待确认)。
概念解释
特性模块下载安装后,其 Koin 模块被加载进容器;ViewModel/仓库绑定随模块就绪可用。未加载模块的定义不在注册表。基础应用提供公共依赖与接口。动态特性与主进程共享注册表还是独立容器,取决于实现方案,需实测确认。
原理流程
基础模块 → 公共定义
特性加载 → 注册特性定义 → 解析使用
代码或图示
// 特性模块导出自身模块;加载时合并(API 待确认)
val featureModule = module { viewModel { FeatureViewModel(get()) } }
常见误区
- 假设特性未加载时其绑定仍可解析。
- 特性模块直接依赖主进程内部实现类。
追问
- 特性间能否互相注入?答:应通过基础层接口,不直接依赖另一动态特性。
- 卸载特性后实例如何处理?答:按容器/作用域清理;机制待确认版本。
07.1.1.10.2-085 动态特性按需加载对单例与作用域的影响?
一句话结论
单例在已加载注册表内共享;动态特性卸载/未加载时其定义不可用,作用域实例随特性容器生命周期管理;不能把特性对象缓存到基础层单例。
概念解释
影响:特性专属对象不应由宿主 single 长期持有;跨特性共享的是基础层接口与状态。特性卸载后残留引用会泄漏或类加载问题。设计上特性内聚自己的 ViewModel/仓库,对外只暴露基础层契约。实例一致性按注册表合并模型确认(待确认)。
原理流程
特性加载 → 定义/实例进入容器
特性卸载 → 清理特性作用域实例
代码或图示
禁止:宿主单例持有动态特性实现引用
允许:宿主持有基础层接口,特性按需实现
常见误区
- 基础层缓存特性类实例,卸载后类加载泄漏。
- 特性状态写入全局 single,影响其他特性。
追问
- 特性状态持久化放哪?答:基础层存储/接口,特性卸载后可恢复。
- 如何验证隔离?答:加载/卸载特性后检查实例与类引用。
07.1.1.10.2-086 库模块发布时 Koin 定义如何自注册?
一句话结论
库导出自己的 Koin 模块供宿主包含;不自行启动全局容器;文档说明必需绑定与加载方式,测试可独立加载库模块。
概念解释
发布库提供 xxxModule 与说明:注册了哪些类型、宿主需提供哪些外部依赖。库内部不调用 startKoin,避免重复初始化。多版本库随版本文档更新绑定清单。消费方按文档聚合模块,缺失定义在集成期暴露。
原理流程
库:导出 module + 绑定说明
宿主:startKoin 包含库模块
代码或图示
// :library 公开
public val libraryModule = module { single { LibraryService() } }
常见误区
- 库 Application 自行 startKoin,与宿主冲突。
- 未文档化宿主必须提供的绑定,集成时缺失。
追问
- 库需要区分调试/发布绑定吗?答:可提供变体模块,宿主按构建变体选择。
- 库测试如何加载?答:测试 startKoin 只加载库模块加 Fake 依赖。
07.1.1.10.2-087 模块可见性检查:Lint 与依赖分析怎么做?
一句话结论
用 Gradle 依赖报告核对 api/implementation,用 Lint/架构规则扫描反向 import;把边界检查纳入 CI,防止腐化回潮。
概念解释
依赖分析:查看模块传递依赖与公开签名引用。Lint 规则:禁止上层包名 import 下层实现包。CI 门禁阻断违规合并。定期复查:新模块依赖配置、公共 API 暴露类型。规则与分层文档保持一致。
原理流程
依赖报告 → 配置复查
Lint/ArchUnit → import 规则
CI → 违规阻断
代码或图示
规则示例:feature 包不得 import data.impl 包
常见误区
- 规则只在本地跑,未进 CI,逐渐失效。
- 依赖配置改动后不复查公开签名。
追问
- 自定义 Lint 规则成本?答:简单包名检查可落地;复杂架构规则用 ArchUnit 类测试。
- 报告在哪生成?答:Gradle dependencies 任务与模块依赖视图。
07.1.1.10.2-088 多模块共享配置与客户端如何注入?
一句话结论
跨模块共享的配置、客户端注册为 single,通过基础接口模块暴露;各模块注入接口,实现绑定在配置实现模块提供。
概念解释
共享对象:HTTP 客户端、数据库、应用配置,全局一份。定义位置:基础 data/network 模块。消费模块依赖接口类型,不依赖客户端具体实现。配置来源(BuildConfig/远程配置)在组装层注入构造参数。避免每个模块自建客户端实例。
原理流程
基础模块:single { SharedClient(config) }
各模块:注入接口
代码或图示
single { OkHttpClient.Builder().build() }
single<NoteApi> { NoteApi(get()) }
常见误区
- 各模块 new 独立客户端,连接池/配置不共享。
- 配置对象散落到业务模块读取 BuildConfig。
追问
- 多环境配置怎么切?答:按构建变体注册不同配置实现。
- 共享客户端线程安全?答:客户端自身线程安全;DI 只保证单实例。
07.1.1.10.2-089 特性模块之间能否直接依赖?
一句话结论
特性模块之间不应直接 Gradle 依赖;跨特性协作通过基础层接口、事件或导航路由,保持特性可独立替换与卸载。
概念解释
直接特性依赖形成耦合网,任一特性改动影响其他,动态加载受阻。协作模式:共享状态放基础层仓库/状态流;动作通过事件;跳转通过路由。特性间只认识基础契约。例外:极少量稳定公共能力下沉到 common 模块,而非特性互依赖。
原理流程
Feature A ↘
Common(接口/状态/事件)
Feature B ↗
代码或图示
禁止::feature-order 依赖 :feature-note
允许:两者依赖 :common,经事件通信
常见误区
- 特性间直接调用对方 ViewModel/仓库。
- 共享逻辑先放某个特性,再被另一特性依赖。
追问
- 跨特性页面跳转怎么做?答:路由/导航接口在 common,各特性注册目标。
- 公共能力沉淀标准?答:被两个以上特性稳定复用,再抽 common。
07.1.1.10.2-090 数据层变更如何不破坏上层模块编译?
一句话结论
上层依赖稳定接口与模型,data 内部实现变更不影响编译;接口演进走兼容策略,破坏性变更先扩展再迁移。
概念解释
保护手段:契约模块隔离接口;上层不引用 data 类型;新增字段/方法向后兼容;删除/改签名先版本过渡。data 内部数据源、客户端、映射调整对上层透明。DI 绑定随实现模块调整,接口不变则上层不动。
原理流程
data 内部变更 → 接口不变 → 上层编译通过
接口变更 → 兼容扩展 → 上层迁移 → 清理旧契约
代码或图示
兼容步骤:新增方法/类型 → 上层切换 → 移除旧接口
常见误区
- 上层直接依赖 data 模型,字段改名即连锁编译失败。
- 接口随实现频繁破坏性调整。
追问
- 模型映射在哪做?答:data 层在接口边界完成领域模型与实体转换。
- 如何回归保护?答:契约测试覆盖接口行为,上层模块编译独立验证。
07.1.1.10.2-091 模块化后的构建优化与模块粒度?
一句话结论
模块化改善并行编译与增量构建,但模块过细增加配置与依赖开销;粒度按业务边界与编译收益平衡,定期合并过碎模块。
概念解释
收益:独立编译、缓存复用、并行构建。代价:模块清单、依赖配置、DI 聚合成本。过细:大量小模块互相依赖,配置阶段与索引负担上升。评估粒度:模块是否有独立变更频率、可否复用、编译收益。构建优化结合模块分层与依赖配置收紧。
原理流程
模块划分:业务边界 + 独立变更 + 复用价值
过碎 → 合并;过粗 → 拆分
代码或图示
优化维度:增量编译、并行度、依赖传递面、配置开销
常见误区
- 为“彻底分层”把每个类做成模块。
- 模块长期不独立变更却维持独立配置。
追问
- 如何度量模块收益?答:构建时间、变更影响面、复用情况。
- 模块边界与功能团队对齐?答:高内聚业务模块对应团队职责。
07.1.1.10.2-092 Koin 定义里引用跨模块类型的前提?
一句话结论
定义中 get() 解析的类型必须在 Gradle 依赖中可见,且对应模块已加载注册;类型不可见编译失败,定义未注册运行期失败。
概念解释
两个前提:编译期类型可引用(模块依赖导出),运行期定义已注册(模块聚合加载)。Koin 定义 lambda 引用跨模块接口时,所在模块需依赖契约模块。实现类型不应出现在上层定义中。检查 DI 配置前先核对 Gradle 依赖与模块聚合链。
原理流程
类型可见:Gradle 依赖
定义可用:Koin 模块加载
代码或图示
// :feature 依赖 :domain,get 解析 NoteRepository
viewModel { HomeViewModel(get()) }
常见误区
- 定义引用实现类型但模块未依赖 data。
- 模块已编译可见,Koin 聚合遗漏导致运行期缺失。
追问
- 泛型跨模块可见性?答:完整泛型类型需依赖对应类型声明。
- 排查顺序?答:先编译可见性,再运行期注册。
07.1.1.10.2-093 架构评审看哪些 DI 与边界指标?
一句话结论
评审指标:依赖方向是否单向、api 传递面、反向 import 数量、跨特性直接依赖、DI 定义归属、单例持有短生命周期对象、测试可替换性。
概念解释
逐项检查:分层依赖指向内层;api 依赖最小化;无上层 import 下层实现;特性间无直接依赖;Koin 模块随归属模块;作用域长短匹配;业务类可构造注入测试。指标用于发现腐化趋势,而非一次性打分为框架优劣。
原理流程
评审清单:方向 / 暴露 / 反向引用 / 特性耦合 / 归属 / 作用域 / 可测试性
代码或图示
检查记录:违规项、模块、修复建议、跟踪状态
常见误区
- 只看 DI 能否跑通,不检查边界与作用域。
- 评审结论无后续跟踪闭环。
追问
- 指标如何量化?答:依赖报告计数、Lint 违规数、模块直接依赖列表。
- 多久复查一次?答:重大模块变更与定期版本节点。
07.1.1.10.2-094 遗留工程拆分模块的迁移步骤?
一句话结论
先抽契约与公共模块,再按业务边界迁出 data/feature,收紧依赖配置,最后清理跨层引用与旧 DI 归属;每步保持可编译可构建。
概念解释
步骤:识别高内聚业务;抽 domain 接口/模型;迁 data 实现;拆 feature;调整 api/implementation;修复反向 import;整理 DI 模块归属;补边界测试。小步迁移,每步独立提交与验证,不一次性大重构。遗留类先做外观隔离,再逐步下沉。
原理流程
契约抽取 → 实现迁出 → 界面拆分 → 依赖收紧 → 引用清理 → 规则固化
代码或图示
迁移闭环:每步编译通过 + 测试通过 + 边界检查通过
常见误区
- 大爆炸重构,长时间不可编译、问题堆积。
- 只移动文件不改依赖方向,腐化随模块复制。
追问
- 迁移期 DI 怎么办?答:先维持现有注入,模块归属随迁出逐步调整。
- 如何避免迁移回潮?答:CI 边界规则先行,再迁代码。
07.1.1.10.2-095 模块内单例与跨模块单例如何区分?
一句话结论
single 注册进全局注册表即跨模块共享;仅模块内部使用的对象可不注册或用局部工厂;区分依据是共享范围而非定义所在文件。
概念解释
Koin single 缓存全局可见,注册即跨模块可解析。模块私有对象不应对外暴露类型;需要内部复用可在模块内持有实例或 factory。判断共享范围:哪些模块注入该类型。跨模块单例需审视状态边界,避免无关模块读到共享可变状态。
原理流程
全局 single:跨模块共享缓存
模块私有:不注册 / 内部持有
代码或图示
共享判断:注入点清单 → 仅本模块 → 私有;多模块 → 全局
常见误区
- 模块内部工具注册 single,意外跨模块复用。
- 以为定义在某模块就只有该模块可见。
追问
- 跨模块单例状态如何隔离?答:状态不可变或按 key 分区;可变状态下沉仓库管理。
- 私有对象怎么测试?答:构造注入传入,不依赖注册表私有性。
07.1.1.10.2-096 反向依赖与 DI 图腐化怎么发现?
一句话结论
反向依赖通过 import 扫描与依赖图发现;DI 图腐化表现为实现类型外泄、跨层绑定、单例持有短生命周期对象,定期评审与规则扫描结合。
概念解释
反向:上层包名引用下层实现。DI 腐化:绑定在错误层级、接口被实现类型替代、作用域倒挂、特性间经容器耦合。发现手段:源码 import 规则、模块依赖报告、DI 定义归属核对、内存泄漏检查。腐化渐进发生,需持续门禁而非一次审查。
原理流程
源码扫描 → 依赖报告 → DI 归属核对 → 运行期/内存检查
代码或图示
腐化信号:domain import data;app 注册全部实现;single 持 Activity
常见误区
- 只在出故障时查 DI,平时无规则基线。
- 把新增便捷注入视为无害,累积成图腐化。
追问
- 腐化修复顺序?答:先切断反向依赖,再调绑定归属与作用域。
- 如何防止新腐化?答:CI 规则 + 评审清单 + 模板约束。
07.1.1.10.2-097 多模块测试如何替换各层定义?
一句话结论
测试按层提供 Fake 模块覆盖接口绑定:domain 用例测试直接传 Fake,集成测试加载 Fake 数据模块;各用例隔离重置注册表。
概念解释
单元测试:不启动 Koin,构造注入 Fake。集成/UI 测试:启动 Koin 加载生产模块加 Fake 覆盖层,替换数据/网络绑定。跨模块替换只改接口层绑定,不改动业务类。测试结束重置避免 single 残留。覆盖范围按测试层级决定替换深度。
原理流程
单测:构造 Fake 传入
集成测:Fake 模块覆盖接口定义
隔离:用例间重置注册表
代码或图示
val fakeRepoModule = module {
single<NoteRepository> { FakeNoteRepository() }
}
常见误区
- 集成测试用真实网络/数据库,不稳定且慢。
- Fake 模块未隔离,上一用例状态污染。
追问
- 如何验证替换生效?答:测试断言 Fake 行为/调用记录。
- 多层替换顺序?答:从最外层数据源 Fake 开始,逐层可替换。
07.1.1.10.2-098 场景:多端复用库加 App 壳如何组织 DI?
一句话结论
复用库提供纯逻辑与接口绑定模块,App 壳聚合并提供平台实现;库不启动全局容器,跨端差异在壳层注入。
概念解释
库:纯 Kotlin 逻辑、契约、可独立测试;导出自己的 Koin 模块。App 壳:Application 启动 Koin,聚合库模块加平台实现模块。多端(Android/其他)各自壳层提供平台绑定。库内不引用平台 API,避免复用受限。DI 配置随壳层变化。
原理流程
:core 库 → 导出 coreModule
:app 壳 → startKoin(coreModule + platformModule)
代码或图示
core:接口/用例/模型
platform:Android 客户端/存储实现
app:聚合入口
常见误区
- 库内直接依赖 Android 框架,其他端无法复用。
- 库自行 startKoin,多壳集成冲突。
追问
- 平台能力如何抽象?答:core 定义接口,壳层实现并绑定。
- 库测试如何组织?答:独立加载 coreModule 加 Fake 平台实现。
07.1.1.10.2-099 依赖注入与架构分层是什么关系?
一句话结论
DI 是组装机制,不决定架构方向;分层规定依赖指向,DI 在组装期把实现接到接口,二者配合但不能互相替代。
概念解释
分层回答“谁依赖谁、职责在哪”;DI 回答“对象如何获得依赖”。错误分层下 DI 只会把耦合接线自动化。健康实践:单向分层 + 构造注入 + 容器在组装层。DI 配置应反映分层,绑定归属与模块边界一致。评审时先看分层方向,再看 DI 接线。
原理流程
分层:依赖方向与职责
DI:组装与提供机制
关系:DI 落地分层,分层约束 DI 归属
代码或图示
先定:presentation → domain ← data
再配:data 绑定 domain 接口
常见误区
- 以为用了 DI 框架架构就正确。
- DI 归属违背分层,掩盖反向依赖。
追问
- 无框架时如何保持分层?答:构造注入 + 入口集中组装。
- 评审顺序?答:依赖方向 → 接口隔离 → DI 绑定归属 → 作用域。
07.1.1.10.2-100 综合:Koin 多模块依赖图与架构边界如何落地?
一句话结论
落地路径:先定单向分层与模块边界,再按归属拆分 Koin 模块聚合加载,用依赖配置、规则检查与测试替换固化边界,持续评审防止腐化。
概念解释
闭环:识别业务边界 → 拆 domain/data/feature 模块 → 接口隔离 → Koin 模块随归属注册 → app 聚合 → 收紧 api/implementation → Lint/CI 门禁 → 测试 Fake 替换 → 定期复查。Koin 提供运行期组装,边界保障靠工程规则与测试。版本敏感 API 以官方文档为准,未确认处标注待确认。
原理流程
边界设计 → 模块拆分 → DI 归属 → 聚合加载 → 规则固化 → 测试与复查
代码或图示
落地清单:
1. 分层依赖单向无环
2. 接口模块与实现模块分离
3. Koin 定义随归属模块导出
4. Gradle 依赖最小化(implementation 默认)
5. CI 边界规则 + 测试替换体系
6. 定期评审 DI 图与作用域
常见误区
- 先写 Koin 模块再补分层,方向被 DI 配置绑架。
- 边界规则未进 CI,迁移后逐渐回潮。
追问
- 落地第一步做什么?答:梳理模块依赖图与反向引用清单。
- 如何判断落地成效?答:模块独立编译、边界违规归零、测试可替换、启动解析无缺失。
参考来源
待整理清单
- [ ] Koin 4.x 具体 DSL 名称与作用域 API 核对(scoped、scope、viewModel、qualifier 等)
- [ ] 动态特性模块加载与注册 Koin 定义的官方机制确认
- [ ] Koin 测试模块覆盖/卸载 API 与版本行为确认
- [ ] KSP/kapt 与 DI 框架构建期开销的实测数据
- [ ] 多进程注册表初始化与实例一致性方案验证
- [ ] 自定义 Lint/ArchUnit 模块边界规则落地示例