Package org.elasticsearch.common.inject

Google Guice (pronounced "juice") is an ultra-lightweight dependency injection framework. 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.
Provider
The interface you will implement when you need to customize exactly how Guice creates instances for a particular binding.
  • Interface Summary 
    Interface Description
    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.
    Injector
    Builds the graphs of objects that make up your application.
    MembersInjector<T>
    Injects dependencies into the fields and methods on instances of type T.
    Module
    A module contributes configuration information, typically interface bindings, which will be used to create an Injector.
    PreProcessModule
    A module can implement this interface to allow to pre process other modules before an injector is created.
    PrivateBinder
    Returns a binder whose configuration information is hidden from its environment by default.
    Provider<T>
    An object capable of providing instances of type T.
    Scope
    A scope is a level of visibility that instances provided by Guice may have.
  • Class Summary 
    Class Description
    AbstractModule
    A support class for Modules which reduces repetition and results in a more readable configuration.
    Guice
    The entry point to the Guice framework.
    Key<T>
    Binding key consisting of an injection type and an optional annotation.
    ModulesBuilder  
    PrivateModule
    A module whose configuration information is hidden from its environment by default.
    Scopes
    Built-in scope implementations.
    TypeLiteral<T>
    Represents a generic type T.
  • Enum Summary 
    Enum Description
    Stage
    The stage we're running in.
  • Exception Summary 
    Exception Description
    ConfigurationException
    Thrown when a programming error such as a misplaced annotation, illegal binding, or unsupported scope is found.
    CreationException
    Thrown when errors occur while creating a Injector.
    OutOfScopeException
    Thrown from Provider.get() when an attempt is made to access a scoped object while the scope in question is not currently active.
    ProvisionException
    Indicates that there was a runtime failure while providing an instance.
  • Annotation Types Summary 
    Annotation Type Description
    BindingAnnotation
    Annotates annotations which are used for binding.
    Exposed
    Accompanies a @Provides method annotation in a private module to indicate that the provided binding is exposed.
    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.
    ProvidedBy
    A pointer to the default provider type for a type.
    Provides
    Annotates methods of a Module to create a provider method binding.
    ScopeAnnotation
    Annotates annotations which are used for scoping.
    Singleton
    Apply this to implementation classes when you want only one instance (per Injector) to be reused for all injections for that binding.