Package com.google.inject

Google Guice (pronounced "juice") is an ultra-lightweight dependency injection container.

See:
          Description

Interface Summary
Binder Used by Module implementations to configure bindings.
Container Injects dependencies into constructors, methods and fields annotated with @Inject.
Context Context of the current injection.
Factory<T> Generates instances of T for a binding.
Locator<T> Locates bound instances of T.
Module A module contributes a set of binding configurations, typically interface bindings, to a Binder which is later used to create a Container.
Scope A scope which bound objects can reside in.
 

Class Summary
AbstractModule A support class for Modules which reduces repetition and results in a more readable configuration.
Binding<T> A binding from a Key (type and name) to an instance locator.
Guice The entry point to the Guice framework.
Key<T> Binding key consisting of an injection type and an optional annotation.
Scopes Built in scope implementations.
TypeLiteral<T> Represents a generic type T.
 

Enum Summary
Stage The stage we're running in.
 

Exception Summary
CreationException Thrown when errors occur while creating a Container.
 

Annotation Types Summary
BindingAnnotation Annotates annotations which are used for binding.
ContainerScoped Apply this to implementation classes when you want one instance per container, as opposed to one instance per injection.
Inject Annotates members of your implementation class (constructors, methods and fields) into which the container should inject references or values.
 

Package com.google.inject Description

Google Guice (pronounced "juice") is an ultra-lightweight dependency injection container. Please refer to the Guice User's Guide for a gentle introduction.

The principal public APIs in this package are:

Inject
The annotation you will use in your implementation classes to tell Guice where and how it should send in ("inject") the objects you depend on (your "dependencies").
Module
The interface you will implement in order to specify "bindings" -- instructions for how Guice should handle injection -- for a particular set of interfaces.
Binder
The object that Guice passes into your Module to collect these bindings.
Factory
The interface you will implement when you need to customize exactly how Guice creates instances for a particular binding.