public class MapBinder<K,V> extends Object
public class SnacksModule extends AbstractModule {
protected void configure() {
MapBinder<String, Snack> mapbinder
= MapBinder.newMapBinder(binder(), String.class, Snack.class);
mapbinder.addBinding("twix").toInstance(new Twix());
mapbinder.addBinding("snickers").toProvider(SnickersProvider.class);
mapbinder.addBinding("skittles").to(Skittles.class);
}
}
With this binding, a Map
<String, Snack>
can now be injected:
class SnackMachine {
@Inject
public SnackMachine(Map<String, Snack> snacks) { ... }
}
In addition to binding Map<K, V>
, a mapbinder will also bind Map<K,
Provider<V>>
for lazy value provision:
class SnackMachine {
@Inject
public SnackMachine(Map<String, Provider<Snack>> snackProviders) { ... }
}
Contributing mapbindings from different modules is supported. For example, it is okay to have
both CandyModule
and ChipsModule
both create their own MapBinder<String,
Snack>
, and to each contribute bindings to the snacks map. When that map is injected, it will
contain entries from both modules.
The map's iteration order is consistent with the binding order. This is convenient when multiple elements are contributed by the same module because that module can order its bindings appropriately. Avoid relying on the iteration order of elements contributed by different modules, since there is no equivalent mechanism to order modules.
The map is unmodifiable. Elements can only be added to the map by configuring the MapBinder. Elements can never be removed from the map.
Values are resolved at map injection time. If a value is bound to a provider, that provider's get method will be called each time the map is injected (unless the binding is also scoped, or a map of providers is injected).
Annotations are used to create different maps of the same key/value type. Each distinct annotation gets its own independent map.
Keys must be distinct. If the same key is bound more than once, map injection
will fail. However, use permitDuplicates()
in order to allow duplicate keys; extra
bindings to Map<K, Set<V>>
and Map<K, Set<Provider<V>>
will be added.
Keys must be non-null. addBinding(null)
will throw an unchecked
exception.
Values must be non-null to use map injection. If any value is null, map injection will fail (although injecting a map of providers will not).
Modifier and Type | Method and Description |
---|---|
LinkedBindingBuilder<V> |
addBinding(K key)
Returns a binding builder used to add a new entry in the map.
|
boolean |
equals(Object obj) |
int |
hashCode() |
static <K,V> MapBinder<K,V> |
newMapBinder(Binder binder,
Class<K> keyType,
Class<V> valueType)
Returns a new mapbinder that collects entries of
keyType /valueType in a Map that is itself bound with no binding annotation. |
static <K,V> MapBinder<K,V> |
newMapBinder(Binder binder,
Class<K> keyType,
Class<V> valueType,
Annotation annotation)
Returns a new mapbinder that collects entries of
keyType /valueType in a Map that is itself bound with annotation . |
static <K,V> MapBinder<K,V> |
newMapBinder(Binder binder,
Class<K> keyType,
Class<V> valueType,
Class<? extends Annotation> annotationType)
Returns a new mapbinder that collects entries of
keyType /valueType in a Map that is itself bound with annotationType . |
static <K,V> MapBinder<K,V> |
newMapBinder(Binder binder,
TypeLiteral<K> keyType,
TypeLiteral<V> valueType)
Returns a new mapbinder that collects entries of
keyType /valueType in a Map that is itself bound with no binding annotation. |
static <K,V> MapBinder<K,V> |
newMapBinder(Binder binder,
TypeLiteral<K> keyType,
TypeLiteral<V> valueType,
Annotation annotation)
Returns a new mapbinder that collects entries of
keyType /valueType in a Map that is itself bound with annotation . |
static <K,V> MapBinder<K,V> |
newMapBinder(Binder binder,
TypeLiteral<K> keyType,
TypeLiteral<V> valueType,
Class<? extends Annotation> annotationType)
Returns a new mapbinder that collects entries of
keyType /valueType in a Map that is itself bound with annotationType . |
MapBinder<K,V> |
permitDuplicates()
Configures the
MapBinder to handle duplicate entries. |
public static <K,V> MapBinder<K,V> newMapBinder(Binder binder, TypeLiteral<K> keyType, TypeLiteral<V> valueType)
keyType
/valueType
in a Map
that is itself bound with no binding annotation.public static <K,V> MapBinder<K,V> newMapBinder(Binder binder, Class<K> keyType, Class<V> valueType)
keyType
/valueType
in a Map
that is itself bound with no binding annotation.public static <K,V> MapBinder<K,V> newMapBinder(Binder binder, TypeLiteral<K> keyType, TypeLiteral<V> valueType, Annotation annotation)
keyType
/valueType
in a Map
that is itself bound with annotation
.public static <K,V> MapBinder<K,V> newMapBinder(Binder binder, Class<K> keyType, Class<V> valueType, Annotation annotation)
keyType
/valueType
in a Map
that is itself bound with annotation
.public static <K,V> MapBinder<K,V> newMapBinder(Binder binder, TypeLiteral<K> keyType, TypeLiteral<V> valueType, Class<? extends Annotation> annotationType)
keyType
/valueType
in a Map
that is itself bound with annotationType
.public static <K,V> MapBinder<K,V> newMapBinder(Binder binder, Class<K> keyType, Class<V> valueType, Class<? extends Annotation> annotationType)
keyType
/valueType
in a Map
that is itself bound with annotationType
.public MapBinder<K,V> permitDuplicates()
MapBinder
to handle duplicate entries.
When multiple equal keys are bound, the value that gets included in the map is arbitrary.
In addition to the Map<K, V>
and Map<K, Provider<V>>
maps that are normally
bound, a Map<K, Set<V>>
and Map<K, Set<Provider<V>>>
are also bound,
which contain all values bound to each key.
When multiple modules contribute elements to the map, this configuration option impacts all of them.
public LinkedBindingBuilder<V> addBinding(K key)
It is an error to call this method without also calling one of the to
methods on the
returned binding builder.
Scoping elements independently is supported. Use the in
method to specify a binding
scope.
Copyright © 2006–2020 Google, Inc.. All rights reserved.