Dagger2 系列（四）Dagger2.Android基本原理

前言

上篇文章我们介绍了dagger2.android的如何使用，知其然知其所以然，本篇我们一起来看下，dagger2.android是怎么在dagger2基础上实现注入的。

注意

• 本篇不讲代码生成过程，后续文章介绍。
• 本篇讲解dagger2.android注入原理肯定还是dagger2注入原理，所以请先阅读前3篇文章，了解Provider、Builder 、SubcomponentImpl、MembersInjector等主要类作用。

dagger2和dagger2.android 调用注入的区别

调用区别我们上篇文章已经详细讲到，本篇从调用区别引入原理实现。dagger2中acitivity实现注入代码如下：

private void initInjector() {
      mComponent = getAppComponent()
          .mainActivityComponent()
          .activity(this)
          .build();
}

dagger2.anodriod中acitivity实现注入代码如下：
Application的改造代码：

public class MyApplication extends Application implements HasActivityInjector {

    @Inject
    DispatchingAndroidInjector dispatchingAndroidInjector;

    @Override
    public void onCreate() {
        super.onCreate();
        DaggerMyAppComponent.create().inject(this);
    }
    @Override
    public AndroidInjector activityInjector() {
        return dispatchingAndroidInjector;
    }
}

activity的注入代码

@Override
protected void onCreate(@Nullable Bundle  savedInstanceState) {
        AndroidInjection.inject(this);
        super.onCreate(savedInstanceState);
}

区别为：
dagger2.android的调要先改造了Application，activity里不需要再调用具体的component接口方法。
代码虽有区别,完成任务是一样的。完成：
拿到MainActivityComponent的的实现类，然后实现MainActivity的注入。
我们本篇就是要讲解dagger2.android是怎么完成这个过程的，从代码上看就是，DaggerMyAppComponent.create().inject(this)和 AndroidInjection.inject(this)做了什么。还是以MainActivity注入为例。

dagger2.android 注入原理

DaggerMyAppComponent.create().inject(this)

先给出这行代码作用的结论：

将MainActivityComponent等subComponent的实现类的工厂实例缓存（简单理解方式，实际缓存是工厂实例进一步封装）起来，activity注入时候备用。

两个问题：

• 缓存在哪？
  缓存在Application的dispatchingAndroidInjector中。
• 如何缓存？
  也是通过注入方式缓存。
  带着结论我们开始撸代码，DaggerMyAppComponent.create()方法：

 public static MyAppComponent create() {
    return new Builder().build();
  }
public static final class Builder {
    private Builder() {}

    public MyAppComponent build() {
      return new DaggerMyAppComponent(this);
    }
  }

就是返回了DaggerMyAppComponent实例。DaggerMyAppComponent初始化又做了什么：

 private DaggerMyAppComponent(Builder builder) {
    initialize(builder);
  }
 private void initialize(final Builder builder) {
    this.mainActivitySubcomponentBuilderProvider =
        new Provider<
            AllActivitysModule_ContributeMainActivitytInjector.MainActivitySubcomponent.Builder>() {
          @Override
          public AllActivitysModule_ContributeMainActivitytInjector.MainActivitySubcomponent.Builder
           //待会要回调此处，请注意  
            get() {
            return new MainActivitySubcomponentBuilder();
          }
        };
    this.secondActivitySubcomponentBuilderProvider =
......
  }

实例化了mainActivitySubcomponentBuilderProvider 、secondActivitySubcomponentBuilderProvider 等SubcomponentBuilderProvider ，这里Provider细节不再深入，简单理解为Subcomponent实现类的工厂类。这里完成了Subcomponent实现类的工厂类的实例化，接下来就是把他缓存起来了。
inject()方法源码：

@Override
public void inject(MyApplication application) {
    injectMyApplication(application);
}

private MyApplication injectMyApplication(MyApplication instance) {
    MyApplication_MembersInjector.injectDispatchingAndroidInjector(
        instance, getDispatchingAndroidInjectorOfActivity());
    return instance;
  }
}

代码调用到了MyApplication_MembersInjector的injectDispatchingAndroidInjector方法，第二个参数getDispatchingAndroidInjectorOfActivity（）方法返回的是对上面我初始化的Provider进一步封装后的结果。在dagger2中MembersInjector是真正完成注入的地方，我们看进去为MyApplication注入了什么。

