Dagger 2 完全解析（六），dagger.android 扩展库的使用

关注

转载最新推荐文章于 2026-01-24 23:51:38 发布 703 阅读 AI 写同款· GEO 优化 ›

Android Dagger2快速入门篇一、什么是Dagger2 Dagger2是编译时依赖注入框架，也就是说，这个框架解决的问题是，在编译阶段动态生成依赖注入代码，有别于其他依赖注入框架是利用反射或者运行时再动态生成字节码。二、什么是依赖注入通俗点解释就是，a依赖b，但a不控制b的创建和销毁，仅使用b，那么b的控制权交给a之外处理，... 阅读详情

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 下单元测试的系列中），希望对大家有所帮助。

参考资料：

作者：JohnnyShieh
链接：https://www.jianshu.com/p/8060a260488d
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

收录于