@Override public <I> void hear(TypeLiteral<I> typeLiteral, TypeEncounter<I> typeEncounter) { final Provider<EventBus> eventBusProvider = typeEncounter.getProvider(EventBus.class); if (EventBusAware.class.isAssignableFrom(typeLiteral.getRawType())) { typeEncounter.register( new InjectionListener<I>() { @Override public void afterInjection(Object o) { ((EventBusAware)o).setEventBus(eventBusProvider.get()); } }); } } }
@Override public <I> void hear(TypeLiteral<I> typeLiteral, TypeEncounter<I> typeEncounter) { final Provider<EventBus> eventBusProvider = typeEncounter.getProvider(EventBus.class); List<Method> methods = ClassUtils.getAnnotatedMethods(typeLiteral.getRawType(), Subscribe.class); if (methods != null && !methods.isEmpty()) { typeEncounter.register( new InjectionListener<I>() { @Override public void afterInjection(Object o) { eventBusProvider.get().register(o); } }); } } }
public <I> void hear(TypeLiteral<I> type, final TypeEncounter<I> encounter) { PropertyDescriptor propertyDescriptors[] = beanUtilsBean.getPropertyUtils().getPropertyDescriptors(type.getRawType()); final Map<PropertyDescriptor, Key<?>> propertyDependencies = new HashMap<PropertyDescriptor, Key<?>>(propertyDescriptors.length); final Provider<Injector> injectorProvider = encounter.getProvider(Injector.class); for (PropertyDescriptor propertyDescriptor : propertyDescriptors) { if (propertyDescriptor.getWriteMethod() != null && Modifier.isPublic(propertyDescriptor.getWriteMethod().getModifiers())) { Type propertyType = propertyDescriptor.getWriteMethod().getGenericParameterTypes()[0]; propertyDependencies.put(propertyDescriptor, createDependencyKey(propertyDescriptor, propertyType)); } } encounter.register(new MembersInjector<I>() { 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); } } } }); }
@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(); }
PlexusRequirements( final TypeEncounter<?> encounter ) { locatorProvider = encounter.getProvider( PlexusBeanLocator.class ); }
/** * Constructor of the listener. Initializes all the fields. * * @param typeEncounter Type encounter instance, provided by Guice. */ public PageObjectInjectorListener(TypeEncounter<?> typeEncounter) { this.webDriverProvider = typeEncounter.getProvider(WebDriver.class); this.locatorStackProvider = typeEncounter.getProvider(ContextStack.class); this.registry = typeEncounter.getProvider(FieldProviderRegistry.class); this.frameMap = typeEncounter.getProvider(FrameMap.class); this.bobcatWebElementFactoryProvider = typeEncounter.getProvider(BobcatWebElementFactory.class); }
/** * Constructor of the listener. Initializes all the fields. * * @param typeEncounter Type encounter instance, provided by Guice. */ public PageObjectInjectorListener(TypeEncounter<?> typeEncounter) { this.webDriverProvider = typeEncounter.getProvider(WebDriver.class); this.locatorStackProvider = typeEncounter.getProvider(ContextStack.class); this.registry = typeEncounter.getProvider(FieldProviderRegistry.class); this.frameMap = typeEncounter.getProvider(FrameMap.class); this.bobcatWebElementFactoryProvider = typeEncounter.getProvider(BobcatWebElementFactory.class); }
PlexusConfigurations( final TypeEncounter<?> encounter ) { converterProvider = encounter.getProvider( PlexusBeanConverter.class ); }
public Provider<? extends T> get(TypeEncounter<?> encounter) { return encounter.getProvider(key); } };
public Provider<? extends T> get(TypeEncounter<?> encounter) { return encounter.getProvider(type); } };
@Override public void processField(Object target, Field field) { providers.put(field.getType(), encounter.getProvider(field.getType())); } }
@Override public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) { final Provider<JmxExporter> exporter = encounter.getProvider(JmxExporter.class); encounter.register(new InjectionListener<I>() { @Override public void afterInjection(I injectee) { exporter.get().register(injectee); } }); } });
@Override public <I> void hear(TypeLiteral<I> typeLiteral, TypeEncounter<I> typeEncounter) { final Provider<EventBus> eventBusProvider = typeEncounter.getProvider(EventBus.class); if (EventBusAware.class.isAssignableFrom(typeLiteral.getRawType())) { typeEncounter.register( new InjectionListener<I>() { @Override public void afterInjection(Object o) { ((EventBusAware)o).setEventBus(eventBusProvider.get()); } }); } } }
/** * Create an injector based on a particular encounter with a field. * * @param typeEncounter the context of the encounter. * @param field the field. * @param <T> the type of the object that declares the field * @return the injector for field. */ public static <T> FieldBasedInjector<T> createFromEncounter( @Nonnull final TypeEncounter<T> typeEncounter, @Nonnull final Field field ) { final Provider<?> provider = typeEncounter.getProvider( field.getType() ); return new FieldBasedInjector<>( provider, field ); }
/** * Create an injector based on a particular encounter with a field. * * @param typeEncounter the context of the encounter. * @param name the name of the resource to inject. * @param field the field. * @param <T> the type of the object that declares the field * @return the injector for field. */ public static <T> FieldBasedInjector<T> createFromEncounter( @Nonnull final TypeEncounter<T> typeEncounter, @Nonnull final String name, @Nonnull final Field field ) { final Provider<?> provider = typeEncounter.getProvider( Key.get( field.getType(), Names.named( name ) ) ); return new FieldBasedInjector<>( provider, field ); }
@Override public <I> void hear(final TypeLiteral<I> type, TypeEncounter<I> encounter) { final Provider<? extends MethodHandler<A>> provider = encounter.getProvider(handlerClass); final List<Method> methods = reverse(newLinkedList(Reflect.findAllAnnotatedMethods(type.getRawType(), annotationType))); if (!methods.isEmpty()) { encounter.register(new InjectionListener<I>() { @Override public void afterInjection(I injectee) { MethodHandler<A> handler = provider.get(); for (Method method : methods) handler.handle(type, injectee, method, method.getAnnotation(annotationType)); } }); } } }
@Override public <I> void hear(TypeLiteral<I> typeLiteral, TypeEncounter<I> typeEncounter) { final Provider<EventBus> eventBusProvider = typeEncounter.getProvider(EventBus.class); List<Method> methods = ClassUtils.getAnnotatedMethods(typeLiteral.getRawType(), Subscribe.class); if (methods != null && !methods.isEmpty()) { typeEncounter.register( new InjectionListener<I>() { @Override public void afterInjection(Object o) { eventBusProvider.get().register(o); } }); } } }
@Override public <I> void hear(final TypeLiteral<I> type, TypeEncounter<I> encounter) { final Provider<? extends FieldHandler<A>> provider = encounter.getProvider(handlerClass); final List<Field> fields = Lists.newLinkedList(Reflect.findAllAnnotatedFields(type.getRawType(), annotationType)); if (!fields.isEmpty()) { encounter.register(new InjectionListener<I>() { @Override public void afterInjection(I injectee) { FieldHandler<A> handler = provider.get(); for (Field field : fields) handler.handle(type, injectee, field, field.getAnnotation(annotationType)); } }); } } }
public <I> void hear(final TypeLiteral<I> type, final TypeEncounter<I> encounter) { Provider<EventCasterInternal> eventCasterProvider = null; for (final Class<?> interfaceClass : interfacesInInheritanceHierarchy(type.getRawType())) { final TypeLiteral<?> interfaceType = type.getSupertype(interfaceClass); if (bindings.contains(interfaceType)) { if(eventCasterProvider == null) { eventCasterProvider = encounter.getProvider(EventCasterInternal.class); } encounter.register(new RegisterInjectedEventListeners<I>(interfaceType, eventCasterProvider)); } } }
@Override public <I> void hear(TypeLiteral<I> type, final TypeEncounter<I> encounter) { final Provider<Injector> injectorProvider = encounter.getProvider(Injector.class); encounter.register((InjectionListener<Object>) injected -> { WebApplication app = (WebApplication) injected; app.getComponentInstantiationListeners().add(new GuiceComponentInjector(app, injectorProvider.get())); }); } });