Java 类com.google.inject.multibindings.MapBinderBinding 实例源码

@Override
        public MapBinderBinding<?> visit(
                MapBinderBinding<? extends Object> mapBinder) {
            if (mapBinder.getValueTypeLiteral().getRawType().isAssignableFrom(ComponentFactory.class)) {
                System.out.println(mapBinder.getValueTypeLiteral());

                for (Entry<?, Binding<?>> entry : mapBinder.getEntries()) {
                    ComponentFactory<?> factory = (ComponentFactory<?>) entry.getValue().getProvider().get();
                    System.out.println(String.format("  for type='%s' use class '%s' with properties: ", entry.getKey(), factory.getRawType().getSimpleName()));

                    for (Entry<String, PropertyInfo> propEntry : factory.getProperties().entrySet()) {
                        PropertyInfo prop = propEntry.getValue();
                        String   name = propEntry.getKey();

//                        System.out.println(String.format("    %-20s %-10s %-10s", name, prop.getType().getSimpleName(), prop.isDynamic() ? "(dynamic)" : ""));
                    }
                }
            }
            return mapBinder;        
        }

@SuppressWarnings("rawtypes")
public void testGetEntries() {
  List<com.google.inject.spi.Element> elements =
      Elements.getElements(new MapBinderWithTwoEntriesModule());

  // Get the MapBinderBinding
  MapBinderBinding<?> mapBinderBinding = getMapBinderBinding(elements);

  // Execute the call to getEntries
  List<Map.Entry<?, Binding<?>>> mapEntries = mapBinderBinding.getEntries(elements);

  // Assert on the results
  Map.Entry<?, Binding<?>> firstEntry = mapEntries.get(0);
  assertEquals("keyOne", firstEntry.getKey());
  Binding<?> firstBinding = firstEntry.getValue();
  assertEquals("valueOne", ((InstanceBinding) firstBinding).getInstance());

  Map.Entry<?, Binding<?>> secondEntry = mapEntries.get(1);
  assertEquals("keyTwo", secondEntry.getKey());
  Binding<?> secondBinding = secondEntry.getValue();
  assertEquals("valueTwo", ((InstanceBinding) secondBinding).getInstance());
}

/**
 * Given an {@link Iterable} of elements, return the one that is a {@link MapBinderBinding}, or
 * {@code null} if it cannot be found.
 */
private static MapBinderBinding<?> getMapBinderBinding(
    Iterable<com.google.inject.spi.Element> elements) {
  final Collector collector = new Collector();
  for (com.google.inject.spi.Element element : elements) {
    element.acceptVisitor(
        new DefaultElementVisitor<Void>() {
          @Override
          public <T> Void visit(Binding<T> binding) {
            binding.acceptTargetVisitor(collector);
            return null;
          }
        });
  }
  return collector.mapbinding;
}

public void testTwoMapBindersAreDistinct() {
  Injector injector =
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              MapBinder.newMapBinder(binder(), String.class, String.class)
                  .addBinding("A")
                  .toInstance("a");

              MapBinder.newMapBinder(binder(), Integer.class, String.class)
                  .addBinding(1)
                  .toInstance("b");
            }
          });
  Collector collector = new Collector();
  Binding<Map<String, String>> map1 = injector.getBinding(Key.get(mapOfString));
  map1.acceptTargetVisitor(collector);
  assertNotNull(collector.mapbinding);
  MapBinderBinding<?> map1Binding = collector.mapbinding;

  Binding<Map<Integer, String>> map2 = injector.getBinding(Key.get(mapOfIntString));
  map2.acceptTargetVisitor(collector);
  assertNotNull(collector.mapbinding);
  MapBinderBinding<?> map2Binding = collector.mapbinding;

  List<Binding<String>> bindings = injector.findBindingsByType(stringType);
  assertEquals("should have two elements: " + bindings, 2, bindings.size());
  Binding<String> a = bindings.get(0);
  Binding<String> b = bindings.get(1);
  assertEquals("a", ((InstanceBinding<String>) a).getInstance());
  assertEquals("b", ((InstanceBinding<String>) b).getInstance());

  // Make sure the correct elements belong to their own sets.
  assertTrue(map1Binding.containsElement(a));
  assertFalse(map1Binding.containsElement(b));

  assertFalse(map2Binding.containsElement(a));
  assertTrue(map2Binding.containsElement(b));
}

