private static Optional<Command> defaultCommand(Injector injector) { // default is optional, so check via injector whether it is bound... Binding<Command> binding = injector.getExistingBinding(Key.get(Command.class, DefaultCommand.class)); return binding != null ? Optional.of(binding.getProvider().get()) : Optional.empty(); }
Object getInstanceOfTypeWithQualifier(Type genericReturnType, Annotation qualifier) { // look for an existing binding Binding<?> binding = injector.getExistingBinding(Key.get(genericReturnType, qualifier)); if (binding != null) return binding.getProvider().get(); // then, try looking via supplier binding = injector .getExistingBinding(Key.get(newParameterizedType(Supplier.class, genericReturnType), qualifier)); if (binding != null) return Supplier.class.cast(binding.getProvider().get()).get(); // else try to create an instance return injector.getInstance(Key.get(genericReturnType, qualifier)); }
protected Optional<SecurityGroupExtension> provideSecurityGroupExtension(Injector i) { Binding<SecurityGroupExtension> binding = i.getExistingBinding(Key.get(SecurityGroupExtension.class)); return binding == null ? Optional.<SecurityGroupExtension> absent() : Optional.of(binding.getProvider().get()); } }
@Test(expected = NullPointerException.class) public void testFailsOnEmptyTier() { final JsonConfigurator configurator = injector.getBinding(JsonConfigurator.class).getProvider().get(); properties.put(propertyBase + ".lookupTier", ""); final JsonConfigProvider<LookupListeningAnnouncerConfig> configProvider = JsonConfigProvider.of( propertyBase, LookupListeningAnnouncerConfig.class ); configProvider.inject(properties, configurator); final LookupListeningAnnouncerConfig config = configProvider.get().get(); config.getLookupTier(); }
String.class, Types.newParameterizedType(Provider.class, key.getTypeLiteral().getType()) ); if (key.getAnnotation() != null) { implsMap = (Map<String, Provider<T>>) injector.getInstance(Key.get(mapType, key.getAnnotation())); } else if (key.getAnnotationType() != null) { implsMap = (Map<String, Provider<T>>) injector.getInstance(Key.get(mapType, key.getAnnotationType())); } else { implsMap = (Map<String, Provider<T>>) injector.getInstance(Key.get(mapType)); return provider.get();
private void registerFilter(Injector injector, Environment environment, Binding<?> binding) { FilterDefinition filterDefinition = (FilterDefinition)binding.getProvider().get(); log.info("Registering filter: " + filterDefinition); Filter filterInstance = filterDefinition.getFilterInstance(); if ( filterInstance == null ) { filterInstance = injector.getInstance(filterDefinition.getFilterKey()); } FilterRegistration.Dynamic registration = environment.servlets().addFilter(filterDefinition.getFilterKey().toString(), filterInstance); registration.setInitParameters(filterDefinition.getInitParams()); registration.addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), true, filterDefinition.getUriPatterns()); }
@Test public void testPropertySetting() throws Exception { IMocksControl control = createControl(); TypeEncounter<SomeInjectableBean> encounter = control.createMock(TypeEncounter.class); Provider<Injector> injectorProvider = control.createMock(Provider.class); Injector injector = control.createMock(Injector.class); expect(encounter.getProvider(Injector.class)).andReturn(injectorProvider); expect(injectorProvider.get()).andReturn(injector).anyTimes(); Capture<MembersInjector<SomeInjectableBean>> capture = new Capture<MembersInjector<SomeInjectableBean>>(); encounter.register(and(anyObject(MembersInjector.class), capture(capture))); SecurityManager securityManager = control.createMock(SecurityManager.class); String property = "myPropertyValue"; expect(injector.getInstance(Key.get(SecurityManager.class))).andReturn(securityManager); expect(injector.getInstance(Key.get(String.class, Names.named("shiro.myProperty")))).andReturn(property); expect(injector.getInstance(Key.get(String.class, Names.named("shiro.unavailableProperty")))) .andThrow(new ConfigurationException(Collections.singleton(new Message("Not Available!")))); expect((Map)injector.getInstance(BeanTypeListener.MAP_KEY)).andReturn(Collections.EMPTY_MAP).anyTimes(); control.replay(); BeanTypeListener underTest = new BeanTypeListener(); underTest.hear(TypeLiteral.get(SomeInjectableBean.class), encounter); SomeInjectableBean bean = new SomeInjectableBean(); capture.getValue().injectMembers(bean); assertSame(securityManager, bean.securityManager); assertSame(property, bean.myProperty); assertNull(bean.unavailableProperty); control.verify(); }
@SuppressWarnings({ "rawtypes", "unchecked" }) @Override public Object findWithName(Class contract, String name) throws StrategyNotFoundException { Binding<Set> b = injector.getBinding(Key.get(setOf(TypeLiteral.get(contract)))); for (Object o : b.getProvider().get()) { if (name.equals(Introspector.decapitalize(o.getClass().getSimpleName()))) return o; } throw new StrategyNotFoundException(contract, name, Collections.<String>emptySet()); }
private <T> T getValue(Class<T> configurationType, String configurationKey) { try { return injectorProvider .get() .getInstance(Key.get(configurationType, Names.named(configurationKey))); } catch (ConfigurationException | ProvisionException e) { return null; } }
throws IllegalAccessException, NoSuchMethodException, InvocationTargetException, IOException JsonConfigurator configurator = injector.getBinding(JsonConfigurator.class).getProvider().get(); propertyValues.put(StringUtils.format("%s.connectorPath", configPrefix), ZKPaths.makePath(base, "connector")); ZkPathsConfig zkPathsConfigObj = zkPathsConfig.get().get(); validateEntries(zkPathsConfigObj); Assert.assertEquals(propertyValues.size(), assertions); ObjectMapper jsonMapper = injector.getProvider(Key.get(ObjectMapper.class, Json.class)).get(); String jsonVersion = jsonMapper.writeValueAsString(zkPathsConfigObj);
@Override protected HttpClient newHttpClient() { return httpClientProvider.get(); }
public void injectMembers(I instance) { for (Map.Entry<PropertyDescriptor, Key<?>> dependency : propertyDependencies.entrySet()) { try { final Injector injector = injectorProvider.get(); Object value = injector.getInstance(getMappedKey(injector, dependency.getValue())); dependency.getKey().getWriteMethod().invoke(instance, value); } catch (ConfigurationException e) { // This is ok, it simply means that we can't fulfill this dependency. // Is there a better way to do this? } catch (InvocationTargetException e) { throw new RuntimeException("Couldn't set property " + dependency.getKey().getDisplayName(), e); } catch (IllegalAccessException e) { throw new RuntimeException("We shouldn't have ever reached this point, we don't try to inject to non-accessible methods.", e); } } } });
private <U> void _find(Class<U> type, List<ExtensionComponent<U>> result, Injector container) { for (Entry<Key<?>, Binding<?>> e : container.getBindings().entrySet()) { if (type.isAssignableFrom(e.getKey().getTypeLiteral().getRawType())) { Annotation a = annotations.get(e.getKey()); Object o = e.getValue().getProvider().get(); if (o!=null) { GuiceExtensionAnnotation gea = a!=null ? extensionAnnotations.get(a.annotationType()) : null; result.add(new ExtensionComponent<>(type.cast(o), gea != null ? gea.getOrdinal(a) : 0)); } } } }
@Override public HttpClient get() final DruidHttpClientConfig config = getConfigProvider().get().get(); sslContextFactory.setSslContext(getSslContextBinding().getProvider().get()); httpClient = new HttpClient(sslContextFactory); } else { httpClient.setExecutor(pool); final Lifecycle lifecycle = getLifecycleProvider().get();
sslContextFactory = sslContextFactoryBinding.getProvider().get(); JettyServerInitializer initializer = injector.getInstance(JettyServerInitializer.class); try { initializer.initialize(server, injector);
private Emitter findEmitter(String emitterType, List<Binding<Emitter>> emitterBindings) { for (Binding<Emitter> binding : emitterBindings) { if (Names.named(emitterType).equals(binding.getKey().getAnnotation())) { return binding.getProvider().get(); } } return null; }
private Set<Object> getBeans(Collection<Class<? extends Annotation>> annotations) { Set<Object> beans = U.set(); for (Map.Entry<Key<?>, Binding<?>> e : injector.getAllBindings().entrySet()) { Key<?> key = e.getKey(); Binding<?> value = e.getValue(); boolean include = false; if (U.notEmpty(annotations)) { if (key.getTypeLiteral() != null && key.getTypeLiteral().getRawType() != null) { Class<?> type = key.getTypeLiteral().getRawType(); if (Metadata.isAnnotatedAny(type, annotations)) { include = true; } } } else { include = true; } if (include) { beans.add(value.getProvider().get()); } } return beans; }
public void processInjector(final Injector injector) { List<Binding<?>> rootResourceBindings = new ArrayList<Binding<?>>(); for (final Binding<?> binding : injector.getBindings().values()) { final Type type = binding.getKey().getTypeLiteral().getRawType(); if (type instanceof Class) { final Class<?> beanClass = (Class) type; if (GetRestful.isRootResource(beanClass)) { // deferred registration rootResourceBindings.add(binding); } if (beanClass.isAnnotationPresent(Provider.class)) { LogMessages.LOGGER.info(Messages.MESSAGES.registeringProviderInstance(beanClass.getName())); providerFactory.registerProviderInstance(binding.getProvider().get()); } } } for (Binding<?> binding : rootResourceBindings) { Class<?> beanClass = (Class) binding.getKey().getTypeLiteral().getType(); final ResourceFactory resourceFactory = new GuiceResourceFactory(binding.getProvider(), beanClass); LogMessages.LOGGER.info(Messages.MESSAGES.registeringFactory(beanClass.getName())); registry.addResourceFactory(resourceFactory); } } }