My Daggon Configuration pour un projet Android que je travaille sur: Remarque: j'ai fourni tous les indicateurs @Component, @module, @Provides annotations dans la mesure du cas.
In file A.java error: B cannot be provided without an @Provides- or @Produces-annotated method. MainActivity.b [injected field of type: B b]
3 Réponses :
est l'application supposée utiliser un gros composant qui prend soin de toutes les injections? p>
Vous pouvez utiliser
sous-composant code>. Dans votre déclaration de cas, la déclaration des composants ressemblera à ceci: p>xxx pré>
Componentence code> Création:CréationCompunenty = Componentx.Plus (nouveau moduleb ()); code> p>maintenant dans
MainAlactivité code> Vous appelez uniquementCompolenty.Iject (this); code> p>MainActivity { @Inject A a; @Inject B b; onCreate(){ ComponentY.inject(this); } }
Dans ce cas aussi, vous parlez de la composition dans un grand composant qui prend soin des injections. Vous ne traitez pas exactement du scénario d'avoir deux composants distincts. Avoir deux injections distinctes
Je pense que cela composant le composant final avant de l'utiliser est beaucoup mieux que de faire une injection multiple comme vous le suggérez. Votre MainAlactivité ne devrait pas savoir comment vos dépendances sont distribuées entre les composants . Y a-t-il deux ou trois composants, etc. et vous êtes libre de changer cette distribution afin de fournir des tests plus faciles ou une réutilisation plus facile sans changer MainAlactivité .
@MydogTom je suis un peu en désaccord qui composant un composant "gras" est meilleur. J'aimerais que la liberté injecte des choses directement dans la classe. Dans les deux sens, la MainAlactivité n'a aucune idée de la création de composants et ne se souciait que de ce qui est injecté. Je ne dis pas que vous ayez tort, c'est juste une perspective différente de la vue, mais je vois cela comme limitation.
est l'application censée utiliser un gros composant p>
genre de, vous devriez y penser dans des cultures. Pour une portée donnée, il y a un composant. Les scopes sont par exemple
applicationsCope code>,fragmentscope code> (retenu),ActivityScope code>,Viewscope code>. Pour chaque portée, il y a un composant donné; Les scopes ne sont pas partagés entre les composants. P>(Cela signifie essentiellement que si vous souhaitez avoir des singletons globaux dans le
@Aplicationscope code>, il existe une composante appliquée de l'application. Si vous voulez Classes spécifiques à l'activité, alors vous créez un composant pour celui-ci pour cette activité spécifique, qui dépendra du composant scopé de l'application). P>Voir @mydogtom pour le
@subcomponent code> Annotation , mais vous pouvez également utiliser des dépendances des composants pour la création de composants sous-morceaux également. P>@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();
1) Cela compile-t-il pour vous? Parce que ce sont deux scopes différentes. 2) Vous parlez finalement d'un composant ici en étendant le composant Y de ComponentX. Vous avez pris la route d'héritage et je pensais à la route de la composition (en choisissant une dépendance inter-composants).
Bien sûr, il compile si vous ajoutez les deux annotations de portée personnalisées, YSPOPE est un sous-charge de xscope. Pensez à une activitéCOPE est un sous-charge d'applicationsCope.
Vous ne devez pas avoir un seul composant, il existe différentes façons de les modulariser, mais chaque objet que vous créez ou injecter des valeurs, doit avoir toutes ses valeurs fournies par un seul composant.
Une façon dont vous avez La restructuration de votre code pourrait-elle compendre sur ComponentX ou vice versa, par exemple ou que vous pouvez créer un composant troisième, indiquez du composant, si un composantx et un calculent sont complètement orthogonaux. l'un à l'autre. ou vous pouvez simplement réutiliser les modules, par exemple comment exactement vous décidez de la diviser dépend en grande partie de la structure de votre code. Si les composants X et Y sont visibles, mais les modules n'utilisent pas, utilisez des dépendances des composants, car ils (et les dépilés de module) sont vraiment des détails de mise en œuvre du composant. Sinon, si les modules sont visibles, alors simples les réutiliser. Je n'utiliserais pas de scopes pour cela car ils sont vraiment destinés à gérer des objets avec des objets de vie différentes, par exemple. Objets associés à un utilisateur spécifique dont la durée de vie est le moment où un utilisateur se connecte au moment où ils se déconnectent ou la durée de vie d'une demande spécifique. S'ils ont une durée de vie différente, vous envisagez d'utiliser des champs et des sous-composants.
La méthode de la composition est ce que j'ai fait actuellement en tant que solution intermédiaire. D'autre part, de ma compréhension, les champs étaient une utilisation différente, comme vous l'avez mentionné. Ce que je voulais identifier, c'est que c'était la bonne approche, une composante d'injection cible unique qui constitue une composition de plusieurs composants (fournis dans des projets de bibliothèque)
C'est définitivement une bonne approche, que ce soit la bonne approche est à vous. Encore une fois, cela dépend de votre "API" et de la façon dont vous voulez le modulariser.
C'est définitivement une bonne approche, que ce soit la bonne approche est à vous. Encore une fois, cela dépend de votre "API" et de la façon dont vous voulez le modulariser.
La seule chose qui mérite d'être prise en compte, c'est que si vos méthodes de fournisseur de module et vos composants sont non cotées, vous obtiendrez une nouvelle instance sur chaque appel d'injecteur. Cependant, vous pouvez contourner cela si vous stockez une référence pour ce que vous avez créé dans le module et que vous le renvoyez une fois que cela est créé. C'est un peu long cependant.