@Override public Injector createChildInjector(Module... modules) { return delegateInjector.createChildInjector(modules); }
@Override public Injector createChildInjector(Iterable<? extends Module> modules) { return delegateInjector.createChildInjector(modules); }
// bind shared singletons here Injector parent = Guice.createInjector(new MySharedSingletonsModule()); // create new injectors that share singletons Injector i1 = parent.createChildInjector(new MyModule1(), new MyModule2()); Injector i2 = parent.createChildInjector(new MyModule3(), new MyModule4()); // now injectors i1 and i2 share all the bindings of parent
public Injector createChildInjector(Module... modules) { return resolve().createChildInjector(modules); }
public Injector createChildInjector(Iterable<? extends Module> modules) { return resolve().createChildInjector(modules); }
MvcWebSocket(final WebSocket ws, final Class handler) { Injector injector = ws.require(Injector.class) .createChildInjector(binder -> binder.bind(WebSocket.class).toInstance(ws)); this.handler = injector.getInstance(handler); this.messageType = TypeLiteral.get(messageType(handler)); }
public class MainClass { public static void main(String[] args) { Injector firstStage = Guice.createInjector(new OtherModule1(), new OtherModule2()); // An alternative design would @Inject-annotate fields in ThreeModule // and get it from firstStage, but that's nonstandard and may be confusing. Injector secondStage = firstStage.createChildInjector(new ThreeModule(firstStage)); } } public class ThreeModule extends AbstractModule { private final Injector otherInjector; public ThreeModule(Injector otherInjector) { this.otherInjector = otherInjector; } @Override public void configure() { bindStuffBasedOn(otherInjector); } }
@Provides @Singleton List<ClusterConnection> getReadClusters(CassandraConfiguration configuration, Injector injector) { ImmutableList.Builder<ClusterConnection> clusters = new ImmutableList.Builder<>(); try { for (ClusterConfiguration clusterConfiguration : configuration.getReadClusters()) { Injector readInjector = injector.createChildInjector((Module) binder -> bindCassandraClient(binder, clusterConfiguration) ); CassandraClient client = readInjector.getInstance(CassandraClient.class); clusters.add(new ClusterConnection(client, EnumSet.of(ClusterConnection.Type.READ))); } } catch (Exception e) { logger.error("Error building read cluster", e); throw e; } return clusters.build(); }
final Injector child = container.createChildInjector(modules); container = child; List<IndexItem<?, Object>> l = Lists.newArrayList(sezpozIndex);
private void createClients(CassandraConfiguration configuration, Injector injector) { if (m_metaCluster != null) return; ClusterConfiguration writeConfig = configuration.getWriteCluster(); ClusterConfiguration metaConfig = configuration.getMetaCluster(); Injector writeInjector = injector.createChildInjector((Module) binder -> bindCassandraClient(binder, writeConfig) ); CassandraClient writeClient = writeInjector.getInstance(CassandraClient.class); if (writeConfig == metaConfig) //No separate meta cluster configuration { m_metaCluster = m_writeCluster = new ClusterConnection(writeClient, EnumSet.of( ClusterConnection.Type.WRITE, ClusterConnection.Type.META)); } else { m_writeCluster = new ClusterConnection(writeClient, EnumSet.of( ClusterConnection.Type.WRITE)); Injector metaInjector = injector.createChildInjector((Module) binder -> bindCassandraClient(binder, metaConfig) ); CassandraClient metaClient = metaInjector.getInstance(CassandraClient.class); m_metaCluster = new ClusterConnection(metaClient, EnumSet.of( ClusterConnection.Type.META)); } }
Injector pluginInjector = RuneLite.getInjector().createChildInjector(pluginModule); pluginInjector.injectMembers(plugin); plugin.injector = pluginInjector;
return injector.createChildInjector(new AbstractModule() { @Override protected void configure() {
@Override public ServiceLocator create(String name, ServiceLocator parent) { final ServiceLocator serviceLocator = super.create(name, parent); final Injector injector = GuiceInjectorHolder.getInjector() .createChildInjector(new HK2IntoGuiceBridge(serviceLocator)); GuiceBridge.getGuiceBridge().initializeGuiceBridge(serviceLocator); final GuiceIntoHK2Bridge guiceBridge = serviceLocator.getService(GuiceIntoHK2Bridge.class); guiceBridge.bridgeGuiceInjector(injector); return serviceLocator; } }
Injector getInjector(IClass iClass) { Annotation annotation = AnnotationHelper.findAnnotationSuperClasses(Guice.class, iClass.getRealClass()); if (annotation == null) { return null; } if (iClass instanceof TestClass) { iClass = ((TestClass)iClass).getIClass(); } if (!(iClass instanceof ClassImpl)) { return null; } Injector parentInjector = ((ClassImpl)iClass).getParentInjector(); Guice guice = (Guice) annotation; List<Module> moduleInstances = Lists.newArrayList(getModules(guice, parentInjector, iClass.getRealClass())); // Reuse the previous injector, if any Injector injector = context.getInjector(moduleInstances); if (injector == null) { injector = parentInjector.createChildInjector(moduleInstances); context.addInjector(moduleInstances, injector); } return injector; }
Injector getInjector(IClass iClass) { Guice guice = AnnotationHelper.findAnnotationSuperClasses(Guice.class, iClass.getRealClass()); if (guice == null) { return null; } if (iClass instanceof TestClass) { iClass = ((TestClass) iClass).getIClass(); } if (!(iClass instanceof ClassImpl)) { return null; } Injector parentInjector = ((ClassImpl) iClass).getParentInjector(); List<Module> moduleInstances = Lists.newArrayList(getModules(guice, parentInjector, iClass.getRealClass())); // Reuse the previous injector, if any Injector injector = context.getInjector(moduleInstances); if (injector == null) { injector = parentInjector.createChildInjector(moduleInstances); context.addInjector(moduleInstances, injector); } return injector; }
private Injector createPluginInjector(final URLClassLoader classLoader) { Class<? extends Module> guiceModule = getGuiceModule(classLoader); try { return injector.createChildInjector(guiceModule.newInstance()); } catch (InstantiationException e) { logger.error("Could not instantiate {}", guiceModule.getName()); } catch (IllegalAccessException e) { logger.error("Could not instantiate {}", guiceModule.getName()); } //If we cannot return a child injector, just use the standard parent injector for the plugin return injector; }
return injector.createChildInjector( new SubModule() ).getInstance( BImpl.class );
public static void main(String[] args) throws Throwable { if (args.length > 0) { System.setProperty("config", args[0]); } ProxyBootstrap app = new ProxyBootstrap(getModules()); app.requireExplicitBindings(true); Injector injector = app.strictConfig().initialize(); Set<InjectionHook> hooks = injector.getInstance( Key.get(new TypeLiteral<Set<InjectionHook>>() { })); hooks.forEach(InjectionHook::call); HttpServerConfig httpConfig = injector.getInstance(HttpServerConfig.class); if (!httpConfig.getDisabled()) { WebServiceModule webServiceModule = injector.getInstance(WebServiceModule.class); injector.createChildInjector(webServiceModule); } LOGGER.info("======== SERVER STARTED ========"); }
injector = parentInjector.createChildInjector(modules); } else { if (stage == null)
@SuppressWarnings("unchecked") protected Function<HttpResponse, T> parser(Injector i) { try { return (Function<HttpResponse, T>) i .createChildInjector(new SaxParserModule()) .getInstance(TransformerForRequest.class) .getTransformerForMethod(Invocation.create(method(getClass(), "expected"), ImmutableList.of()), i); } catch (Exception e) { throw Throwables.propagate(e); } }