Inject a TypeListener

Question

I have this scenario where I want to inject a TypeListener with dependencies, but it will never work because the TypeListener is used to actually perform the injection.

How can I get this thing done? Is there a guicey-way?

Notes:

• I'm using Guice 4.0
• MyManager will be used after Guice::createInjector.
• Both MyManager::registerType and MyManager::use are called exclusively before Guice::createInjector returns.
• MyDependency is present to show that MyManager cannot be instanciated with new. I will also be used after Guice::createInjector has returned.

I created the following SSCCE to showcase my issue:

import com.google.inject.*;
import com.google.inject.matcher.*;
import com.google.inject.spi.*;

public class MyClass {

  public static void main(String[] args) {
    Guice.createInjector(new MyModule());
  }

  static class MyModule extends AbstractModule {
    @Override protected void configure() {
      TypeListener listener = new MyTypeListener();
      requestInjection(listener);
      bindListener(Matchers.any(), listener);
    }
  }

  static class MyTypeListener implements TypeListener {
    @Inject MyManager manager;
    @Override public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
      Class<?> rawType = type.getRawType();
      manager.registerType(rawType);
      encounter.register(new InjectionListener<I>() {
        @Override public void afterInjection(I injectee) {
          manager.use(rawType, injectee);
        }
      });
    }
  }

  @Singleton static class MyManager {
    @Inject MyManager(MyDependency dependency) { }
    void registerType(Class<?> type) {  }
    void use(Class<?> type, Object injectee) { }
  }

  static class MyDependency { }
}

Answer 1

I think at least some of the time (in tests or code analysis) type listeners have no cohesion to the types they are listening to, so there's no reason to have one injector. You'd use one injector to create the listener and one injector to create the code to be tested/analyzed.

If you really want one injector (e.g. if the types in the injector you wish to listen to and the types needed by the listener are cohesive) then your best bet is AbstractModule's getProvider() method. So, if MyTypeListener needs an instance of Foo, this is what MyModule would look like:

   static class MyModule extends AbstractModule {
     @Override protected void configure() {
       TypeListener listener = new MyTypeListener(getProvider(Foo.class));
       bindListener(Matchers.any(), listener);
     }
   }

If you haven't used getProvider(), be forewarned that you cannot call .get() on the provider until the injector is constructed. As long as you don't call it from the context of the listener's constructor you should be fine.