Jetpack Hilt 依赖注入框架使用指南

Hilt 没有为 broadcast receivers 提供组件，因为 Hilt 直接从 ApplicationComponent 中注入 broadcast receivers。

Hilt 中组件的生命周期

Hilt 会根据相应的 Android 类生命周期自动创建和销毁组件的实例，对应关系如下：

如何使用 Hilt

1. 添加依赖

// build.gradle (Project level)
buildscript {
    dependencies {
        classpath 'com.google.dagger:hilt-android-gradle-plugin:2.45'
    }
}

// build.gradle (App level)
plugins {
    id 'com.android.application'
    id 'kotlin-kapt'
    id 'dagger.hilt.android.plugin'
}

dependencies {
    implementation 'com.google.dagger:hilt-android:2.45'
    kapt 'com.google.dagger:hilt-android-compiler:2.45'
}

2. 配置 Application

class BaseApplication : Application() {
    override fun onCreate() {
        super.onCreate()
    }
}

在 AndroidManifest.xml 中将 BaseApplication 设置为 application 标签的 name 属性，并添加 @HiltAndroidApp 注解。

使用 Hilt 进行依赖注入

class HiltTest {
    fun hiltTest() {
        Log.e("----------->", "hiltTest")
    }
}

class BaseApplication : Application() {
    @Inject
    lateinit var hiltTest: HiltTest

    override fun onCreate() {
        super.onCreate()
        // 注意：在 Application 中通常不直接调用注入的依赖，除非确保生命周期正确
    }
}

Hilt 在 Android 组件中的使用

• 如果使用 @AndroidEntryPoint 注解 Android 类，还必须注解依赖他的 Android 类；
• 例如：给 Fragment 使用 @AndroidEntryPoint 后，则还需要给 Fragment 依赖的 Activity 添加 @AndroidEntryPoint，否则会出现异常；
• @AndroidEntryPoint 不能写在抽象类上；
• @AndroidEntryPoint 注解仅仅支持 ComponentActivity 的子类，例如 Fragment、AppCompatActivity 等等。

@AndroidEntryPoint
class HomeNavigationActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_home_navigation)
    }
}

@AndroidEntryPoint
class FragmentOne : Fragment() {
    
    // 使用 @Inject 从组件中获取依赖进行注入
    @Inject
    lateinit var hiltTest: HiltTest

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        // 对象已经注入，直接调用即可
        hiltTest.hiltTest()
    }
}

Hilt 和第三方组件的使用

如果需要在项目中注入第三方依赖，可以使用 @Module 注解。使用 @Module 在注解的普通类，在其中创建第三方依赖的对象即可。 使用了 @Module 的类，相当于是一个模块，常用于创建依赖对象（如 OkHttp、Retrofit 等）。 使用 @Module 的类，需要使用 @InstallIn 指定此 module 的范围，会绑定到对应 Android 类的生命周期上。 @Provides，常用于被 @Module 注解标记类的内部方法，并提供依赖项对象。

@Module
@InstallIn(ApplicationComponent::class)
object TestModule {
    
    /**
     * 每次都是新的实例
     */
    @Provides
    fun bindHiltTest(): HiltTest {
        return HiltTest()
    }

    /**
     * 全局复用同一个实例
     */
    @Provides
    @Singleton
    fun bindSingTest(): Test {
        return Test()
    }
}

使用如下：

class SomeClass {
    @Inject
    lateinit var hiltTest: HiltTest

    @Inject
    lateinit var test1: Test

    @Inject
    lateinit var test2: Test
}

其中 bindSingTest 只会被调用一次，@Singleton 相当于是一个单例。

Hilt 和 ViewModel 的使用

使用之前需要在 app.build 下添加对 ViewModel 的支持。

implementation 'androidx.hilt:hilt-lifecycle-viewmodel:1.0.0-alpha03'
kapt 'androidx.hilt:hilt-compiler:1.0.0-alpha03'

• 通过 @ViewModelInject 注解进行构造注入。
• SavedStateHandle 使用 @Assisted 注解。

class HomeContentViewModel(
    private val response: HomeContentRepository,
    @Assisted val state: SavedStateHandle
) : ViewModel() {
    
    private val liveData by lazy { MutableLiveData<String>() }

    val testLiveData: LiveData<String> by lazy { liveData }
    
    fun requestBaiDu() {
        // 模拟网络请求
        liveData.postValue(response.requestBaidu())
    }
}

• 通过 @Inject 进行注入，在 ViewModel 中不需要手动创建其对象。

class HomeContentRepository @Inject constructor() {
    suspend fun requestBaidu(): String {
        return "Response from Baidu"
    }
}

• 获取 ViewModel 的实例。

