private static void doReinjectBean(BeanManagerImpl beanManager, InjectionTargetBean<?> bean) { try { if (!bean.getScope().equals(ApplicationScoped.class) && HaCdiCommons.isRegisteredScope(bean.getScope())) { doReinjectRegisteredBeanInstances(beanManager, bean); } else { doReinjectBeanInstance(beanManager, bean, beanManager.getContext(bean.getScope())); } } catch (ContextNotActiveException e) { LOGGER.info("No active contexts for bean '{}'", bean.getBeanClass().getName()); } }
@SuppressWarnings({ "unchecked", "rawtypes" }) private static void doReinjectRegisteredBeanInstances(BeanManagerImpl beanManager, InjectionTargetBean bean) { for (Object instance: HaCdiCommons.getBeanInstances(bean)) { if (instance != null) { bean.getProducer().inject(instance, beanManager.createCreationalContext(bean)); LOGGER.info("Bean '{}' injection points was reinjected.", bean.getBeanClass().getName()); } else { LOGGER.info("Unexpected 'null' bean instance in registry. bean='{}'", bean.getBeanClass().getName()); } } }
private static Interceptor<?> readInterceptor(String id, BeanManager beanManager) throws IOException { if (id.startsWith(SELF_KEY)) { Bean<?> bean = beanManager.getPassivationCapableBean(id.substring(SELF_KEY.length())); if (InjectionTargetBean.class.isInstance(bean)) { InjectionTarget<?> it = InjectionTargetBean.class.cast(bean).getInjectionTarget(); if (InjectionTargetImpl.class.isInstance(it)) { InterceptorResolutionService.BeanInterceptorInfo info = InjectionTargetImpl.class.cast(it) .getInterceptorInfo(); return info.getSelfInterceptorBean(); } else { throw new NotSerializableException("Can't find self interceptor"); } } else { throw new NotSerializableException("Can't find self interceptor"); } } return (Interceptor<?>) beanManager.getPassivationCapableBean(id); }
bean.getInjectionTarget().inject(beanInstance, creationalContext); if (shouldBeReleased(bean.getScope())) { creationalContexts.put(beanInstance, creationalContext);
@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()); }
protected AnnotatedType<?> getSuperType() { Class<?> superclass = annotatedMember.getDeclaringType().getJavaClass().getSuperclass(); if (superclass == null) { return null; } return parent.getWebBeansContext().getAnnotatedElementFactory().getAnnotatedType(superclass); }
AnnotatedType<T> beanAnnotatedType = bean.getAnnotatedType(); if(bean.isEnabled()) WebBeansContext wbc = bean.getWebBeansContext(); Set<ProducerFieldBean<?>> producerFields = new ProducerFieldBeansBuilder(wbc, beanAnnotatedType).defineProducerFields(bean); Set<ProducerMethodBean<?>> producerMethods = new ProducerMethodBeansBuilder(wbc, beanAnnotatedType).defineProducerMethods(bean, producerFields);
private static void doReloadInjectionTargetBean(BeanManagerImpl beanManager, InjectionTargetBean<?> bean, Map<String, String> oldSignatures, BeanReloadStrategy reloadStrategy) { String signatureByStrategy = OwbClassSignatureHelper.getSignatureByStrategy(reloadStrategy, bean.getBeanClass()); String oldSignature = oldSignatures.get(bean.getBeanClass().getName()); if (reloadStrategy == BeanReloadStrategy.CLASS_CHANGE || (reloadStrategy != BeanReloadStrategy.NEVER && signatureByStrategy != null && !signatureByStrategy.equals(oldSignature))) { // Reload bean in contexts - invalidates existing instances doReloadBeanInBeanContexts(beanManager, bean); } else { // keep beans in contexts, reinitialize bean injection points doReinjectBean(beanManager, bean); } }
public void defineInterceptorsIfNeeded() { if (getProducer() instanceof AbstractProducer) { AbstractProducer<T> producer = (AbstractProducer<T>)getProducer(); producer.defineInterceptorStack(this, annotatedType, webBeansContext); } }
InjectionTargetBean<T> bean = new InjectionTargetBean<T>( webBeansContext, WebBeansType.THIRDPARTY, bean.defineInterceptorsIfNeeded();
public T create(CreationalContext<T> creationalContext) { if (!(creationalContext instanceof CreationalContextImpl)) { creationalContext = webBeansContext.getCreationalContextFactory().wrappedCreationalContext(creationalContext, this); } CreationalContextImpl<T> creationalContextImpl = (CreationalContextImpl<T>)creationalContext; Bean<T> oldBean = creationalContextImpl.putBean(this); Contextual<T> oldContextual = creationalContextImpl.putContextual(this); // otherwise BeanMetaData is broken try { return super.create(creationalContext); } finally { creationalContextImpl.putBean(oldBean); creationalContextImpl.putContextual(oldContextual); } }
public Object inject(final Object o) throws OpenEJBException { try { final WebBeansContext webBeansContext = getWebBeansContext(); // Create bean instance final Context initialContext = (Context) new InitialContext().lookup("java:"); final Context unwrap = InjectionProcessor.unwrap(initialContext); final InjectionProcessor injectionProcessor = new InjectionProcessor(o, injections, unwrap); final Object beanInstance = injectionProcessor.createInstance(); if (webBeansContext != null) { final ConstructorInjectionBean<Object> beanDefinition = getConstructorInjectionBean(o.getClass(), webBeansContext); final CreationalContext<Object> creationalContext = webBeansContext.getBeanManagerImpl().createCreationalContext(beanDefinition); final InjectionTargetBean<Object> bean = InjectionTargetBean.class.cast(beanDefinition); bean.getInjectionTarget().inject(beanInstance, creationalContext); // if the bean is dependent simply cleanup the creational context once it is created final Class<? extends Annotation> scope = beanDefinition.getScope(); if (scope == null || Dependent.class.equals(scope)) { creatonalContexts.put(beanInstance, creationalContext); } } return beanInstance; } catch (final NamingException e) { throw new OpenEJBException(e); } }
@Override protected <X> P createBean(InjectionTargetBean<X> owner, Class<T> beanClass) { return (P) new ProducerFieldBean<T>(owner, beanAttributes, beanClass, new FieldProducerFactory(annotatedMember, owner, owner.getWebBeansContext())); }
/** * Create a new instance. * * @param returnType bean type info */ public AbstractProducerBean(InjectionTargetBean<?> ownerComponent, WebBeansType webBeansType, BeanAttributes<T> beanAttributes, Class<T> returnType, ProducerFactory<?> producerFactory) { super(ownerComponent.webBeansContext, webBeansType, beanAttributes, ownerComponent.getBeanClass(), !returnType.isPrimitive()); this.returnType = returnType; this.ownerComponent = ownerComponent; producer = producerFactory.createProducer(this); }
@SuppressWarnings("unchecked") public <T> void inject(final T instance, CreationalContext<T> ctx) { final WebBeansContext webBeansContext = getWebBeansContext(); if (webBeansContext == null) { return; } InjectionTargetBean<T> beanDefinition = get(CdiEjbBean.class); if (beanDefinition == null) { beanDefinition = InjectionTargetBean.class.cast(createConstructorInjectionBean(webBeansContext)); } if (!(ctx instanceof CreationalContextImpl)) { ctx = webBeansContext.getCreationalContextFactory().wrappedCreationalContext(ctx, beanDefinition); } beanDefinition.getInjectionTarget().inject(instance, ctx); }
private static void doReloadBeanInBeanContexts(BeanManagerImpl beanManager, InjectionTargetBean<?> bean) { try { Map<Class<? extends Annotation>, Context> singleContextMap = getSingleContextMap(beanManager); Context context = singleContextMap.get(bean.getScope()); if (context != null) { doReloadBeanInContext(beanManager, bean, context); } else { Map<Class<? extends Annotation>, List<Context>> allContexts = getContextMap(beanManager); List<Context> ctxList = allContexts.get(bean.getScope()); if (ctxList != null) { for(Context ctx: ctxList) { doReloadBeanInContext(beanManager, bean, ctx); } } else { LOGGER.debug("No active contexts for bean '{}' in scope '{}'", bean.getBeanClass().getName(), bean.getScope()); } } } catch (ContextNotActiveException e) { LOGGER.warning("No active contexts for bean '{}'", e, bean.getBeanClass().getName()); } catch (Exception e) { LOGGER.warning("Context for '{}' failed to reload", e, bean.getBeanClass().getName()); } }
@SuppressWarnings({ "unchecked", "rawtypes" }) private static void doReinjectBeanInstance(BeanManagerImpl beanManager, InjectionTargetBean bean, Context context) { Object instance = context.get(bean); if (instance != null) { bean.getProducer().inject(instance, beanManager.createCreationalContext(bean)); LOGGER.info("Bean '{}' injection points was reinjected.", bean.getBeanClass().getName()); } }
@Override protected <P> ProducerMethodBean<T> createBean(InjectionTargetBean<P> parent, Class<T> beanClass) { AnnotatedMethod<P> annotatedMethod = (AnnotatedMethod<P>) annotatedMember; ProducerMethodBean<T> producerMethodBean = new ProducerMethodBean<>(parent, beanAttributes, beanClass, new MethodProducerFactory<>(annotatedMethod, parent, parent.getWebBeansContext())); return producerMethodBean; }
@Override protected String providedId() { return webBeansContext.getBeanManagerImpl().getId(Class.class.cast(getBeanClass()), annotatedType); }
@SuppressWarnings("unchecked") public <T> void inject(final T instance, CreationalContext<T> ctx) { final WebBeansContext webBeansContext = getWebBeansContext(); if (webBeansContext == null) { return; } InjectionTargetBean<T> beanDefinition = get(CdiEjbBean.class); if (beanDefinition == null) { beanDefinition = InjectionTargetBean.class.cast(createConstructorInjectionBean(webBeansContext)); } if (!(ctx instanceof CreationalContextImpl)) { ctx = webBeansContext.getCreationalContextFactory().wrappedCreationalContext(ctx, beanDefinition); } beanDefinition.getInjectionTarget().inject(instance, ctx); }