Package com.google.inject.spi

Class Elements.RecordingBinder

java.lang.Object

com.google.inject.spi.Elements.RecordingBinder

All Implemented Interfaces:

Binder, PrivateBinder

Enclosing class:

Elements

private static class Elements.RecordingBinder
extends java.lang.Object
implements Binder, PrivateBinder

Field Summary

Fields

Modifier and Type	Field	Description
private java.util.List<Element>	elements
private java.util.Map<Module,Elements.ModuleInfo>	modules
private ModuleSource	moduleSource	The current modules stack
private Elements.RecordingBinder	parent	The binder where exposed bindings will be created
private java.util.List<Elements.RecordingBinder>	privateBinders	All children private binders, so we can scan through them.
private PrivateElementsImpl	privateElements
private java.util.Set<ModuleAnnotatedMethodScanner>	scanners
private java.lang.Object	source
private SourceProvider	sourceProvider
private Stage	stage

Constructor Summary

Constructors

Modifier	Constructor	Description
private	RecordingBinder(Elements.RecordingBinder parent, PrivateElementsImpl privateElements)	Creates a private recording binder.
private	RecordingBinder(Elements.RecordingBinder prototype, java.lang.Object source, SourceProvider sourceProvider)	Creates a recording binder that's backed by prototype.
private	RecordingBinder(Stage stage)

Method Summary

Modifier and Type	Method	Description
void	addError(Message message)	Records an error message to be presented to the user at a later time.
void	addError(java.lang.String message, java.lang.Object... arguments)	Records an error message which will be presented to the user at a later time.
void	addError(java.lang.Throwable t)	Records an exception, the full details of which will be logged, and the message of which will be presented to the user at a later time.
<T> AnnotatedBindingBuilder<T>	bind(Key<T> key)	See the EDSL examples at Binder.
<T> AnnotatedBindingBuilder<T>	bind(TypeLiteral<T> typeLiteral)	See the EDSL examples at Binder.
<T> AnnotatedBindingBuilder<T>	bind(java.lang.Class<T> type)	See the EDSL examples at Binder.
AnnotatedConstantBindingBuilder	bindConstant()	See the EDSL examples at Binder.
void	bindInterceptor(Matcher<? super java.lang.Class<?>> classMatcher, Matcher<? super java.lang.reflect.Method> methodMatcher, org.aopalliance.intercept.MethodInterceptor... interceptors)	Binds method interceptor[s] to methods matched by class and method matchers.
void	bindListener(Matcher<? super Binding<?>> bindingMatcher, ProvisionListener... listeners)	Registers listeners for provisioned objects.
void	bindListener(Matcher<? super TypeLiteral<?>> typeMatcher, TypeListener listener)	Registers a listener for injectable types.
void	bindScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, Scope scope)	Binds a scope to an annotation.
void	convertToTypes(Matcher<? super TypeLiteral<?>> typeMatcher, TypeConverter converter)	Binds a type converter.
Stage	currentStage()	Gets the current stage.
void	disableCircularProxies()	Prevents Guice from injecting dependencies that form a cycle, unless broken by a Provider.
void	expose(Key<?> key)	Makes the binding for key available to the enclosing environment
AnnotatedElementBuilder	expose(TypeLiteral<?> type)	Makes a binding for type available to the enclosing environment.
AnnotatedElementBuilder	expose(java.lang.Class<?> type)	Makes a binding for type available to the enclosing environment.
private <T> AnnotatedElementBuilder	exposeInternal(Key<T> key)
private ElementSource	getElementSource()
<T> MembersInjector<T>	getMembersInjector(TypeLiteral<T> typeLiteral)	Returns the members injector used to inject dependencies into methods and fields on instances of the given type T.
<T> MembersInjector<T>	getMembersInjector(java.lang.Class<T> type)	Returns the members injector used to inject dependencies into methods and fields on instances of the given type T.
private ModuleSource	getModuleSource(java.lang.Object module)
private java.lang.StackTraceElement[]	getPartialCallStack(java.lang.StackTraceElement[] callStack)	Removes the moduleSource call stack from the beginning of current call stack.
<T> Provider<T>	getProvider(Key<T> key)	Returns the provider used to obtain instances for the given injection key.
<T> Provider<T>	getProvider(Dependency<T> dependency)	Returns the provider used to obtain instances for the given injection key.
<T> Provider<T>	getProvider(java.lang.Class<T> type)	Returns the provider used to obtain instances for the given injection type.
void	install(Module module)	Uses the given module to configure more bindings.
PrivateBinder	newPrivateBinder()	Creates a new private child environment for bindings and other configuration.
<T> void	requestInjection(TypeLiteral<T> type, T instance)	Upon successful creation, the Injector will inject instance fields and methods of the given object.
void	requestInjection(java.lang.Object instance)	Upon successful creation, the Injector will inject instance fields and methods of the given object.
void	requestStaticInjection(java.lang.Class<?>... types)	Upon successful creation, the Injector will inject static fields and methods in the given classes.
void	requireAtInjectOnConstructors()	Requires that a @Inject annotation exists on a constructor in order for Guice to consider it an eligible injectable class.
void	requireExactBindingAnnotations()	Requires that Guice finds an exactly matching binding annotation.
void	requireExplicitBindings()	Instructs the Injector that bindings must be listed in a Module in order to be injected.
(package private) void	scanForAnnotatedMethods()	Applies all scanners to the modules we've installed.
void	scanModulesForAnnotatedMethods(ModuleAnnotatedMethodScanner scanner)	Adds a scanner that will look in all installed modules for annotations the scanner can parse, and binds them like @Provides methods.
Elements.RecordingBinder	skipSources(java.lang.Class... classesToSkip)	Returns a binder that skips classesToSkip when identify the calling code.
java.lang.String	toString()
Elements.RecordingBinder	withSource(java.lang.Object source)	Returns a binder that uses source as the reference location for configuration errors.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

