¿El gin soporta algo como los inyectores infantiles?

Question

Tengo una aplicación que contiene Sub-Aplicaciones.Me gustaría segregar la inyección de la ginebra para que cada Subpondede pueda tener instancias separadas de las mismas clases compartidas básicas.También quiero que el inyector suministre clases de algunos módulos básicos a todas las subpectativas, para que se puedan compartir las instancias de Singleton.e.g.

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

En Guicio Puedo hacerlo usando createChildInjector, pero no puedo ver un equivalente obvio en la ginebra.

¿Puedo lograr algo similar en la ginebra?

Answer 1

Aquí está en SOF http://code.google.com/p/ Google-gin / wiki / privatemodulesdesigndoc . Espero que te ayude.

Answer 2

Resolví esto gracias al enlace dado por @abderrazlakk, pero como el enlace no está muy próximo con las instrucciones, pensé que agregaría una solución de muestra aquí también:

Los módulos de ginebra privada le permiten tener un solo nivel de inyección jerárquica, donde los tipos registrados dentro de un módulo privado solo son visibles para otras instancias creadas dentro de ese módulo. Los tipos registrados dentro de cualquier módulo no privado todavía están disponibles para todos.

Ejemplo

Tendremos algunos tipos de muestra para inyectar (e inyectar en):

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

Crear dos módulos privados como este (usando Hubertwer2 para el segundo):

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

y un módulo compartido:

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

Ahora registre los dos módulos en nuestro inyector:

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

Finalmente podemos ver y ver que ambos instancias de la mercancía y las cosas de la mercancía tienen la misma instancia de la totalidad del módulo compartido, sino por diferentes casos de sus registros privados:

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