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

06.8.4.2 DI 对比、测试与架构实践

所属:全栈开发面试题库 / 06 后端框架与工程实践 / 06.8 Kotlin 后端 / 06.8.4 Koin 与依赖注入

本节要解决的问题

本篇横向对比 Koin、Dagger/Hilt、Spring 容器与手动 DI 在编译期安全、启动开销、可测试性与 AOT 友好度上的取舍;覆盖测试替换、循环依赖、模块边界与 Clean Architecture 落地、DI 反模式与 GraalVM 冲突。Koin 自身 API 机制在 06.8.4.1 已讲,本篇不复述;版本基线 Koin 4.x、Dagger 2.x、Spring Boot 3.x,不确定处标「待确认」。

06.8.4.2-001 依赖注入(DI)解决的核心问题是什么?

一句话结论

DI 把「对象创建与依赖装配」从业务代码中剥离,组件只声明所需依赖,由外部容器/构造方提供;目的是解耦实现、提升可测试性与可替换性。

概念解释

控制反转(IoC)是思想:依赖不由组件自己获取,而由外部注入。DI 是 IoC 的一种实现方式。组件面向接口依赖,实现可替换。没有 DI 时,组件内部 new 依赖、自己定位配置,实现与使用强耦合。

原理流程

  1. 组件构造函数声明依赖接口。
  2. 外部装配方选择实现并传入。
  3. 组件只使用接口行为。
  4. 替换实现不改动组件内部。

代码或图示

// 依赖注入:依赖由外部传入
class UserService(val repo: UserRepository)

// 自行获取:耦合具体实现
class UserService { val repo = JdbcUserRepository() }

常见误区

  • 用了 DI 框架就等于做了 DI:内部仍到处取容器只是换了定位方式。
  • 把 DI 理解成设计模式本身,它是装配机制。

追问

  • DI 与 DIP(依赖倒置原则)关系?答:DIP 是原则,DI 是落地手段;依赖抽象、注入实现。
  • 不用框架能做 DI 吗?答:能,手动构造函数传参就是最朴素的 DI。

06.8.4.2-002 编译期 DI 与运行时 DI 的根本区别是什么?

一句话结论

编译期 DI 在构建期生成装配代码并校验依赖图;运行时 DI 在程序启动/解析时按类型查找装配。区别在于错误暴露时机与是否生成代码。

概念解释

编译期方案(如 Dagger)由注解处理器在编译期生成组件代码,缺失依赖、类型不匹配在编译报错。运行时方案(如 Koin、Spring)在容器内保存定义,解析时查找,问题到运行时或测试才暴露。两者都支持构造注入,差异在校验时机与实现机制。

原理流程

  1. 编译期:处理器扫描注解,生成装配代码,编译期校验图完整。
  2. 运行时:容器注册定义,解析时按类型查找构造。
  3. 错误暴露:编译期在构建阶段,运行时在启动/调用阶段。
  4. 产物:编译期多生成类,运行时多容器元数据。

代码或图示

编译期:注解处理器 → 生成组件代码 → 编译校验
运行时:DSL/注解注册 → 容器注册表 → 解析查找

常见误区

  • 以为运行时 DI 性能一定差:主要差异在校验时机,运行时查找成本通常很小。
  • 以为编译期 DI 不需要容器概念:生成代码内部仍有装配组件。

追问

  • 运行时 DI 怎么弥补编译期安全?答:模块校验、集成测试覆盖解析图。
  • 编译期 DI 在 KMP 下限制?答:注解处理器对各平台支持程度不同,见后续题目。

06.8.4.2-003 Koin 运行时解析的成本体现在哪里?

一句话结论

成本包括启动注册定义、解析时类型查找与首次构造;实例化后复用,单次解析查找开销很小。主要代价是缺失依赖要到运行时才暴露。

概念解释

Koin 不生成装配类,容器在运行时维护定义表。get 时按键查找 definition 并按语义取实例。查找是内存操作,相比业务 IO 可忽略。真正的工程成本是编译期不校验,依赖图错误靠测试与启动校验兜底。

原理流程

  1. 启动把模块定义写入注册表。
  2. 解析按键查找 definition。
  3. 首次构造或取缓存实例。
  4. 缺失/歧义在解析时抛异常。

代码或图示

运行时成本:注册内存占用 + 解析查找 + 首次构造
非成本:编译期代码生成与注解处理

常见误区

  • 把运行时 DI 误解为每次反射 new 对象。
  • 担心解析查找成为性能瓶颈:热点路径先量化再判断。

追问

  • 解析查找能优化吗?答:热点 bean 预热为 single,减少首次构造;查找本身无需优化。
  • 运行时方案调试难点?答:装配图不体现在编译产物,需借助日志与校验工具。

06.8.4.2-004 Dagger/Hilt 编译期是怎么完成装配的?

一句话结论

注解处理器在编译期扫描注入注解与模块,生成组件工厂代码,把构造调用按依赖关系串好;依赖缺失或绑定不匹配在编译期报错。

概念解释

Dagger 不依赖运行时反射注入,处理器为每个绑定生成工厂类,组件接口方法由生成代码实现。Hilt 在 Dagger 之上提供 Android 集成与预定义作用域。服务端 JVM 可用 Dagger,但生态与文档偏移动端。

原理流程

  1. 标注注入构造与模块。
  2. 注解处理器生成工厂与组件代码。
  3. 编译期检查依赖图完整。
  4. 运行时生成代码直接 new 并传参。

代码或图示

class UserService @Inject constructor(val repo: UserRepository)

@Module
interface RepositoryModule {
    @Binds fun bindRepo(impl: JdbcUserRepository): UserRepository
}

常见误区

  • 以为 Dagger 运行时反射注入:注入由生成代码完成。
  • 把 Hilt 的 Android 作用域概念直接搬到服务端。

追问

  • Dagger 生成代码在哪看?答:编译产物中的生成目录,工厂与组件实现类。
  • 编译期报错信息友好吗?答:绑定缺失/歧义由处理器报错,定位到模块与类型。

06.8.4.2-005 Spring 容器的运行时机制是怎样的?

一句话结论

Spring 容器在运行时扫描/读取配置,注册 bean 定义,启动时按依赖关系实例化并注入;支持构造/字段/方法注入与大量生态集成。

概念解释

Spring 是成熟运行时容器,配置来自注解、Java DSL 或 XML。Bean 生命周期由容器管理,支持作用域、AOP 代理与自动装配。服务端 Spring Boot 生态完整,但容器重、启动慢于轻量方案。Kotlin 下可利用构造注入与 DSL 配置。

原理流程

  1. 容器读取配置注册 bean 定义。
  2. 启动阶段实例化单例并解析依赖。
  3. 注入方式完成装配。
  4. 容器关闭管理生命周期。

代码或图示

@Service
class UserService(val repo: UserRepository)

@Repository
class JdbcUserRepository : UserRepository

常见误区

  • 以为 Spring 只靠反射:构造注入由容器调用构造函数,字段注入涉及反射。
  • 把 Spring 自动装配当成编译期校验:缺失 bean 仍在启动时报错。

追问

  • Spring 单例与 Koin single 语义差异?答:都是容器级复用,Spring 额外有作用域代理与生命周期回调体系。
  • Spring Boot 3 对 AOT 支持?答:支持 AOT 处理,详见后续 GraalVM 题目。

06.8.4.2-006 手动 DI(构造函数传参)有什么优劣?

一句话结论

手动 DI 无框架、无魔法,依赖显式可见、编译期可检查;缺点是对象图大时装配代码冗长,需要自己管理生命周期与替换。

概念解释

手动 DI 在组装根点(main/控制器工厂)逐层 new 并传参。组件不感知容器。小型服务足够清晰,大型项目装配代码集中且易遗漏。框架 DI 本质是把手动装配规则自动化。

原理流程

  1. 根组装点创建最底层依赖。
  2. 逐层传入上层。
  3. 组件只接收构造参数。
  4. 生命周期由根点管理。

代码或图示

val repo = JdbcUserRepository(dataSource)
val service = UserService(repo)
val controller = UserController(service)

常见误区

  • 项目变大后在各处手动 new,装配关系分散。
  • 手动管理资源关闭遗漏,生命周期失控。

追问

  • 什么时候手动 DI 最合适?答:小服务、库代码、框架无关核心层。
  • 手动 DI 算反模式吗?答:不算,它是 DI 的基础形式;问题在于装配分散而非手动本身。

06.8.4.2-007 各方案启动开销怎么对比?

一句话结论

手动 DI 启动只执行组装代码;编译期 DI 启动跑生成代码;运行时 DI 多容器注册与查找开销。实际启动差异更多来自框架生态与 bean 初始化,而非 DI 方案本身。

概念解释

DI 方案对启动时间的影响:运行时容器注册定义、编译期生成代码无注册扫描、手动无容器。重型 bean 初始化(连接池、客户端)在各方案下都耗时。Koin 轻量,但不解决外部资源启动成本。

原理流程

  1. 区分容器启动开销与 bean 初始化开销。
  2. 容器注册:运行时方案有成本,编译期/手动无。
  3. bean 构造:各方案一致。
  4. 压测分段定位。

代码或图示

启动时间 = 容器初始化 + bean 构造 + 外部连接建立

常见误区

  • 把框架整体启动慢归咎于 DI 方案。
  • 只比理论开销,不压测实际 bean 初始化。

追问

  • 启动敏感场景怎么选?答:核心链路预热可控、非关键懒加载;方案差异次要。
  • 怎么测量 DI 开销?答:分段计时容器注册与 bean 构造。

06.8.4.2-008 可测试性在各方案下有什么差异?

一句话结论

构造注入让所有方案都能在单测中直接传替身;差异在于测试是否需要启动容器、能否轻松替换实现。手动与构造注入最直接,运行时容器提供模块替换机制。

概念解释

可测试性关键是依赖可替换。构造函数接收接口,单测传 mock 不启动容器。运行时 DI 测试可装载覆盖模块;编译期 DI 测试也可手动构造传替身。字段注入削弱可测试性,任何方案都应避免。

原理流程

  1. 组件构造函数声明接口依赖。
  2. 单测直接传 mock 实例。
  3. 集成测试启动容器并替换实现。
  4. 断言业务行为。

代码或图示

@Test
fun `create user`() {
    val svc = UserService(FakeRepository())
    svc.register(...)
}

常见误区

  • 字段注入导致单测必须启动容器才能填依赖。
  • 测试依赖真实外部资源,用例慢且不稳定。

追问

  • 运行时容器测试替换怎么做?答:见后续 loadKoinModules/declareMock 题目。
  • 编译期 DI 测试要生成组件吗?答:单测可绕过容器直接构造。

06.8.4.2-009 缺失依赖在编译期还是运行时暴露?

一句话结论

编译期 DI 在构建期报缺失绑定;运行时 DI 在启动校验或首次解析时报缺失。工程上用模块校验与集成测试把运行时问题尽量前移到 CI。

概念解释

编译期方案的处理器遍历依赖图,缺绑定直接编译失败。运行时方案注册阶段不解析构造,缺失要到 checkModules 或实际调用才发现。测试覆盖不到的路径,问题留到线上。

原理流程

  1. 编译期:构建遍历图,缺失即编译错误。
  2. 运行时:启动校验主动解析全部定义。
  3. 未校验路径首次调用时报缺失。
  4. CI 集成测试覆盖核心链路。

代码或图示

编译期:build 失败
运行时:checkModules 失败 / 启动报错 / 调用抛 NoBeanDefFound

常见误区

  • 运行时项目不做模块校验,依赖图问题靠线上发现。
  • 单测传替身绕过容器,装配图从未被验证。

追问

  • checkModules 能替代集成测试吗?答:不能,它校验定义可解析,不验证真实行为。
  • 怎么提高运行时方案安全度?答:校验 + 集成测试 + 启动自检组合。

06.8.4.2-010 重构友好度怎么比较?

一句话结论

构造注入让依赖显式,重构改构造参数时编译器协助定位;运行时容器隐式查找在重构后可能静默解析到错误实现,需要测试兜底。

概念解释

显式构造参数在改类型/加依赖时编译期提示调用点。运行时按类型查找,重命名或改实现后解析点不报错,可能装配错误。编译期生成代码同样在编译期绑定。测试断言实现类型作为补充保护。

原理流程

  1. 重构修改依赖类型。
  2. 显式构造:编译期列出需调整的组装点。
  3. 运行时容器:解析点不编译报错,靠测试发现。
  4. 评审核对装配图同步更新。

代码或图示

显式依赖:编译器协助定位
容器查找:测试与评审兜底

常见误区

  • 重构后只改生产定义,解析侧未同步。
  • 依赖类型放宽成宽泛接口,重构失去类型保护。

追问

  • 运行时方案怎么增强重构安全?答:模块校验、实现类型断言测试、评审装配图。
  • 接口抽象过度有什么代价?答:层级过多增加跳转与理解成本。

06.8.4.2-011 Koin 在 KMP 场景的优势是什么?

一句话结论

Koin 纯 Kotlin、无注解处理器强依赖、DSL 可在 commonMain 共享,适配 KMP 各平台;编译期 DI 方案在多平台注解处理上限制更多。

概念解释

KMP 共享代码需要在 JVM/JS/Native 等平台复用装配逻辑。Koin 模块用 Kotlin DSL 编写,公共模块跨端复用,平台差异由平台模块补实现。Dagger 类方案对 Native/JS 注解处理支持有限(具体支持矩阵待确认)。

原理流程

  1. commonMain 定义公共 module 与接口。
  2. 各平台模块提供实现绑定。
  3. 端侧启动装载公共 + 平台模块。
  4. 共享代码解析到平台实现。

代码或图示

// commonMain
val commonModule = module { single<Settings> { get() } }

常见误区

  • commonMain 引用平台特定类,共享代码编译失败。
  • 平台模块漏装实现,公共代码运行时缺失。

追问

  • Koin 在 Native 平台实例化有约束吗?答:按当前版本 KMP 支持矩阵确认(待确认)。
  • 其他 KMP DI 方案?答:可评估编译期生成类方案的跨端支持情况。

