Java 类com.google.inject.spi.TypeListener 实例源码

@Override
protected void configure() {
    registerConfigFiles(this.configFiles);

    //init system runtime eagerly
    bind(SystemRuntime.IRuntime.class).to(BaseRuntime.class).asEagerSingleton();

    bind(IResourceClientLibrary.class).to(ResourceClientLibrary.class).in(Scopes.SINGLETON);
    bind(IBotStoreClientLibrary.class).to(BotStoreClientLibrary.class).in(Scopes.SINGLETON);
    bind(IPackageStoreClientLibrary.class).to(PackageStoreClientLibrary.class).in(Scopes.SINGLETON);
    bind(IPackageStoreService.class).to(PackageStoreService.class).in(Scopes.SINGLETON);
    bind(IBotStoreService.class).to(BotStoreService.class).in(Scopes.SINGLETON);

    bind(IBotFactory.class).to(BotFactory.class).in(Scopes.SINGLETON);
    bind(IPackageFactory.class).to(PackageFactory.class).in(Scopes.SINGLETON);

    bind(IAutoBotDeployment.class).to(AutoBotDeployment.class).in(Scopes.SINGLETON);

    //call init method of system runtime after creation
    bindListener(HasInitMethod.INSTANCE, new TypeListener() {
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
            encounter.register(InitInvoker.INSTANCE);
        }
    });
}

@Override
protected void configure() {
  final Destroyer destroyer = new Destroyer(errorHandler);
  bind(Destroyer.class).toInstance(destroyer);
  bindListener(
      Matchers.any(),
      new TypeListener() {
        @Override
        public <T> void hear(TypeLiteral<T> type, TypeEncounter<T> encounter) {
          encounter.register(
              new InjectionListener<T>() {
                @Override
                public void afterInjection(T injectee) {
                  final Method[] methods = get(injectee.getClass(), annotationType);
                  if (methods.length > 0) {
                    // copy array when pass it outside
                    final Method[] copy = new Method[methods.length];
                    System.arraycopy(methods, 0, copy, 0, methods.length);
                    destroyer.add(injectee, copy);
                  }
                }
              });
        }
      });
}

@Override
protected void configure() {
    bind(ActionRepository.class).to(CassandraActionRepository.class);
    bind(PlayerRepository.class).to(CassandraPlayerRepository.class);
    bind(BadgeRepository.class).to(CassandraBadgeRepository.class);
    bind(EventRepository.class).to(CassandraEventRepository.class);
    bind(EventTypeRepository.class).to(CassandraEventTypeRepository.class);

    this.eventBus =  new AsyncEventBus(java.util.concurrent.Executors.newCachedThreadPool());
    bind(EventBus.class).toInstance(eventBus);

    bindListener(Matchers.any(), new TypeListener() {
        public <I> void hear(TypeLiteral<I> typeLiteral, TypeEncounter<I> typeEncounter) {
            typeEncounter.register(new InjectionListener<I>() {
                public void afterInjection(I i) {
                    eventBus.register(i);
                }
            });
        }
    });
}

public void testToConstructorSpiData() throws NoSuchMethodException {
  final Set<TypeLiteral<?>> heardTypes = Sets.newHashSet();

  final Constructor<D> constructor = D.class.getConstructor(Stage.class);
  final TypeListener listener =
      new TypeListener() {
        @Override
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
          if (!heardTypes.add(type)) {
            fail("Heard " + type + " multiple times!");
          }
        }
      };

  Guice.createInjector(
      new AbstractModule() {
        @Override
        protected void configure() {
          bind(Object.class).toConstructor(constructor);
          bind(D.class).toConstructor(constructor);
          bindListener(Matchers.any(), listener);
        }
      });

  assertEquals(ImmutableSet.of(TypeLiteral.get(D.class)), heardTypes);
}

