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

public void testGetInstanceName_providerMethod() throws Exception {
  final ProviderMethod<?>[] methodHolder = new ProviderMethod[1];

  Injector injector = Guice.createInjector(new ProvidingModule());
  injector
      .getBinding(Integer.class)
      .acceptTargetVisitor(
          new DefaultBindingTargetVisitor<Object, Void>() {
            @SuppressWarnings("unchecked")
            @Override
            public Void visit(ProviderInstanceBinding<?> binding) {
              methodHolder[0] = (ProviderMethod) binding.getUserSuppliedProvider();
              return null;
            }
          });

  assertEquals(
      "Method provider should pretty print as the method signature",
      "#provideInteger(String)",
      nameFactory.getInstanceName(methodHolder[0]));
}

public void testGetInstanceName_providerMethod() throws Exception {
  final ProviderMethod<?>[] methodHolder = new ProviderMethod[1];

  Injector injector = Guice.createInjector(new ProvidingModule());
  injector.getBinding(Integer.class).acceptTargetVisitor(
      new DefaultBindingTargetVisitor<Object, Void>() {
        @SuppressWarnings("unchecked") @Override
        public Void visit(ProviderInstanceBinding<?> binding) {
          methodHolder[0] = (ProviderMethod) binding.getUserSuppliedProvider();
          return null;
        }
      });

  assertEquals("Method provider should pretty print as the method signature",
      "#provideInteger(String)", nameFactory.getInstanceName(methodHolder[0]));
}

public void testGetInstanceName_providerMethod() throws Exception {
  final ProviderMethod<?>[] methodHolder = new ProviderMethod[1];

  Injector injector = Guice.createInjector(new ProvidingModule());
  injector.getBinding(Integer.class).acceptTargetVisitor(
      new DefaultBindingTargetVisitor<Object, Void>() {
        @SuppressWarnings("unchecked") @Override
        public Void visit(ProviderInstanceBinding<?> binding) {
          methodHolder[0] = (ProviderMethod) binding.getProviderInstance();
          return null;
        }
      });

  assertEquals("Method provider should pretty print as the method signature",
      "#provideInteger(String)", nameFactory.getInstanceName(methodHolder[0]));
}

@Override
public <T> Void visit(Binding<T> binding) {
  final Key<T> key = binding.getKey();

  if (!keysToIntercept.contains(key)) {
    return super.visit(binding);
  }

  binding.acceptTargetVisitor(new DefaultBindingTargetVisitor<T, Void>() {
    @Override
    public Void visit(UntargettedBinding<? extends T> untargettedBinding) {
      binder.addError("Cannot intercept bare binding of %s. " +
                "You may only intercept bindings that bind a class to something.", key);
      return null;
    }
  });

  Key<T> anonymousKey = Key.get(key.getTypeLiteral(), UniqueAnnotations.create());
  binder.bind(key).toProvider(new InterceptingProvider<T>(key, binder.getProvider(anonymousKey)));

  ScopedBindingBuilder scopedBindingBuilder = bindKeyToTarget(binding, binder, anonymousKey);

  // we scope the user's provider, not the interceptor. This is dangerous,
  // but convenient. It means that although the user's provider will live
  // in its proper scope, the intereptor gets invoked without a scope
  applyScoping(binding, scopedBindingBuilder);

  keysIntercepted.add(key);
  return null;
}

@Override
public <T> Void visit(Binding<T> binding) {
  final Key<T> key = binding.getKey();

  if (!keysToIntercept.contains(key)) {
    return super.visit(binding);
  }

  binding.acceptTargetVisitor(new DefaultBindingTargetVisitor<T, Void>() {
    @Override
    public Void visit(UntargettedBinding<? extends T> untargettedBinding) {
      binder.addError("Cannot intercept bare binding of %s. " +
                "You may only intercept bindings that bind a class to something.", key);
      return null;
    }
  });

  Key<T> anonymousKey = Key.get(key.getTypeLiteral(), UniqueAnnotations.create());
  binder.bind(key).toProvider(new InterceptingProvider<T>(key, binder.getProvider(anonymousKey)));

  ScopedBindingBuilder scopedBindingBuilder = bindKeyToTarget(binding, binder, anonymousKey);

  // we scope the user's provider, not the interceptor. This is dangerous,
  // but convenient. It means that although the user's provider will live
  // in its proper scope, the interceptor gets invoked without a scope
  applyScoping(binding, scopedBindingBuilder);

  keysIntercepted.add(key);
  return null;
}

private Module getBindings(LogInject<_Logger_> logInject, Class<_Logger_> loggerClass)
{
    TypeLiteral<_Logger_> loggerType = TypeLiteral.get(loggerClass);
    GuiceLoggerProvider<_Logger_> provider = new GuiceLoggerProvider<>();
    Predicate<Dependency<?>> matchesLogger = dependency -> loggerType.equals(dependency.getKey().getTypeLiteral());
    return new AbstractModule()
    {
        @Override
        protected void configure()
        {
            ProvisionListener provisionListener = new ProvisionListener()
            {
                @Override
                public <_Target_> void onProvision(ProvisionInvocation<_Target_> provision)
                {
                    Binding<_Target_> binding = provision.getBinding();
                    if (loggerType.equals(binding.getKey().getTypeLiteral()))
                    {
                        Dependency<?> loggerDependency;
                        Stream<Dependency<?>> stream;
                        stream = provision.getDependencyChain().stream().map(DependencyAndSource::getDependency);
                        Iterator<Dependency<?>> dependencies = reverse(stream.collect(toList())).iterator();
                        if (dependencies.hasNext() && matchesLogger.test(loggerDependency = dependencies.next()))
                        {
                            InjectionPoint injectionPoint = loggerDependency.getInjectionPoint();
                            TypeLiteral<?> declaringType = injectionPoint.getDeclaringType();
                            TypeLiteral<?> targetType = null;
                            if (dependencies.hasNext())
                            {
                                TypeLiteral<?> typeLiteral = dependencies.next().getKey().getTypeLiteral();
                                if (declaringType.getRawType().isAssignableFrom(typeLiteral.getRawType()))
                                {
                                    targetType = typeLiteral;
                                }
                            }
                            Class<?> logger = (targetType != null? targetType:declaringType).getRawType();
                            BindingTargetVisitor<_Target_, Void> bindingTargetVisitor;
                            bindingTargetVisitor = new DefaultBindingTargetVisitor<_Target_, Void>()
                            {
                                @Override
                                public Void visit(ProviderInstanceBinding<? extends _Target_> instanceBinding)
                                {
                                    if (provider.equals(instanceBinding.getUserSuppliedProvider()))
                                    {
                                        provider.setLogger(logInject.createLogger(logger));
                                    }
                                    return null;
                                }
                            };
                            binding.acceptTargetVisitor(bindingTargetVisitor);
                        }
                    }
                }
            };
            bind(loggerClass).toProvider(provider);
            bindListener(Matchers.any(), provisionListener);
        }
    };
}