06.8.4.2-012 Dagger 在 JVM 后端使用有什么局限?

一句话结论

Dagger 生态与文档偏 Android/Java 服务端,服务端生态集成(配置、生命周期、AOP)不如 Spring;注解处理器增加构建步骤,团队学习成本较高。

概念解释

Dagger 本身可用于 JVM 后端,编译期安全是优势。但服务端常见的自动配置、条件装配、切面集成在 Dagger 生态薄弱。后端团队若已用 Spring,切换 Dagger 收益有限。KMP 跨端场景再权衡。

原理流程

  1. 评估服务端生态需求。
  2. Dagger 提供编译期装配。
  3. 配置/生命周期需自行组织。
  4. 对比团队熟悉度与构建链成本。

代码或图示

Dagger 优势:编译期安全
Dagger 局限:后端生态薄、注解处理器构建链

常见误区

  • 照搬 Android Dagger 教程到服务端,作用域概念不匹配。
  • 为编译期安全引入整套注解处理,收益与成本不匹配。

追问

  • 服务端编译期安全还有别的手段?答:模块校验 + 集成测试是运行时方案的补偿。
  • Dagger 与 Spring 能混用吗?答:不建议,两套容器边界混乱。

06.8.4.2-013 Spring 在 Kotlin 后端项目里怎么定位?

一句话结论

Spring Boot 适合需要成熟生态(数据访问、消息、安全、Actuator)的服务端;Kotlin 下用构造注入、DSL 配置与协程支持。轻量 Ktor 服务则通常搭配 Koin,不引入 Spring 容器。

概念解释

选型先定 Web 框架与生态需求。Spring 全家桶集成完善但容器重;Ktor 轻量灵活,DI 配 Koin。同一项目不并行两套容器。Kotlin 与 Spring 兼容良好,可使用 data class、构造注入与协程 Web 支持。

原理流程

  1. 评估生态需求与团队栈。
  2. 重生态服务选 Spring Boot。
  3. 轻量服务选 Ktor + Koin。
  4. DI 体系跟随主框架。

代码或图示

Spring Boot 服务:Spring DI
Ktor 服务:Koin DI

常见误区

  • Ktor 项目引入 Spring 容器只为部分注解,增加不必要重量。
  • 以为 Kotlin 必须配特定 DI,实际按框架与团队选择。

追问

  • Spring 项目能用 Koin 吗?答:技术上可嵌独立容器,但不推荐;保留 Spring DI 保持一致。
  • Spring Kotlin 特化细节见哪篇?答:06.8.2 Spring Boot 与 Kotlin。

06.8.4.2-014 服务端 DI 选型决策矩阵看哪些维度?

一句话结论

维度包括:编译期安全需求、KMP 跨端、生态集成、团队熟悉度、启动与内存预算、AOT/GraalVM 要求、测试替换便利度。按项目权重打分,不追求单项最优。

概念解释

没有绝对最优方案。内部业务服务重生态选 Spring;KMP/轻量服务选 Koin;强编译期约束且团队接受注解链可评估 Dagger。库代码保持框架无关,手动构造注入。

原理流程

  1. 列出项目硬性约束(跨端、AOT、生态)。
  2. 各方案按维度评分。
  3. 团队维护成本纳入决策。
  4. 核心层保持框架无关,便于后续切换。

代码或图示

维度:校验时机 / 跨端 / 生态 / 启动开销 / AOT / 测试 / 团队成本

常见误区

  • 只看技术新潮度选型,忽略团队维护能力。
  • 核心层绑定某 DI 框架,后续切换成本高。

追问

  • 选型错了能换吗?答:核心层框架无关时,替换装配层成本可控;耦合越深越难换。
  • 小团队推荐?答:优先团队熟悉、生态匹配的方案,不引入复杂构建链。

06.8.4.2-015 循环依赖是怎么产生的?

一句话结论

两个或多个 bean 的构造参数互相引用,形成闭环:A 依赖 B,B 又依赖 A;容器无法先实例化任何一方。

概念解释

循环依赖分构造循环(构造参数成环)与字段循环(先构造再互相注入)。构造循环在任何容器都难以解决;字段循环可被部分容器用提前暴露引用缓解,但属于设计异味。根因通常是职责划分不清,两个类承担了对方该有的逻辑。

原理流程

  1. A 构造需要 B 实例。
  2. B 构造又需要 A 实例。
  3. 双方都等待对方先创建。
  4. 容器报循环依赖或提前暴露半成品。

代码或图示

class OrderService(val repo: OrderRepository)
class OrderRepository(val service: OrderService) // 环

常见误区

  • 把循环依赖当容器能力问题,实际是设计问题。
  • 用字段注入掩盖构造循环,运行期状态不一致。

追问

  • 循环依赖一定是错的吗?答:多数情况是职责边界问题;极少数双向协作应重构为中介/事件。
  • 怎么检测?答:启动校验与代码审查识别构造参数环。

06.8.4.2-016 Koin 遇到循环依赖会怎么表现?

一句话结论

构造参数成环时,Koin 在解析链上检测到循环并抛出循环依赖异常;具体异常类型与检测时机以 4.x 实现为准(待确认)。

概念解释

运行时容器按构造链递归解析,回到正在构造的类型即识别成环。Koin 不像部分容器支持三级缓存提前暴露半成品。字段注入的循环是否被允许取决于解析时机。面试时区分构造环与字段环的处理差异。

原理流程

  1. 解析 A,构造参数需要 B。
  2. 解析 B,构造参数需要 A。
  3. 检测到 A 正在构造中。
  4. 抛循环依赖异常,中断解析。

代码或图示

resolve A → resolve B → resolve A(循环)→ 异常

常见误区

  • 以为 Koin 会像 Spring 一样暴露早期引用打破构造环。
  • 循环异常出现后只换注入方式,不重构职责。

追问

  • 字段注入能绕过吗?答:可能不报错,但两个半成品互相持有,行为风险更高。
  • 异常怎么定位环?答:沿解析链找重复类型,重构切断回边。

06.8.4.2-017 Spring 的循环依赖与三级缓存是什么机制?

一句话结论

Spring 通过三级缓存提前暴露未完全初始化的单例引用,解决字段/setter 注入的单例循环;构造器注入循环无法解决。该机制是 Spring 容器内部实现,Koin 不照搬。

概念解释

一级缓存存成品单例,二级存早期半成品,三级缓存存工厂对象。单例创建中先暴露工厂,循环方拿到早期引用,属性填充后成品归位。构造注入需要完整对方实例,无法用早期引用打破。Spring Boot 2.6 后默认禁止部分循环依赖(待确认当前默认策略)。

原理流程

  1. 单例 A 创建中,提前暴露工厂到三级缓存。
  2. B 注入 A 时拿到早期引用。
  3. B 创建完成,A 继续属性填充。
  4. 成品放入一级缓存。

代码或图示

三级缓存:singletonObjects / earlySingletonObjects / singletonFactories

常见误区

  • 把三级缓存当成推荐设计,依赖它维持循环依赖。
  • 以为构造循环也能被三级缓存解决。

追问

  • 为什么 Spring 默认收紧循环依赖?答:早期引用半成品易出状态问题,鼓励重构。
  • 其他容器有类似机制吗?答:多数运行时容器不提供,避免半成品暴露。

06.8.4.2-018 打破循环依赖有哪些重构手段?

一句话结论

手段包括:抽取第三方中介类承载协作、一方改为事件/回调解耦、拆分职责让依赖单向化、使用懒获取延迟解析。根本是调整职责边界,而不是换注入方式掩盖。

概念解释

常见重构:A、B 互相调用,抽出 C 承接双方共用逻辑;B 完成后发事件通知 A;依赖方向改为单向。lazy 代理可推迟一方解析,但只是缓解,环仍在。评审优先消除设计环。

原理流程

  1. 画出循环调用链。
  2. 识别可抽取的协作职责。
  3. 引入中介或事件,依赖改单向。
  4. 验证行为不变。

代码或图示

// 事件解耦:OrderService 发布事件,InventoryService 订阅
class OrderService(val events: EventPublisher)
class InventoryService(val handler: OrderEventHandler)

常见误区

  • 用 lazy/字段注入把环藏起来,代码更难理解。
  • 抽中介类只是把环平移,未真正单向化。

追问

  • 两个领域服务双向调用正常吗?答:正常协作应通过应用编排或领域事件,而非直接构造互注。
  • 重构后怎么验证?答:单测覆盖双方交互场景,确认事件/中介行为。

06.8.4.2-019 测试中怎么用 loadKoinModules 替换依赖?

一句话结论

测试启动容器后用 loadKoinModules 装载覆盖模块,把真实实现替换为替身;替换按类型/qualifier 覆盖,测试结束卸载或重置容器。具体 API 名称在 4.x 待确认。

概念解释

生产模块注册真实实现,测试模块注册 mock/fake 绑定同一接口。覆盖后解析得到替身。替换只影响测试容器,不修改生产定义。模块可在每个用例前装载、用例后卸载。

原理流程

  1. 测试装载生产公共模块。
  2. loadKoinModules 追加替身模块覆盖绑定。
  3. 执行用例断言。
  4. 卸载模块或关闭容器重置。

代码或图示

startKoin { modules(prodModule) }
loadKoinModules(module { single<UserRepository> { FakeRepository() } })

常见误区

  • 覆盖模块未卸载,跨用例替身残留。
  • 覆盖类型/qualifier 与生产不一致,未真正替换。

追问

  • 覆盖与生产定义重复注册冲突吗?答:按覆盖规则生效,测试模块后装载优先。
  • 怎么验证替换生效?答:断言解析实例类型为替身。

06.8.4.2-020 declareMock 一类 mock 替换怎么用?

一句话结论

部分 DI 方案提供声明式 mock 注册,测试中直接把接口绑定为 mock 对象;Koin 生态的 mock 集成 API(如 mockk 桥接)名称与能力在 4.x 需对照文档确认(待确认)。

概念解释

声明 mock 省去手写 Fake 类,mock 框架控制行为与断言。替身分两类:手写 fake(状态可控、行为简单)与 mock(按调用断言)。测试中按场景选择。mock 注册进容器后,业务代码无感知。

原理流程

  1. 创建 mock 实例(mockk/Mockito)。
  2. 注册绑定到接口类型。
  3. 业务解析得到 mock。
  4. 断言调用交互。

代码或图示

// 意图示例;具体 Koin mock 桥接 API 待确认
val repo = mockk<UserRepository>()
module { single<UserRepository> { repo } }

常见误区

  • 过度使用 mock,把领域规则也 mock 掉,测试无意义。
  • mock 行为未打桩,返回默认值导致断言偏差。

追问

  • fake 与 mock 怎么选?答:状态/简单行为用 fake;验证调用交互用 mock。
  • mock 框架在 Kotlin 下注意什么?答:final 类/协程支持,选 mockk 一类 Kotlin 友好方案。

06.8.4.2-021 checkModules 启动校验能检查什么?

一句话结论

checkModules 在不完整启动服务的情况下遍历模块定义,尝试解析 bean,检查缺失绑定、歧义与构造问题;是运行时 DI 前移错误的主要手段。具体校验范围与 API 在 4.x 待确认。

概念解释

校验主动触发 definition 解析,暴露未被测试覆盖路径的缺失依赖。它不验证业务行为,也不保证外部资源可用。校验应纳入 CI,随测试一起运行。带参数/作用域的定义需要提供测试解析上下文。

原理流程

  1. 装载目标模块。
  2. 校验遍历 definition 尝试构造。
  3. 缺失/歧义/构造失败即报错。
  4. CI 阻断不通过的装配图。

代码或图示

// 校验 API 形式待确认
koin.checkModules()

常见误区

  • 以为校验通过就等于集成测试通过。
  • 作用域/参数定义未在校验上下文提供,漏检。

追问

  • 校验能发现循环依赖吗?答:构造环在校验解析时暴露。
  • 校验慢吗?答:只构造不跑业务,成本可控;重外部资源需替身覆盖。

06.8.4.2-022 测试模块隔离与容器重置怎么做?

一句话结论

每个测试类/用例使用独立容器或在用例间关闭重置,确保 single 不跨用例残留;替身模块随用例装载,结束卸载。

概念解释

共享全局容器会让上一用例的单例状态影响下一用例。隔离方式:独立 koinApplication、用例前启动用例后关闭、卸载测试模块。公共生产模块可复用,状态与替身必须隔离。

原理流程

  1. 用例前创建容器装载模块。
  2. 追加替身模块。
  3. 执行用例。
  4. 关闭/卸载容器,清理缓存。

代码或图示

@BeforeEach fun setUp() { startKoin { modules(prodModule, fakeModule) } }
@AfterEach fun tearDown() { closeKoin() }

常见误区

  • 全局容器只装载一次,单例状态串扰导致偶发失败。
  • 测试模块残留生产环境配置。

追问

  • 集成测试能共享容器提速吗?答:可复用容器但数据要隔离;单例状态需确认无副作用。
  • 重置 API 有哪些?答:关闭容器、卸载模块,具体名称待确认。

06.8.4.2-023 契约测试中替身怎么注入?

一句话结论

契约测试验证服务与外部协作方的约定,外部客户端接口注入 mock/fake,按契约打桩返回,断言本服务发出的请求符合约定。

概念解释

契约测试不连真实外部系统,替身模拟对方响应。注入点在客户端接口,业务服务无感知。契约变化通过替身断言捕获。消息/HTTP 客户端替身按协议记录请求。

原理流程

  1. 定义外部客户端接口。
  2. 测试注入符合契约的替身。
  3. 执行业务用例。
  4. 断言请求参数与响应处理。

代码或图示

val client = mockk<PaymentClient>()
every { client.charge(any()) } returns ChargeResult.ok()
val service = OrderService(client, repo)

常见误区

  • 契约测试连真实测试环境,结果受对方稳定性影响。
  • 替身打桩与真实契约不一致,测试通过但集成失败。