public void testTypeListenersAreFired() {
  final AtomicInteger firedCount = new AtomicInteger();

  final TypeListener typeListener =
      new TypeListener() {
        @Override
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
          assertEquals(new TypeLiteral<A>() {}, type);
          firedCount.incrementAndGet();
        }
      };

  Guice.createInjector(
      new AbstractModule() {
        @Override
        protected void configure() {
          bindListener(onlyAbcd, typeListener);
          bind(A.class);
        }
      });

  assertEquals(1, firedCount.get());
}

public void testLookupsPostCreate() {
  Injector injector =
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              bindListener(
                  only(TypeLiteral.get(C.class)),
                  new TypeListener() {
                    @Override
                    public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
                      assertNotNull(encounter.getProvider(B.class).get());

                      A a = new A();
                      encounter.getMembersInjector(A.class).injectMembers(a);
                      assertNotNull(a.injector);
                    }
                  });
            }
          });

  injector.getInstance(C.class);
}

/**
 * We had a bug where we weren't notifying of types encountered for member injection when those
 * types had no members to be injected. Constructed types are always injected because they always
 * have at least one injection point: the class constructor.
 */
public void testTypesWithNoInjectableMembersAreNotified() {
  final AtomicInteger notificationCount = new AtomicInteger();

  Guice.createInjector(
      new AbstractModule() {
        @Override
        protected void configure() {
          bindListener(
              onlyAbcd,
              new TypeListener() {
                @Override
                public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
                  notificationCount.incrementAndGet();
                }
              });

          bind(C.class).toInstance(new C());
        }
      });

  assertEquals(1, notificationCount.get());
}

public void testToConstructorSpiData() throws NoSuchMethodException {
  final Set<TypeLiteral<?>> heardTypes = Sets.newHashSet();

  final Constructor<D> constructor = D.class.getConstructor(Stage.class);
  final TypeListener listener = new TypeListener() {
    public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
      if (!heardTypes.add(type)) {
        fail("Heard " + type + " multiple times!");
      }
    }
  };

  Guice.createInjector(new AbstractModule() {
    protected void configure() {
      bind(Object.class).toConstructor(constructor);
      bind(D.class).toConstructor(constructor);
      bindListener(Matchers.any(), listener);
    }
  });

  assertEquals(ImmutableSet.of(TypeLiteral.get(D.class)), heardTypes);
}

public void testTypeListenersAreFired() {
  final AtomicInteger firedCount = new AtomicInteger();

  final TypeListener typeListener = new TypeListener() {
    public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
      assertEquals(new TypeLiteral<A>() {}, type);
      firedCount.incrementAndGet();
    }
  };

  Guice.createInjector(new AbstractModule() {
    @Override protected void configure() {
      bindListener(onlyAbcd, typeListener);
      bind(A.class);
    }
  });

  assertEquals(1, firedCount.get());
}

public void testAddingInterceptors() throws NoSuchMethodException {
  final Matcher<Object> buzz = only(C.class.getMethod("buzz"));

  Injector injector = Guice.createInjector(new AbstractModule() {
    @Override protected void configure() {
      bindInterceptor(any(), buzz, prefixInterceptor("ka"));
      bindInterceptor(any(), any(), prefixInterceptor("fe"));

      bindListener(onlyAbcd, new TypeListener() {
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
          encounter.bindInterceptor(any(), prefixInterceptor("li"));
          encounter.bindInterceptor(buzz, prefixInterceptor("no"));
        }
      });
    }
  });

  // interceptors must be invoked in the order they're bound.
  C c = injector.getInstance(C.class);
  assertEquals("kafelinobuzz", c.buzz());
  assertEquals("felibeep", c.beep());
}

public void testLookupsPostCreate() {
  Injector injector = Guice.createInjector(new AbstractModule() {
    @Override protected void configure() {
      bindListener(only(TypeLiteral.get(C.class)), new TypeListener() {
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
          assertNotNull(encounter.getProvider(B.class).get());

          A a = new A();
          encounter.getMembersInjector(A.class).injectMembers(a);
          assertNotNull(a.injector);
        }
      });
    }
  });

  injector.getInstance(C.class);
}

