dagger2 : 组件依赖(Component)和子组件(Subcomponent)的区别

example 依赖

  • SomeClassB1依赖SomeClassA1。provideSomeClassB1 方法显示了它们之间的依赖关系。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@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;
    }
}

example 组件依赖

  • SomeClassB1依赖SomeClassA1。 ComponentB需要显式声明依赖， ComponentA不需要声明ModuleB。
  • 组件依赖保持两个组件独立性。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class ComponentDependency {
    @Component(modules = ModuleA.class)
    public interface ComponentA {
       //ComponentA-ModuleA里面的对象不能用于child module(ComponentB-ModuleB)
       //显式声明ComponentA-ModuleA里面的对象后 对子组件可见(ComponentB-ModuleB 可以消费父组件对象)
        SomeClassA1 someClassA1();
    }
    //声明Component 显式声明依赖(dependencies = ...) 
    @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();
    }
}

example 子依赖

  • SomeClassB1依赖SomeClassA1。 ComponentB不需要显式声明依赖。ComponentA需要声明ModuleB。
  • 子依赖使得两个组件耦合。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class SubComponent {
    @Component(modules = {ModuleA.class, ModuleB.class})
    public interface ComponentA {
       //可以访问它所有模块的所有对象而无需显示声明
       //ComponentB组件继承父组件
        ComponentB componentB(ModuleB moduleB);
    }
    //声明Subcomponent 不需要显式声明依赖
    @Subcomponent(modules = ModuleB.class)
    public interface ComponentB {
        SomeClassB1 someClassB1();
    }
    public static void main(String[] args) {
        ModuleA moduleA = new ModuleA();
        ModuleB moduleB = new ModuleB();
        ComponentA componentA = DaggerSubComponent_ComponentA.builder()
                .moduleA(moduleA)
                .moduleB(moduleB)
                .build();
        ComponentB componentB = componentA.componentB(moduleB);
    }
}

链接

[dagger2：组件依赖和子组件的区别]

[Dagger 2 subcomponents vs component dependencies]