追问

  • 契约测试与集成测试分工?答:契约测约定,集成测真实连通;外部契约变更由消费者驱动测试覆盖。
  • 替身接口怎么设计稳定?答:按业务能力定义接口,不暴露第三方 SDK 细节。

06.8.4.2-024 Clean Architecture 下 DI 怎么组织?

一句话结论

DI 作为最外层装配机制:领域用例与实体不感知容器,适配器实现接口并在装配层绑定;依赖方向指向核心,容器只在边界组装。

概念解释

Clean Architecture 分层:核心(实体/用例)→ 接口端口 → 适配器(DB、HTTP、外部客户端)。核心层不引入 DI 框架注解,端口接口在核心定义,适配器实现并由装配模块绑定。DI 是外层把适配器接到端口上的手段。

原理流程

  1. 核心定义端口接口与用例。
  2. 适配器实现端口。
  3. 装配模块绑定接口到适配器。
  4. 用例通过构造接收端口。

代码或图示

核心:OrderUseCase(val repo: OrderRepositoryPort)
适配器:JdbcOrderRepository : OrderRepositoryPort
装配:single<OrderRepositoryPort> { JdbcOrderRepository(get()) }

常见误区

  • 核心层引入容器注解/框架类型,依赖方向倒置。
  • 适配器接口泄漏进核心,反向绑定具体实现。

追问

  • 端口接口放哪一层?答:核心层定义,适配器实现;命名表达业务能力。
  • DI 模块算哪一层?答:外层装配,不属于核心业务逻辑。

06.8.4.2-025 为什么领域层不应感知 DI 框架?

一句话结论

领域层是纯业务规则,引入框架注解/容器 API 会把核心逻辑绑定到特定 DI 方案,降低可测试性与可迁移性;依赖通过构造函数接收接口即可。

概念解释

领域类不需要知道对象由谁创建,只声明需要的接口。框架相关代码留在装配层。这样核心可在无容器环境单测,框架更换不影响业务规则。注解处理器生成代码若渗入核心,迁移成本上升。

原理流程

  1. 领域类构造函数接收端口接口。
  2. 不引用容器类型与注解。
  3. 装配层选择实现传入。
  4. 核心单测直接构造。

代码或图示

// 核心:无框架引用
class PlaceOrderUseCase(val repo: OrderRepositoryPort)

常见误区

  • 核心类加 DI 注解,框架升级牵动业务代码。
  • 领域模型继承框架基类,被持久层/容器绑定。

追问

  • 配置对象能进核心吗?答:纯数据配置可传值,不引用框架配置 API。
  • 怎么检查核心层干净?答:架构守护测试扫描核心包不依赖容器类型。

06.8.4.2-026 模块间依赖方向怎么用 DI 保证?

一句话结论

高层模块定义端口,低层模块实现端口,装配层绑定;DI 注入方向与代码依赖方向一致,禁止低层反向依赖高层实现。

概念解释

依赖倒置:高层不依赖低层细节,双方依赖抽象。DI 装配把低层实现接到高层端口。Gradle 模块依赖与 DI 绑定方向一致。评审检查 import 方向,反向依赖视为违规。

原理流程

  1. 高层定义端口接口。
  2. 低层实现端口。
  3. 装配模块绑定。
  4. 守护测试校验方向。

代码或图示

order-core(端口/用例)← order-persistence(实现)← app(装配)

常见误区

  • 低层直接 import 高层 DTO/服务,方向倒置。
  • 装配层跨模块 new 低层实现,绕过端口抽象。

追问

  • 共享 DTO 放哪?答:公共契约模块,双方依赖;避免高层模型被低层引用。
  • 架构守护怎么做?答:ArchUnit 一类规则扫描包依赖,见 06.8.5.3。

06.8.4.2-027 反模式:服务定位器是什么,问题在哪?

一句话结论

服务定位器是组件主动从容器查找依赖,而非构造接收;它隐藏依赖关系、削弱可测试性,使组件与容器耦合。

概念解释

DI 容器作为全局定位器,业务代码内调用 get() 取依赖。依赖不出现在构造参数,单测无法显式传参。组件对容器有全局感知。框架边界处使用定位可接受,业务类应构造注入。

原理流程

  1. 组件持有容器引用。
  2. 方法内 get() 取依赖。
  3. 依赖关系不可见。
  4. 测试必须起容器或 mock 定位器。

代码或图示

// 反模式
class OrderService {
    val repo: OrderRepository get() = koin.get()
}

常见误区

  • 图方便在组件内随时 get,积累成定位器泛滥。
  • 认为用了 DI 框架就不是定位器,关键看组件是否主动查找。

追问

  • 服务定位器完全不能用吗?答:框架插件/边界桥接处可用,业务核心禁止。
  • 怎么重构?答:依赖移入构造参数,装配点传入。

06.8.4.2-028 反模式:在构造函数里做业务/重活有什么问题?

一句话结论

构造函数应只做赋值与轻量校验,重 IO、复杂计算、线程启动留在构造里会导致首次解析阻塞、难以测试且生命周期失控。

概念解释

构造时机由容器控制,构造内做外部连接、批量加载、启动线程,放大解析延迟并隐藏副作用。单测构造对象时被迫承受重活。资源初始化应显式方法或由生命周期钩子管理。

原理流程

  1. 构造函数接收依赖并保存。
  2. 轻量校验入参。
  3. 重资源在初始化方法/钩子建立。
  4. 关闭钩子释放。

代码或图示

class OrderService(val repo: OrderRepository) {
    fun start() { /* 显式初始化外部资源 */ }
}

常见误区

  • 构造函数里连数据库、起线程,容器解析时阻塞。
  • 构造副作用无法在单测中隔离。

追问

  • 构造参数校验算重活吗?答:纯数据校验可在构造内做,IO 与计算移出。
  • 资源初始化时机谁控制?答:容器生命周期钩子或应用启动流程显式编排。

06.8.4.2-029 反模式:对象图过深怎么识别和治理?

一句话结论

对象图过深表现为一个用例串联多层包装、构造链长且每层只转发;治理靠合并内聚职责、明确用例编排层,缩短调用链。

概念解释

过度分层导致 service→manager→helper→repository 层层透传,依赖链深、跳转多、测试困难。DI 容器能装配深图,但不代表深图合理。评审看用例实际经过几层,合并无行为差异的中间层。

原理流程

  1. 梳理用例调用链。
  2. 识别只转发不决策的中间层。
  3. 合并职责内聚的类。
  4. 保留有独立变更理由的层。

代码或图示

反模式:Controller → Service → Manager → Helper → Repository
合理:Controller → UseCase → Repository

常见误区

  • 为分层而分层,每层薄到只剩转发。
  • 深图靠 DI 自动串起,无人审视职责。

追问

  • 怎么判断中间层是否有存在理由?答:是否独立变更、独立测试、承担明确职责。
  • 分层与过深的界限?答:按业务能力划分,不按技术层级机械堆叠。

06.8.4.2-030 反模式:God Component(上帝组件)是什么?

一句话结论

God Component 承担过多职责、依赖大量其他 bean,成为系统中心;应按业务能力拆分,DI 装配随之分解。

概念解释

一个 service 注入十几个 repository/客户端,方法覆盖多个业务域。它难以测试、变更影响面大。DI 只是把它装配起来,不解决职责膨胀。拆分后用例编排协调多个细粒度组件。

原理流程

  1. 统计组件依赖数量与方法覆盖面。
  2. 按业务域拆分多个组件。
  3. 应用服务编排协作。
  4. DI 模块按拆分后结构组织。

代码或图示

反模式:OrderGodService(repo1, repo2, client1, client2, ...)
拆分:OrderQueryService / OrderCommandService / PaymentService

常见误区

  • 新需求继续往中心类加方法,职责持续膨胀。
  • 拆分后仍由上帝组件转发,只是换包装。

追问

  • 依赖多少算过多?答:无固定阈值,看是否跨业务域、方法是否内聚。
  • 拆分后事务边界怎么办?答:应用用例层编排跨聚合操作,见 06.8.5.3。

06.8.4.2-031 反模式:到处持有容器引用有什么风险?

一句话结论

组件随处持有容器/全局 Koin 引用,导致依赖隐式、测试困难、生命周期耦合;应只在装配边界访问容器,业务组件接收构造依赖。

概念解释

容器引用渗入业务类后,类可在任意位置取任意 bean,依赖图失去约束。测试需要 mock 整个容器。更换 DI 框架时业务类全部受影响。评审扫描容器类型字段与导入。

原理流程

  1. 识别组件内容器类型引用。
  2. 依赖改为构造参数。
  3. 容器引用集中到启动/装配层。
  4. 守护测试拦截业务包容器导入。

代码或图示

// 反模式:class OrderService(val koin: Koin)
// 推荐:class OrderService(val repo: OrderRepository)

常见误区

  • 方便调试留全局容器引用,遗留到生产代码。
  • 工具类静态持有容器,全局扩散。

追问

  • 框架强制回调里需要取 bean 怎么办?答:边界适配类持有容器,向内层传依赖。
  • 怎么扫描违规?答:架构规则检查业务包不 import 容器类型。

06.8.4.2-032 DI 与 AOT/GraalVM 有哪些冲突点?

一句话结论

AOT/原生镜像要求反射、动态代理、类加载在编译期可枚举;运行时反射型 DI、动态生成代理、类路径扫描会与 GraalVM 冲突,需要元数据登记或改用编译期方案。

概念解释

GraalVM 原生镜像编译期分析可达代码,运行时反射调用的类需注册反射配置。DI 框架若靠反射注入字段、动态代理增强、扫描类路径,原生镜像下可能找不到类或代理。Koin DSL 显式装配反射较少,但 bean 内部库仍需检查。

原理流程

  1. 盘点 DI 机制:反射/代理/扫描使用情况。
  2. 原生镜像构建生成可达性元数据。
  3. 登记反射类、动态代理配置。
  4. 运行期验证无类加载告警。

代码或图示

AOT 风险:字段反射注入 / 动态代理 / 类路径扫描 / 反射实例化

常见误区

  • 框架自身无反射就认为整个应用兼容 AOT。
  • 忽略第三方库的反射使用。

追问

  • Spring Boot 3 AOT 怎么做?答:启动期处理生成 AOT 元数据,原生镜像构建复用。
  • 编译期 DI 为何友好?答:装配代码编译期固化,无运行时查找与反射。

06.8.4.2-033 GraalVM 下反射元数据怎么登记?

一句话结论

被反射访问的类、方法、字段需在原生镜像配置中登记;可由框架 AOT 处理自动生成,或手动补充 reflect 配置。具体配置格式按 GraalVM 与框架文档确认。

概念解释

原生镜像看不到运行时反射目标,未登记的类在调用时报缺类。DI 字段注入、序列化、第三方 ORM 都可能触发反射。登记前先在原生镜像运行时收集告警,逐项补全。

原理流程

  1. 原生镜像启动运行,记录反射缺失告警。
  2. 补充反射/代理元数据配置。
  3. 重新构建镜像验证。
  4. 随依赖升级回归配置。

代码或图示

收集告警 → 登记类/方法/字段 → 重建镜像 → 回归运行

常见误区

  • 只在 JVM 模式测试通过就交付原生镜像。
  • 反射配置随版本升级过期未维护。

追问

  • 怎么减少反射依赖?答:优先构造注入、编译期绑定,减少字段反射。
  • 框架能自动生成配置吗?答:Spring AOT 等框架提供生成能力;Koin 方案需自行验证(待确认)。

06.8.4.2-034 编译期 DI 为什么对 AOT 更友好?

一句话结论

编译期 DI 生成显式装配代码,依赖关系在构建期固化,无需运行时反射查找与动态代理,原生镜像可达性分析更容易覆盖。

概念解释

生成代码直接调用构造函数,编译器可追踪引用链。容器元数据、反射注入、运行时扫描都不需要。代价是注解处理器构建链与生成代码。对 GraalVM 要求高的场景,编译期方案减少 AOT 登记工作量。

原理流程

  1. 处理器生成装配代码。
  2. 构造调用链编译期可见。
  3. 原生镜像按生成代码分析可达性。
  4. 运行时无反射查找。

代码或图示

编译期生成:new Service(repo) —— 显式调用,可静态分析

常见误区

  • 以为编译期 DI 的 bean 内部代码就没有反射:bean 自身依赖仍需检查。
  • 为 AOT 强行换框架,忽略团队成本。

追问

  • Koin DSL 在 AOT 下风险点?答:容器注册表为运行时代码,bean 构造显式;需实测原生镜像行为(待确认)。
  • AOT 不是必须时怎么选?答:常规 JVM 部署按生态与团队选择,不提前优化。

06.8.4.2-035 配置类与 DI 框架怎么避免耦合?

一句话结论

配置先组装为框架无关的类型安全对象,再作为普通依赖注入;DI 框架只负责传递配置对象,不在业务类里读取框架专有配置 API。

概念解释

配置来源(环境变量、配置文件、Secret)在启动边界读取并校验,生成纯 Kotlin 配置 data class。bean 注入配置对象。更换 DI 框架或配置中心不影响业务类。配置读取与校验细节见 06.8.5.2。

原理流程

  1. 启动边界读取原始配置。
  2. 校验并组装配置对象。
  3. 注册配置对象到容器。
  4. bean 注入配置对象使用。

代码或图示

data class AppConfig(val db: DbConfig, val timeout: Duration)

module { single { appConfig } }

常见误区

  • bean 直接调用框架配置 API 取值,业务类绑定框架。
  • 配置散装属性散落各 definition,校验重复。

追问

  • 配置对象需要接口抽象吗?答:通常 data class 足够;多来源适配可抽配置读取接口。
  • 敏感配置怎么进对象?答:Secret 注入,对象内存持有,日志脱敏。

06.8.4.2-036 dev/test/prod 环境的实现怎么装配?

一句话结论

公共定义共享,环境差异通过独立模块覆盖实现或按配置选择;生产模块不包含测试替身,环境选择在启动装配层完成。

概念解释