public static void injectDispatchingAndroidInjector(
      MyApplication instance, DispatchingAndroidInjector dispatchingAndroidInjector) {
    instance.dispatchingAndroidInjector = dispatchingAndroidInjector;
}

到这里，真正的我们之前说的：用注入的方式把subComponent的实现类的工厂实例缓存在Application的dispatchingAndroidInjector中。

AndroidInjection.inject(this)

这行代码完成的工作是：

从Application的dispatchingAndroidInjector中获取MainActivityComponent的的实现类实例，然后完成MainActivity的注入。

public static void inject(Activity activity) {
    checkNotNull(activity, "activity");
    Application application = activity.getApplication();
    if (!(application instanceof HasActivityInjector)) {
      throw new RuntimeException(
          String.format(
              "%s does not implement %s",
              application.getClass().getCanonicalName(),
                   HasActivityInjector.class.getCanonicalName()));
    }

AndroidInjector activityInjector =
        ((HasActivityInjector) application).activityInjector();
    checkNotNull(activityInjector, "%s.activityInjector() returned null", application.getClass());

 activityInjector.inject(activity);
  }

代码解释：异常处理，然后得到application的dispatchingAndroidInjector，调用其inject(activity)方法。
继续看到DispatchingAndroidInjector中inject方法：

  @Override
  public void inject(T instance) {
    boolean wasInjected = maybeInject(instance);
    if (!wasInjected) {
      throw new IllegalArgumentException(errorMessageSuggestions(instance));
    }
  }
public boolean maybeInject(T instance) {
    Provider> factoryProvider =
        injectorFactories.get(instance.getClass());
    if (factoryProvider == null) {
      return false;
    }

    @SuppressWarnings("unchecked")
    AndroidInjector.Factory factory = (AndroidInjector.Factory) factoryProvider.get();
    try {
      AndroidInjector injector =
          checkNotNull(
              factory.create(instance), "%s.create(I) should not return null.", factory.getClass());

      injector.inject(instance);
      return true;
    } catch (ClassCastException e) {
      throw new InvalidInjectorBindingException(
          String.format(
              "%s does not implement AndroidInjector.Factory<%s>",
              factory.getClass().getCanonicalName(), instance.getClass().getCanonicalName()),
          e);
    }
  }

代码又调用到maybeInject方法，还是以MainActivity为例，

• 获得MainActivity对应我们之前缓存的Provider
• 调用get方法获得MainActivitySubcomponentBuilder实例factory（参考上面provider实例化的地方get的具体实现）
• 调用MainActivitySubcomponentBuilder的create方法，create方法中又调用到build方法：

@Override
public AllActivitysModule_ContributeMainActivitytInjector.MainActivitySubcomponent build() {
      if (seedInstance == null) {
        throw new IllegalStateException(MainActivity.class.getCanonicalName() + " must be set");
      }
      return new MainActivitySubcomponentImpl(this);
    }
}

最终我终于得到了MainActivitySubcomponent的实现类MainActivitySubcomponentImpl，回到上面主流程中，调用了其inject方法：

@Override
public void inject(MainActivity arg0) {
     injectMainActivity(arg0);
}

private MainActivity injectMainActivity(MainActivity instance) {
      MainActivity_MembersInjector.injectClassName(
          instance, MainActivityModule_ProvideNameFactory.proxyProvideName());
      MainActivity_MembersInjector.injectSp(instance, getSharedPreferences());
      MainActivity_MembersInjector.injectPresenter(instance, getMainPresenter());
      MainActivity_MembersInjector.injectS1(instance, provideStudentProvider.get());
      MainActivity_MembersInjector.injectS2(instance, provideStudentProvider.get());
      return instance;
    }
}

到这里终于调用了各种MembersInjector完成了MainActivity的注入。
最后一句话总结dagger2.android的注入原理：

将MainActivityComponent的实现类的工厂实例（简单理解）缓存起来，MainActivity注入时取出工厂实例，build构建得到MainActivitySubcomponentImpl后，完成MainActivity注入。