Package com.google.inject.spi

Class Elements.RecordingBinder

java.lang.Object
com.google.inject.spi.Elements.RecordingBinder
All Implemented Interfaces:
Binder, PrivateBinder
Enclosing class:
Elements
private static class Elements.RecordingBinder extends Object implements Binder, PrivateBinder

  • Field Details

  • Constructor Details

  • Method Details

    • bindScope

      public void bindScope(Class<? extends Annotation> annotationType, Scope scope)
      Description copied from interface: Binder
      Binds a scope to an annotation.
      Specified by:
      bindScope in interface Binder

    • requestInjection

      public void requestInjection(Object instance)
      Description copied from interface: Binder
      Upon successful creation, the Injector will inject instance fields and methods of the given object.
      Specified by:
      requestInjection in interface Binder
      Parameters:
      instance - for which members will be injected

    • requestInjection

      public <T> void requestInjection(TypeLiteral<T> type, T instance)
      Description copied from interface: Binder
      Upon successful creation, the Injector will inject instance fields and methods of the given object.
      Specified by:
      requestInjection in interface Binder
      Parameters:
      type - of instance
      instance - for which members will be injected

    • getMembersInjector

      public <T> MembersInjector<T> getMembersInjector(TypeLiteral<T> typeLiteral)
      Description copied from interface: Binder
      Returns the members injector used to inject dependencies into methods and fields on instances of the given type T. The returned members injector will not be valid until the main Injector has been created. The members injector will throw an IllegalStateException if you try to use it beforehand.
      Specified by:
      getMembersInjector in interface Binder
      Parameters:
      typeLiteral - type to get members injector for

    • getMembersInjector

      public <T> MembersInjector<T> getMembersInjector(Class<T> type)
      Description copied from interface: Binder
      Returns the members injector used to inject dependencies into methods and fields on instances of the given type T. The returned members injector will not be valid until the main Injector has been created. The members injector will throw an IllegalStateException if you try to use it beforehand.
      Specified by:
      getMembersInjector in interface Binder
      Parameters:
      type - type to get members injector for

    • bindListener

      public void bindListener(Matcher<? super TypeLiteral<?>> typeMatcher, TypeListener listener)
      Description copied from interface: Binder
      Registers a listener for injectable types. Guice will notify the listener when it encounters injectable types matched by the given type matcher.
      Specified by:
      bindListener in interface Binder
      Parameters:
      typeMatcher - that matches injectable types the listener should be notified of
      listener - for injectable types matched by typeMatcher

    • bindListener

      public void bindListener(Matcher<? super Binding<?>> bindingMatcher, ProvisionListener... listeners)
      Description copied from interface: Binder
      Registers listeners for provisioned objects. Guice will notify the listeners just before and after the object is provisioned. Provisioned objects that are also injectable (everything except objects provided through Providers) can also be notified through TypeListeners registered in Binder.bindListener(com.google.inject.matcher.Matcher<? super com.google.inject.TypeLiteral<?>>, com.google.inject.spi.TypeListener).
      Specified by:
      bindListener in interface Binder
      Parameters:
      bindingMatcher - that matches bindings of provisioned objects the listener should be notified of
      listeners - for provisioned objects matched by bindingMatcher

    • requestStaticInjection

      public void requestStaticInjection(Class<?>... types)
      Description copied from interface: Binder
      Upon successful creation, the Injector will inject static fields and methods in the given classes.
      Specified by:
      requestStaticInjection in interface Binder
      Parameters:
      types - for which static members will be injected

    • scanForAnnotatedMethods

      void scanForAnnotatedMethods()
      Applies all scanners to the modules we've installed. We skip certain PrivateModules because store them in more than one Modules map and only want to process them through one of the maps. (They're stored in both maps to prevent a module from being installed more than once.)

    • install

      public void install(Module module)
      Description copied from interface: Binder
      Uses the given module to configure more bindings.
      Specified by:
      install in interface Binder

    • currentStage

      public Stage currentStage()
      Description copied from interface: Binder
      Gets the current stage.
      Specified by:
      currentStage in interface Binder

    • addError

      public void addError(String message, Object... arguments)
      Description copied from interface: Binder
      Records an error message which will be presented to the user at a later time. Unlike throwing an exception, this enable us to continue configuring the Injector and discover more errors. Uses String.format(String, Object[]) to insert the arguments into the message.
      Specified by:
      addError in interface Binder

    • addError

      public void addError(Throwable t)
      Description copied from interface: Binder
      Records an exception, the full details of which will be logged, and the message of which will be presented to the user at a later time. If your Module calls something that you worry may fail, you should catch the exception and pass it into this.
      Specified by:
      addError in interface Binder

    • addError

      public void addError(Message message)
      Description copied from interface: Binder
      Records an error message to be presented to the user at a later time.
      Specified by:
      addError in interface Binder

    • bind

      public <T> AnnotatedBindingBuilder<T> bind(Key<T> key)
      Description copied from interface: Binder
      See the EDSL examples at Binder.
      Specified by:
      bind in interface Binder

    • bind

      public <T> AnnotatedBindingBuilder<T> bind(TypeLiteral<T> typeLiteral)
      Description copied from interface: Binder
      See the EDSL examples at Binder.
      Specified by:
      bind in interface Binder

    • bind

      public <T> AnnotatedBindingBuilder<T> bind(Class<T> type)
      Description copied from interface: Binder
      See the EDSL examples at Binder.
      Specified by:
      bind in interface Binder

    • bindConstant

      public AnnotatedConstantBindingBuilder bindConstant()
      Description copied from interface: Binder
      See the EDSL examples at Binder.
      Specified by:
      bindConstant in interface Binder

    • getProvider

      public <T> Provider<T> getProvider(Key<T> key)
      Description copied from interface: Binder
      Returns the provider used to obtain instances for the given injection key. The returned provider will not be valid until the Injector has been created. The provider will throw an IllegalStateException if you try to use it beforehand.
      Specified by:
      getProvider in interface Binder

    • getProvider

      public <T> Provider<T> getProvider(Dependency<T> dependency)
      Description copied from interface: Binder
      Returns the provider used to obtain instances for the given injection key. The returned provider will be attached to the injection point and will follow the nullability specified in the dependency. Additionally, the returned provider will not be valid until the Injector has been created. The provider will throw an IllegalStateException if you try to use it beforehand.
      Specified by:
      getProvider in interface Binder

    • getProvider

      public <T> Provider<T> getProvider(Class<T> type)
      Description copied from interface: Binder
      Returns the provider used to obtain instances for the given injection type. The returned provider will not be valid until the Injector has been created. The provider will throw an IllegalStateException if you try to use it beforehand.
      Specified by:
      getProvider in interface Binder

    • convertToTypes

      public void convertToTypes(Matcher<? super TypeLiteral<?>> typeMatcher, TypeConverter converter)
      Description copied from interface: Binder
      Binds a type converter. The injector will use the given converter to convert string constants to matching types as needed.
      Specified by:
      convertToTypes in interface Binder
      Parameters:
      typeMatcher - matches types the converter can handle
      converter - converts values

    • withSource

      public Elements.RecordingBinder withSource(Object source)
      Description copied from interface: Binder
      Returns a binder that uses source as the reference location for configuration errors. This is typically a StackTraceElement for .java source but it could any binding source, such as the path to a .properties file.
      Specified by:
      withSource in interface Binder
      Specified by:
      withSource in interface PrivateBinder
      Parameters:
      source - any object representing the source location and has a concise toString() value
      Returns:
      a binder that shares its configuration with this binder

    • skipSources

      public Elements.RecordingBinder skipSources(Class... classesToSkip)
      Description copied from interface: Binder
      Returns a binder that skips classesToSkip when identify the calling code. The caller's StackTraceElement is used to locate the source of configuration errors.
      Specified by:
      skipSources in interface Binder
      Specified by:
      skipSources in interface PrivateBinder
      Parameters:
      classesToSkip - library classes that create bindings on behalf of their clients.
      Returns:
      a binder that shares its configuration with this binder.

    • newPrivateBinder

      public PrivateBinder newPrivateBinder()
      Description copied from interface: Binder
      Creates a new private child environment for bindings and other configuration. The returned binder can be used to add and configuration information in this environment. See PrivateModule for details.
      Specified by:
      newPrivateBinder in interface Binder
      Returns:
      a binder that inherits configuration from this binder. Only exposed configuration on the returned binder will be visible to this binder.

    • disableCircularProxies

      public void disableCircularProxies()
      Description copied from interface: Binder
      Prevents Guice from injecting dependencies that form a cycle, unless broken by a Provider. By default, circular dependencies are not disabled.

      If a parent injector disables circular dependencies, then all child injectors (and private modules within that injector) also disable circular dependencies. If a parent does not disable circular dependencies, a child injector or private module may optionally declare itself as disabling circular dependencies. If it does, the behavior is limited only to that child or any grandchildren. No siblings of the child will disable circular dependencies.

      Specified by:
      disableCircularProxies in interface Binder

    • requireExplicitBindings

      public void requireExplicitBindings()
      Description copied from interface: Binder
      Instructs the Injector that bindings must be listed in a Module in order to be injected. Classes that are not explicitly bound in a module cannot be injected. Bindings created through a linked binding (bind(Foo.class).to(FooImpl.class)) are allowed, but the implicit binding (FooImpl) cannot be directly injected unless it is also explicitly bound ( bind(FooImpl.class)).

      Tools can still retrieve bindings for implicit bindings (bindings created through a linked binding) if explicit bindings are required, however Binding.getProvider() will fail.

      By default, explicit bindings are not required.

      If a parent injector requires explicit bindings, then all child injectors (and private modules within that injector) also require explicit bindings. If a parent does not require explicit bindings, a child injector or private module may optionally declare itself as requiring explicit bindings. If it does, the behavior is limited only to that child or any grandchildren. No siblings of the child will require explicit bindings.

      In the absence of an explicit binding for the target, linked bindings in child injectors create a binding for the target in the parent. Since this behavior can be surprising, it causes an error instead if explicit bindings are required. To avoid this error, add an explicit binding for the target, either in the child or the parent.

      Specified by:
      requireExplicitBindings in interface Binder

    • requireAtInjectOnConstructors

      public void requireAtInjectOnConstructors()
      Description copied from interface: Binder
      Requires that a @Inject annotation exists on a constructor in order for Guice to consider it an eligible injectable class. By default, Guice will inject classes that have a no-args constructor if no @Inject annotation exists on any constructor.

      If the class is bound using LinkedBindingBuilder.toConstructor(java.lang.reflect.Constructor<S>), Guice will still inject that constructor regardless of annotations.

      Specified by:
      requireAtInjectOnConstructors in interface Binder

    • requireExactBindingAnnotations

      public void requireExactBindingAnnotations()
      Description copied from interface: Binder
      Requires that Guice finds an exactly matching binding annotation. This disables the error-prone feature in Guice where it can substitute a binding for @Named Foo when attempting to inject @Named("foo") Foo.
      Specified by:
      requireExactBindingAnnotations in interface Binder

    • scanModulesForAnnotatedMethods

      public void scanModulesForAnnotatedMethods(ModuleAnnotatedMethodScanner scanner)
      Description copied from interface: Binder
      Adds a scanner that will look in all installed modules for annotations the scanner can parse, and binds them like @Provides methods. Scanners apply to all modules installed in the injector. Scanners installed in child injectors or private modules do not impact modules in siblings or parents, however scanners installed in parents do apply to all child injectors and private modules.
      Specified by:
      scanModulesForAnnotatedMethods in interface Binder

    • expose

      public void expose(Key<?> key)
      Description copied from interface: PrivateBinder
      Makes the binding for key available to the enclosing environment
      Specified by:
      expose in interface PrivateBinder

    • expose

      public AnnotatedElementBuilder expose(Class<?> type)
      Description copied from interface: PrivateBinder
      Makes a binding for type available to the enclosing environment. Use annotatedWith() to expose type with a binding annotation.
      Specified by:
      expose in interface PrivateBinder

    • expose

      public AnnotatedElementBuilder expose(TypeLiteral<?> type)
      Description copied from interface: PrivateBinder
      Makes a binding for type available to the enclosing environment. Use annotatedWith() to expose type with a binding annotation.
      Specified by:
      expose in interface PrivateBinder

    • exposeInternal

      private <T> AnnotatedElementBuilder exposeInternal(Key<T> key)

    • getModuleSource

      private ModuleSource getModuleSource(Class<?> module)

    • getElementSource

      private ElementSource getElementSource()

    • getPartialCallStack

      private StackTraceElement[] getPartialCallStack(StackTraceElement[] callStack)
      Removes the moduleSource call stack from the beginning of current call stack. It also removes the last two elements in order to make install(Module) the last call in the call stack.

    • toString

      public String toString()
      Overrides:
      toString in class Object