Dolch 2 Scope Lifetimes

Question

Ich bin gerade mit dagger2 und Dependency-Injektion im Allgemeinen bekannt. Ich denke, ich habe ein gutes Verständnis für die Grundlagen, aber ich habe Probleme, Bereiche zu verstehen. Es gibt zwei Dinge, die ich gerne verstehen möchte. A) über Umfang Lebenszeiten und B) über Wiederverwendung von Bereichen mehrmals.

Wenn wir über Bereiche sprechen, kommt die Idee der Lebensdauer des Bereichs unweigerlich auf. Ich nehme an, dass für Abhängigkeiten, die in einem bestimmten Bereich bereitgestellt werden, eine einzelne Instanz bereitgestellt wird, während dieser Bereich "lebt". Was bestimmt wirklich, ob ein Scope lebt oder tot ist? ist es an die Lebensdauer der Komponente gebunden, die damit versehen ist? Wenn diese Komponente nicht in den Geltungsbereich fällt und dann gecodiert wird, ist das der Tod dieses Geltungsbereichs?

Auch eine verwandte Frage: Angenommen, ich habe einige Abhängigkeiten, die ich auf eine von zwei Aktivitäten beschränken möchte. Muss ich zwei separate Bereiche erstellen (z. B. @MainActivityScope und @SettingsActivityScope), oder kann ich einen allgemeinen Aktivitätsbereich (@ActivityScope) verwenden, den ich für beide verwende, der aber abhängig von der Verwendung zwei separate Bereiche angibt? Vielleicht, wenn ich meine erste Frage verstehe, hilft mir das, die Antwort auf diese Frage zu verstehen.

Danke.

Answer 1

Dolch behandelt Bereiche auf die einfachste Art und Weise: Ein Bereich gehört zu einer Komponente Instanz. Wenn Sie eine Bereichsbindung haben, wird sie in der Komponenteninstanz mit dem entsprechenden Bereich gespeichert und von dieser abgerufen.

@Singleton @Component(...) public interface MyComponent { 
    ActivityComponent createActivityComponent(); // creates a new ActivityComponent 

    Thing1 getThing1(); // @Singleton 

    Thing2 getThing2(); // no scope 
} 

@ActivityScope @Subcomponent(...) public interface ActivityComponent { 
    Thing3 getThing3(); // @ActivityScoped 

    Thing4 getThing4(); // no scope 
} 

Das Konzept von "lebend oder tot" ist hier nicht wirklich relevant. Es kommt darauf an, dass Sie mit jeder von Ihnen erstellten ActivityComponent eine andere Instanz von Thing3, aber die gleiche Instanz von Thing1 erhalten. Wenn Sie für jede von Ihnen erstellte Aktivität eine neue ActivityComponent-Instanz erstellen, wird die Komponente nach dem Löschen der Aktivität (im Idealfall) nicht erreichbar und gesammelt. Soweit es Dagger betrifft, können Sie jedoch so viele ActivityComponents erstellen, wie Sie möchten.

MyComponent myComponent = DaggerMyComponent.create(); 
Thing1 a = myComponent.getThing1(); 
Thing1 b = myComponent.getThing1(); // b == a 
Thing2 c = myComponent.getThing2(); 
Thing2 d = myComponent.getThing2(); // c != d 

Unscoped bedeutet neue Instanz pro Injektion. Nun wollen wir versuchen, die Subkomponente:

ActivityComponent activityComponent1 = myComponent.createActivityComponent(); 
Thing3 e = activityComponent1.getThing3(); 
Thing3 f = activityComponent1.getThing3(); // e == f 
ActivityComponent activityComponent2 = myComponent.createActivityComponent(); 
Thing3 g = activityComponent2.getThing3(); // e != g 

// But you can still use activityComponent1. It's not dead. 
Thing3 h = activityComponent1.getThing3(); // e == h 

Natürlich ist dies breitet sich auch durch den Graphen: Wenn thing2 auf Thing1 abhängt, Sie viele thing2 Instanzen haben könnte, die jeweils abhängig von einer gemeinsamen Singleton Thing1 Instanz. Wenn Thing4 von Thing1, Thing2 und Thing3 abhängen würde, könnten Sie viele Thing4-Instanzen haben, jede mit ihrem eigenen Thing2, wobei Thing3 innerhalb derselben Aktivität (Komponente) und Thing1 innerhalb derselben Komponente (Anwendung/Singleton) gemeinsam genutzt wird .

Solange sie alle Teile separater Hierarchien sind, können Sie so viele ActivityComponents haben, wie Sie möchten, oder so viele @ActivityScoped-Komponenten. Sie könnten eine @ActivityScoped-Komponente "MainActivityComponent" und eine @ActivityScoped-Komponente "SettingsActivityComponent" erstellen oder eine einzelne gemeinsame ActivityComponent-Komponente erstellen, die weiß, wie sie jede injiziert. Sie benötigen wahrscheinlich kein @MainActivityScope und kein @SettingsActivityScope, da das eine niemals von dem anderen abgeleitet wird. Wichtig ist, dass Sie eine neue @ActivityScoped-Komponente Instanz per Aktivitätsinstanz erstellen. Dies ist alles, was Dagger benötigt, um die Bereiche ausgerichtet zu halten.