class HomeContentActivity : AppCompatActivity(){
    // 生成 ViewModel 的实例
    private val viewModel: HomeContentViewModel by viewModels<HomeContentViewModel>()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_home_content)

        viewModel.requestBaiDu()
        viewModel.testLiveData.observe(this) { 
            Toast.makeText(this, it, Toast.LENGTH_SHORT).show()
        }
    }
}

Hilt 和 Room 的使用

这里需要用到 @Module 注解，使用 @Module 注解的普通类，在其中提供 Room 的实例。并且使用 @InstallIn 来声明作用范围。

@InstallIn(ApplicationComponent::class)
object RoomModule {

    /**
     * @Provides：常用于被 @Module 标记类的内部方法，并提供依赖对象
     * @Singleton：提供单例
     */
    @Provides
    @Singleton
    fun provideAppDataBase(application: Application): AppDataBase {
        return Room.databaseBuilder(
            application,
            AppDataBase::class.java,
            "knif.db"
        ).fallbackToDestructiveMigration().build()
    }

    @Provides
    @Singleton
    fun providerUserDao(appDataBase: AppDataBase): UserDao {
        return appDataBase.getUserDao()
    }
}

我们给 providerUserDao 使用了 @Provides 注解和 @Singleton 注解，是为了告诉 Hilt，当使用 UserDao 时需要执行 appDataBase.getUserDao()。 而在调用 appDataBase.getUserDao() 时需要传入 AppDataBase，这时就会调用上面的方法 provideAppDataBase 了，因为这个方法也是用了 @Provides 注解。 并且这两个方法都是单例，只会调用一次。

使用如下：

class SomeFragment : Fragment() {
    @Inject
    lateinit var userDao: UserDao
}

到现在为止，就可以在任意地方获取到 UserDao，并且不用手动创建实例。

使用 @Binds 进行接口注入

Binds：必须注释一个抽象函数，抽象函数的返回值是实现的接口。通过添加具有接口实现类型的唯一参数来指定实现。 首先需要一个接口，和一个实现类。

interface User {
    fun getName(): String
}

class UserImpl : User {
    override fun getName(): String {
        return "345"
    }
}

接着就需要新建一个 Module，用来实现接口的注入。

@InstallIn(ApplicationComponent::class)
abstract class UserModule {
    @Binds
    abstract fun getUser(userImpl: UserImpl): User
}

注意：这个 Module 是抽象的。

使用如下：

class FragmentOne : Fragment() {
    @Inject
    lateinit var user: User
}

使用 @Qualifier 提供同一接口，不同的实现

还是上面的 User 接口，有两个不同的实现，如下：

class UserAImpl : User {
    override fun getName(): String {
        return "345"
    }
}

class UserBImpl : User {
    override fun getName(): String {
        return "Lv"
    }
}

接着定义两个注解。

@Qualifier
annotation class A

@Qualifier
annotation class B

然后修改 Module，在 module 中用来标记相应的依赖。

@InstallIn(ApplicationComponent::class)
abstract class UserAModule {
    @A
    @Singleton
    @Binds
    abstract fun getUserA(userImpl: UserAImpl): User
}

@Module
@InstallIn(ActivityComponent::class)
abstract class UserBModule {
    @B
    @ActivityScoped
    @Binds
    abstract fun getUserB(userImpl: UserBImpl): User
}

这里用了两个不同的 module，并且对应两个不同的 component，一个是 Application，另一个是 Activity。

最后使用如下：

class FragmentOne : Fragment() {
    @A
    @Inject
    lateinit var userA: User

    @B
    @Inject
    lateinit var userB: User
}

遇到的问题

在使用 @AndroidEntryPoint 注解的时候，需要在 Fragment 和 Activity 都使用这个注解。 但是如果 Activity 和 Fragment 没在同一个 Module 中，就会报错。 对于组件化的项目来说，这种情况就比较难受。 主要问题之一是，通过在 Hilt 中发现模块的方式，无法区分哪些模块属于应用中的组件（如果他们确实使用过 Hilt）以及库或其他库中的组件。 另一个问题是，它将预先构建的组件层次结构变得复杂和混乱。就将你的库中所有活动一样，使父级成为 ApplicationComponent 也没有意义，因为你没有将组件放入 Application。 同样，如果一个仅包含片段库并托管在应用程序的活动中，那可能会遇到类似的情况，你希望库片段是独立的，但让 FragmentComponent 对象作为 ActivityComponent 并没有意义。

Hilt 好处

• 降低 Android 开发者使用依赖注入框架的上手成本。
• 内部有一套标准的组件和作用域，对范围进行声明后，只能使用在指定的作用域中使用这个类，并且提供声明周期的管理，会自动释放不在使用的对象，减少资源的过度使用，提供代码的可重用性。
• 使用起来简单，告别繁琐的 new... 这种流程，只需要添加注解即可。提高了代码的可读性，构建简单，耦合变低，容易测试。
• 最大的好处就是管理他们的生命周期，只能在对应的范围内进行使用。感觉非常好。