Não GIN suporte qualquer coisa como criança injetores?

Question

Eu tenho uma aplicação que contém sub-aplicações.Eu gostaria de separar o GIN de injeção, de modo que cada sub-aplicativo pode ter instâncias separadas do mesmo núcleo compartilhado de classes.Eu também quero o injector para o fornecimento de classes, a partir de alguns módulos para todas as sub-aplicações, de modo que singleton instâncias podem ser compartilhados.exemplo:

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

Em Guice eu posso fazer isso usando createChildInjector, mas eu não posso ver um óbvio equivalente no GIN.

Posso conseguir algo semelhante no GIN?

Answer 1

Aqui é no SOF http://code.google.com/p/google-gin/wiki/PrivateModulesDesignDoc.Espero que ajude vocês.

Answer 2

Eu resolvi isso graças à ligação dada por @Abderrazakk, mas como o link não está muito próxima com instruções pensei em adicionar uma solução de exemplo aqui também:

Privado GIN módulos permitem que você tenha um único nível hierárquico de injeção, onde tipos registrado dentro de um módulo particular só são visíveis para outras instâncias criadas dentro do módulo.Tipos registrado dentro de qualquer não-privado módulos estão ainda disponíveis para todos.

Exemplo

Vamos ter alguns tipos de amostra para injetar (e injetar em):

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

Criar privada dois módulos, como este (usando ThingOwner2 para o segundo):

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

E um módulo compartilhado:

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

Agora registrar os dois módulos em nosso injector:

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

Finalmente, podemos olhar e ver que tanto ThingOwner1 e ThingOwner2 instâncias têm o mesmo SharedThing instância do módulo compartilhado, mas Coisa diferente instâncias de seus privada inscrições:

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