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();
@Override public void destroy(Supplier<T> instance, CreationalContext<Supplier<T>> context) { injectionTarget.preDestroy(instance); injectionTarget.dispose(instance); context.release(); }
@Override public Set<InjectionPoint> getInjectionPoints() { return injectionTarget.getInjectionPoints(); }
@Override public Supplier<T> create(CreationalContext<Supplier<T>> context) { Supplier<T> instance = injectionTarget.produce(context); injectionTarget.inject(instance, context); injectionTarget.postConstruct(instance); return instance; }
@Override public T getInstance(final Class<T> clazz) { final CreationalContext<T> creationalContext = beanManager.createCreationalContext(null); final T instance = injectionTarget.produce(creationalContext); injectionTarget.inject(instance, creationalContext); if (injectionManager != null) { injectionManager.inject(instance, CdiComponentProvider.CDI_CLASS_ANALYZER); } injectionTarget.postConstruct(instance); return instance; }
@Override @SuppressWarnings("unchecked") public void inject(Object instance) { if (beanManager != null) { AnnotatedType annotatedType = beanManager.createAnnotatedType((Class) instance.getClass()); InjectionTarget injectionTarget = beanManager.createInjectionTarget(annotatedType); CreationalContext context = beanManager.createCreationalContext(null); injectionTarget.inject(instance, context); } }
@Override public ManagedReference createInstance(final Object instance) { final BeanManager beanManager = beanManagerSupplier.get(); final InjectionTarget injectionTarget = getInjectionTarget(instance.getClass()); final CreationalContext context = beanManager.createCreationalContext(null); injectionTarget.inject(instance, context); injectionTarget.postConstruct(instance); return new WeldManagedReference(injectionTarget, context, instance); }
/** * Injects the instance * * @param instance */ public void inject(T instance) { CreationalContext<T> cc = BeanManagerLookup.lookup().createCreationalContext(null); it.inject(instance, cc); }
private static <T> T createAndInjectBeans(BeanManager beanManager, InjectionTarget<T> injectionTarget) { CreationalContext<T> creationalContext = beanManager.createCreationalContext( null ); T instance = injectionTarget.produce( creationalContext ); injectBeans( beanManager, creationalContext, injectionTarget, instance ); return instance; }
@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(); } } }
/** * Runs CDI injection on the instance. This should be called after resource injection has been performed */ public void inject(Object instance) { injectionTarget.inject(instance, context); }
@Override public T create(CreationalContext<T> creationalContext) { T instance = injectionTarget.produce(creationalContext); injectionTarget.inject(instance, creationalContext); for (Entry<AnnotatedField<? super T>, InjectionPoint> field : injectedFields.entrySet()) { Object value = getBeanManager().getInjectableReference(field.getValue(), creationalContext); field.getKey().getJavaMember().setAccessible(true); Reflections.setFieldValue(field.getKey().getJavaMember(), instance, value); } injectionTarget.postConstruct(instance); return instance; }
@Override public T create(CreationalContext<T> context) { T registry = target.produce(context); target.inject(registry, context); target.postConstruct(registry); context.push(registry); return registry; }
@Override public void release() { try { injectionTarget.preDestroy(instance); } finally { ctx.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; }
private static <T> void injectBeans(BeanManager beanManager, CreationalContext<T> creationalContext, InjectionTarget<T> injectionTarget, T instance) { injectionTarget.inject( instance, creationalContext ); injectionTarget.postConstruct( instance ); } }
@Override public void preDestroy(final T instance) { injectionTarget.preDestroy(instance); } };
@Override public void postConstruct(final Object t) { delegate.postConstruct(t); }
public void destroy() { injectionTarget.preDestroy( instance ); injectionTarget.dispose( instance ); }