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); } }; }