[dagger] 단검 2 하위 구성 요소 및 구성 요소 종속성

구성 요소 종속성-두 구성 요소를 독립적으로 유지하려는 경우에 사용하십시오.

하위 구성 요소-두 구성 요소를 결합시키려는 경우에 사용하십시오.

아래 예제를 사용하여 구성 요소 종속성 및 하위 구성 요소 를 설명 합니다. 예제에 주목할만한 몇 가지 사항은 다음과 같습니다.

• SomeClassA1의존없이 만들 수 있습니다. 방법 ModuleA을 SomeClassA1통해 제공 및 인스턴스 provideSomeClassA1().
• SomeClassB1없이는 만들 수 없습니다 SomeClassA1. ModuleB의 인스턴스 가 메소드에 인수로 전달 된 SomeClassB1경우에만 인스턴스를 제공 할 수 있습니다 .SomeClassA1provideSomeClassB1()

@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;
    }
}

단검은 컴포넌트 / 하위 컴포넌트 선언 이 초기화 될 때마다 메소드 SomeClassA1의 인수로 인스턴스를 전달하는 것을 provideSomeClassB1()처리합니다 . 의존성을 충족시키는 방법을 Dagger에게 지시해야합니다. 이는 Component dependency 또는 Subcomponent를 사용하여 수행 할 수 있습니다 .ModuleBModuleB

구성 요소 종속성

아래의 컴포넌트 종속성 예제에서 다음 사항을 참고하십시오.

• ComponentB주석 의 dependencies메소드를 통해 종속성을 정의해야합니다 @Component.
• ComponentA선언 할 필요가 없습니다 ModuleB. 이렇게하면 두 구성 요소가 독립적으로 유지됩니다.

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 예제에서 다음 사항을 참고하십시오.

• 에 ComponentB대한 종속성을 정의 ModuleA하지 않았으므로 독립적으로 살 수 없습니다. 를 제공 할 구성 요소에 따라 달라집니다 ModuleA. 따라서 @Subcomponent주석이 있습니다.
• ComponentAModuleB인터페이스 메소드를 통해 선언했습니다 componentB(). 이렇게하면 두 구성 요소가 결합됩니다. 실제로는를 ComponentB통해서만 초기화 할 수 있습니다 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);
    }
}

답변

MySubcomponent mySubcomponent = myComponent.plus(new ChildGraphModule("child!")); // No need!