各环境外部依赖不同:测试用替身/容器,生产用真实客户端。装配层按环境装载对应模块。配置对象区分环境参数。避免在业务 bean 内判断环境分支。环境配置与 profile 细节见 06.8.5.2。

原理流程

  1. 公共模块定义接口与业务逻辑。
  2. 环境模块提供实现绑定。
  3. 启动按环境选择模块集合。
  4. 配置对象注入环境参数。

代码或图示

val modules = commonModule + when (env) {
    "prod" -> prodModule
    else -> devModule
}

常见误区

  • 测试替身模块被打进生产装配路径。
  • 环境判断散落在各 bean 构造逻辑。

追问

  • 同一份代码多环境部署怎么做?答:镜像统一,环境差异由配置与模块选择在启动时决定。
  • 环境模块怎么测试?答:各环境装配分别有集成用例验证。

06.8.4.2-037 条件装配在不同方案下怎么实现?

一句话结论

Spring 有成熟条件注解;Koin 核心倾向装配层选择模块,条件能力有限;手动 DI 在组装点 if/else。条件决策集中在装配层,不进业务类。

概念解释

条件装配按开关/环境选择实现。Spring @ConditionalOn* 注解体系完善;Koin 按版本能力评估条件定义,通用做法是启动时选模块。手动 DI 在根组装点分支。条件规则需要可审计、可测试。

原理流程

  1. 读取开关/环境。
  2. 装配层选择模块或实现。
  3. 业务 bean 不感知条件。
  4. 未启用实现不注册。

代码或图示

if (feature.exportEnabled) {
    loadKoinModules(exportModule)
}

常见误区

  • 在 definition lambda 内读全局开关切换实现。
  • 条件分支无测试覆盖,默认行为出错。

追问

  • 条件注册能力怎么核实?答:查 Koin 4.x DSL 是否提供 conditional 定义(待确认)。
  • 开关默认值怎么定?答:安全默认值,显式开启可选能力。

06.8.4.2-038 依赖版本与 bean 生命周期怎么对齐?

一句话结论

长生命周期 bean 依赖的资源必须比它活得更久;短生命周期对象不能被 single 长期持有。装配时核对依赖链的生命周期层级。

概念解释

single 持有 scoped/factory 实例会把短对象变相延长寿命。外部客户端、连接池的关闭时机要晚于使用方。生命周期错配是内存泄漏与关闭报错的常见来源。装配评审检查依赖方向上的寿命层级。

原理流程

  1. 列出各 bean 生命周期层级:容器级 > 作用域级 > 临时。
  2. 检查长寿命 bean 不持有短寿命可变状态。
  3. 资源释放按依赖反向。
  4. 关闭钩子覆盖外部资源。

代码或图示

single 可依赖 single;scoped 可依赖 single;single 不应缓存 scoped 实例

常见误区

  • single 缓存请求级对象,跨请求串状态。
  • 先关闭被依赖的客户端,使用方释放时报错。

追问

  • 怎么发现寿命错配?答:堆分析残留实例 + 作用域监控 + 代码评审依赖类型。
  • 工厂实例被 single 字段缓存怎么办?答:改为 single 定义或明确缓存意图。

06.8.4.2-039 DI 模块拆分怎么配合 Gradle 模块化?

一句话结论

Gradle 模块边界即 DI 装配边界:每个代码模块导出自己的 Koin module,应用模块聚合;模块间只依赖公开接口,装配不跨模块引用实现类。

概念解释

代码模块与 DI 模块对应,避免装配集中在 app 模块穿透各层实现。公共组件入基础模块。Gradle 依赖方向与 DI 绑定方向一致。模块化构建与包规则见 06.8.5.3。

原理流程

  1. Gradle 模块按业务/基础划分。
  2. 模块内定义自身 Koin module。
  3. app 模块 includes 各业务模块。
  4. 跨模块只解析接口类型。

代码或图示

:app → :user-module → :common
user-module 导出 userModule;common 导出 commonModule

常见误区

  • app 模块引用各层实现类手动装配,模块封装失效。
  • 基础模块反向依赖业务模块。

追问

  • 模块间共享配置对象放哪?答:common 模块提供配置,各业务模块注入。
  • 怎么检查模块边界?答:Gradle 依赖分析 + 架构守护测试。

06.8.4.2-040 端口与适配器怎么通过 DI 注入?

一句话结论

核心定义端口接口,适配器实现接口,装配模块把接口绑定到适配器;业务用例只依赖端口,更换适配器不改核心代码。

概念解释

端口是核心对外能力声明,适配器是技术实现(数据库、外部 API、消息)。DI 绑定发生在最外层。适配器可被替身替换做测试。接口命名表达业务能力,不暴露技术细节。

原理流程

  1. 核心定义 OrderRepositoryPort。
  2. 适配器 JdbcOrderRepository 实现端口。
  3. 模块绑定 single<OrderRepositoryPort> { JdbcOrderRepository(get()) }。
  4. 用例注入端口。

代码或图示

class PlaceOrderUseCase(val repo: OrderRepositoryPort)

module {
    single<OrderRepositoryPort> { JdbcOrderRepository(get()) }
}

常见误区

  • 端口接口命名带技术前缀(Jdbc/Http),泄漏实现细节。
  • 核心直接依赖适配器类型,端口抽象落空。

追问

  • 入站端口与出站端口区别?答:入站是驱动核心的用例接口,出站是核心依赖的外部能力接口。
  • 适配器需要多个实现吗?答:按环境/渠道提供,装配层选择。

06.8.4.2-041 DI 装配图怎么可视化和评审?

一句话结论

从容器导出 definition 清单与依赖关系,按模块/类型分组评审;重点检查方向、生命周期、多实现与循环。图形作为评审辅助,代码与测试为准。

概念解释

运行时 DI 的装配图不显式体现在编译产物,需要工具导出。评审关注:依赖是否指向接口、生命周期是否合理、有无循环与定位器。清单纳入 MR 检查项。复杂图可用工具生成依赖关系图。

原理流程

  1. 导出容器 definition 与依赖。
  2. 按模块分组审查方向。
  3. 检查循环、定位器、寿命错配。
  4. 问题记录整改。

代码或图示

评审视图:模块 → definition → 依赖类型 → 生命周期/qualifier

常见误区

  • 只在问题出现时翻代码,平时不维护装配图认知。
  • 图形过期后仍作为评审依据。

追问

  • 工具能自动生成依赖图吗?答:按容器 API 遍历定义生成(方法名待确认);静态分析补充包依赖。
  • 评审看什么粒度?答:模块间方向优先,模块内生命周期与多实现其次。

06.8.4.2-042 怎么发现未使用或冗余的 bean?

一句话结论

结合代码引用分析与容器解析记录,找注册了但无解析路径的 definition;冗余 bean 增加启动与维护成本,定期清理。

概念解释

未使用 bean 可能来自历史遗留、注释掉的功能。静态分析查找类型引用,运行时记录解析类型辅助判断。注意集合注入、反射/配置加载的间接引用,避免误删。

原理流程

  1. 列出全部 definition。
  2. 静态搜索类型/接口引用点。
  3. 运行期核对实际解析类型。
  4. 确认无引用后删除定义。

代码或图示

definition 清单 → 引用搜索 → 运行解析记录 → 确认冗余 → 移除

常见误区

  • 只看静态引用,漏掉集合注入或动态解析。
  • 删除仍被配置/插件使用的 bean。

追问

  • 死代码分析工具有限制吗?答:DI 动态解析超出静态工具能力,需运行记录补充。
  • 冗余 bean 有什么实际危害?答:占注册内存、增加误解与维护成本;重型冗余 bean 还拖慢启动。

06.8.4.2-043 启动失败怎么系统化定位?

一句话结论

按异常类型分类(缺失/歧义/循环/构造失败/资源不可达),沿 cause 链定位根因 definition,核对模块装载、绑定与配置;启动失败记录完整上下文后中止。

概念解释

启动阶段暴露的 DI 问题集中在解析图与外部资源。缺失查模块与绑定,歧义查多实现,循环查依赖链,构造失败查内部资源。日志保留模块与类型信息。修复后重跑启动校验。

原理流程

  1. 读取异常类型与 cause 链。
  2. 分类缺失/歧义/循环/构造。
  3. 核对对应 definition 与模块装载。
  4. 修复后校验复跑。

代码或图示

启动失败 → 异常分类 → cause 链根因 → 模块/绑定/配置核对 → 修复复跑

常见误区

  • 反复重启猜测,不分析异常根因。
  • 忽略配置非法导致的构造失败。

追问

  • 启动失败要重试吗?答:瞬时外部问题可由编排层重启;配置/装配缺陷必须修复代码。
  • 怎么让启动错误更易读?答:definition 命名清晰,异常带模块与类型上下文。

06.8.4.2-044 单例预热与懒加载怎么权衡?

一句话结论

核心链路重型 bean 预热缩短首请求延迟,非关键 bean 懒加载控制启动时间;预热清单按核心链路确定,预热失败阻断启动。

概念解释

预热是启动期主动解析,懒加载是首次使用构造。权衡启动时间与首请求响应。预热 bean 的外部连接纳入启动健康检查。非关键、偶发使用的 bean 不预热。

原理流程

  1. 梳理核心链路依赖。
  2. 启动后主动解析核心 bean。
  3. 记录初始化耗时。
  4. 其余 bean 首次解析构造。

代码或图示

预热:数据源 / 核心客户端 / 核心 service
懒加载:后台任务、偶发工具组件

常见误区

  • 全部单例预热,启动时间失控。
  • 预热失败被吞,首请求才暴露。

追问

  • 预热和懒加载能按配置切换吗?答:按环境调整预热清单,启动参数控制。
  • 预热顺序重要吗?答:按依赖链构造,容器自动递归;外部资源初始化按依赖编排。

06.8.4.2-045 作用域与单例的内存泄漏怎么排查?

一句话结论

排查活动作用域数不下降、single 持有大对象引用、factory 被长期缓存;用堆分析看残留实例引用链,对照生命周期设计整改。

概念解释

泄漏形态:作用域只创不闭、长生命周期 bean 持有短生命周期对象、闭包捕获大对象。容器不清理使用方持有的引用。监控活动作用域与 bean 实例数,堆 dump 定位引用链。

原理流程

  1. 监控作用域创建/关闭差值与实例数。
  2. 堆 dump 找残留大对象。
  3. 向上追引用链到持有方。
  4. 修正生命周期或解除引用。

代码或图示

泄漏链:长寿命 bean → 短生命周期实例 → 大对象

常见误区

  • 以为容器会自动回收所有 bean。
  • 只关注 single,忽略作用域堆积。

追问

  • 怎么测作用域释放?答:用例创建关闭后断言钩子调用、实例可回收。
  • 单例缓存集合无限增长怎么办?答:加容量上限与过期策略,不放在无界 single 集合。

06.8.4.2-046 并发下单例初始化要注意什么?

一句话结论

容器保证单例构造的并发安全,但实例内部状态需自己做并发控制;构造 lambda 内不依赖外部可变线程状态。

概念解释

多线程同时首次解析同一 single,容器避免重复构造(机制待确认)。实例方法共享调用,可变字段需要同步或设计为无状态。构造慢会阻塞并发首次访问线程。

原理流程

  1. 并发请求解析同一 single。
  2. 容器同步首次构造。
  3. 完成后共享实例。
  4. 实例内部并发访问由实现保证。

代码或图示

// 无状态优先;必须有状态则加同步/并发集合
single { CounterService() }

常见误区

  • 把容器初始化安全当成实例线程安全。
  • 构造 lambda 内启动线程且未登记关闭。

追问

  • 单例可变状态怎么设计?答:优先不可变;需要计数用原子类型/锁。
  • 重复构造现象怎么查?答:断言实例引用相等,检查是否误注册为 factory。

06.8.4.2-047 测试里真实组件与替身组件怎么搭配?

一句话结论

单元测试用替身隔离外部依赖,集成测试用真实组件连测试基础设施;按测试目标选择,不为追求覆盖率把外部系统全 mock 掉。

概念解释

单测快而隔离,替身覆盖规则分支;集成测真实装配与连通,用 Testcontainers 起外部依赖。边界:业务规则用替身验证,SQL/协议/连通用真实组件。全 mock 的集成测试价值有限。

原理流程

  1. 单测:mock 端口,验证用例规则。
  2. 集成测:真实 bean 装配,外部依赖走容器化测试环境。
  3. 契约测:客户端接口替身。
  4. 各层测试目标明确。

代码或图示

单测:fake/mock 端口
集成测:真实 repository + Testcontainers DB

常见误区

  • 集成测试也全 mock,没验证真实装配。
  • 单测连真实数据库,用例慢且不稳定。

追问

  • 测试替身比例怎么定?答:看测试类型,不是固定数字;外部不可控依赖必须替身。
  • 替身与真实行为不一致怎么办?答:契约测试约束替身行为。

06.8.4.2-048 集成测试启动容器的策略是什么?

一句话结论

集成测试装载真实模块,外部依赖用 Testcontainers 提供;容器在测试套件级复用加速,用例间数据隔离。DI 装配与生产一致,只替换外部基础设施连接。

概念解释

集成测试验证 bean 真实装配与 SQL/协议行为。DI 模块与生产相同,数据源指向测试容器。容器复用降低启动成本,数据按用例清理或回滚。测试分层细节见 06.8.5.3。

原理流程

  1. 启动测试外部依赖容器。
  2. 装载生产模块,配置指向测试环境。
  3. 执行用例。
  4. 清理数据/销毁容器。

代码或图示

startKoin { modules(prodModuleWithTestDb) }

常见误区

  • 集成测试用 H2 替目标数据库,方言差异漏测。
  • 容器每用例重建,测试耗时过长。

追问

  • 怎么平衡速度与真实度?答:核心路径目标数据库容器,边缘用例内存替身。
  • 测试容器与生产版本对齐?答:镜像版本跟随生产数据库版本。

06.8.4.2-049 契约测试框架与 DI 怎么配合?

一句话结论

外部客户端接口注入替身或契约桩,契约框架按约定记录/校验交互;DI 只负责把桩接入业务,契约规则由测试框架管理。

