Dagger 2：向父组件添加子组件

Question

Dagger 2：向父组件添加子组件

5

大家好，我在理解Dagger 2新的添加子组件方法（在Dagger 2.7中添加）方面遇到了问题。请看下面的示例：

@Component(modules = {AppModule.class, MainActivityBinder.class})
@Singleton
interface AppComponent
{
   inject(MyApplication _)
}

@Subcomponent(modules = ActivityModule.class)
interface ActivitySubcomponent
{
   inject(MainActivity _)

   @Subcomponent.Builder
   interface Builder
   {
      @BindInstance
      Builder activity(Activity activity)

      ActivitySubcomponent build();
   }
}

首先，我有一个名为AppComponent的根组件，它提供单例（如retrofit、okhttp等）给AppModule。在ActivitySubcomponent中，我提供了ActivityModule，其中包含特定于该活动的依赖项。现在，子组件必须添加到AppComponent中，因此我创建了一个指定模块MainActivityBinder，它具有注释@ Module.subcomponents并指向绑定子组件的点，但我遇到了第一个问题：该绑定模块的主体应该是什么？

@Module(subcomponents = ActivitySubcomponent.class)
public class MainActivityBinder
{
  //what body of this class should be ??
}

我知道，这个想法是我可以绑定子组件或它们的构建器。第二个问题是什么时候绑定构建器，什么时候绑定子组件？例如，我的ActivitySubcomponent需要活动上下文，所以我创建了一个构建器，在这种情况下，最好在MainActivityBinder中提供一个构建器吗？第三个问题是如何调用组件构建器以及如何获取应用程序组件的子组件？在标准子组件工厂中，我添加了一个方法到AppComponent，返回子组件，我可以定义参数（例如给出活动上下文，如下所示）

@Component(modules = {AppModule.class})
@Singleton
interface AppComponent
{
   ActivitySubcomponents newActivitySubcomponents(Activity activity);

   inject(MyApplication _);
}

// in MainActivity
appComponent.newActivitySubcomponents(this).build().inject(this);

所以在新的子组件中添加方法来实现这种行为？

- Heroes84

1

为什么不使用dagger-android？有更简单的选择。 - Zuluft

3

@Zuluft您的建议不是主题，我的目标是理解Module.subcomponents，我读到的文档说：“使用Module.subcomponents更好，因为它允许Dagger检测是否请求了子组件。通过父组件上的方法安装子组件是对该组件的明确请求，即使该方法从未被调用。”，因此我想尝试测试新方法的工作原理，但我无法正确定义绑定模块。 - Heroes84

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Jeff Bowman · Accepted Answer

Your module MainActivityBinder is allowed to be empty, and should be if you don't have anything else to bind with it. Empty (annotation-only) modules are also useful when you only use Module.includes, such as when you want to keep a module list in one place rather than duplicating it among several components. The subcomponents attribute on the annotation is enough for Dagger to understand what you're trying to do.
You can inject a FooSubcomponent or Provider if and only if it has no @BindsInstance methods or instantiable modules (that Dagger can't instantiate). If all of your modules are interfaces, abstract classes, or modules that have public zero-arg constructors, then you may inject the subcomponent directly. Otherwise you should inject your subcomponent builder instead.

You can get to your subcomponent builder by creating a method that returns it on your AppComponent, just as you can for any binding that exists in the graph:

@Component(modules = {AppModule.class, MainActivityBinder.class})
@Singleton
interface AppComponent {
  ActivitySubcomponent.Builder activitySubcomponentBuilder();

  inject(MyApplication _)
}

You may also inject it into the object of your choice.

@Inject ActivitySubcomponent.Builder activitySubComponentBuilder;
activitySubComponentBuilder.activity(this).build().inject(this);

// You can also inject a Provider<ActivitySubcomponent.Builder> if you want,
// which is a good idea if you are injecting this directly into your Application.
// Your Application will outlive your Activity, and may need to inject several
// instances of the Activity across application lifetime.
@Inject Provider<ActivitySubcomponent.Builder> activitySubComponentBuilderProvider;
activitySubComponentBuilderProvider.get().activity(this).build().inject(this);

尽管注入子组件构建器与在组件上调用方法（返回Builder或返回子组件）没有太大的优势，但注入构建器有几个优点：

Dagger无法判断您是否调用了组件上的方法，因此即使您的子组件未被使用，它仍会生成和编译代码。Dagger可以判断您是否尝试注入构建器，因此如果没有子组件/构建器注入和没有方法，则Dagger将跳过生成子组件的代码。
如果您的代码库足够大，需要将其拆分成不同的目标进行编译，则工厂方法技术可能会在某些依赖循环中捕获到您的应用程序组件和模块依赖于所有内容，并且您只能从组件本身访问子组件。通过可注入的子组件构建器，您可以更多地选择如何访问子组件或构建器。