Package com.google.inject

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

See:
          Description

Interface Summary
Container Injects dependencies into constructors, methods and fields annotated with @Inject.
Context Context of the current injection.
ContextualFactory<T> Gets instances of T.
Factory<T> Gets instances of T.
Module A module contributes a set of configurations, typically interface bindings, to a ContainerBuilder which will later 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 implementation.
ContainerBuilder Builds a dependency injection Container.
Key<T> Binding key consisting of a type and a name.
Scopes Built in scope implementations.
TypeLiteral<T> Represents a generic type T.
 

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

Annotation Types Summary
ContainerScoped Apply this to implementation classes when you want one instance per container, as opposed to one instance per injection.
Inject Annotates members and parameters which should have their value[s] injected.
Scoped Annotates an implementation class with the name of its scope.
 

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.
ContainerBuilder
The object that Guice passes into your Module to collect these bindings.
Factory and ContextualFactory
The interface you will implement when you need to customize exactly how Guice creates instances for a particular binding. These differ only in whether a Context is made available to the factory.
Container
An object which creates and manages all the instances that make up your application. It is created by a ContainerBuilder after each of your Modules has been allowed to contribute its bindings. In most cases you will never need to interact directly with the container -- which is the main distinguishing feature of the Dependency Injection pattern from its rival, Service Locator.