/**
 * We had a bug where we weren't notifying of types encountered for member injection when those
 * types had no members to be injected. Constructed types are always injected because they always
 * have at least one injection point: the class constructor.
 */
public void testTypesWithNoInjectableMembersAreNotified() {
  final AtomicInteger notificationCount = new AtomicInteger();

  Guice.createInjector(new AbstractModule() {
    @Override protected void configure() {
      bindListener(onlyAbcd, new TypeListener() {
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
          notificationCount.incrementAndGet();
        }
      });

      bind(C.class).toInstance(new C());
    }
  });

  assertEquals(1, notificationCount.get());
}

public void testAddErrors() {
  try {
    Guice.createInjector(new AbstractModule() {
      @Override protected void configure() {
        requestInjection(new Object());
        bindListener(Matchers.any(), new TypeListener() {
          public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
            encounter.addError("There was an error on %s", type);
            encounter.addError(new IllegalArgumentException("whoops!"));
            encounter.addError(new Message("And another problem"));
            encounter.addError(new IllegalStateException());
          }
        });
      }
    });
    fail();
  } catch (CreationException expected) {
    assertContains(expected.getMessage(),
        "1) There was an error on java.lang.Object",
        "2) An exception was caught and reported. Message: whoops!",
        "3) And another problem",
        "4) An exception was caught and reported. Message: null",
        "4 errors");
  }
}

public void testToConstructorSpiData() throws NoSuchMethodException {
  final Set<TypeLiteral<?>> heardTypes = Sets.newHashSet();

  final Constructor<D> constructor = D.class.getConstructor(Stage.class);
  final TypeListener listener = new TypeListener() {
    public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
      if (!heardTypes.add(type)) {
        fail("Heard " + type + " multiple times!");
      }
    }
  };

  Guice.createInjector(new AbstractModule() {
    protected void configure() {
      bind(Object.class).toConstructor(constructor);
      bind(D.class).toConstructor(constructor);
      bindListener(Matchers.any(), listener);
    }
  });

  assertEquals(ImmutableSet.of(TypeLiteral.get(D.class)), heardTypes);
}

public void testTypeListenersAreFired() throws NoSuchMethodException {
  final AtomicInteger firedCount = new AtomicInteger();

  final TypeListener typeListener = new TypeListener() {
    public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
      assertEquals(new TypeLiteral<A>() {}, type);
      firedCount.incrementAndGet();
    }
  };

  Guice.createInjector(new AbstractModule() {
    protected void configure() {
      bindListener(onlyAbcd, typeListener);
      bind(A.class);
    }
  });

  assertEquals(1, firedCount.get());
}

public void testAddingInterceptors() throws NoSuchMethodException {
  final Matcher<Object> buzz = only(C.class.getMethod("buzz"));

  Injector injector = Guice.createInjector(new AbstractModule() {
    protected void configure() {
      bindInterceptor(any(), buzz, prefixInterceptor("ka"));
      bindInterceptor(any(), any(), prefixInterceptor("fe"));

      bindListener(onlyAbcd, new TypeListener() {
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
          encounter.bindInterceptor(any(), prefixInterceptor("li"));
          encounter.bindInterceptor(buzz, prefixInterceptor("no"));
        }
      });
    }
  });

  // interceptors must be invoked in the order they're bound.
  C c = injector.getInstance(C.class);
  assertEquals("kafelinobuzz", c.buzz());
  assertEquals("felibeep", c.beep());
}

public void testLookupsPostCreate() {
  Injector injector = Guice.createInjector(new AbstractModule() {
    protected void configure() {
      bindListener(only(TypeLiteral.get(C.class)), new TypeListener() {
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
          assertNotNull(encounter.getProvider(B.class).get());

          A a = new A();
          encounter.getMembersInjector(A.class).injectMembers(a);
          assertNotNull(a.injector);
        }
      });
    }
  });

  injector.getInstance(C.class);
}

