public final class BoundFieldModule extends java.lang.Object implements Module
Bind
.
This module is intended for use in tests to reduce the code needed to bind local fields (usually mocks) for injection.
The following rules are followed in determining how fields are bound using this module:
Bind
annotated field of an object and its superclasses, this module will
bind that field's type to that field's value at injector creation time. This includes both
instance and static fields.
Bind.to()
is specified, the field's value will be bound to the class specified by
Bind.to()
instead of the field's actual type.
Bind.lazy()
is true, this module will delay reading the value from the field until
injection time, allowing the field's value to be reassigned during the course of a test's
execution.
BindingAnnotation
or Qualifier
is present on the field,
that field will be bound using that annotation via AnnotatedBindingBuilder.annotatedWith(java.lang.Class<? extends java.lang.annotation.Annotation>)
. For example, bind(Foo.class).annotatedWith(BarAnnotation.class).toInstance(theValue)
. It is an error to
supply more than one BindingAnnotation
or Qualifier
.
Provider
, the field's value will be bound as a Provider
using LinkedBindingBuilder.toProvider(com.google.inject.Provider<? extends T>)
to the provider's parameterized
type. For example, Provider<Integer>
binds to Integer
. Attempting to bind a
non-parameterized Provider
without a Bind.to()
clause is an error.
Example use:
public class TestFoo {
// bind(new TypeLiteral <List<Object>>
() {}).toInstance(listOfObjects);
@Bind private List <Object>
listOfObjects = Lists.of();
// private String userName = "string_that_changes_over_time";
// bind(String.class).toProvider(new Provider() { public String get() { return userName; }});
@Bind(lazy = true) private String userName;
// bind(SuperClass.class).toInstance(aSubClass);
@Bind(to = SuperClass.class) private SubClass aSubClass = new SubClass();
// bind(String.class).annotatedWith(MyBindingAnnotation.class).toInstance(myString);
@Bind
@MyBindingAnnotation
private String myString = "hello";
// bind(Object.class).toProvider(myProvider);
@Bind private Provider <Object>
myProvider = getProvider();
@Before public void setUp() {
Guice.createInjector(BoundFieldModule.of(this)).injectMembers(this);
}
}
Bind
Modifier and Type | Class and Description |
---|---|
static class |
BoundFieldModule.BoundFieldInfo
Information about a field bound by
BoundFieldModule . |
Modifier and Type | Method and Description |
---|---|
void |
configure(Binder binder)
Contributes bindings and other configurations for this module to
binder . |
com.google.common.collect.ImmutableSet<BoundFieldModule.BoundFieldInfo> |
getBoundFields()
Returns information about the fields bound by this module.
|
java.lang.Object |
getInstance()
Returns the the object originally passed to
of(java.lang.Object) ). |
static BoundFieldModule |
of(java.lang.Object instance)
Create a BoundFieldModule which binds the
Bind annotated fields of instance . |
public static BoundFieldModule of(java.lang.Object instance)
Bind
annotated fields of instance
.instance
- the instance whose fields will be bound.Bind
annotated fields of instance
.public java.lang.Object getInstance()
of(java.lang.Object)
).public com.google.common.collect.ImmutableSet<BoundFieldModule.BoundFieldInfo> getBoundFields()
Note this is available immediately after construction, fields with errors won't be included but their error messages will be deferred to configuration time.
Fields with invalid null values are included but still cause errors at configuration time.
public void configure(Binder binder)
Module
binder
.
Do not invoke this method directly to install submodules. Instead use
Binder.install(Module)
, which ensures that provider methods
are
discovered.