概念解释

契约测试关注请求/响应约定,不关心容器内部。客户端接口在 DI 中可替换为桩。消费者驱动契约由桩模拟提供方响应,验证本服务解析正确。

原理流程

  1. 客户端接口在生产绑定真实实现。
  2. 测试绑定契约桩。
  3. 执行业务用例。
  4. 桩记录请求并按契约返回。

代码或图示

val stub = PaymentContractStub()
module { single<PaymentClient> { stub } }

常见误区

  • 契约桩自行编造响应,与真实提供方契约脱节。
  • 契约测试绕过 DI 直接调桩,未验证装配接入。

追问

  • 提供方契约变更谁同步?答:消费者驱动契约测试捕获不兼容变更。
  • 契约测试放哪个测试层?答:独立契约测试套件,与单元/集成测试并列。

06.8.4.2-050 异常边界与 DI 注入有什么关系?

一句话结论

DI 不管业务异常分类,组件抛出的异常类型由领域/边界层定义;注入的端口接口应声明可能的异常类型,装配不改变异常语义。

概念解释

依赖注入解决对象装配,不负责错误处理。业务异常在核心层定义,适配器翻译底层异常。测试替身按接口约定抛对应异常。异常边界设计见 06.8.5.3。

原理流程

  1. 端口接口声明异常约定。
  2. 实现抛领域异常或翻译底层异常。
  3. 边界层统一错误响应。
  4. 替身模拟异常分支。

代码或图示

interface OrderRepositoryPort {
    fun findById(id: Long): Order?
    // 不暴露底层 SQL 异常类型
}

常见误区

  • 端口接口泄漏底层异常类型,核心被技术实现绑定。
  • 替身不模拟异常分支,错误路径未测试。

追问

  • Result 类型与异常哪个好?答:按团队约定,见下一题;DI 不参与选择。
  • 异常翻译在哪层做?答:适配器出口翻译为领域异常。

06.8.4.2-051 Result 类型在层间传递与 DI 有关系吗?

一句话结论

没有直接关系:Result/密封类是层间返回值模式,DI 是装配机制;端口接口返回 Result 或抛异常由架构约定,注入方式不变。

概念解释

用例可以返回 Result<T> 显式表达失败,也可以抛领域异常。两种方式都与 DI 无关。接口签名决定测试替身如何模拟结果。团队统一一种错误传播风格。

原理流程

  1. 端口约定返回值风格(Result 或异常)。
  2. 实现遵循签名。
  3. 替身按约定返回成功/失败。
  4. 边界层转换对外响应。

代码或图示

sealed interface Result<out T> {
    data class Success<T>(val value: T) : Result<T>
    data class Failure(val error: DomainError) : Result<Nothing>
}

常见误区

  • 层间混用 Result 与异常,错误处理路径不一致。
  • 把 DI 容器异常与业务 Result 混在一层。

追问

  • Result 适合 Kotlin 服务端吗?答:可替代部分受检异常场景;风格按团队约定。
  • 异常信息怎么跨层传递?答:领域错误码/消息在核心定义,适配器不新增业务语义。

06.8.4.2-052 架构评审怎么检查 DI 依赖方向?

一句话结论

评审检查:核心不依赖框架、高层不依赖低层实现、跨模块只依赖接口、无容器引用渗入业务包;用架构守护测试固化规则。

概念解释

DI 方向是架构方向的体现。评审看构造参数类型、import 方向、模块引用。守护测试自动扫描违规包依赖。人工评审补充语义合理性(职责、生命周期)。

原理流程

  1. 检查构造参数是否为接口。
  2. 扫描业务包容器类型导入。
  3. 核对模块依赖方向。
  4. 守护测试纳入 CI。

代码或图示

规则:核心包不 import 容器/适配器类型;低层不 import 高层实现

常见误区

  • 评审只看功能实现,忽略依赖方向。
  • 规则只写文档,无自动化检查。

追问

  • 架构守护测试用什么工具?答:ArchUnit 一类 JVM 规则库;Kotlin 项目可结合包扫描断言,见 06.8.5.3。
  • 发现反向依赖怎么整改?答:抽端口接口,适配器实现,装配层绑定。

06.8.4.2-053 公共组件与业务模块的 bean 怎么命名归类?

一句话结论

公共基础设施 bean 放基础模块并按技术能力命名,业务 bean 放业务模块按业务概念命名;跨模块解析只认接口,命名不暴露归属模块。

概念解释

公共客户端、配置、工具组件归入 common 模块。业务 service/repository 归入对应功能模块。类型名表达职责,模块归属由包与装配文件体现。避免业务 bean 散落在公共模块。

原理流程

  1. 识别组件是否跨功能复用。
  2. 复用组件入公共模块。
  3. 业务专属组件入功能模块。
  4. 接口名稳定,实现名带技术/渠道。

代码或图示

common:HttpClient、Clock、配置
user 模块:UserService、UserRepository

常见误区

  • 公共模块堆满业务特例,被多个模块反向依赖。
  • 业务 bean 通用化命名,归属不清。

追问

  • 组件被两个业务模块共用怎么办?答:下沉公共模块,接口保持中立。
  • 命名冲突怎么处理?答:按模块包隔离,类型名带业务前缀。

06.8.4.2-054 配置校验失败为什么应该在启动时暴露?

一句话结论

必填配置缺失、格式非法在启动组装配置对象时校验失败并中止,避免首次业务调用才报错;配置对象不可变,bean 拿到即合法值。

概念解释

延迟到使用时校验,错误暴露晚且影响部分请求。启动校验把配置问题前移到部署阶段。校验包括必填、范围、枚举合法、外部地址格式。校验失败的具体异常由配置模块定义。

原理流程

  1. 读取原始属性。
  2. 校验必填与范围。
  3. 组装配置对象,非法即抛启动异常。
  4. 合法对象注册容器。

代码或图示

data class DbConfig(val poolSize: Int) {
    init { require(poolSize in 1..100) { "poolSize invalid" } }
}

常见误区

  • bean 内延迟转换属性,格式错误在请求时报错。
  • 配置校验散落各组件,口径不一。

追问

  • 可选配置默认值怎么定?答:明确安全默认值,必填项不静默兜底。
  • 配置校验与健康检查区别?答:启动校验静态配置,健康检查动态连通。

06.8.4.2-055 外部客户端纳入容器生命周期要注意什么?

一句话结论

客户端注册为 single,构造读取配置,登记关闭回调释放连接/线程池;业务依赖客户端接口,测试可替换。多客户端按 qualifier 区分。

概念解释

HTTP/RPC/MQ 客户端持有重资源,生命周期跟随容器。不登记关闭会在停机时泄漏。客户端内部线程池、连接数配置从配置对象读取。包装自身接口便于测试与更换实现。

原理流程

  1. 注册客户端 single。
  2. 构造建立资源。
  3. 关闭钩子释放。
  4. 业务解析接口使用。

代码或图示

single { PaymentHttpClient(config.payment) }

常见误区

  • 业务类各自 new 客户端,实例与线程池多份。
  • 客户端未登记关闭,停机泄漏线程。

追问

  • 客户端需要预热连通吗?答:关键客户端纳入启动自检,见 06.8.5.3。
  • 客户端超时配置在哪?答:配置对象集中管理,不硬编码在客户端内部。

06.8.4.2-056 资源关闭顺序与 DI 有什么关系?

一句话结论

bean 依赖方向即关闭反向:上层先释放,底层资源后关闭;DI 容器按注册/依赖关系执行回调,关键资源在应用层显式编排兜底。

概念解释

使用方先停,被依赖资源后释放。容器关闭回调顺序保证程度按实现确认(待确认)。外部线程池、连接池的关闭要等待在途任务完成。关闭回调容错,单点失败不阻断其余释放。

原理流程

  1. 停止入口与后台调度。
  2. 上层 bean 关闭回调。
  3. 客户端/连接池后释放。
  4. 记录未释放资源告警。

代码或图示

关闭:Service → Repository → Client → Pool

常见误区

  • 基础资源先关,上层释放时引用已关闭对象。
  • 回调抛异常中断后续清理。

追问

  • 关闭顺序不确定怎么办?答:应用启动/停机流程显式编排关键资源,不只依赖容器回调。
  • 关闭超时怎么处理?答:设置超时上限,强制退出并告警。

06.8.4.2-057 插件化架构怎么与模块加载配合?

一句话结论

插件实现公共扩展接口,各插件模块注册定义;主服务集合注入扩展点,按配置决定装载哪些插件。插件模块可独立编译,应用根模块按需 includes。

概念解释

插件化依赖显式注册,不靠类路径扫描。扩展接口定义在公共模块,插件模块提供实现。插件失败隔离不影响主流程。插件启停钩子纳入生命周期管理。

原理流程

  1. 公共模块定义扩展接口。
  2. 插件模块注册实现。
  3. 根模块按配置 includes 插件。
  4. 主服务集合注入遍历。

代码或图示

interface Plugin { fun start(); fun stop() }
// 插件模块:single<Plugin> { OrderPlugin() }

常见误区

  • 期待自动扫描发现插件,漏注册。
  • 插件初始化失败阻断核心启动。

追问

  • 插件能运行时装卸吗?答:Koin 模块可卸载/加载(能力待确认);常规插件随启动装配。
  • 插件配置隔离?答:每插件独立配置对象注入。

06.8.4.2-058 服务端无状态设计与 single 选择有什么关系?

一句话结论

无状态服务的协作组件注册 single 复用;任何请求专属状态放请求作用域或参数,不放进 single 字段。

概念解释

无状态设计要求组件不保存跨请求数据。single 复用实例,可变字段会跨请求共享。无状态 service/repository 适合 single;请求上下文、用户标识走 scoped 或参数传递。

原理流程

  1. 识别组件是否持有请求数据。
  2. 无状态组件注册 single。
  3. 请求数据作用域化或参数化。
  4. 多副本部署无内存状态依赖。

代码或图示

// 无状态:可 single
class OrderQueryService(val repo: OrderRepository)
// 请求数据:方法参数或 scoped
fun detail(id: Long, currentUser: User)

常见误区

  • single 里放可变请求字段,并发串扰。
  • 把会话状态存内存 single,多副本不一致。

追问

  • 有状态组件怎么处理?答:明确作用域(请求/会话),状态外置到缓存/库。
  • 无状态怎么验证?答:代码评审字段设计 + 并发测试。

06.8.4.2-059 有状态组件怎么选择生命周期?

一句话结论

按状态存活时间选择:应用级缓存/连接池用 single,请求级上下文用 scoped,临时计算对象用 factory;有状态 single 必须处理并发。

概念解释

生命周期选择本质是状态复用范围。状态跨请求复用 → single;状态属单次请求 → scoped;状态用完即弃 → factory。选错导致串扰或资源浪费。有状态 bean 的并发访问要同步。

原理流程

  1. 梳理组件状态存活范围。
  2. 按范围匹配 definition 语义。
  3. 有状态 single 加并发控制。
  4. 评审实例缓存层级。

代码或图示

应用级:single
请求级:scoped
临时:factory

常见误区

  • 请求状态注册 single,并发串扰。
  • 无状态对象注册 scoped,徒增作用域管理成本。

追问

  • 缓存对象算有状态吗?答:是,状态为缓存数据,注意失效与并发。
  • 状态能放对象字段吗?答:按生命周期设计,跨请求状态外置存储。

06.8.4.2-060 DI 依赖冲突怎么排查?

一句话结论

冲突表现为解析到错误实现、重复定义或类型不匹配;核对模块装载顺序、覆盖规则、qualifier 与绑定类型,用定义清单与解析断言定位。

概念解释

依赖冲突来源:同类型多实现未区分、模块重复装载、覆盖顺序意外、接口绑定遗漏。排查从解析结果反查 definition 来源。测试断言实现类型防止静默错误。

原理流程

  1. 确认解析得到的实际类型。
  2. 导出 definition 清单找同类型多条。
  3. 核对模块装载与覆盖规则。
  4. 修正 qualifier/绑定/重复装载。

代码或图示

错误实现 → definition 清单 → 重复/覆盖/qualifier → 修正

常见误区

  • 以为后加载一定覆盖,行为随顺序漂移。
  • 接口多实现不加 qualifier,解析歧义。

追问

  • 怎么在 CI 拦截冲突?答:校验模块 + 实现类型断言测试。
  • 冲突与循环依赖区别?答:冲突是多候选/错候选,循环是构造链成环。

06.8.4.2-061 Koin 版本升级迁移要注意什么?

一句话结论

按 changelog 升级依赖版本,编译修复 API 改名,跑模块校验与集成测试;4.x 相对 3.x 的 breaking changes 逐项核对(待确认清单)。

概念解释

大版本可能调整模块坐标、作用域 API、注解集成。升级在分支进行,先编译适配再跑测试。运行时行为差异(缓存、覆盖规则)用测试复核。不跨多个大版本直接跳。

原理流程

  1. 阅读 changelog 与迁移指南。
  2. 升级依赖版本。
  3. 编译修复不兼容 API。
  4. 校验 + 集成测试回归。

代码或图示

changelog → 依赖升级 → 编译适配 → checkModules → 集成测试 → 灰度

常见误区

  • 只升版本不跑测试,运行期 API 错误残留。
  • 依赖中混入 3.x 与 4.x 模块。

追问

  • 升级后行为变了怎么排查?答:对比解析清单与实例身份断言,复核覆盖规则。
  • 不确定 API 行为标什么?答:待确认 + 最小验证用例。

06.8.4.2-062 从 Dagger 迁移到 Koin 是什么场景?

一句话结论

通常发生在转向 KMP 跨端、简化构建链或团队降低注解处理器成本;迁移把生成组件改为 DSL 定义,核心业务代码保持构造注入不变。

概念解释

构造注入的业务类在两种方案间可复用,变化的是装配层。迁移先抽离装配模块,再把 Dagger 模块改写为 Koin module,移除注解处理器。分步迁移,保留测试保护。

原理流程

  1. 确认业务类已是构造注入。
  2. Dagger 模块逐个改写 Koin 定义。
  3. 移除注解与处理器配置。
  4. 测试回归装配图。

