N'GIN soutenir quoi que ce soit comme enfant injecteurs?

Question

J'ai une application qui contient des sous-applications.Je voudrais isoler le GIN injection, de sorte que chaque sous-application peut avoir des instances distinctes de la même base partagée classes.Je veux aussi que l'injecteur d'alimentation des classes à partir de certains modules de base pour tous les sous-applications, de sorte que singleton instances peuvent être partagés.par exemple

GIN Modules:
  Core - shared
  MetadataCache - one per sub-application
  UserProvider - one per sub-application

Dans Guice je peux le faire à l'aide de createChildInjector, mais je ne vois pas évident d'équivalent dans le GIN.

Puis-je les obtenir quelque chose de similaire dans le GIN?

Answer 1

ici il est sur sof http://code.google.com/p/ google-gin / wiki / privateemodulesDesigndoc . J'espère que cela vous aidera.

Answer 2

J'ai résolu cela grâce au lien donné par @Abderrazakk, mais comme le lien n'est pas très à venir avec des instructions que je pensais ajouter une solution d'échantillon ici aussi:

Les modules de gin privés vous permettent d'avoir un seul niveau d'injection hiérarchique, où les types enregistrés dans un module privé ne sont visibles que dans d'autres instances créées dans ce module. Les types enregistrés à l'intérieur de tous les modules non privés sont toujours disponibles pour tous.

exemple

Avoir des types d'échantillons à injecter (et injecter):

public class Thing {
    private static int thingCount = 0;
    private int index;

    public Thing() {
        index = thingCount++;
    }

    public int getIndex() {
        return index;
    }
}

public class SharedThing extends Thing {
}

public class ThingOwner1 {
    private Thing thing;
    private SharedThing shared;

    @Inject
    public ThingOwner1(Thing thing, SharedThing shared) {
        this.thing = thing;
        this.shared = shared;
    }

    @Override
    public String toString() {
        return "" + this.thing.getIndex() + ":" + this.shared.getIndex();
    }
}

public class ThingOwner2 extends ThingOwner1 {
    @Inject
    public ThingOwner2(Thing thing, SharedThing shared) {
        super(thing, shared);
    }
}

Créer deux modules privés comme celui-ci (à l'aide de Trensowner2 pour le second):

public class MyPrivateModule1 extends PrivateGinModule {
  @Override
  protected void configure() {
    bind(Thing.class).in(Singleton.class);
    bind(ThingOwner1.class).in(Singleton.class);
  }
}

et un module partagé:

public class MySharedModule extends AbstractGinModule {
    @Override
    protected void configure() {
        bind(SharedThing.class).in(Singleton.class);
    }
}

Enregistrez maintenant les deux modules de notre injecteur:

@GinModules({MyPrivateModule1.class, MyPrivateModule2.class, MySharedModule.class})
public interface MyGinjector extends Ginjector {
    ThingOwner1 getOwner1();
    ThingOwner2 getOwner2();
}

Enfin, nous pouvons regarder et voir que les instances de TakInser1 et de TakInser2 ont la même instance de partage à partir du module partagé, mais des instances différentes de leurs enregistrements privés:

System.out.println(injector.getOwner1().toString());
System.out.println(injector.getOwner2().toString());