Java Key.get方法代码示例

import com.google.inject.Key; //导入方法依赖的package包/类
private <T> DriftClientBindingBuilder bindDriftClient(Class<T> clientInterface, String configPrefix, Class<? extends Annotation> annotation)
{
    Annotation clientAnnotation = getDriftClientAnnotation(clientInterface, annotation);

    configBinder(binder).bindConfig(DriftClientConfig.class, clientAnnotation, configPrefix);

    TypeLiteral<DriftClient<T>> typeLiteral = driftClientTypeLiteral(clientInterface);

    Provider<T> instanceProvider = new DriftClientInstanceProvider<>(clientAnnotation, Key.get(typeLiteral, annotation));
    Provider<DriftClient<T>> factoryProvider = new DriftClientProvider<>(clientInterface, clientAnnotation);

    binder.bind(Key.get(clientInterface, annotation)).toProvider(instanceProvider).in(Scopes.SINGLETON);
    binder.bind(Key.get(typeLiteral, annotation)).toProvider(factoryProvider).in(Scopes.SINGLETON);

    if (annotation == DefaultClient.class) {
        binder.bind(Key.get(clientInterface)).toProvider(instanceProvider).in(Scopes.SINGLETON);
        binder.bind(Key.get(typeLiteral)).toProvider(factoryProvider).in(Scopes.SINGLETON);
    }

    return new DriftClientBindingBuilder(binder, clientAnnotation, configPrefix);
}
 

import com.google.inject.Key; //导入方法依赖的package包/类
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()));
}
 

import com.google.inject.Key; //导入方法依赖的package包/类
public TypeMapBinder(Binder binder, @Nullable TypeLiteral<K> keyType, @Nullable TypeLiteral<V> valueType) {
    this.keyType = keyType != null ? keyType : new ResolvableType<K>(){}.in(getClass());
    this.valueType = valueType != null ? valueType : new ResolvableType<V>(){}.in(getClass());

    final TypeArgument<K> keyTypeArg = new TypeArgument<K>(this.keyType){};
    final TypeArgument<V> valueTypeArg = new TypeArgument<V>(this.valueType){};

    this.collectionKey = Key.get(new ResolvableType<TypeMap<K, V>>(){}.with(keyTypeArg, valueTypeArg));
    this.backingCollectionKey = Key.get(new ResolvableType<Map<TypeToken<? extends K>, Set<V>>>(){}.with(keyTypeArg, valueTypeArg));

    this.backingCollectionBinder = MapBinder.newMapBinder(
        binder,
        new ResolvableType<TypeToken<? extends K>>(){}.with(keyTypeArg),
        this.valueType
    ).permitDuplicates();

    binder.install(new KeyedManifest.Impl(collectionKey) {
        @Override
        public void configure() {
            final Provider<Map<TypeToken<? extends K>, Set<V>>> backingCollectionProvider = getProvider(backingCollectionKey);
            bind(collectionType()).toProvider(() -> ImmutableTypeMap.copyOf(backingCollectionProvider.get()));
        }
    });
}
 

import com.google.inject.Key; //导入方法依赖的package包/类
@Override
public synchronized T get(Class<? extends Annotation> bindingAnnotation) {
  BindingAnnotations.checkIsBindingAnnotation(bindingAnnotation);

  Key<T> key = Key.get(type, bindingAnnotation);
  return injector.getInstance(key);
}
 

import com.google.inject.Key; //导入方法依赖的package包/类
@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());
}
 

import com.google.inject.Key; //导入方法依赖的package包/类
public FeatureBinder(Binder binder, @Nullable TypeLiteral<T> type) {
    this.binder = binder;
    this.type = type != null ? type : new ResolvableType<T>(){}.in(getClass());
    this.typeArg = new TypeArgument<T>(this.type){};
    this.key = Key.get(this.type);

    binder.install(new FeatureManifest<>(this.type));
}
 