stage

private final Stage stage

modules

private final java.util.Map<Module,Elements.ModuleInfo> modules

elements

private final java.util.List<Element> elements

source

private final java.lang.Object source

moduleSource

private ModuleSource moduleSource

The current modules stack

sourceProvider

private final SourceProvider sourceProvider

scanners

private final java.util.Set<ModuleAnnotatedMethodScanner> scanners

parent

private final Elements.RecordingBinder parent

The binder where exposed bindings will be created

privateElements

private final PrivateElementsImpl privateElements

privateBinders

private final java.util.List<Elements.RecordingBinder> privateBinders

All children private binders, so we can scan through them.

Constructor Detail

RecordingBinder

private RecordingBinder(Stage stage)

RecordingBinder

private RecordingBinder(Elements.RecordingBinder prototype,
                        java.lang.Object source,
                        SourceProvider sourceProvider)

Creates a recording binder that's backed by prototype.

RecordingBinder

private RecordingBinder(Elements.RecordingBinder parent,
                        PrivateElementsImpl privateElements)

Creates a private recording binder.

Method Detail

bindInterceptor

public void bindInterceptor(Matcher<? super java.lang.Class<?>> classMatcher,
                            Matcher<? super java.lang.reflect.Method> methodMatcher,
                            org.aopalliance.intercept.MethodInterceptor... interceptors)

Description copied from interface: Binder

Binds method interceptor[s] to methods matched by class and method matchers. A method is eligible for interception if:

• Guice created the instance the method is on
• Neither the enclosing type nor the method is final
• And the method is package-private, protected, or public

Specified by:

bindInterceptor in interface Binder

Parameters:

classMatcher - matches classes the interceptor should apply to. For example: only(Runnable.class).

methodMatcher - matches methods the interceptor should apply to. For example: annotatedWith(Transactional.class).

interceptors - to bind. The interceptors are called in the order they are given.

bindScope

public void bindScope(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                      Scope scope)

Description copied from interface: Binder

Binds a scope to an annotation.

Specified by:

bindScope in interface Binder

