Java Code Examples for com.google.inject.Key#get()

private Pair<Integer, Pair<Executor, Executor>> buildGraphWithChildInjector(Supplier<Executor> executorProvider) {
    Injector childInjector = Guice.createInjector(new AbstractModule() {
        @Override
        public void configure() {
            bind(Executor.class).toProvider(executorProvider::get);
        }
    });

    ComponentGraph componentGraph = new ComponentGraph();

    Key<ComponentTakingExecutor> keyA = Key.get(ComponentTakingExecutor.class, Names.named("A"));
    Key<ComponentTakingExecutor> keyB = Key.get(ComponentTakingExecutor.class, Names.named("B"));

    componentGraph.add(mockComponentNode(keyA));
    componentGraph.add(mockComponentNode(keyB));

    componentGraph.complete(childInjector);

    return new Pair<>(componentGraph.size(),
            new Pair<>(componentGraph.getInstance(keyA).executor, componentGraph.getInstance(keyB).executor));
}
 

@Override
protected void configure() {
    requestStaticInjection(JndiContext.class);

    // Bind default context
    Key<Context> defaultContextKey = Key.get(Context.class, Names.named("defaultContext"));
    bind(defaultContextKey).toInstance(this.defaultContext);
    bind(Context.class).to(defaultContextKey);

    // Bind additional contexts
    for (Map.Entry<String, Context> jndiContextToBeBound : jndiContextsToBeBound.entrySet()) {
        Key<Context> key = Key.get(Context.class, Names.named(jndiContextToBeBound.getKey()));
        bind(key).toInstance(jndiContextToBeBound.getValue());
    }

    bindListener(Matchers.any(), new ResourceTypeListener(this.defaultContext, this.jndiContextsToBeBound));
}
 

public ModuleManifest(@Nullable TypeLiteral<Module> type) {
    // Figure out the module type. If the given type is null,
    // then try to resolve it from this object's superclass.
    this.type = type != null ? Types.assertFullySpecified(type)
                             : new ResolvableType<Module>(){}.in(getClass());
    this.rawType = (Class<Module>) this.type.getRawType();
    this.simpleName = rawType.getSimpleName();

    // Resolve the scope type automatically
    this.scope = (Class<Scope>) new ResolvableType<Scope>(){}.in(getClass()).getRawType();

    // Construct various keys related to the module/scope
    this.key = Key.get(this.type);
    this.optionalKey = Keys.optional(this.key);
    this.wrapperKey = ProvisionWrapper.keyOf(this.type);
    this.contextKey = Key.get(new ResolvableType<Context>(){}.in(getClass()));
    this.setElementKey = Key.get(new ResolvableType<ProvisionWrapper<? extends Base>>(){}.in(getClass()));
}
 

/** Creates a new option from a type literal. */
@SuppressWarnings("unchecked")
public static <T> Option<T> createOption(
    TypeLiteral<T> type, String name, String description, @Nullable T defaultValue) {
  Option<T> option =
              new Option<T>(
                  Key.get(type, Names.named(name)), name, description, defaultValue, false, true);
  registeredOptions.add(option);
  return option;
}
 

public InnerFactoryManifest(Key<I> innerKey, TypeLiteral<O> outerType) {
    if(innerKey == null) {
        innerKey = Key.get(new ResolvableType<I>(){}.in(getClass()));
    }
    this.innerType = innerKey.getTypeLiteral();
    this.outerType = outerType != null ? outerType : new ResolvableType<O>(){}.in(getClass());

    this.factoryKey = innerKey.ofType(new ResolvableType<InnerFactory<O, I>>(){}
                                          .with(new TypeArgument<O>(this.outerType){},
                                                new TypeArgument<I>(this.innerType){}));
}
 

public CharSequence get(String target, ExecutionFlow flow, IGenArtifactConfigurations config) {
	Key<Set<ISourceFragment>> key = Key.get(new TypeLiteral<Set<ISourceFragment>>() {
	}, Names.named(target));
	if (injector.getExistingBinding(key) == null) {
		return "";
	}
	Set<ISourceFragment> fragments = injector.getInstance(key);
	return fragments.stream().map((it) -> it.get(flow, config))
			.collect(Collectors.joining(Strings.newLine() + Strings.newLine()));
}
 

@Override
protected void configure() {
    // @ModelSync ExecutorService must be bound elsewhere
    final Key<Executor> executorKey = Key.get(Executor.class, ModelSync.class);
    final Key<ExecutorService> executorServiceKey = Key.get(ExecutorService.class, ModelSync.class);
    final Key<ListeningExecutorService> listeningExecutorServiceKey = Key.get(ListeningExecutorService.class, ModelSync.class);

    bind(executorKey).to(executorServiceKey);

    expose(executorKey);
    expose(executorServiceKey);
    expose(listeningExecutorServiceKey);

    new ModelListenerBinder(publicBinder());
}
 

