Class Index



AbstractMatcher<T> Implements and() and or()
AbstractModule A support class for Modules which reduces repetition and results in a more readable configuration. 
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. 

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. 


Binder Collects configuration information (primarily bindings) which will be used to create an Injector
Binding<T> A mapping from a key (type and optional annotation) to the strategy for getting instances of the type. 
BindingAnnotation Annotates annotations which are used for binding. 
BindingEdge<K> Interface for an edge that connects an interface to the type or instance that is bound to implement it. 
BindingEdge.Factory<K, T extends BindingEdge<K>> Factory interface for BindingEdges. 
BindingEdge.Type Classification for what kind of binding this edge represents. 
BindingEdgeFactory Graphviz-specific implementation of BindingEdge.Factory
BindingEdgeFactory.GraphvizEdgeAdaptor Adaptor class that converts BindingEdge methods to display operations on a GraphvizEdge
BindingScopingVisitor<V> Visits each of the strategies used to scope an injection. 
BindingTargetVisitor<T, V> Visits each of the strategies used to find an instance to satisfy an injection. 


CheckedProvider<T> Alternative to the Guice Provider that throws a checked Exception. 
CheckedProvides Annotates methods of a Module to create a CheckedProvider method binding that can throw exceptions. 
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


DefaultBindingScopingVisitor<V> No-op visitor for subclassing. 
DefaultBindingTargetVisitor<T, V> No-op visitor for subclassing. 
DefaultElementVisitor<V> No-op visitor for subclassing. 
Dependency<T> A variable that can be resolved by an injector. 
DependencyEdge<K> Interface for an edge from a class or InjectionPoint to the interface node that will satisfy the dependency. 
DependencyEdge.Factory<K, T extends DependencyEdge<K>> Factory interface for DependencyEdges. 
DependencyEdgeFactory Graphviz-specific implementation of DependencyEdge.Factory
DependencyEdgeFactory.GraphvizEdgeAdaptor Adaptor class that converts DependencyEdge methods to display operations on a GraphvizEdge
DisableCircularProxiesOption A request to disable circular proxies. 
DynamicFinder Utility that helps you introspect dynamic finder methods. 


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
ElementVisitor<V> Visit elements. 
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> This class is 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. 


GrapherModule Module for the common bindings for InjectorGrapher
GraphingVisitor<K, N extends InterfaceNode<K>, M extends ImplementationNode<K>, B extends BindingEdge<K>, D extends DependencyEdge<K>> BindingTargetVisitor that adds nodes and edges to the graph based on the visited Binding
GraphvizEdge Data object to encapsulate the attributes of Graphviz edges that we're interested in drawing. 
GraphvizModule Module that provides GraphvizRenderer as the Renderer and binds the other Graphviz factories. 
GraphvizNode Data object to encapsulate the attributes of Graphviz nodes that we're interested in drawing. 
GraphvizRenderer Renderer implementation that writes out a Graphviz DOT file of the graph. 
Guice The entry point to the Guice framework. 

Apply this filter in web.xml above all other filters (typically), to all requests where you plan to use servlet scopes. 

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<K> Node for classes and instances that have Dependencys and are bound to InterfaceNodes. 
ImplementationNode.Factory<K, T extends ImplementationNode<K>> Factory interface for ImplementationNodes. 
ImplementationNodeFactory Graphviz-specific implementation of ImplementationNode.Factory
ImplementationNodeFactory.GraphvizNodeAdaptor Adaptor class that converts ImplementationNode methods to display operations on a GraphvizNode
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 Root class for graphing an Injector
InstanceBinding<T> A binding to a single instance. 
InstanceFilterBinding A binding to a single instance of a filter. 
InstanceServletBinding A binding to a single instance of a servlet. 
InterceptorBinding Registration of interceptors for matching methods of matching classes. 
InterfaceNode<K> Node for an interface class that has been bound to an implementation class or instance. 
InterfaceNode.Factory<K, T extends InterfaceNode<K>> Factory interface for InterfaceNodes. 
InterfaceNodeFactory Graphviz-specific implementation of InterfaceNode.Factory
InterfaceNodeFactory.GraphvizNodeAdaptor Adaptor class that converts InterfaceNode methods to display operations on a GraphvizNode


JndiIntegration Integrates Guice with JNDI. 
JpaPersistModule JPA provider for guice persist. 


Key<T> Binding key consisting of an injection type and an optional annotation. 


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. 
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
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. 
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
NodeAliasFactory<K> Factory for aliasing one node ID to another. 
NodeIdFactory<K> Factory for abstract identifiers for elements on the graph. 
NodeShape Enum for the shapes that are most interesting for Guice graphing. 
NodeStyle Styles for nodes. 


OutOfScopeException Thrown from 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. 
ProvisionException Indicates that there was a runtime failure while providing an instance. 


Renderer Interface for the service that renders the graph. 
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. 
RequireExplicitBindingsOption A request to require explicit bindings. 


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. 
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 configureServlets() 
ServletModule.ServletKeyBindingBuilder See the EDSL examples at 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. 
StringNodeIdFactory IdFactory implementation that for String node IDs. 


ThrowingProvider<T, E extends Exception> This interface is deprecated. use CheckedProvider instead.  

Builds a binding for a CheckedProvider

ThrowingProviderBinder.SecondaryBinder<P extends CheckedProvider>  
Toolable Instructs an Injector running in TOOL that a method should be injected. 

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