Non GIN sostenere nulla come un bambino iniettori?

Question

Ho una applicazione che contiene sotto-applicazioni.Vorrei separare il GIN iniezione in modo che ogni sub-applicazione può avere diverse istanze dello stesso nucleo classi.Anche io voglio l'iniettore di alimentazione classi da alcuni moduli di base a tutti i sub-applicazioni, in modo che singleton istanze possono essere condivise.ad es.

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

In Guice posso fare questo utilizzando createChildInjector, ma io non posso evidente l'equivalente in GIN.

Posso realizzare qualcosa di simile in GIN?

Answer 1

Qui è su Sof http://code.google.com/p/ Google-gin / wiki / privatemodulesdesigndoc . Spero che ti aiuta.

Answer 2

Ho risolto grazie al link indicato da @Abderrazakk, ma il link non è molto vario, con istruzioni, ho pensato di aggiungere una soluzione di esempio anche qui:

Privato GIN moduli consentono di disporre di un unico livello gerarchico di iniezione, in cui i tipi di registrati all'interno di un modulo sono visibili solo ad altre istanze create all'interno di tale modulo.Tipi di registrati all'interno di qualsiasi non-privato moduli sono ancora a disposizione di tutti.

Esempio

Diamo alcuni esempi di tipi di iniettare (e iniettare in):

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);
    }
}

Creare due moduli privati come questo (utilizzando ThingOwner2 per la seconda):

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

In comune e un modulo:

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

Ora registrare i due moduli nel nostro iniettore:

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

Finalmente siamo in grado di guardare e vedere che sia ThingOwner1 e ThingOwner2 casi hanno la stessa SharedThing istanza condivisa modulo, ma una Cosa diversa, le istanze da loro privato iscrizioni:

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