/** * Initializes the bean and its metadata */ @Override public void internalInitialize(BeanDeployerEnvironment environment) { getDeclaringBean().initialize(environment); super.internalInitialize(environment); initPassivationCapable(); }
private boolean isInjectedIntoDisposer(Bean<?> bean, Collection<Bean<?>> beans) { for (Bean<?> producerCandidate : beans) { if (producerCandidate instanceof AbstractProducerBean) { AbstractProducerBean<?, ?, ?> producerBean = cast(producerCandidate); if (producerBean.getProducer() instanceof AbstractMemberProducer<?, ?>) { AbstractMemberProducer<?, ?> producer = Reflections.<AbstractMemberProducer<?, ?>> cast(producerBean.getProducer()); if (producer.getDisposalMethod() != null) { BeanManager beanManager = getBeanManager(bean); for (InjectionPoint injectionPoint : producer.getDisposalMethod().getInjectionPoints()) { if (bean.equals(beanManager.resolve(beanManager.getBeans(injectionPoint.getType(), injectionPoint.getQualifiers().toArray(new Annotation[injectionPoint.getQualifiers().size()]))))) { return true; } } } } } } return false; }
/** * Creates an instance of the bean * * @returns The instance */ public T create(final CreationalContext<T> creationalContext) { T instance = getProducer().produce(creationalContext); instance = checkReturnValue(instance); return instance; }
@Override protected void checkType() { if (beanManager.isPassivatingScope(getScope()) && !isPassivationCapableBean()) { throw BeanLogger.LOG.passivatingBeanNeedsSerializableImpl(this); } }
if (instance == null && !isDependent()) { throw BeanLogger.LOG.nullNotAllowedFromProducer(getProducer(), Formats.formatAsStackTraceElement(getAnnotated().getJavaMember())); InjectionPoint injectionPoint = beanManager.getServices().get(CurrentInjectionPoint.class).peek(); if (injectionPoint != null) { Class<?> injectionPointRawType = Reflections.getRawType(injectionPoint.getType()); if (injectionPointRawType.isPrimitive()) { return cast(Defaults.getJlsDefaultValue(injectionPointRawType)); if (beanManager.isPassivatingScope(getScope())) { throw BeanLogger.LOG.nonSerializableProductError(getProducer(), Formats.formatAsStackTraceElement(getAnnotated().getJavaMember())); InjectionPoint injectionPoint = beanManager.getServices().get(CurrentInjectionPoint.class).peek(); if (injectionPoint != null && injectionPoint.getBean() != null && Beans.isPassivatingScope(injectionPoint.getBean(), beanManager)) { if (!(injectionPoint.getMember() instanceof Field) || !injectionPoint.isTransient()) { throw BeanLogger.LOG.unserializableProductInjectionError(this, Formats.formatAsStackTraceElement(getAnnotated().getJavaMember()), injectionPoint, Formats.formatAsStackTraceElement(injectionPoint.getMember()));
private void removeUnusedBeans() { String excludeTypeProperty = getServices().get(WeldConfiguration.class).getStringProperty(ConfigurationKey.UNUSED_BEANS_EXCLUDE_TYPE); String excludeAnnotationProperty = getServices().get(WeldConfiguration.class).getStringProperty(ConfigurationKey.UNUSED_BEANS_EXCLUDE_ANNOTATION); Validator validator = getServices().get(Validator.class); if (bean instanceof AbstractProducerBean) { AbstractProducerBean<?, ?, ?> producer = (AbstractProducerBean<?, ?, ?>) bean; beanToDeclaredProducers.put(producer.getDeclaringBean(), producer); if (bean.getName() != null) { continue; if (excludeType != null && excludeType.matcher(bean.getBeanClass().getName()).matches()) { continue;
for (InjectionPoint injectionPoint : bean.getInjectionPoints()) { if (!injectionPoint.isDelegate()) { dependencyPath.add(injectionPoint); validatePseudoScopedInjectionPoint(injectionPoint, beanManager, dependencyPath, validatedBeans); final List<Decorator<?>> decorators = Reflections.<DecorableBean<?>>cast(bean).getDecorators(); if (!decorators.isEmpty()) { for (final Decorator<?> decorator : decorators) { if (!beanManager.isNormalScope(producer.getDeclaringBean().getScope()) && !producer.getAnnotated().isStatic()) { reallyValidatePseudoScopedBean(producer.getDeclaringBean(), beanManager, dependencyPath, validatedBeans);
private void addBean(Bean<?> bean, List<Bean<?>> beanList, List<Bean<?>> transitiveBeans) { if (beanSet.add(bean)) { if (bean.isAlternative() && (!registry.isEnabledInAnyBeanDeployment(bean) && !(bean instanceof Prioritized)) && !isConfiguratorBeanWithPriority(bean)) { BootstrapLogger.LOG.foundDisabledAlternative(bean); } else if (registry.isSpecializedInAnyBeanDeployment(bean)) { BootstrapLogger.LOG.foundSpecializedBean(bean); } else if (bean instanceof AbstractProducerBean<?, ?, ?> && registry.isSpecializedInAnyBeanDeployment(((AbstractProducerBean<?, ?, ?>) bean).getDeclaringBean())) { BootstrapLogger.LOG.foundProducerOfSpecializedBean(bean); specializedBeans.add(bean); } else { BootstrapLogger.LOG.foundBean(bean); beanList.add(bean); if (bean instanceof SessionBean) { SessionBean<?> enterpriseBean = (SessionBean<?>) bean; enterpriseBeans.put(enterpriseBean.getEjbDescriptor(), enterpriseBean); } if (bean instanceof PassivationCapable) { getServices().get(ContextualStore.class).putIfAbsent(bean); } registerBeanNamespace(bean); // New beans (except for SessionBeans) and most built in beans aren't resolvable transitively if (bean instanceof ExtensionBean || bean instanceof SessionBean || (!(bean instanceof NewBean) && !(bean instanceof AbstractBuiltInBean<?>))) { transitiveBeans.add(bean); } } } }
ContextualStore contextualStore = beanManager.getServices().get(ContextualStore.class); bdaToManager.putAll(Container.instance(beanManager).beanDeploymentArchives()); for (Bean<?> bean : manager.getBeans()) { if (manager.isBeanEnabled(bean)) { && candidate instanceof AbstractProducerBean) { AbstractProducerBean<?, ?, ?> producerBean = (AbstractProducerBean<?, ?, ?>) candidate; beanToDeclaredProducers.put(producerBean.getDeclaringBean(), producerBean);
public AnnotatedParameter<T> getAnnotatedDisposedParameter() { checkWithinObserverNotification(); if (getBean().getProducer() instanceof AbstractMemberProducer<?, ?>) { AbstractMemberProducer<?, ?> producer = (AbstractMemberProducer<?, ?>) getBean().getProducer(); if (producer.getDisposalMethod() != null) { return cast(producer.getDisposalMethod().getDisposesParameter()); } } return null; } }
protected static <T, X> void fire(BeanManagerImpl beanManager, AbstractProducerBean<T, X, Member> bean) { if (beanManager.isBeanEnabled(bean)) { new ProcessProducerImpl<T, X>(beanManager, Reflections.<AnnotatedMember<T>> cast(bean.getAnnotated()), bean) { }.fire(); } }
private void initPassivationCapable() { this.passivationCapableBean = !Reflections.isFinal(getEnhancedAnnotated().getJavaClass()) || Reflections.isSerializable(getEnhancedAnnotated().getJavaClass()); if (isNormalScoped()) { this.passivationCapableDependency = true; } else if (getScope().equals(Dependent.class) && passivationCapableBean) { this.passivationCapableDependency = true; } else { this.passivationCapableDependency = false; } }
AbstractClassBean<?> classBean = (AbstractClassBean<?>) bean; if (classBean.hasInterceptors()) { validateInterceptors(beanManager, classBean); AbstractProducerBean<?, ?, ?> producerBean = Reflections.<AbstractProducerBean<?, ?, ?>> cast(bean); if (producerBean.getProducer() instanceof AbstractMemberProducer<?, ?>) { AbstractMemberProducer<?, ?> producer = Reflections.<AbstractMemberProducer<?, ?>> cast(producerBean .getProducer()); if (producer.getDisposalMethod() != null) { for (InjectionPoint ip : producer.getDisposalMethod().getInjectionPoints()) {
public boolean isCandidateForLifecycleEvent(Bean<?> bean) { if (bean instanceof AbstractProducerBean<?, ?, ?>) { AbstractProducerBean<?, ?, ?> producer = cast(bean); if (!isCandidateForLifecycleEvent(producer.getDeclaringBean())) { return false; } } return isEnabledInAnyBeanDeployment(bean) && !isSpecializedInAnyBeanDeployment(bean); }
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(); } } }
private boolean hasDecorators() { if (getBean() instanceof AbstractClassBean) { return ((AbstractClassBean<?>) getBean()).hasDecorators(); } if (getBean() instanceof AbstractProducerBean) { return ((AbstractProducerBean<?, ?, ?>) getBean()).getDeclaringBean().hasDecorators(); } return false; } }
/** * Initializes the type */ protected void initType() { try { this.type = getEnhancedAnnotated().getJavaClass(); } catch (ClassCastException e) { Type type = Beans.getDeclaredBeanType(getClass()); throw BeanLogger.LOG.producerCastError(getEnhancedAnnotated().getJavaClass(), (type == null ? " unknown " : type), e); } }
@Override // Overridden to provide the class of the bean that declares the producer // method/field public Class<?> getBeanClass() { return getDeclaringBean().getBeanClass(); }
private boolean hasExcludeAnnotation(Bean<?> bean, Pattern excludeAnnotation) { if (bean instanceof AbstractClassBean) { return hasExcludeAnnotation((AbstractClassBean<?>) bean, excludeAnnotation); } else if (bean instanceof AbstractProducerBean) { return hasExcludeAnnotation(((AbstractProducerBean<?, ?, ?>) bean).getDeclaringBean(), excludeAnnotation); } return false; }
public Annotated getAnnotated() { checkWithinObserverNotification(); return bean.getAnnotated(); }