public abstract class PrivateModule extends Object implements Module
A private module can be nested within a regular module or within another private module using
install(). Its bindings live in a new environment that inherits bindings,
type converters, scopes, and interceptors from the surrounding ("parent") environment. When you
nest multiple private modules, the result is a tree of environments where the injector's
environment is the root.
Guice EDSL bindings can be exposed with expose(). @Provides bindings can be exposed with the @Exposed annotation:
public class FooBarBazModule extends PrivateModule {
protected void configure() {
bind(Foo.class).to(RealFoo.class);
expose(Foo.class);
install(new TransactionalBarModule());
expose(Bar.class).annotatedWith(Transactional.class);
bind(SomeImplementationDetail.class);
install(new MoreImplementationDetailsModule());
}
@Provides @Exposed
public Baz provideBaz() {
return new SuperBaz();
}
}
Private modules are implemented using parent
injectors. When it can satisfy their dependencies, just-in-time bindings will be created in the
root environment. Such bindings are shared among all environments in the tree.
The scope of a binding is constrained to its environment. A singleton bound in a private module will be unique to its environment. But a binding for the same type in a different private module will yield a different instance.
A shared binding that injects the Injector gets the root injector, which only has
access to bindings in the root environment. An explicit binding that injects the Injector
gets access to all bindings in the child environment.
To promote a just-in-time binding to an explicit binding, bind it:
bind(FooImpl.class);
| Constructor and Description |
|---|
PrivateModule() |
| Modifier and Type | Method and Description |
|---|---|
protected void |
addError(Message message) |
protected void |
addError(String message,
Object... arguments) |
protected void |
addError(Throwable t) |
protected <T> AnnotatedBindingBuilder<T> |
bind(Class<T> clazz) |
protected <T> LinkedBindingBuilder<T> |
bind(Key<T> key) |
protected <T> AnnotatedBindingBuilder<T> |
bind(TypeLiteral<T> typeLiteral) |
protected AnnotatedConstantBindingBuilder |
bindConstant() |
protected PrivateBinder |
binder()
Returns the current binder.
|
protected void |
bindInterceptor(Matcher<? super Class<?>> classMatcher,
Matcher<? super Method> methodMatcher,
MethodInterceptor... interceptors) |
protected void |
bindListener(Matcher<? super Binding<?>> bindingMatcher,
ProvisionListener... listeners) |
protected void |
bindListener(Matcher<? super TypeLiteral<?>> typeMatcher,
TypeListener listener) |
protected void |
bindScope(Class<? extends Annotation> scopeAnnotation,
Scope scope) |
protected abstract void |
configure()
Creates bindings and other configurations private to this module.
|
void |
configure(Binder binder)
Contributes bindings and other configurations for this module to
binder. |
protected void |
convertToTypes(Matcher<? super TypeLiteral<?>> typeMatcher,
TypeConverter converter) |
protected Stage |
currentStage() |
protected AnnotatedElementBuilder |
expose(Class<?> type)
Makes a binding for
type available to other modules and the injector. |
protected <T> void |
expose(Key<T> key)
Makes the binding for
key available to other modules and the injector. |
protected AnnotatedElementBuilder |
expose(TypeLiteral<?> type)
Makes a binding for
type available to other modules and the injector. |
protected <T> MembersInjector<T> |
getMembersInjector(Class<T> type) |
protected <T> MembersInjector<T> |
getMembersInjector(TypeLiteral<T> type) |
protected <T> Provider<T> |
getProvider(Class<T> type) |
protected <T> Provider<T> |
getProvider(Key<T> key) |
protected void |
install(Module module) |
protected void |
requestInjection(Object instance) |
protected void |
requestStaticInjection(Class<?>... types) |
protected void |
requireBinding(Class<?> type)
Instructs Guice to require a binding to the given type.
|
protected void |
requireBinding(Key<?> key)
Instructs Guice to require a binding to the given key.
|
public final void configure(Binder binder)
Modulebinder.
Do not invoke this method directly to install submodules. Instead use
Binder.install(Module), which ensures that provider methods are
discovered.
protected abstract void configure()
expose() to make the bindings in this module available externally.protected final <T> void expose(Key<T> key)
key available to other modules and the injector.protected final AnnotatedElementBuilder expose(Class<?> type)
type available to other modules and the injector. Use annotatedWith() to expose type with a
binding annotation.protected final AnnotatedElementBuilder expose(TypeLiteral<?> type)
type available to other modules and the injector. Use annotatedWith() to expose type with a
binding annotation.protected final PrivateBinder binder()
protected final void bindScope(Class<? extends Annotation> scopeAnnotation, Scope scope)
Binder.bindScope(Class, Scope)protected final <T> LinkedBindingBuilder<T> bind(Key<T> key)
Binder.bind(Key)protected final <T> AnnotatedBindingBuilder<T> bind(TypeLiteral<T> typeLiteral)
Binder.bind(TypeLiteral)protected final <T> AnnotatedBindingBuilder<T> bind(Class<T> clazz)
Binder.bind(Class)protected final AnnotatedConstantBindingBuilder bindConstant()
Binder.bindConstant()protected final void install(Module module)
Binder.install(Module)protected final void addError(String message, Object... arguments)
Binder.addError(String, Object[])protected final void addError(Throwable t)
Binder.addError(Throwable)protected final void addError(Message message)
Binder.addError(Message)protected final void requestInjection(Object instance)
Binder.requestInjection(Object)protected final void requestStaticInjection(Class<?>... types)
Binder.requestStaticInjection(Class[])protected final void bindInterceptor(Matcher<? super Class<?>> classMatcher, Matcher<? super Method> methodMatcher, MethodInterceptor... interceptors)
protected final void requireBinding(Key<?> key)
protected final void requireBinding(Class<?> type)
protected final <T> Provider<T> getProvider(Key<T> key)
Binder.getProvider(Key)protected final <T> Provider<T> getProvider(Class<T> type)
Binder.getProvider(Class)protected final void convertToTypes(Matcher<? super TypeLiteral<?>> typeMatcher, TypeConverter converter)
protected final Stage currentStage()
Binder.currentStage()protected <T> MembersInjector<T> getMembersInjector(Class<T> type)
Binder.getMembersInjector(Class)protected <T> MembersInjector<T> getMembersInjector(TypeLiteral<T> type)
Binder.getMembersInjector(TypeLiteral)protected void bindListener(Matcher<? super TypeLiteral<?>> typeMatcher, TypeListener listener)
protected void bindListener(Matcher<? super Binding<?>> bindingMatcher, ProvisionListener... listeners)
Binder.bindListener(Matcher, ProvisionListener...)