/** * Create an injector for the given class * @param manager the {@link BeanManager} * @param clazz class of the unmanaged instances */ public Unmanaged(BeanManager manager, Class<T> clazz) { this.beanManager = manager; AnnotatedType<T> type = manager.createAnnotatedType(clazz); this.injectionTarget = manager.getInjectionTargetFactory(type).createInjectionTarget(null); }
final InjectionTargetFactory<T> injectionTargetFactory = beanManager.getInjectionTargetFactory(annotatedType); final InjectionTarget<T> injectionTarget = injectionTargetFactory.createInjectionTarget(null);
@Override public <T> InjectionTargetFactory<T> getInjectionTargetFactory(AnnotatedType<T> annotatedType) { return delegate().getInjectionTargetFactory(annotatedType); }
@Override public <T> InjectionTargetFactory<T> getInjectionTargetFactory(AnnotatedType<T> annotatedType) { return delegate().getInjectionTargetFactory(annotatedType); }
@Override public <T> InjectionTargetFactory<T> getInjectionTargetFactory(AnnotatedType<T> annotatedType) { return delegate().getInjectionTargetFactory(annotatedType); }
@Override public <T> InjectionTargetFactory<T> getInjectionTargetFactory(AnnotatedType<T> annotatedType) { return delegate().getInjectionTargetFactory(annotatedType); }
/** * Create an injector for the given class * @param manager the {@link BeanManager} * @param clazz class of the unmanaged instances */ public Unmanaged(BeanManager manager, Class<T> clazz) { this.beanManager = manager; AnnotatedType<T> type = manager.createAnnotatedType(clazz); this.injectionTarget = manager.getInjectionTargetFactory(type).createInjectionTarget(null); }
/** * Create an injector for the given class * @param manager the {@link BeanManager} * @param clazz class of the unmanaged instances */ public Unmanaged(BeanManager manager, Class<T> clazz) { this.beanManager = manager; AnnotatedType<T> type = manager.createAnnotatedType(clazz); this.injectionTarget = manager.getInjectionTargetFactory(type).createInjectionTarget(null); }
/** * Create an injector for the given class * @param manager the {@link BeanManager} * @param clazz class of the unmanaged instances */ public Unmanaged(BeanManager manager, Class<T> clazz) { this.beanManager = manager; AnnotatedType<T> type = manager.createAnnotatedType(clazz); this.injectionTarget = manager.getInjectionTargetFactory(type).createInjectionTarget(null); }
/** * Create an injector for the given class * @param manager the {@link BeanManager} * @param clazz class of the unmanaged instances */ public Unmanaged(BeanManager manager, Class<T> clazz) { this.beanManager = manager; AnnotatedType<T> type = manager.createAnnotatedType(clazz); this.injectionTarget = manager.getInjectionTargetFactory(type).createInjectionTarget(null); }
/** * Create an injector for the given class * @param manager the {@link BeanManager} * @param clazz class of the unmanaged instances */ public Unmanaged(BeanManager manager, Class<T> clazz) { this.beanManager = manager; AnnotatedType<T> type = manager.createAnnotatedType(clazz); this.injectionTarget = manager.getInjectionTargetFactory(type).createInjectionTarget(null); }
/** * Create an injector for the given class */ public Unmanaged(BeanManager manager, Class<T> clazz) { this.beanManager = manager; AnnotatedType<T> type = manager.createAnnotatedType(clazz); this.injectionTarget = manager.getInjectionTargetFactory(type).createInjectionTarget(null); }
/** * Create an injector for the given class * @param manager the {@link BeanManager} * @param clazz class of the unmanaged instances */ public Unmanaged(BeanManager manager, Class<T> clazz) { this.beanManager = manager; AnnotatedType<T> type = manager.createAnnotatedType(clazz); this.injectionTarget = manager.getInjectionTargetFactory(type).createInjectionTarget(null); }
private <T> InjectionTarget<T> createInjectionTarget(Class<T> klass) { AnnotatedType<T> type = beanManager.createAnnotatedType(klass); InjectionTargetFactory<T> itFactory = beanManager.getInjectionTargetFactory(type); InjectionTarget<T> it = itFactory.createInjectionTarget(null); return it; // return getWrapper(klass).wrap(it); }
void inject() { BeanManager beanManager = container.getBeanManager(); CreationalContext<Object> ctx = beanManager.createCreationalContext(null); @SuppressWarnings("unchecked") InjectionTarget<Object> injectionTarget = (InjectionTarget<Object>) beanManager .getInjectionTargetFactory(beanManager.createAnnotatedType(instance.getClass())).createInjectionTarget(null); injectionTarget.inject(instance, ctx); creationalContext = ctx; }
void inject() { BeanManager beanManager = container.getBeanManager(); CreationalContext<Object> ctx = beanManager.createCreationalContext(null); @SuppressWarnings("unchecked") InjectionTarget<Object> injectionTarget = (InjectionTarget<Object>) beanManager .getInjectionTargetFactory(beanManager.createAnnotatedType(instance.getClass())).createInjectionTarget(null); injectionTarget.inject(instance, ctx); creationalContext = ctx; }
HandlerInstance(AnnotatedType<T> annotatedType, BeanManager beanManager) { this.annotatedType = annotatedType; this.injectionTarget = beanManager.getInjectionTargetFactory(annotatedType).createInjectionTarget(null); this.creationalContext = beanManager.createCreationalContext(null); this.instance = injectionTarget.produce(creationalContext); injectionTarget.inject(instance, creationalContext); injectionTarget.postConstruct(instance); }
@Override public Bean createHelperBean(BeanManager beanManager, Class beanClass) { BeanWrapper result = null; AnnotatedType annotatedType = beanManager.createAnnotatedType( beanClass ); InjectionTargetFactory factory = beanManager.getInjectionTargetFactory(annotatedType); result = new BeanWrapper(beanClass); //use this to create the class and inject dependencies final InjectionTarget injectionTarget = factory.createInjectionTarget(result); result.setInjectionTarget(injectionTarget); return result; }
public static Bean createHelperBean(BeanManager beanManager, Class beanClass) { BeanWrapper result = null; AnnotatedType annotatedType = beanManager.createAnnotatedType(beanClass); result = new BeanWrapper(beanClass); //use this to create the class and inject dependencies InjectionTargetFactory factory = beanManager.getInjectionTargetFactory(annotatedType); final InjectionTarget injectionTarget = factory.createInjectionTarget(result); result.setInjectionTarget(injectionTarget); return result; }
HandlerInstance(AnnotatedType<T> annotatedType, BeanManager beanManager) { this.annotatedType = annotatedType; this.injectionTarget = beanManager.getInjectionTargetFactory(annotatedType).createInjectionTarget(null); this.creationalContext = beanManager.createCreationalContext(null); this.instance = injectionTarget.produce(creationalContext); injectionTarget.inject(instance, creationalContext); injectionTarget.postConstruct(instance); }