All Classes

Class	Description
AbstractInjectorGrapher	Abstract injector grapher that builds the dependency graph but doesn't render it.
AbstractInjectorGrapher.GrapherParameters	Parameters used to override default settings of the grapher.
AbstractMatcher<T>	Implements and() and or().
AbstractModule	AbstractModule is a helper class used to add bindings to the Guice injector.
Alias	Alias between two nodes.
AliasCreator	Creator of node aliases.
AnnotatedBindingBuilder<T>	See the EDSL examples at Binder.
AnnotatedConstantBindingBuilder	See the EDSL examples at Binder.
AnnotatedElementBuilder	See the EDSL examples at Binder.
ArrowType	Arrow symbols that are available from Graphviz.
Assisted	Annotates an injected parameter or field whose value comes from an argument to a factory method.
AssistedInject	When used in tandem with FactoryModuleBuilder, constructors annotated with @AssistedInject indicate that multiple constructors can be injected, each with different parameters.
AssistedInjectBinding<T>	A binding for a factory created by FactoryModuleBuilder.
AssistedInjectTargetVisitor<T,V>	A visitor for the AssistedInject extension.
AssistedMethod	Details about how a method in an assisted inject factory will be assisted.
Bind	Annotation used by BoundFieldModule to indicate that a field should be bound to its value using Guice.
Binder	Collects configuration information (primarily bindings) which will be used to create an Injector.
Binding<T>	A mapping from a Key to the strategy for getting instances of the type.
BindingAnnotation	Annotates annotations which are used for binding.
BindingEdge	Edge that connects an interface to the type or instance that is bound to implement it.
BindingEdge.Type	Classification for what kind of binding this edge represents.
BindingScopingVisitor<V>	Visits each of the strategies used to scope an injection.
BindingSourceRestriction	Contains abstractions for enforcing RestrictedBindingSource.
BindingTargetVisitor<T,V>	Visits each of the strategies used to find an instance to satisfy an injection.
BoundFieldModule	A Guice module that automatically adds Guice bindings into the injector for all Bind annotated fields of a specified object.
BoundFieldModule.BoundFieldInfo	Information about a field bound by BoundFieldModule.
BoundFieldModule.WithPermits	Wrapper of BoundFieldModule which enables attaching {@link @RestrictedBindingSource} permits to instances of it.
CheckedProvider<T>	Alternative to the Guice Provider that throws a checked Exception.
CheckedProviders	Static utility methods for creating and working with instances of CheckedProvider.
CheckedProviderSubject<T,P extends CheckedProvider<T>>	Truth Subject for use with CheckedProvider classes.
CheckedProvides	Annotates methods of a Module to create a CheckedProvider method binding that can throw exceptions.
ClassMapKey	Allows @ProvidesIntoMap to specify a class map key.
CompassPoint	Enum for the "compass point" values used to control where edge end points appear on the graph.
ConfigurationException	Thrown when a programming error such as a misplaced annotation, illegal binding, or unsupported scope is found.
ConstantBindingBuilder	Binds to a constant value.
ConstructorBinding<T>	A binding to the constructor of a concrete clss.
ConvertedConstantBinding<T>	A binding created from converting a bound instance to a new type.
CreationException	Thrown when errors occur while creating a Injector.
DaggerAdapter	Adapts classes annotated with {@link @dagger.Module} such that their {@link @dagger.Provides} methods can be properly invoked by Guice to perform their provision operations.
DaggerAdapter.Builder	Builder for setting configuration options on DaggerAdapter.
DefaultBindingScopingVisitor<V>	No-op visitor for subclassing.
DefaultBindingTargetVisitor<T,V>	No-op visitor for subclassing.
DefaultElementVisitor<V>	No-op visitor for subclassing.
DefaultRootKeySetCreator	Root key set creator that starts with all types that are not Guice internal types or the Logger type.
Dependency<T>	A variable that can be resolved by an injector.
DependencyEdge	Edge from a class or InjectionPoint to the interface node that will satisfy the dependency.
DisableCircularProxiesOption	A request to disable circular proxies.
DynamicFinder	Utility that helps you introspect dynamic finder methods.
Edge	Edge in a guice dependency graph.
EdgeCreator	Creator of graph edges to render.
EdgeStyle	Styles for edges.
Element	A core component of a module or injector.
Elements	Exposes elements of a module so they can be inspected, validated or rewritten.
ElementSource	Contains information about where and how an element was bound.
ElementVisitor<V>	Visit elements.
ErrorDetail<SelfT extends ErrorDetail<SelfT>>	Details about a single Guice error and supports formatting itself in the context of other Guice errors.
Exposed	Acccompanies a @Provides method annotation in a private module to indicate that the provided binding is exposed.
ExposedBinding<T>	A binding to a key exposed from an enclosed private environment.
FactoryModuleBuilder	Provides a factory that combines the caller's arguments with injector-supplied values to construct objects.
FactoryProvider<F>	Deprecated. use FactoryModuleBuilder instead.
Finder	Marks a method stub as a dynamic finder.
FirstResult	Annotate any dynamic finder method's integer argument with this to pass in the index of the first result in the result set you are interested in.
GraphvizEdge	Data object to encapsulate the attributes of Graphviz edges that we're interested in drawing.
GraphvizGrapher	InjectorGrapher implementation that writes out a Graphviz DOT file of the graph.
GraphvizModule	Module that provides classes needed by GraphvizGrapher.
GraphvizNode	Data object to encapsulate the attributes of Graphviz nodes that we're interested in drawing.
Guice	The entry point to the Guice framework.
GuiceFilter	Apply this filter in web.xml above all other filters (typically), to all requests where you plan to use servlet scopes.
GuiceObjectFactory	Deprecated. Use Struts2Factory instead.
GuiceServletContextListener	As of Guice 2.0 you can still use (your subclasses of) GuiceServletContextListener class as a logical place to create and configure your injector.
HasDependencies	Implemented by bindings, providers and instances that expose their dependencies explicitly.
ImplementationNode	Node for types that have Dependencys and are bound to InterfaceNodes.
ImplementedBy	A pointer to the default implementation of a type.
Inject	Annotates members of your implementation class (constructors, methods and fields) into which the Injector should inject values.
InjectionListener<I>	Listens for injections into instances of type I.
InjectionPoint	A constructor, field or method that can receive injections.
InjectionRequest<T>	A request to inject the instance fields and methods of an instance.
Injector	Builds the graphs of objects that make up your application.
InjectorGrapher	Guice injector grapher.
InstanceBinding<T>	A binding to a single instance.
InstanceFilterBinding	A binding to a single instance of a filter.
InstanceNode	Node for instances.
InstanceServletBinding	A binding to a single instance of a servlet.
InterceptorBinding	Registration of interceptors for matching methods of matching classes.
InterfaceNode	Node for an interface type that has been bound to an implementation class or instance.
JndiIntegration	Integrates Guice with JNDI.
JpaPersistModule	JPA provider for guice persist.
Key<T>	Guice uses Key objects to identify a dependency that can be resolved by the Guice Injector.
LinkedBindingBuilder<T>	See the EDSL examples at Binder.
LinkedFilterBinding	A linked binding to a filter.
LinkedKeyBinding<T>	A binding to a linked key.
LinkedServletBinding	A linked binding to a servlet.
ManagedBindingMBean	JMX interface to bindings.
Manager	Provides a JMX interface to Guice.
MapBinder<K,V>	An API to bind multiple map entries separately, only to later inject them as a complete map.
MapBinderBinding<T>	A binding for a MapBinder.
MapKey	Allows users define customized key type annotations for map bindings by annotating an annotation of a Map's key type.
Matcher<T>	Returns true or false for a given input.
Matchers	Matcher implementations.
MaxResults	Annotate any dynamic finder method's integer argument with this to pass in the maximum size of returned result window.
MembersInjector<T>	Injects dependencies into the fields and methods on instances of type T.
MembersInjectorLookup<T>	A lookup of the members injector for a type.
Message	An error message and the context in which it occured.
Module	A module contributes configuration information, typically interface bindings, which will be used to create an Injector.
ModuleAnnotatedMethodScanner	Allows extensions to scan modules for annotated methods and bind those methods as providers, similar to @Provides methods.
ModuleAnnotatedMethodScannerBinding	Represents a call to Binder.scanModulesForAnnotatedMethods(com.google.inject.spi.ModuleAnnotatedMethodScanner) in a module.
Modules	Static utility methods for creating and working with instances of Module.
Modules.OverriddenModuleBuilder	See the EDSL example at override().
Multibinder<T>	An API to bind multiple values separately, only to later inject them as a complete collection.
MultibinderBinding<T>	A binding for a Multibinder.
MultibindingsScanner	Deprecated. This functionality is installed by default.
MultibindingsTargetVisitor<T,V>	A visitor for the multibinder extension.
Named	Annotates named things.
NameFactory	Interface for a service that provides nice Strings that we can display in the graph for the types that come up in Bindings.
Names	Utility methods for use with @Named.
Node	Node in a guice dependency graph.
NodeCreator	Creator of graph nodes.
NodeId	ID of a node in the graph.
NodeId.NodeType	Type of node.
NodeShape	Enum for the shapes that are most interesting for Guice graphing.
NodeStyle	Styles for nodes.
OptionalBinder<T>	An API to bind optional values, optionally with a default value.
OptionalBinderBinding<T>	A binding for a OptionalBinder.
OutOfScopeException	Thrown from Provider.get() when an attempt is made to access a scoped object while the scope in question is not currently active.
PersistFilter	Apply this filter to enable the HTTP Request unit of work and to have guice-persist manage the lifecycle of active units of work.
PersistModule	Install this module to add guice-persist library support for JPA persistence providers.
PersistService	Persistence provider service.
PortIdFactory	Interface for a service that returns Graphviz port IDs, used for naming the rows in ImplementationNode-displaying GraphvizNodes.
PortIdFactoryImpl	Implementation of PortIdFactory.
PrivateBinder	Returns a binder whose configuration information is hidden from its environment by default.
PrivateElements	A private collection of elements that are hidden from the enclosing injector or module by default.
PrivateModule	A module whose configuration information is hidden from its environment by default.
ProvidedBy	A pointer to the default provider type for a type.
Provider<T>	An object capable of providing instances of type T.
ProviderBinding<T extends Provider<?>>	A binding to a Provider that delegates to the binding for the provided type.
ProviderInstanceBinding<T>	A binding to a provider instance.
ProviderKeyBinding<T>	A binding to a provider key.
ProviderLookup<T>	A lookup of the provider for a type.
Providers	Static utility methods for creating and working with instances of Provider.
ProviderWithDependencies<T>	A provider with dependencies on other injected types.
ProviderWithExtensionVisitor<T>	A Provider that is part of an extension which supports a custom BindingTargetVisitor.
Provides	Annotates methods of a Module to create a provider method binding.
ProvidesIntoMap	Annotates methods of a Module to add items to a MapBinder.
ProvidesIntoOptional	Annotates methods of a Module to add items to a Multibinder.
ProvidesIntoOptional.Type
ProvidesIntoSet	Annotates methods of a Module to add items to a Multibinder.
ProvidesMethodBinding<T>	An @Provides binding or binding produced by a ModuleAnnotatedMethodScanner.
ProvidesMethodTargetVisitor<T,V>	A visitor for the @Provides bindings.
ProvisionException	Indicates that there was a runtime failure while providing an instance.
ProvisionListener	Listens for provisioning of objects.
ProvisionListener.ProvisionInvocation<T>	Encapsulates a single act of provisioning.
ProvisionListenerBinding	Binds keys (picked using a Matcher) to a provision listener.
RequestParameters	Apply this to field or parameters of type Map<String, String[]> when you want the HTTP request parameter map to be injected.
RequestScoped	Apply this to implementation classes when you want one instance per request.
RequestScoper	Object that can be used to apply a request scope to a block of code.
RequestScoper.CloseableScope	Closeable subclass that does not throw any exceptions from close.
RequireAtInjectOnConstructorsOption	A request to require explicit @Inject annotations on constructors.
RequireExactBindingAnnotationsOption	A request to require exact binding annotations.
RequireExplicitBindingsOption	A request to require explicit bindings.
RestrictedBindingSource	Annotation restricting the binding of the target type to permitted sources.
RestrictedBindingSource.Permit	Meta-annotation indicating that the target annotation is a permit for binding restricted bindings.
RestrictedBindingSource.RestrictionLevel	Level of restriction.
RootKeySetCreator	Creator of the default starting set of keys to graph.
Scope	A scope is a level of visibility that instances provided by Guice may have.
ScopeAnnotation	Annotates annotations which are used for scoping.
ScopeBinding	Registration of a scope annotation with the scope that implements it.
ScopedBindingBuilder	See the EDSL examples at Binder.
Scopes	Built-in scope implementations.
ScopingException	Exception thrown when there was a failure entering request scope.
ScopingOnly	Annotates a GuiceFilter that provides scope functionality, but doesn't dispatch to ServletModule bound servlets or filters.
ServletModule	Configures the servlet scopes and creates bindings for the servlet API objects so you can inject the request, response, session, etc.
ServletModule.FilterKeyBindingBuilder	See the EDSL examples at ServletModule.configureServlets()
ServletModule.ServletKeyBindingBuilder	See the EDSL examples at ServletModule.configureServlets()
ServletModuleBinding	A binding created by ServletModule.
ServletModuleTargetVisitor<T,V>	A visitor for the servlet extension.
ServletScopes	Servlet scopes.
SessionScoped	Apply this to implementation classes when you want one instance per session.
ShortNameFactory	Reasonable implementation for NameFactory.
Singleton	Apply this to implementation classes when you want only one instance (per Injector) to be reused for all injections for that binding.
SpringIntegration	Integrates Guice with Spring.
Stage	The stage we're running in.
StaticInjectionRequest	A request to inject the static fields and methods of a type.
StringMapKey	Allows @ProvidesIntoMap to specify a string map key.
Struts2Factory	Cleanup up version from Bob's GuiceObjectFactory.
Struts2GuicePluginModule	Initializes the Struts 2 Guice Plugin.
ThrowingInject	A version of @Inject designed for ThrowingProviders.
ThrowingProvider<T,E extends Exception>	Deprecated. use CheckedProvider instead.
ThrowingProviderBinder	Builds a binding for a CheckedProvider.
Toolable	Instructs an Injector running in Stage.TOOL that a method should be injected.
Transactional	Any method or class marked with this annotation will be considered for transactionality.
TransitiveDependencyVisitor	BindingTargetVisitor that returns a Collection of the Keys of each Binding's dependencies.
TypeConverter	Converts constant string values to a different type.
TypeConverterBinding	Registration of type converters for matching target types.
TypeEncounter<I>	Context of an injectable type encounter.
TypeListener	Listens for Guice to encounter injectable types.
TypeListenerBinding	Binds types (picked using a Matcher) to an type listener.
TypeLiteral<T>	Represents a generic type T.
Types	Static methods for working with types.
UnitOfWork	This interface is used to gain manual control over the unit of work.
UntargettedBinding<T>	An untargetted binding.
UriPatternType	An enumeration of the available URI-pattern matching styles