protected <T extends HttpServlet> ServletBindingBuilder bindServlet(Class<T> servlet)
{
    Annotation annotation = UniqueAnnotations.create();
    Key<T> servletKey = Key.get(servlet, UniqueAnnotations.create());
    binder().bind(servletKey).to(servlet).in(Scopes.SINGLETON);
    return new ServletBindingBuilder(binder(), servletKey);
}
 

@SuppressWarnings("unchecked")
public ApplicationBindingBuilder addProvider(Class<?> annotatedClass)
{
    Key<Object> key = Key.get((Class<Object>) annotatedClass, UniqueAnnotations.create());
    binder.bind(key).to(annotatedClass);
    initializer.addProvider(key);
    return this;
}
 

private TestTcpDataSender findTestTcpDataSender(Injector injector) {
    TypeLiteral<EnhancedDataSender<Object>> dataSenderTypeLiteral = new TypeLiteral<EnhancedDataSender<Object>>() {
    };
    Key<EnhancedDataSender<Object>> dataSenderKey = Key.get(dataSenderTypeLiteral);
    EnhancedDataSender dataSender = injector.getInstance(dataSenderKey);
    if (dataSender instanceof TestTcpDataSender) {
        return (TestTcpDataSender) dataSender;
    }
    throw new IllegalStateException("unexpected dataSender" + dataSender);
}
 

@Override
public Module module(final Key<PluginSink> key, final String id) {
    return new OutputPluginModule(id) {
        @Provides
        Supplier<AggregateMetricSender> sender() {
            final Collection<OnSendErrorHandler> handlers = ImmutableList.of(metricError -> {
                log.error(metricError.toString());
            });

            return () -> {
                final SignalFxEndpoint endpoint = new SignalFxEndpoint();
                final HttpDataPointProtobufReceiverFactory dataPoints =
                    new HttpDataPointProtobufReceiverFactory(endpoint).setVersion(2);

                BasicHttpClientConnectionManager connectionManager =
                    new BasicHttpClientConnectionManager();
                SocketConfig socketConfigWithSoTimeout = SocketConfig
                    .copy(connectionManager.getSocketConfig())
                    .setSoTimeout(soTimeout)
                    .build();
                connectionManager.setSocketConfig(socketConfigWithSoTimeout);
                dataPoints.setHttpClientConnectionManager(connectionManager);

                final EventReceiverFactory events =
                    new HttpEventProtobufReceiverFactory(endpoint);
                final AuthToken auth = new StaticAuthToken(authToken);

                return new AggregateMetricSender(sourceName, dataPoints, events, auth,
                    handlers);
            };
        }

        @Override
        protected void configure() {
            final Key<SignalFxPluginSink> sinkKey =
                Key.get(SignalFxPluginSink.class, Names.named("signalfxSink"));
            bind(sinkKey).to(SignalFxPluginSink.class).in(Scopes.SINGLETON);
            install(wrapPluginSink(sinkKey, key));
            expose(key);
        }
    };
}
 

public ReflectiveFeatureManifest(@Nullable TypeLiteral<T> type) {
    this.type = type != null ? Types.assertFullySpecified(type)
                             : new ResolvableType<T>(){}.in(getClass());
    this.typeArg = new TypeArgument<T>(this.type){};
    this.definitionParserKey = Key.get(new ResolvableType<FeatureDefinitionParser<T>>(){}.with(typeArg));
}
 

static <T> Key<ProvisionWrapper<T>> keyOf(TypeLiteral<T> type) {
    return Key.get(new ResolvableType<ProvisionWrapper<T>>(){}.where(new TypeParameter<T>(){}, type));
}
 

public ProvisionAtParseTime(TypeLiteral<T> type) {
    this(Key.get(type));
}
 

@Override public <T> Key<T> create(TypeLiteral<T> type) {
  return Key.get(type);
}
 

public static <T> Key<T> get(TypeToken<T> type) {
    return Key.get(Types.toLiteral(type));
}
 

@Override public <T> Key<T> create(Class<T> type) {
  return Key.get(type);
}
 

public TransformableBinder(Binder binder, @Nullable Class<T> type) {
    this(binder, type == null ? null : Key.get(type));
}
 

public <T> void bindType(Class<T> type, String impl) throws ClassNotFoundException {
  Key<T> key = Key.get(type, Names.named(type.getSimpleName())) ;
  Class<?> clazz = (Class<?>)Class.forName(impl);
  bind(type).to((Class)clazz);
}
 

@Test public void testInjection() {
	Key<ValidatorTester<TestingValidator>> key = Key.get(new TypeLiteral<ValidatorTester<TestingValidator>>() {});
	ValidatorTester<TestingValidator> injectedTester = get(key);
	assertNotNull(injectedTester);
}