07.1.1.10.1 Hilt 组件、作用域与测试
所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.1 原生移动开发 / 07.1.1 Android / 07.1.1.10 DI 与模块化
本节要解决的问题
本节深入 Hilt 依赖注入:组件层级与作用域对应、构造注入与模块绑定、限定符、EntryPoint 与生成机制、ViewModel 注入、多模块可见性、测试替换,以及 KSP/kapt、编译期错误排查与启动开销。面试常从“依赖怎么来的”追问到作用域越界、缺失绑定与测试 Fake 替换。版本基线:Hilt 2.5x、AGP 8.x、Kotlin;版本敏感处标「待确认」。
07.1.1.10.1-001 Hilt 是什么?与 Dagger 是什么关系?
一句话结论
Hilt 是 Google 基于 Dagger 为 Android 定制的依赖注入框架,预置 Android 组件容器与作用域约定,编译期生成依赖图代码。
概念解释
Dagger 提供编译期 DI 内核,但 Android 上需要手写组件与生命周期绑定;Hilt 在此之上约定了 Singleton/Activity/Fragment/ViewModel/Service 组件,自动管理容器创建与销毁。Hilt 保留 Dagger 的编译期校验与性能,减少样板配置。
原理流程
@Inject/@Module 声明 → 编译期生成组件与绑定代码
→ 运行期容器按作用域提供实例
代码或图示
@HiltAndroidApp
class App : Application()
常见误区
- 把 Hilt 理解为运行时反射容器,实际核心绑定图在编译期生成。
- 以为 Hilt 替代 Dagger 全部 API,多数 Dagger 注解在 Hilt 中仍可使用。
追问
- Hilt 解决了 Dagger 哪些痛点?答:省去手写 Android 组件、内置作用域、统一入口与测试容器。
- 什么时候仍直接用 Dagger?答:非 Android 模块或需要 Hilt 未覆盖的自定义组件时。
07.1.1.10.1-002 Hilt 的组件层级有哪些?
一句话结论
核心组件包括 SingletonComponent、ActivityComponent、FragmentComponent、ViewModelComponent、ServiceComponent,分别对应应用、Activity、Fragment、ViewModel、Service 生命周期。
概念解释
组件是依赖容器的层级单位:应用级单例挂在 SingletonComponent,页面级对象挂在 Activity/Fragment 组件,ViewModel 级挂在 ViewModelComponent。子组件随宿主创建销毁,能访问父组件绑定;层级对应 Android 组件生命周期,避免页面对象被全局持有。
原理流程
SingletonComponent
├ ActivityComponent
│ ├ FragmentComponent
│ └ ViewModelComponent
└ ServiceComponent
代码或图示
应用容器 → Activity 容器 → Fragment/ViewModel 容器
容器销毁 → 对应作用域对象释放
常见误区
- 组件层级记成平级,不清楚父子访问方向。
- 把页面级对象绑到 Singleton 组件,造成上下文泄漏。
追问
- 组件能否自定义扩展?答:可以定义自定义作用域与组件,但常规业务用内置组件即可。
- 组件与作用域注解如何对应?答:每个组件配套一个作用域注解,见后续条目。
07.1.1.10.1-003 SingletonComponent 对应什么生命周期与作用域?
一句话结论
SingletonComponent 是应用级根容器,对应进程生命周期;@Singleton 绑定在其中全局唯一,随 Application 存活。
概念解释
应用级单例(数据库、API 客户端、配置仓库)绑定到 SingletonComponent,整个进程共享一份。容器在 Application 初始化时创建,进程销毁时释放。标注 @Singleton 的对象不会因 Activity 重建而重新创建,也不应持有 Activity 上下文。
原理流程
Application 启动 → SingletonComponent 创建
→ @Singleton 实例全局唯一 → 进程结束释放
代码或图示
@Singleton
class AppRepository @Inject constructor(
private val api: NoteApi
)
常见误区
- 单例里注入 Activity Context,导致上下文被全局持有泄漏。
- 把只在某页面使用的对象提升为应用单例,内存常驻。
追问
- @Singleton 对象何时初始化?答:首次注入时惰性创建;也可在模块中配置提前提供。
- 进程内有几个 SingletonComponent?答:每个进程各自一个,多进程不共享实例。
07.1.1.10.1-004 ActivityComponent 与 @ActivityScoped 的生命周期?
一句话结论
ActivityComponent 对应单个 Activity 实例,@ActivityScoped 对象在该 Activity 内唯一,随 Activity 销毁释放。
概念解释
Activity 作用域对象在同一 Activity 的多次注入中复用,跨 Activity 各自新建。容器随 Activity 创建、销毁;配置变更(旋转)时是否保留取决于作用域设计,Activity 作用域对象通常不跨重建保留。适合 Activity 级协调器、页面会话对象。
原理流程
Activity 创建 → ActivityComponent
→ @ActivityScoped 实例在本 Activity 复用
→ Activity 销毁 → 容器与对象释放
代码或图示
@ActivityScoped
class SessionCoordinator @Inject constructor(
private val activity: Activity
)
常见误区
- Activity 作用域对象持有长期引用,容器销毁后残留。
- 混淆 Activity 作用域与单例,以为跨页面共享。
追问
- 旋转屏幕后 @ActivityScoped 对象会重建吗?答:Activity 重建会新建组件,对象随重建重新创建;需要跨重建保留用 ViewModel 作用域。
- Activity 容器能访问单例绑定吗?答:能,子组件访问父组件绑定。
07.1.1.10.1-005 FragmentComponent 与 @FragmentScoped 的生命周期?
一句话结论
FragmentComponent 对应单个 Fragment,@FragmentScoped 对象在该 Fragment 内唯一,随 Fragment 视图销毁释放。
概念解释
Fragment 作用域对象服务于单个 Fragment 实例;同一 Fragment 内复用,宿主 Activity 的其他 Fragment 不共享。容器绑定 Fragment 生命周期,视图销毁时释放。注意 Fragment 实例与视图生命周期分离,作用域对象按 Fragment 实例而非视图重建理解。
原理流程
Fragment 附着 → FragmentComponent
→ @FragmentScoped 复用 → Fragment 分离/销毁释放
代码或图示
@FragmentScoped
class ListViewModelAssisted @Inject constructor(
private val dao: NoteDao
)
常见误区
- 把 Fragment 作用域对象当跨 Fragment 共享单例。
- 忽略 Fragment 视图重建,作用域对象持有旧视图引用。
追问
- Fragment 与 ViewModel 作用域如何选?答:跨配置变更保留的状态放 ViewModel 作用域;纯 Fragment 交互协调器用 Fragment 作用域。
- 子 Fragment 能访问父 Fragment 绑定吗?答:通过组件层级与作用域约定,具体可见性按 Hilt 实现(待确认)。
07.1.1.10.1-006 ViewModelComponent 与 @ViewModelScoped 的生命周期?
一句话结论
ViewModelComponent 对应单个 ViewModel,@ViewModelScoped 对象在该 ViewModel 内共享,随 ViewModel 清除(onCleared)释放。
概念解释
ViewModel 作用域解决“多个依赖服务属于同一 ViewModel 会话”的场景:在 ViewModel 注入链中复用同一实例,跨配置变更保留,ViewModel 销毁时释放。它与 @HiltViewModel 配合,绑定 ViewModel 生命周期而非 Activity。
原理流程
ViewModel 创建 → ViewModelComponent
→ @ViewModelScoped 实例在 ViewModel 链中复用
→ onCleared → 释放
代码或图示
@ViewModelScoped
class NoteEditorSession @Inject constructor(
private val dao: NoteDao
)
@HiltViewModel
class EditorViewModel @Inject constructor(
private val session: NoteEditorSession
) : ViewModel()
常见误区
- 用 Activity 作用域对象承载需跨旋转保留的状态,重建后丢失。
- ViewModel 作用域对象持有 View 引用,onCleared 后泄漏。
追问
- @ViewModelScoped 与 @ActivityScoped 区别?答:前者随 ViewModel 清除释放且跨配置保留,后者随 Activity 销毁。
- 一个 ViewModel 组件对应几个 ViewModel?答:每个 ViewModel 实例独立组件。
07.1.1.10.1-007 ServiceComponent 与 @ServiceScoped 的生命周期?
一句话结论
ServiceComponent 对应单个 Service,@ServiceScoped 对象在该 Service 内唯一,随 Service 销毁释放。
概念解释
Service 作用域绑定服务生命周期,适合服务级协调器与连接管理。容器随 Service 创建销毁,不跨服务共享。注意 Service 可能多次 onStartCommand,作用域对象在服务存活期间复用,而非每次启动新建。
原理流程
Service 创建 → ServiceComponent
→ @ServiceScoped 复用 → onDestroy 释放
代码或图示
@ServiceScoped
class DownloadCoordinator @Inject constructor(
private val dao: NoteDao
)
常见误区
- 把 Service 作用域对象当应用单例,多服务不共享。
- 长驻服务中作用域对象持有未释放的资源连接。
追问
- 后台任务注入走哪个作用域?答:Worker 有专门集成;Service 内协调器用 @ServiceScoped。
- Service 容器能访问单例吗?答:能,作为子组件访问父级绑定。
07.1.1.10.1-008 作用域注解与组件如何一一对应?
一句话结论
内置映射固定:@Singleton→SingletonComponent、@ActivityScoped→ActivityComponent、@FragmentScoped→FragmentComponent、@ViewModelScoped→ViewModelComponent、@ServiceScoped→ServiceComponent。
概念解释
作用域注解标记绑定所属容器,组件决定容器层级与生命周期。模块 @InstallIn 指定组件,绑定标注作用域与组件对应;错配会编译报错或对象生命周期不符。新增自定义作用域需配合自定义组件声明。
原理流程
@InstallIn(XxxComponent::class) + @XxxScoped
→ 绑定进入对应容器
代码或图示
@Module
@InstallIn(SingletonComponent::class)
object AppModule {
@Provides @Singleton
fun provideApi(): NoteApi = /* ... */
}
常见误区
- 模块 InstallIn 组件与绑定作用域不匹配,编译期报作用域错误。
- 只标作用域不声明模块安装组件,绑定无处安放。
追问
- 作用域注解必须和组件同名对应吗?答:内置约定如此;自定义作用域通过组件绑定关系建立对应。
- 不标作用域的绑定进哪个组件?答:每次注入新建实例,不保留在任何作用域缓存中。
07.1.1.10.1-009 未加作用域的绑定默认是什么生命周期?
一句话结论
未标注作用域的绑定不被容器缓存,每次注入都新建实例;属于“无作用域”依赖,适合无状态轻量对象。
概念解释
无作用域对象不随容器保留单例,构造参数每次重新解析。有状态、构造昂贵的对象应指定作用域;无作用域默认值避免意外全局共享。注意无作用域不等于每次方法调用新建,而是每次注入点获取时新建。
原理流程
无作用域绑定 → 注入时构造新实例
→ 容器不持有复用引用
代码或图示
class PasswordHasher @Inject constructor() // 无作用域,每次注入新建
常见误区
- 无状态工具类不标作用域却被当作单例复用。
- 有状态对象漏标作用域,每次注入得到不同实例,状态不共享。
追问
- 无作用域对象能注入单例吗?答:能,单例持有一份该实例引用;单例自身仍唯一。
- 如何判断是否需要作用域?答:看对象是否有内部状态、构造成本与共享诉求。
07.1.1.10.1-010 作用域对象何时被创建与销毁?
一句话结论
惰性创建:首次被注入时构造;销毁跟随所属组件生命周期结束,容器释放后作用域实例不再复用。
概念解释
Hilt 默认惰性提供绑定,未使用不创建;组件销毁时其缓存的作用域对象随容器丢弃。单例进程结束释放,Activity/Fragment/ViewModel/Service 作用域随宿主清除。对象内部资源应在对应生命周期回调中释放,DI 不负责关闭资源。
原理流程
首次注入 → 构造并缓存到组件
宿主销毁 → 组件丢弃 → 实例不可复用
代码或图示
@Singleton
class Tracker @Inject constructor() {
fun start() { /* 初始化 */ }
}
常见误区
- 假设单例在 Application.onCreate 就已构造,实际首次注入才创建。
- 作用域对象释放后仍被外部长期引用,形成泄漏。
追问
- 如何提前初始化单例?答:模块中提供或在启动流程显式注入;需权衡启动耗时。
- 容器销毁会调用对象 close 吗?答:不会自动;资源释放走宿主生命周期或显式清理。
07.1.1.10.1-011 一个绑定能否同时标注多个作用域?
一句话结论
不能。一个绑定只属于一个作用域;标注多个作用域会产生作用域冲突,编译期报错。
概念解释
作用域决定对象在哪个容器复用,多重作用域语义矛盾:既想 Activity 级又想单例级。需要不同生命周期的实例时,应拆成两个绑定或用限定符区分。组件层级也不允许一个对象同时挂在父子两个缓存中。
原理流程
一个绑定 → 单一作用域
多作用域标注 → 编译期作用域冲突错误
代码或图示
// 错误:同时标注两个作用域
// @Singleton @ActivityScoped
class BadScope @Inject constructor(...)
常见误区
- 试图用多注解同时获得单例复用与页面隔离。
- 在模块方法上叠加不同作用域注解。
追问
- 父子组件需要同一类型两个实例怎么办?答:定义两个绑定,用 @Qualifier 区分;或分别构造。
- 作用域冲突报错长什么样?答:编译期提示绑定作用域与组件不兼容,需按模块 InstallIn 核对。
07.1.1.10.1-012 组件层级与依赖方向:子组件能访问父组件绑定吗?
一句话结论
可以。子组件能解析父组件及祖先组件的绑定;反向不行,父组件不能访问子组件作用域对象。
概念解释
依赖方向自上而下:Activity 组件访问单例绑定,Fragment 组件访问 Activity 与单例绑定,反之不可。这保证应用级依赖可被各页面复用,页面级对象不被上层误持有。模块安装在哪个组件,决定其绑定在哪一层可见。
原理流程
子组件 → 向上查找父组件绑定
父组件 → 不可引用子组件作用域对象
代码或图示
Singleton(api, db)
└ Activity(session)
└ Fragment(listAssisted)
常见误区
- 在单例模块中注入 Activity 作用域对象,方向倒置导致编译错误。
- 以为父组件能复用子组件创建的实例。
追问
- 跨层级共享对象放哪?答:按最高需要它的层级放置;只在页面用就不提升到单例。
- 依赖方向与 Gradle 模块方向一致吗?答:应保持一致,避免架构反向依赖。
07.1.1.10.1-013 @ActivityRetainedScoped 解决什么问题?
一句话结论
它绑定 Activity 实例但跨配置变更保留:旋转屏幕后该作用域对象不随 Activity 重建销毁,用于承载 Activity 级但需跨旋转保留的会话状态。
概念解释
普通 @ActivityScoped 对象在 Activity 重建时重新创建;@ActivityRetainedScoped 对象挂在 retained 级别配置变更期间存活,Activity 销毁重建后仍复用。它区别于 ViewModel 作用域:属于 Activity 级 retained 容器,配置变更后释放条件是 Activity 真正 finish。
原理流程
配置变更 → Activity 重建,retained 容器保留
→ @ActivityRetainedScoped 实例复用
Activity finish → 释放
代码或图示
@ActivityRetainedScoped
class RetainedSession @Inject constructor(
private val dao: NoteDao
)
常见误区
- 用 ActivityRetainedScoped 存放 View 引用,配置变更后引用旧视图。
- 混淆它与 ViewModelScoped:前者 Activity 级 retained,后者 ViewModel 生命周期。
追问
- 它和 ViewModel 怎么选?答:需要跨旋转的业务状态优先 ViewModel;Activity 级协调器可用 retained 作用域。
- retained 对象何时清除?答:Activity 真正销毁(非配置变更)后释放。
07.1.1.10.1-014 自定义作用域与自定义组件怎么定义?
一句话结论
用 @Scope 元注解定义自定义作用域注解,配合 Dagger 自定义组件并在 Hilt 集成中声明安装关系;内置组件满足不了时才使用。
概念解释
自定义场景如模块内独立会话容器。流程:定义 @Scope 注解 → 声明 @Component(或 Hilt 自定义组件)→ 模块 @InstallIn 指向该组件。Hilt 对自定义组件的支持范围有限,多数 Android 场景内置组件已足够;复杂需求需核对版本能力(待确认)。
原理流程
@Scope 注解 → 自定义组件 → 模块安装关系
代码或图示
@Scope
@Retention(AnnotationRetention.BINARY)
annotation class SessionScope
常见误区
- 自定义作用域不挂组件,对象无处缓存。
- 重复造内置作用域已覆盖的生命周期。
追问
- Hilt 推荐优先内置组件吗?答:是,自定义组件增加维护成本与版本兼容风险。
- 自定义组件能注入 Android 入口吗?答:需额外集成 EntryPoint 机制,按官方文档确认。
07.1.1.10.1-015 作用域与配置变更(旋转屏幕)的对象保留关系?
一句话结论
单例与 ActivityRetained/ViewModel 作用域跨旋转保留;普通 Activity/Fragment 作用域对象随重建重新创建,需按状态保留诉求选作用域。
概念解释
旋转销毁重建 Activity:Singleton 不变;@ActivityRetainedScoped 与 ViewModel 保留;@ActivityScoped 重建。Fragment 视图重建时作用域行为按 Fragment 实例与视图生命周期区分。选型时先明确状态是否要跨旋转,再选对应作用域,而不是凭感觉标注。
原理流程
旋转 → Activity 重建
保留:Singleton / ActivityRetained / ViewModel
重建:普通 Activity / Fragment 作用域
代码或图示
需要跨旋转的状态 → ViewModel / retained 作用域
纯视图协调 → Activity/Fragment 作用域
常见误区
- 把跨旋转状态放 @ActivityScoped,重建后丢失。
- 把 View 相关对象放 retained/ViewModel 作用域,持有旧视图引用。
追问
- ViewModel 本身为什么能跨旋转?答:ViewModelStore 挂在 retained 级别,与 Activity 重建分离。
- 作用域对象里的列表状态怎么保留?答:状态放入 ViewModel 或 retained 容器,作用域对象不直接持有视图。
07.1.1.10.1-016 Hilt 组件与 Android 组件生命周期对应表?
一句话结论
对照关系:SingletonComponent↔Application 进程,ActivityComponent↔Activity,FragmentComponent↔Fragment,ViewModelComponent↔ViewModel,ServiceComponent↔Service。
概念解释
每个 Hilt 组件容器跟随对应 Android 组件创建销毁,作用域注解同名配套。理解这张表是排查“对象何时新建/泄漏/越界”的基础。自定义入口(如 WorkManager、Receiver)有各自集成方式,不属于内置 Activity/Fragment 链。
原理流程
Android 组件 → Hilt 组件 → 作用域注解
Application → SingletonComponent → @Singleton
Activity → ActivityComponent → @ActivityScoped
Fragment → FragmentComponent → @FragmentScoped
ViewModel → ViewModelComponent → @ViewModelScoped
Service → ServiceComponent → @ServiceScoped
代码或图示
EntryPoint 标注:@AndroidEntryPoint 作用于 Activity/Fragment/Service 等
常见误区
- 把 Worker、Receiver 误归到 Service 组件。
- 记反组件与作用域注解的对应关系。
追问
- 一个 Android 组件能挂多个 Hilt 组件吗?答:Activity 链内含 Activity 与其子 Fragment/ViewModel 组件。
- 测试容器如何对应?答:Hilt 测试用 Application 级测试容器替换生产 Application。
07.1.1.10.1-017 构造注入 @Inject 如何工作?
一句话结论
在构造函数上标注 @Inject,Hilt 编译期解析构造参数并递归注入,运行期自动构造实例并纳入对应作用域。
概念解释
构造注入是首选方式:Hilt 看到 @Inject constructor 即生成绑定,参数类型从图中解析,递归构造依赖链。类可被直接注入时无需写模块提供方法;构造参数显式列出依赖,便于测试与审阅。
原理流程
@Inject constructor(a: A, b: B)
→ 编译期解析 A、B 绑定 → 运行期构造并传入
代码或图示
class NoteRepository @Inject constructor(
private val api: NoteApi,
private val dao: NoteDao
)
常见误区
- 构造参数类型在图中无绑定,编译期报缺失绑定。
- 在类内部手写
new依赖,绕过注入导致无法替换。
追问
- 构造注入能标注作用域吗?答:类上加作用域注解,如 @Singleton。
- 递归注入断裂在哪排查?答:从报错类型沿构造链向上找缺失绑定。
07.1.1.10.1-018 @Provides 与 @Binds 如何选择?
一句话结论
实现类可构造注入时用 @Binds 绑定接口到实现;需要手写构造逻辑、第三方实例或多参数组装时用 @Provides。
概念解释
@Binds 只声明接口与实现的对应,实现通过构造注入提供;@Provides 是模块方法手写返回实例,适合第三方库对象、配置实例、条件构造。@Binds 更轻量,@Provides 更灵活。接口绑定优先 @Binds。
原理流程
接口 ← 实现可注入:@Binds abstract fun bind(impl: Impl): Interface
需手写构造:@Provides fun provide(): Xxx
代码或图示
@Module
@InstallIn(SingletonComponent::class)
abstract class BindModule {
@Binds abstract fun bindRepo(impl: NoteRepositoryImpl): NoteRepository
}
@Module
@InstallIn(SingletonComponent::class)
object ProvideModule {
@Provides fun provideClient(): NoteApi = Retrofit.create()
}
常见误区
- 实现无法构造注入却用 @Binds,参数链断裂。
- 简单可注入实现也写 @Provides,增加样板代码。
追问
- @Binds 与 @Provides 性能差异?答:@Binds 生成代码更少;运行期实例化路径接近。
- 一个模块能混用两者吗?答:可以,抽象方法用 @Binds,对象/静态方法用 @Provides。
07.1.1.10.1-019 @Binds 为什么必须在模块抽象方法上?
一句话结论
@Binds 只做接口到实现的映射,由 Hilt 生成绑定;因此放在抽象模块的抽象方法上,方法体不需要手写实现逻辑。
概念解释
@Binds 方法签名为 abstract fun bind(impl: 实现类型): 接口类型,Hilt 按参数实现类型解析构造。模块需为 abstract 类;方法不能有方法体。@Provides 才是有返回逻辑的普通方法,可在 object 模块中声明。
原理流程
abstract module + @Binds abstract fun
→ 生成接口→实现绑定,实现走构造注入
代码或图示
@Module
@InstallIn(SingletonComponent::class)
abstract class RepoModule {
@Binds abstract fun bindNoteRepo(impl: NoteRepositoryImpl): NoteRepository
}
常见误区
- 在 object 模块里写 @Binds 抽象方法,object 不能有抽象方法。
- @Binds 方法手写方法体,与语义冲突。
追问
- @Binds 实现类必须 @Inject 构造吗?答:是,Hilt 需要能构造实现实例。
- @Binds 能标注作用域吗?答:作用域标在方法或实现类上,与组件对应。
07.1.1.10.1-020 @Provides 方法的参数如何注入?
一句话结论
@Provides 方法的参数由 Hilt 从依赖图解析传入,参数类型需要有对应绑定;方法体只负责组装返回实例。
概念解释
提供方法参数如同构造参数:Hilt 先解析参数绑定再调用方法。需要配置对象时可把配置作为参数注入。返回类型即提供的绑定类型,参数不成为返回类型的绑定。
原理流程
@Provides fun provide(api: NoteApi, config: AppConfig): NoteApiImpl
→ 解析 api/config → 调用方法 → 提供实现
代码或图示
@Provides
@Singleton
fun provideNoteDao(db: AppDatabase): NoteDao = db.noteDao()
常见误区
- 方法参数类型无绑定,编译期缺失绑定报错。
- 在 Provides 方法里硬编码 new 依赖,绕过参数注入。
追问
- Provides 方法可以带限定符参数吗?答:可以,参数侧用限定符区分同类型绑定。
- 提供方法作用域标在哪?答:方法上加 @Singleton 等,模块 InstallIn 对应组件。
07.1.1.10.1-021 模块 @InstallIn 的作用是什么?
一句话结论
@InstallIn 声明模块绑定安装到哪个 Hilt 组件,决定绑定的层级、可见性与生命周期。
概念解释
模块不指定组件就无法纳入依赖图。安装到 SingletonComponent 即应用级可见;安装到 Activity 组件则页面级可用。组件选择同时约束模块内绑定的作用域:子组件模块不能提供父组件访问的对象。
原理流程
@Module @InstallIn(XxxComponent::class)
→ 绑定进入该组件层级
代码或图示
@Module
@InstallIn(ActivityComponent::class)
object ActivityModule
常见误区
- 漏写 @InstallIn,绑定不进入图。
- 模块安装组件与绑定作用域层级不匹配,编译报错。
追问
- 一个模块能安装到多个组件吗?答:通常按层级拆分模块;跨层级绑定放最高需要的组件。
- 库模块模块安装谁?答:按库提供的依赖所属层级选择对应组件。
07.1.1.10.1-022 接口绑定与实现绑定有什么区别?
一句话结论
接口绑定声明“注入接口类型时用哪个实现”;实现绑定提供具体类型实例。依赖面向接口,模块完成接口到实现的映射。
概念解释
消费方注入接口类型(如 NoteRepository),Hilt 根据绑定找到 NoteRepositoryImpl。实现类自身的构造注入解决其依赖。接口绑定便于替换 Fake/双实现;没有接口时可直接绑定具体类。
原理流程
消费方: NoteRepository
绑定: NoteRepository ← NoteRepositoryImpl
代码或图示
interface NoteRepository { fun observe(): Flow<List<Note>> }
@Singleton
class NoteRepositoryImpl @Inject constructor(
private val dao: NoteDao
) : NoteRepository
常见误区
- 消费方注入实现类,后续替换接口实现时改动面扩大。
- 接口与实现无绑定映射,编译期找不到接口类型提供方。
追问
- 接口绑定放哪个模块?答:实现所在数据模块提供绑定,接口定义在 domain/公共模块。
- 多实现如何绑定同一接口?答:配合 @Qualifier 区分,见后续条目。
07.1.1.10.1-023 构造注入无法使用的场景有哪些?
一句话结论
第三方库类、框架要求的实例、需要配置参数或条件分支构造的对象,无法直接 @Inject 构造,需用 @Provides 模块提供。
概念解释
构造注入要求类构造可由 Hilt 解析;第三方 SDK 类源码不在工程内、构造需要上下文/配置、单例工厂创建、按条件选实现,都只能在模块方法中手写组装。典型:Retrofit/OkHttpClient、数据库实例、平台服务、带配置的客户端。
原理流程
不可注入构造 → @Provides 方法手写构造
→ 注入配置/上下文参数 → 返回实例
代码或图示
@Provides
@Singleton
fun provideOkHttp(): OkHttpClient = OkHttpClient.Builder().build()
常见误区
- 尝试给第三方类加 @Inject 构造,源码不可改。
- 在 Provides 方法里硬编码配置,失去注入灵活性。
追问
- 平台服务(如 LocationManager)怎么提供?答:模块方法从 Context 获取后绑定。
- 条件选择实现放哪?答:模块方法按配置返回对应实现,限定符区分备选。
07.1.1.10.1-024 模块 @Provides 标注对象的作用域如何声明?
一句话结论
在 @Provides 方法上加作用域注解(如 @Singleton),并保证模块 @InstallIn 对应组件;无作用域则每次注入新建。
概念解释
提供方法的复用级别由方法上的作用域决定。作用域与组件必须配套:@Singleton 配 SingletonComponent,@ActivityScoped 配 ActivityComponent。漏标作用域的提供对象不缓存;错配组件编译报错。
原理流程
@Provides @Singleton fun provideX(): X
@InstallIn(SingletonComponent::class)
代码或图示
@Module
@InstallIn(SingletonComponent::class)
object DbModule {
@Provides @Singleton
fun provideDb(context: Context): AppDatabase =
Room.databaseBuilder(context, AppDatabase::class.java, "app.db").build()
}
常见误区
- Provides 方法标了 @Singleton 模块却装到子组件,作用域不匹配。
- 昂贵实例漏标作用域,每次注入重复创建。
追问
- 作用域能标在模块类上吗?答:作用域标注在提供方法/绑定上;模块类本身不持有作用域。
- 单例数据库注入 Context 用哪个 Context?答:应用 Context,避免持有 Activity 上下文。
07.1.1.10.1-025 绑定的类型匹配:实现类与接口如何对应?
一句话结论
绑定返回/参数类型必须与注入点类型兼容:@Binds 参数是实现、返回是接口;@Provides 返回类型即绑定类型,Hilt 按类型查找。
概念解释
类型不兼容(如返回父类但注入子类、接口无实现绑定)会在编译期报错。泛型绑定需完整匹配类型参数;协变/逆变位置要符合 Kotlin 类型规则。注入点声明的类型决定查找哪个绑定键。
原理流程
注入点类型 T → 查找绑定键 T
实现类 → 实现 T 接口 → 匹配
代码或图示
@Binds abstract fun bind(impl: NoteRepositoryImpl): NoteRepository
// 注入 NoteRepository 时解析到 Impl
常见误区
- 返回类型写实现类,注入接口时找不到绑定。
- 泛型擦除/类型参数不一致导致匹配失败。
追问
- 同一接口多绑定如何区分?答:用限定符构成绑定键的一部分。
- 绑定能向上转型提供吗?答:按声明返回类型匹配;需要父类类型另建绑定。
07.1.1.10.1-026 为什么 @Binds 比 @Provides 更轻量?
一句话结论
@Binds 只生成接口到实现的映射,实现走构造注入;@Provides 需生成方法调用与组装代码,因此 @Binds 生成代码更少、配置更简。
概念解释
可构造注入的实现不需要手写工厂方法,@Binds 仅记录映射关系;@Provides 方法体由 Hilt 调用,参数解析与返回实例都要生成对应代码。优先 @Binds 能减少模块样板与生成代码量,编译图更清晰。
原理流程
@Binds:映射记录 + 构造注入复用
@Provides:方法调用 + 手写组装
代码或图示
// @Binds:一行映射
@Binds abstract fun bind(impl: Impl): Contract
常见误区
- 所有绑定都写 @Provides,模块冗长且生成代码增多。
- 实现不满足构造注入条件仍强行 @Binds。
追问
- @Binds 能提供第三方实例吗?答:不能,第三方需 @Provides。
- 轻量体现在编译还是运行?答:主要在生成代码与配置;运行期复用程度由作用域决定。
07.1.1.10.1-027 模块方法返回类型与注入类型不一致会怎样?
一句话结论
类型不匹配在编译期报缺失绑定或类型不兼容错误,注入点拿不到对应类型实例;需对齐返回类型或补绑定。
概念解释
Hilt 按绑定键(类型 + 限定符)查找。方法返回 Impl 而注入 Contract 时,除非另有 @Binds 映射,否则图中没有 Contract 绑定。泛型、可空性、限定符差异都会让绑定键不同。
原理流程
注入类型 Contract → 图中查找 Contract 键
仅提供 Impl → 缺失绑定报错
代码或图示
@Provides fun provideImpl(): NoteRepositoryImpl = NoteRepositoryImpl()
// 注入 NoteRepository 时仍需绑定映射
常见误区
- 以为返回实现类自动满足接口注入。
- 限定符漏标导致“同类型不同绑定”匹配不上。
追问
- 报错信息如何定位?答:报错给出注入点与缺失类型,沿模块返回类型核对。
- 可空类型影响绑定吗?答:绑定按非空类型解析;可空性在注入侧处理,不另建可空绑定。
07.1.1.10.1-028 同一类型多个绑定如何区分?
一句话结论
同一接口/类型有多个实现时,用 @Qualifier(或 @Named)构成绑定键的一部分,注入点与模块两侧标注同一限定符。
概念解释
无区分符时 Hilt 不知道选哪个实现,报重复/歧义绑定。限定符把“类型”细化为“类型 + 标记”:如两个 NoteApi 分别标 @LocalApi、@RemoteApi。模块提供与消费注入都要带同一限定符,缺一即匹配失败。
原理流程
绑定键 = 类型 + Qualifier
模块标注 + 注入点标注 → 精确匹配
代码或图示
@Qualifier @Retention(BINARY) annotation class RemoteApi
@Provides @RemoteApi
fun provideRemote(): NoteApi = /* 远程实现 */
常见误区
- 只在模块侧标限定符,注入点漏标,类型歧义。
- 两个绑定用同名限定符不同语义,造成误用。
追问
- 多绑定与 @Binds 配合?答:@Binds 方法/实现上同样可标限定符。
- 限定符与作用域叠加?答:两者正交,限定符区分同类型,作用域决定复用级别。
07.1.1.10.1-029 @Qualifier 解决什么问题?
一句话结论
@Qualifier 解决同一类型多实现/多实例的歧义注入问题,给绑定加上语义标记,使 Hilt 能选择正确实现。
概念解释
依赖图中同一类型可能有多个绑定(远程/本地、主/备、不同配置客户端)。限定符作为绑定键组成部分区分它们。没有限定符,Hilt 无法从多个同类型绑定中选择,编译期报歧义。它是编译期解析,不是运行时动态选择。
原理流程
多实现同类型 → 加 Qualifier 标记
注入点按标记取对应实现
代码或图示
interface Logger { fun log(msg: String) }
@Qualifier @Retention(BINARY) annotation class DebugLogger
常见误区
- 用运行时 if/else 选择实现,绕过 DI 图。
- 限定符命名模糊(如 @A、@B),可读性差。
追问
- Qualifier 只能标接口吗?答:可用于任何同类型多绑定场景,包括字符串、配置实例。
- 限定符能继承组合吗?答:按注解定义使用;避免多层标记造成歧义。
07.1.1.10.1-030 @Named 与自定义 Qualifier 的区别?
一句话结论
@Named 是基于字符串的内置限定符;自定义 Qualifier 是类型安全的注解,编译期更明确,推荐业务代码使用自定义限定符。
概念解释
@Named("remote") 用字符串区分,简单但字符串拼写错误不被类型检查发现;自定义注解在模块与注入点都是强类型符号,重构更安全。@Named 适合快速原型,正式工程优先自定义 Qualifier。
原理流程
@Named("remote"):字符串键
自定义 @RemoteApi:注解类型键
代码或图示
@Named("remote")
@Provides fun provideRemote(): NoteApi = /* ... */
// 注入
fun consume(@Named("remote") api: NoteApi)
常见误区
- @Named 字符串两侧拼写不一致,编译期才暴露匹配问题。
- 字符串易复制粘贴产生重复标记。
追问
- @Named 能标注参数吗?答:可用于方法参数与注入字段。
- 什么时候保留 @Named?答:遗留代码或快速实验;新代码用自定义注解。
07.1.1.10.1-031 如何定义自定义限定符注解?
一句话结论
用 @Qualifier 元注解组合 @Retention(AnnotationRetention.BINARY) 定义注解,按需声明 value 属性,再在模块与注入点使用。
概念解释
自定义限定符是普通注解加 @Qualifier 标记,Hilt/Dagger 识别它作为绑定键一部分。可带参数区分更多实例。定义放在公共 DI 模块,模块提供与消费注入引用同一注解。
原理流程
@Qualifier + @Retention(BINARY) → 注解类型
模块/注入点标注 → 绑定键加标记
代码或图示
@Qualifier
@Retention(AnnotationRetention.BINARY)
annotation class LocalApi
@Qualifier
@Retention(AnnotationRetention.BINARY)
annotation class Endpoint(val value: String)
常见误区
- 漏加 @Qualifier,注解不参与绑定键区分。
- 保留策略写成 SOURCE/RUNTIME 与 DI 识别要求不符(按版本确认,待确认)。
追问
- 限定符注解可以带多个参数吗?答:可以,参数共同构成标记语义。
- 定义放哪个模块?答:被多模块复用时放公共 DI/contract 模块。
07.1.1.10.1-032 限定符在模块与注入点两侧如何保持一致?
一句话结论
同一限定符注解(及参数值)必须同时出现在提供绑定处和消费注入处;两侧缺任一侧都会导致绑定键不匹配。
概念解释
绑定键由类型加限定符组成。模块标 @RemoteApi 提供,注入点也要标 @RemoteApi;字符串限定符两侧值一致。校验在编译期完成:未标注的一侧按无标记类型查找,产生缺失或歧义。
原理流程
模块: @RemoteApi provide()
注入: @RemoteApi api: NoteApi
→ 键一致,匹配成功
代码或图示
// 模块
@RemoteApi @Provides fun provideRemote(): NoteApi = /* ... */
// 消费
class Consumer @Inject constructor(@RemoteApi private val api: NoteApi)
常见误区
- 模块标限定符、字段漏标,解析到另一个无标记绑定。
- 限定符参数值两侧不同,视为不同绑定。
追问
- 如何批量检查不一致?答:编译报错定位注入点;代码评审核对模块与消费侧注解。
- 限定符能继承父类标注吗?答:按 Dagger/Hilt 规则,构造参数需显式标注(待确认版本细节)。
07.1.1.10.1-033 同一接口多个实现如何分别注入?
一句话结论
为每个实现定义独立限定符,模块分别提供绑定,消费方按需要的限定符注入对应实现;切换实现只改标注或测试模块。
概念解释
典型:远程 API 与本地模拟实现、不同环境客户端。每个绑定带专属限定符,注入点明确选择。测试时可用测试模块替换某一限定符绑定,不影响其他实现。多实现场景避免靠运行时分支选择。
原理流程
RemoteImpl @RemoteApi;MockImpl @MockApi
注入点按限定符取实现
代码或图示
@RemoteApi @Provides
fun provideRemote(): NoteApi = RemoteNoteApi()
@MockApi @Provides
fun provideMock(): NoteApi = MockNoteApi()
class HomeViewModel @Inject constructor(
@RemoteApi private val api: NoteApi
) : ViewModel()
常见误区
- 两个实现都无标记,Hilt 报重复绑定。
- 测试替换实现时改错限定符,生产实现被误换。
追问
- 多实现能做成集合注入吗?答:Dagger 多绑定可提供 Set/Map;Hilt 支持范围按版本确认(待确认)。
- 环境切换放哪层?答:模块按构建变体提供不同绑定,限定符区分备选实现。
07.1.1.10.1-034 限定符与作用域的区别是什么?
一句话结论
限定符区分“同类型的哪个绑定”,作用域决定“实例复用多久/在哪复用”;两者正交,可叠加在同一绑定上。
概念解释
解决不同问题:歧义选择靠限定符,生命周期与缓存靠作用域。一个 @RemoteApi @Singleton 绑定既标记是远程实现,又在应用级唯一。理解二者分工可避免把“多实现”问题误用作用域解决。
原理流程
Qualifier:选择哪个实现
Scope:复用级别与生命周期
代码或图示
@RemoteApi @Singleton
@Provides fun provideRemote(): NoteApi = /* ... */
常见误区
- 用不同作用域区分两个同类型实现,生命周期语义被污染。
- 以为加了限定符就自动单例,复用仍需作用域标注。
追问
- 两者顺序有要求吗?答:注解顺序不影响语义,保持代码风格统一即可。
- 无多实现时需要限定符吗?答:不需要,避免无谓标记。
07.1.1.10.1-035 绑定注解标注在类、构造参数与模块方法上有何区别?
一句话结论
类上标 @Inject constructor 提供自身构造绑定;构造参数上标限定符选择依赖;模块方法上标 @Provides/@Binds 与作用域提供外部绑定,三者位置对应不同绑定环节。
概念解释
类构造注入由 Hilt 解析构造参数;参数侧限定符决定取哪个实现;模块方法负责无法构造注入的类型。作用域标在被提供的类或方法上。理解各注解位置,可快速判断报错出在“类未绑定、参数选错实现,还是模块未提供”。
原理流程
类:@Inject constructor → 自身可注入
参数:@Qualifier → 选择依赖绑定
模块方法:@Provides/@Binds + Scope → 提供外部实例
代码或图示
class HomeViewModel @Inject constructor(
@RemoteApi private val api: NoteApi // 参数侧限定符
) : ViewModel()
常见误区
- 把作用域标在构造参数上,作用域应属于提供方而非消费方。
- 在实现类上重复标注与模块方法冲突的绑定,造成重复绑定。
追问
- 构造注入类自身作用域标哪?答:标在类声明上,如
@Singleton class Xxx @Inject constructor(...)。 - 注解位置报错如何归类?答:缺失提供查模块,歧义查限定符,生命周期不符查作用域。
07.1.1.10.1-036 @AndroidEntryPoint 标注在哪些组件上?
一句话结论
@AndroidEntryPoint 标注在需要注入的 Android 入口组件上,支持 Activity、Fragment、Service、BroadcastReceiver 等;标注后 Hilt 为其生成注入入口并关联对应组件容器。
概念解释
入口组件是 Android 框架创建、Hilt 无法直接构造的对象。加注解后,Hilt 在编译期生成基类代理/注入逻辑,组件创建时从对应容器取依赖注入字段或构造。未标注的组件不会被 Hilt 自动注入,需走 EntryPoint 手动获取。
原理流程
@AndroidEntryPoint → 生成入口注入代码
组件创建 → 关联 Hilt 组件 → 字段/构造注入
代码或图示
@AndroidEntryPoint
class HomeActivity : AppCompatActivity() {
@Inject lateinit var noteRepository: NoteRepository
}
常见误区
- 给普通 Kotlin 类加 @AndroidEntryPoint,该注解只用于 Android 入口组件。
- 标注了 Fragment 但宿主 Activity 未标注,容器链不完整。
追问
- 注解支持哪些组件类型?答:Activity/Fragment/Service/Receiver 等,完整清单以 Hilt 版本文档为准(待确认)。
- 字段注入为什么用 lateinit?答:注入在 super.onCreate 之后完成,字段构造期不可用。
07.1.1.10.1-037 @HiltAndroidApp 做了什么?
一句话结论
@HiltAndroidApp 标注 Application 类,触发 Hilt 根容器(SingletonComponent)生成与初始化,是整个依赖图的入口。
概念解释
没有根容器,子组件与绑定无法创建。注解在编译期生成 Application 级 Hilt 组件代码,进程启动时初始化单例容器。所有 @AndroidEntryPoint 组件都挂在这个根容器之下;多进程时各进程独立初始化根容器。
原理流程
@HiltAndroidApp → 生成 SingletonComponent 初始化代码
Application 创建 → 根容器就绪 → 子组件可解析绑定
代码或图示
@HiltAndroidApp
class App : Application()
常见误区
- Application 未标注,其他组件注入时报根容器缺失。
- 多进程各自使用独立 Application 初始化,误以为单例跨进程共享。
追问
- 根容器何时创建?答:Application 初始化阶段;具体生成代码时机按 Hilt 实现(待确认)。
- 能否不继承自定义 Application?答:需要 Application 初始化时仍应有标注的 Application 类作为根入口。
07.1.1.10.1-038 EntryPoint 是什么?为什么需要 @EntryPoint?
一句话结论
EntryPoint 是从 Hilt 容器外部显式获取绑定的入口接口;@EntryPoint 用于 Hilt 无法直接注解的框架对象或静态/第三方场景。
概念解释
@AndroidEntryPoint 覆盖常规 Android 组件;框架回调、第三方基类、工具类、ContentProvider 等无法加注解时,定义带 @EntryPoint 的接口声明要暴露的依赖,再通过容器实例获取。EntryPoint 打破“只有注解入口能拿依赖”的限制。
原理流程
定义 @EntryPoint 接口(暴露依赖)
→ 从组件容器取 entryPoint() → 拿到绑定
代码或图示
@EntryPoint
@InstallIn(SingletonComponent::class)
interface NoteEntryPoint {
fun noteRepository(): NoteRepository
}
// 获取
val entryPoint = EntryPointAccessors.fromApplication(context, NoteEntryPoint::class.java)
常见误区
- 把 EntryPoint 当普通接口手写实现,绕过 Hilt 绑定。
- EntryPoint 接口暴露过多内部依赖,破坏封装。
追问
- EntryPoint 安装到哪个组件?答:@InstallIn 声明,决定能访问哪一层绑定。
- EntryPoint 与 @AndroidEntryPoint 怎么选?答:能注解就用注解;框架对象无法注解才用 EntryPoint。
07.1.1.10.1-039 哪些场景用 EntryPoint 而不是 @AndroidEntryPoint?
一句话结论
框架直接实例化、源码不可改、非标准组件(部分 Receiver、Provider、工具类、Compose 外的遗留类)场景用 EntryPoint;可控的标准组件优先 @AndroidEntryPoint。
概念解释
典型场景:第三方 SDK 回调注册的类、由系统创建无法继承 Hilt 基类的组件、静态工具类访问容器、WorkManager 之外的后台入口。EntryPoint 在这些位置从应用/组件容器取依赖,保持 DI 图统一,不在类内 new 单例。
原理流程
无法加注解 → 定义 EntryPoint → 容器 accessor 获取
代码或图示
// 第三方回调类内部获取
val repo = EntryPointAccessors.fromApplication(
context, NoteEntryPoint::class.java
).noteRepository()
常见误区
- 在不可注解类里手写 ServiceLocator,绕过 DI 图不可测试。
- EntryPoint 按 Activity 容器获取却传入 Application 上下文,层级错误。
追问
- ContentProvider 用哪种方式?答:按版本支持情况,Provider 注入或 EntryPoint 获取(待确认)。
- EntryPoint 获取的对象作用域?答:由其安装组件与绑定作用域决定。
07.1.1.10.1-040 生成机制:Hilt 编译期生成什么代码?
一句话结论
编译期生成组件实现、绑定工厂、入口注入代码与作用域缓存;运行期由这些生成代码解析依赖,而非反射扫描注解。
概念解释
注解处理器(kapt/KSP)扫描 @Inject、@Module、@InstallIn 等,生成对应 Dagger 组件类、提供方法工厂、入口类注入逻辑。生成代码位于构建产物的 generated source 目录。编译期完成图校验:缺失绑定、重复绑定、作用域错配在编译阶段暴露。
原理流程
注解扫描 → 生成组件/工厂/入口代码
→ 编译进 APK → 运行期容器解析实例
代码或图示
生成产物:XxxComponentImpl、绑定工厂、入口注入辅助类
目录:构建产物 generated source(具体路径按构建工具,待确认)
常见误区
- 以为运行时反射读注解创建对象,性能模型理解错误。
- 修改模块后未重新编译,生成代码与源码不同步。
追问
- KSP 与 kapt 生成代码结构一致吗?答:核心绑定图一致,产物组织与增量编译表现有差异(待确认)。
- 生成代码能直接改吗?答:不能,下次构建被覆盖。
07.1.1.10.1-041 @AndroidEntryPoint 支持的组件清单与限制?
一句话结论
覆盖 Activity、Fragment、Service、BroadcastReceiver 等标准组件;受限点包括:必须继承可注入基类、部分组件注入时机晚于构造函数、多模块库需注意注解可见性。
概念解释
各组件注入时机不同:Activity 在 super.onCreate 后字段可用,Fragment 受视图生命周期约束。第三方基类若不在支持链上,需用 EntryPoint。具体支持清单随 Hilt 版本演进,使用前核对官方文档(待确认)。
原理流程
标准组件 → 注解注入
不可继承/非标准 → EntryPoint
代码或图示
@AndroidEntryPoint
class MainService : Service() {
@Inject lateinit var syncRepository: SyncRepository
}
常见误区
- 在构造函数阶段使用注入字段,此时尚未注入。
- 自定义框架基类加了注解但继承链不在支持范围。
追问
- 注入时机在哪个回调后可用?答:Activity 为 super.onCreate 之后;Fragment/Service 按对应生命周期,细节以版本为准。
- 支持自定义 View 注入吗?答:View 通常通过 EntryPoint 或构造传入,标准组件清单不含普通 View(待确认)。
07.1.1.10.1-042 广播接收器、ContentProvider 如何接入 Hilt?
一句话结论
Receiver 可按版本使用 @AndroidEntryPoint 或 EntryPoint 获取依赖;Provider 生命周期早于常规组件,通常通过 EntryPoint 从应用容器取绑定。
概念解释
Receiver 由系统注册/拉起,Hilt 支持程度随版本变化;不能注解时在 onReceive 内用 accessor 取 EntryPoint。Provider 在 Application 早期创建,注入时序受限,一般不做字段注入,改为手动获取应用级单例。注意不要在 Provider 构造期依赖尚未初始化的绑定。
原理流程
Receiver:注解注入 / onReceive 内 EntryPoint
Provider:应用容器 EntryPoint 手动获取
代码或图示
override fun onReceive(context: Context, intent: Intent) {
val repo = EntryPointAccessors.fromApplication(
context, NoteEntryPoint::class.java
).noteRepository()
}
常见误区
- 在 Provider onCreate 前访问依赖,根容器尚未就绪。
- Receiver 内存持有容器引用造成泄漏。
追问
- Receiver 注入的依赖作用域?答:应用级单例为主;页面级绑定在 Receiver 场景不可用。
- 版本支持差异?答:以当前 Hilt 官方文档清单为准(待确认)。
07.1.1.10.1-043 第三方或框架基类无法加注解时怎么注入?
一句话结论
通过 EntryPoint 从对应容器获取依赖,或在可控制的封装层构造注入后传入;不在不可改的类内部 new 依赖。
概念解释
源码不在工程内的类无法加 @Inject/@AndroidEntryPoint。两条路:类能拿到 Context 时用 EntryPoint accessor 取应用级绑定;外层可控制时用构造函数把依赖传入类内。保持数据来源统一,便于测试替换。
原理流程
不可改类 → EntryPoint 取绑定 / 外层构造传参
避免:类内硬编码单例
代码或图示
// 外层封装注入后传入
class ThirdPartyWrapper(private val repo: NoteRepository) {
fun delegate() = repo.observe()
}
常见误区
- 在第三方类内部直接 new Repository,测试无法替换。
- EntryPoint 暴露整套内部图,封装边界被打开。
追问
- 框架回调需要长生命周期依赖?答:取应用级单例,避免持有页面级容器。
- 这种场景算绕过 Hilt 吗?答:不算,依赖仍来自 Hilt 容器,只是获取方式显式。
07.1.1.10.1-044 EntryPoint 访问入口如何获取?
一句话结论
用 EntryPointAccessors.fromApplication 或对应组件 accessor,传入上下文与 EntryPoint 接口类,返回接口实例即可调用暴露的绑定方法。
概念解释
accessor 根据上下文定位 Hilt 组件容器:fromApplication 取根容器,Activity/Fragment 场景有对应组件 accessor。EntryPoint 接口方法返回暴露类型,容器在方法调用时解析绑定。获取顺序:先有容器,再取接口实例。
原理流程
Context → 定位 Hilt 组件
→ EntryPointAccessors → 接口实例 → 调用方法取绑定
代码或图示
val point = EntryPointAccessors.fromApplication(
context.applicationContext, NoteEntryPoint::class.java
)
val repo = point.noteRepository()
常见误区
- 传 Activity Context 给 fromApplication,层级混淆。
- EntryPoint 接口方法返回页面级绑定,却从应用容器获取。
追问
- accessor 有哪些类型?答:application/activity 等对应组件层级,按安装组件选择。
- 获取 EntryPoint 实例开销大吗?答:轻量代理对象;真正实例化按作用域缓存。
07.1.1.10.1-045 字段注入与构造注入有什么区别?
一句话结论
构造注入在对象创建时传入依赖,显式且可测试;字段注入由入口组件在创建后回填字段,适用于框架无法改构造函数的对象。
概念解释
Hilt 优先构造注入:依赖在构造参数中可见,对象不可变。字段注入(@Inject lateinit var)用于 Activity/Fragment/Service 等框架实例,构造由系统调用,Hilt 在生命周期回调后回填。字段注入产生可空/lateinit 字段,时序上晚于构造。
原理流程
构造注入:new 时传入依赖
字段注入:组件创建 → Hilt 回填 @Inject 字段
代码或图示
// 构造注入(普通类/ViewModel)
class NoteRepository @Inject constructor(private val dao: NoteDao)
// 字段注入(Activity)
@AndroidEntryPoint
class HomeActivity : AppCompatActivity() {
@Inject lateinit var viewModel: HomeViewModel
}
常见误区
- 在构造函数里使用字段注入依赖,此时未回填。
- 能用构造注入的类改用字段注入,隐藏依赖关系。
追问
- 字段注入能换成构造注入吗?答:框架组件不行;普通业务类一律构造注入。
- 字段注入如何测试?答:测试中手动给字段赋值或用 Hilt 测试容器。
07.1.1.10.1-046 @HiltViewModel 如何工作?
一句话结论
@HiltViewModel 标注 ViewModel,Hilt 生成对应 ViewModel 工厂并注入其构造依赖,配合 @Inject constructor 完成 ViewModel 装配。
概念解释
ViewModel 由系统 ViewModelProvider 创建,普通构造注入无法直接传入依赖。@HiltViewModel 让 Hilt 生成工厂,在 ViewModel 创建时解析构造参数。注入的 Repository、DAO 等来自对应组件;ViewModel 作用域内绑定可复用。
原理流程
@HiltViewModel + @Inject constructor
→ Hilt 生成工厂 → ViewModelProvider 创建时注入依赖
代码或图示
@HiltViewModel
class HomeViewModel @Inject constructor(
private val noteRepository: NoteRepository
) : ViewModel()
常见误区
- 只标 @HiltViewModel 构造参数无 @Inject,工厂解析不到依赖。
- ViewModel 持有 Activity 上下文类型引用,造成泄漏风险。
追问
- @HiltViewModel 需要额外工厂注册吗?答:Hilt 集成自动生成,无需手写 ViewModelProvider.Factory。
- ViewModel 作用域绑定在哪一层?答:ViewModelComponent,见组件层级条目。
07.1.1.10.1-047 ViewModel 构造注入依赖怎么写?
一句话结论
ViewModel 类标 @HiltViewModel,构造函数标 @Inject,业务依赖作为构造参数;Hilt 从图中解析并在创建时传入。
概念解释
依赖方向:ViewModel 接收仓库/用例接口,不直接 new。构造参数类型需在 DI 图中有绑定。可注入多参数、限定符区分的依赖。ViewModel 内部把仓库流转成界面状态,不持有框架上下文。
原理流程
@HiltViewModel
class XxxViewModel @Inject constructor(repo: NoteRepository) : ViewModel()
代码或图示
@HiltViewModel
class EditorViewModel @Inject constructor(
private val repo: NoteRepository,
@LocalApi private val localApi: NoteApi
) : ViewModel()
常见误区
- 构造参数注入 Context,应注入应用级所需组件而非 Activity 上下文。
- 把 View 层对象(View、LiveData 宿主)注入 ViewModel。
追问
- 依赖是接口还是实现?答:构造面向接口,模块绑定实现,便于测试替换。
- 多个 ViewModel 共享依赖实例吗?答:按依赖作用域;@Singleton 共享,@ViewModelScoped 各自一份。
07.1.1.10.1-048 ViewModel 跨配置变更时依赖如何保留?
一句话结论
ViewModel 实例与注入的 ViewModel 作用域依赖跨旋转保留;单例依赖本就全局保留,页面级依赖不进入 ViewModel 构造链。
概念解释
配置变更销毁重建 Activity,ViewModel 由 ViewModelStore 保留,其构造注入的 @ViewModelScoped 对象随之保留。@ActivityScoped 依赖不应注入 ViewModel:Activity 重建后旧作用域已失效。需要跨旋转的状态放 ViewModel 及其作用域会话对象。
原理流程
旋转 → ViewModelStore 保留 ViewModel
→ ViewModel 与其作用域依赖保留
Activity 作用域对象不进入 ViewModel
代码或图示
@HiltViewModel
class ProfileViewModel @Inject constructor(
private val repo: NoteRepository // 单例/仓库级
) : ViewModel()
常见误区
- ViewModel 注入 @ActivityScoped 对象,重建后引用失效。
- 把界面状态存在 Activity 作用域对象里,旋转后丢失。
追问
- @ViewModelScoped 会话对象何时释放?答:ViewModel onCleared 时随组件释放。
- 跨进程保留吗?答:不保留;ViewModel 只在进程内存中存活。
07.1.1.10.1-049 带 SavedStateHandle 的 ViewModel 如何注入?
一句话结论
构造参数声明 SavedStateHandle,Hilt 自动提供该 ViewModel 对应的句柄,用于读取 arguments 与保存状态。
概念解释
SavedStateHandle 是 ViewModel 与保存状态/参数之间的通道,Hilt 集成识别该类型并由工厂传入。无需手动从 Activity 取 arguments 再塞给 ViewModel。句柄按 ViewModel 实例隔离,可观察其中键值。
原理流程
构造参数 SavedStateHandle
→ Hilt 工厂注入对应句柄 → 读取 arguments/state
代码或图示
@HiltViewModel
class DetailViewModel @Inject constructor(
private val savedStateHandle: SavedStateHandle,
private val repo: NoteRepository
) : ViewModel() {
private val noteId: Long = savedStateHandle["noteId"]
}
常见误区
- 手动 new SavedStateHandle,与系统保存状态脱节。
- 从句柄取参数未判空,类型转换异常。
追问
- SavedStateHandle 作用域?答:跟随 ViewModel,跨配置变更保留。
- 导航参数如何传入?答:导航路由参数落入 arguments,句柄按键读取。
07.1.1.10.1-050 Hilt 如何向 ViewModel 注入 Activity 作用域依赖?
一句话结论
一般不向 ViewModel 注入 Activity 作用域对象;需要页面级会话时用 @ViewModelScoped 或 ActivityRetained 设计,避免 ViewModel 持有已销毁的 Activity 容器。
概念解释
ViewModel 生命周期长于 Activity,注入 Activity 作用域绑定会造成层级越界与泄漏风险。确需 Activity 级协作者时,通过 ViewModel 事件让 Activity 参与,或使用 retained 作用域对象。编译期作用域规则会约束组件可访问的绑定层级。
原理流程
ViewModelComponent 可访问:单例 + 自身作用域
不可访问:Activity 作用域缓存对象
代码或图示
// 推荐:ViewModel 只依赖仓库级/单例绑定
@HiltViewModel
class MainViewModel @Inject constructor(
private val repo: NoteRepository
) : ViewModel()
常见误区
- ViewModel 注入 Activity Context 或 Activity 作用域协调器。
- 为绕过限制在单例模块里放页面状态,污染全局。
追问
- ViewModel 怎么和 Activity 交互?答:通过状态/事件流,Activity 观察后执行页面级操作。
- 作用域越界编译报错吗?答:按 Dagger 规则报作用域/绑定层级错误。
07.1.1.10.1-051 @HiltViewModel 与普通 ViewModel 工厂是什么关系?
一句话结论
@HiltViewModel 由 Hilt 生成替代手写工厂的 ViewModelProvider.Factory;普通工厂用于无 DI 或复杂构造参数场景。
概念解释
手写工厂在 create() 里 new ViewModel 并传依赖;Hilt 工厂按构造注入解析依赖生成实例。迁移到 Hilt 后删除手写工厂与 viewModelFactory 样板。复杂参数(如运行时计算入参)仍可结合 assisted 注入或工厂处理。
原理流程
手写:Factory.create() → new ViewModel(deps)
Hilt:生成工厂 → 构造注入解析 → 创建 ViewModel
代码或图示
// 手写工厂(旧)
val factory = ViewModelFactory(repo)
// Hilt 后直接获取
val vm: HomeViewModel by viewModels()
常见误区
- 保留旧工厂又用 @HiltViewModel,两套创建路径冲突。
- 运行时入参与注入依赖混在构造里,工厂解析失败。
追问
- 运行时参数怎么注入?答:assisted 注入或工厂包装;按 Hilt 支持能力确认(待确认)。
- Compose 中如何获取?答:
hiltViewModel()组合函数配合 @HiltViewModel。
07.1.1.10.1-052 ViewModel 注入常见错误:作用域越界有哪些表现?
一句话结论
表现为编译期作用域/绑定缺失错误,或运行期持有 Activity 上下文导致泄漏;根因是 ViewModel 链引用了更短生命周期的绑定。
概念解释
典型越界:ViewModel 注入 Activity 作用域对象、注入 Activity Context。编译期规则拦截部分错配;绕过规则后表现为泄漏引用。排查沿 ViewModel 构造参数向上找绑定所属组件,把页面级依赖移出 ViewModel 链。
原理流程
ViewModel 构造参数 → 查绑定组件
越界:Activity/页面作用域 → 移出或改 retained/ViewModel 作用域
代码或图示
// 风险:注入 Activity 类型
class BadViewModel @Inject constructor(activity: Activity)
常见误区
- 用 Application Context 替代 Activity Context 后仍注入页面级协调器。
- 报错只改编译配置,未调整依赖归属层级。
追问
- 如何检测 ViewModel 泄漏?答:LeakCanary 观察 Activity 被 ViewModel 引用链。
- 页面级能力如何给 ViewModel 用?答:接口回调到 Activity 执行,ViewModel 只发事件。
07.1.1.10.1-053 多模块下 Hilt 模块如何组织?
一句话结论
按架构层拆分 Hilt 模块:数据模块提供实现绑定,公共/domain 模块定义接口,聚合模块汇总安装;绑定随实现所在模块分发,避免集中在单一大模块。
概念解释
每个 Gradle 模块可声明自己的 @Module @InstallIn,Hilt 在编译期聚合所有模块绑定。实现模块提供接口→实现绑定;第三方实例在数据/平台模块提供。模块间依赖方向与 DI 图一致:上层依赖接口,下层提供绑定。
原理流程
domain:接口定义
data:实现 + Hilt 绑定模块
app:聚合各模块绑定,装配入口
代码或图示
// data 模块
@Module
@InstallIn(SingletonComponent::class)
abstract class DataBindModule {
@Binds abstract fun bindRepo(impl: NoteRepositoryImpl): NoteRepository
}
常见误区
- 所有绑定堆在 app 模块,数据实现模块不可独立替换。
- 接口模块依赖实现模块,架构反向。
追问
- 库模块要带 Hilt 模块吗?答:提供可注入实现的库应自带绑定模块;纯接口模块不提供绑定。
- 多模块绑定如何被发现?答:注解处理器扫描参与编译的所有模块。
07.1.1.10.1-054 @InstallIn 选择组件与模块可见性如何关联?
一句话结论
安装组件决定绑定在哪一层容器可见:装到 Singleton 全局可用,装到子组件仅该层级及子级可访问;模块可见性同时受 Gradle 模块依赖约束。
概念解释
两层可见性:Hilt 组件层级(父子访问方向)与 Gradle 模块依赖(编译可见)。模块装到哪个组件,绑定就在哪层解析;消费模块还必须在 Gradle 上依赖提供方模块。跨层级访问遵循子→父方向,不可反向。
原理流程
InstallIn 组件 → Hilt 容器层级可见性
Gradle dependencies → 编译期类可见性
代码或图示
@Module
@InstallIn(ActivityComponent::class)
object ActivityScopedModule // 仅 Activity 链可用
常见误区
- 以为装到单例模块所有地方都能拿,忽略组件层级限制。
- 提供模块未被消费模块 Gradle 依赖,类不可见。
追问
- 页面级绑定放单例模块会怎样?答:层级提升为全局,可能泄漏与常驻。
- 模块绑定可见性如何审查?答:结合 InstallIn 与 Gradle 依赖图双向核对。
07.1.1.10.1-055 模块在哪个模块声明,绑定才对谁可见?
一句话结论
绑定声明跟随实现所在模块;只要该模块参与编译并被依赖,其 Hilt 模块就进入聚合图;消费方通过接口类型解析,不直接依赖绑定模块内部。
概念解释
Hilt 模块放在实现模块(如 data),app/domain 依赖 data 后编译期聚合绑定。消费方只看到接口,不知道绑定在哪个模块。若绑定模块在未被依赖的独立模块,编译图中不存在该绑定,报缺失。
原理流程
实现模块声明绑定 → 被依赖参与编译 → 聚合进图
消费方按接口类型解析
代码或图示
app → data(含 DataBindModule)
domain 接口 ← data 实现绑定
常见误区
- 绑定模块放在 app 但实现类在 data,模块跨层引用实现。
- 功能模块未被 app 聚合,绑定不进图。
追问
- 库发布后绑定如何随库进入图?答:库模块自带 Hilt 模块,依赖方编译时自动聚合。
- 如何确认绑定被聚合?答:编译期缺失绑定报错;构建产物中检查生成组件。
07.1.1.10.1-056 跨模块依赖注入如何保证模块被聚合?
一句话结论
消费模块在 Gradle 依赖实现模块,Hilt 注解处理器扫描编译 classpath 上所有 Hilt 模块;未依赖的模块绑定不会进入图。
概念解释
聚合不是运行期扫描全部 APK,而是编译期各模块生成的绑定汇总进组件。保证链路:app 依赖各特性/数据模块,模块依赖公共接口模块。新增实现模块后要检查 app 依赖链是否包含,否则绑定缺失。
原理流程
Gradle 依赖链 → 模块参与编译 → Hilt 模块被扫描聚合
代码或图示
// app/build.gradle.kts
dependencies {
implementation(project(":data"))
implementation(project(":domain"))
}
常见误区
- 模块被源码包含但未在依赖链声明,绑定不编译进图。
- 动态特性模块未按 Hilt 动态特性约定接入。
追问
- 多模块重复提供同一绑定?答:编译期报重复绑定,需按模块去重或限定符区分。
- 聚合失败如何定位?答:从缺失类型反查实现模块是否在依赖链。
07.1.1.10.1-057 库模块能否使用 @AndroidEntryPoint?
一句话结论
库模块可包含被注解的组件类,但 Hilt 注入依赖由宿主应用聚合图提供;库自身不能独立拥有完整 Hilt 根容器。
概念解释
特性库模块可定义 @AndroidEntryPoint 的 Activity/Fragment,其注入绑定来自 app 聚合的模块图。库模块不应假定自己提供全部依赖;可通过接口与可选绑定约定。宿主 Application 必须 @HiltAndroidApp 初始化根容器。
原理流程
库模块组件 → 注解注入
绑定由宿主 app 聚合图提供
代码或图示
// feature 库内
@AndroidEntryPoint
class FeatureActivity : AppCompatActivity() {
@Inject lateinit var repo: NoteRepository
}
常见误区
- 库模块自己声明 Application 根容器,与宿主冲突。
- 库直接绑定具体实现,宿主无法替换。
追问
- 库如何暴露可选依赖?答:接口 + 宿主提供绑定;缺失时编译期按约定报错或默认实现。
- 动态特性库接入见后续条目。
07.1.1.10.1-058 多模块绑定重复或冲突如何排查?
一句话结论
编译期报 duplicate/ambiguous binding 时,按绑定类型与限定符定位各模块提供方,去重、合并模块或加限定符区分。
概念解释
重复来源:两个模块 @Binds/@Provides 提供同一类型无区分符;接口与实现绑定重复注册。排查沿报错类型遍历各模块 Hilt 声明,确认哪个是生产绑定。解决:删冗余、统一实现模块、多实现加限定符。
原理流程
报错类型 → 搜索模块提供方法
→ 去重 / 限定符区分 / 合并
代码或图示
NoteRepository 绑定出现在 DataBindModule 与 LegacyModule
→ 移除 LegacyModule 重复绑定
常见误区
- 用 @Named 临时掩盖重复,语义不清。
- 测试模块与生产模块同时提供同一绑定未卸载。
追问
- 缺失绑定与重复绑定报错区别?答:缺失是无提供方;重复是多个提供方无法选择。
- 多模块如何避免约定漂移?答:架构规则统一绑定归属模块,评审检查。
07.1.1.10.1-059 Hilt 模块的聚合方式是什么?
一句话结论
Hilt 通过 @InstallIn 把各模块绑定归入对应组件,编译期所有模块绑定聚合进组件图;可在汇总模块用 @Module(subcomponents=...) 或聚合声明组织分组(按版本能力确认)。
概念解释
聚合机制:注解处理器收集参与编译的模块,按安装组件归组生成组件。模块分组只是代码组织,运行期仍是同一组件图。Hilt 对“聚合模块”的具体注解支持以官方文档为准(待确认);常规项目按层拆模块即可。
原理流程
各模块 @InstallIn 声明 → 按组件归组 → 生成聚合组件图
代码或图示
@Module
@InstallIn(SingletonComponent::class)
object NetworkModule { /* 网络绑定 */ }
常见误区
- 以为运行期动态加载模块绑定;实际绑定在编译图中固定。
- 为分组新增多余聚合模块,增加维护成本。
追问
- 模块化后绑定延迟加载吗?答:单例图随进程初始化;对象惰性创建,模块本身不延迟。
- 聚合与动态特性模块关系?答:动态特性有单独接入约定,不能直接加入常规聚合。
07.1.1.10.1-060 接口在 domain 模块、实现在 data 模块,绑定放哪?
一句话结论
绑定放在 data 模块(实现侧),用 @Binds 把接口映射到实现;domain 模块只定义接口,不依赖 data。
概念解释
依赖倒置:domain 定义契约,data 实现契约并提供绑定。data 模块的 Hilt 模块完成 NoteRepository ← NoteRepositoryImpl。app 同时依赖两边,编译期聚合。domain 不出现 DI 绑定实现细节。
原理流程
domain:interface NoteRepository
data:NoteRepositoryImpl + @Binds 绑定
代码或图示
// data 模块
@Module
@InstallIn(SingletonComponent::class)
abstract class DomainBindModule {
@Binds abstract fun bind(impl: NoteRepositoryImpl): NoteRepository
}
常见误区
- 绑定放 domain 模块并 import data 实现,反向依赖。
- data 直接暴露具体类型给上层,接口分层失效。
追问
- 实现需要第三方依赖构造怎么办?答:data 模块 @Provides 组装,仍在实现侧。
- 测试如何替换?答:测试模块提供接口 Fake 绑定,卸载生产模块。
07.1.1.10.1-061 动态特性模块如何接入 Hilt?
一句话结论
动态特性模块按 Hilt 动态特性约定安装绑定入口,依赖 app 基模块提供的绑定;特性级模块与组件需遵循官方动态特性集成规则(具体 API 以版本为准,待确认)。
概念解释
动态特性按需下载,其 Hilt 绑定不能假设在常规聚合链中。Hilt 对动态特性有专门的组件/模块集成方式;特性内 Activity/Fragment 注入依赖基础模块提供的绑定。接入前核对当前 Hilt 版本对动态特性的支持范围。
原理流程
app 基模块绑定 → 动态特性模块接入约定
特性组件注入基础依赖
代码或图示
动态特性:遵循 Hilt dynamic feature 集成文档
(注解与组件名按版本确认,待确认)
常见误区
- 把特性绑定写进常规 app 模块,失去按需加载意义。
- 特性模块直接依赖实现内部模块,边界混乱。
追问
- 动态特性需要独立组件吗?答:按 Hilt 动态特性方案确认是否有特性级组件。
- 特性缺失绑定报什么?答:编译期缺失绑定,检查特性模块接入与依赖链。
07.1.1.10.1-062 模块依赖方向与 DI 图一致性如何检查?
一句话结论
Gradle 依赖方向应与 DI 绑定方向一致:上层依赖接口,下层提供实现绑定;检查循环依赖、反向引用与作用域层级是否匹配。
概念解释
一致性原则:domain 不依赖 data,data 实现 domain;app 组装两端。DI 图中注入方向从消费方到提供方,与模块依赖同向。检查工具/规则可识别模块循环;评审核对绑定归属与作用域层级。方向倒置会导致编译不可见或架构腐化。
原理流程
Gradle 依赖:app → data → domain
DI 注入:消费方 → 接口 ← 提供方
方向一致,无循环
代码或图示
禁止:domain import data 实现
禁止:data 反向依赖 app 模块
常见误区
- 模块分层与 DI 绑定各写各的,后期反向依赖累积。
- 作用域提升掩盖模块边界问题。
追问
- 发现循环依赖怎么拆?答:抽公共接口/事件模块,打破环;详见 07.1.1.10.2。
- 自动化检查怎么做?答:Gradle 依赖分析 + Lint/架构规则校验。
07.1.1.10.1-063 @HiltAndroidTest 如何配置测试?
一句话结论
instrumentation 测试类标 @HiltAndroidTest,配合 Hilt 测试运行器与 HiltTestApplication,由 Hilt 测试容器注入测试依赖。
概念解释
普通 Android 测试不装配 Hilt 图;@HiltAndroidTest 启用测试版 DI 容器,测试中可替换模块绑定。需要配置测试 Application 与运行器(按工程测试基类约定)。测试注入字段用 @Inject,Fake 绑定通过测试模块提供。
原理流程
@HiltAndroidTest + 测试运行器
→ HiltTestApplication 容器 → 注入 Fake/测试绑定
代码或图示
@HiltAndroidTest
class HomeActivityTest {
@Inject lateinit var fakeRepository: NoteRepository
}
常见误区
- 测试类标了注解但未配测试 Application/运行器,容器不初始化。
- 单元测试(JVM 本地)误用 @HiltAndroidTest。
追问
- 本地 JVM 测试用 Hilt 吗?答:一般手动构造 Fake 或普通 DI;HiltAndroidTest 用于设备/仪器测试。
- 测试基类如何复用配置?答:抽取带运行器与 Application 配置的基类。
07.1.1.10.1-064 HiltTestApplication 是什么?
一句话结论
HiltTestApplication 是 Hilt 提供的测试 Application 容器实现,在 instrumentation 测试中替换生产 Application,装配测试版依赖图。
概念解释
测试 manifest 或运行器指定 HiltTestApplication,使测试进程拥有 Hilt 根容器。它与生产 @HiltAndroidApp Application 角色对应,用于测试环境初始化 DI 图。替换生产 Application 后,测试模块与 @BindValue 绑定才生效。
原理流程
测试进程 → HiltTestApplication
→ 测试 Hilt 容器 → 注入测试绑定
代码或图示
// 测试 manifest 或运行器配置
// android:name="androidx.test.HiltTestApplication"(按工件坐标确认,待确认)
常见误区
- 测试仍用生产 Application,测试模块绑定不生效。
- 自定义测试 Application 未继承/接入 Hilt 测试容器。
追问
- 测试 Application 能提供测试初始化吗?答:可在测试基类/回调中做;容器初始化由 Hilt 管理。
- 与生产 Application 冲突吗?答:测试配置仅作用于测试进程。
07.1.1.10.1-065 @UninstallModules 如何替换生产模块?
一句话结论
测试类上用 @UninstallModules(ProductionModule::class) 移除生产模块,再提供测试模块绑定替换对应实现。
概念解释
生产模块绑定真实仓库/远程客户端;测试需替换为 Fake。卸载生产模块后,安装测试模块提供同类型绑定。卸载按模块粒度,未卸载模块的其他绑定仍保留。注意测试模块提供的类型与限定符要对齐。
原理流程
@UninstallModules(ProdRepoModule::class)
→ @InstallIn 测试模块提供 Fake 绑定
代码或图示
@HiltAndroidTest
@UninstallModules(ProdRepoModule::class)
class RepoTest {
@Inject lateinit var repository: NoteRepository
}
@Module
@InstallIn(SingletonComponent::class)
abstract class FakeRepoModule {
@Binds abstract fun bind(impl: FakeNoteRepository): NoteRepository
}
常见误区
- 只加测试模块不卸载生产模块,造成重复绑定。
- 测试模块遗漏生产模块提供的其他类型,缺失绑定。
追问
- 卸载模块后其单例重建吗?答:测试容器重新装配,替换绑定按测试图创建。
- 部分替换能用 @BindValue 吗?答:简单对象用 @BindValue,整模块替换用卸载+测试模块。
07.1.1.10.1-066 @BindValue 如何在测试中提供绑定?
一句话结论
@BindValue 直接把测试类字段/值绑定进 Hilt 图,适合注入已构造好的 Fake 实例或常量,无需写测试模块方法。
概念解释
测试类中声明 @BindValue @JvmField val fake = FakeRepository(),Hilt 将该值作为对应类型绑定。省去 @Provides 测试模块样板;类型与限定符需与注入点匹配。@BindValue 提供的值在测试容器内复用,便于断言交互。
原理流程
测试字段 @BindValue
→ 绑定进测试图 → 注入点取同一 Fake 实例
代码或图示
@HiltAndroidTest
class HomeViewModelTest {
@BindValue @JvmField
val fakeRepo = FakeNoteRepository()
@Inject lateinit var viewModel: HomeViewModel
}
常见误区
- 字段不是 @JvmField/可见形式,Hilt 无法读取值。
- 类型/限定符与生产注入点不一致,绑定不匹配。
追问
- @BindValue 与测试模块怎么选?答:单实例 Fake 用 BindValue;多绑定、作用域实例用测试模块。
- 绑定值能替换单例吗?答:测试容器内按测试图提供,生产单例不参与测试进程。
07.1.1.10.1-067 测试中替换接口 Fake 实现的完整流程?
一句话结论
定义 Fake 实现接口 → 卸载生产模块或提供测试模块绑定 → 测试类注入接口类型 → 验证 Fake 收到的调用与返回数据。
概念解释
流程闭环:生产图绑定真实实现,测试图绑定 Fake。测试类注入接口,Fake 内部记录调用参数、预置返回。断言仓库/ViewModel 与 Fake 交互正确。需要状态共享时 Fake 暴露查询方法。
原理流程
Fake implements NoteRepository
→ 测试模块 @Binds / @BindValue
→ 测试注入接口 → 断言交互
代码或图示
class FakeNoteRepository : NoteRepository {
val calls = mutableListOf<String>()
override fun observe() = flowOf(emptyList<Note>())
}
常见误区
- Fake 未实现接口全部方法,测试编译失败。
- 测试注入具体实现类,无法替换为 Fake。
追问
- 多个测试共用 Fake 模块?答:抽取测试公共模块,各测试类按需安装。
- Fake 要模拟错误态吗?答:是,预置异常/空列表分支覆盖错误与空态。
07.1.1.10.1-068 测试作用域与生产作用域是否一致?
一句话结论
测试图沿用相同组件与作用域约定,替换的是绑定实现而非作用域规则;@Singleton 测试对象仍在测试容器内复用。
概念解释
Hilt 测试容器按生产组件层级装配,作用域缓存行为一致。替换绑定不改变对象生命周期:单例 Fake 在测试进程内复用,ViewModel 作用域随 ViewModel。测试中不要依赖生产单例跨测试类残留,按测试隔离原则清理。
原理流程
测试容器 = 同组件层级 + 替换绑定
作用域复用规则不变
代码或图示
@Singleton
class FakeNoteRepository @Inject constructor() : NoteRepository
常见误区
- 以为测试替换后所有对象每次新建,作用域缓存仍生效。
- 跨测试类依赖单例 Fake 状态未清理,用例互相污染。
追问
- 测试间如何重置单例?答:按测试框架重建容器/Application,或 Fake 暴露重置方法。
- 作用域错配测试能暴露吗?答:编译期规则同样校验测试图。
07.1.1.10.1-069 Hilt 测试与普通 JUnit/Robolectric 的区别?
一句话结论
Hilt 测试在真实测试容器中装配 DI 图,适合验证注入与替换;纯 JUnit 手动 new 依赖,轻量快速;Robolectric 可在 JVM 模拟 Android 组件,按是否需要 DI 容器选择。
概念解释
单元测试:直接构造 Fake 注入被测类,不启动 Hilt,快且简单。Hilt instrumentation 测试:验证组件注入、模块绑定、作用域与替换链路。Robolectric 配合 Hilt 可在 JVM 跑部分组件流程。选择按测试目标:逻辑用纯 JUnit,DI 装配用 Hilt 测试。
原理流程
纯 JUnit:手动构造依赖
Hilt 测试:容器装配 + 替换绑定
Robolectric:JVM 模拟组件环境
代码或图示
// 纯单元测试
val vm = HomeViewModel(FakeNoteRepository())
常见误区
- 所有测试都走 Hilt 容器,反馈慢、维护重。
- 纯逻辑测试引入 Android 容器,无谓复杂化。
追问
- ViewModel 测试需要 Hilt 吗?答:手动构造 Fake 即可;验证 @HiltViewModel 工厂才用容器测试。
- 测试金字塔如何分层?答:大量纯 JUnit 逻辑测试 + 少量 Hilt/UI 装配测试。
07.1.1.10.1-070 如何在 instrumentation 测试中注入 Fake 仓库?
一句话结论
测试类标 @HiltAndroidTest,提供 Fake 绑定(测试模块或 @BindValue),注入接口类型;启动 Activity/ViewModel 后断言 Fake 交互与界面表现。
概念解释
完整链路:测试图替换仓库绑定 → 注入点拿到 Fake → 操作 UI/调用方法 → Fake 记录入参、预置数据 → 断言状态。需要 Activity 场景用 Hilt 测试规则启动;ViewModel 场景直接注入实例。Fake 状态在每个测试前重置。
原理流程
@HiltAndroidTest → Fake 绑定注入
→ 触发操作 → 断言 Fake.calls / 界面状态
代码或图示
@HiltAndroidTest
class HomeScreenTest {
@BindValue @JvmField val fake = FakeNoteRepository()
@Inject lateinit var viewModel: HomeViewModel
@Test fun rendersNotes() { /* 断言 */ }
}
常见误区
- 测试未重置 Fake 调用记录,上一用例断言残留。
- 注入具体类而非接口,Fake 无法替换。
追问
- UI 测试如何拿到同一 Fake?答:测试容器提供的 Fake 单例/绑定与被测 ViewModel 注入同一实例。
- 失败如何定位是绑定问题还是逻辑问题?答:先检查 Fake 是否被注入、调用是否到达,再看断言数据。
07.1.1.10.1-071 测试模块重复绑定如何避免?
一句话结论
测试替换生产绑定时先卸载对应生产模块,或用 @BindValue 覆盖;同一类型在测试图中只保留一个提供方,避免 duplicate binding。
概念解释
重复来源:生产模块未卸载、测试模块又提供同类型;多个测试模块叠加绑定同一接口。解决:整模块替换用 @UninstallModules,单值替换用 @BindValue,测试模块按类型互斥。测试基类共享绑定要防止子类重复安装。
原理流程
生产绑定 + 测试绑定并存 → 重复
卸载生产模块 / @BindValue 覆盖 → 单一提供方
代码或图示
@UninstallModules(ProdModule::class)
@HiltAndroidTest
class ReplacedTest
常见误区
- 测试模块提供接口绑定,生产模块未卸载,编译报重复。
- 多个测试基类各自安装绑定,叠加后冲突。
追问
- @BindValue 会与生产绑定冲突吗?答:覆盖对应类型;仍需保证图中无第二个同类型提供方。
- 重复绑定报错在测试编译期还是运行期?答:编译期图校验阶段暴露。
07.1.1.10.1-072 多模块测试如何覆盖各层 Fake?
一句话结论
按层提供测试绑定:domain 接口 Fake 在公共测试模块提供,data/network 层 Fake 按模块替换;测试类卸载对应生产模块后注入接口验证。
概念解释
多模块工程中,仓库接口 Fake 供 UI/ViewModel 测试复用;网络层 Fake 供仓库测试替换 API。公共测试模块导出绑定,各测试模块按需安装。层级替换不跨层:测仓库时替换 API,测界面时替换仓库,避免一次替换过多。
原理流程
公共测试模块:接口 Fake 绑定
仓库测试:替换网络 API
界面测试:替换仓库
代码或图示
@Module
@TestInstallIn(components = [SingletonComponent::class], replaces = [ProdModule::class])
abstract class FakeModule { /* 绑定 */ }
常见误区
- 所有层用一个大 Fake 模块,测试定位不到真实失败层。
- 公共测试模块依赖生产实现,失去隔离意义。
追问
- @TestInstallIn 是什么?答:Hilt 测试模块声明替换关系的注解,具体参数以版本为准(待确认)。
- 跨模块 Fake 如何复用?答:放测试公共模块,被各测试实现模块依赖。
07.1.1.10.1-073 Hilt 测试启动慢的原因与缓解?
一句话结论
Hilt 测试要装配完整测试容器、生成/加载绑定图,启动开销高于纯 JUnit;缓解方式是缩小容器范围、分层测试、减少仪器测试数量。
概念解释
慢的来源:测试 Application 初始化、DI 图装配、组件创建与 instrumentation 环境启动。缓解:纯逻辑用纯 JUnit 手动 Fake;Hilt 测试只覆盖装配与替换链路;复用测试基类与容器,避免每个用例重建过重依赖。
原理流程
纯 JUnit:直接 new,最快
Hilt 测试:容器装配,较慢,少量关键用例
代码或图示
测试金字塔:大量 JUnit Fake 注入 + 少量 Hilt/UI 装配测试
常见误区
- 所有 ViewModel/仓库测试都走 Hilt 容器,套件执行时间膨胀。
- Hilt 测试里重复初始化重依赖(数据库、网络)。
追问
- 容器能在测试类间复用吗?答:按测试框架隔离策略;单例状态需主动重置。
- 生成代码影响测试编译速度吗?答:测试模块同样参与注解处理,模块越大编译越慢。
07.1.1.10.1-074 替换绑定后作用域对象是否重建?
一句话结论
测试容器独立装配,替换绑定后按测试图创建对象;生产单例不进入测试进程,测试作用域对象在测试容器内按规则复用。
概念解释
测试与生产是不同容器实例,不存在“替换运行中的生产单例”。测试图中 @Singleton Fake 在该测试容器内唯一;跨测试类是否保留取决于容器是否重建。替换绑定不会改变作用域缓存规则,只改变提供的实现。
原理流程
测试容器新建 → 测试绑定装配
作用域缓存按测试图生效
代码或图示
@Singleton
class FakeRepo @Inject constructor() : NoteRepository
常见误区
- 以为替换绑定后旧生产实例还残留被复用。
- 跨用例依赖 Fake 单例状态未重置,造成污染。
追问
- 如何在测试间重置?答:重建容器或 Fake 暴露 reset();按测试框架生命周期调用。
- 作用域对象资源在测试结束释放吗?答:容器销毁时丢弃;持有的文件/线程需 Fake 自行清理。
07.1.1.10.1-075 测试中如何验证依赖被正确替换?
一句话结论
注入接口类型后断言运行时类型为 Fake,或检查 Fake 记录的调用/预置数据;确认生产实现未被装配进测试图。
概念解释
验证点:注入实例 is FakeXxx、Fake 收到预期调用、返回预置数据。若仍走生产实现,断言网络/数据库交互会暴露。结合卸载模块清单核对,确保被替换类型在测试图中只有 Fake 提供方。
原理流程
注入接口 → 断言类型/调用记录
→ 确认 Fake 行为生效
代码或图示
@Test fun injectsFake() {
assertTrue(repository is FakeNoteRepository)
}
常见误区
- 只断言界面输出,分不清是 Fake 还是生产数据生效。
- Fake 与生产返回相同默认值,替换失败未被发现。
追问
- 如何观察调用是否到达 Fake?答:Fake 内部列表记录方法调用与参数,断言调用次数与入参。
- 替换失败编译期能发现吗?答:重复/缺失绑定编译报错;类型用错但绑定存在时需运行期断言。
07.1.1.10.1-076 Hilt 基于 kapt 还是 KSP?当前状态是什么?
一句话结论
Hilt 可通过 kapt 或 KSP 处理注解;新项目推荐 KSP 以改善编译速度,具体 KSP 支持版本与注解处理器坐标以当前依赖版本为准(待确认)。
概念解释
Hilt 底层依赖 Dagger 注解处理;kapt 走 Java 处理通道,KSP 是 Kotlin 原生通道。KSP 增量编译与速度更优,但需 Hilt/Dagger 版本兼容。工程切换前核对版本矩阵,避免 KSP 版本与 Hilt 不匹配导致生成代码缺失。
原理流程
kapt:Java 注解处理通道
KSP:Kotlin 原生处理,增量更快
代码或图示
// 处理器启用方式按工程构建脚本配置;具体插件坐标待确认
常见误区
- 同时启用 kapt 与 KSP 处理 Hilt,重复生成或冲突。
- 未核对版本兼容就切 KSP,编译期绑定缺失。
追问
- 如何确认工程用的是哪个?答:查看模块构建脚本的插件与注解处理器依赖。
- KSP 支持所有 Dagger 特性吗?答:以官方兼容矩阵为准,受限特性需标注待确认。
07.1.1.10.1-077 KSP 与 kapt 生成代码有什么差异?
一句话结论
两者生成的绑定图语义一致;差异在处理通道、增量编译表现与产物组织方式,运行期注入行为基本相同。
概念解释
kapt 把 Kotlin 编译成 Java 桩再走注解处理,速度较慢;KSP 直接分析 Kotlin 语法树,增量重处理范围更小。生成的组件/工厂类命名与目录按处理器实现组织,版本间可能不同。业务代码不直接依赖产物形态。
原理流程
kapt:Kotlin → Java 桩 → 注解处理
KSP:Kotlin AST → 增量处理 → 生成代码
代码或图示
产物:组件实现、绑定工厂(命名/目录随处理器版本,待确认)
常见误区
- 切换处理器后按旧目录找生成类,定位错误。
- 以为 KSP 改变作用域或注入语义,实际绑定规则不变。
追问
- 生成代码能跨处理器版本稳定引用吗?答:业务代码只依赖注解 API,不引用生成类。
- 增量失效如何排查?答:清理重建后对比生成产物与编译报错。
07.1.1.10.1-078 Hilt 编译期错误常见类型有哪些?
一句话结论
常见类型:缺失绑定、重复/歧义绑定、作用域不匹配、类型不兼容、组件层级越界、EntryPoint/模块安装错误。
概念解释
编译期图校验在注解处理阶段完成:无提供方报缺失;多提供方报重复;作用域与组件错配报层级错误;泛型/返回类型不符报类型不兼容。理解分类后可按报错类型快速定位是模块、限定符还是作用域问题。
原理流程
图校验:提供方存在性 → 唯一性 → 作用域/类型/层级
代码或图示
Missing binding / Duplicate binding / Scope mismatch / Type mismatch
常见误区
- 把所有报错当成“缺少模块”,实际是限定符或作用域问题。
- 忽略 warning 级图提示,运行期才暴露问题。
追问
- 报错信息如何读?答:先看缺失/冲突类型,再沿注入点类型与模块提供方核对。
- 运行期才会失败的场景?答:EntryPoint 配置、反射/动态获取等编译期覆盖不到的路径。
07.1.1.10.1-079 "Cannot provide" / "Missing binding" 如何排查?
一句话结论
沿报错类型找注入点,检查该类型是否有 @Inject 构造或模块绑定、限定符是否一致、模块是否安装到对应组件并参与编译。
概念解释
排查路径:缺失类型 → 类是否可构造注入 → 模块 @Provides/@Binds 是否提供 → 限定符两侧是否匹配 → 模块 InstallIn 组件与 Gradle 依赖是否到位。常见原因:实现未注册、接口绑定漏写、跨模块未依赖、限定符漏标。
原理流程
报错类型 T
→ 构造注入?模块提供?限定符匹配?组件/依赖到位?
代码或图示
// 排查清单:
// 1. class X @Inject constructor(...)
// 2. @Binds/@Provides 提供 X
// 3. @InstallIn 组件正确
// 4. 提供模块被编译依赖
常见误区
- 只在 app 模块找绑定,提供方实际在 data 模块且未被依赖。
- 注入点漏限定符,匹配到无标记类型缺失。
追问
- 第三方类型缺失怎么办?答:模块 @Provides 手写构造并注入所需配置。
- 接口缺失但实存在?答:核对 @Binds 返回类型是否为接口,限定符是否对齐。
07.1.1.10.1-080 作用域不匹配编译错误怎么定位?
一句话结论
报错指向绑定作用域与其安装组件不一致,或子组件引用了父级不可见绑定;核对模块 InstallIn、绑定作用域注解与注入点所属组件。
概念解释
典型错配:@Singleton 绑定装到 ActivityComponent;模块装到子组件却被单例注入点引用;ViewModel 链注入 Activity 作用域对象。定位三要素:绑定声明的作用域、模块安装组件、消费点所在组件层级。
原理流程
绑定 Scope ↔ InstallIn 组件 ↔ 消费点组件
三者层级一致才通过
代码或图示
// 错误:作用域与组件错配
@Module @InstallIn(ActivityComponent::class)
object BadModule {
@Provides @Singleton fun provideX(): X = X()
}
常见误区
- 把页面级对象标 @Singleton 塞进子组件模块。
- 只改报错一侧,未同步另一侧作用域/组件。
追问
- 作用域与组件对应表见哪条?答:见 07.1.1.10.1-008 与 016。
- 运行期能绕过作用域校验吗?答:编译期规则优先;动态 EntryPoint 路径需自行保证层级。
07.1.1.10.1-081 重复绑定(duplicate binding)如何解决?
一句话结论
同一类型多个提供方时:保留一个生产绑定、删除冗余;多实现场景加限定符区分;测试替换先卸载生产模块。
概念解释
重复来源:两个模块提供同类型、@Binds 与 @Provides 并存、测试与生产模块叠加。解决按场景:实现唯一就去重;确需多实现用 Qualifier;测试替换走卸载/替换声明。解决后重新编译确认图中单一提供方。
原理流程
多提供方 → 去重 / Qualifier / 测试卸载
代码或图示
// 多实现区分
@RemoteApi @Binds abstract fun bindRemote(impl: RemoteImpl): Api
@MockApi @Binds abstract fun bindMock(impl: MockImpl): Api
常见误区
- 用 @Named 字符串临时压重复,长期语义不清。
- 误删唯一生产绑定,转为缺失绑定。
追问
- 重复绑定能在运行时选择吗?答:Hilt 编译期要求唯一或限定符区分,不做运行时动态选择。
- 集合多绑定(Set/Map)是重复吗?答:属于多绑定聚合机制,与单类型重复不同(待确认版本支持)。
07.1.1.10.1-082 Hilt 注解处理器配置在 build.gradle 怎么写?
一句话结论
模块应用 Hilt 插件/依赖,并在 annotationProcessor/kapt/ksp 配置中引入 Hilt/Dagger 处理器;具体工件坐标随版本与处理器通道确定(待确认)。
概念解释
配置分三层:Hilt 依赖、注解处理器通道(kapt 或 KSP)、插件应用。处理器负责生成组件代码;缺处理器只引入依赖不会生成绑定。版本基线 Hilt 2.5x、AGP 8.x,切换前核对兼容矩阵。
原理流程
依赖 Hilt → 启用处理器通道 → 处理器生成代码
代码或图示
// 结构示意;具体插件 id 与工件坐标按当前版本核对(待确认)
dependencies {
implementation("androidx.hilt:hilt-common")
// annotationProcessor / kapt / ksp 引入处理器
}
常见误区
- 只加实现依赖未配处理器,编译期不生成注入代码。
- kapt 与 KSP 处理器重复配置。
追问
- 插件与处理器版本要一致吗?答:Hilt、Dagger、KSP/kapt 版本需在兼容矩阵内。
- 多模块每个都要配处理器吗?答:提供绑定的模块需要;纯消费模块按配置约定。
07.1.1.10.1-083 Hilt 生成代码量与编译速度是什么关系?
一句话结论
绑定类、组件工厂越多生成代码量越大,注解处理与编译耗时上升;合理拆分模块、优先 @Binds、减少冗余绑定可控制生成规模。
概念解释
每个可注入类、模块方法、入口组件都参与生成。大模块绑定集中时处理范围大。优化:@Binds 替代 @Provides 减少工厂样板;无作用域轻量对象合理复用;按模块拆分改善增量编译。KSP 通常改善增量表现。
原理流程
绑定数量 → 生成代码量 → 注解处理/编译耗时
代码或图示
@Binds 映射 < @Provides 工厂代码
模块拆分 → 增量重处理范围缩小
常见误区
- 为减少绑定把多类合并成巨型工厂类,可读性下降。
- 忽略生成代码对方法数/包体积的影响评估。
追问
- 如何量化生成规模?答:查看构建产物生成源码目录与编译指标。
- 编译慢优先优化什么?答:先切 KSP、拆模块改善增量,再精简绑定。
07.1.1.10.1-084 Hilt 启动时做了哪些初始化?
一句话结论
启动阶段初始化根 Hilt 容器并装配单例绑定图;单例对象惰性创建,但容器与绑定元数据在 Application 阶段就绪。
概念解释
@HiltAndroidApp 触发根组件初始化;依赖图元数据由生成代码提供。@Singleton 绑定首次注入时构造,非全部启动即创建。数据库、网络客户端等重对象若在启动链被提前引用,会计入启动耗时。
原理流程
Application 启动 → 根容器初始化
→ 单例惰性创建 → 首次注入时实例化
代码或图示
@HiltAndroidApp
class App : Application() // 根容器入口
常见误区
- 以为所有单例在 onCreate 全部构造。
- 在 Application 注入重依赖链,拉长冷启动。
追问
- 容器初始化包含反射吗?答:核心绑定由生成代码解析,非运行期反射扫描。
- 多进程初始化几次?答:每个进程独立初始化根容器。
07.1.1.10.1-085 如何降低 Hilt 对启动耗时的影响?
一句话结论
保持单例惰性创建、避免 Application 提前注入重依赖、按作用域收敛常驻对象、精简启动链上的绑定初始化。
概念解释
优化点:不在 Application 构造数据库/网络/大仓库;需要时由对应页面/任务惰性获取;页面级对象不提升单例;启动阶段只初始化必要组件。Hilt 本身容器开销有限,主要耗时来自被提前拉起的依赖链。
原理流程
重依赖 → 首次使用时惰性创建
启动链只保留必要初始化
代码或图示
// 反例:Application 注入重仓库并立即访问
// 正例:仓库/数据库在首次业务调用时由 Hilt 提供
常见误区
- 把所有单例在 onCreate 预热,启动时间叠加。
- 作用域泛滥,本应页面级的对象全局常驻。
追问
- 如何测量 Hilt 相关启动开销?答:按依赖初始化分段埋点,对比冷启动各阶段耗时。
- 预热有必要吗?答:高频且构造昂贵的对象可评估预热;其余保持惰性。
07.1.1.10.1-086 Hilt 容器在 Application 创建时如何初始化?
一句话结论
@HiltAndroidApp 生成的 Application 逻辑在进程启动时创建根组件,注册单例绑定;后续组件由对应 Android 入口创建时挂接到根容器。
概念解释
根容器是所有子组件的父级;Activity/Fragment/ViewModel/Service 容器在各自入口创建时从根容器解析共享绑定。初始化顺序:Application 根容器 → 入口组件容器 → 作用域对象构造。多进程各自走一遍该流程。
原理流程
Application 创建 → 根容器
入口组件创建 → 子容器挂接 → 解析绑定
代码或图示
SingletonComponent(根)
→ ActivityComponent → Fragment/ViewModelComponent
→ ServiceComponent
常见误区
- 在 Application 构造期访问子组件绑定,层级尚未创建。
- 假设根容器跨进程共享实例。
追问
- 根容器何时销毁?答:进程结束。
- 容器初始化失败表现?答:启动期绑定缺失/初始化异常崩溃,见线上排查条目。
07.1.1.10.1-087 生成的组件类与绑定图在哪里查看?
一句话结论
生成代码位于构建产物的 generated source 目录,可查看组件实现、绑定工厂与入口注入类;业务源码不直接引用这些生成类。
概念解释
按构建工具不同,生成源码目录在模块 build 目录下的 generated 分区。查看生成类可确认绑定映射、作用域缓存与注入路径。目录与命名随处理器版本变化,定位时按模块与类名搜索,不要硬编码路径到业务文档。
原理流程
注解处理 → generated source 目录
→ 组件实现 / 工厂 / 入口辅助类
代码或图示
查看方式:IDE 打开生成源码或构建产物目录搜索组件实现类
常见误区
- 直接修改生成类,下次构建被覆盖。
- 业务代码 import 生成类,耦合处理器产物。
追问
- 找不到生成代码?答:先执行一次构建确认处理器运行;检查 kapt/KSP 配置。
- 如何核对绑定图?答:在生成组件实现中查看构造参数与提供方法。
07.1.1.10.1-088 Hilt 与手动单例/ServiceLocator 如何共存迁移?
一句话结论
新增依赖走 Hilt,遗留手动单例逐步迁移;过渡期仓库/工具类可作为 Hilt 绑定提供给注入链,避免两套来源混用。
概念解释
迁移策略:新代码构造注入;遗留单例在 Hilt 模块中包装提供(@Provides 返回既有单例),逐步把内部依赖改为注入。不要在业务类里同时 new 单例和接收注入,导致来源混乱。迁移按模块/依赖链分批进行。
原理流程
遗留单例 → Hilt 模块包装提供
新代码注入 → 逐步替换内部手动获取
代码或图示
@Provides @Singleton
fun provideLegacy(): LegacyService = LegacyService.getInstance()
常见误区
- 业务类一半注入一半手动 getInstance,测试无法统一替换。
- 一次性全量改造,回归范围过大。
追问
- 手动单例持有的 Context 如何处理?答:包装层使用 applicationContext,避免 Activity 泄漏。
- 迁移顺序怎么排?答:从叶子依赖(工具、客户端)开始,逐步向上替换仓库与入口。
07.1.1.10.1-089 Hilt 依赖图循环依赖如何检测与处理?
一句话结论
构造链 A→B→A 形成循环,编译期/容器解析时暴露循环依赖;处理方式是拆出共享组件、引入接口回调或调整作用域,而非在构造期互相注入。
概念解释
循环来源:两个类构造互相持有;同作用域单例互相注入。编译期 Dagger 可检测部分循环,运行期也可能初始化失败。解法:提取第三方协作对象、一方改为方法参数/回调注入、用事件解耦。设计层减少双向依赖。
原理流程
A(ctor B) ↔ B(ctor A):循环
提取 C / 回调接口 / 方法传参 → 打破环
代码或图示
// 反例:互相构造注入
class A @Inject constructor(val b: B)
class B @Inject constructor(val a: A)
常见误区
- 用懒注入(lazy)掩盖循环,生命周期与初始化顺序更难追踪。
- 循环靠运行期侥幸通过,升级后初始化崩溃。
追问
- Lazy 能解决循环吗?答:可延迟一方实例化,但循环设计仍应消除。
- 循环在多模块如何定位?答:沿构造参数链画依赖图,找回环节点拆分。
07.1.1.10.1-090 @Inject 构造链断裂的常见原因?
一句话结论
断裂指构造参数链上某类型无绑定;常见原因:参数类型未注册、限定符不匹配、第三方类未 Provides、模块未参与编译。
概念解释
注入 A 时递归构造其参数,任一环节缺失即断裂。排查从报错类型沿构造链向上:类是否 @Inject 构造、模块是否提供、限定符/组件/依赖是否到位。链式断裂不一定出现在顶层类,常在深层依赖。
原理流程
顶层注入 → 递归解析构造参数
某环缺失 → 整条链报错
代码或图示
class A @Inject constructor(b: B)
class B @Inject constructor(c: C)
// 若 C 无绑定,报错定位 C,链 A→B→C
常见误区
- 只检查顶层类构造,忽略深层参数绑定。
- 新增实现类后忘记补模块绑定。
追问
- 如何快速画构造链?答:从报错类型回溯模块与构造参数,IDE 查找注入点。
- 抽象参数断裂怎么补?答:模块 @Binds 绑定到具体实现。
07.1.1.10.1-091 Hilt 对第三方 SDK 初始化的注入时机如何安排?
一句话结论
SDK 客户端通过 @Provides 在模块中构造并按需注入;SDK 早期初始化(线程、配置)在启动流程显式执行,Hilt 不替代 SDK 自身初始化时机。
概念解释
区分两件事:SDK 实例注入(DI 提供客户端)与 SDK 初始化(start/init 调用)。重 SDK 在 Application 阶段按要求初始化,客户端对象惰性注入;需要密钥/配置的客户端由模块注入配置构造。初始化顺序与 Hilt 容器初始化顺序对齐验证。
原理流程
启动流程:SDK init()
DI:模块提供 SDK 客户端 → 业务类注入
代码或图示
@Provides @Singleton
fun provideAnalytics(context: Context): Analytics =
Analytics.getInstance(context)
常见误区
- 把 SDK init 放进客户端构造,注入时机不可控。
- 多进程 SDK 初始化重复执行。
追问
- SDK 需要异步初始化怎么办?答:启动任务按需调度,DI 提供句柄/客户端,不阻塞主线程。
- 初始化失败如何兜底?答:模块提供可选包装,业务层处理降级。
07.1.1.10.1-092 作用域对象线程安全由谁保证?
一句话结论
Hilt 只负责提供实例与复用,不保证对象内部线程安全;有状态单例/作用域对象需自身加同步或设计为不可变。
概念解释
单例被多线程/多协程共享,可变状态需自行加锁、并发集合或不可变设计。Hilt 不替绑定对象做并发保护。页面作用域对象通常单线程访问,但跨线程共享状态时同样要处理并发。
原理流程
Hilt:实例复用与生命周期
对象自身:状态并发安全(锁/不可变/并发容器)
代码或图示
@Singleton
class SharedState {
private val mutex = Mutex()
suspend fun update(...) = mutex.withLock { /* 修改 */ }
}
常见误区
- 以为单例天然线程安全,可变集合被并发改写。
- 作用域对象持有非线程安全后端实例被多线程调用。
追问
- 仓库 Flow 状态并发收集安全吗?答:Flow 操作符自身保证流语义;共享可变状态另需防护。
- 如何审查?答:检查单例字段是否可变、访问是否跨线程。
07.1.1.10.1-093 Hilt 配置中的 Gradle 插件与版本基线是什么?
一句话结论
版本基线 Hilt 2.5x、AGP 8.x、Kotlin 2.x;具体插件 id、工件坐标与 KSP 兼容版本以官方发布说明为准,不确定处标「待确认」。
概念解释
工程配置包含 Hilt 依赖、处理器通道与可选插件;版本之间需满足兼容矩阵。AGP/Kotlin/KSP 升级时同步核对 Hilt/Dagger 版本。项目内不固化未确认的具体版本号,避免编造坐标。
原理流程
Hilt 2.5x + AGP 8.x + Kotlin 2.x
处理器:kapt 或 KSP(版本兼容待确认)
代码或图示
版本核对:官方 release notes / 兼容矩阵
常见误区
- 引用过时工件坐标或假设最新特性已可用。
- 升级 Kotlin/AGP 后不同步 Hilt,处理器报错。
追问
- 如何查当前工程版本?答:查看版本目录与模块构建脚本依赖声明。
- 版本不确定怎么标注?答:文档中标「待确认」并写明验证点(插件坐标、KSP 支持范围)。
07.1.1.10.1-094 Hilt 与 Compose 集成有哪些要点?
一句话结论
Compose 中用 hiltViewModel() 获取 @HiltViewModel ViewModel;普通依赖由 ViewModel/仓库注入,Composable 本身不直接做 DI 容器。
概念解释
Hilt 与 Compose 集成入口是 ViewModel 获取函数;Activity 用 @AndroidEntryPoint 标注。Composable 接收 ViewModel 暴露的状态与事件,不在组合函数里构造依赖。导航场景下各屏幕 ViewModel 由 Hilt 工厂创建,依赖来自对应组件。
原理流程
@AndroidEntryPoint Activity → setContent
→ hiltViewModel() 获取 @HiltViewModel
→ Compose 收集状态
代码或图示
@Composable
fun HomeScreen(vm: HomeViewModel = hiltViewModel()) {
val state by vm.uiState.collectAsStateWithLifecycle()
}
常见误区
- 在 Composable 里 new 仓库/ViewModel,绕过注入。
- 把 Activity 作用域对象传入组合函数持有,配置变更后引用问题。
追问
- 跨屏共享 ViewModel 怎么做?答:按作用域在导航层级共享;Hilt 提供对应作用域支持(待确认具体 API)。
- Compose 测试如何注入 Fake?答:测试替换仓库绑定,ViewModel 测试用 Fake 构造或 Hilt 测试容器。
07.1.1.10.1-095 Hilt 与 WorkManager 集成:Worker 如何注入?
一句话结论
通过 Hilt 对 Worker 的集成支持,在 Worker 构造注入依赖;配合 Worker 工厂让系统创建 Worker 时由 Hilt 提供参数。
概念解释
Worker 由 WorkManager 创建,默认不走构造注入。Hilt 集成提供注入式 Worker 工厂/注解支持,构造参数从图解析。依赖应为应用级单例或无状态对象;Worker 实例短生命周期,不持有页面作用域绑定。具体集成注解与工件以版本为准(待确认)。
原理流程
WorkManager 创建 Worker
→ Hilt Worker 工厂解析构造参数
→ Worker 内使用注入依赖
代码或图示
class SyncWorker @Inject constructor(
private val syncRepository: SyncRepository,
appContext: Context,
params: WorkerParameters
) : CoroutineWorker(appContext, params) { /* doWork */ }
常见误区
- Worker 注入 Activity/页面作用域依赖,生命周期不匹配。
- 未配置 Hilt Worker 工厂,系统创建时构造参数缺失。
追问
- Worker 依赖数据库/仓库可以吗?答:应用级单例依赖可以;注入 DAO 经仓库获取。
- 集成 API 版本差异?答:按当前 Hilt/WorkManager 版本文档核对(待确认)。
07.1.1.10.1-096 Hilt 与广播、服务的注入限制有哪些?
一句话结论
Service 可作为注入入口;Receiver/Provider 注入时机与支持范围受限,常需 EntryPoint 手动获取应用级绑定;这些组件不持有页面作用域依赖。
概念解释
ServiceComponent 提供 Service 作用域;Receiver 由系统临时拉起,注入支持按版本变化;Provider 生命周期早,通常手动取根容器绑定。后台组件只能安全访问应用级单例,不能依赖 Activity/Fragment 作用域对象。
原理流程
Service:@AndroidEntryPoint 字段注入
Receiver/Provider:EntryPoint 取应用级绑定
代码或图示
// Receiver 内手动获取
val repo = EntryPointAccessors.fromApplication(context, NoteEntryPoint::class.java).noteRepository()
常见误区
- 后台组件注入页面级对象,容器层级不存在该绑定。
- 在 Receiver 持有注入的长生命周期对象造成泄漏。
追问
- Receiver 能注入 ViewModel 吗?答:不能,ViewModel 绑定界面层级;后台任务用仓库/Worker。
- 版本支持清单在哪核对?答:Hilt 官方组件支持文档(待确认)。
07.1.1.10.1-097 线上如何排查 Hilt 绑定失败崩溃?
一句话结论
崩溃堆栈定位缺失绑定/初始化异常类型,回查模块绑定、限定符、作用域与依赖链;线上先复现构建变体,再对照生成图与模块依赖。
概念解释
线上 Hilt 相关崩溃多为:绑定缺失初始化失败、作用域对象持上下文泄漏、多进程容器问题。排查:抓异常类型与注入点 → 核对对应模块是否打包进变体 → 检查限定符/组件 → 本地复现同样构建变体。多渠道/产品风味可能遗漏模块依赖。
原理流程
崩溃堆栈 → 缺失类型/注入点
→ 核对模块打包、限定符、作用域、依赖链
→ 本地同变体复现修复
代码或图示
排查清单:模块在变体依赖中?限定符两侧一致?作用域层级正确?多进程初始化?
常见误区
- 只在 debug 复现,release 混淆/裁剪导致模块或类丢失。
- 忽略多进程:子进程缺少对应 Application 初始化。
追问
- 混淆会影响 Hilt 生成类吗?答:按 Hilt 混淆规则保留生成代码;裁剪规则需核对官方建议(待确认)。
- 崩溃上报带哪些信息?答:变体、进程名、堆栈、缺失类型与依赖链摘要。
07.1.1.10.1-098 Hilt 相比手写 DI 的编译期保障有哪些?
一句话结论
Hilt/Dagger 在编译期校验绑定存在性、唯一性、类型兼容与作用域层级,缺失与冲突在构建阶段暴露,而非运行期才崩溃。
概念解释
手写 ServiceLocator 运行期才发现没注册依赖;Hilt 编译期生成图并校验:每个注入点可解析、无歧义重复、类型匹配、作用域合法。重构删除实现时,绑定断裂在编译期报错。配合生成代码,运行期解析路径确定。
原理流程
编译期:存在性 + 唯一性 + 类型 + 作用域校验
运行期:按生成图提供实例
代码或图示
手写 DI:运行期 get() 可能为空
Hilt:编译期保证绑定链完整
常见误区
- 以为编译通过就所有路径安全,EntryPoint/反射路径仍需自测。
- 把编译期保障等同于运行期无并发/资源问题。
追问
- 编译期能校验接口实现正确性吗?答:校验类型与绑定关系;业务行为仍靠测试。
- 运行期还有哪些失败面?答:初始化异常、资源关闭、多进程与动态入口路径。
07.1.1.10.1-099 迁移到 Hilt 时有哪些架构红线?
一句话结论
保持依赖方向与模块边界、不在业务类内 new 依赖、不把页面级对象提升单例、不混用两套来源;按层分批迁移并保留可测试接口。
概念解释
红线清单:上层不反向依赖实现模块;注入面向接口;作用域跟随生命周期;遗留单例包装进 Hilt 而非业务自取;测试可替换绑定。迁移中避免一次性大改,每批保证编译图完整与测试通过。页面/后台组件不越界注入短生命周期依赖。
原理流程
接口在上层,实现在下层
注入走 Hilt,来源单一
作用域对齐生命周期,分批迁移
代码或图示
禁止:业务类 getInstance() 混用注入
禁止:domain 依赖 data 实现
常见误区
- 迁移期双来源并存,测试与运行行为不一致。
- 为图省事把仓库全标单例,内存与泄漏风险上升。
追问
- 迁移如何不破坏现有功能?答:叶子依赖先行,包装遗留单例,逐层替换并跑测试。
- 架构红线用什么工具守?答:模块依赖检查、Lint 规则与代码评审。
07.1.1.10.1-100 综合:一个多模块 Hilt 依赖图如何组织与排查?
一句话结论
组织上按层级分模块提供绑定:domain 定义接口,data 提供实现绑定,app 装配入口与根容器;排查沿“注入点 → 绑定提供方 → 限定符 → 作用域组件 → 模块打包”链路逐层定位。
概念解释
完整图:根容器持有单例网络/数据库/仓库;Activity/Fragment/ViewModel 子组件提供页面级绑定;跨模块绑定经 Gradle 依赖链聚合。排查顺序固定:报错类型 → 找注入点 → 找提供模块 → 核对限定符/作用域/组件 → 确认模块参与编译。测试图通过卸载/绑定替换验证隔离性。
原理流程
domain 接口 ← data 实现绑定(@Binds/@Provides)
app 聚合 → 根容器 → 子组件按生命周期提供
排查:注入点 → 提供方 → 限定符 → 作用域 → 打包
代码或图示
app(入口、聚合)
├ domain(接口)
└ data(实现 + Hilt 模块 + 第三方 Provides)
常见误区
- 绑定归属模块与 Gradle 依赖方向不一致,编译不可见。
- 排查跳过限定符与作用域,反复在缺失/重复之间误判。
追问
- 新功能加依赖的标准流程?答:定义接口 → 实现并在所属模块绑定 → 注入点使用 → 编译图校验 → 测试替换。
- 多模块图如何做架构审查?答:按模块导出绑定清单核对方向、作用域与可见性。
参考来源
- Android 官方:Hilt 依赖注入 — 组件、作用域、模块与注入入口。
- Android 官方:测试 Hilt 应用 — @HiltAndroidTest、卸载模块与测试绑定替换。
- Dagger 官方文档 — 绑定、作用域、限定符与编译期校验内核。
- Android 官方:应用架构指南 — 分层架构与依赖方向约定。
- Kotlin Symbol Processing — KSP 注解处理通道与编译增量。
待整理清单
- [ ] 核对工程 Hilt、Dagger、KSP/kapt 的具体版本与兼容矩阵。
- [ ] 确认当前版本 Worker、Receiver、Provider、动态特性模块的 Hilt 集成 API。
- [ ] 核对 @TestInstallIn、多绑定 Set/Map 等特性在所用版本的支持范围。
- [ ] 补充 release 混淆/裁剪对 Hilt 生成类的保留规则。
- [ ] 梳理本项目各模块 Hilt 绑定归属与作用域清单。