Java 类com.google.inject.internal.ProviderMethodsModule 实例源码

/**
 * 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.)
 */
void scanForAnnotatedMethods() {
  for (ModuleAnnotatedMethodScanner scanner : scanners) {
    // Note: we must iterate over a copy of the modules because calling install(..)
    // will mutate modules, otherwise causing a ConcurrentModificationException.
    for (Map.Entry<Module, ModuleInfo> entry : Maps.newLinkedHashMap(modules).entrySet()) {
      Module module = entry.getKey();
      ModuleInfo info = entry.getValue();
      if (info.skipScanning) {
        continue;
      }
      moduleSource = entry.getValue().moduleSource;
      try {
        info.binder.install(ProviderMethodsModule.forModule(module, scanner));
      } catch (RuntimeException e) {
        Collection<Message> messages = Errors.getMessagesFromThrowable(e);
        if (!messages.isEmpty()) {
          elements.addAll(messages);
        } else {
          addError(e);
        }
      }
    }
  }
  moduleSource = null;
}

public void install(Module module) {
  if (modules.add(module)) {
    Binder binder = this;
    if (module instanceof PrivateModule) {
      binder = binder.newPrivateBinder();
    }

    try {
      module.configure(binder);
    } catch (RuntimeException e) {
      Collection<Message> messages = Errors.getMessagesFromThrowable(e);
      if (!messages.isEmpty()) {
        elements.addAll(messages);
      } else {
        addError(e);
      }
    }
    binder.install(ProviderMethodsModule.forModule(module));
  }
}

public void configure(Binder binder) {
  // For Guice error reporting, ignore the adapters
  binder = binder.skipSources(GinModuleAdapter.class, BinderAdapter.class,
      AbstractGinModule.class);

  ginModule.configure(new BinderAdapter(binder, bindings));

  // Install provider methods from the GinModule
  binder.install(ProviderMethodsModule.forObject(ginModule));
}

public void configure() {
  Binder binder = binder().skipSources(PrivateGinModuleAdapter.class,
      BinderAdapter.class, PrivateBinderAdapter.class, PrivateGinModule.class);

  ginModule.configure(new PrivateBinderAdapter((PrivateBinder) binder,
      bindings == null ? null : bindings.createChildGinjectorBindings(ginModule.getClass())));

  // Install provider methods from the GinModule
  binder.install(ProviderMethodsModule.forObject(ginModule));
}

public void testNonModuleProviderMethods() {
  final Object methodsObject =
      new Object() {
        @Provides
        @Named("foo")
        String provideFoo() {
          return "foo-value";
        }
      };

  Module module =
      new AbstractModule() {
        @Override
        protected void configure() {
          install(ProviderMethodsModule.forObject(methodsObject));
        }
      };

  Injector injector = Guice.createInjector(module);

  Key<String> key = Key.get(String.class, Names.named("foo"));
  assertEquals("foo-value", injector.getInstance(key));

  // Test the provider method object itself. This makes sure getInstance works, since GIN uses it
  List<Element> elements = Elements.getElements(module);
  assertEquals(1, elements.size());

  Element element = elements.get(0);
  assertTrue(
      element + " instanceof ProviderInstanceBinding",
      element instanceof ProviderInstanceBinding);

  ProviderInstanceBinding binding = (ProviderInstanceBinding) element;
  javax.inject.Provider provider = binding.getUserSuppliedProvider();
  assertTrue(provider instanceof ProviderMethod);
  assertEquals(methodsObject, ((ProviderMethod) provider).getInstance());
  assertSame(provider, binding.getProviderInstance());
}

public void install(Module module) {
  if (modules.add(module)) {
    Binder binder = this;
    // Update the module source for the new module
    if (!(module instanceof ProviderMethodsModule)) {
      moduleSource = getModuleSource(module);
    }
    if (module instanceof PrivateModule) {
      binder = binder.newPrivateBinder();
    }      
    try {
      module.configure(binder);
    } catch (RuntimeException e) {
      Collection<Message> messages = Errors.getMessagesFromThrowable(e);
      if (!messages.isEmpty()) {
        elements.addAll(messages);
      } else {
        addError(e);
      }
    }
    binder.install(ProviderMethodsModule.forModule(module));
    // We are done with this module, so undo module source change
    if (!(module instanceof ProviderMethodsModule)) {
      moduleSource = moduleSource.getParent();
    }
  }
}

