public <I> void hear(TypeLiteral<I> typeLiteral, TypeEncounter<I> typeEncounter) { typeEncounter.register(new InjectionListener<I>() { public void afterInjection(I i) { m_eventBus.register(i); if (i instanceof KairosPostConstructInit) { ((KairosPostConstructInit)i).init(); } } }); } });
@Override public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) { encounter.register(new InjectionListener<I>() { @Override public void afterInjection(I injectee) { if (KairosMetricReporter.class.isAssignableFrom(injectee.getClass())) { m_reporters.add((KairosMetricReporter)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()); } }); } } }
@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(TypeLiteral<I> type, TypeEncounter<I> encounter) { if (scheduler.hasScheduledMethod(type.getRawType())) { // Add the listener encounter.register(new ScheduleListener<I>(scheduler)); } } }
@Override public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) { if (hasLifecycleMethod(type.getRawType())) { // Add the listener encounter.register(new LifecycleListener<I>()); } } }
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); } } } }); }
public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) { if (InitializableInjectionListener.MATCHER.matches(type)) { encounter.register(this.<I>castListener(new InitializableInjectionListener<Initializable>())); } if (DestroyableInjectionListener.MATCHER.matches(type)) { encounter.register(this.<I>castListener(new DestroyableInjectionListener<Destroyable>(registry))); } }
encounter.register(new ConfigMethodInjector<>(method, configValue));
@Test public void testHearDestroyable() throws Exception { TypeEncounter encounter = createMock(TypeEncounter.class); encounter.register(anyObject(DestroyableInjectionListener.class)); replay(encounter); LifecycleTypeListener underTest = new LifecycleTypeListener(null); underTest.hear(TypeLiteral.get(MyDestroyable.class), encounter); verify(encounter); }
@Test public void testHearInitializable() throws Exception { TypeEncounter encounter = createMock(TypeEncounter.class); encounter.register(anyObject(InitializableInjectionListener.class)); replay(encounter); LifecycleTypeListener underTest = new LifecycleTypeListener(null); underTest.hear(TypeLiteral.get(MyInitializable.class), encounter); verify(encounter); }
@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(); }
public void hear(TypeLiteral typeLiteral, TypeEncounter typeEncounter) { typeEncounter.register((InjectionListener) i -> eventBus.register(i)); } });
@Override public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) { encounter.register(injectionListener); } };
@Override public <I> void hear(TypeLiteral<I> typeLiteral, TypeEncounter<I> typeEncounter) { for( Class<?> c = typeLiteral.getRawType(); c != Object.class; c = c.getSuperclass() ) { for( final Field field : c.getDeclaredFields() ) { if( field.getType().isAssignableFrom(Logger.class) && field.isAnnotationPresent(Inject.class) ) { typeEncounter.register(new MyMembersInjector<I>(field)); } } } } }
@Override public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) { MembersInjector<? super I> membersInjector = x -> { Class<? super I> rawType = type.getRawType(); configurables.add(rawType.asSubclass(Configurable.class)); }; encounter.register(membersInjector); } }
/** * @inheritDoc */ public <I> void hear(final TypeLiteral<I> theTypeLiteral, final TypeEncounter<I> theTypeEncounter) { for (Field aField : theTypeLiteral.getRawType().getDeclaredFields()) { if (aField.getType() == EntityManager.class && aField.isAnnotationPresent(PersistenceContext.class)) { theTypeEncounter.register(new PersistenceContextInjector<I>(aField)); } } } }
@Override public <T> void hear(TypeLiteral<T> type, TypeEncounter<T> encounter) { for (Field field : type.getRawType().getDeclaredFields()) { if (field.getType() == Renderer.class && field.isAnnotationPresent(Render.class)) { encounter.register(new RendererMemberInjector<>(field, renderers)); } } } }
@Override public <I> void hear(TypeLiteral<I> injectableType, TypeEncounter<I> encounter) { Class<? super I> type = injectableType.getRawType(); if (StatusProviderService.class.isAssignableFrom(type)) { encounter.register(new InjectionListenerImpl<I>(providers)); } } });
public <I> void hear(TypeLiteral<I> literal, TypeEncounter<I> encounter) { final List<Method> constructs = new ArrayList<Method>(); final List<Method> destroys = new ArrayList<Method>(); extractLifecycleMethods(literal, constructs, destroys); logger.debug("Registering lifecycle listeners for {}", literal); if (!constructs.isEmpty() || !destroys.isEmpty()) { encounter.register(new LifecycleExecutor(constructs, destroys)); } }