Dagger 2 完全解析(六),dagger.android 扩展库的使用

2018-02-27 11:18:33来源:https://www.jianshu.com/p/8060a260488d作者:JohnnyShieh人点击

分享


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 接口。依赖关系图如下:




gank_dependency.jpg

其中 AppComponent 持有单例的 GankService 依赖,三个 Activity 对应三个 SubComponent 继承自 AppComponent,六个 Fragment 对应六个 SubComponent 继承自 MainActivityComponent。


相应的 Dagger 2 类结构如下:




gank_di_toc.png

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<XXActivity> 接口,对应的 @Subcomponent.Builder 继承 AndroidInjector.Builder<XXActivity>。


@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<Activity> 类型的依赖作为 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
try {
// 根据 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<Activity> 的注入过程,Application 需要实现 HasActivityInjector 接口,也是为了方便获取 dispatchingActivityInjector 对象,这样就隐藏了注入器的类型,通过 Activity 的类型获取对应的 SubComponent 完成注入。


4. 总结

dagger.android 扩展库可以极大地简化在 Android 项目中使用 Dagger 2 的过程,但是还是有些限制,SubComponent.Builder 不能自定义 @BindsInstance 方法,SubCompoennt 的 Module 不能有含参数的构造函数,否则AndroidInjection.inject(this)在创建 SubComponent 时无法成功。


在使用过 dagger.android 扩展库一段时间后,个人认为其设计非常优雅,简化了 SubComponent 的定义过程和依赖注入的过程,使得开发者可以专注于 Module 管理依赖对象,所以建议大家在 Android 项目中使用。


最后 Dagger 2 系列文章也到此结束了(Dagger 2 关于单元测试的部分放到 Kotlin 下单元测试的系列中),希望对大家有所帮助。


参考资料:


Dagger 2 官网的 Dagger & Android 文档


Dagger 2 官网的 Multibindings 文档









最新文章

123

最新摄影

闪念基因

微信扫一扫

第七城市微信公众平台