/** * {@inheritDoc} */ @Override public Set<InjectionPoint> getInjectionPoints() { return getProducer().getInjectionPoints(); }
@Override public boolean isDependent() { return getScope().equals(Dependent.class); }
public String getId() if (!isEnabled() || getReturnType().equals(Object.class)) String providedId = providedId(); if (providedId != null) sb.append(getReturnType()).append('#'); for (Annotation qualifier : getQualifiers())
if (!ownerBean.isEnabled()) BeanManagerImpl manager = ownerBean.getWebBeansContext().getBeanManagerImpl(); CreationalContextImpl<Object> creationalContext = manager.createCreationalContext(component); if (metadata != null) try context = manager.getContext(component.getScope()); Type t = component.getBeanClass(); if (component.getWebBeansType() == WebBeansType.ENTERPRISE) t = (Type) component.getTypes().toArray()[0]; ownerBean.getWebBeansContext().getSecurityService().doPrivilegedSetAccessible(view, true); creationalContext.removeInjectionPoint(); if (component.getScope().equals(Dependent.class) && object != null) component.destroy(object, creationalContext);
String simpleName = getReturnType().getSimpleName(); builder.append(simpleName); builder.append(", WebBeansType:").append(getWebBeansType()).append(", Name:").append(getName()); builder.append(", API Types:["); int size = getTypes().size(); int index = 1; for(Type clazz : getTypes()) builder.append("Qualifiers:["); size = getQualifiers().size(); index = 1; for(Annotation ann : getQualifiers()) addToStringInfo(builder);
@Override public void destroy(T instance, CreationalContext<T> creationalContext) { if (getScope().equals(Dependent.class) && creationalContext instanceof CreationalContextImpl && ((CreationalContextImpl<T>)creationalContext).containsDependent(this, instance)) { // we just have to call release, because release will destroy us since we are @Dependent creationalContext.release(); return; } try { Producer<T> producer = getProducer(); if (producer instanceof InjectionTarget) { InjectionTarget<T> injectionTarget = (InjectionTarget<T>)producer; injectionTarget.preDestroy(instance); } producer.dispose(instance); //Destroy dependent instances creationalContext.release(); } catch(Exception e) { getLogger().log(Level.SEVERE, WebBeansLoggerFacade.constructMessage(OWBLogConst.FATAL_0001, this), e); } }
final AbstractOwbBean<?> aob = AbstractOwbBean.class.cast(bean); final Producer producer = aob.getProducer(); implementor = producer.produce(creationalContext); if (producer instanceof InjectionTarget) { if (aob.getScope().equals(Dependent.class)) { creationalContext.addDependent(aob, instance);
Producer<T> producer = getProducer(); T instance = producer.produce(creationalContext); if (producer instanceof InjectionTarget && instance != null) // @AroundConstruct can skip proceed and then it returns null injectionTarget.postConstruct(instance); if (getScope().equals(Dependent.class) && instance != null) Throwable throwable = getRootException(re);
@Override public boolean isPassivationCapable() { if (isPassivationCapable != null) { return isPassivationCapable; } if(Serializable.class.isAssignableFrom(getReturnType())) { isPassivationCapable = Boolean.TRUE; return true; } isPassivationCapable = Boolean.FALSE; return false; }
if( ((AbstractOwbBean<?>)contextual).isPassivationCapable()) return ((AbstractOwbBean<?>)contextual).getId();
for (Annotation annotation: annotatedObservesParameter.getAnnotations()) if (ownerBean.getWebBeansContext().getAnnotationManager().isQualifierAnnotation(annotation.annotationType())) if (ejbPlugin != null && ejbPlugin.isNewSessionBean(ownerBean.getBeanClass()))
/** * Returns observer owner bean. * * @return the bean */ @Override @SuppressWarnings("unchecked") public Class<?> getBeanClass() { return ownerBean.getBeanClass(); }
public ProducerAwareInjectionTargetBean(WebBeansContext webBeansContext, WebBeansType webBeansType, BeanAttributes<T> beanAttributes, Class<?> beanClass, boolean nullable, ProducerFactory<?> factory) { super(webBeansContext, webBeansType, beanAttributes, beanClass, nullable); this.producer = factory.createProducer(this); String id = super.getId(); if (id != null) { passivatingId = "ProvidedProducer" + id + ",factory=" + factory.hashCode(); } }
/** * {@inheritDoc} */ public Set<ObserverMethod<?>> defineObserverMethods(AbstractOwbBean<T> ownerBean) { Set<ObserverMethod<?>> definedObservers = new HashSet<>(); for (AnnotatedMethod<?> annotatedMethod : webBeansContext.getAnnotatedElementFactory().getFilteredAnnotatedMethods(annotatedType)) { ObserverMethod<?> observerMethod = defineObserverMethod(ownerBean, annotatedMethod); if (observerMethod != null) { definedObservers.add(observerMethod); } } if (!definedObservers.isEmpty()) { for (InjectionPoint ip : ownerBean.getInjectionPoints()) { Set<Annotation> qualifiers = ip.getQualifiers(); if (EventMetadata.class == ip.getType() && qualifiers != null && ip.getQualifiers().size() == 1 && Default.class == qualifiers.iterator().next().annotationType()) { throw new WebBeansConfigurationException(ip + " is not an observer parameter"); } } } return definedObservers; }
final AbstractOwbBean<?> aob = AbstractOwbBean.class.cast(bean); final Producer producer = aob.getProducer(); implementor = producer.produce(creationalContext); if (producer instanceof InjectionTarget) { if (aob.getScope().equals(Dependent.class)) { creationalContext.addDependent(aob, instance);
public void validateBeanInjection(Bean<?> bean) { for (InjectionPoint injectionPoint : bean.getInjectionPoints()) { Type type = injectionPoint.getType(); if (type instanceof ParameterizedType) { Bean injectionPointBean = injectionPoint.getBean(); ParameterizedType pt = (ParameterizedType) type; if (pt.getRawType() == Bean.class) { Class<?> beanClass = AbstractOwbBean.class.isInstance(injectionPointBean) ? AbstractOwbBean.class.cast(injectionPointBean).getReturnType() : injectionPointBean.getBeanClass(); Type beanType = pt.getActualTypeArguments()[0]; if (!GenericsUtil.isAssignableFrom(false, AbstractProducerBean.class.isInstance(bean), beanClass, beanType)) { throw new WebBeansConfigurationException("@Inject Bean<X> can only be done in X, found " + beanType + " and " + beanClass); } } } } }
/** * Gets type of the producer method/field or the bean class if it's not a producer. * This basically determines the class which will get created. * * @return type of the producer method * @see #getBeanClass() */ @Override public Class<T> getReturnType() { return (Class<T>) getBeanClass(); }
if (bean != null && bean.getScope().equals(Dependent.class))
@Override public T create(final CreationalContext<T> context) { if (isAnotherApp(context) && isContainerScope()) {// in another app context, lookup the container instance to share the same one in sub apps return (T) wbc.getBeanManagerImpl().getReference( delegate, AbstractOwbBean.class.isInstance(delegate) ? AbstractOwbBean.class.cast(delegate).getReturnType() : getBeanClass(), context); } return delegate.create(context); }
+ component.getReturnType().getName() + " may not define @Named annotation");