/** * 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 InjectionTarget<T> injectionTarget = injectionTargetFactory.createInjectionTarget(null);
@SuppressWarnings({ "rawtypes", "unchecked" }) private static void createAnnotatedTypeForExistingBeanClass(BeanManagerImpl beanManager, InjectionTargetBean bean) { WebBeansContext wbc = beanManager.getWebBeansContext(); AnnotatedElementFactory annotatedElementFactory = wbc.getAnnotatedElementFactory(); // Clear AnnotatedElementFactory caches annotatedElementFactory.clear(); AnnotatedType annotatedType = annotatedElementFactory.newAnnotatedType(bean.getBeanClass()); ReflectionHelper.set(bean, InjectionTargetBean.class, "annotatedType", annotatedType); // Updated members that were set by bean attributes BeanAttributesImpl attributes = BeanAttributesBuilder.forContext(wbc).newBeanAttibutes(annotatedType).build(); ReflectionHelper.set(bean, BeanAttributesImpl.class, "types", attributes.getTypes()); ReflectionHelper.set(bean, BeanAttributesImpl.class, "qualifiers", attributes.getQualifiers()); ReflectionHelper.set(bean, BeanAttributesImpl.class, "scope", attributes.getScope()); ReflectionHelper.set(bean, BeanAttributesImpl.class, "name", attributes.getName()); ReflectionHelper.set(bean, BeanAttributesImpl.class, "stereotypes", attributes.getStereotypes()); ReflectionHelper.set(bean, BeanAttributesImpl.class, "alternative", attributes.isAlternative()); InjectionTargetFactory factory = new InjectionTargetFactoryImpl(annotatedType, bean.getWebBeansContext()); InjectionTarget injectionTarget = factory.createInjectionTarget(bean); ReflectionHelper.set(bean, InjectionTargetBean.class, "injectionTarget", injectionTarget); LOGGER.debug("New annotated type created for bean '{}'", bean.getBeanClass()); }
public SyntheticClassBean(BeanAttributes<T> attributes, Class<T> beanClass, InjectionTargetFactory<T> factory, BeanManagerImpl manager) { super(attributes, manager, beanClass); this.producer = factory.createInjectionTarget(this); }
public SyntheticClassBean(BeanAttributes<T> attributes, Class<T> beanClass, InjectionTargetFactory<T> factory, BeanManagerImpl manager) { super(attributes, manager, beanClass); this.producer = factory.createInjectionTarget(this); }
/** * 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); }
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); }
/** * 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); }
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; }
@Inject public IoCForFramework(BeanManager bm) { nocc = bm.createCreationalContext(null); InjectionTargetFactory<NotOurClass> itf = bm.getInjectionTargetFactory(bm.createAnnotatedType(NotOurClass.class)); itf.configure().filterMethods(m -> m.getJavaMember().getName().equals("setService")).findFirst().get().add(InjectLiteral.INSTANCE); it = itf.createInjectionTarget(null); // invoking configure() after create method should throw exception try { itf.configure().filterMethods(m -> m.getJavaMember().getName().equals("setService")).findFirst().get().add(InjectLiteral.INSTANCE); } catch (IllegalStateException e) { //expected behaviour exceptionThrown = true; } }
@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; }
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); }
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); }