/**
 * We had a bug where we weren't notifying of types encountered for member injection when those
 * types had no members to be injected. Constructed types are always injected because they always
 * have at least one injection point: the class constructor.
 */
public void testTypesWithNoInjectableMembersAreNotified() {
  final AtomicInteger notificationCount = new AtomicInteger();

  Guice.createInjector(new AbstractModule() {
    protected void configure() {
      bindListener(onlyAbcd, new TypeListener() {
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
          notificationCount.incrementAndGet();
        }
      });

      bind(C.class).toInstance(new C());
    }
  });

  assertEquals(1, notificationCount.get());
}

public void testAddErrors() {
  try {
    Guice.createInjector(new AbstractModule() {
      protected void configure() {
        requestInjection(new Object());
        bindListener(Matchers.any(), new TypeListener() {
          public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
            encounter.addError("There was an error on %s", type);
            encounter.addError(new IllegalArgumentException("whoops!"));
            encounter.addError(new Message("And another problem"));
            encounter.addError(new IllegalStateException());
          }
        });
      }
    });
    fail();
  } catch (CreationException expected) {
    assertContains(expected.getMessage(),
        "1) There was an error on java.lang.Object",
        "2) An exception was caught and reported. Message: whoops!",
        "3) And another problem",
        "4) An exception was caught and reported. Message: null",
        "4 errors");
  }
}

private void mapUtil() {
    final EventBus eventBus = new EventBus();
    bind(EventBus.class).toInstance(eventBus);
    bindListener(Matchers.any(), new TypeListener() {
        @Override
        public <I> void hear(@SuppressWarnings("unused") final TypeLiteral<I> type, final TypeEncounter<I> encounter) {
            encounter.register(new InjectionListener<I>() {
                @Override
                public void afterInjection(final I injectee) {
                    eventBus.register(injectee);
                }
            });
        }
    });

    requestStaticInjection(TextUtil.class);
}

protected void bindMBeanListener() {
    final MBeanAnnotationScanner scanner = new MBeanAnnotationScanner();
    this.bindListener(Matchers.any(), new TypeListener() {

            @Override
            public <I> void hear(final TypeLiteral<I> type, final TypeEncounter<I> encounter) {
                final MBeanMetadata metadata = scanner.scan(type.getRawType());

                if (metadata != null) {
                    encounter.register((InjectionListener<I>) injectee -> {
                        try {
                            final ResourceDynamicMBean dynamicMBean = new ResourceDynamicMBean(injectee,
                                    metadata);

                            mBeanRegistry.register(dynamicMBean, metadata.getObjectName());
                        } catch (Exception e) {
                            LOG.error("Could not register MBean {}", metadata.getObjectName(), e);
                        }
                    });
                }
            }
        });
}

private void addPostConstructInterceptor(GuiceModuleConfiguration guiceModuleConfiguration) {
    HasPostConstructMethod hasPostConstruct = new HasPostConstructMethod(guiceModuleConfiguration.getClassWithDisabledPostConstruct());
    final PostConstructInvoker postConstructInvoker = new PostConstructInvoker();
    bindListener(hasPostConstruct, new TypeListener() {
        @Override
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
            encounter.register(postConstructInvoker);
        }
    });
}

@Override
protected void configure()
{
    bindListener(Matchers.any(), new TypeListener()
    {
        @Override
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter)
        {
            PluginResourceHandler.inst().getForClass(type.getRawType());
        }
    });
}

@Override
protected void configure() {
    // Call methods annotated with @AfterInjection after injection, mainly used to create UIs
    bindListener(new AfterInjectionMatcher(), new TypeListener() {
        AfterInjectionInvoker invoker = new AfterInjectionInvoker();
        @Override
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
            encounter.register(invoker);
        }
    });
}

