All Classes and Interfaces
Class
Description
Base class used to create a new binding with the Guice EDSL described in
Binder.Implements
and() and or().AbstractModule is a helper class used to add bindings to the Guice injector.
See the EDSL examples at
Binder.See the EDSL examples at
Binder.See the EDSL examples at
Binder.Annotation utilities.
Collects configuration information (primarily bindings) which will be used to create an
Injector.A mapping from a
Key to the strategy for getting instances of the type.Annotates annotations which are used for binding.
Bind a non-constant key.
Visits each of the strategies used to scope an injection.
Contains abstractions for enforcing
RestrictedBindingSource.Visits each of the strategies used to find an instance to satisfy an injection.
Utility methods for circular proxies, faster reflection, and method interception.
Builder of enhanced classes.
Entry-point for building enhanced classes and 'fast-class' invocation.
Entry-point for defining dynamically generated classes.
Class utilities.
Allows @
ProvidesIntoMap to specify a class map key.Thrown when a programming error such as a misplaced annotation, illegal binding, or unsupported
scope is found.
Binds to a constant value.
Bind a constant.
A binding to the constructor of a concrete clss.
A continuously timing stopwatch that is used for simple performance monitoring.
A binding created from converting a bound instance to a new type.
Thrown when errors occur while creating a
Injector.Utility class for retrieving declared fields or methods in a particular order, because the JVM
doesn't guarantee ordering for listing declared methods.
No-op visitor for subclassing.
No-op visitor for subclassing.
No-op visitor for subclassing.
A variable that can be resolved by an injector.
A request to disable circular proxies.
A core component of a module or injector.
Exposes elements of a module so they can be inspected, validated or
rewritten.Contains information about where and how an
element was bound.Visit elements.
Details about a single Guice error and supports formatting itself in the context of other Guice
errors.
Enum used to identify a specific Guice error.
A collection of error messages.
Indicates that a result could not be returned while preparing or resolving a binding.
Acccompanies a @
Provides method annotation in a
private module to indicate that the provided binding is exposed.A binding to a key exposed from an enclosed private environment.
For private binder's expose() method.
Lazily creates (and caches) values for keys.
Generic error message representing a Guice internal error.
The entry point to the Guice framework.
Class used for restricting APIs in other packages to only be used by this package.
A pointer to the default implementation of a type.
Annotates members of your implementation class (constructors, methods and fields) into which the
Injector should inject values.Listens for injections into instances of type
I.A constructor, field or method that can receive injections.
A request to inject the instance fields and methods of an instance.
Builds the graphs of objects that make up your application.
A binding to a single instance.
Registration of interceptors for matching methods of matching classes.
Contains flags for Guice.
Options for controlling whether Guice uses bytecode generation at runtime.
Options for enable or disable using ansi color in error messages.
The options for Guice custom class loading.
The options for Guice stack trace collection.
Options for handling nullable parameters used in provides methods.
Builds a tree of injectors.
A checked exception for provisioning errors.
Guice uses Key objects to identify a dependency that can be resolved by the Guice
Injector.Class to conditionally load support for Kotlin features.
Interface for accessing information about Kotlin code.
See the EDSL examples at
Binder.A binding to a linked key.
An API to bind multiple map entries separately, only to later inject them as a complete map.
A binding for a MapBinder.
Allows users define customized key type annotations for map bindings by annotating an annotation
of a
Map's key type.Returns
true or false for a given input.Matcher implementations.
Injects dependencies into the fields and methods on instances of type
T.A lookup of the members injector for a type.
An error message and the context in which it occured.
Utility methods for
Message objectsA module contributes configuration information, typically interface bindings, which will be used
to create an
Injector.Allows extensions to scan modules for annotated methods and bind those methods as providers,
similar to
@Provides methods.Represents a call to
Binder.scanModulesForAnnotatedMethods(com.google.inject.spi.ModuleAnnotatedMethodScanner) in a module.Static utility methods for creating and working with instances of
Module.See the EDSL example at
override().Static methods for working with types that we aren't publishing in the public
Types API.The WildcardType interface supports multiple upper bounds and multiple lower bounds.
An API to bind multiple values separately, only to later inject them as a complete collection.
A binding for a Multibinder.
Deprecated.
This functionality is installed by default.
A visitor for the multibinder extension.
Annotates named things.
Utility methods for use with
@Named.Whether a member supports null values injected.
An API to bind optional values, optionally with a default value.
A binding for a OptionalBinder.
Thrown from
Provider.get() when an attempt is made to access a scoped object while the
scope in question is not currently active.Returns a binder whose configuration information is hidden from its environment by default.
A private collection of elements that are hidden from the enclosing injector or module by
default.
A module whose configuration information is hidden from its environment by default.
A pointer to the default provider type for a type.
An object capable of providing instances of type
T.A binding to a
Provider that delegates to the binding for the provided type.A binding to a provider instance.
A binding to a provider key.
A lookup of the provider for a type.
A provider that invokes a method and returns its result.
Creates bindings to methods annotated with @
Provides.Static utility methods for creating and working with instances of
Provider.A provider with dependencies on other injected types.
A Provider that is part of an extension which supports a custom BindingTargetVisitor.
Annotates methods of a
Module to create a provider method binding.Annotates methods of a
Module to add items to a Multibinder.Annotates methods of a
Module to add items to a Multibinder.An @
Provides binding or binding produced by a ModuleAnnotatedMethodScanner.A visitor for the @
Provides bindings.Indicates that there was a runtime failure while providing an instance.
Listens for provisioning of objects.
Encapsulates a single act of provisioning.
Binds keys (picked using a Matcher) to a provision listener.
The actual mapbinder plays several roles:
The actual multibinder plays several roles:
The actual OptionalBinder plays several roles.
A request to require explicit @
Inject annotations on constructors.A request to require exact binding annotations.
A request to require explicit bindings.
Annotation restricting the binding of the target type to permitted sources.
Meta-annotation indicating that the target annotation is a permit for binding restricted
bindings.
Level of restriction.
A scope is a level of visibility that instances provided by Guice may have.
Annotates annotations which are used for scoping.
Registration of a scope annotation with the scope that implements it.
See the EDSL examples at
Binder.Built-in scope implementations.
References a scope, either directly (as a scope instance), or indirectly (as a scope annotation).
Apply this to implementation classes when you want only one instance (per
Injector) to be
reused for all injections for that binding.One instance per
Injector.Provides access to the calling line of code.
Creates stack trace elements for members.
In-Memory version of
StackTraceElement that does not store the file name.The stage we're running in.
A request to inject the static fields and methods of a type.
Allows @
ProvidesIntoMap to specify a string map key.Instructs an
Injector running in Stage.TOOL that a method should be injected.Converts constant string values to a different type.
Registration of type converters for matching target types.
Context of an injectable type encounter.
Listens for Guice to encounter injectable types.
Binds types (picked using a Matcher) to an type listener.
Represents a generic type
T.Static methods for working with types.
An untargetted binding.