requestInjection

public void requestInjection(java.lang.Object instance)

Description copied from interface: Binder

Upon successful creation, the Injector will inject instance fields and methods of the given object.

Specified by:

requestInjection in interface Binder

Parameters:

instance - for which members will be injected

requestInjection

public <T> void requestInjection(TypeLiteral<T> type,
                                 T instance)

Description copied from interface: Binder

Upon successful creation, the Injector will inject instance fields and methods of the given object.

Specified by:

requestInjection in interface Binder

Parameters:

type - of instance

instance - for which members will be injected

getMembersInjector

public <T> MembersInjector<T> getMembersInjector(TypeLiteral<T> typeLiteral)

Description copied from interface: Binder

Returns the members injector used to inject dependencies into methods and fields on instances of the given type T. The returned members injector will not be valid until the main Injector has been created. The members injector will throw an IllegalStateException if you try to use it beforehand.

Specified by:

getMembersInjector in interface Binder

Parameters:

typeLiteral - type to get members injector for

getMembersInjector

public <T> MembersInjector<T> getMembersInjector(java.lang.Class<T> type)

Description copied from interface: Binder

Returns the members injector used to inject dependencies into methods and fields on instances of the given type T. The returned members injector will not be valid until the main Injector has been created. The members injector will throw an IllegalStateException if you try to use it beforehand.

Specified by:

getMembersInjector in interface Binder

Parameters:

type - type to get members injector for

bindListener

public void bindListener(Matcher<? super TypeLiteral<?>> typeMatcher,
                         TypeListener listener)

Description copied from interface: Binder

Registers a listener for injectable types. Guice will notify the listener when it encounters injectable types matched by the given type matcher.

Specified by:

bindListener in interface Binder

Parameters:

typeMatcher - that matches injectable types the listener should be notified of

listener - for injectable types matched by typeMatcher

bindListener

public void bindListener(Matcher<? super Binding<?>> bindingMatcher,
                         ProvisionListener... listeners)

Description copied from interface: Binder

Registers listeners for provisioned objects. Guice will notify the listeners just before and after the object is provisioned. Provisioned objects that are also injectable (everything except objects provided through Providers) can also be notified through TypeListeners registered in Binder.bindListener(com.google.inject.matcher.Matcher<? super com.google.inject.TypeLiteral<?>>, com.google.inject.spi.TypeListener).

Specified by:

bindListener in interface Binder

Parameters:

bindingMatcher - that matches bindings of provisioned objects the listener should be notified of

listeners - for provisioned objects matched by bindingMatcher

requestStaticInjection

public void requestStaticInjection(java.lang.Class<?>... types)

Description copied from interface: Binder

Upon successful creation, the Injector will inject static fields and methods in the given classes.

Specified by:

requestStaticInjection in interface Binder

Parameters:

types - for which static members will be injected

scanForAnnotatedMethods

void scanForAnnotatedMethods()

Applies all scanners to the modules we've installed. We skip certain PrivateModules because store them in more than one Modules map and only want to process them through one of the maps. (They're stored in both maps to prevent a module from being installed more than once.)

install

public void install(Module module)

Description copied from interface: Binder

Uses the given module to configure more bindings.

Specified by:

install in interface Binder

currentStage

public Stage currentStage()

Description copied from interface: Binder

Gets the current stage.

Specified by:

currentStage in interface Binder

addError

public void addError(java.lang.String message,
                     java.lang.Object... arguments)

Description copied from interface: Binder

Records an error message which will be presented to the user at a later time. Unlike throwing an exception, this enable us to continue configuring the Injector and discover more errors. Uses String.format(String, Object[]) to insert the arguments into the message.

Specified by:

addError in interface Binder

addError

public void addError(java.lang.Throwable t)

Description copied from interface: Binder

Records an exception, the full details of which will be logged, and the message of which will be presented to the user at a later time. If your Module calls something that you worry may fail, you should catch the exception and pass it into this.

Specified by:

addError in interface Binder

addError

