}
public <T> ManagedBean<T> defineManagedBean(ManagedBeanCreatorImpl<T> managedBeanCreator, ProcessInjectionTarget<T> processInjectionTargetEvent, boolean allowLazyInit)
{
BeanManagerImpl manager = webBeansContext.getBeanManagerImpl();
//Annotated type
AnnotatedType<T> annotatedType = processInjectionTargetEvent.getAnnotatedType();
ManagedBean<T> managedBean = managedBeanCreator.getBean();
Class<T> clazz = annotatedType.getJavaClass();
managedBeanCreator.defineApiType();
//Define meta-data
managedBeanCreator.defineStereoTypes();
//Scope type
managedBeanCreator.defineScopeType(WebBeansLoggerFacade.getTokenString(OWBLogConst.TEXT_MB_IMPL) + clazz.getName() +
WebBeansLoggerFacade.getTokenString(OWBLogConst.TEXT_SAME_SCOPE), allowLazyInit);
managedBeanCreator.defineSerializable();
//Check for Enabled via Alternative
setInjectionTargetBeanEnableFlag(managedBean);
managedBeanCreator.checkCreateConditions();
managedBeanCreator.defineQualifier();
managedBeanCreator.defineName(WebBeansUtil.getManagedBeanDefaultName(clazz.getSimpleName()));
if (managedBean.isFullInit())
{
managedBeanCreator.defineConstructor();
Set<ProducerMethodBean<?>> producerMethods = managedBeanCreator.defineProducerMethods();
Set<ProducerFieldBean<?>> producerFields = managedBeanCreator.defineProducerFields();
managedBeanCreator.defineInjectedFields();
managedBeanCreator.defineInjectedMethods();
Set<ObserverMethod<?>> observerMethods = new HashSet<ObserverMethod<?>>();
if(managedBean.isEnabled())
{
observerMethods = managedBeanCreator.defineObserverMethods();
}
//Put final InjectionTarget instance
manager.putInjectionTargetWrapper(managedBean,
new InjectionTargetWrapper(processInjectionTargetEvent.getInjectionTarget()));
Map<ProducerMethodBean<?>,AnnotatedMethod<?>> annotatedMethods =
new HashMap<ProducerMethodBean<?>, AnnotatedMethod<?>>();
for(ProducerMethodBean<?> producerMethod : producerMethods)
{
AnnotatedMethod<?> method = webBeansContext.getAnnotatedElementFactory().newAnnotatedMethod(producerMethod.getCreatorMethod(),
annotatedType);
ProcessProducerImpl<?, ?> producerEvent = fireProcessProducerEventForMethod(producerMethod,
method);
inspectErrorStack("There are errors that are added by ProcessProducer event observers for "
+ "ProducerMethods. Look at logs for further details");
annotatedMethods.put(producerMethod, method);
manager.putInjectionTargetWrapper(producerMethod, new InjectionTargetWrapper(producerEvent.getProducer()));
}
Map<ProducerFieldBean<?>,AnnotatedField<?>> annotatedFields =
new HashMap<ProducerFieldBean<?>, AnnotatedField<?>>();
for(ProducerFieldBean<?> producerField : producerFields)
{
AnnotatedField<?> field = webBeansContext.getAnnotatedElementFactory().newAnnotatedField(producerField.getCreatorField(),
annotatedType);
ProcessProducerImpl<?, ?> producerEvent = fireProcessProducerEventForField(producerField,
field);
inspectErrorStack("There are errors that are added by ProcessProducer event observers for"
+ " ProducerFields. Look at logs for further details");
annotatedFields.put(producerField, field);
manager.putInjectionTargetWrapper(producerField, new InjectionTargetWrapper(producerEvent.getProducer()));
}
Map<ObserverMethod<?>,AnnotatedMethod<?>> observerMethodsMap =
new HashMap<ObserverMethod<?>, AnnotatedMethod<?>>();
for(ObserverMethod<?> observerMethod : observerMethods)
{
ObserverMethodImpl<?> impl = (ObserverMethodImpl<?>)observerMethod;
AnnotatedMethod<?> method = webBeansContext.getAnnotatedElementFactory().newAnnotatedMethod(impl.getObserverMethod(),
annotatedType);
observerMethodsMap.put(observerMethod, method);
}
BeanManagerImpl beanManager = webBeansContext.getBeanManagerImpl();
//Fires ProcessManagedBean
ProcessBeanImpl<T> processBeanEvent = new GProcessManagedBean(managedBean, annotatedType);
beanManager.fireEvent(processBeanEvent);
inspectErrorStack("There are errors that are added by ProcessManagedBean event observers for " +
"managed beans. Look at logs for further details");
//Fires ProcessProducerMethod
fireProcessProducerMethodBeanEvent(annotatedMethods, annotatedType);
inspectErrorStack("There are errors that are added by ProcessProducerMethod event observers for " +
"producer method beans. Look at logs for further details");
//Fires ProcessProducerField
fireProcessProducerFieldBeanEvent(annotatedFields);
inspectErrorStack("There are errors that are added by ProcessProducerField event observers for " +
"producer field beans. Look at logs for further details");
//Fire ObservableMethods
fireProcessObservableMethodBeanEvent(observerMethodsMap);
inspectErrorStack("There are errors that are added by ProcessObserverMethod event observers for " +
"observer methods. Look at logs for further details");
if(!isAnnotatedTypeDecoratorOrInterceptor(annotatedType))
{
beanManager.addBean(managedBean);
for (ProducerMethodBean<?> producerMethod : producerMethods)
{
// add them one after the other to enable serialization handling et al
beanManager.addBean(producerMethod);
}
managedBeanCreator.defineDisposalMethods();//Define disposal method after adding producers
for (ProducerFieldBean<?> producerField : producerFields)
{
// add them one after the other to enable serialization handling et al
beanManager.addBean(producerField);
}
}
}
else
{
// we still need to fire a ProcessManagedBean event, even for lazily initiated beans
// (which most probably are no beans at all...)
BeanManagerImpl beanManager = webBeansContext.getBeanManagerImpl();
//Fires ProcessManagedBean
ProcessBeanImpl<T> processBeanEvent = new GProcessManagedBean(managedBean, annotatedType);
beanManager.fireEvent(processBeanEvent);
inspectErrorStack("There are errors that are added by ProcessManagedBean event observers for " +
"managed beans. Look at logs for further details");
if(!isAnnotatedTypeDecoratorOrInterceptor(annotatedType))
{
beanManager.addBean(managedBean);
}
}
return managedBean;
}