代码或图示

// Dagger 模块 → Koin module
module { single<UserRepository> { JdbcUserRepository(get()) } }

常见误区

  • 业务类耦合 Dagger 注解,迁移要先清理。
  • 迁移期两套装配并存,定义重复。

追问

  • 迁移动机充分吗?答:KMP/简化构建是主要理由;单纯个人偏好不构成迁移理由。
  • 怎么降低迁移风险?答:按模块灰度,每步测试通过。

06.8.4.2-063 Spring 应用里内嵌 Koin 有必要吗?

一句话结论

通常没有必要:Spring 项目保留 Spring DI 保持一致;内嵌第二套容器只会带来双生命周期与装配割裂。仅在特殊跨端共享代码场景评估,且边界清晰隔离。

概念解释

两套容器互不可见,bean 跨容器传递需手动桥接。Spring 生态的自动装配、AOP、生命周期由 Spring 管理。引入 Koin 增加理解成本而无明显收益。Kotlin 服务端若选 Spring,DI 跟随 Spring。

原理流程

  1. 确认主框架与容器。
  2. 装配全部走主容器。
  3. 跨体系对象在边界手动传递。
  4. 评审禁止新增第二套容器。

代码或图示

Spring Boot:Spring 容器
Ktor:Koin 容器
不并行装配业务 bean

常见误区

  • 局部代码习惯 Koin 写法,在 Spring 项目另起容器。
  • 跨容器对象生命周期不一致,代理/事务失效。

追问

  • 共享库代码怎么复用?答:核心库框架无关,两套容器各自适配装配。
  • Spring 事务代理失效场景?答:对象不经 Spring 容器管理时,AOP 代理不生效。

06.8.4.2-064 框架无关核心层有什么长期价值?

一句话结论

核心业务规则不绑定 DI 框架、Web 框架与数据访问技术,框架更换、测试与移植成本最低;DI 作为外层适配可整体替换。

概念解释

框架无关意味着核心类不引用容器注解、Web 注解、ORM 基类。更换 Web 框架或 DI 方案时,用例与实体规则保留。库代码尤其要保持中立。架构投入在前期,长期降低演进成本。

原理流程

  1. 核心只依赖自身抽象与标准库。
  2. 端口接口在核心定义。
  3. 框架相关实现放外层适配器。
  4. 装配层连接核心与适配器。

代码或图示

核心:纯 Kotlin 业务规则
外层:Web / DI / DB / 客户端适配器

常见误区

  • 核心类继承 ORM 实体基类或 Web 请求对象。
  • 核心 import 框架类型,迁移时大面积改动。

追问

  • 怎么验证核心无关?答:核心模块编译不依赖框架 artifact;守护测试扫描导入。
  • 过度抽象的代价?答:简单服务不必强行分层,按规模演进。

06.8.4.2-065 不启动容器的单元测试怎么写?

一句话结论

直接构造被测类并传入 mock/fake 依赖,断言业务行为;不调用容器 API,用例快且隔离。

概念解释

构造注入使单测可绕过容器。测试按用例创建依赖替身,组装被测对象。涉及端口接口的替身手写或 mock 框架生成。容器装配由集成测试覆盖。

原理流程

  1. 创建依赖替身。
  2. 直接构造被测类。
  3. 执行业务方法。
  4. 断言结果与交互。

代码或图示

@Test
fun `register rejects duplicate`() {
    val repo = FakeRepository()
    val service = UserService(repo, encoder)
    // 断言
}

常见误区

  • 单测也启动 Koin 容器,用例慢且耦合装配。
  • mock 掉被测类自身规则,测试无断言价值。

追问

  • 依赖很多怎么构造?答:测试工厂集中创建替身,避免用例内重复组装。
  • 哪些必须集成测试?答:真实 SQL、协议、装配连通。

06.8.4.2-066 纯函数与 DI 是什么关系?

一句话结论

纯函数无依赖、无副作用,不需要 DI;有外部依赖或状态的组件才纳入容器。不要为了对称把纯工具函数注册成 bean。

概念解释

纯函数输入决定输出,可直接调用测试。DI 解决外部协作对象的装配。工具函数放伴生对象/工具类,服务组件才注册。把纯函数包成 single 增加容器负担而无收益。

原理流程

  1. 判断组件是否有外部依赖/状态。
  2. 纯逻辑用函数/object。
  3. 有依赖的服务注册容器。
  4. 评审区分两者。

代码或图示

object AmountCalculator { fun tax(amount: Int) = amount * 0.1 } // 纯函数

module { single { InvoiceService(get()) } } // 有依赖

常见误区

  • 所有类都注册 bean,容器膨胀。
  • 纯函数挂状态后不再纯,仍当无状态使用。

追问

  • 纯函数需要配置吗?答:需要配置则改为接收参数的函数或注入配置对象。
  • 纯函数好测吗?答:最易测,参数化用例覆盖边界。

06.8.4.2-067 工厂模式与 DI 怎么协作?

一句话结论

需要运行时按参数创建不同对象时,工厂组件注入容器或接收依赖,封装创建逻辑;DI 管理工厂本身,对象创建策略由工厂决定。

概念解释

简单依赖直接构造注入;创建逻辑复杂、按条件选实现、需要传运行时参数时引入工厂。工厂可注册为 bean,内部用 factory definition 或直接构造。业务面向产品接口,不直接选择实现类。

原理流程

  1. 定义产品接口。
  2. 工厂 bean 封装选择/创建逻辑。
  3. 业务注入工厂。
  4. 运行时调工厂方法取产品。

代码或图示

class GatewayFactory(private val koin: Koin) {
    fun get(channel: String): PaymentGateway = koin.get(named(channel))
}

常见误区

  • 工厂内部又形成定位器泛滥。
  • 简单对象也包工厂,层级多余。

追问

  • 工厂需要容器引用吗?答:可注入预构造的实现映射,避免工厂直接持有容器。
  • 工厂产品生命周期?答:按产品 definition 语义,工厂只负责选择。

06.8.4.2-068 策略模式多实现怎么通过 DI 注入?

一句话结论

策略实现注册为同接口多定义(带 qualifier 或集合绑定),策略解析器按标识选择;新增策略只加实现与配置,不改选择主干。

概念解释

策略模式与多实现注入天然匹配。单选按 qualifier/配置取实现;多选集合注入遍历。策略标识与实现映射集中在装配或解析器。业务代码不 new 策略类。

原理流程

  1. 策略接口定义。
  2. 各策略实现注册定义。
  3. 解析器按标识选实现。
  4. 执行策略行为。

代码或图示

interface DiscountStrategy { fun apply(amount: Int): Int }

module {
    single<DiscountStrategy>(named("vip")) { VipDiscount() }
    single<DiscountStrategy>(named("normal")) { NormalDiscount() }
}

常见误区

  • 选择逻辑散落各调用点。
  • 策略实现无注册约定,新增遗漏。

追问

  • 策略集合怎么按优先级排序?答:实现声明优先级字段,解析器排序。
  • 策略配置参数怎么注入?答:各策略构造接收自身配置对象。

06.8.4.2-069 装饰器链在 DI 里怎么装配?

一句话结论

装饰器 definition 接收被包装接口实例,逐层包装;装配顺序明确哪层在外,解析接口得到装饰后链。横切关注点(日志、监控、重试)用装饰器叠加。

概念解释

装饰器在不修改主实现的情况下加行为。DI 中装饰器注入接口类型,注意不要同类型递归绑定。多层装饰顺序在模块中写清。装饰器自身也可带配置。

原理流程

  1. 主实现注册接口。
  2. 外层装饰器注入接口包装。
  3. 解析接口得到最外层。
  4. 调用沿链执行。

代码或图示

module {
    single<Service> { MetricsService(LoggingService(RealService())) }
}

常见误区

  • 装饰器与被装饰同类型 definition 递归解析。
  • 装饰顺序与预期相反,日志/监控层级错乱。

追问

  • 装饰器链怎么测试?答:逐层解包断言类型,或分别测试各装饰行为。
  • 与拦截器/ AOP 怎么选?答:简单横切用装饰器,框架切面能力按技术栈选择。

06.8.4.2-070 拦截器/过滤器怎么注册进容器?

一句话结论

拦截器作为组件注册,依赖所需服务;执行链由框架装配或主服务编排。拦截器面向接口/处理器抽象,不直接持有业务容器。

概念解释

请求拦截器做认证、日志、监控等横切逻辑。注入业务服务或客户端完成检查。多个拦截器顺序在装配/配置层定义。拦截器本身纳入容器生命周期与测试替换。

原理流程

  1. 定义拦截器接口。
  2. 拦截器 bean 注入依赖服务。
  3. 框架按顺序挂载拦截器链。
  4. 测试替身验证拦截行为。

代码或图示

class AuthInterceptor(val authService: AuthService) : Interceptor

常见误区

  • 拦截器内写业务规则,职责越界。
  • 拦截器顺序硬编码在多处,难以调整。

追问

  • 拦截器依赖请求上下文?答:上下文从调用入参取,不存拦截器字段。
  • 拦截器链与装饰器区别?答:拦截器面向请求流程编排,装饰器包裹组件实例。

06.8.4.2-071 事件总线与后台任务组件的生命周期怎么管理?

一句话结论

事件总线、调度器、消费者注册为应用级 single,持有自己的协程作用域/线程池,并在容器关闭时停止;请求数据不进入这些长生命周期组件的状态。

概念解释

后台组件跨请求存活,状态设计为无状态或外置存储。事件订阅者随容器注册,关闭时取消订阅与任务。组件内部协程作用域纳入关闭回调。后台任务与部署停机配合,见 06.8.5.3。

原理流程

  1. 后台组件注册 single。
  2. 启动时注册订阅/调度任务。
  3. 运行期处理事件。
  4. 关闭时取消任务、释放订阅。

代码或图示

single { EventBus(applicationScope) }

常见误区

  • 后台组件持有请求级数据快照长期引用。
  • 不取消协程/线程,停机时任务泄漏。

追问

  • 事件总线需要 DI 管理吗?答:需要,便于测试替换与统一关闭。
  • 订阅者注册顺序有影响吗?答:按事件语义约定顺序,关键事件链路单独测试。

06.8.4.2-072 DI 配置怎么做到可审计?

一句话结论

装配关系通过模块文件、definition 命名与评审记录可追溯;多实现选择、覆盖规则、条件开关有文档说明,变更走代码评审。

概念解释

可审计意味着能回答「哪个 bean 由谁提供、为什么选这个实现」。模块文件注释、qualifier 命名、配置项说明支撑审计。测试断言实现类型作为可执行记录。不在运行时隐藏装配决策。

原理流程

  1. 模块文件记录职责与依赖。
  2. 多实现选择规则写入注释/配置说明。
  3. 装配变更纳入 MR 评审。
  4. 测试断言关键绑定。

代码或图示

审计问题:谁提供 PaymentGateway?→ 模块文件 + qualifier + 配置项 + 测试断言

常见误区

  • 装配决策只在作者脑中,新人无法追溯。
  • 覆盖实现无注释,为什么替换不明确。

追问

  • 审计需要运行时导出清单吗?答:可作为发布检查产物,辅助核对。
  • 配置开关变更要记录吗?答:开关与默认值在配置文档中说明。

06.8.4.2-073 各 DI 方案的新人上手成本怎么比较?

一句话结论

手动 DI 最直观,Koin DSL 轻量易读,Spring 概念体系庞大,Dagger 注解处理器与生成代码需要学习;成本不仅是 API,还包括排查思路与生态约定。

概念解释

上手成本:理解装配模型、报错排查、工具链。Koin 概念少但运行时问题要靠日志定位;Spring 功能多但概念重;Dagger 要理解生成代码与作用域。团队既有经验权重很大。

原理流程

  1. 评估新人背景与团队栈。
  2. 对比概念数量与排查路径。
  3. 考虑构建链与文档成熟度。
  4. 选型包含培训成本。

代码或图示

上手成本:手动 < Koin < Dagger ≈ Spring(概念体系维度)

常见误区

  • 只看 Hello World 难度,忽略排障与维护成本。
  • 引入团队不熟悉的方案,长期产出受限。

追问

  • 文档与示例成熟度重要吗?答:重要,Spring/Koin 文档较全,小众方案需自证可行。
  • 怎么降低上手成本?答:模板模块 + 评审清单 + 示例用例。

06.8.4.2-074 团队为什么要规范构造注入优先?

一句话结论

构造注入让依赖显式、不可变、便于测试,避免字段注入的隐藏依赖与容器耦合;团队规范统一注入方式,评审有据可依。

概念解释

构造注入在构造参数列出全部必需依赖,对象构造完成即可用。字段注入允许对象先创建再补依赖,中间状态不可用。规范优先构造注入,字段注入仅在框架强制场景使用。

原理流程

  1. 新类依赖写入构造参数。
  2. 必需依赖不使用可空字段注入。
  3. 评审检查字段注入。
  4. 例外场景记录说明。

代码或图示

// 规范:构造注入
class UserService(val repo: UserRepository, val encoder: PasswordEncoder)

常见误区

  • 构造参数过多(上帝组件)却归因于构造注入。
  • 为方便测试改字段注入,依赖更隐蔽。

追问

  • 循环依赖逼出字段注入怎么办?答:重构职责切断环,而不是换注入方式。
  • 可选依赖怎么注入?答:构造参数可空或提供默认实现,不用字段后补。

06.8.4.2-075 接口默认实现与 fallback 怎么设计?

一句话结论

可选能力提供默认实现注册主路径,特殊实现按配置/ qualifier 替换;缺失可选依赖时主流程走默认行为,而不是报错中断。

概念解释

扩展点场景需要兜底:未注册专用实现时使用内置默认。默认实现与专用实现同接口绑定,选择规则在装配层。fallback 行为要明确记录并测试。默认实现不做敏感操作。

原理流程

  1. 接口定义能力契约。
  2. 默认实现注册为兜底。
  3. 专用实现按配置覆盖/选择。
  4. 未提供专用实现时走默认。

