com.google.inject.binder.LinkedBindingBuilder Java Examples

@Override
protected void configure() {
  LinkedBindingBuilder<Iterable<InetSocketAddress>> clusterBinder =
      bind(ServiceDiscoveryBindings.ZOO_KEEPER_CLUSTER_KEY);

  if (zooKeeperConfig.isInProcess()) {
    requireBinding(ShutdownRegistry.class);
    File tempDir = Files.createTempDir();
    bind(ZooKeeperTestServer.class).toInstance(new ZooKeeperTestServer(tempDir, tempDir));
    SchedulerServicesModule.addAppStartupServiceBinding(binder()).to(TestServerService.class);

    clusterBinder.toProvider(LocalZooKeeperClusterProvider.class).in(Singleton.class);
  } else {
    clusterBinder.toInstance(zooKeeperConfig.getServers());
  }

  install(new CuratorServiceDiscoveryModule(discoveryPath, zooKeeperConfig));
}
 

public static LinkedBindingBuilder<ContainerRequestFilter> bindContainerRequestFilter(
  Binder binder
) {
  Multibinder<ContainerRequestFilter> requestFilterBinder = Multibinder.newSetBinder(
    binder,
    ContainerRequestFilter.class
  );
  return requestFilterBinder.addBinding();
}
 

@SuppressWarnings("unchecked")
private void bindValue(final LinkedBindingBuilder binding, final Object value) {
    if (value != null) {
        binding.toInstance(value);
    } else {
        binding.toProvider(Providers.of(null));
    }
}
 

protected void bindHealthCheck(LinkedBindingBuilder<HealthCheckHandler> bindingBuilder) {
    if (null != healthcheckHandlerClass) {
        bindingBuilder.to(healthcheckHandlerClass);
    } else {
        bindingBuilder.toInstance(healthcheckHandler);
    }
}
 

/**
 * Binds individual flattened key-value properties in the configuration yml
 * file. So one can directly inject something like this:
 *
 * @Named("Hibernate.hibernate.jdbcDriver") String jdbcDriver OR
 * @Named("Dashboard.service.port") int port
 */
@SuppressWarnings({"rawtypes", "unchecked"})
private void bindConfigProperties() {
    bind(YamlConfiguration.class).toInstance(yamlConfiguration);
    Iterator<String> propertyKeys = yamlConfiguration.getKeys();
    while (propertyKeys.hasNext()) {
        String propertyKey = propertyKeys.next();
        Object propertyValue = yamlConfiguration.getProperty(propertyKey);
        LinkedBindingBuilder annotatedWith = bind(propertyValue.getClass()).annotatedWith(Names.named(propertyKey));
        annotatedWith.toInstance(propertyValue);
    }
}
 

public static LinkedBindingBuilder<SingularityClientCredentials> bindCredentials(
  Binder binder
) {
  return binder
    .bind(SingularityClientCredentials.class)
    .annotatedWith(Names.named(CREDENTIALS_PROPERTY_NAME));
}
 

/**
 * Bind the given key to an {@link ElementParser<T>}, which will be applied to
 * the root {@link Element} of the {@link Document} at parse-time, and the
 * result bound in {@link MapScoped}.
 */
default <T> LinkedBindingBuilder<ElementParser<T>> bindRootElementParser(Key<T> key) {
    install(new ProvisionAtParseTime<>(key));
    bind(key).toProvider(new ResolvableType<RootElementParsingProvider<T>>(){}
                             .with(new TypeArgument<T>(key.getTypeLiteral()){}))
             .in(MapScoped.class);
    return bindElementParser(key);
}
 

protected final LinkedBindingBuilder<StateTransitionListener> bindTransitionListener() {
  return listenerBinder.addBinding();
}
 

public LinkedBindingBuilder<SettingCallback> changesIn(Setting setting) {
    return mapBinder.addBinding(setting);
}
 

public LinkedBindingBuilder<Tagger> addBinding() {
    return taggers.addBinding();
}
 

