使用 DispatchingAndroidInjector<> 和其他 dagger.android 类有哪些优点？

我正在努力将 Dagger 2 设置到我的 android 项目中。这是我第一次使用这个框架，到目前为止一切都很顺利。但是我在项目中设置这个框架的方式上看到了不同的方法，我想知道哪一个更好，因为我比较了这两种方法，对我来说结果是一样的。

我遵循了这个指南：https://github.com/codepath/android_guides/wiki/Dependency-Injection-with-Dagger-2 https://github.com/codepath/android_guides/wiki/Dependency-Injection-with-Dagger-2

上网查了一下，都是采用这种方式。 它使用@Module和@Component来定义依赖项。

你的应用程序最终会像这样：

public class MyApp extends Application {

    private NetComponent mNetComponent;

    @Override
    public void onCreate() {
        super.onCreate();

        // Dagger%COMPONENT_NAME%
        mNetComponent = DaggerNetComponent.builder()
                // list of modules that are part of this component need to be created here too
                .appModule(new AppModule(this)) // This also corresponds to the name of your module: %component_name%Module
                .netModule(new NetModule("https://api.github.com"))
                .build();

        // If a Dagger 2 component does not have any constructor arguments for any of its modules,
        // then we can use .create() as a shortcut instead:
        //  mNetComponent = com.codepath.dagger.components.DaggerNetComponent.create();
    }

    public NetComponent getNetComponent() {
       return mNetComponent;
    }
}

但我找到了另一种方法（我没有测试过）：https://google.github.io/dagger/android.html https://google.github.io/dagger/android.html它看起来完全不同，使用不同的类和注释。 它使用这样的东西：

@Subcomponent(modules = ...)
 public interface YourActivitySubcomponent extends AndroidInjector<YourActivity> {
   @Subcomponent.Builder
   public abstract class Builder extends AndroidInjector.Builder<YourActivity> {}
 }

@Module(subcomponents = YourActivitySubcomponent.class)
 abstract class YourActivityModule {
   @Binds
   @IntoMap
   @ActivityKey(YourActivity.class)
   abstract AndroidInjector.Factory<? extends Activity>
       bindYourActivityInjectorFactory(YourActivitySubcomponent.Builder builder);
 }

 @Component(modules = {..., YourActivityModule.class})
 interface YourApplicationComponent {}

public class YourApplication extends Application implements HasDispatchingActivityInjector {
   @Inject DispatchingAndroidInjector<Activity> dispatchingActivityInjector;

   @Override
   public void onCreate() {
     super.onCreate();
     DaggerYourApplicationComponent.create()
         .inject(this);
   }

   @Override
   public DispatchingAndroidInjector<Activity> activityInjector() {
     return dispatchingActivityInjector;
   }
 }

所以，我的问题是：

1. 哪一个更好？

2. 选择一种方法而不是另一种方法的原因是什么？

现在官方规定了 Android 版 Dagger 2 的设置方法Dagger 2 文档 https://google.github.io/dagger/android.html有很多优点，应该是首选。优点就是那里阐述的那些，即：

1. 复制粘贴代码使得以后重构变得困难。随着越来越多的开发人员复制粘贴该块，很少有人知道它实际上做了什么。

2. 更根本的是，它需要请求注入的类型（FrombulationActivity）来了解其注入器。即使这是通过接口而不是具体类型完成的，它也打破了依赖注入的核心原则：类不应该知道它是如何注入的。

让我们将这些原因应用到您的第一个示例中。

Reason 1

假设我们有一个 Activity 想要使用您的NetComponent。我们就这样称呼它吧NetActivity. The onCreate(Bundle savedInstanceState)那个方法NetActivity看起来像这样：

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ((MyApp) getApplicationContext()).getNetComponent().inject(this);
}

该代码具有散落在燕麦片上的脚趾甲剪下的所有视觉吸引力（不是我的比喻），并且最终将复制粘贴到您使用的所有注射部位活动中NetComponent。如果您使用更复杂的组件，例如文档中的这个示例：

@Override
public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  // DO THIS FIRST. Otherwise frombulator might be null!
  ((SomeApplicationBaseType) getContext().getApplicationContext())
     .getApplicationComponent()
     .newActivityComponentBuilder()
     .activity(this)
     .build()
     .inject(this);
 // ... now you can write the exciting code

}

更糟。它很容易退化为一段神奇的代码，必须在整个注入站点中复制并粘贴。如果发生变化，很容易忘记只更新一个网站，从而导致应用程序崩溃。

Reason 2

依赖项注入的一大优点是注入站点不需要知道或关心它们的注入器，就像依赖项不知道或关心它们的依赖项一样。回到我们的NetActivity， 我们有：

((MyApp) getApplicationContext()).getNetComponent().inject(this);

活动“知道”它的注入器（NetComponent），并且 Activity 现在与具体结合在一起MyApp和方法getNetComponent()来自同一个。如果这些类别中的任何一个发生变化，NetActivity也必须改变。

在 Dagger 版本 2.10 及更高版本中遵循 Activity 和 Fragment 内新注入方式的优点与这些缺点正好相反：

1. 您最终会得到更少的复制粘贴代码
2. 请求注入的类型不再需要知道或关心它们的注入器或其注入器的来源。

此外，正如指出的这个博客 https://medium.com/azimolabs/dagger-2-on-production-reducing-methods-count-5a13ff671e30#.p0au1nwnm，优先使用子组件而不是依赖组件可以减少应用程序的方法数量。

虽然使用子组件最初可能看起来更困难，但有一些明显的优点。然而，出于学习 Dagger 的目的，依赖组件最初可能更容易理解。如果第二个示例一开始太复杂，当您掌握了技巧后，您可以逐步采用首选方法。