代码或图示

single<Exporter> { NoopExporter() } // 默认兜底
// 启用导出模块时覆盖为 CsvExporter

常见误区

  • 默认实现静默吞掉错误,问题不可见。
  • 覆盖规则不清,实际生效实现不明。

追问

  • 默认实现需要配置开关吗?答:按场景,无操作兜底可默认启用。
  • 多个 fallback 怎么排序?答:明确优先级链,避免歧义。

06.8.4.2-076 测试替身的命名与模块有什么约定?

一句话结论

替身类按「Fake/Mock + 接口名」命名,集中在测试模块或测试源集;生产代码不引用替身。替身行为与接口契约一致,命名区分 fake(状态可控)与 mock(交互断言)。

概念解释

测试源集隔离替身,不进入生产装配。命名让评审一眼识别测试用途。手写 fake 实现接口维护状态;mock 由框架生成。替身模块覆盖生产绑定,用例结束重置。

原理流程

  1. 测试源集创建替身类。
  2. 命名前缀区分 fake/mock。
  3. 测试模块绑定替身到接口。
  4. 生产代码不依赖测试源集。

代码或图示

class FakeUserRepository : UserRepositoryPort
val repo = mockk<UserRepositoryPort>()

常见误区

  • 替身类放生产源码包,被误打包。
  • fake 与 mock 混用命名,测试意图不清。

追问

  • 替身需要实现全部接口方法吗?答:未用方法可抛未实现断言,避免静默空行为。
  • 共享替身放哪?答:测试公共源集,多测试套件复用。

06.8.4.2-077 容器重复初始化会导致什么问题?

一句话结论

重复启动容器会重建注册表与单例,旧实例被丢弃;全局引用错乱、状态串扰。应保证应用生命周期内容器初始化一次,测试每次独立重置。

概念解释

全局容器被二次 startKoin,旧 single 不再被新容器管理,持有旧引用的组件行为不一致。正常应用启动路径只初始化一次。测试中重复初始化需先关闭旧容器。

原理流程

  1. 启动路径只调用一次容器初始化。
  2. 测试用例间关闭旧容器再新建。
  3. 检查全局引用是否指向当前容器。
  4. 避免静态初始化重复触发。

代码或图示

生产:单次 startKoin
测试:@BeforeEach 启动 / @AfterEach 关闭

常见误区

  • 插件与主流程各自启动容器,出现两套实例。
  • 重复初始化未关闭旧容器,资源泄漏。

追问

  • 怎么检测重复初始化?答:启动日志与容器实例计数,重复告警。
  • 多模块各自初始化?答:根模块统一装载,子模块只提供定义。

06.8.4.2-078 多部署单元为什么需要独立容器?

一句话结论

每个进程/部署单元独立持有容器,bean 实例不跨进程共享;容器内单例只是进程内单例,跨副本一致性依赖外部存储。

概念解释

多副本部署时各进程独立装配。容器状态不复制到其他副本。需要共享的数据(会话、缓存、配置)走外部存储。定时任务等全局协调不靠容器单例。

原理流程

  1. 每进程启动独立容器。
  2. 进程内 single 复用。
  3. 跨副本共享数据走 DB/Redis。
  4. 全局任务由分布式协调选主。

代码或图示

副本 A 容器 ←→ 共享存储 ←→ 副本 B 容器

常见误区

  • 把进程内单例当全局共享状态。
  • 多副本定时任务重复执行,缺分布式协调。

追问

  • 容器能跨进程共享吗?答:不能,容器是进程内组件。
  • 配置怎么多副本一致?答:配置中心/环境变量统一注入。

06.8.4.2-079 DI 怎么落地依赖倒置原则(DIP)?

一句话结论

高层定义抽象端口,低层实现端口,DI 把低层实现注入高层;高层不依赖低层细节,两者都依赖抽象。

概念解释

DIP 要求抽象不依赖细节,细节依赖抽象。DI 是组装手段:高层构造接收端口,装配层接实现。代码依赖方向与控制方向反转。评审检查高层 import 是否出现低层具体类。

原理流程

  1. 高层用例定义端口接口。
  2. 低层模块实现端口。
  3. 装配层绑定。
  4. 高层只引用端口。

代码或图示

// 高层
class PlaceOrderUseCase(val repo: OrderRepositoryPort)
// 低层
class JdbcOrderRepository : OrderRepositoryPort

常见误区

  • 高层直接 new 低层实现,倒置落空。
  • 端口接口放在低层包,方向仍倒置。

追问

  • DIP 与 DI 是一回事吗?答:原则与实现手段的关系。
  • 怎么验证倒置落地?答:守护扫描高层包不依赖低层实现包。

06.8.4.2-080 「依赖抽象不依赖细节」在 Kotlin 代码里怎么体现?

一句话结论

构造参数与变量类型使用接口/抽象类,实现类只在装配模块出现;业务代码不引用实现类名与技术细节。

概念解释

类型声明面向接口,替换实现不改业务代码。实现类名带技术前缀(Jdbc/Http)只在绑定处出现。数据传输模型与领域模型分离,避免暴露持久细节。

原理流程

  1. 定义接口表达能力。
  2. 业务代码声明接口类型。
  3. 装配模块绑定实现。
  4. 更换实现只改绑定。

代码或图示

// 业务代码
val service: PaymentGateway = get()
// 装配
single<PaymentGateway> { AlipayGateway() }

常见误区

  • 字段类型写实现类,接口抽象失效。
  • 接口返回实现特定类型,细节泄漏。

追问

  • 接口会不会过度设计?答:有替换/测试需求才抽象,简单内部类可直接类型。
  • 抽象层怎么命名?答:按业务能力,不带技术实现词。

06.8.4.2-081 框架迁移时 DI 层的成本取决于什么?

一句话结论

成本取决于业务类与原 DI 框架的耦合程度:构造注入、核心无关的项目只需替换装配层;注解/容器引用渗入业务类则迁移面大。

概念解释

迁移 DI 方案要改:模块定义、注解、容器 API 调用、生命周期钩子。业务类若是纯构造注入,改动集中在装配文件。核心层无关框架时可独立保留。迁移前统计框架耦合点。

原理流程

  1. 扫描框架注解与容器类型引用。
  2. 业务类先清理为构造注入。
  3. 装配层逐模块迁移。
  4. 测试回归装配图。

代码或图示

耦合低:只改装配模块
耦合高:业务类注解/容器引用逐层清理

常见误区

  • 直接换框架不清理旧耦合,两套引用并存。
  • 低估业务类框架渗透面。

追问

  • 怎么降低未来迁移成本?答:核心层框架无关,DI 集中在外层。
  • 迁移要换 Web 框架吗?答:DI 迁移可独立于 Web 框架,按风险分步。

06.8.4.2-082 为什么不全部用静态工厂替代 DI 框架?

一句话结论

静态工厂能封装创建逻辑,但无法替代接口替换、生命周期管理、多实现选择与测试隔离;项目规模增长后工厂之间的依赖组装仍需要容器。

概念解释

静态工厂集中创建对象,但依赖关系硬编码在工厂内,测试替换要改工厂。生命周期、作用域、资源释放需自行实现。DI 框架把这些通用能力自动化。小型脚本可用静态工厂,服务端不推荐全静态化。

原理流程

  1. 静态工厂封装单类创建。
  2. 跨对象图组装仍需手工串联。
  3. 替换实现要改工厂代码。
  4. 规模扩大后装配逻辑重复维护。

代码或图示

object ServiceFactory {
    fun userService() = UserService(JdbcUserRepository())
}

常见误区

  • 工厂内 new 具体实现,无法测试替换。
  • 静态工厂持有全局状态,并发难控。

追问

  • 工厂与 DI 矛盾吗?答:不矛盾,复杂创建策略用工厂 bean,DI 管理工厂。
  • 库代码适合静态工厂吗?答:库优先构造注入,由使用方组装。

06.8.4.2-083 服务定位器与构造注入的本质区别是什么?

一句话结论

构造注入把依赖作为契约显式列出,组件不知道容器存在;服务定位器让组件主动向容器索取依赖,依赖隐式且组件耦合容器。

概念解释

依赖方向相反:构造注入是外部推入,定位器是内部拉出。构造注入可单测传参,定位器测试要 mock 容器。两者都可能用到容器 API,但使用位置决定模式性质。

原理流程

  1. 构造注入:构造参数声明依赖。
  2. 定位器:组件内部调用容器 get。
  3. 对比可测试性与依赖可见性。
  4. 业务类优先构造注入。

代码或图示

// 构造注入
class OrderService(val repo: OrderRepository)
// 定位器
class OrderService { fun repo() = koin.get<OrderRepository>() }

常见误区

  • 认为只要用了容器就是 DI,不区分注入方向。
  • 定位器残留少量代码未重构。

追问

  • 定位器有没有合理场景?答:框架回调、插件边界等无法构造注入的位置。
  • 怎么扫描定位器?答:检查业务包内容器类型字段与 get 调用。

06.8.4.2-084 容器感知组件有哪些弊端?

一句话结论

组件持有容器引用后,依赖隐式、测试困难、生命周期与容器绑定、难以脱离框架复用;弊端随组件在核心层出现而放大。

概念解释

容器感知组件可在任意位置取任意 bean,依赖图失去约束。单测需要准备容器,类不可独立复用。框架更换时所有感知组件受影响。边界适配类可感知,业务核心不可感知。

原理流程

  1. 识别组件内容器引用。
  2. 依赖改为构造参数。
  3. 容器引用上移到装配边界。
  4. 守护测试拦截核心包容器导入。

代码或图示

弊端:依赖隐式 / 测试困难 / 框架耦合 / 生命周期失控

常见误区

  • 为调试方便留下容器引用,遗留生产。
  • 工具类静态持有全局容器。

追问

  • 框架要求组件拿到容器怎么办?答:适配层包装,向内层传依赖。
  • 容器感知与插件化冲突吗?答:插件边界可感知,业务插件内部仍构造注入。

06.8.4.2-085 全局单例与环境隔离怎么处理?

一句话结论

进程内全局单例不跨环境隔离;多环境(多租户/多配置)不能靠单例字段区分,环境数据外置或按作用域隔离。

概念解释

single 是进程级复用,dev/test/prod 是不同进程,天然隔离。同一进程内多租户/多配置场景,不能把环境差异存 single 字段。租户标识随请求传递,资源按作用域或外部存储区分。

原理流程

  1. 区分进程级环境与进程内上下文。
  2. 进程间靠部署隔离。
  3. 进程内上下文随请求传递。
  4. 共享资源按 key 隔离。

代码或图示

进程:单例复用
请求/租户:参数或作用域隔离

常见误区

  • single 字段存当前租户/用户,并发串扰。
  • 测试复用全局单例,环境配置残留。

追问

  • 多租户数据源怎么管?答:按租户路由数据源,不属于单例字段状态。
  • 测试环境隔离怎么做?答:独立容器/进程,配置独立注入。

06.8.4.2-086 数据层依赖业务层的方向为什么是错的?

一句话结论

依赖方向应是业务层依赖数据层抽象,数据层实现业务端口;数据层反向引用业务模型/服务会导致分层倒置,技术细节与业务规则纠缠。

概念解释

Repository 实现业务定义的端口,返回领域模型。数据层不调用业务 service,不感知 Web DTO。反向依赖让数据访问无法独立复用与替换。DI 绑定方向与代码 import 方向一致。

原理流程

  1. 业务层定义端口。
  2. 数据层实现端口并返回领域模型。
  3. 装配层绑定。
  4. 数据层不 import 业务服务。

代码或图示

业务 → 端口 ← 数据层实现
禁止:数据层 → 业务 service

常见误区

  • Repository 返回 Web DTO,方向泄漏。
  • 数据层调用业务规则,规则重复实现。

追问

  • 数据层需要业务枚举吗?答:可用核心定义的枚举,不反向依赖业务服务。
  • 方向违规怎么整改?答:抽端口,模型下移核心。

06.8.4.2-087 Web 层为什么只做编排?

一句话结论

Controller/路由只负责请求解析、调用用例、组装响应;业务规则在 Service/用例层,数据存取在 Repository。Web 层不写业务判断与直接 SQL。

概念解释

分层职责清晰:Web 适配协议,业务层承载规则,数据层存取。Controller 注入用例接口,不注入 Repository 拼装规则。这样 Web 框架可替换,业务规则可独立测试。

原理流程

  1. Web 层解析请求参数与认证。
  2. 调用用例服务。
  3. 把结果转 DTO 响应。
  4. 业务判断不在 Web 层。

代码或图示

routing {
    post("/orders") {
        val dto = placeOrderUseCase.handle(req.toCommand())
        call.respond(dto)
    }
}

常见误区

  • Controller 直接调 Repository 拼业务规则。
  • Web 模型与领域模型混用。

追问

  • 权限校验放哪层?答:Web 边界做认证鉴权,业务规则校验在业务层。
  • 编排与业务规则界限?答:组织调用顺序是编排,判断业务对错是规则。

06.8.4.2-088 领域服务怎么装配?

一句话结论

领域/用例服务注入端口接口,注册为 single(无状态);它不持有 Web 请求对象,输入来自命令/参数,输出领域模型或 Result。

概念解释

领域服务承载业务规则,依赖仓库端口与领域服务。无状态设计适合 single。请求上下文(用户、trace)以参数传入。装配模块按功能注册用例与其依赖端口。

原理流程

  1. 用例类构造接收端口。
  2. 模块注册用例 single。
  3. Web 层调用用例。
  4. 用例不感知框架与请求对象。

代码或图示

class PlaceOrderUseCase(
    private val orderRepo: OrderRepositoryPort,
    private val stockService: StockService
)

常见误区

  • 领域服务注入 Web 请求对象,耦合框架。
  • 用例内直接访问数据访问实现类。

追问

  • 领域服务需要接口吗?答:被多个适配器调用或需替身时抽接口;内部用例可具体类。
  • 多聚合协作谁编排?答:应用服务/用例层协调多个领域服务。