public void addError(Message message)

Description copied from interface: Binder

Records an error message to be presented to the user at a later time.

Specified by:

addError in interface Binder

bind

public <T> AnnotatedBindingBuilder<T> bind(Key<T> key)

Description copied from interface: Binder

See the EDSL examples at Binder.

Specified by:

bind in interface Binder

bind

public <T> AnnotatedBindingBuilder<T> bind(TypeLiteral<T> typeLiteral)

Description copied from interface: Binder

See the EDSL examples at Binder.

Specified by:

bind in interface Binder

bind

public <T> AnnotatedBindingBuilder<T> bind(java.lang.Class<T> type)

Description copied from interface: Binder

See the EDSL examples at Binder.

Specified by:

bind in interface Binder

bindConstant

public AnnotatedConstantBindingBuilder bindConstant()

Description copied from interface: Binder

See the EDSL examples at Binder.

Specified by:

bindConstant in interface Binder

getProvider

public <T> Provider<T> getProvider(Key<T> key)

Description copied from interface: Binder

Returns the provider used to obtain instances for the given injection key. The returned provider will not be valid until the Injector has been created. The provider will throw an IllegalStateException if you try to use it beforehand.

Specified by:

getProvider in interface Binder

getProvider

public <T> Provider<T> getProvider(Dependency<T> dependency)

Description copied from interface: Binder

Returns the provider used to obtain instances for the given injection key. The returned provider will be attached to the injection point and will follow the nullability specified in the dependency. Additionally, the returned provider will not be valid until the Injector has been created. The provider will throw an IllegalStateException if you try to use it beforehand.

Specified by:

getProvider in interface Binder

getProvider

public <T> Provider<T> getProvider(java.lang.Class<T> type)

Description copied from interface: Binder

Returns the provider used to obtain instances for the given injection type. The returned provider will not be valid until the Injector has been created. The provider will throw an IllegalStateException if you try to use it beforehand.

Specified by:

getProvider in interface Binder

convertToTypes

public void convertToTypes(Matcher<? super TypeLiteral<?>> typeMatcher,
                           TypeConverter converter)

Description copied from interface: Binder

Binds a type converter. The injector will use the given converter to convert string constants to matching types as needed.

Specified by:

convertToTypes in interface Binder

Parameters:

typeMatcher - matches types the converter can handle

converter - converts values

withSource

public Elements.RecordingBinder withSource(java.lang.Object source)

Description copied from interface: Binder

Returns a binder that uses source as the reference location for configuration errors. This is typically a StackTraceElement for .java source but it could any binding source, such as the path to a .properties file.

Specified by:

withSource in interface Binder

Specified by:

withSource in interface PrivateBinder

Parameters:

source - any object representing the source location and has a concise toString() value

Returns:

a binder that shares its configuration with this binder

skipSources

public Elements.RecordingBinder skipSources(java.lang.Class... classesToSkip)

Description copied from interface: Binder

Returns a binder that skips classesToSkip when identify the calling code. The caller's StackTraceElement is used to locate the source of configuration errors.

Specified by:

skipSources in interface Binder

Specified by:

skipSources in interface PrivateBinder

Parameters:

classesToSkip - library classes that create bindings on behalf of their clients.

Returns:

a binder that shares its configuration with this binder.

newPrivateBinder

public PrivateBinder newPrivateBinder()

Description copied from interface: Binder

Creates a new private child environment for bindings and other configuration. The returned binder can be used to add and configuration information in this environment. See PrivateModule for details.

Specified by:

newPrivateBinder in interface Binder

Returns:

a binder that inherits configuration from this binder. Only exposed configuration on the returned binder will be visible to this binder.

disableCircularProxies

public void disableCircularProxies()

Description copied from interface: Binder

Prevents Guice from injecting dependencies that form a cycle, unless broken by a Provider. By default, circular dependencies are not disabled.