@Override
public void configure(Binder binder)
{
    binder.disableCircularProxies();

    binder.bindListener(any(), new TypeListener()
    {
        @Override
        public <T> void hear(TypeLiteral<T> type, TypeEncounter<T> encounter)
        {
            encounter.register(new InjectionListener<T>()
            {
                @Override
                public void afterInjection(T obj)
                {
                    if (isLifeCycleClass(obj.getClass())) {
                        LifeCycleManager lifeCycleManager = lifeCycleManagerRef.get();
                        if (lifeCycleManager != null) {
                            try {
                                lifeCycleManager.addInstance(obj);
                            }
                            catch (Exception e) {
                                throw new Error(e);
                            }
                        }
                        else {
                            injectedInstances.add(obj);
                        }
                    }
                }
            });
        }
    });
}

/**
 * Configures module - binds all core interfaces to their (default) implementations.
 */
@Override
public void configure() {
  // binding for object populator
  bind(ObjectPopulator.class).to(ObjectPopulatorImpl.class);

  // binding of factories
  bind(ClassProviderFactory.class).to(ClassProviderFactoryImpl.class);
  bind(ConstructionStrategyFactory.class).to(ConstructionStrategyFactoryImpl.class);
  bind(ValueGeneratorFactory.class).to(ValueGeneratorFactoryImpl.class);
  bind(InstanceMatcherFactory.class).to(InstanceMatcherFactoryImpl.class);
  bind(PropertyPopulatorFactory.class).to(PropertyPopulatorFactoryImpl.class);
  bind(PopulatingStrategyFactory.class).to(PopulatingStrategyFactoryImpl.class);

  // binding of interlayers
  bind(ClassProviderInvoker.class).to(ClassProviderInvokerImpl.class);
  bind(ConstructionStrategyInvoker.class).to(ConstructionStrategyInvokerImpl.class);
  bind(ValueGeneratorInvoker.class).to(ValueGeneratorInvokerImpl.class);
  bind(InstanceMatcherInvoker.class).to(InstanceMatcherInvokerImpl.class);
  bind(PropertyPopulatorInvoker.class).to(PropertyPopulatorInvokerImpl.class);
  bind(PopulatingStrategyInvoker.class).to(PopulatingStrategyInvokerImpl.class);

  // binding of sessions
  bind(ClassLoaderSession.class).to(ClassLoaderSessionImpl.class);
  bind(RandomGeneratorSession.class).to(RandomGeneratorSessionImpl.class);
  bind(RandomGeneratorSession.class).annotatedWith(Names.named(NamedScopes.EXTENDED_IMPL)).to(ExtendedRandomGeneratorSessionImpl.class);
  bind(PopulatingSession.class).to(GlobalPopulatingSession.class);

  // binding of named implementations
  bind(PopulatingStrategy.class).annotatedWith(Names.named(NamedScopes.DEFAULT_IMPL)).to(DefaultStrategy.class);
  bind(new TypeLiteral<PropertyPopulator<?>>() {}).annotatedWith(Names.named(NamedScopes.DEFAULT_IMPL)).to(DefaultPropertyPopulator.class);
  bind(ConstructionStrategy.class).annotatedWith(Names.named(NamedScopes.DEFAULT_IMPL)).to(ConstructionStrategyImpl.class);

  // bind listener of classes implementing callback interfaces.
  bindListener(new SubclassesMatcher(Initializable.class), new TypeListener() {
    public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
      encounter.register(new CallbacksInjectionListener<I>());
    }
  });
}

@Override
public void configure(Binder binder)
{
    binder.disableCircularProxies();

    binder.bindListener(Matchers.any(), new TypeListener()
    {
        @Override
        public <T> void hear(TypeLiteral<T> type, TypeEncounter<T> encounter)
        {
            encounter.register(new InjectionListener<T>()
            {
                @Override
                public void afterInjection(T obj)
                {
                    ServerLifeCycleManager initialized = lifeCycleManagerRef.get();
                    if (initialized == null) {
                        earlyInjected.add(obj);
                    }
                    else {
                        try {
                            initialized.manageInstance(obj);
                        }
                        catch (Exception e) {
                            // really nothing we can do here
                            throw new Error(e);
                        }
                    }
                }
            });
        }
    });
}