final protected LinkedBindingBuilder<HealthIndicator> bindAdditionalHealthIndicator() {
    return Multibinder.newSetBinder(binder(), HealthIndicator.class).addBinding();
}
 

public <M extends Model> LinkedBindingBuilder<ModelHandler<? super M>> bindHandler(TypeLiteral<M> model) {
    return (LinkedBindingBuilder) handlers.addBinding(model);
}
 

protected LinkedBindingBuilder<EurekaClientConfig > bindEurekaClientConfig() {
    return bind(EurekaClientConfig.class);
}
 

public static LinkedBindingBuilder<List<String>> bindBaseUrlProvider(Binder binder) {
  return binder.bind(new TypeLiteral<List<String>>() {}).annotatedWith(Names.named(BASE_URL_PROVIDER_NAME));
}
 

public static LinkedBindingBuilder<Optional<String>> bindAuthkeyProvider(Binder binder) {
  return binder.bind(new TypeLiteral<Optional<String>>() {}).annotatedWith(Names.named(AUTHKEY_PROVIDER_PROPERTY_NAME));
}
 

public LinkedBindingBuilder<ConnectionHandler<I, O>> bindConnectionHandler() {
    return bind(connectionHandlerKey);
}
 

protected LinkedBindingBuilder<RequestHandler<I, O>> bindRouter() {
    return bind(routerKey);
}
 

public static LinkedBindingBuilder<String> bindContextPath(Binder binder) {
  return binder.bind(String.class).annotatedWith(Names.named(CONTEXT_PATH_PROPERTY_NAME));
}
 

public LinkedBindingBuilder<ModelListener> bindListener() {
    return listeners.addBinding();
}
 

protected LinkedBindingBuilder<ArgumentResolverFactory<PlatformMessage, MessageBody>> addArgumentResolverBinding() {
	Preconditions.checkState(resolvers != null, "Must call super.configure() before calling addArgumentResolverBinding()");
	return resolvers.addBinding();
}
 

public <M extends Model> LinkedBindingBuilder<ModelHandler<? super M>> bindHandler(Class<M> model) {
    return (LinkedBindingBuilder) handlers.addBinding(model);
}
 

public LinkedBindingBuilder<ModelService<M, P>> bindService() {
    queryService().setBinding().to(ModelService(M, P));
    updateService().setBinding().to(ModelService(M, P));
    return serviceBinder.setBinding();
}
 

public LinkedBindingBuilder<ModelService<M, P>> bindDefaultService() {
    queryService().setDefault().to(ModelService(M, P));
    updateService().setDefault().to(ModelService(M, P));
    return serviceBinder.setDefault();
}
 

public LinkedBindingBuilder<ModelStore<M>> bindStore() {
    binder.provisionEagerly(ModelStore(M));
    new SuspendableBinder(binder).addBinding().to(ModelStore(M));
    return storeBinder.setBinding();
}
 

public LinkedBindingBuilder<ConnectionHandler<I, O>> bindConnectionHandler() {
    return bind(connectionHandlerKey);
}
 

public <T> LinkedBindingBuilder<JsonDeserializer<? extends T>> bindHiearchyDeserializer(Class<T> type) {
    return (LinkedBindingBuilder) hiearchyAdapters.addBinding(type);
}
 

public <T> LinkedBindingBuilder<JsonSerializer<? super T>> bindHiearchySerializer(Class<T> type) {
    return (LinkedBindingBuilder) hiearchyAdapters.addBinding(type);
}
 

public <T> LinkedBindingBuilder<TypeAdapter<T>> bindHiearchyAdapter(Class<T> type) {
    return (LinkedBindingBuilder) hiearchyAdapters.addBinding(type);
}
 

public <T> LinkedBindingBuilder<JsonDeserializer<? extends T>> bindDeserializer(TypeLiteral<T> type) {
    return (LinkedBindingBuilder) adapters.addBinding(type.getType());
}
 

public <T> LinkedBindingBuilder<JsonDeserializer<? extends T>> bindDeserializer(Class<T> type) {
    return (LinkedBindingBuilder) adapters.addBinding(type);
}