If a parent injector disables circular dependencies, then all child injectors (and private modules within that injector) also disable circular dependencies. If a parent does not disable circular dependencies, a child injector or private module may optionally declare itself as disabling circular dependencies. If it does, the behavior is limited only to that child or any grandchildren. No siblings of the child will disable circular dependencies.

Specified by:

disableCircularProxies in interface Binder

requireExplicitBindings

public void requireExplicitBindings()

Description copied from interface: Binder

Instructs the Injector that bindings must be listed in a Module in order to be injected. Classes that are not explicitly bound in a module cannot be injected. Bindings created through a linked binding (bind(Foo.class).to(FooImpl.class)) are allowed, but the implicit binding (FooImpl) cannot be directly injected unless it is also explicitly bound ( bind(FooImpl.class)).

Tools can still retrieve bindings for implicit bindings (bindings created through a linked binding) if explicit bindings are required, however Binding.getProvider() will fail.

By default, explicit bindings are not required.

If a parent injector requires explicit bindings, then all child injectors (and private modules within that injector) also require explicit bindings. If a parent does not require explicit bindings, a child injector or private module may optionally declare itself as requiring explicit bindings. If it does, the behavior is limited only to that child or any grandchildren. No siblings of the child will require explicit bindings.

In the absence of an explicit binding for the target, linked bindings in child injectors create a binding for the target in the parent. Since this behavior can be surprising, it causes an error instead if explicit bindings are required. To avoid this error, add an explicit binding for the target, either in the child or the parent.

Specified by:

requireExplicitBindings in interface Binder

requireAtInjectOnConstructors

public void requireAtInjectOnConstructors()

Description copied from interface: Binder

Requires that a @Inject annotation exists on a constructor in order for Guice to consider it an eligible injectable class. By default, Guice will inject classes that have a no-args constructor if no @Inject annotation exists on any constructor.

If the class is bound using LinkedBindingBuilder.toConstructor(java.lang.reflect.Constructor<S>), Guice will still inject that constructor regardless of annotations.

Specified by:

requireAtInjectOnConstructors in interface Binder

requireExactBindingAnnotations

public void requireExactBindingAnnotations()

Description copied from interface: Binder

Requires that Guice finds an exactly matching binding annotation. This disables the error-prone feature in Guice where it can substitute a binding for @Named Foo when attempting to inject @Named("foo") Foo.

Specified by:

requireExactBindingAnnotations in interface Binder

scanModulesForAnnotatedMethods

public void scanModulesForAnnotatedMethods(ModuleAnnotatedMethodScanner scanner)

Description copied from interface: Binder

Adds a scanner that will look in all installed modules for annotations the scanner can parse, and binds them like @Provides methods. Scanners apply to all modules installed in the injector. Scanners installed in child injectors or private modules do not impact modules in siblings or parents, however scanners installed in parents do apply to all child injectors and private modules.

Specified by:

scanModulesForAnnotatedMethods in interface Binder

expose

public void expose(Key<?> key)

Description copied from interface: PrivateBinder

Makes the binding for key available to the enclosing environment

Specified by:

expose in interface PrivateBinder

expose

public AnnotatedElementBuilder expose(java.lang.Class<?> type)

Description copied from interface: PrivateBinder

Makes a binding for type available to the enclosing environment. Use annotatedWith() to expose type with a binding annotation.

Specified by:

expose in interface PrivateBinder

expose

public AnnotatedElementBuilder expose(TypeLiteral<?> type)

Description copied from interface: PrivateBinder

Makes a binding for type available to the enclosing environment. Use annotatedWith() to expose type with a binding annotation.

Specified by:

expose in interface PrivateBinder

exposeInternal

private <T> AnnotatedElementBuilder exposeInternal(Key<T> key)

getModuleSource

private ModuleSource getModuleSource(java.lang.Object module)

getElementSource

private ElementSource getElementSource()

getPartialCallStack

private java.lang.StackTraceElement[] getPartialCallStack(java.lang.StackTraceElement[] callStack)

Removes the moduleSource call stack from the beginning of current call stack. It also removes the last two elements in order to make install(Module) the last call in the call stack.

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object