Author: rmannibucau
Date: Tue Dec 27 11:17:25 2011
New Revision: 1224895
URL: http://svn.apache.org/viewvc?rev=1224895&view=rev
Log:
copying OWB method to be able to fix it: annotatedtype was not propagated when
an event was fired and the process annotated event was a 3rd party one. TODO:
rmeove this hack when OWB will fix it
Modified:
openejb/trunk/openejb/container/openejb-core/src/main/java/org/apache/openejb/cdi/OpenEJBLifecycle.java
Modified:
openejb/trunk/openejb/container/openejb-core/src/main/java/org/apache/openejb/cdi/OpenEJBLifecycle.java
URL:
http://svn.apache.org/viewvc/openejb/trunk/openejb/container/openejb-core/src/main/java/org/apache/openejb/cdi/OpenEJBLifecycle.java?rev=1224895&r1=1224894&r2=1224895&view=diff
==============================================================================
---
openejb/trunk/openejb/container/openejb-core/src/main/java/org/apache/openejb/cdi/OpenEJBLifecycle.java
(original)
+++
openejb/trunk/openejb/container/openejb-core/src/main/java/org/apache/openejb/cdi/OpenEJBLifecycle.java
Tue Dec 27 11:17:25 2011
@@ -16,48 +16,36 @@
*/
package org.apache.openejb.cdi;
-import java.io.BufferedInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.lang.annotation.Annotation;
-import java.net.URL;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Properties;
-import java.util.Set;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.TimeUnit;
-
-import javax.el.ELResolver;
-import javax.enterprise.inject.Specializes;
-import javax.enterprise.inject.spi.AnnotatedType;
-import javax.enterprise.inject.spi.BeanManager;
-import javax.servlet.ServletContext;
-import javax.servlet.ServletContextEvent;
-import javax.servlet.jsp.JspApplicationContext;
-import javax.servlet.jsp.JspFactory;
-
import org.apache.openejb.AppContext;
import org.apache.openejb.BeanContext;
import org.apache.openejb.assembler.classic.Assembler;
import org.apache.webbeans.component.InjectionPointBean;
+import org.apache.webbeans.component.InjectionTargetWrapper;
import org.apache.webbeans.component.NewBean;
+import org.apache.webbeans.component.ProducerFieldBean;
+import org.apache.webbeans.component.ProducerMethodBean;
+import org.apache.webbeans.component.creation.BeanCreator;
import org.apache.webbeans.config.OWBLogConst;
import org.apache.webbeans.config.OpenWebBeansConfiguration;
import org.apache.webbeans.config.WebBeansContext;
import org.apache.webbeans.config.WebBeansFinder;
import org.apache.webbeans.container.BeanManagerImpl;
import org.apache.webbeans.container.InjectionResolver;
+import org.apache.webbeans.ejb.common.component.BaseEjbBean;
import org.apache.webbeans.ejb.common.component.EjbBeanCreatorImpl;
import org.apache.webbeans.ejb.common.util.EjbUtility;
+import org.apache.webbeans.event.ObserverMethodImpl;
+import org.apache.webbeans.exception.WebBeansConfigurationException;
import org.apache.webbeans.intercept.InterceptorData;
import org.apache.webbeans.logger.WebBeansLogger;
+import org.apache.webbeans.portable.AnnotatedElementFactory;
import org.apache.webbeans.portable.events.ExtensionLoader;
import org.apache.webbeans.portable.events.ProcessAnnotatedTypeImpl;
+import org.apache.webbeans.portable.events.ProcessInjectionTargetImpl;
+import org.apache.webbeans.portable.events.ProcessProducerImpl;
+import org.apache.webbeans.portable.events.ProcessSessionBeanImpl;
import org.apache.webbeans.portable.events.discovery.BeforeShutdownImpl;
+import org.apache.webbeans.portable.events.generics.GProcessSessionBean;
import org.apache.webbeans.spi.ContainerLifecycle;
import org.apache.webbeans.spi.ContextsService;
import org.apache.webbeans.spi.JNDIService;
@@ -68,6 +56,38 @@ import org.apache.webbeans.util.WebBeans
import org.apache.webbeans.util.WebBeansUtil;
import org.apache.webbeans.xml.WebBeansXMLConfigurator;
+import javax.el.ELResolver;
+import javax.enterprise.inject.Specializes;
+import javax.enterprise.inject.spi.AnnotatedField;
+import javax.enterprise.inject.spi.AnnotatedMethod;
+import javax.enterprise.inject.spi.AnnotatedType;
+import javax.enterprise.inject.spi.Bean;
+import javax.enterprise.inject.spi.BeanManager;
+import javax.enterprise.inject.spi.ObserverMethod;
+import javax.enterprise.inject.spi.ProcessAnnotatedType;
+import javax.servlet.ServletContext;
+import javax.servlet.ServletContextEvent;
+import javax.servlet.jsp.JspApplicationContext;
+import javax.servlet.jsp.JspFactory;
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+
/**
* @version $Rev:$ $Date:$
*/
@@ -248,7 +268,7 @@ public class OpenEJBLifecycle implements
beanContext.set(CurrentCreationalContext.class, new
CurrentCreationalContext());
beanContext.addSystemInterceptor(new CdiInterceptor(bean,
beanManager, cdiPlugin.getContexsServices()));
- EjbUtility.fireEvents((Class<Object>) implClass, bean,
(ProcessAnnotatedTypeImpl<Object>) processAnnotatedEvent);
+ fireEvents((Class<Object>) implClass, bean,
(ProcessAnnotatedTypeImpl<Object>) processAnnotatedEvent);
webBeansContext.getWebBeansUtil().setInjectionTargetBeanEnableFlag(bean);
@@ -323,6 +343,137 @@ public class OpenEJBLifecycle implements
logger.info(OWBLogConst.INFO_0001,
Long.toString(System.currentTimeMillis() - begin));
}
+ // TODO:
+ // big copy/paste from OWB to fix the propagation of annotatedtype (look
if(processAnnotatedEvent.isModifiedAnnotatedType()) block)
+ // when it will be fixed simply remove this method and replace it by the
EJBUtility one
+ public static <T> void fireEvents(Class<T> clazz, BaseEjbBean<T>
ejbBean,ProcessAnnotatedType<T> event)
+ {
+ WebBeansContext webBeansContext = ejbBean.getWebBeansContext();
+ BeanManagerImpl manager = webBeansContext.getBeanManagerImpl();
+ AnnotatedElementFactory annotatedElementFactory =
webBeansContext.getAnnotatedElementFactory();
+
+ AnnotatedType<T> annotatedType =
annotatedElementFactory.newAnnotatedType(clazz);
+
+ //Fires ProcessAnnotatedType
+ ProcessAnnotatedTypeImpl<T> processAnnotatedEvent =
(ProcessAnnotatedTypeImpl<T>)event;
+ EjbBeanCreatorImpl<T> ejbBeanCreator = new
EjbBeanCreatorImpl<T>(ejbBean);
+ ejbBeanCreator.checkCreateConditions();
+
+ if(processAnnotatedEvent.isVeto())
+ {
+ return;
+ }
+
+ if(processAnnotatedEvent.isModifiedAnnotatedType())
+ {
+
ejbBeanCreator.setMetaDataProvider(BeanCreator.MetaDataProvider.THIRDPARTY);
+ ejbBeanCreator.setAnnotatedType(annotatedType); // missing lin ein
OWB
+ }
+
+ //Define meta-data
+ ejbBeanCreator.defineSerializable();
+ ejbBeanCreator.defineStereoTypes();
+ ejbBeanCreator.defineApiType();
+ ejbBeanCreator.defineScopeType("Session Bean implementation class : "
+ clazz.getName() + " stereotypes must declare same @ScopeType annotations",
false);
+ ejbBeanCreator.defineQualifier();
+
ejbBeanCreator.defineName(WebBeansUtil.getManagedBeanDefaultName(clazz.getSimpleName()));
+ Set<ProducerMethodBean<?>> producerMethodBeans =
ejbBeanCreator.defineProducerMethods();
+ for(ProducerMethodBean<?> producerMethodBean : producerMethodBeans)
+ {
+ Method producerMethod = producerMethodBean.getCreatorMethod();
+ if(!Modifier.isStatic(producerMethod.getModifiers()))
+ {
+ if(!EjbUtility.isBusinessMethod(producerMethod, ejbBean))
+ {
+ throw new WebBeansConfigurationException("Producer Method
Bean must be business method of session bean : " + ejbBean);
+ }
+ }
+ }
+ Set<ProducerFieldBean<?>> producerFieldBeans =
ejbBeanCreator.defineProducerFields();
+ ejbBeanCreator.defineInjectedFields();
+ ejbBeanCreator.defineInjectedMethods();
+ Set<ObserverMethod<?>> observerMethods =
ejbBeanCreator.defineObserverMethods();
+
+ //Fires ProcessInjectionTarget
+ ProcessInjectionTargetImpl<T> processInjectionTargetEvent =
+
webBeansContext.getWebBeansUtil().fireProcessInjectionTargetEvent(ejbBean);
+ webBeansContext.getWebBeansUtil().inspectErrorStack(
+ "There are errors that are added by ProcessInjectionTarget
event observers. Look at logs for further details");
+ //Put final InjectionTarget instance
+ manager.putInjectionTargetWrapper(ejbBean, new
InjectionTargetWrapper(processInjectionTargetEvent.getInjectionTarget()));
+
+ Map<ProducerMethodBean<?>,AnnotatedMethod<?>> annotatedMethods = new
HashMap<ProducerMethodBean<?>, AnnotatedMethod<?>>();
+ for(ProducerMethodBean<?> producerMethod : producerMethodBeans)
+ {
+ AnnotatedMethod<?> method =
annotatedElementFactory.newAnnotatedMethod(producerMethod.getCreatorMethod(),
annotatedType);
+ ProcessProducerImpl<?, ?> producerEvent =
+
webBeansContext.getWebBeansUtil().fireProcessProducerEventForMethod(producerMethod,
+ method);
+ webBeansContext.getWebBeansUtil().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 : producerFieldBeans)
+ {
+ AnnotatedField<?> field =
annotatedElementFactory.newAnnotatedField(producerField.getCreatorField(),
annotatedType);
+ ProcessProducerImpl<?, ?> producerEvent =
+
webBeansContext.getWebBeansUtil().fireProcessProducerEventForField(producerField,
field);
+ webBeansContext.getWebBeansUtil().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);
+ }
+
+ //Fires ProcessManagedBean
+ ProcessSessionBeanImpl<T> processBeanEvent = new
GProcessSessionBean((Bean<Object>)ejbBean,annotatedType,ejbBean.getEjbName(),ejbBean.getEjbType());
+ webBeansContext.getBeanManagerImpl().fireEvent(processBeanEvent, new
Annotation[0]);
+ webBeansContext.getWebBeansUtil().inspectErrorStack(
+ "There are errors that are added by ProcessSessionBean event
observers for managed beans. Look at logs for further details");
+
+ //Fires ProcessProducerMethod
+
webBeansContext.getWebBeansUtil().fireProcessProducerMethodBeanEvent(annotatedMethods,
+ annotatedType);
+ webBeansContext.getWebBeansUtil().inspectErrorStack(
+ "There are errors that are added by ProcessProducerMethod
event observers for producer method beans. Look at logs for further details");
+
+ //Fires ProcessProducerField
+
webBeansContext.getWebBeansUtil().fireProcessProducerFieldBeanEvent(annotatedFields);
+ webBeansContext.getWebBeansUtil().inspectErrorStack(
+ "There are errors that are added by ProcessProducerField event
observers for producer field beans. Look at logs for further details");
+
+ //Fire ObservableMethods
+
webBeansContext.getWebBeansUtil().fireProcessObservableMethodBeanEvent(observerMethodsMap);
+ webBeansContext.getWebBeansUtil().inspectErrorStack(
+ "There are errors that are added by ProcessObserverMethod
event observers for observer methods. Look at logs for further details");
+
+ manager.addBean(ejbBean);
+
+ // Let the plugin handle adding the new bean instance as it knows more
about its EJB Bean
+
+ manager.getBeans().addAll(producerMethodBeans);
+ ejbBeanCreator.defineDisposalMethods();
+ manager.getBeans().addAll(producerFieldBeans);
+ }
+
public static class NewEjbBean<T> extends CdiEjbBean<T> implements
NewBean<T> {
public NewEjbBean(BeanContext beanContext, WebBeansContext
webBeansContext) {
