Dagger2 in Android（四）.android 扩展库

系列文章

• Dagger2 in Android（一）通俗基础
• Dagger2 in Android（二）进阶
• Dagger2 in Android（三）Scope与生命周期
• Dagger2 in Android（四）.android 扩展库

问题

在以前咱们讨论过，Dagger 在 Android 上广泛的结构是：定义一个全局的 AppComponent，其余组件依赖或继承它。假设如今有 AppComponent 与 ActivityComponent 两个，他们多是这样编写的：

@Module(subcomponents = [ActivityComponent::class])
class AppModule(val context: Context) {

    @Provides
    @Singleton
    fun provideContext() = context
}

@Component(modules = [AppModule::class])
@Singleton
interface AppComponent {
	fun inject(app: MyApplication)
	
	fun activityComponent(): ActivityComponent.Builder
}
复制代码

@Module
class ActivityModule {
    @Provides
    fun provideSp(context: Context) =
            context.getSharedPreferences("Cooker", Context.MODE_PRIVATE)
}

@SubComponent(modules = [ActivityModule::class])
interface ActivityComponent {
	
	fun inject(activity: MainActivity)

	@Subcomponent.Builder
	interface Builder {
		fun build(): ActivityComponent
	}
}
复制代码

上面定义了这两个 Component 而且他们是包含关系。而后咱们必须在 Appliction 中实例化 AppComponent 来保证单例：

class MyApplication: Application {
    lateinit var component: AppComponent
    override fun onCreate() {
        super.onCreate();
        component = DaggerAppComponent.builder().appModule(AppModule(this)).build();
    }
}
复制代码

最后若是要在 Activity 中使用注入咱们得这样写：

class MainAty : AppCompatActivity() {
    @Inject
    lateinit var sp: SharedPreferences

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
		(application as MyApplication).component
			.activityComponent()
			.build()
			.inject(this)
}
复制代码

这种作法有下面两个问题：

• 每一个 Activity 都必须建立一个 Component 实例。这些代码是重复的，会被复制粘贴到不少 Activity。这将很难重构，并且随着时间的推移，甚至都没人知道这段代码到底是干什么的，成为传说中的「祖传代码」。
• Activity 必须知道它所需的 Component 类型，这有悖于原则：被注入的类不该该关心依赖注入的细节。

解决

本节主要来源于 Dagger 官方文档。

Dagger.android 是一个 Dagger 扩展库，用于解决上面问题，让 Dagger 在 Android 上面的使用更加顺畅。要使用 Dagger.android，首先须要引入，在第一节已经讨论过这个问题了，须要额外依赖下面三个东西：

implementation "com.google.dagger:dagger-android:$dagger_version"
implementation "com.google.dagger:dagger-android-support:$dagger_version"
kapt "com.google.dagger:dagger-android-processor:$dagger_version"
复制代码

这里以向 MainActivity 中注入对象为例，看看 .android 扩展库如何简化使用。

1. 首先须要在 AppComponent 中安装扩展库提供的 AndroidInjectionModule，这个 Module 提供了对 Android 系统组件的建立支持。例如 Activity、Fragment 等。

@Component(modules = [AppModule::class, AndroidInjectionModule::class]) // 注意这行
@Singleton
interface AppComponent {

    fun activityComponent(): ActivityComponent.Builder
}
复制代码

2. 让 Activity 所需的子 Component 实现 AndroidInjector<Activity> 接口。而且其 Builder 继承 AndroidInjector.Factory。（Builder 已经被标注为弃用）

@SubComponent(modules = [ActivityModule::class])
interface ActivityComponent : AndroidInjector<MainActivity> {

	@Subcomponent.Factory
	interface Factory : AndroidInjector.Factory<MainActivity> {} // 注意这里不用再写 build() 方法了
}
复制代码

3. 新建立一个 Module，来绑定 Subcomponent 的 Factory，并把它添加到 AppComponent 中。

@Module(subcomponents = [ActivityComponent::class])
abstract class ActivityBindModule {
    @Binds
    @IntoMap
    @ClassKey(MainAty::class)
    abstract fun bindMainAtyInjectorFactory( factory: ActivityComponent.Factory): AndroidInjector.Factory<*>
}

@Component(modules = [AppModule::class, AndroidInjectionModule::class, ActivityBindModule::class]) // 注意这行
@Singleton
interface AppComponent {

    fun activityComponent(): ActivityComponent.Builder
}
复制代码

提示：

若是子 Component 以及其 Factory(Builder) 没有其余函数，或继承除了步骤2所提到的以外的类，那么能够用注解 @ContributesAndroidInjector 来简化#2#3两步。

只需在 Module 里添加一个抽象方法，返回对应的 Activity 类型，而后用 @ContributesAndroidInjector 来注解它，并指定要加入子 Component 的模块。若是子 Component 拥有 Scope，那么将对应的 Scope 注解也应用到这个抽象方法。

@Module(subcomponents = [LocalWatchFaceComponent::class])
abstract class ActivityBindModule {

    @ActivityScope
    @ContributesAndroidInjector(modules = [ActivityModule::class])
    abstract fun activityInjector(): MainAty
}

// 别忘记加入 AppComponent 当中了
复制代码

提示：

若有多个 Activity 能够写入同一个 Bind 抽象类中，不必分别写一个。

4. 让 Application 类实现 HasActivityInjector 接口，而且注入一个 DispatchingAndroidInjector<Activity> 类型的依赖做为 activityInjector() 函数的返回值。

class MyApplication: Application, HasActivityInjector {
	@Inject
    lateinit var dispatchingActivityInjector: DispatchingAndroidInjector<Activity>
	
	override fun activityInjector() = dispatchingActivityInjector
	
    lateinit var component: AppComponent
    override fun onCreate() {
        super.onCreate();
        component = DaggerAppComponent.builder().appModule(AppModule(this)).build();
    }
}
复制代码

5. 最后在 Activity 的 onCreate() 方法中，super.onCreate() 以前，调用 AndroidInjection.inject(this) 便可。

class MainAty : AppCompatActivity() {
    @Inject
    lateinit var sp: SharedPreferences

    override fun onCreate(savedInstanceState: Bundle?) {
		AndroidInjection.inject(this) // <----
        super.onCreate(savedInstanceState)
}
复制代码

这样 Activity 中的注入被大大简化了，并且 Activity 再也不须要知道 Component 的细节。