public void testNonModuleProviderMethods() {
  final Object methodsObject = new Object() {
    @Provides @Named("foo") String provideFoo() {
      return "foo-value";
    }
  };

  Module module = new AbstractModule() {
    @Override protected void configure() {
      install(ProviderMethodsModule.forObject(methodsObject));
    }
  };

  Injector injector = Guice.createInjector(module);

  Key<String> key = Key.get(String.class, Names.named("foo"));
  assertEquals("foo-value", injector.getInstance(key));

  // Test the provider method object itself. This makes sure getInstance works, since GIN uses it
  List<Element> elements = Elements.getElements(module);
  assertEquals(1, elements.size());

  Element element = elements.get(0);
  assertTrue(element + " instanceof ProviderInstanceBinding",
      element instanceof ProviderInstanceBinding);

  ProviderInstanceBinding binding = (ProviderInstanceBinding) element;
  javax.inject.Provider provider = binding.getUserSuppliedProvider();    
  assertEquals(ProviderMethod.class, provider.getClass());
  assertEquals(methodsObject, ((ProviderMethod) provider).getInstance());    
  assertSame(provider, binding.getProviderInstance());
}

public void testNonModuleProviderMethods() {
  final Object methodsObject = new Object() {
    @Provides @Named("foo") String provideFoo() {
      return "foo-value";
    }
  };

  Module module = new AbstractModule() {
    @Override protected void configure() {
      install(ProviderMethodsModule.forObject(methodsObject));
    }
  };

  Injector injector = Guice.createInjector(module);

  Key<String> key = Key.get(String.class, Names.named("foo"));
  assertEquals("foo-value", injector.getInstance(key));

  // Test the provider method object itself. This makes sure getInstance works, since GIN uses it
  List<Element> elements = Elements.getElements(module);
  assertEquals(1, elements.size());

  Element element = elements.get(0);
  assertTrue(element + " instanceof ProviderInstanceBinding",
      element instanceof ProviderInstanceBinding);

  ProviderInstanceBinding binding = (ProviderInstanceBinding) element;
  Provider provider = binding.getProviderInstance();    
  assertEquals(ProviderMethod.class, provider.getClass());
  assertEquals(methodsObject, ((ProviderMethod) provider).getInstance());
}

@Override
public void configure(Binder binder) {
  for (Object module : daggerModuleObjects) {
    binder.install(ProviderMethodsModule.forModule(module, DaggerMethodScanner.INSTANCE));
  }
}

@Override
public void install(Module module) {
  if (!modules.containsKey(module)) {
    RecordingBinder binder = this;
    boolean unwrapModuleSource = false;
    // Update the module source for the new module
    if (module instanceof ProviderMethodsModule) {
      // There are two reason's we'd want to get the module source in a ProviderMethodsModule.
      // ModuleAnnotatedMethodScanner lets users scan their own modules for @Provides-like
      // bindings.  If they install the module at a top-level, then moduleSource can be null.
      // Also, if they pass something other than 'this' to it, we'd have the wrong source.
      Object delegate = ((ProviderMethodsModule) module).getDelegateModule();
      if (moduleSource == null
          || !moduleSource.getModuleClassName().equals(delegate.getClass().getName())) {
        moduleSource = getModuleSource(delegate);
        unwrapModuleSource = true;
      }
    } else {
      moduleSource = getModuleSource(module);
      unwrapModuleSource = true;
    }
    boolean skipScanning = false;
    if (module instanceof PrivateModule) {
      binder = (RecordingBinder) binder.newPrivateBinder();
      // Store the module in the private binder too so we scan for it.
      binder.modules.put(module, new ModuleInfo(binder, moduleSource, false));
      skipScanning = true; // don't scan this module in the parent's module set.
    }
    // Always store this in the parent binder (even if it was a private module)
    // so that we know not to process it again, and so that scanners inherit down.
    modules.put(module, new ModuleInfo(binder, moduleSource, skipScanning));
    try {
      module.configure(binder);
    } catch (RuntimeException e) {
      Collection<Message> messages = Errors.getMessagesFromThrowable(e);
      if (!messages.isEmpty()) {
        elements.addAll(messages);
      } else {
        addError(e);
      }
    }
    binder.install(ProviderMethodsModule.forModule(module));
    // We are done with this module, so undo module source change
    if (unwrapModuleSource) {
      moduleSource = moduleSource.getParent();
    }
  }
}

/**
 * HACK!
 *
 * Scan the given module for methods annotated with {@link ProvidesGeneric} and generate provider methods
 * from them. This works exactly like Guice's built-in provider methods, except that the owner type can
 * be specified explicitly, allowing for generic provider methods.
 *
 * HACK: Reflectively change the module type in ProviderMethodsModule, before it scans for provider methods.
 * This allows the actual type of a generic module to be provided at runtime.
 */
public static <T extends Module> Module providerMethodsModule(T hostModule, TypeLiteral<T> type) {
    final ProviderMethodsModule module = (ProviderMethodsModule) ProviderMethodsModule.forModule(hostModule, SCANNER);
    ProviderMethodsModule_typeLiteral.set(module, type);
    return module;
}