Package org.robolectric.util.inject

Class Injector

java.lang.Object

org.robolectric.util.inject.Injector

public class Injector
extends Object

A tiny dependency injection and plugin helper for Robolectric.

Dependencies may be retrieved explicitly by calling getInstance(java.lang.Class<T>); transitive dependencies will be automatically injected as needed. For a given injector, all calls to getInstance(java.lang.Class<T>) are idempotent.

Dependencies are identified by an interface or class, and optionally by a name specified with @Named.

Dependency Resolution

When a dependency is requested, an implementation is sought.

The injector looks for any instance that has been previously found for the given interface, or that has been explicitly registered with Injector.Builder.bind(Class, Object) or Builder#bind(Key, Object). If none is found, the injector searches for an implementing class from the following sources, in order:

1. Explicitly-registered implementations registered with Injector.Builder.bind(Class, Class).
2. If the dependency type is an array or Collection, then its component type is recursively sought using PluginFinder.findPlugins(Class) and an array or collection of those instances is returned.
3. Plugin implementations published as ServiceLoader services under the dependency type (see also PluginFinder.findPlugin(Class)).
4. Fallback default implementation classes registered with Injector.Builder.bindDefault(Class, Class).
5. If the dependency type is a concrete class, then the dependency type itself.

If the injector has a superinjector, it is always consulted first (with the exception of interfaces annotated @AutoFactory; see Scopes below).

If no implementing class is found in the injector or any superinjector, an exception is thrown.

Injection

When the injector has determined an implementing class, it attempts to instantiate it. It searches for a constructor in the following order:

1. A singular public constructor annotated @Inject. (If multiple constructors are @Inject annotated, the injector will throw an exception.)
2. A singular public constructor of any arity.
3. If no constructor has yet been found, the injector will throw an exception.

Any constructor parameters are treated as further dependencies, and the injector will recursively attempt to resolve an implementation for each before invoking the constructor and thereby instantiating the original dependency implementation.

Scopes

If the dependency type is an interface annotated @AutoFactory, then a factory object implementing that interface is created; a new scoped injector is created for every method call to the factory, with parameter arguments registered on the scoped injector.

Thread Safety

All methods are MT-safe.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Injector.Builder Builder for Injector.
static class	Injector.Key<T> Identifies an injection point.

Constructor Summary

Constructors

Constructor and Description
Injector() Creates a new empty injector.

Method Summary

Modifier and Type	Method and Description
<T> T	getInstance(Class<T> type) Finds an instance for the given class.
Injector.Builder	newScopeBuilder(ClassLoader classLoader)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Injector

public Injector()

Creates a new empty injector.

Method Detail

getInstance

@Nonnull
public <T> T getInstance(@Nonnull
                         Class<T> type)

Finds an instance for the given class. Calls are guaranteed idempotent.

newScopeBuilder

public Injector.Builder newScopeBuilder(ClassLoader classLoader)