annotatedType = beanManager.createAnnotatedType( beanType ); this.injectionTarget = beanManager.createInjectionTarget( annotatedType ); this.creationalContext = beanManager.createCreationalContext( null ); this.beanInstance = this.injectionTarget.produce( creationalContext ); injectionTarget.inject( beanInstance, creationalContext ); injectionTarget.postConstruct( beanInstance ); this.creationalContext.release();
@Test @SpecAssertion(section = DEPENDENT_OBJECTS, id = "aa") public void testDependentScopedInterceptorsAreDependentObjectsOfBean() { TransactionalInterceptor.destroyed = false; TransactionalInterceptor.intercepted = false; Bean<AccountTransaction> bean = getBeans(AccountTransaction.class).iterator().next(); CreationalContext<AccountTransaction> ctx = getCurrentManager().createCreationalContext(bean); AccountTransaction trans = (AccountTransaction) getCurrentManager().getReference(bean, AccountTransaction.class, ctx); trans.execute(); assert TransactionalInterceptor.intercepted; ctx.release(); assert TransactionalInterceptor.destroyed; } }
@Override public <U extends T> WeldBeanConfigurator<U> read(AnnotatedType<U> type) { checkArgumentNotNull(type); final InjectionTarget<T> injectionTarget = cast(beanManager.getInjectionTargetFactory(type).createInjectionTarget(null)); addInjectionPoints(injectionTarget.getInjectionPoints()); createWith(c -> { T instance = injectionTarget.produce(c); injectionTarget.inject(instance, c); injectionTarget.postConstruct(instance); return instance; }); destroyWith((i, c) -> { injectionTarget.preDestroy(i); c.release(); }); BeanAttributes<U> beanAttributes = beanManager.createBeanAttributes(type); read(beanAttributes); return cast(this); }
@Override public void destroy(Supplier<T> instance, CreationalContext<Supplier<T>> context) { injectionTarget.preDestroy(instance); injectionTarget.dispose(instance); context.release(); }
this.creationalContext = beanManager.createCreationalContext( null ); Set<Bean<?>> beans = beanManager.getBeans( beanType, new NamedBeanQualifier( beanName ) ); this.bean = (Bean<B>) beanManager.resolve( beans ); this.beanInstance = bean.create( creationalContext ); this.creationalContext.release();
import javax.enterprise.context.spi.CreationalContext; import javax.enterprise.inject.spi.AnnotatedType; import javax.enterprise.inject.spi.BeanManager; import javax.enterprise.inject.spi.InjectionTarget; import javax.naming.InitialContext; import javax.naming.NamingException; public class CdiHelper { // Nicked from: http://docs.jboss.org/weld/reference/1.1.0.Final/en-US/html_single/#d0e5286 public static <T> void programmaticInjection(Class clazz, T injectionObject) throws NamingException { InitialContext initialContext = new InitialContext(); Object lookup = initialContext.lookup("java:comp/BeanManager"); BeanManager beanManager = (BeanManager) lookup; AnnotatedType annotatedType = beanManager.createAnnotatedType(clazz); InjectionTarget injectionTarget = beanManager.createInjectionTarget(annotatedType); CreationalContext creationalContext = beanManager.createCreationalContext(null); injectionTarget.inject(injectionObject, creationalContext); creationalContext.release(); } }
public M create(CreationalContext<M> creationalContext) { Set<Bean<?>> beans = manager.getBeans(InjectionPoint.class, defaultQualifiers); Bean<?> injectionPointBean = (Bean<?>) beans.iterator().next(); InjectionPoint injectionPoint = (InjectionPoint) manager.getReference(injectionPointBean, InjectionPoint.class, creationalContext); UnwrapsInvocationHandler hdl = new UnwrapsInvocationHandler(manager, this.method, this, injectionPoint, declaringClassQualifiers); try { M obj = proxyClass.newInstance(); ((ProxyObject) obj).setHandler(hdl); creationalContext.push(obj); return obj; } catch (Exception e) { throw new RuntimeException(e); } }
public Object invoke(Object proxy, Method thisMethod, Method m, Object[] args) throws Throwable { CreationalContext<?> ctx = manager.createCreationalContext(bean); Object[] params = new Object[method.getParameterTypes().length]; for (int i = 0; i < this.method.getParameterTypes().length; ++i) { if (InjectionPoint.class.isAssignableFrom(this.method.getParameterTypes()[i])) { params[i] = injectionPoint; } else { params[i] = manager.getInjectableReference(injectionPoints[i], ctx); } } Object base = manager.getReference(mainClassBean, annotatedMethod.getDeclaringType().getJavaClass(), ctx); Object result = method.invoke(base, params); Object ret = thisMethod.invoke(result, args); ctx.release(); return ret; }
@Override public T create(CreationalContext<T> context) { T registry = target.produce(context); target.inject(registry, context); target.postConstruct(registry); context.push(registry); return registry; }
@Test(groups = { "contexts", "beanDestruction"}) @SpecAssertions({ @SpecAssertion(section = "6.1.1", id = "e") }) public void testCallingCreationalContextReleaseDestroysDependents() { assert getBeans(Farm.class).size() == 1; Bean<Farm> farmBean = getBeans(Farm.class).iterator().next(); CreationalContext<Farm> creationalContext = getCurrentManager().createCreationalContext(farmBean); Farm farm = farmBean.create(creationalContext); farm.open(); Stable.destroyed = false; Horse.destroyed = false; creationalContext.release(); assert Stable.destroyed; assert Horse.destroyed; }
@Override public <T> void invoke(Object receiver, MethodInjectionPoint<?, ?> method, T instance, BeanManagerImpl manager, CreationalContext<?> creationalContext) { boolean release = creationalContext == null; if (release) { creationalContext = manager.createCreationalContext(null); } try { method.invoke(receiver, instance, manager, creationalContext, exceptionTypeToThrow); } finally { if (release) { creationalContext.release(); } } } }
@Override public void preDestroy(Object instance, Object creationMetaData) throws InjectionProviderException { if (creationMetaData instanceof CreationalContext) { AnnotatedType annoType = beanManager.createAnnotatedType(instance.getClass()); InjectionTarget target = beanManager.createInjectionTarget(annoType); target.preDestroy(instance); ((CreationalContext)creationMetaData).release(); } } }
public void release() { context.release(); } }
@Override public void release() { try { injectionTarget.preDestroy(instance); } finally { ctx.release(); } }
public void destroy(T instance, CreationalContext<T> creationalContext) { super.destroy(instance, creationalContext); try { getProducer().dispose(instance); } catch (Exception e) { BeanLogger.LOG.errorDestroying(instance, this); BeanLogger.LOG.catchingDebug(e); } finally { if (getDeclaringBean().isDependent()) { creationalContext.release(); } } }
/** * Dispose of the instance, doing any necessary cleanup * * @throws IllegalStateException if dispose() is called before produce() is called * @throws IllegalStateException if dispose() is called on an instance that has already been disposed * @return self */ public UnmanagedInstance<T> dispose() { if (instance == null) { throw new IllegalStateException("Trying to call dispose() before produce() was called"); } if (disposed) { throw new IllegalStateException("Trying to call dispose() on already disposed instance"); } disposed = true; injectionTarget.dispose(instance); ctx.release(); return this; }
/** * Shutdown the container. * * @see Weld#initialize() */ public synchronized void shutdown() { checkIsRunning(); try { beanManager().fireEvent(new ContainerShutdown(id), DestroyedLiteral.APPLICATION); } finally { discard(id); // Destroy all the dependent beans correctly creationalContext.release(); bootstrap.shutdown(); WeldSELogger.LOG.weldContainerShutdown(id); } }
@Override public void destroy(T instance, CreationalContext<T> creationalContext) { super.destroy(instance, creationalContext); if (instance == null) { throw BeanLogger.LOG.cannotDestroyNullBean(this); } if (!(instance instanceof EnterpriseBeanInstance)) { throw BeanLogger.LOG.cannotDestroyEnterpriseBeanNotCreated(instance); } EnterpriseBeanInstance enterpriseBeanInstance = (EnterpriseBeanInstance) instance; enterpriseBeanInstance.destroy(Marker.INSTANCE, this, creationalContext); creationalContext.release(); }
public void close() { ContextItem<?> entry = _values; _values = null; for (; entry != null; entry = entry.getNext()) { Contextual bean = entry.getBean(); Object id = entry.getId(); Object value = entry.getObject(); if (bean == null && id instanceof String) { BeanManager beanManager = getBeanManager(); bean = beanManager.getPassivationCapableBean((String) id); } CreationalContext<?> env = entry.getEnv(); bean.destroy(value, env); if (env != null) env.release(); } }