Dagger 2子组件与组件依赖关系 [英] Dagger 2 subcomponents vs component dependencies

问题描述

Dagger 1的 plus（）方法是我在以前的应用程序中经常使用的方法，因此我了解您可能希望拥有一个对父级具有完全访问权限的子组件的情况图绑定。

Dagger 1's plus() method is something I used quite often in previous applications, so I understand situations where you might want to have a subcomponent with full access to the parent graphs bindings.

在什么情况下使用组件依赖项而不是子组件依赖项为什么？

In what situation would it be beneficial to use a component dependency instead of a subcomponent dependency and why?

推荐答案

组件依赖关系-当要使两个组件保持独立时，请使用此功能。

Component dependencies - Use this when you want to keep two components independent.

子组件-要将两个组件耦合在一起时使用此子组件。

Subcomponents - Use this when you want to keep two components coupled.

我将使用以下示例说明组件依赖项和子组件。值得注意的例子：

I will use the below example to explain Component dependencies and Subcomponents. Some points worth noticing about the example are:

• SomeClassA1 依赖性。 ModuleA 通过 provideSomeClassA1（）提供和 SomeClassA1 的实例。


• SomeClassB1 如果没有 SomeClassA1 ，则无法创建。仅当 SomeClassA1 ModuleB 才能提供 SomeClassB1 的实例。 c>作为参数传递给 provideSomeClassB1（）方法。

• SomeClassA1 can be created without any dependency. ModuleA provides and instance of SomeClassA1 via the provideSomeClassA1() method.
• SomeClassB1 cannot be created without SomeClassA1. ModuleB can provide an instance of SomeClassB1 only if an instance of SomeClassA1 is passed as an argument to provideSomeClassB1() method.

@Module
public class ModuleA {
    @Provides
    public SomeClassA1 provideSomeClassA1() {
        return new SomeClassA1();
    }
}

@Module
public class ModuleB {
    @Provides
    public SomeClassB1 provideSomeClassB1(SomeClassA1 someClassA1) {
        return new SomeClassB1(someClassA1);
    }
}

public class SomeClassA1 {
    public SomeClassA1() {}
}

public class SomeClassB1 {
    private SomeClassA1 someClassA1;

    public SomeClassB1(SomeClassA1 someClassA1) {
        this.someClassA1 = someClassA1;
    }
}

Dagger将负责传递 SomeClassA1 作为 ModuleB 上 provideSomeClassB1（）方法的参数声明 ModuleB 的组件/子组件已初始化。我们需要指导Dagger如何实现依赖关系。可以通过使用组件依赖性或 Subcomponent 来完成。

Dagger will take care of passing the instance of SomeClassA1 as an argument to provideSomeClassB1() method on ModuleB whenever the Component/Subcomponent declaring ModuleB is initialized. We need to instruct Dagger how to fulfill the dependency. This can be done either by using Component dependency or Subcomponent.

请注意下面的组件依赖示例中的以下几点：

Note the following points in the Component dependency example below:

• ComponentB 必须在 @Component 批注上通过 dependencies 方法定义依赖项。


• ComponentA 不需要声明 ModuleB 。这样可以使两个组件保持独立。

• ComponentB has to define the dependency via the dependencies method on @Component annotation.
• ComponentA doesn't need to declare ModuleB. This keeps the two components independent.

public class ComponentDependency {
    @Component(modules = ModuleA.class)
    public interface ComponentA {
        SomeClassA1 someClassA1();
    }

    @Component(modules = ModuleB.class, dependencies = ComponentA.class)
    public interface ComponentB {
        SomeClassB1 someClassB1();
    }

    public static void main(String[] args) {
        ModuleA moduleA = new ModuleA();
        ComponentA componentA = DaggerComponentDependency_ComponentA.builder()
                .moduleA(moduleA)
                .build();

        ModuleB moduleB = new ModuleB();
        ComponentB componentB = DaggerComponentDependency_ComponentB.builder()
                .moduleB(moduleB)
                .componentA(componentA)
                .build();
    }
}

子组件

在SubComponent示例中注意以下几点：

SubComponent

Note the following points in the SubComponent example:

• 作为 ComponentB 尚未定义对 ModuleA 的依赖关系，它不能独立存在。它取决于将提供 ModuleA 的组件。因此，它具有 @Subcomponent 注释。


• ComponentA 已声明 ModuleB 通过接口方法 componentB（）。这使两个组件耦合。实际上，只能通过 ComponentA 初始化 ComponentB 。

• As ComponentB has not defined the dependency on ModuleA, it cannot live independently. It becomes dependent on the component that will provide the ModuleA. Hence it has a @Subcomponent annotation.
• ComponentA has declared ModuleB via the interface method componentB(). This makes the two components coupled. In fact, ComponentB can only be initialized via ComponentA.

public class SubComponent {
    @Component(modules = ModuleA.class)
    public interface ComponentA {
        ComponentB componentB(ModuleB moduleB);
    }

    @Subcomponent(modules = ModuleB.class)
    public interface ComponentB {
        SomeClassB1 someClassB1();
    }

    public static void main(String[] args) {
        ModuleA moduleA = new ModuleA();
        ComponentA componentA = DaggerSubComponent_ComponentA.builder()
                .moduleA(moduleA)
                .build();

        ModuleB moduleB = new ModuleB();
        ComponentB componentB = componentA.componentB(moduleB);
    }
}

这篇关于Dagger 2子组件与组件依赖关系的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！