Où conserver les injecteurs de guice?

Question

Quel est votre conseil? J'ai trouvé la solution la plus appropriée pour moi - garder les injecteurs et les modules dans les classes d'énumération. Avantages:

1. injecteurs et modules créés une fois,
2. injecteurs peuvent être utilisés de différentes classes alors que l'application en cours d'exécution (non seulement d'amorçage),
3. injecteurs conservés dans un endroit et peuvent être facilement trouvés.

Exemple:

import static ru.package.Modules.*; 

public enum Injectors { 

FOO_INJECTOR(BarModule.module()), 

FOO2_INJECTOR(FOO_INJECTOR.injector(), 
     Bar2Module.module(), FooModule.module()); 

private final Injector m_injector; 

Injectors (Module... modules) { 
    m_injector = Guice.createInjector(modules); 
} 

Injectors (Injector parentInjector, Module... modules) { 
    m_injector = parentInjector.createChildInjector(modules); 
} 

public Injector injector() { 
    return m_injector; 
} 
} 

Answer 1

La grande question est pourquoi?

Il ne devrait pas être nécessaire de conserver le Injector, car une fois l'injection terminée, le Injector devrait être terminé et devrait disparaître.

Cependant, si vous avez vraiment besoin Injector, vous ne pourriez pas simplement:

@Inject 
private Injector injector; 

Est-ce application web basée ou est-il autonome?

Answer 2

Vous semblez fondamentalement comprendre mal comment fonctionne l'injection de dépendances. Si vous essayez d'utiliser une référence à Injector n'importe où dans votre code en dehors de l'endroit où vous amorcez l'application, vous n'utilisez pas l'injection de dépendance, vous l'utilisez plutôt comme un localisateur de service. Vous êtes obligé de préparer un Injector chaque fois que vous avez besoin de tester une classe et vos classes ne précisent pas dans leurs constructeurs exactement quelles sont leurs dépendances (puisque qui sait ce qu'ils vont sortir du Injector dans une méthode s'ils ont ou peut obtenir une référence à celui-ci). En fait, en utilisant enum comme vous l'avez décrit ici est encore pire que cela: vous ne pouvez pas changer du tout la configuration, même pour le test, parce que vos modules sont codés en dur dans l'énumération. Avec l'injection de dépendances, les classes déclarent uniquement leurs dépendances et autorisent le Injector à fonctionner de manière transparente (après l'appel initial pour obtenir l'objet d'application racine) afin de fournir toutes ces dépendances. Cela facilite la compréhension, le test et la modification des fonctionnalités de votre code. Quoi qu'il en soit, je suggère d'en apprendre plus sur la façon dont DI et Guice sont destinés à être utilisés ... vous ne devriez vraiment pas vouloir faire cela.