Guice / Gin. Comment injecter plusieurs implémentations

Question

I ai une webapp que l'utilisation GIN pour injecter des dépendances au point d'entrée.

private InjectorService injector = GWT.create(InjectorService.class);

---

@GinModules({PlaceContollerInject.class, RootViewInject.class})
public interface InjectorService extends Ginjector {

  RootView getRootView();
  PlaceController getPlaceConroller();

}

---

public class RootViewInject extends AbstractGinModule {

  @Override
  protected void configure() {
    bind(RootView.class).to(RootViewImpl.class);
  }
}

Je besoin d'une version mobile qui utilisent différentes implémentation RootView. Les dépendances sont décrites dans le module suivant

public class RootViewMobileInject extends AbstractGinModule {

  @Override
  protected void configure() {
    bind(RootView.class).to(RootViewMobileImpl.class);
  }
}

La question est de savoir comment choisir la dépendance nécessaire sous condition si nous avons besoin d'une version mobile ou par défaut. Je l'ai vu GWT-GIN multiples Implémentations, mais ne l'ai pas compris cette solution parce que la pauses fournisseur de la dépendance de la chaîne et les sauts de motif usine testabilité. Dans "Big modulaire Java avec Guice" vidéo ici (12 minutes) l'injecteur de Guice avec des modules a été présenté comme un substitut aux usines. Donc, ma question est que je devrais créer différentes Ginjector pour les versions mobiles et par défaut (comme MobileFactory et defaultFactory) de mon application ou ce serait une mauvaise pratique et je dois configurer une instance de Ginjector avec toutes les versions nécessaires. Par exemple, avec les liaisons d'annotation comme celle-ci.

public class RootViewMobileInject extends AbstractGinModule {

  @Override
  protected void configure() {
    bind(RootView.class).annotatedWith(Mobile.class).to(RootViewMobileImpl.class);
  }
}

et de l'utilisation des liaisons @mobile annotées au point d'entrée GWT

  @Inject
  private void setMobileRootView(@Mobile RootView rw) {
    this.rw = rw;
  }

---

Dans un tel exemple simplifié ci-dessus il est peut-être possible. Mais si une application a plus de dépendances qui nécessitent des versions mobiles et par défaut. Il ressemble à nouveau à invérifiable « laid » (comme lors de la présentation de Guice a été dit) les usines. Désolé pour mon anglais. Toute aide est appréciée.

Answer 1

Je crois que vous voulez utiliser la liaison différée GWT, en utilisant le remplacement de la classe pour lier une version différente de votre InjectorService en fonction de l'agent utilisateur. Cela permettra d'assurer la version mobile ne dispose que les implémentations mobiles compilées dans (et téléchargé)

Vous auriez InjectorServiceDesktop, InjectorServiceMobile, qui s'étendent tous deux de InjectorService, puis GWT.create (InjectorService.class) et laisser différé liaison décider quelle mise en œuvre devrait utiliser.

http://code.google.com/webtoolkit/doc/latest/DevGuideCodingBasicsDeferred.html #replacement

Une instance de Ginjector avec toutes les versions semble mauvais que cela signifie tout le code pour les deux versions est toujours téléchargé (et vous ne voulez certainement pas télécharger toutes vos vues de bureau dans votre application mobile)

EDIT: Comme Thomas souligne dans les commentaires, puisque les Injecteurs sont classes générées, vous aurez besoin de mettre chaque InjectorServiceXXX dans une classe simple support qui GWT.create () 's pour basculer entre les détenteurs du remplacement InjectorServiceXXX et d'utilisation.

Answer 2

Pour faire ce que vous voulez est en fait assez compliqué parce que votre interface d'injection commune, qui est annotées avec votre module Gin, ne peut pointer vers un module abstrait Gin. Le module Gin pointé par votre interface Ginjector doit être un béton. Un module de béton ne peut pas satisfaire plusieurs configurations en même temps.

Alors qu'est-ce que vous faites est: (A) Créer votre interface Ginjector, dites ClientGinjector et votre module, ClientModule, pour une application de bureau.

(b) Créer une deuxième interface Ginjector, disons ClientGinjectorTablet, étendant celui que vous avez créé à (a) mais avec une annotation GinModule pointant vers un module differnt, dire ClientModuletablet.

-. Maintenant, vous avez deux interfaces Ginjecor un par défaut et secondaire pour les tablettes, chacun pointant vers un module avec ses propres implémentations Configurer ()

(c) Maintenant, vous voulez créer l'usine pour obtenir votre mise en œuvre Ginjector droit. Vous pouvez le faire parce que le Ginjector vous careated en (a) et (b) ont une demonitador commune qui est l'interface par défaut créée en (a). Donc, vous créez un facotry abstrait avec une méthode telle que celle-ci: abstraite ClientGinjector publique getInjector (); Vous créez deux enfants des classes concrètes pour obtenir un Desktop / Par défaut Ginjector et un autre pour obtenir le Tablet Ginjector.

(d) Maintenant, vous configurez le gwt.xml de votre module comme Google IO sur YouTube vous explique devriez faire obtenir votre facotry désirée lors de l'exécution, en utilisant les liaisons différées GWT pour chacun de vos usine Ginjector.

(e) sur votre point d'entrée de la chose Frist vous est de ne pas obtenir un Ginjector mais votre usine pour Ginjectors en utilisant GWT différé de liaison. Vous appelez la méthode abstraite qui renvoie une ClientGinjector, votre jeu.

(f) L'épopée sûr à la fin. Guice ne vous laissera pas lier deux fois la même clé (classe ainsi que l'annotation), même si vous seriez en utilisant différents injecteurs (un pour le bureau et un pour la tablette). Il semble que la clé de liaison sont DEFINITIONS mondiale, dès que vous avez deux modules qui redéfinissent les mêmes touches, qui est la fin de l'aventure.