Dagger 2 完全解析（六），dagger.android 扩展库的使用
source link: http://johnnyshieh.me/posts/dagger-use-of-dagger-dot-android/?amp%3Butm_medium=referral
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
Dagger 2 完全解析（六），dagger.android 扩展库的使用
Dagger 2 完全解析系列：
Dagger 2 完全解析（一），Dagger 2 的基本使用与原理
Dagger 2 完全解析（二），进阶使用 Lazy、Qualifier、Scope 等
Dagger 2 完全解析（三），Component 的组织关系与 SubComponent
Dagger 2 完全解析（四），Android 中使用 Dagger 2
Dagger 2 完全解析（五），Kotlin 中使用 Dagger 2
Dagger 2 完全解析（六），dagger.android 扩展库的使用
本系列文章是基于 Google Dagger 2.11-rc2 版本
在项目中使用了 dagger.android 扩展库后，体验到了其可以简化 Dagger 2 在 Android 项目中的使用，所以该系列的最后一篇文章解析 dagger.android 扩展库的使用及原理。本文以个人写的 Gank 项目 为例，逐步分析 dagger.android 扩展库的使用。
注：本文代码语言为 Kotlin。
1. Gank 项目中原来的 Dagger 2 依赖注入逻辑
Gank 项目中依赖关系比较简单，主要是提供一个单例的 GankService 依赖用于拉取 API 接口。依赖关系图如下：
其中 AppComponent 持有单例的 GankService 依赖，三个 Activity 对应三个 SubComponent 继承自 AppComponent，六个 Fragment 对应六个 SubComponent 继承自 MainActivityComponent。
相应的 Dagger 2 类结构如下：
AppModule 提供 GankService 依赖，ActivityBindModule 定义三个 Activity 对应的 SubComponent 的继承关系，FragemntBindModule 定义六个 Fragment 对应的 SubComponent 的继承关系。
1.1 继承关系的代码实现
继承关系的实现需要：（1）在 parent Component 依赖的 Module 中的subcomponents加上 SubComponent 的 class；（2）在 parent Component 中提供返回 SubComponent.Builder 的接口用以创建 SubComponent。
ActivityBindModule 和 FragemntBindModule 对应上面的第一步，下面看看 AppComponent 和 MainActivityComponent 两个关键 Component 的实现：
@Singleton @Component(modules = [AppModule::class, ActivityBindModule::class]) interface AppComponent { val appContext: Context fun mainActivityComponent(): MainActivityComponent.Builder fun pictureActivityComponent(): PictureActivityComponent.Builder fun searchActivityComponent(): SearchActivityComponent.Builder @ActivityScope @Subcomponent(modules = [FragmentBindModule::class]) interface MainActivityComponent { @Subcomponent.Builder interface Builder { @BindsInstance fun activity(activity: Activity): Builder fun build(): MainActivityComponent fun welfareFragmentComponent(): WelfareFragmentComponent.Builder fun todayGankFragmentComponent(): TodayGankFragmentComponent.Builder fun androidFragmentComponent(): AndroidFragmentComponent.Builder fun iosFragmentComponent(): IOSFragmentComponent.Builder fun frontEndFragmentComponent(): FrontEndFragmentComponent.Builder fun videoFragmentComponent(): VideoFramentComponent.Builder |
1.2 Component 依赖注入的实现
先看 AppComponent 的创建过程：
class GankApp : Application() { lateinit var appComponent: AppComponent override fun onCreate() { super.onCreate() initInjector() private fun initInjector() { appComponent = DaggerAppComponent.builder() .appModule(AppModule(this)) .build() |
再看 SearchActivity 中的注入实现：
class SearchActivity : BaseActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) initInjector() private fun initInjector() { (application as GankApp).appComponent .searchActivityComponent() .activity(this) .build() .inject(this) |
上面的实现有下面几个问题：
每个需要注入依赖的页面 Activity 或 Fragment 都需要创建一个 Component 类。
继承关系中第二步实现，每个 SubComponent 都需要在 parent componenet 声明对应的返回对应的 SubComponent.Builder 的接口
在 Activity 或 Fragment 中注入依赖时，都必须知道其对应的注入器（Component）的类型，这有悖于依赖注入的原则：被注入的类不应该知道依赖注入的任何细节。
2. dagger.android 扩展库的使用
dagger.android 扩展库就是为了解决上述问题而产生的，简化 Dagger 2 在 Android 的使用。
2.1 引入 dagger.android 扩展库
// dagger 2 implementation "com.google.dagger:dagger:$dagger_version" kapt "com.google.dagger:dagger-compiler:$dagger_version" // 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" |
从上面可以看出 dagger.android 扩展库有单独的注解处理器 dagger-android-processor。
2.2 注入 Activity 中的依赖
以 SearchActivity 为例，说明 dagger.android 的使用：
1.在 AppComponent 中安装 AndroidInjectionModule，确保包含四大组件和 Fragment 的注入器类型。
@Singleton @Component(modules = [AppModule::class, AndroidInjectionModule::class]) interface AppComponent { ... } |
2.Activity 对应的 SubComponent 实现 AndroidInjector 接口，对应的 @Subcomponent.Builder 继承 AndroidInjector.Builder。
@ActivityScope @Subcomponent interface SearchActivitySubcomponent : AndroidInjector<SearchActivity> { @Subcomponent.Builder abstract class Builder : AndroidInjector.Builder<SearchActivity>() |
3.在定义 SubComponent 后，添加一个 ActivityBindModule 用来绑定 subcomponent builder，并把该 module 安装到 AppComponent 中。
@Module(subcomponents = [SearchActivitySubcomponent::class]) abstract class ActivityBindModule { @Binds @IntoMap @ActivityKey(SearchActivity::class) abstract fun bindAndroidInjectorFactory( builder: SearchActivitySubcomponent.Builder): AndroidInjector.Factory<out Activity> @Singleton @Component(modules = [AppModule::class, AndroidInjectionModule::class, ActivityBindModule::class]) interface AppComponent { ... } |
如果 SubComponent 和其 Builder 没有其他方法或没有继承其他类型，可以使用 @ContributesAndroidInjector 注解简化第二步和第三步，在一个抽象 Module 中添加一个使用 @ContributesAndroidInjector 注解标记的返回具体的 Activity 类型的抽象方法，还可以在 ContributesAndroidInjector 注解中标明 SubComponent 需要安装的 module。如果 SubComponent 需要作用域，只需要标记在该方法上即可。
@Module abstract class ActivityBindModule { @ActivityScope @ContributesAndroidInjector abstract fun searchActivityInjector(): SearchActivity @Singleton @Component(modules = [AppModule::class, AndroidInjectionModule::class, ActivityBindModule::class]) interface AppComponent { ... } |
4.Application 类实现 HasActivityInjector 接口，并且注入一个 DispatchingAndroidInjector 类型的依赖作为 activityInjector() 方法的返回值。
class GankApp : Application(), HasActivityInjector { @Inject lateinit var dispatchingActivityInjector: DispatchingAndroidInjector<Activity> override fun onCreate() { super.onCreate() DaggerAppComponent.builder() .appModule(AppModule(this)) .build() .inject(this) override fun activityInjector() = dispatchingActivityInjector |
5.最后在 onCreate)() 方法中，在 super.onCreate() 之前调用 AndroidInjection.inject(this)。
class SearchActivity : BaseActivity() { override fun onCreate(savedInstanceState: Bundle?) { AndroidInjection.inject(this) super.onCreate(savedInstanceState) |
使用 dagger.android 后 Activity 对应的 SubComponent 的定义简化如下：
@Module abstract class ActivityBindModule { @ActivityScope @ContributesAndroidInjector(modules = [FragmentBindModule::class]) abstract fun mainActivityInjector(): MainActivity @ActivityScope @ContributesAndroidInjector abstract fun pictureActivityInjector(): PictureActivity @ActivityScope @ContributesAndroidInjector abstract fun searchActivityInjector(): SearchActivity |
其中 @ContributesAndroidInjector 注解可以解决之前的两个问题，不需要手动创建每一个 SubComponent，也不用在 parent componenet 声明对应的返回对应的 SubComponent.Builder 的接口，以后添加 SubComponent 只需要添加一个 ContributesAndroidInjector 抽象方法。
然后使用AndroidInjection.inject(this) 来简化注入依赖的过程，隐藏注入依赖的细节。
注入 Fragment 和其他三大组件也是类似，只是 ContributesAndroidInjector 抽象方法的返回值变了，HasActivityInjector 接口换做 HasFragmentInjector 等接口。
3. dagger.android 扩展库的原理
3.1 @ContributesAndroidInjector 原理
在上面使用 dagger.android 扩展库注入 Activity 中依赖时，其中第二步定义 SubComponent 和第三步添加一个 SubComponent.Builder 的绑定到 Map 中，这两步可以用 ContributesAndroidInjector 抽象方法简化。其实只是 dagger.android 的注解处理器根据 ContributesAndroidInjector 抽象方法在编译时完成了这两步的代码，编译完后的代码逻辑其实是一样。
看上面 SearchActivity 的例子，ContributesAndroidInjector 抽象方法为：
@Module abstract class ActivityBindModule { @ActivityScope @ContributesAndroidInjector abstract fun searchActivityInjector(): SearchActivity |
在编译后会生成一个 ActivityBindModule_SearchActivityInjector 类：
@Module(subcomponents = ActivityBindModule_SearchActivityInjector.SearchActivitySubcomponent.class) public abstract class ActivityBindModule_SearchActivityInjector { private ActivityBindModule_SearchActivityInjector() {} @Binds @IntoMap @ActivityKey(SearchActivity.class) abstract AndroidInjector.Factory<? extends Activity> bindAndroidInjectorFactory( SearchActivitySubcomponent.Builder builder); // 第三步添加一个 SubComponent.Builder 的绑定到 Map 中 @Subcomponent @ActivityScope public interface SearchActivitySubcomponent extends AndroidInjector<SearchActivity> { // 第二步定义 SubComponent @Subcomponent.Builder abstract class Builder extends AndroidInjector.Builder<SearchActivity> {} |
所以 @ContributesAndroidInjector 原理是利用注解处理器减少手动 coding 的代码量。
3.2 AndroidInjection.inject(this) 的原理
dagger.android 扩展库可以使用一行代码AndroidInjection.inject(this)完成依赖注入的过程，这背后是如何实现的呢？
先看该方法的关键源码：
public static void inject(Activity activity) { // 调用 application 的 activityInjector() 方法获取到 dispatchingActivityInjector 对象 AndroidInjector<Activity> activityInjector = ((HasActivityInjector) application).activityInjector(); // 使用 dispatchingActivityInjector 对象注入 activity 所需的依赖 activityInjector.inject(activity); |
接着看 DispatchingAndroidInjector 的 inject() 方法的逻辑：
public final class DispatchingAndroidInjector<T> implements AndroidInjector<T> { private final Map<Class<? extends T>, Provider<AndroidInjector.Factory<? extends T>>> injectorFactories; @Inject DispatchingAndroidInjector( Map<Class<? extends T>, Provider<AndroidInjector.Factory<? extends T>>> injectorFactories) { this.injectorFactories = injectorFactories; @Override public void inject(T instance) { // 在 maybeInject 中完成注入 boolean wasInjected = maybeInject(instance); if (!wasInjected) { throw new IllegalArgumentException(errorMessageSuggestions(instance)); public boolean maybeInject(T instance) { // 根据 activity 的类型获取到对应的 AndroidInjector.Factory 的 Provider， // 其实就是 SubComponent.Builder，因为第二步中定义的 SubComponent.Builder 继承了 AndroidInjector.Factory Provider<AndroidInjector.Factory<? extends T>> factoryProvider = injectorFactories.get(instance.getClass()); if (factoryProvider == null) { return false; @SuppressWarnings("unchecked") AndroidInjector.Factory<T> factory = (AndroidInjector.Factory<T>) factoryProvider.get(); // 获取到 AndroidInjector.Factory // 根据 AndroidInjector.Factory 创建 AndroidInjector，即创建 SubComponent AndroidInjector<T> injector = checkNotNull( factory.create(instance), "%s.create(I) should not return null.", factory.getClass().getCanonicalName()); injector.inject(instance); return true; } catch (ClassCastException e) { |
上面的逻辑简单的来说就是根据 activity 的类型获取相应的 SubComponent.Builder，然后创建其 SubComponent，最后使用 SubComponent 完成依赖注入工作。
现在再回过头来看第三步添加一个 SubComponent.Builder 的绑定到 Map 中，是添加到 AndroidInjectionModule 的 multibinging 中。
@Module public abstract class AndroidInjectionModule { @Multibinds abstract Map<Class<? extends Activity>, AndroidInjector.Factory<? extends Activity>> activityInjectorFactories(); |
然后才能实现 DispatchingAndroidInjector 的注入过程，Application 需要实现 HasActivityInjector 接口，也是为了方便获取 dispatchingActivityInjector 对象，这样就隐藏了注入器的类型，通过 Activity 的类型获取对应的 SubComponent 完成注入。
dagger.android 扩展库可以极大地简化在 Android 项目中使用 Dagger 2 的过程，但是还是有些限制，SubComponent.Builder 不能自定义 @BindsInstance 方法，SubCompoennt 的 Module 不能有含参数的构造函数，否则AndroidInjection.inject(this)在创建 SubComponent 时无法成功。
在使用过 dagger.android 扩展库一段时间后，个人认为其设计非常优雅，简化了 SubComponent 的定义过程和依赖注入的过程，使得开发者可以专注于 Module 管理依赖对象，所以建议大家在 Android 项目中使用。
最后 Dagger 2 系列文章也到此结束了（Dagger 2 关于单元测试的部分放到 Kotlin 下单元测试的系列中），希望对大家有所帮助。
参考资料：
Recommend
About Joyk
Aggregate valuable and interesting links.
Joyk means Joy of geeK