private TypeListener createTypeListener() {
    return new TypeListener() {
        @Override
        public <I> void hear(final TypeLiteral<I> typeLiteral, final TypeEncounter<I> typeEncounter) {
            typeEncounter.register((InjectionListener<I>) LoggerInjector::inject);
        }
    };
}

private TypeListener createTypeListener(final ObjectConverterRegistry registry) {
    return new TypeListener() {
        @Override
        public <I> void hear(final TypeLiteral<I> typeLiteral, final TypeEncounter<I> typeEncounter) {
            typeEncounter.register(new InjectionListener<I>() {
                @Override
                public void afterInjection(final I injectee) {
                    registry.registerConverters(injectee);
                }
            });
        }
    };
}

@Override
public void configure(final Binder binder) {
    binder.bindListener(Matchers.any(), new TypeListener() {
        @Override
        public <I> void hear(final TypeLiteral<I> type, final TypeEncounter<I> encounter) {
            final List<Field> fields = fields(Lists.newArrayList(), type.getRawType());
            fields.stream().filter(field -> field.isAnnotationPresent(FieldInject.class)).forEach(field -> {
                final FieldInject inject = field.getAnnotation(FieldInject.class);
                encounter.register(ReflectUtils.newInstance(inject.value(), field));
            });
        }
    });
}

@Override
public void configure() {
    final FindByKeyInjectionListener findByKeyInjectionListener = new FindByKeyInjectionListener();
    bind(FindByKeyInjectionListener.class).toInstance(findByKeyInjectionListener);

    bindListener(Matchers.any(), new TypeListener() {
        @Override
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
            if (hasFindByKeyAnnotation(type.getRawType())) {
                encounter.register(findByKeyInjectionListener);
            }
        }

        private boolean hasFindByKeyAnnotation(Class<?> clazz) {
            while (clazz != null) {
                for (Field field : clazz.getDeclaredFields()) {
                    if (field.isAnnotationPresent(FindByKey.class) || field.isAnnotationPresent(FindBy.class) || field
                            .isAnnotationPresent(FindAll.class)) {
                        return true;
                    }
                }
                // If this Class represents either the Object class, an interface, a primitive type, or void, then
                // null is returned.
                clazz = clazz.getSuperclass();
            }
            return false;
        }
    });
}

public void testEarlyInjectableReferencesWithSameIdentity() {
  Injector injector =
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              // Add a listener to trigger all toInstance bindings to get an Initializable.
              bindListener(
                  Matchers.any(),
                  new TypeListener() {
                    @Override
                    public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {}
                  });

              // Bind two different Keys to the IDENTITICAL object
              // ORDER MATTERS! We want the String binding to push out the Object one
              String fail = new String("better not fail!");
              bind(Object.class).toInstance(fail);
              bind(String.class).toInstance(fail);

              // Then try to inject those objects in a requestInjection,
              // letting us get into InjectableReference.get before it has
              // finished running through all its injections.
              // Each of these technically has its own InjectableReference internally.
              // ORDER MATTERS!.. because Object is injected first, that InjectableReference
              // attempts to process its members injector, but it wasn't initialized,
              // because String pushed it out of the queue!
              requestInjection(
                  new Object() {
                    @SuppressWarnings("unused")
                    @Inject
                    Object obj;

                    @SuppressWarnings("unused")
                    @Inject
                    String str;
                  });
            }
          });
}

public void testAddingInterceptors() throws NoSuchMethodException {
  final Matcher<Object> buzz = only(C.class.getMethod("buzz"));

  Injector injector =
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              bindInterceptor(any(), buzz, prefixInterceptor("ka"));
              bindInterceptor(any(), any(), prefixInterceptor("fe"));

              bindListener(
                  onlyAbcd,
                  new TypeListener() {
                    @Override
                    public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
                      encounter.bindInterceptor(any(), prefixInterceptor("li"));
                      encounter.bindInterceptor(buzz, prefixInterceptor("no"));
                    }
                  });
            }
          });

  // interceptors must be invoked in the order they're bound.
  C c = injector.getInstance(C.class);
  assertEquals("kafelinobuzz", c.buzz());
  assertEquals("felibeep", c.beep());
}

