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

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 依赖方向不一致,编译不可见。
  • 排查跳过限定符与作用域,反复在缺失/重复之间误判。

追问

  • 新功能加依赖的标准流程?答:定义接口 → 实现并在所属模块绑定 → 注入点使用 → 编译图校验 → 测试替换。
  • 多模块图如何做架构审查?答:按模块导出绑定清单核对方向、作用域与可见性。

参考来源

待整理清单

  • [ ] 核对工程 Hilt、Dagger、KSP/kapt 的具体版本与兼容矩阵。
  • [ ] 确认当前版本 Worker、Receiver、Provider、动态特性模块的 Hilt 集成 API。
  • [ ] 核对 @TestInstallIn、多绑定 Set/Map 等特性在所用版本的支持范围。
  • [ ] 补充 release 混淆/裁剪对 Hilt 生成类的保留规则。
  • [ ] 梳理本项目各模块 Hilt 绑定归属与作用域清单。