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

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 模块边界规则落地示例