public void testAddErrors() {
  try {
    Guice.createInjector(
        new AbstractModule() {
          @Override
          protected void configure() {
            requestInjection(new Object());
            bindListener(
                Matchers.any(),
                new TypeListener() {
                  @Override
                  public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
                    encounter.addError("There was an error on %s", type);
                    encounter.addError(new IllegalArgumentException("whoops!"));
                    encounter.addError(new Message("And another problem"));
                    encounter.addError(new IllegalStateException());
                  }
                });
          }
        });
    fail();
  } catch (CreationException expected) {
    assertContains(
        expected.getMessage(),
        "1) There was an error on java.lang.Object",
        "2) An exception was caught and reported. Message: whoops!",
        "3) And another problem",
        "4) An exception was caught and reported. Message: null",
        "4 errors");
  }
}

private void messageBusRegisterRule() {
    // This rule registers all objects created by Guice with the message bus.
    // As a result, all instances created by Guice can receive messages without explicit
    // subscription.
    bindListener(Matchers.any(), new TypeListener() {
        @Override
        public <I> void hear(TypeLiteral<I> typeLiteral, TypeEncounter<I> typeEncounter) {
            typeEncounter.register(new InjectionListener<I>() {
                public void afterInjection(I i) {
                    messageBus.subscribe(i);
                }
            });
        }
    });
}

@Override
protected void configure() {
    bind(SampleApplication.class);

    bind(MessageConverter.class).to(JsonMessageConverter.class).in(Singleton.class);
    bind(ObjectConverter.class).to(JsonObjectConverter.class).in(Singleton.class);
    bind(SubscriptionAdapter.class).to(MapSubscriptionAdapter.class).in(Singleton.class);
    bind(DDPMessageEndpoint.class).to(DDPMessageEndpointImpl.class).in(Singleton.class);
    bind(SubscriptionEventDispatcher.class).asEagerSingleton();
    bind(MeteorCollectionRepository.class).to(MeteorCollectionRepositoryImpl.class).in(Singleton.class);
    bind(RPCClient.class).to(RPCClientImpl.class).in(Singleton.class);
    bind(EventBus.class).in(Singleton.class);

    bindListener(
            new AbstractMatcher<TypeLiteral<?>>() {
                @Override
                public boolean matches(TypeLiteral<?> typeLiteral) {
                    return typeLiteral.getRawType().isAnnotationPresent(Presents.class);
                }
            },
            new TypeListener() {
                @Override
                public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
                    final Presents presents = type.getRawType().getAnnotation(Presents.class);
                    encounter.register((InjectionListener<I>) injectee -> {
                        final FXMLLoader loader = new FXMLLoader(injectee.getClass().getResource(presents.value()));
                        loader.setController(injectee);
                        try {
                            loader.load();
                        } catch (IOException e) {
                            throw new RuntimeException(e);
                        }
                    });
                }
            }
    );
}

public void testEarlyInjectableReferencesWithSameIdentity() {
  Injector injector = Guice.createInjector(new AbstractModule() {
    @Override
    protected void configure() {
      // Add a listener to trigger all toInstance bindings to get an Initializable.
      bindListener(Matchers.any(), new TypeListener() {
        @Override
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
        }
      });

      // Bind two different Keys to the IDENTITICAL object
      // ORDER MATTERS! We want the String binding to push out the Object one
      String fail = new String("better not fail!");
      bind(Object.class).toInstance(fail);
      bind(String.class).toInstance(fail);

      // Then try to inject those objects in a requestInjection,
      // letting us get into InjectableReference.get before it has
      // finished running through all its injections.
      // Each of these technically has its own InjectableReference internally.
      // ORDER MATTERS!.. because Object is injected first, that InjectableReference
      // attempts to process its members injector, but it wasn't initialized,
      // because String pushed it out of the queue!
      requestInjection(new Object() {
        @SuppressWarnings("unused") @Inject Object obj;
        @SuppressWarnings("unused") @Inject String str;
      });
    }
  });
}

