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

@Override
public Void visit(ExposedBinding<? extends T> binding) {
    final PrivateBinder privateBinder = this.binder.newPrivateBinder();
    final Scoper scoper = new Scoper(privateBinder, scoping);
    for(Element element : binding.getPrivateElements().getElements()) {
        if(element instanceof Binding) {
            ((Binding) element).acceptTargetVisitor(scoper);
        } else {
            element.applyTo(privateBinder);
        }
    }
    for(Key key : binding.getPrivateElements().getExposedKeys()) {
        privateBinder.expose(key);
    }
    return null;
}

public void testSpiAccess() {
  Injector injector = Guice.createInjector(new PrivateModule() {
        @Override public void configure() {
          bind(String.class).annotatedWith(named("a")).toInstance("private");
          bind(String.class).annotatedWith(named("b")).toInstance("exposed");
          expose(String.class).annotatedWith(named("b"));
        }
      });

  ExposedBinding<?> binding
      = (ExposedBinding<?>) injector.getBinding(Key.get(String.class, Names.named("b")));
  assertEquals(ImmutableSet.<Dependency<?>>of(Dependency.get(Key.get(Injector.class))),
      binding.getDependencies());
  PrivateElements privateElements = binding.getPrivateElements();
  assertEquals(ImmutableSet.<Key<?>>of(Key.get(String.class, named("b"))),
      privateElements.getExposedKeys());
  assertContains(privateElements.getExposedSource(Key.get(String.class, named("b"))).toString(),
      PrivateModuleTest.class.getName(), getDeclaringSourcePart(getClass()));
  Injector privateInjector = privateElements.getInjector();
  assertEquals("private", privateInjector.getInstance(Key.get(String.class, Names.named("a"))));
}

public void testSpiAccess() {
  Injector injector = Guice.createInjector(new PrivateModule() {
        public void configure() {
          bind(String.class).annotatedWith(named("a")).toInstance("private");
          bind(String.class).annotatedWith(named("b")).toInstance("exposed");
          expose(String.class).annotatedWith(named("b"));
        }
      });

  ExposedBinding<?> binding
      = (ExposedBinding<?>) injector.getBinding(Key.get(String.class, Names.named("b")));
  assertEquals(ImmutableSet.<Dependency<?>>of(Dependency.get(Key.get(Injector.class))),
      binding.getDependencies());
  PrivateElements privateElements = binding.getPrivateElements();
  assertEquals(ImmutableSet.<Key<?>>of(Key.get(String.class, named("b"))),
      privateElements.getExposedKeys());
  assertContains(privateElements.getExposedSource(Key.get(String.class, named("b"))).toString(),
      PrivateModuleTest.class.getName(), ".configure(PrivateModuleTest.java:");
  Injector privateInjector = privateElements.getInjector();
  assertEquals("private", privateInjector.getInstance(Key.get(String.class, Names.named("a"))));
}

@Override
public Optional<TypeLiteral<?>> visit(ExposedBinding<?> binding) {
    // Lookup the exposed key in the private environment.
    // Since this visitor can only be used on an injector binding,
    // the private child injector should always be present too.
    return ofNullable(binding.getPrivateElements().getInjector())
        .flatMap(child -> child.getBinding(binding.getKey())
                               .acceptTargetVisitor(new BindingTargetTypeResolver(child)));
}

public static <T> Optional<TypeLiteral<? extends T>> targetType(Injector injector, Binding<T> binding) {
    if(binding instanceof UntargettedBinding) {
        return Optional.of(binding.getKey().getTypeLiteral());
    } else if(binding instanceof ConstructorBinding) {
        return Optional.of((TypeLiteral<? extends T>) ((ConstructorBinding) binding).getConstructor().getDeclaringType());
    } else if(binding instanceof InstanceBinding) {
        return Optional.of(TypeLiteral.get((Class<T>) ((InstanceBinding) binding).getInstance().getClass()));
    } else if(binding instanceof LinkedKeyBinding) {
        return targetType(injector, injector.getBinding(((LinkedKeyBinding) binding).getLinkedKey()));
    } else if(binding instanceof ExposedBinding) {
        return targetType(((ExposedBinding) binding).getPrivateElements().getInjector(), binding.getKey());
    }
    return Optional.empty();
}

@Override
public String toString() {
  return MoreObjects.toStringHelper(ExposedBinding.class)
      .add("key", getKey())
      .add("source", getSource())
      .add("privateElements", privateElements)
      .toString();
}

public void testSpiAccess() {
  Injector injector =
      Guice.createInjector(
          new PrivateModule() {
            @Override
            public void configure() {
              bind(String.class).annotatedWith(named("a")).toInstance("private");
              bind(String.class).annotatedWith(named("b")).toInstance("exposed");
              expose(String.class).annotatedWith(named("b"));
            }
          });

  ExposedBinding<?> binding =
      (ExposedBinding<?>) injector.getBinding(Key.get(String.class, Names.named("b")));
  assertEquals(
      ImmutableSet.<Dependency<?>>of(Dependency.get(Key.get(Injector.class))),
      binding.getDependencies());
  PrivateElements privateElements = binding.getPrivateElements();
  assertEquals(
      ImmutableSet.<Key<?>>of(Key.get(String.class, named("b"))),
      privateElements.getExposedKeys());
  assertContains(
      privateElements.getExposedSource(Key.get(String.class, named("b"))).toString(),
      PrivateModuleTest.class.getName(),
      getDeclaringSourcePart(getClass()));
  Injector privateInjector = privateElements.getInjector();
  assertEquals("private", privateInjector.getInstance(Key.get(String.class, Names.named("a"))));
}

@Override public String toString() {
  return Objects.toStringHelper(ExposedBinding.class)
      .add("key", getKey())
      .add("source", getSource())
      .add("privateElements", privateElements)
      .toString();
}

@Override public String toString() {
  return Objects.toStringHelper(ExposedBinding.class)
      .add("key", getKey())
      .add("source", getSource())
      .add("privateElements", privateElements)
      .toString();
}

@Override
public Indexer.IndexedBinding visit(ExposedBinding<? extends Object> binding) {
  return new Indexer.IndexedBinding(binding, BindingType.EXPOSED, scope(binding), binding);
}

@Override
public ResolvedBinding<T> visit(ExposedBinding<? extends T> exposedBinding) {
  return resolve(exposedBinding.getKey(), exposedBinding.getPrivateElements().getInjector());
}