import com.google.inject.Key; //导入方法依赖的package包/类
private Key<SectionNode> bindProvider()
{
	if( key == null )
	{
		key = Key.get(SectionNode.class, this);
		bind(key).toProvider(this);
	}
	return key;
}
 

import com.google.inject.Key; //导入方法依赖的package包/类
protected SetBinder(Binder binder, @Nullable Key<T> key) {
    if(key == null) {
        key = Key.get(new ResolvableType<T>(){}.in(getClass()));
    }

    this.binder = binder.skipSources(SetBinder.class);
    this.elementType = key.getTypeLiteral();
    this.collectionType = new ResolvableType<Set<T>>(){}.with(new TypeArgument<T>(this.elementType){});
    this.multibinder = Multibinder.newSetBinder(binder, key);
}
 

import com.google.inject.Key; //导入方法依赖的package包/类
public static Key<?> dependencyKey(Key<?> key) {
    if(isImplicitProvider(key.getTypeLiteral())) {
        return Key.get(providedType((TypeLiteral<? extends Provider<Object>>) key.getTypeLiteral()));
    } else {
        return key;
    }
}
 

import com.google.inject.Key; //导入方法依赖的package包/类
public TransformableBinder(Binder binder, @Nullable Key<T> keyOrNull) {
    this.binder = binder.skipSources(TransformableBinder.class, TransformingProvider.class);
    this.key = keyOrNull != null ? keyOrNull : Key.get(new ResolvableType<T>(){}.in(getClass()));
    this.untransformedKey = Keys.get(key, new UntransformedImpl());

    final TypeLiteral<Transformer<T>> transformerType = new ResolvableType<Transformer<T>>(){}.with(new TypeArgument<T>(key.getTypeLiteral()){});
    final Annotation annotation = key.getAnnotation();
    this.transformerSetKey = Keys.get(Types.setOf(transformerType), annotation);
    this.transformerBinder = Multibinder.newSetBinder(this.binder, Keys.get(transformerType, annotation));

    this.binder.install(new TransformingProvider());
}
 

import com.google.inject.Key; //导入方法依赖的package包/类
protected <T> T get(Class<T> clazz) {
    T result = getFromSpring(clazz);
    if (result != null) {
        return result;
    }
    Key<T> key = Key.get(clazz);
    return injector.getInstance(key);
}
 

import com.google.inject.Key; //导入方法依赖的package包/类
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){}));
}
 

import com.google.inject.Key; //导入方法依赖的package包/类
public ProvisionAtParseTime(Class<T> type) {
    this(Key.get(type));
}
 

import com.google.inject.Key; //导入方法依赖的package包/类
public static <T> Key<T> get(TypeLiteral<T> type, @Nullable Annotation annotation) {
    return annotation == null ? Key.get(type) : Key.get(type, annotation);
}
 

import com.google.inject.Key; //导入方法依赖的package包/类
/**
 * Binds a {@link DynamicBindingProvider} for the specified class.
 *
 * <p>The instance bound to the class can later be retrieved through
 * {@link DynamicBindingProvider#get(Class)} given the same annotation provided during binding
 * time. This method also 'requires' a binding of {@code clazz} to {@code annotation} to exist.
 *
 * <p>This method requires a binder, and must be used from a Guice module that is in the
 * configure phase.
 *
 * @param binder the Guice binder to bind with
 * @param clazz the class to create a {@link DynamicBindingProvider} for
 * @param annotation the binding annotation that must be bound with the provided class
 */
static <T> void bindDynamicProvider(
    Binder binder, Class<T> clazz, Class<? extends Annotation> annotation) {
  binder.getProvider(Key.get(clazz, annotation));

  ParameterizedType type = Types.newParameterizedType(DynamicBindingProvider.class, clazz);
  DynamicBindingProvider<T> provider = new DynamicBindingProviderImpl<T>(TypeLiteral.get(clazz));
  @SuppressWarnings("unchecked")
  Key<DynamicBindingProvider<T>> key = (Key<DynamicBindingProvider<T>>) Key.get(type);
  binder.bind(key).toInstance(provider);
}