06.8.4.2-089 Testcontainers 与 DI 外部依赖替身怎么配合?

一句话结论

集成测试用 Testcontainers 起真实外部服务,DI 配置指向容器地址;单元测试用替身。容器化依赖按测试层选择,不混为一谈。

概念解释

Testcontainers 提供目标版本的数据库/中间件容器,Repository 真实连容器验证 SQL 与协议。DI 模块在测试环境绑定连接配置。单测仍用 fake/mock 隔离。测试分层整体见 06.8.5.3。

原理流程

  1. 测试启动 Testcontainers 服务。
  2. 测试配置注入容器地址。
  3. 装载生产模块连接容器。
  4. 执行集成用例。

代码或图示

// 测试配置:数据源指向 Testcontainers JDBC URL
module { single { DataSource(testcontainersUrl) } }

常见误区

  • 用内存库替代目标数据库,方言差异漏测。
  • 集成测试仍 mock 数据层,未验证真实存取。

追问

  • 容器复用怎么加速?答:套件级容器复用,用例间清数据。
  • Testcontainers 版本基线?答:1.x,具体坐标待确认。

06.8.4.2-090 配置驱动的实现选择怎么落地?

一句话结论

配置项声明渠道/策略标识,装配层把标识映射到 qualifier 或模块选择;启动校验标识合法,业务代码不读配置分支选实现。

概念解释

配置驱动让同一镜像按环境切换实现。映射关系集中在装配层,配置值与已注册定义对照校验。非法配置启动失败。新增渠道补充实现与配置枚举。

原理流程

  1. 配置读取渠道标识。
  2. 装配层映射 qualifier/模块。
  3. 校验标识对应已注册实现。
  4. 业务接收选定接口。

代码或图示

val gateway: PaymentGateway = when (config.channel) {
    "alipay" -> get(named("alipay"))
    else -> get(named("default"))
}

常见误区

  • 业务代码读配置字符串分支 new 实现。
  • 配置标识无校验,运行时解析失败。

追问

  • 配置热切换实现可行吗?答:模块运行时重载能力有限(待确认),通常重启生效。
  • 映射表放哪?答:装配层集中维护,可测。

06.8.4.2-091 安全敏感组件的注入怎么审计?

一句话结论

认证、授权、加密、密钥访问等组件登记注册与使用点,评审确认最小权限;敏感配置不进日志,组件接口限制暴露面。

概念解释

安全相关 bean 纳入装配审计:谁注入了编码器、谁能访问密钥客户端。权限检查组件在边界与业务层的位置明确。测试替身不泄露真实密钥。注入关系可追溯到模块文件。

原理流程

  1. 列出安全敏感组件清单。
  2. 审查注入点与权限范围。
  3. 确认配置/密钥来源合规。
  4. 日志与响应脱敏。

代码或图示

审计清单:编码器 / 鉴权服务 / 密钥客户端 / 敏感配置访问点

常见误区

  • 加密工具被任意业务类注入,暴露面过大。
  • 测试配置使用真实密钥。

追问

  • 密钥怎么注入组件?答:Secret 环境变量/挂载,不写模块代码。
  • 安全组件替换测试替身?答:测试用替身模拟通过/拒绝分支。

06.8.4.2-092 怎么监控 DI 解析与初始化耗时?

一句话结论

上报 bean 初始化耗时与解析失败计数;解析频次不做全量埋点。启动初始化慢的 bean 进入启动看板,失败纳入错误告警。

概念解释

DI 指标服务启动性能与故障定位。构造阶段计时,区分容器注册与 bean 初始化。运行期解析失败计数告警。具体拦截扩展点按 Koin 能力确认(待确认)。

原理流程

  1. 构造/解析阶段计时。
  2. 上报初始化直方图与失败计数。
  3. 启动看板关联发布版本。
  4. 慢 bean 列入优化清单。

代码或图示

指标:bean.init.latency / bean.resolve.error / koin.startup

常见误区

  • 每次解析打点,标签基数与开销过大。
  • 只监控进程存活,不看 bean 初始化失败。

追问

  • 初始化慢怎么优化?答:拆分重构造、延迟非关键 bean、外部连接预热。
  • 指标标签怎么控制基数?答:按 bean 类型聚合,不带实例 ID。

06.8.4.2-093 线上排障怎么确认 bean 的实际实现?

一句话结论

通过日志解析记录、定义清单或临时诊断端点确认运行时绑定的实现类型;结合配置与模块装载核对预期实现。

概念解释

运行时 DI 不在编译产物固定实现,排障需确认容器实际选择。开发日志可记录解析类型,生产可在诊断端点导出定义与实现。多实现场景核对 qualifier 与配置。

原理流程

  1. 读取解析日志/诊断清单。
  2. 核对类型与 qualifier。
  3. 对照配置与模块装载。
  4. 确认是否解析到错误实现。

代码或图示

排障:实际实现类型 → qualifier/配置 → 模块来源 → 是否符合预期

常见误区

  • 凭代码默认实现猜测,忽略覆盖模块。
  • 多实例部署间实现不一致未发现。

追问

  • 诊断端点要鉴权吗?答:敏感内部端点受限开放,见 Actuator 安全题目。
  • 怎么提前防止错误实现?答:测试断言实现类型 + 启动自检。

06.8.4.2-094 本篇版本基线与适用边界是什么?

一句话结论

基线 Koin 4.x、Dagger 2.x、Spring Boot 3.x、Kotlin 2.x;服务端 Kotlin 场景,Android/Hilt 端侧细节归 07 分册,RPC 契约层不在本篇。

概念解释

对比结论面向服务端选型与工程实践。移动端 Hilt 作用域、ViewModel 集成不在本篇展开。版本敏感能力标注待确认,不编造坐标与行为。各方案官方文档以当前发布为准。

原理流程

  1. 核对基线版本。
  2. 服务端场景组织对比。
  3. 端侧内容引用 07 分册。
  4. 不确定 API 标待确认。

代码或图示

基线:Koin 4.x / Dagger 2.x / Spring Boot 3.x / Kotlin 2.x
边界:服务端;端侧见 07;契约层见 06.8.5.1

常见误区

  • 把移动端 Hilt 概念套到服务端选型。
  • 引用旧版本文档行为当作当前结论。

追问

  • 版本差异怎么说明?答:标注适用版本范围,跨版本行为以 changelog 为准。
  • 其他 DI 方案要不要对比?答:按面试范围补充,结论保持中立有依据。

06.8.4.2-095 待确认:Koin 4 与 Compose Multiplatform 集成的 DI 方式是什么?

一句话结论

Compose Multiplatform 端侧的组件注入、生命周期作用域与 Koin 集成 API 在 4.x 的具体形态需对照官方文档确认(待确认);本篇只记录待核实点,不编造 composable 注入 API。

概念解释

桌面/移动端 Compose 组件有宿主生命周期,DI 作用域与视图模型绑定方式与服务端不同。服务端项目通常不涉及。跨端共享模块的公共定义可复用,端侧集成细节归 07 分册与官方文档。

原理流程

  1. 确认目标 Compose 平台与 Koin 版本。
  2. 查官方集成指南当前 API。
  3. 最小示例验证注入与作用域。
  4. 记录可用 API 与限制。

代码或图示

待确认:Compose Multiplatform 下 Koin 注入函数、作用域绑定 API
验证点:官方文档版本、依赖坐标、最小可运行示例

常见误区

  • 照搬 Android Koin compose 教程到 CMP,API 已调整。
  • 把端侧作用域概念写进服务端结论。

追问

  • 服务端需要关注 CMP 集成吗?答:不需要,除非项目含桌面端。
  • 待确认信息怎么补全?答:查 insert-koin.io 对应平台文档与示例仓库。

06.8.4.2-096 选型题:Ktor + Kotlin 后端为什么常用 Koin?

一句话结论

Ktor 轻量、无强制容器,搭配同样轻量、纯 Kotlin、KMP 友好的 Koin 最自然;两者都不引入重型注解处理,启动快、模块 DSL 直观。

概念解释

技术栈一致性:Ktor 协程与 Kotlin DSL 风格搭配 Koin DSL。Koin 无编译期生成步骤,与 Ktor 插件模型契合。编译期安全弱于 Dagger,靠模块校验与集成测试补偿。团队若已用 Spring 生态则另选 Spring。

原理流程

  1. 服务端框架选 Ktor。
  2. DI 选型匹配轻量与跨端需求。
  3. Koin 模块装配业务组件。
  4. 校验与测试补偿运行时安全。

代码或图示

Ktor 3.x + Koin 4.x:轻量、DSL、KMP 友好

常见误区

  • 为用 Koin 而用,忽略团队 Spring 经验。
  • 以为 Koin 提供编译期校验。

追问

  • Ktor 项目能不用 DI 框架吗?答:小服务可手动构造注入,规模增长再引入 Koin。
  • Koin 短板怎么补?答:checkModules + 集成测试 + 实现类型断言。

06.8.4.2-097 选型题:Spring Boot 项目什么时候保留 Spring DI?

一句话结论

使用 Spring 数据访问、安全、事务、Actuator 等生态时保留 Spring DI;框架能力依赖容器代理与生命周期,另起 DI 容器会破坏这些集成。

概念解释

Spring 的事务、AOP、自动配置都基于容器管理 bean。组件由 Spring 容器创建才能被代理增强。Kotlin 下用构造注入保持简洁。引入 Koin 替代 Spring 容器收益低、风险高。

原理流程

  1. 确认依赖 Spring 生态组件。
  2. bean 由 Spring 容器管理。
  3. 构造注入 Kotlin 风格装配。
  4. 不并行第二套容器。

代码或图示

@Service
class UserService(val repo: UserRepository) // Spring 容器管理

常见误区

  • 只想要 Kotlin 语法却另起容器,丢失 Spring 代理能力。
  • 部分 bean 脱离容器,事务/切面失效。

追问

  • Spring bean 能用字段注入吗?答:建议构造注入,框架同样支持。
  • Spring 与 Koin 桥接可行吗?答:不推荐,边界混乱;核心库框架无关。

06.8.4.2-098 单体演进到模块化时 DI 怎么重构?

一句话结论

先按业务域拆 Gradle 模块,抽取端口接口,DI 模块随代码模块拆分;装配从集中大模块变为各模块提供定义、根模块聚合。

概念解释

单体初期单模块集中装配可接受。模块化时把业务定义移入对应模块,公共组件入基础模块。重构保持构造注入,测试覆盖装配图。拆模块顺序:抽公共 → 分业务 → 根聚合。

原理流程

  1. 梳理业务域边界。
  2. 抽取跨模块端口。
  3. 代码与 DI 定义迁入模块。
  4. 根模块 includes 聚合,守护方向规则。

代码或图示

单体大 module → userModule / orderModule / commonModule → app 聚合

常见误区

  • 只拆代码不拆装配,根模块穿透引用各层实现。
  • 模块边界未抽端口,拆分后仍强耦合。

追问

  • 模块化前要做什么准备?答:核心层框架无关、构造注入到位。
  • 拆分风险怎么控制?答:按域逐步迁移,每步测试回归。

06.8.4.2-099 场景题:设计一个核心层与适配器分离的装配方案

一句话结论

核心定义用例与端口,适配器实现数据/外部客户端,DI 模块分三层:核心用例装配、适配器绑定、根模块聚合;核心不引用任何框架类型。

概念解释

方案要素:端口在核心,实现在外层;配置对象启动组装注入;适配器可替换为替身测试。模块按 Gradle 边界组织,依赖方向指向核心。装配文件只做绑定,不含业务规则。

原理流程

  1. 核心模块:用例 + 端口接口。
  2. 持久/客户端适配器模块:实现端口。
  3. 装配模块:绑定接口到实现。
  4. 根模块聚合启动。

代码或图示

app(装配) → order-core(用例/端口) ← order-persistence(适配器)

常见误区

  • 端口放在适配器模块,方向倒置。
  • 装配模块写业务规则,变成第二层 service。

追问

  • 适配器需要多个实现吗?答:生产/测试分别绑定,测试覆盖模块替换。
  • 配置对象归哪层?答:启动边界组装,传入各层,不进核心框架 API。

06.8.4.2-100 场景题:评审发现循环依赖,整改步骤是什么?

一句话结论

先画依赖链定位环,判断职责可否抽取中介/事件解耦;能用重构消除的消除,必要时用懒加载缓解;整改后跑模块校验与测试,禁止靠字段注入掩盖。

概念解释

整改顺序:识别环上双方职责 → 抽取共享逻辑到第三方 → 或一方改事件通知 → 依赖单向化。构造环不能靠容器缓存机制解决。lazy 只是临时缓解,环仍需评审消除。整改验证装配图无环、行为回归。

原理流程

  1. 构造参数链画出循环。
  2. 分析双方职责重叠与协作方向。
  3. 抽中介/事件,切断回边。
  4. checkModules 与测试回归。

代码或图示

A ↔ B  →  抽 C / 事件通知  →  A → C ← B(单向)

常见误区

  • 改字段注入让环不报错,半成品风险保留。
  • 抽中介类后双方仍互调,环平移未消除。

追问

  • 实在无法消除的双向协作怎么处理?答:引入应用服务编排,两方向应用服务依赖,互不直接注入。
  • 整改后怎么防回归?答:架构测试检测构造依赖环,评审清单保留循环依赖检查。

参考来源

待整理清单

  • [ ] 核对 Koin 4.x 测试替换(loadKoinModules/declareMock)、checkModules、卸载与关闭容器的准确 API
  • [ ] 核实 Spring Boot 3.x 默认对循环依赖(构造/字段注入)的处理策略与配置项
  • [ ] 确认 Koin 在 GraalVM 原生镜像下的反射/代理登记需求与官方支持说明
  • [ ] 整理 Dagger 2.x 在 JVM 服务端与 KMP 各平台的支持矩阵
  • [ ] 待确认:Koin 4 与 Compose Multiplatform 集成的当前 API 与作用域绑定方式
  • [ ] 核实 Koin 内部并发初始化、覆盖规则与集合绑定注入的源码级行为