Refine search
/** * Will re-inject any managed beans in the target. Will not call any other life-cycle methods * * @param ctx * @param managedBean */ public static void reinitialize(Context ctx, Contextual<Object> contextual) { try { ManagedBean<Object> managedBean = ManagedBean.class.cast(contextual); LOGGER.debug("Re-Initializing........ {},: {}", managedBean, ctx); Object get = ctx.get(managedBean); if (get != null) { LOGGER.debug("Bean injection points are reinitialized '{}'", managedBean); managedBean.getProducer().inject(get, managedBean.getBeanManager().createCreationalContext(managedBean)); } } catch (Exception e) { LOGGER.error("Error reinitializing bean {},: {}", e, contextual, ctx); } } }
@Test(groups = "contexts") @SpecAssertion(section = "6.4", id = "f") public void testContextGetWithCreateFalseReturnsNull() { Set<Bean<Fox>> foxBeans = getBeans(Fox.class); assert foxBeans.size() == 1; Bean<Fox> foxBean = foxBeans.iterator().next(); Context context = getCurrentManager().getContext(Dependent.class); assert context.get(foxBean, null) == null; }
@Test @SpecAssertion(section = ALTERNATIVE_METADATA_SOURCES, id = "ab") public void testDisposesIsAppliedToMethodParameter() { Bean<Yogurt> yogurt = getBeans(Yogurt.class, new ExpensiveLiteral()).iterator().next(); CreationalContext<Yogurt> context = getCurrentManager().createCreationalContext(yogurt); Yogurt instance = getCurrentManager().getContext(yogurt.getScope()).get(yogurt, context); yogurt.destroy(instance, context); assertTrue(Grocery.isDisposerMethodCalled()); }
@Test @SpecAssertion(section = CONTEXT, id = "q") @SpecAssertion(section = BEAN, id = "aa") public void testDestroyedInstanceMustNotBeReturnedByGet() { assert getBeans(MySessionBean.class).size() == 1; Bean<MySessionBean> mySessionBean = getBeans(MySessionBean.class).iterator().next(); CreationalContext<MySessionBean> sessionCreationalContext = getCurrentManager().createCreationalContext(mySessionBean); MySessionBean beanInstance = mySessionBean.create(sessionCreationalContext); assert beanInstance != null; Context sessionContext = getCurrentManager().getContext(SessionScoped.class); destroyContext(sessionContext); setContextActive(sessionContext); beanInstance = sessionContext.get(mySessionBean); assert beanInstance == null; }
@Test @SpecAssertion(section = AFTER_BEAN_DISCOVERY, id = "f") public void testAddContext() { Context context = getCurrentManager().getContext(SuperScoped.class); assertNotNull(context); assertTrue(context.isActive()); assertTrue(context instanceof SuperContext); }
@Test @SpecAssertion(section = TYPECASTING_BETWEEN_BEAN_TYPES, id = "a") @SuppressWarnings("unused") public void testBeanClientCanCastBeanInstanceToAnyBeanType() { Set<Bean<Tarantula>> beans = getBeans(Tarantula.class); assertEquals(beans.size(), 1); Bean<Tarantula> bean = beans.iterator().next(); Tarantula tarantula = getCurrentManager().getContext(bean.getScope()).get(bean); Animal animal = tarantula; Object obj = tarantula; DeadlySpider deadlySpider = tarantula; DeadlyAnimal deadlyAnimal = tarantula; }
@Test(groups = { "contexts" }, expectedExceptions = { ContextNotActiveException.class }) @SpecAssertion(section = "6.2", id = "m") public void testInvokingGetOnInactiveContextFails() { Context sessionContext = getCurrentManager().getContext(SessionScoped.class); assert sessionContext.isActive(); setContextInactive(sessionContext); Contextual<MySessionBean> mySessionBean = getBeans(MySessionBean.class).iterator().next(); sessionContext.get(mySessionBean); }
@Test @SpecAssertion(section = CONTEXT, id = "ab") public void testContextScopeType() { assert getCurrentManager().getContext(Dependent.class).getScope().equals(Dependent.class); }
@Override public void run() { if (firstInit) { Context theContext = beanManager.getContext(bean.getScope()); instance = theContext.get(bean); if (instance == null) { CreationalContext theCreational = beanManager.createCreationalContext(bean); instance = beanManager.getReference(bean, bean.getBeanClass(), theCreational); } firstInit = false; } try { method.invoke(instance, new Object[0]); } catch (Exception e) { throw new RuntimeException(e); } } }
public static <T> T getInstance(BeanManager beanManager, Bean<T> bean, boolean create) { Context context = beanManager.getContext(bean.getScope()); if (create) { return context.get(bean, beanManager.createCreationalContext(bean)); } else { return context.get(bean); } }
/** * @see Beans#getActiveInstances(Class) */ public static <S extends Annotation> Map<Object, String> getActiveInstances(BeanManager beanManager, Class<S> scope) { Map<Object, String> activeInstances = new HashMap<>(); Set<Bean<?>> beans = beanManager.getBeans(Object.class); Context context = beanManager.getContext(scope); for (Bean<?> bean : beans) { Object instance = context.get(bean); if (instance != null) { activeInstances.put(instance, bean.getName()); } } return Collections.unmodifiableMap(activeInstances); }
@Override T getIfExists(Bean<T> bean, BeanManagerImpl manager) { return manager.getContext(bean.getScope()).get(bean); }
@Override T get(Bean<T> bean, BeanManagerImpl manager, CreationalContext<?> ctx) { Context context = manager.getContext(bean.getScope()); T instance = context.get(bean); if (instance == null) { if (ctx == null) { ctx = manager.createCreationalContext(bean); } instance = context.get(bean, Reflections.<CreationalContext<T>> cast(ctx)); } return instance; }
/** * @see Beans#destroy(Bean) */ public static <T> void destroy(BeanManager beanManager, Bean<T> bean) { Context context = beanManager.getContext(bean.getScope()); if (context instanceof AlterableContext) { ((AlterableContext) context).destroy(bean); } else { T instance = context.get(bean); if (instance != null) { destroy(beanManager, bean, instance); } } }
public void testConversationContextIsActive() { try { result = beanManager.getContext(ConversationScoped.class).isActive(); } catch (ContextNotActiveException expected) { result = false; } }
@SuppressWarnings({ "unchecked", "rawtypes" }) private static void doReinjectBeanInstance(BeanManagerImpl beanManager, AbstractClassBean bean, Context context) { Object instance = context.get(bean); if (instance != null) { doCallInject(beanManager, bean, instance); } }
@SuppressWarnings("unchecked") private void addInterceptorInstance(Interceptor<Object> interceptor, BeanManagerImpl beanManager, Map<String, SerializableContextualInstance<Interceptor<Object>, Object>> instances) { Object instance = beanManager.getContext(interceptor.getScope()).get(interceptor, creationalContext); SerializableContextualInstance<Interceptor<Object>, Object> serializableContextualInstance = beanManager.getServices().get(ContextualStore.class).<Interceptor<Object>, Object>getSerializableContextualInstance(interceptor, instance, creationalContext); instances.put(interceptor.getBeanClass().getName(), serializableContextualInstance); }