Inyección de múltiples componentes independientes

No es necesario tener un solo componente, hay varias maneras de modularizarlos, pero cada objeto que se crea o se inyecta valores en, debe tener todos sus valores proporcionados por un solo componente.

Una forma de reestructurar su código es que ComponentY dependa de ComponentX, o viceversa, por ejemplo

 @Component(dependencies = ComponentX.class) interface ComponentY { void inject(MainActivity activity); } 

O puede crear un tercer componente, digamos ComponentZ, si ComponentX y ComponentY son completamente ortogonales entre sí.

 @Component(dependencies = {ComponentX.class, ComponentY.class}) interface ComponentZ { void inject(MainActivity activity); } 

O simplemente podría reutilizar los módulos, por ejemplo

 @Component(modules = {ModuleA.class, ModuleB.class}) interface ComponentZ { void inject(MainActivity activity); } 

Cómo exactamente usted decide dividirlo depende en gran medida de la estructura de su código. Si los componentes X e Y son visibles, pero los módulos no lo son, utilice dependencias de componentes, ya que (y las depedencias de módulos) son realmente detalles de implementación del componente. De lo contrario, si los módulos son visibles entonces simple reutilizarlos.

Yo no utilizaría los ámbitos para esto, ya que son realmente para la gestión de objetos con diferentes lifespans, por ejemplo, los objetos asociados con un usuario específico cuya vida útil es el tiempo desde el momento en que un usuario inicia sesión cuando se desconectan o la vida útil de una solicitud específica . Si tienen diferentes vida útil, entonces usted está buscando en el uso de ámbitos y subcomponentes.

Se supone que la aplicación utiliza un componente grande

Deberías pensarlo en ámbitos. Para un ámbito determinado, hay un componente. Los ámbitos son, por ejemplo, ApplicationScope , FragmentScope (retenido), ActivityScope , ViewScope . Para cada ámbito, hay un componente dado; Los ámbitos no se comparten entre los componentes.

(Esto significa que si desea tener singletons globales en el @ApplicationScope , hay un componente de ámbito de aplicación para @ApplicationScope desea clases específicas de la actividad, a continuación, crear un componente para ello para esa actividad específica, que dependerá de El componente de ámbito de aplicación).

Consulte @MyDogTom para la anotación @Subcomponent , pero también puede usar dependencias de componentes para la creación de componentes subscoped.

 @YScope @Component(dependencies = ComponentX.class, modules=ModuleB.class) public interface ComponentY extends ComponentX { B b(); void inject(MainActivity mainActivity); } @XScope @Component(modules=ModuleA.class) public interface ComponentX{ A a(); } ComponentY componentY = DaggerComponentY.builder().componentX(componentX).build(); 

¿Se supone que la aplicación utiliza un componente grande que se encarga de todas las inyecciones?

Puede utilizar Subcomponent . En su caso, la declaración de componentes se verá así:

 @Subcomponent(modules=ModuleB.class) public interface ComponentY{ void inject(MainActivity mainActivity); } @Component(modules=ModuleA.class) public interface ComponentX{ ComponentY plus(ModuleB module); } 

Creación de ComponentY : creationCompunentY = ComponentX.plus(new ModuleB());

Ahora en MainActivity se llama sólo ComponentY.inject(this);

 MainActivity { @Inject A a; @Inject B b; onCreate(){ ComponentY.inject(this); } } 

Puede encontrar más información sobre los subcomponentes en la migración de la guía Dagger1 (ver parte de Subgraphs), Subcomponente JavaDoc y Component JavaDoc (consulte la parte Subcomponentes).