public void testInstallingInjectionListener() {
  final List<Object> injectees = Lists.newArrayList();
  final InjectionListener<Object> injectionListener = new InjectionListener<Object>() {
    public void afterInjection(Object injectee) {
      injectees.add(injectee);
    }
  };

  Injector injector = Guice.createInjector(new AbstractModule() {
    @Override protected void configure() {
      bindListener(onlyAbcd, new TypeListener() {
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
          encounter.register(injectionListener);
        }
      });
      bind(A.class);
    }
  });

  assertEquals(ImmutableList.of(), injectees);

  Object a1 = injector.getInstance(A.class);
  assertEquals(ImmutableList.of(a1), injectees);

  Object a2 = injector.getInstance(A.class);
  assertEquals(ImmutableList.of(a1, a2), injectees);

  Object b1 = injector.getInstance(B.class);
  assertEquals(ImmutableList.of(a1, a2, b1), injectees);

  Provider<A> aProvider = injector.getProvider(A.class);
  assertEquals(ImmutableList.of(a1, a2, b1), injectees);
  A a3 = aProvider.get();
  A a4 = aProvider.get();
  assertEquals(ImmutableList.of(a1, a2, b1, a3, a4), injectees);
}

public void testEarlyInjectableReferencesWithSameIdentity() {
  Injector injector = Guice.createInjector(new AbstractModule() {
    @Override
    protected void configure() {
      // Add a listener to trigger all toInstance bindings to get an Initializable.
      bindListener(Matchers.any(), new TypeListener() {
        @Override
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
        }
      });

      // Bind two different Keys to the IDENTITICAL object
      // ORDER MATTERS! We want the String binding to push out the Object one
      String fail = new String("better not fail!");
      bind(Object.class).toInstance(fail);
      bind(String.class).toInstance(fail);

      // Then try to inject those objects in a requestInjection,
      // letting us get into InjectableReference.get before it has
      // finished running through all its injections.
      // Each of these technically has its own InjectableReference internally.
      // ORDER MATTERS!.. because Object is injected first, that InjectableReference
      // attempts to process its members injector, but it wasn't initialized,
      // because String pushed it out of the queue!
      requestInjection(new Object() {
        @SuppressWarnings("unused") @Inject Object obj;
        @SuppressWarnings("unused") @Inject String str;
      });
    }
  });
}

public void testInstallingInjectionListener() {
  final List<Object> injectees = Lists.newArrayList();
  final InjectionListener<Object> injectionListener = new InjectionListener<Object>() {
    public void afterInjection(Object injectee) {
      injectees.add(injectee);
    }
  };

  Injector injector = Guice.createInjector(new AbstractModule() {
    protected void configure() {
      bindListener(onlyAbcd, new TypeListener() {
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
          encounter.register(injectionListener);
        }
      });
      bind(A.class);
    }
  });

  assertEquals(ImmutableList.of(), injectees);

  Object a1 = injector.getInstance(A.class);
  assertEquals(ImmutableList.of(a1), injectees);

  Object a2 = injector.getInstance(A.class);
  assertEquals(ImmutableList.of(a1, a2), injectees);

  Object b1 = injector.getInstance(B.class);
  assertEquals(ImmutableList.of(a1, a2, b1), injectees);

  Provider<A> aProvider = injector.getProvider(A.class);
  assertEquals(ImmutableList.of(a1, a2, b1), injectees);
  A a3 = aProvider.get();
  A a4 = aProvider.get();
  assertEquals(ImmutableList.of(a1, a2, b1, a3, a4), injectees);
}