private static void doReinjectBean(BeanManagerImpl beanManager, AbstractClassBean<?> bean) { try { if (!bean.getScope().equals(ApplicationScoped.class) && HaCdiCommons.isRegisteredScope(bean.getScope())) { doReinjectRegisteredBeanInstances(beanManager, bean); } else { doReinjectBeanInstance(beanManager, bean, beanManager.getContext(bean.getScope())); } } catch (Exception e) { if (e.getClass().getSimpleName().equals("ContextNotActiveException")) { LOGGER.info("No active contexts for bean '{}'", bean.getBeanClass().getName()); } else { throw e; } } }
@SuppressWarnings("unchecked") private static void doCallInject(BeanManagerImpl beanManager, AbstractClassBean bean, Object instance) { // In whatever reason, we have to use reflection call for beanManager.createCreationalContext() in weld>=3.0 Method m = null; try { m = beanManager.getClass().getMethod("createCreationalContext", Contextual.class); } catch (Exception e) { LOGGER.error("BeanManager.createCreationalContext() method not found beanManagerClass='{}'", e, bean.getBeanClass().getName()); return; } try { bean.getProducer().inject(instance, (CreationalContext) m.invoke(beanManager, bean)); LOGGER.debug("Bean instance '{}' injection points was reinjected.", instance); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { LOGGER.error("beanManager.createCreationalContext(beanManager, bean) invocation failed beanManagerClass='{}', beanClass='{}'", e, bean.getBeanClass().getName(), bean.getClass().getName()); } }
Set<Bean<?>> beans = beanManager.getBeans(beanClass, new AnnotationLiteral<Any>() {}); if (bean.getBeanClass().isInterface()) { continue; LOGGER.debug("Skipping bean redefinition. Bean '{}' signature was not changed.", bean.getBeanClass().getName()); continue; if (!eat.isAbstract() || !eat.getJavaClass().isInterface()) { // injectionTargetCannotBeCreatedForInterface ((AbstractClassBean)bean).setProducer(beanManager.getLocalInjectionTargetFactory(eat).createInjectionTarget(eat, bean, false)); if (isReinjectingContext(bean)) { doReloadAbstractClassBean(beanManager, (AbstractClassBean) bean, oldSignatures, reloadStrategy); LOGGER.debug("Bean reloaded '{}'", bean.getBeanClass().getName()); continue;
private void validateInterceptors(BeanManagerImpl beanManager, AbstractClassBean<?> classBean) { InterceptionModel interceptionModel = beanManager.getInterceptorModelRegistry().get(classBean.getAnnotated()); if (interceptionModel != null) { Set<? extends InterceptorClassMetadata<?>> interceptors = interceptionModel.getAllInterceptors(); if (interceptors.size() > 0) { boolean passivationCapabilityCheckRequired = beanManager.isPassivatingScope(classBean.getScope()); for (InterceptorClassMetadata<?> interceptorMetadata : interceptors) { throw ValidatorLogger.LOG.passivatingBeanWithNonserializableInterceptor(classBean, interceptor); Bean<?> resolvedBean = beanManager.resolve(beanManager.getBeans(injectionPoint)); validateInterceptorDecoratorInjectionPointPassivationCapable(injectionPoint, resolvedBean, beanManager, classBean); PlainInterceptorFactory<?> factory = (PlainInterceptorFactory<?>) interceptorMetadata.getInterceptorFactory(); Class<?> interceptorClass = interceptorMetadata.getJavaClass(); if (passivationCapabilityCheckRequired && !Reflections.isSerializable(interceptorClass)) { throw ValidatorLogger.LOG.passivatingBeanWithNonserializableInterceptor(this, interceptorClass.getName()); validateInjectionPoint(injectionPoint, beanManager); if (passivationCapabilityCheckRequired) { Bean<?> resolvedBean = beanManager.resolve(beanManager.getBeans(injectionPoint)); validateInterceptorDecoratorInjectionPointPassivationCapable(injectionPoint, resolvedBean, beanManager, classBean);
JsonObjectBuilder beanBuilder = createBasicBeanJson(bean, probe); if (bean.getName() != null) { beanBuilder.add(NAME, bean.getName()); if (bean.getStereotypes() != null && !bean.getStereotypes().isEmpty()) { JsonArrayBuilder stereotypesBuilder = Json.arrayBuilder(); for (Class<?> stereotype : Components.getSortedProbeComponetCandidates(bean.getStereotypes())) { if (producerBean.getDeclaringBean() != null) { beanBuilder.add(DECLARING_BEAN, createSimpleBeanJson(producerBean.getDeclaringBean(), probe)); if (producerBean.getProducer() instanceof ProducerMethodProducer) { ProducerMethodProducer<?, ?> producer = (ProducerMethodProducer<?, ?>) producerBean.getProducer(); if (producer.getDisposalMethod() != null) { if (BeanKind.INTERCEPTOR.equals(kind) || BeanKind.DECORATOR.equals(kind) || bean.isAlternative()) { JsonObjectBuilder enablementBuilder = Json.objectBuilder(); AnnotationApiAbstraction annotationApi = beanManager.getServices().get(AnnotationApiAbstraction.class); Object priority = bean.getBeanClass().getAnnotation(annotationApi.PRIORITY_ANNOTATION_CLASS); if (priority != null) { InterceptionModel interceptionModel = abstractClassBean.getInterceptors(); List<Decorator<?>> decorators = abstractClassBean.getDecorators(); if (!decorators.isEmpty()) { JsonArrayBuilder decoratorsBuilder = Json.arrayBuilder();
private static Set<Bean<?>> findDecoratedBeans(Decorator<?> decorator, BeanManagerImpl beanManager, Probe probe) { Set<Bean<?>> beans = new HashSet<Bean<?>>(); for (Bean<?> bean : probe.getBeans()) { List<?> decorators; if (bean instanceof AbstractClassBean) { decorators = ((AbstractClassBean<?>) bean).getDecorators(); } else { decorators = beanManager.resolveDecorators(bean.getTypes(), bean.getQualifiers()); } if (decorators.contains(decorator)) { beans.add(bean); } } return beans; }
throw ValidatorLogger.LOG.pseudoScopedBeanHasCircularReferences(WeldCollections.toMultiRowString(realDependencyPath)); for (InjectionPoint injectionPoint : bean.getInjectionPoints()) { if (!injectionPoint.isDelegate()) { dependencyPath.add(injectionPoint); validatePseudoScopedInjectionPoint(injectionPoint, beanManager, dependencyPath, validatedBeans); dependencyPath.remove(injectionPoint); final List<Decorator<?>> decorators = Reflections.<DecorableBean<?>>cast(bean).getDecorators(); if (!decorators.isEmpty()) { for (final Decorator<?> decorator : decorators) { reallyValidatePseudoScopedBean(decorator, beanManager, dependencyPath, validatedBeans); if (!beanManager.isNormalScope(producer.getDeclaringBean().getScope()) && !producer.getAnnotated().isStatic()) { reallyValidatePseudoScopedBean(producer.getDeclaringBean(), beanManager, dependencyPath, validatedBeans);
protected ResourceInjection<T> getResourceInjection(EnhancedAnnotatedField<T, ? super X> field, AbstractClassBean<X> declaringBean, BeanManagerImpl manager) { FieldInjectionPoint<T, X> injectionPoint = cast(InjectionPointFactory.silentInstance().createFieldInjectionPoint(field, declaringBean, declaringBean.getBeanClass(), manager)); return manager.getServices().get(ResourceInjectionFactory.class).getStaticProducerFieldResourceInjection(injectionPoint, beanManager); }
public static WeldEEInjection createWeldEEInjection(Class<?> componentClass, Bean<?> bean, final BeanManagerImpl beanManager) { final AnnotatedType<?> type = beanManager.getServices().get(ClassTransformer.class).loadClass(componentClass); List<InjectableField> injectableFields = new ArrayList<InjectableField>(); List<InjectableMethod> injectableMethods = new ArrayList<InjectableMethod>(); injectionTarget = ((AbstractClassBean) bean).getInjectionTarget(); } else { injectionTarget = null; if (beanManager.isQualifier(annotation.annotationType())) { qualifiers.add(annotation); Set<Bean<?>> beans = beanManager.getBeans(ip); Bean<?> ipBean = beanManager.resolve(beans); if (ipBean == null) {
@Override // Overridden to provide the class of the bean that declares the producer // method/field public Class<?> getBeanClass() { return getDeclaringBean().getBeanClass(); }
protected StaticEEResourceProducerField(BeanAttributes<T> attributes, EnhancedAnnotatedField<T, ? super X> field, AbstractClassBean<X> declaringBean, DisposalMethod<X, ?> disposalMethod, BeanManagerImpl manager, ServiceRegistry services) { super(attributes, field, declaringBean, disposalMethod, manager, services); this.resourceInjection = getResourceInjection(field, declaringBean, manager); this.accessibleField = AccessController.doPrivileged(new GetAccessibleCopyOfMember<Field>(field.getJavaMember())); this.injectionContext = new InjectionContextImpl<X>(manager, declaringBean.getInjectionTarget(), declaringBean.getAnnotated(), null) { @Override public void proceed() { } }; }
protected ResourceInjection<T> getResourceInjection(EnhancedAnnotatedField<T, ? super X> field, AbstractClassBean<X> declaringBean, BeanManagerImpl manager) { FieldInjectionPoint<T, X> injectionPoint = cast(InjectionPointFactory.silentInstance().createFieldInjectionPoint(field, declaringBean, declaringBean.getBeanClass(), manager)); return ResourceInjectionFactory.instance().getStaticProducerFieldResourceInjection(injectionPoint, beanManager); }
/** * Duplicate of {@link #getProducer()} - kept for backwards compatibility. */ public InjectionTarget<T> getInjectionTarget() { return getProducer(); }
@Override public void setProducer(InjectionTarget<T> producer) { super.setProducer(producer); this.hasPostConstructCallback = initHasPostConstructCallback(producer); }
@Override public void initializeAfterBeanDiscovery() { super.initializeAfterBeanDiscovery(); this.proxyInstantiator = new SessionBeanProxyInstantiator<T>(enhancedAnnotatedItem, this); registerInterceptors(); }
@Override public void internalInitialize(BeanDeployerEnvironment environment) { super.internalInitialize(environment); initPassivationCapable(); }
@Override public void destroy(T instance, CreationalContext<T> creationalContext) { super.destroy(instance, creationalContext); if (instance == null) { throw BeanLogger.LOG.cannotDestroyNullBean(this); } if (!(instance instanceof EnterpriseBeanInstance)) { throw BeanLogger.LOG.cannotDestroyEnterpriseBeanNotCreated(instance); } EnterpriseBeanInstance enterpriseBeanInstance = (EnterpriseBeanInstance) instance; enterpriseBeanInstance.destroy(Marker.INSTANCE, this, creationalContext); creationalContext.release(); }
public boolean hasInterceptors() { return getInterceptors() != null; }
public boolean hasDecorators() { return !getDecorators().isEmpty(); }
private static void doReloadAbstractClassBean(BeanManagerImpl beanManager, AbstractClassBean<?> bean, Map<String, String> oldSignatures, BeanReloadStrategy reloadStrategy) { String signatureByStrategy = WeldClassSignatureHelper.getSignatureByStrategy(reloadStrategy, bean.getBeanClass()); String oldSignature = oldSignatures.get(bean.getBeanClass().getName()); if (bean instanceof ManagedBean && ( reloadStrategy == BeanReloadStrategy.CLASS_CHANGE || (reloadStrategy != BeanReloadStrategy.NEVER && signatureByStrategy != null && !signatureByStrategy.equals(oldSignature))) ) { // Reload bean in contexts - invalidates existing instances doReloadBeanInBeanContexts(beanManager, (ManagedBean<?>) bean); } else { // Reinjects bean instances in aproperiate contexts doReinjectBean(beanManager, bean); } }