InjectorBuilder (Grapht Dependency Injector 0.11.0-BETA2 API)

java.lang.Object
- org.grouplens.grapht.AbstractContext
- - org.grouplens.grapht.InjectorBuilder

All Implemented Interfaces:

Context
```
public class InjectorBuilder
extends AbstractContext
```
InjectorBuilder is a Builder implementation that is capable of creating a simple Injector. Additionally, it is root Context to make configuring the built Injector as easy as possible. Injectors created by InjectorBuilder instances memoize their created objects.

Internally, it uses an BindingFunctionBuilder to accumulate bind rules and a DefaultInjector to resolve dependencies.

Author:

GroupLens Research

Constructor Summary

Constructors
Constructor and Description

InjectorBuilder(Module... modules)
Deprecated.
use create(Module...) instead

Constructors
Constructor and Description
`InjectorBuilder(Module... modules)` Deprecated. use `create(Module...)` instead

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`InjectorBuilder`	`applyModule(Module module)` Apply a module to the root context of this InjectorBuilder (i.e.
`Context`	`at(Annotation annot, Class<?> type)` Create a new Context that extends the current context stack with the given class, qualified by the specific Annotation instance.
`Context`	`at(Class<?> type)` Create a new Context that extends the current context stack with the given class type as an anchored match.
`Context`	`at(Class<? extends Annotation> qualifier, Class<?> type)` Create a new Context that extends the current context stack with the given class and `Qualifier` annotation as an anchored match.
`<T> Binding<T>`	`bind(Class<T> type)` Start a new binding for the given type T within the scope of this context.
`<T> Binding<T>`	`bindAny(Class<T> type)` Start a new binding for a type irrespective of qualifier.
`Injector`	`build()`
`static InjectorBuilder`	`create(ClassLoader loader, Module... modules)` Create a new injector builder using the specified class loader.
`static InjectorBuilder`	`create(Module... modules)` Create a new injector builder with the default SPI.
`Context`	`matching(ContextPattern pattern)` Restruct context to matching a particular pattern.
`InjectorBuilder`	`setDefaultCachePolicy(CachePolicy policy)` Set the default cache policy used by injectors created by this builder.
`InjectorBuilder`	`setProviderInjectionEnabled(boolean enable)` Set whether or not to enable provider injection support in the built Injectors.
`Context`	`within(Annotation annot, Class<?> type)` Create a new Context that extends the current context stack with the given class, qualified by the specific Annotation instance.
`Context`	`within(Class<?> type)` Create a new Context that extends the current context stack with the given class type.
`Context`	`within(Class<? extends Annotation> qualifier, Class<?> type)` Create a new Context that extends the current context stack with the given class and `Qualifier` annotation.

Methods inherited from class org.grouplens.grapht.AbstractContext
bind, in, in, in

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - InjectorBuilder
```
@Deprecated
public InjectorBuilder(Module... modules)
```
    Deprecated. use create(Module...) instead
    
    Create a new InjectorBuilder that automatically applies the given Modules via applyModule(Module). Additional Modules can be applied later as well. Configuration via the Context interface is also possible (and recommended if Modules aren't used) before calling build().
    
    Parameters:
    
    modules - Any modules to apply immediately
- Method Detail
  - create
```
public static InjectorBuilder create(ClassLoader loader,
                                     Module... modules)
```
    Create a new injector builder using the specified class loader.
    
    Parameters:
    
    loader - The class loader.
    
    modules - The initial modules to configure.
    
    Returns:
    
    The injector builder.
  - create
```
public static InjectorBuilder create(Module... modules)
```
    Create a new injector builder with the default SPI.
    
    Parameters:
    
    modules - The initial modules to configure.
    
    Returns:
    
    The injector builder.
  - setDefaultCachePolicy
```
public InjectorBuilder setDefaultCachePolicy(CachePolicy policy)
```
    Set the default cache policy used by injectors created by this builder.
    
    Parameters:
    
    policy - The default policy
    
    Returns:
    
    This builder
    
    Throws:
    
    NullPointerException - if policy is null
    
    IllegalArgumentException - if policy is NO_PREFERENCE
  - setProviderInjectionEnabled
```
public InjectorBuilder setProviderInjectionEnabled(boolean enable)
```
    Set whether or not to enable provider injection support in the built Injectors.
    
    Parameters:
    
    enable - True if the injector should support "provider injection"
    
    Returns:
    
    This builder
  - bind
```
public <T> Binding<T> bind(Class<T> type)
```
    Description copied from interface: Context
    
    Start a new binding for the given type T within the scope of this context. The returned Binding instance can be configured and completed by invoking one of its various to() methods. Unless further configuration is done, this binding will match unqualified dependencies and dependencies with a qualifier annotated with AllowUnqualifiedMatch.
    
    Type Parameters:
    
    T - The matched source type
    
    Parameters:
    
    type - The raw class that is matched
    
    Returns:
    
    A new binding in this context for type T
  - bindAny
```
public <T> Binding<T> bindAny(Class<T> type)
```
    Description copied from interface: Context
    
    Start a new binding for a type irrespective of qualifier. This is a shortcut for bind(type).withAnyQualifier().
    
    Specified by:
    
    bindAny in interface Context
    
    Overrides:
    
    bindAny in class AbstractContext
    
    Parameters:
    
    type - The type.
    
    Returns:
    
    A new binding in this context for type T with any (or no) qualifier.
  - within
```
public Context within(Class<?> type)
```
    Description copied from interface: Context
    
    Create a new Context that extends the current context stack with the given class type. This matches with the default Qualifier. This is equivalent to within(null, type);
    
    Parameters:
    
    type - The type to extend this context by
    
    Returns:
    
    A new Context with a longer context stack
  - within
```
public Context within(Class<? extends Annotation> qualifier,
                      Class<?> type)
```
    Description copied from interface: Context
    
    Create a new Context that extends the current context stack with the given class and Qualifier annotation. If the qualifier is null, the default or null qualifier is used.
    
    Parameters:
    
    qualifier - The qualifier type that must be matched along with the type
    
    type - The type to extend this context by
    
    Returns:
    
    A new Context with a longer context stack
  - within
```
public Context within(Annotation annot,
                      Class<?> type)
```
    Description copied from interface: Context
    
    Create a new Context that extends the current context stack with the given class, qualified by the specific Annotation instance. If the qualifier is null, the default or null qualifier is used.
    The annotation provided must be serializable. Annotations built by AnnotationBuilder (recommended) or retrieved from the Java reflection API are serializable; if you use some other annotation implementation, it must be serializable.
    
    Parameters:
    
    annot - The qualifier instance that must be matched along with the type
    
    type - The type to extend this context by
    
    Returns:
    
    A new Context with a longer context stack
  - matching
```
public Context matching(ContextPattern pattern)
```
    Description copied from interface: Context
    
    Restruct context to matching a particular pattern. The pattern is appended to the pattern generated by the other context-restriction methods. This is a high-powered method that won't be needed in most situations, but allows fine-grained control of context matching.
    
    Parameters:
    
    pattern - The context pattern to match.
    
    Returns:
    
    A context with longer context.
  - at
```
public Context at(Class<?> type)
```
    Description copied from interface: Context
    
    Create a new Context that extends the current context stack with the given class type as an anchored match. This matches with the default Qualifier. This is equivalent to at(null, type);
    
    Parameters:
    
    type - The type to extend this context by
    
    Returns:
    
    A new Context with a longer context stack
    
    See Also:
    
    Context.at(Class, Class)
  - at
```
public Context at(Class<? extends Annotation> qualifier,
                  Class<?> type)
```
    Description copied from interface: Context
    
    Create a new Context that extends the current context stack with the given class and Qualifier annotation as an anchored match. If the qualifier is null, the default or null qualifier is used.
    Unlike Context.in(Class,Class), this match is anchored — that is, it only matches at the end of a context chain. Context is matched if it ends with this or, if further context is opened inside this context, if the inner context matches immediately.
    
    Parameters:
    
    qualifier - The qualifier type that must be matched along with the type
    
    type - The type to extend this context by
    
    Returns:
    
    A new Context with a longer context stack
  - at
```
public Context at(Annotation annot,
                  Class<?> type)
```
    Description copied from interface: Context
    
    Create a new Context that extends the current context stack with the given class, qualified by the specific Annotation instance. as an anchored match. If the qualifier is null, the default or null qualifier is used.
    The annotation provided must be serializable. Annotations built by AnnotationBuilder (recommended) or retrieved from the Java reflection API are serializable; if you use some other annotation implementation, it must be serializable.
    
    Parameters:
    
    annot - The qualifier instance that must be matched along with the type
    
    type - The type to extend this context by
    
    Returns:
    
    A new Context with a longer context stack
  - applyModule
```
public InjectorBuilder applyModule(Module module)
```
    Apply a module to the root context of this InjectorBuilder (i.e. Module.configure(Context)).
    
    Parameters:
    
    module - The module to apply
    
    Returns:
    
    This InjectorBuilder
  - build
```
public Injector build()
```

Class InjectorBuilder

Constructor Summary

Method Summary

Methods inherited from class org.grouplens.grapht.AbstractContext

Methods inherited from class java.lang.Object

Constructor Detail

InjectorBuilder

Method Detail

create

create

setDefaultCachePolicy

setProviderInjectionEnabled

bind

bindAny

within

within

within

matching

at

at

at

applyModule

build