public static <T> ManagedBean<T> defineManagedBean(ManagedBeanCreatorImpl<T> managedBeanCreator,
ProcessInjectionTarget<T> processInjectionTargetEvent)
{
BeanManagerImpl manager = BeanManagerImpl.getManager();
//Annotated type
AnnotatedType<T> annotatedType = processInjectionTargetEvent.getAnnotatedType();
ManagedBean<T> managedBean = managedBeanCreator.getBean();
Class<T> clazz = annotatedType.getJavaClass();
managedBeanCreator.defineSerializable();
//Define meta-data
managedBeanCreator.defineStereoTypes();
//Scope type
managedBeanCreator.defineScopeType(logger.getTokenString(OWBLogConst.TEXT_MB_IMPL) + clazz.getName() +
logger.getTokenString(OWBLogConst.TEXT_SAME_SCOPE));
//Check for Enabled via Alternative
WebBeansUtil.setInjectionTargetBeanEnableFlag(managedBean);
managedBeanCreator.defineApiType();
managedBeanCreator.checkCreateConditions();
managedBeanCreator.defineQualifier();
managedBeanCreator.defineName(WebBeansUtil.getManagedBeanDefaultName(clazz.getSimpleName()));
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 = AnnotatedElementFactory.newAnnotatedMethod(producerMethod.getCreatorMethod(),
annotatedType);
ProcessProducerImpl<?, ?> producerEvent = WebBeansUtil.fireProcessProducerEventForMethod(producerMethod,
method);
WebBeansUtil.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()));
producerEvent.setProducerSet(false);
}
Map<ProducerFieldBean<?>,AnnotatedField<?>> annotatedFields =
new HashMap<ProducerFieldBean<?>, AnnotatedField<?>>();
for(ProducerFieldBean<?> producerField : producerFields)
{
AnnotatedField<?> field = AnnotatedElementFactory.newAnnotatedField(producerField.getCreatorField(),
annotatedType);
ProcessProducerImpl<?, ?> producerEvent = WebBeansUtil.fireProcessProducerEventForField(producerField,
field);
WebBeansUtil.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()));
producerEvent.setProducerSet(false);
}
Map<ObserverMethod<?>,AnnotatedMethod<?>> observerMethodsMap =
new HashMap<ObserverMethod<?>, AnnotatedMethod<?>>();
for(ObserverMethod<?> observerMethod : observerMethods)
{
ObserverMethodImpl<?> impl = (ObserverMethodImpl<?>)observerMethod;
AnnotatedMethod<?> method = AnnotatedElementFactory.newAnnotatedMethod(impl.getObserverMethod(),
annotatedType);
observerMethodsMap.put(observerMethod, method);
}
BeanManagerImpl beanManager = BeanManagerImpl.getManager();
//Fires ProcessManagedBean
ProcessBeanImpl<T> processBeanEvent = new GProcessManagedBean(managedBean,annotatedType);
beanManager.fireEvent(processBeanEvent, new Annotation[0]);
WebBeansUtil.inspectErrorStack("There are errors that are added by ProcessManagedBean event observers for " +
"managed beans. Look at logs for further details");
//Fires ProcessProducerMethod
WebBeansUtil.fireProcessProducerMethodBeanEvent(annotatedMethods, annotatedType);
WebBeansUtil.inspectErrorStack("There are errors that are added by ProcessProducerMethod event observers for " +
"producer method beans. Look at logs for further details");
//Fires ProcessProducerField
WebBeansUtil.fireProcessProducerFieldBeanEvent(annotatedFields);
WebBeansUtil.inspectErrorStack("There are errors that are added by ProcessProducerField event observers for " +
"producer field beans. Look at logs for further details");
//Fire ObservableMethods
WebBeansUtil.fireProcessObservableMethodBeanEvent(observerMethodsMap);
WebBeansUtil.inspectErrorStack("There are errors that are added by ProcessObserverMethod event observers for " +
"observer methods. Look at logs for further details");
if(!WebBeansAnnotatedTypeUtil.isAnnotatedTypeDecoratorOrInterceptor(annotatedType))
{
beanManager.addBean(WebBeansUtil.createNewBean(managedBean));
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);
}
}
return managedBean;
}