@SuppressWarnings("rawtypes")
public void testGetEntriesWithDuplicateKeys() {
  // Set up the module
  Module module =
      new AbstractModule() {
        @Override
        protected void configure() {
          MapBinder<String, String> mapBinder =
              MapBinder.newMapBinder(binder(), String.class, String.class);
          mapBinder.addBinding("A").toInstance("a1");
          mapBinder.addBinding("A").toInstance("a2");
          mapBinder.permitDuplicates();
        }
      };

  // Get the MapBinderBinding
  List<com.google.inject.spi.Element> elements = Elements.getElements(module);
  MapBinderBinding<?> mapBinderBinding = getMapBinderBinding(elements);

  // Execute the call to getEntries
  List<Map.Entry<?, Binding<?>>> mapEntries = mapBinderBinding.getEntries(elements);

  // Assert on the results
  Map.Entry<?, Binding<?>> firstEntry = mapEntries.get(0);
  assertEquals("A", firstEntry.getKey());
  Binding<?> firstBinding = firstEntry.getValue();
  assertEquals("a1", ((InstanceBinding) firstBinding).getInstance());

  Map.Entry<?, Binding<?>> secondEntry = mapEntries.get(1);
  assertEquals("A", secondEntry.getKey());
  Binding<?> secondBinding = secondEntry.getValue();
  assertEquals("a2", ((InstanceBinding) secondBinding).getInstance());
}

@SuppressWarnings("rawtypes")
public void testGetEntriesWithDuplicateValues() {
  // Set up the module
  Module module =
      new AbstractModule() {
        @Override
        protected void configure() {
          MapBinder<String, String> mapBinder =
              MapBinder.newMapBinder(binder(), String.class, String.class);
          mapBinder.addBinding("A").toInstance("a");
          mapBinder.addBinding("A").toInstance("a");
        }
      };

  // Get the MapBinderBinding
  List<com.google.inject.spi.Element> elements = Elements.getElements(module);
  MapBinderBinding<?> mapBinderBinding = getMapBinderBinding(elements);

  // Execute the call to getEntries
  List<Map.Entry<?, Binding<?>>> mapEntries = mapBinderBinding.getEntries(elements);

  // Assert on the results
  Map.Entry<?, Binding<?>> firstEntry = mapEntries.get(0);
  assertEquals("A", firstEntry.getKey());
  Binding<?> firstBinding = firstEntry.getValue();
  assertEquals("a", ((InstanceBinding) firstBinding).getInstance());

  Map.Entry<?, Binding<?>> secondEntry = mapEntries.get(1);
  assertEquals("A", secondEntry.getKey());
  Binding<?> secondBinding = secondEntry.getValue();
  assertEquals("a", ((InstanceBinding) secondBinding).getInstance());
}

@SuppressWarnings("rawtypes")
public void testGetEntriesMissingProviderMapEntry() {
  List<com.google.inject.spi.Element> elements =
      Lists.newArrayList(Elements.getElements(new MapBinderWithTwoEntriesModule()));

  // Get the MapBinderBinding
  MapBinderBinding<?> mapBinderBinding = getMapBinderBinding(elements);

  // Remove the ProviderMapEntry for "a" from the elements
  com.google.inject.spi.Element providerMapEntryForA = getProviderMapEntry("keyOne", elements);
  boolean removeSuccessful = elements.remove(providerMapEntryForA);
  assertTrue(removeSuccessful);

  // Execute the call to getEntries, we expect it to fail
  try {
    mapBinderBinding.getEntries(elements);
    fail();
  } catch (IllegalArgumentException expected) {
    assertContains(
        expected.getMessage(),
        "Expected a 1:1 mapping from map keys to values.",
        "Found these Bindings that were missing an associated entry:",
        "java.lang.String",
        "bound at:",
        "MapBinderWithTwoEntriesModule");
  }
}

@SuppressWarnings("rawtypes")
public void testGetEntriesMissingBindingForValue() {
  List<com.google.inject.spi.Element> elements =
      Lists.newArrayList(Elements.getElements(new MapBinderWithTwoEntriesModule()));

  // Get the MapBinderBinding
  MapBinderBinding<?> mapBinderBinding = getMapBinderBinding(elements);

  // Remove the ProviderMapEntry for "a" from the elements
  com.google.inject.spi.Element bindingForA = getInstanceBindingForValue("valueOne", elements);
  boolean removeSuccessful = elements.remove(bindingForA);
  assertTrue(removeSuccessful);

  // Execute the call to getEntries, we expect it to fail
  try {
    mapBinderBinding.getEntries(elements);
    fail();
  } catch (IllegalArgumentException expected) {
    assertContains(
        expected.getMessage(),
        "Expected a 1:1 mapping from map keys to values.",
        "Found these map keys without a corresponding value:",
        "keyOne",
        "bound at:",
        "MapBinderWithTwoEntriesModule");
  }
}

@Override
public MapBinderBinding<?> visit(
        MultibinderBinding<? extends Object> multibinding) {
    // TODO Auto-generated method stub
    return null;
}

@Override
public MapBinderBinding<?> visit(
        OptionalBinderBinding<? extends Object> optionalbinding) {
    // TODO Auto-generated method stub
    return null;
}

@Override
public Object visit(MapBinderBinding<? extends Object> mapbinding) {
  this.mapbinding = mapbinding;
  return null;
}

@Override
public Object visit(MapBinderBinding<? extends T> mapbinding) {
  return mapbinding;
}

@Override
public Set<ResolvedBinding<?>> visit(MapBinderBinding<?> mapbinding) {
  return resolveMultiDependencies(Functional.funPairs(mapbinding.getEntries()).values());
}