You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openwebbeans.apache.org by ge...@apache.org on 2010/02/06 17:25:30 UTC
svn commit: r907247 - in
/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans:
component/ component/creation/ config/ container/ inject/impl/
portable/creation/ util/ xml/
Author: gerdogdu
Date: Sat Feb 6 16:25:29 2010
New Revision: 907247
URL: http://svn.apache.org/viewvc?rev=907247&view=rev
Log:
[OWB-268] Implementation of BeanManager#createInjectionTarget
Added:
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AnnotatedTypeBeanCreatorImpl.java (with props)
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/WebBeansAnnotatedTypeUtil.java (with props)
Modified:
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/AbstractInjectionTargetBean.java
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AbstractBeanCreator.java
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AbstractInjectedTargetBeanCreator.java
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/BeanCreator.java
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/ManagedBeanCreatorImpl.java
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/BeansDeployer.java
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/DefinitionUtil.java
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/ManagedBeanConfigurator.java
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanManagerImpl.java
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/inject/impl/InjectionPointFactory.java
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/portable/creation/InjectionTargetProducer.java
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/AnnotationUtil.java
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/WebBeansUtil.java
openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/xml/WebBeansXMLConfigurator.java
Modified: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/AbstractInjectionTargetBean.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/AbstractInjectionTargetBean.java?rev=907247&r1=907246&r2=907247&view=diff
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/AbstractInjectionTargetBean.java (original)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/AbstractInjectionTargetBean.java Sat Feb 6 16:25:29 2010
@@ -65,11 +65,6 @@
/** Injected methods of the bean */
private Set<Method> injectedFromSuperMethods = new HashSet<Method>();
-
- /** @deprecated */
- /* Removed from specification */
- protected boolean fromRealizes;
-
/**
* InjectionTargt instance. If this is not null, it is used for creating
* instance.
Modified: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AbstractBeanCreator.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AbstractBeanCreator.java?rev=907247&r1=907246&r2=907247&view=diff
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AbstractBeanCreator.java (original)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AbstractBeanCreator.java Sat Feb 6 16:25:29 2010
@@ -14,15 +14,18 @@
package org.apache.webbeans.component.creation;
import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
import java.util.Set;
import javax.enterprise.context.NormalScope;
import javax.enterprise.context.spi.CreationalContext;
+import javax.enterprise.inject.spi.AnnotatedType;
import javax.enterprise.inject.spi.InjectionPoint;
import javax.enterprise.inject.spi.Producer;
import org.apache.webbeans.component.AbstractBean;
import org.apache.webbeans.config.DefinitionUtil;
+import org.apache.webbeans.util.AnnotationUtil;
import org.apache.webbeans.util.WebBeansUtil;
/**
@@ -46,6 +49,11 @@
/**Bean annotations*/
private final Annotation[] beanAnnotations;
+ /**If annotated type is set by ProcessAnnotatedType event, used this annotated type
+ * to define bean instance intead of using class artifacts.
+ */
+ private AnnotatedType<T> annotatedType;
+
/**Producer set or not*/
private boolean producerSet = false;
@@ -91,7 +99,8 @@
}
else
{
- //TODO Define Api Types by third party
+ Set<Type> types = this.annotatedType.getTypeClosure();
+ this.bean.getTypes().addAll(types);
}
}
@@ -107,7 +116,7 @@
}
else
{
- //TODO Define Qualifiers
+ DefinitionUtil.defineQualifiers(this.bean, AnnotationUtil.getAnnotationsFromSet(this.annotatedType.getAnnotations()));
}
}
@@ -124,7 +133,8 @@
}
else
{
- //TODO
+ DefinitionUtil.defineName(this.bean, AnnotationUtil.getAnnotationsFromSet(this.annotatedType.getAnnotations()),
+ WebBeansUtil.getManagedBeanDefaultName(annotatedType.getJavaClass().getSimpleName()));
}
}
@@ -142,7 +152,7 @@
}
else
{
- //TODO
+ DefinitionUtil.defineScopeType(this.bean, AnnotationUtil.getAnnotationsFromSet(this.annotatedType.getAnnotations()), errorMessage);
}
}
@@ -152,15 +162,7 @@
@Override
public void defineSerializable()
{
- if(isDefaultMetaDataProvider())
- {
- DefinitionUtil.defineSerializable(this.bean);
- }
- else
- {
- //TODO
- }
-
+ DefinitionUtil.defineSerializable(this.bean);
}
/**
@@ -175,7 +177,7 @@
}
else
{
- //TODO
+ DefinitionUtil.defineStereoTypes(this.bean, AnnotationUtil.getAnnotationsFromSet(this.annotatedType.getAnnotations()));
}
}
@@ -267,4 +269,14 @@
{
return producer.produce(creationalContext);
}
+
+ protected AnnotatedType<T> getAnnotatedType()
+ {
+ return this.annotatedType;
+ }
+
+ public void setAnnotatedType(AnnotatedType<T> annotatedType)
+ {
+ this.annotatedType = annotatedType;
+ }
}
\ No newline at end of file
Modified: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AbstractInjectedTargetBeanCreator.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AbstractInjectedTargetBeanCreator.java?rev=907247&r1=907246&r2=907247&view=diff
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AbstractInjectedTargetBeanCreator.java (original)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AbstractInjectedTargetBeanCreator.java Sat Feb 6 16:25:29 2010
@@ -23,6 +23,7 @@
import org.apache.webbeans.component.ProducerFieldBean;
import org.apache.webbeans.component.ProducerMethodBean;
import org.apache.webbeans.config.DefinitionUtil;
+import org.apache.webbeans.util.WebBeansAnnotatedTypeUtil;
/**
* Abstract implementation of {@link InjectedTargetBeanCreator}.
@@ -70,7 +71,7 @@
}
else
{
- //TODO
+ WebBeansAnnotatedTypeUtil.defineDisposalMethods(getBean(), getAnnotatedType());
}
}
@@ -87,7 +88,7 @@
}
else
{
- //TODO
+ WebBeansAnnotatedTypeUtil.defineInjectedFields(getBean(), getAnnotatedType());
}
}
@@ -102,6 +103,10 @@
{
DefinitionUtil.defineInjectedMethods(getBean());
}
+ else
+ {
+ WebBeansAnnotatedTypeUtil.defineInjectedMethods(getBean(), getAnnotatedType());
+ }
}
@@ -117,7 +122,7 @@
}
else
{
- return null;
+ return WebBeansAnnotatedTypeUtil.defineObserverMethods(getBean(), getAnnotatedType());
}
}
@@ -133,7 +138,7 @@
}
else
{
- return null;
+ return WebBeansAnnotatedTypeUtil.defineProducerFields(getBean(), getAnnotatedType());
}
}
@@ -149,7 +154,7 @@
}
else
{
- return null;
+ return WebBeansAnnotatedTypeUtil.defineProducerMethods(getBean(), getAnnotatedType());
}
}
Added: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AnnotatedTypeBeanCreatorImpl.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AnnotatedTypeBeanCreatorImpl.java?rev=907247&view=auto
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AnnotatedTypeBeanCreatorImpl.java (added)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AnnotatedTypeBeanCreatorImpl.java Sat Feb 6 16:25:29 2010
@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.webbeans.component.creation;
+
+import org.apache.webbeans.component.ManagedBean;
+import org.apache.webbeans.util.WebBeansAnnotatedTypeUtil;
+import org.apache.webbeans.util.WebBeansUtil;
+
+public class AnnotatedTypeBeanCreatorImpl<T> extends ManagedBeanCreatorImpl<T>
+{
+
+ public AnnotatedTypeBeanCreatorImpl(ManagedBean<T> managedBean)
+ {
+ super(managedBean);
+ setMetaDataProvider(MetaDataProvider.THIRDPARTY);
+ }
+
+ /* (non-Javadoc)
+ * @see org.apache.webbeans.component.creation.ManagedBeanCreatorImpl#checkCreateConditions()
+ */
+ @Override
+ public void checkCreateConditions()
+ {
+ WebBeansAnnotatedTypeUtil.checkManagedBeanCondition(getAnnotatedType());
+ WebBeansUtil.checkGenericType(getBean());
+ }
+
+
+
+}
Propchange: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/AnnotatedTypeBeanCreatorImpl.java
------------------------------------------------------------------------------
svn:eol-style = native
Modified: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/BeanCreator.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/BeanCreator.java?rev=907247&r1=907246&r2=907247&view=diff
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/BeanCreator.java (original)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/BeanCreator.java Sat Feb 6 16:25:29 2010
@@ -13,8 +13,6 @@
*/
package org.apache.webbeans.component.creation;
-import java.lang.annotation.Annotation;
-
import javax.enterprise.inject.spi.Bean;
import javax.enterprise.inject.spi.Producer;
Modified: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/ManagedBeanCreatorImpl.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/ManagedBeanCreatorImpl.java?rev=907247&r1=907246&r2=907247&view=diff
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/ManagedBeanCreatorImpl.java (original)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/ManagedBeanCreatorImpl.java Sat Feb 6 16:25:29 2010
@@ -15,11 +15,14 @@
import java.lang.reflect.Constructor;
+import javax.enterprise.inject.spi.AnnotatedConstructor;
+
import org.apache.webbeans.component.ManagedBean;
import org.apache.webbeans.component.WebBeansType;
import org.apache.webbeans.config.DefinitionUtil;
import org.apache.webbeans.config.ManagedBeanConfigurator;
import org.apache.webbeans.decorator.WebBeansDecoratorConfig;
+import org.apache.webbeans.util.WebBeansAnnotatedTypeUtil;
import org.apache.webbeans.util.WebBeansUtil;
/**
@@ -61,16 +64,21 @@
@Override
public void defineConstructor()
{
+ Constructor<T> constructor = null;
if(isDefaultMetaDataProvider())
{
- Constructor<T> constructor = WebBeansUtil.defineConstructor(getBean().getReturnType());
- getBean().setConstructor(constructor);
+ constructor = WebBeansUtil.defineConstructor(getBean().getReturnType());
DefinitionUtil.addConstructorInjectionPointMetaData(getBean(), constructor);
}
else
{
- //TODO
+ AnnotatedConstructor<T> annotated = WebBeansAnnotatedTypeUtil.getBeanConstructor(getAnnotatedType());
+ constructor = annotated.getJavaMember();
+ WebBeansAnnotatedTypeUtil.addConstructorInjectionPointMetaData(getBean(), annotated);
}
+
+ getBean().setConstructor(constructor);
+
}
/**
Modified: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/BeansDeployer.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/BeansDeployer.java?rev=907247&r1=907246&r2=907247&view=diff
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/BeansDeployer.java (original)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/BeansDeployer.java Sat Feb 6 16:25:29 2010
@@ -642,6 +642,7 @@
if(processAnnotatedEvent.isSet())
{
+ managedBeanCreator.setAnnotatedType(processAnnotatedEvent.getAnnotatedType());
managedBeanCreator.setMetaDataProvider(MetaDataProvider.THIRDPARTY);
}
@@ -659,7 +660,7 @@
managedBeanCreator.defineApiType();
managedBeanCreator.defineQualifier();
- managedBeanCreator.defineName(WebBeansUtil.getSimpleWebBeanDefaultName(clazz.getSimpleName()));
+ managedBeanCreator.defineName(WebBeansUtil.getManagedBeanDefaultName(clazz.getSimpleName()));
managedBeanCreator.defineConstructor();
Set<ProducerMethodBean<?>> producerMethods = managedBeanCreator.defineProducerMethods();
Set<ProducerFieldBean<?>> producerFields = managedBeanCreator.defineProducerFields();
@@ -694,7 +695,7 @@
if(producerEvent.isProducerSet())
{
- producerMethod.setProducer((Producer) managedBeanCreator.getProducer());
+ producerMethod.setProducer((Producer)managedBeanCreator);
}
producerEvent.setProducerSet(false);
@@ -711,7 +712,7 @@
if(producerEvent.isProducerSet())
{
- producerField.setProducer((Producer) managedBeanCreator.getProducer());
+ producerField.setProducer((Producer) managedBeanCreator);
}
producerEvent.setProducerSet(false);
@@ -746,7 +747,7 @@
//Set InjectionTarget that is used by the container to inject dependencies!
if(managedBeanCreator.isInjectionTargetSet())
{
- managedBean.setInjectionTarget(managedBeanCreator.getInjectedTarget());
+ managedBean.setInjectionTarget(managedBeanCreator);
}
BeanManagerImpl.getManager().addBean(WebBeansUtil.createNewBean(managedBean));
Modified: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/DefinitionUtil.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/DefinitionUtil.java?rev=907247&r1=907246&r2=907247&view=diff
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/DefinitionUtil.java (original)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/DefinitionUtil.java Sat Feb 6 16:25:29 2010
@@ -795,7 +795,7 @@
}
- private static <T> void defineInternalInjectedFieldsRecursively(AbstractInjectionTargetBean<T> component, Class<T> clazz)
+ public static <T> void defineInternalInjectedFieldsRecursively(AbstractInjectionTargetBean<T> component, Class<T> clazz)
{
// From inheritance
Class<?> superClazz = clazz.getSuperclass();
@@ -811,7 +811,7 @@
}
- private static <T> void defineInternalInjectedFields(AbstractInjectionTargetBean<T> component, Class<T> clazz, boolean fromSuperClazz)
+ public static <T> void defineInternalInjectedFields(AbstractInjectionTargetBean<T> component, Class<T> clazz, boolean fromSuperClazz)
{
Field[] fields = clazz.getDeclaredFields();
@@ -887,7 +887,7 @@
defineInternalInjectedMethodsRecursively(bean, clazz);
}
- private static <T> void defineInternalInjectedMethodsRecursively(AbstractInjectionTargetBean<T> component, Class<T> clazz)
+ public static <T> void defineInternalInjectedMethodsRecursively(AbstractInjectionTargetBean<T> component, Class<T> clazz)
{
// From inheritance
Class<?> superClazz = clazz.getSuperclass();
Modified: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/ManagedBeanConfigurator.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/ManagedBeanConfigurator.java?rev=907247&r1=907246&r2=907247&view=diff
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/ManagedBeanConfigurator.java (original)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/config/ManagedBeanConfigurator.java Sat Feb 6 16:25:29 2010
@@ -125,7 +125,7 @@
WebBeansUtil.checkGenericType(component);
WebBeansUtil.checkPassivationScope(component, component.getScope().getAnnotation(NormalScope.class));
DefinitionUtil.defineQualifiers(component, clazzAnns);
- DefinitionUtil.defineName(component, clazzAnns, WebBeansUtil.getSimpleWebBeanDefaultName(clazz.getSimpleName()));
+ DefinitionUtil.defineName(component, clazzAnns, WebBeansUtil.getManagedBeanDefaultName(clazz.getSimpleName()));
Constructor<T> constructor = WebBeansUtil.defineConstructor(clazz);
component.setConstructor(constructor);
@@ -167,7 +167,7 @@
WebBeansUtil.checkGenericType(component);
WebBeansUtil.checkPassivationScope(component, component.getScope().getAnnotation(NormalScope.class));
DefinitionUtil.defineQualifiers(component, clazzAnns);
- DefinitionUtil.defineName(component, clazzAnns, WebBeansUtil.getSimpleWebBeanDefaultName(javaClazz.getSimpleName()));
+ DefinitionUtil.defineName(component, clazzAnns, WebBeansUtil.getManagedBeanDefaultName(javaClazz.getSimpleName()));
Constructor<T> constructor = WebBeansUtil.defineConstructor(annotatedType.getConstructors().toArray(new Constructor[0]), javaClazz);
component.setConstructor(constructor);
Modified: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanManagerImpl.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanManagerImpl.java?rev=907247&r1=907246&r2=907247&view=diff
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanManagerImpl.java (original)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanManagerImpl.java Sat Feb 6 16:25:29 2010
@@ -51,10 +51,7 @@
import org.apache.webbeans.component.AbstractBean;
import org.apache.webbeans.component.EnterpriseBeanMarker;
import org.apache.webbeans.component.JmsBeanMarker;
-import org.apache.webbeans.component.ManagedBean;
-import org.apache.webbeans.component.WebBeansType;
import org.apache.webbeans.component.third.ThirdpartyBeanImpl;
-import org.apache.webbeans.config.ManagedBeanConfigurator;
import org.apache.webbeans.config.WebBeansFinder;
import org.apache.webbeans.context.ContextFactory;
import org.apache.webbeans.context.creational.CreationalContextFactory;
@@ -79,6 +76,7 @@
import org.apache.webbeans.util.AnnotationUtil;
import org.apache.webbeans.util.Asserts;
import org.apache.webbeans.util.ClassUtil;
+import org.apache.webbeans.util.WebBeansAnnotatedTypeUtil;
import org.apache.webbeans.util.WebBeansUtil;
import org.apache.webbeans.xml.WebBeansXMLConfigurator;
@@ -955,9 +953,7 @@
@Override
public <T> InjectionTarget<T> createInjectionTarget(AnnotatedType<T> type)
{
- ManagedBean<T> bean = ManagedBeanConfigurator.define(type.getJavaClass(), WebBeansType.MANAGED);
-
- return new InjectionTargetProducer<T>(bean);
+ return new InjectionTargetProducer<T>(WebBeansAnnotatedTypeUtil.defineManagedBean(type));
}
@Override
Modified: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/inject/impl/InjectionPointFactory.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/inject/impl/InjectionPointFactory.java?rev=907247&r1=907246&r2=907247&view=diff
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/inject/impl/InjectionPointFactory.java (original)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/inject/impl/InjectionPointFactory.java Sat Feb 6 16:25:29 2010
@@ -28,6 +28,7 @@
import javax.enterprise.event.Observes;
import javax.enterprise.inject.spi.Annotated;
import javax.enterprise.inject.spi.AnnotatedConstructor;
+import javax.enterprise.inject.spi.AnnotatedField;
import javax.enterprise.inject.spi.AnnotatedMethod;
import javax.enterprise.inject.spi.AnnotatedParameter;
import javax.enterprise.inject.spi.Bean;
@@ -105,6 +106,25 @@
}
+ public static <X> InjectionPoint getFieldInjectionPointData(Bean<?> owner, AnnotatedField<X> annotField)
+ {
+ Asserts.assertNotNull(owner, "owner parameter can not be null");
+ Asserts.assertNotNull(annotField, "annotField parameter can not be null");
+ Field member = annotField.getJavaMember();
+
+ Annotation[] annots = AnnotationUtil.getAnnotationsFromSet(annotField.getAnnotations());
+
+ if(!checkFieldApplicable(annots))
+ {
+ return getGenericInjectionPoint(owner, annots, annotField.getBaseType(), member, annotField);
+ }
+ else
+ {
+ return null;
+ }
+
+ }
+
private static boolean checkFieldApplicable(Annotation[] anns)
{
// if(AnnotationUtil.isAnnotationExist(anns, Fires.class) || AnnotationUtil.isAnnotationExist(anns, Obtains.class))
@@ -198,6 +218,31 @@
return lists;
}
+ public static <X> List<InjectionPoint> getMethodInjectionPointData(Bean<?> owner, AnnotatedMethod<X> method)
+ {
+ Asserts.assertNotNull(owner, "owner parameter can not be null");
+ Asserts.assertNotNull(method, "method parameter can not be null");
+
+ List<InjectionPoint> lists = new ArrayList<InjectionPoint>();
+
+ List<AnnotatedParameter<X>> parameters = method.getParameters();
+
+ InjectionPoint point = null;
+
+ for(AnnotatedParameter<?> parameter : parameters)
+ {
+ //@Observes is not injection point type for method parameters
+ if(parameter.getAnnotation(Observes.class) == null)
+ {
+ point = getGenericInjectionPoint(owner, parameter.getAnnotations().toArray(new Annotation[parameter.getAnnotations().size()]), parameter.getBaseType(), method.getJavaMember() , parameter);
+ lists.add(point);
+ }
+ }
+
+ return lists;
+ }
+
+
private static boolean checkMethodApplicable(Annotation[] annot)
{
@@ -227,6 +272,27 @@
}
+ public static <T> List<InjectionPoint> getConstructorInjectionPointData(Bean<T> owner, AnnotatedConstructor<T> constructor)
+ {
+ Asserts.assertNotNull(owner, "owner parameter can not be null");
+ Asserts.assertNotNull(constructor, "constructor parameter can not be null");
+
+ List<InjectionPoint> lists = new ArrayList<InjectionPoint>();
+
+ List<AnnotatedParameter<T>> parameters = constructor.getParameters();
+
+ InjectionPoint point = null;
+
+ for(AnnotatedParameter<?> parameter : parameters)
+ {
+ point = getGenericInjectionPoint(owner, parameter.getAnnotations().toArray(new Annotation[parameter.getAnnotations().size()]), parameter.getBaseType(), constructor.getJavaMember() , parameter);
+ lists.add(point);
+ }
+
+ return lists;
+ }
+
+
@SuppressWarnings("unchecked")
public static List<InjectionPoint> getConstructorInjectionPointData(Bean<?> owner, Constructor<?> member)
{
Modified: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/portable/creation/InjectionTargetProducer.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/portable/creation/InjectionTargetProducer.java?rev=907247&r1=907246&r2=907247&view=diff
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/portable/creation/InjectionTargetProducer.java (original)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/portable/creation/InjectionTargetProducer.java Sat Feb 6 16:25:29 2010
@@ -14,7 +14,6 @@
package org.apache.webbeans.portable.creation;
import javax.enterprise.context.spi.CreationalContext;
-import javax.enterprise.inject.spi.AnnotatedType;
import javax.enterprise.inject.spi.InjectionTarget;
import org.apache.webbeans.component.AbstractInjectionTargetBean;
Modified: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/AnnotationUtil.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/AnnotationUtil.java?rev=907247&r1=907246&r2=907247&view=diff
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/AnnotationUtil.java (original)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/AnnotationUtil.java Sat Feb 6 16:25:29 2010
@@ -27,6 +27,8 @@
import javax.enterprise.inject.Any;
import javax.enterprise.inject.Stereotype;
+import javax.enterprise.inject.spi.AnnotatedMethod;
+import javax.enterprise.inject.spi.AnnotatedParameter;
import javax.enterprise.inject.spi.Bean;
import javax.enterprise.util.Nonbinding;
import javax.inject.Qualifier;
@@ -123,6 +125,24 @@
}
return false;
}
+
+ public static <X> boolean hasAnnotatedMethodParameterAnnotation(AnnotatedMethod<X> annotatedMethod, Class<? extends Annotation> clazz)
+ {
+ Asserts.assertNotNull(annotatedMethod, "annotatedMethod argument can not be null");
+ Asserts.assertNotNull(clazz, "Clazz argument can not be null");
+
+ List<AnnotatedParameter<X>> parameters = annotatedMethod.getParameters();
+ for(AnnotatedParameter<X> parameter : parameters)
+ {
+ if(parameter.isAnnotationPresent(clazz))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
public static Type[] getMethodParameterGenericTypesWithGivenAnnotation(Method method, Class<? extends Annotation> clazz)
{
@@ -230,6 +250,34 @@
}
return false;
}
+
+ public static <X> boolean hasAnnotatedMethodMultipleParameterAnnotation(AnnotatedMethod<X> annotatedMethod, Class<? extends Annotation> clazz)
+ {
+ Asserts.assertNotNull(annotatedMethod, "annotatedMethod argument can not be null");
+ Asserts.assertNotNull(clazz, "Clazz argument can not be null");
+
+ boolean found = false;
+
+ List<AnnotatedParameter<X>> parameters = annotatedMethod.getParameters();
+ for(AnnotatedParameter<X> parameter : parameters)
+ {
+ if(parameter.isAnnotationPresent(clazz))
+ {
+ if(!found)
+ {
+ found = true;
+ }
+ else
+ {
+ return true;
+ }
+ }
+ }
+
+
+ return false;
+ }
+
/**
* Gets the method first found parameter type that is annotated with the
@@ -264,6 +312,41 @@
}
return null;
}
+
+ public static <X> Type getAnnotatedMethodFirstParameterWithAnnotation(AnnotatedMethod<X> annotatedMethod, Class<? extends Annotation> clazz)
+ {
+ Asserts.assertNotNull(annotatedMethod, "annotatedMethod argument can not be null");
+ Asserts.assertNotNull(clazz, "Clazz argument can not be null");
+
+ List<AnnotatedParameter<X>> parameters = annotatedMethod.getParameters();
+ for(AnnotatedParameter<X> parameter : parameters)
+ {
+ if(parameter.isAnnotationPresent(clazz))
+ {
+ return parameter.getBaseType();
+ }
+ }
+
+ return null;
+ }
+
+ public static <X> Annotation[] getAnnotatedMethodFirstParameterQualifierWithGivenAnnotation(AnnotatedMethod<X> annotatedMethod, Class<? extends Annotation> clazz)
+ {
+ Asserts.assertNotNull(annotatedMethod, "annotatedMethod argument can not be null");
+ Asserts.assertNotNull(clazz, "Clazz argument can not be null");
+
+ List<AnnotatedParameter<X>> parameters = annotatedMethod.getParameters();
+ for(AnnotatedParameter<X> parameter : parameters)
+ {
+ if(parameter.isAnnotationPresent(clazz))
+ {
+ return getAnnotationsFromSet(parameter.getAnnotations());
+ }
+ }
+
+ return null;
+ }
+
public static Class<?> getMethodFirstParameterTypeClazzWithAnnotation(Method method, Class<? extends Annotation> clazz)
{
@@ -401,6 +484,25 @@
return null;
}
+
+ public static <X,T extends Annotation> T getAnnotatedMethodFirstParameterAnnotation(AnnotatedMethod<X> annotatedMethod, Class<T> clazz)
+ {
+ Asserts.assertNotNull(annotatedMethod, "annotatedMethod argument can not be null");
+ Asserts.assertNotNull(clazz, "Clazz argument can not be null");
+
+
+ List<AnnotatedParameter<X>> parameters = annotatedMethod.getParameters();
+ for(AnnotatedParameter<X> parameter : parameters)
+ {
+ if(parameter.isAnnotationPresent(clazz))
+ {
+ return clazz.cast(parameter.getAnnotation(clazz));
+ }
+ }
+
+ return null;
+ }
+
/**
* Check given annotation cross ref exist in the any parameter of the given
Added: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/WebBeansAnnotatedTypeUtil.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/WebBeansAnnotatedTypeUtil.java?rev=907247&view=auto
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/WebBeansAnnotatedTypeUtil.java (added)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/WebBeansAnnotatedTypeUtil.java Sat Feb 6 16:25:29 2010
@@ -0,0 +1,773 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.webbeans.util;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import javax.decorator.Decorator;
+import javax.decorator.Delegate;
+import javax.enterprise.context.Dependent;
+import javax.enterprise.event.Observes;
+import javax.enterprise.event.Reception;
+import javax.enterprise.inject.Disposes;
+import javax.enterprise.inject.Produces;
+import javax.enterprise.inject.Specializes;
+import javax.enterprise.inject.UnsatisfiedResolutionException;
+import javax.enterprise.inject.spi.AnnotatedConstructor;
+import javax.enterprise.inject.spi.AnnotatedField;
+import javax.enterprise.inject.spi.AnnotatedMethod;
+import javax.enterprise.inject.spi.AnnotatedParameter;
+import javax.enterprise.inject.spi.AnnotatedType;
+import javax.enterprise.inject.spi.Bean;
+import javax.enterprise.inject.spi.InjectionPoint;
+import javax.enterprise.inject.spi.ObserverMethod;
+import javax.inject.Inject;
+import javax.inject.Named;
+import javax.interceptor.Interceptor;
+
+import org.apache.webbeans.annotation.DependentScopeLiteral;
+import org.apache.webbeans.component.AbstractBean;
+import org.apache.webbeans.component.AbstractInjectionTargetBean;
+import org.apache.webbeans.component.ManagedBean;
+import org.apache.webbeans.component.ProducerFieldBean;
+import org.apache.webbeans.component.ProducerMethodBean;
+import org.apache.webbeans.component.WebBeansType;
+import org.apache.webbeans.component.creation.AnnotatedTypeBeanCreatorImpl;
+import org.apache.webbeans.config.DefinitionUtil;
+import org.apache.webbeans.config.OWBLogConst;
+import org.apache.webbeans.config.OpenWebBeansConfiguration;
+import org.apache.webbeans.container.InjectionResolver;
+import org.apache.webbeans.decorator.DecoratorUtil;
+import org.apache.webbeans.event.NotificationManager;
+import org.apache.webbeans.exception.WebBeansConfigurationException;
+import org.apache.webbeans.inject.impl.InjectionPointFactory;
+import org.apache.webbeans.logger.WebBeansLogger;
+
+public final class WebBeansAnnotatedTypeUtil
+{
+ private static final WebBeansLogger logger = WebBeansLogger.getLogger(WebBeansAnnotatedTypeUtil.class);
+
+ private WebBeansAnnotatedTypeUtil()
+ {
+
+ }
+
+ public static <T> AnnotatedConstructor<T> getBeanConstructor(AnnotatedType<T> type)
+ {
+ Asserts.assertNotNull(type,"Type is null");
+ AnnotatedConstructor<T> result = null;
+
+ Set<AnnotatedConstructor<T>> annConsts = type.getConstructors();
+ if(annConsts != null)
+ {
+ boolean found = false;
+ for(AnnotatedConstructor<T> annConst : annConsts)
+ {
+ if(annConst.isAnnotationPresent(Inject.class))
+ {
+ if (found == true)
+ {
+ throw new WebBeansConfigurationException("There are more than one constructor with @Inject annotation in annotation type : " + type);
+ }
+ else
+ {
+ found = true;
+ result = annConst;
+ }
+ }
+ else
+ {
+ List<AnnotatedParameter<T>> parameters = annConst.getParameters();
+ if(parameters != null && parameters.isEmpty())
+ {
+ result = annConst;
+ }
+ }
+ }
+ }
+
+ if (result == null)
+ {
+ throw new WebBeansConfigurationException("No constructor is found for the annotated type : " + type);
+ }
+
+ List<AnnotatedParameter<T>> parameters = result.getParameters();
+ for(AnnotatedParameter<T> parameter : parameters)
+ {
+ if (parameter.isAnnotationPresent(Disposes.class))
+ {
+ throw new WebBeansConfigurationException("Constructor parameter annotations can not contain @Disposes annotation in annotated constructor : " + result);
+ }
+
+ if(parameter.isAnnotationPresent(Observes.class))
+ {
+ throw new WebBeansConfigurationException("Constructor parameter annotations can not contain @Observes annotation in annotated constructor : " + result);
+ }
+
+ }
+
+
+ return result;
+ }
+
+ public static <T> void addConstructorInjectionPointMetaData(AbstractBean<T> owner, AnnotatedConstructor<T> constructor)
+ {
+ List<InjectionPoint> injectionPoints = InjectionPointFactory.getConstructorInjectionPointData(owner, constructor);
+ for (InjectionPoint injectionPoint : injectionPoints)
+ {
+ DefinitionUtil.addImplicitComponentForInjectionPoint(injectionPoint);
+ owner.addInjectionPoint(injectionPoint);
+ }
+ }
+
+ public static <T,X> void addMethodInjectionPointMetaData(AbstractBean<T> owner, AnnotatedMethod<X> method)
+ {
+ List<InjectionPoint> injectionPoints = InjectionPointFactory.getMethodInjectionPointData(owner, method);
+ for (InjectionPoint injectionPoint : injectionPoints)
+ {
+ DefinitionUtil.addImplicitComponentForInjectionPoint(injectionPoint);
+ owner.addInjectionPoint(injectionPoint);
+ }
+ }
+
+ public static <T,X> void addFieldInjectionPointMetaData(AbstractBean<T> owner, AnnotatedField<X> annotField)
+ {
+ owner.addInjectionPoint(InjectionPointFactory.getFieldInjectionPointData(owner, annotField));
+ }
+
+ @SuppressWarnings("unchecked")
+ public static <X> Set<ObserverMethod<?>> defineObserverMethods(AbstractInjectionTargetBean<X> bean,AnnotatedType<X> annotatedType)
+ {
+ Set<AnnotatedMethod<? super X>> annotatedMethods = annotatedType.getMethods();
+ for (AnnotatedMethod<? super X> annotatedMethod : annotatedMethods)
+ {
+ AnnotatedMethod<X> annt = (AnnotatedMethod<X>)annotatedMethod;
+ List<AnnotatedParameter<X>> parameters = annt.getParameters();
+ boolean found = false;
+ for(AnnotatedParameter<X> parameter : parameters)
+ {
+ if(parameter.isAnnotationPresent(Observes.class))
+ {
+ found = true;
+ break;
+ }
+ }
+
+ if(found)
+ {
+ checkObserverMethodConditions(annotatedMethod, annotatedMethod.getDeclaringType().getJavaClass());
+ if(bean.getScope().equals(Dependent.class))
+ {
+ //Check Reception
+ AnnotationUtil.getAnnotatedMethodFirstParameterWithAnnotation(annotatedMethod, Observes.class);
+
+ Observes observes = AnnotationUtil.getAnnotatedMethodFirstParameterAnnotation(annotatedMethod, Observes.class);
+ Reception reception = observes.notifyObserver();
+ if(reception.equals(Reception.IF_EXISTS))
+ {
+ throw new WebBeansConfigurationException("Dependent Bean : " + bean + " can not define observer method with @Receiver = IF_EXIST");
+ }
+ }
+
+
+ bean.addObservableMethod(annotatedMethod.getJavaMember());
+
+ addMethodInjectionPointMetaData(bean, annotatedMethod);
+ }
+ }
+
+ return NotificationManager.getInstance().addObservableComponentMethods(bean);
+ }
+
+ @SuppressWarnings("unchecked")
+ public static <X> void defineDisposalMethods(AbstractInjectionTargetBean<X> bean,AnnotatedType<X> annotatedType)
+ {
+ Set<AnnotatedMethod<? super X>> annotatedMethods = annotatedType.getMethods();
+ ProducerMethodBean<?> previous = null;
+ for (AnnotatedMethod<? super X> annotatedMethod : annotatedMethods)
+ {
+ Method declaredMethod = annotatedMethod.getJavaMember();
+ AnnotatedMethod<X> annt = (AnnotatedMethod<X>)annotatedMethod;
+ List<AnnotatedParameter<X>> parameters = annt.getParameters();
+ boolean found = false;
+ for(AnnotatedParameter<X> parameter : parameters)
+ {
+ if(parameter.isAnnotationPresent(Disposes.class))
+ {
+ found = true;
+ break;
+ }
+ }
+
+ if(found)
+ {
+ checkProducerMethodDisposal(annotatedMethod);
+ Type type = AnnotationUtil.getAnnotatedMethodFirstParameterWithAnnotation(annotatedMethod, Disposes.class);
+ Annotation[] annot = AnnotationUtil.getAnnotatedMethodFirstParameterQualifierWithGivenAnnotation(annotatedMethod, Disposes.class);
+
+ Set<Bean<?>> set = InjectionResolver.getInstance().implResolveByType(type, annot);
+ if (set.isEmpty()) {
+ throw new UnsatisfiedResolutionException("Producer method component of the disposal method : " + declaredMethod.getName() +
+ " in class : " + declaredMethod.getDeclaringClass().getName() + ". Cannot find bean " + type + " with qualifier " + Arrays.toString(annot));
+ }
+
+ Bean<?> foundBean = set.iterator().next();
+ ProducerMethodBean<?> pr = null;
+
+ if (foundBean == null || !(foundBean instanceof ProducerMethodBean))
+ {
+ throw new UnsatisfiedResolutionException("Producer method component of the disposal method : " + declaredMethod.getName() + " in class : " + annotatedMethod.getDeclaringType().getJavaClass() + "is not found");
+ }
+
+ else
+ {
+ pr = (ProducerMethodBean<?>) foundBean;
+ }
+
+ if (previous == null)
+ {
+ previous = pr;
+ }
+ else
+ {
+ // multiple same producer
+ if (previous.equals(pr))
+ {
+ throw new WebBeansConfigurationException("There are multiple disposal method for the producer method : " + pr.getCreatorMethod().getName() + " in class : " + annotatedMethod.getDeclaringType().getJavaClass());
+ }
+ }
+
+ Method producerMethod = pr.getCreatorMethod();
+ //Disposer methods and producer methods must be in the same class
+ if(!producerMethod.getDeclaringClass().getName().equals(declaredMethod.getDeclaringClass().getName()))
+ {
+ throw new WebBeansConfigurationException("Producer method component of the disposal method : " + declaredMethod.getName() + " in class : " + annotatedMethod.getDeclaringType().getJavaClass() + " must be in the same class!");
+ }
+
+ pr.setDisposalMethod(declaredMethod);
+
+ addMethodInjectionPointMetaData(bean, annotatedMethod);
+
+ }
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public static <X> void defineInjectedMethods(AbstractInjectionTargetBean<X> bean,AnnotatedType<X> annotatedType)
+ {
+ Set<AnnotatedMethod<? super X>> annotatedMethods = annotatedType.getMethods();
+
+ for (AnnotatedMethod<? super X> annotatedMethod : annotatedMethods)
+ {
+ Annotation[] anns = AnnotationUtil.getAnnotationsFromSet(annotatedMethod.getAnnotations());
+ boolean isInitializer = annotatedMethod.isAnnotationPresent(Inject.class);
+ boolean isResource = AnnotationUtil.hasResourceAnnotation(anns);
+
+ if (isInitializer && isResource)
+ {
+ throw new WebBeansConfigurationException("Found initializer and resource injection at the same time for the annotated method : " + annotatedMethod);
+ }
+
+ if (isInitializer)
+ {
+ //Do not support static
+ if(annotatedMethod.isStatic())
+ {
+ continue;
+ }
+
+ checkForInjectedInitializerMethod(bean, (AnnotatedMethod<X>)annotatedMethod);
+ }
+ else if (isResource)
+ {
+ throw new WebBeansConfigurationException("Error in annotated method : " + annotatedMethod + ".Injection of resources into methods are not supported.");
+ }
+ else
+ {
+ continue;
+ }
+
+ Method method = annotatedMethod.getJavaMember();
+
+ if (!Modifier.isStatic(method.getModifiers()))
+ {
+ bean.addInjectedMethod(method);
+ addMethodInjectionPointMetaData(bean, annotatedMethod);
+ }
+ }
+
+ DefinitionUtil.defineInternalInjectedMethodsRecursively(bean, annotatedType.getJavaClass());
+ }
+
+ public static <X> void defineInjectedFields(AbstractInjectionTargetBean<X> bean,AnnotatedType<X> annotatedType)
+ {
+ Set<AnnotatedField<? super X>> annotatedFields = annotatedType.getFields();
+ boolean useOwbSpecificInjection = OpenWebBeansConfiguration.getInstance().isOwbSpecificFieldInjection();
+ for(AnnotatedField<? super X> annotatedField: annotatedFields)
+ {
+ if(!useOwbSpecificInjection)
+ {
+ if(!annotatedField.isAnnotationPresent(Inject.class))
+ {
+ continue;
+ }
+ }
+
+ if (annotatedField.isAnnotationPresent(Produces.class) || annotatedField.isAnnotationPresent(Delegate.class))
+ {
+ continue;
+ }
+
+
+ Field field = annotatedField.getJavaMember();
+ Annotation[] anns = AnnotationUtil.getAnnotationsFromSet(annotatedField.getAnnotations());
+ if(ClassUtil.isPublic(field.getModifiers()))
+ {
+ if(!bean.getScope().equals(Dependent.class))
+ {
+ throw new WebBeansConfigurationException("Error in annotated field : " + annotatedField +" while definining injected field. If bean has a public modifier injection point, bean scope must be defined as @Dependent");
+ }
+ }
+
+ Annotation[] qualifierAnns = AnnotationUtil.getQualifierAnnotations(anns);
+
+ if (qualifierAnns.length > 0)
+ {
+ if (qualifierAnns.length > 0)
+ {
+ WebBeansUtil.checkForNewQualifierForDeployment(annotatedField.getBaseType(), annotatedField.getDeclaringType().getJavaClass(), field.getName(), anns);
+ }
+
+ int mod = field.getModifiers();
+
+ if (!Modifier.isStatic(mod) && !Modifier.isFinal(mod))
+ {
+ bean.addInjectedField(field);
+ addFieldInjectionPointMetaData(bean, annotatedField);
+ }
+ }
+ }
+
+ DefinitionUtil.defineInternalInjectedFieldsRecursively(bean, annotatedType.getJavaClass());
+ }
+
+
+ @SuppressWarnings("unchecked")
+ public static <X> Set<ProducerFieldBean<?>> defineProducerFields(AbstractBean<X> bean, AnnotatedType<X> annotatedType)
+ {
+ Set<ProducerFieldBean<?>> producerBeans = new HashSet<ProducerFieldBean<?>>();
+ Set<AnnotatedField<? super X>> annotatedFields = annotatedType.getFields();
+ for(AnnotatedField<? super X> annotatedField: annotatedFields)
+ {
+ if(annotatedField.isAnnotationPresent(Produces.class))
+ {
+ Type genericType = annotatedField.getBaseType();
+
+ if(ClassUtil.isParametrizedType(genericType))
+ {
+ if(!ClassUtil.checkParametrizedType((ParameterizedType)genericType))
+ {
+ throw new WebBeansConfigurationException("Producer annotated field : " + annotatedField + " can not be Wildcard type or Type variable");
+ }
+ }
+
+ ProducerFieldBean<X> producerFieldBean = new ProducerFieldBean<X>(bean, (Class<X>)ClassUtil.getClass(annotatedField.getBaseType()));
+ Annotation[] anns = AnnotationUtil.getAnnotationsFromSet(annotatedField.getAnnotations());
+ Field field = annotatedField.getJavaMember();
+
+ producerFieldBean.setProducerField(field);
+ //Producer field for resource
+ if(AnnotationUtil.hasResourceAnnotation(anns))
+ {
+
+ //Check for valid resource annotation
+ WebBeansUtil.checkForValidResources(annotatedField.getBaseType(), field.getType(), field.getName(), anns);
+
+ //Can not define EL name
+ if(annotatedField.isAnnotationPresent(Named.class))
+ {
+ throw new WebBeansConfigurationException("Resource producer annotated field : " + annotatedField + " can not define EL name");
+ }
+
+ producerFieldBean.getTypes().addAll(annotatedField.getTypeClosure());
+ DefinitionUtil.defineQualifiers(producerFieldBean, anns);
+ producerFieldBean.setImplScopeType(new DependentScopeLiteral());
+ }
+ else
+ {
+ if (ClassUtil.isPrimitive(ClassUtil.getClass(annotatedField.getBaseType())))
+ {
+ producerFieldBean.setNullable(false);
+ }
+
+ DefinitionUtil.defineSerializable(producerFieldBean);
+ DefinitionUtil.defineStereoTypes(producerFieldBean, anns);
+ WebBeansUtil.setBeanEnableFlagForProducerBean(bean, producerFieldBean, anns);
+ Set<Type> types = annotatedField.getTypeClosure();
+ producerFieldBean.getTypes().addAll(types);
+ DefinitionUtil.defineScopeType(producerFieldBean, anns, "Annotated producer field: " + annotatedField + "must declare default @Scope annotation");
+ WebBeansUtil.checkProducerGenericType(producerFieldBean,annotatedField.getJavaMember());
+ DefinitionUtil.defineQualifiers(producerFieldBean, anns);
+ DefinitionUtil.defineName(producerFieldBean, anns, WebBeansUtil.getProducerDefaultName(annotatedField.getJavaMember().getName()));
+ }
+
+ producerBeans.add(producerFieldBean);
+ }
+ }
+
+ return producerBeans;
+ }
+
+
+ @SuppressWarnings("unchecked")
+ public static <X> Set<ProducerMethodBean<?>> defineProducerMethods(AbstractBean<X> bean, AnnotatedType<X> annotatedType)
+ {
+ Set<ProducerMethodBean<?>> producerBeans = new HashSet<ProducerMethodBean<?>>();
+ Set<AnnotatedMethod<? super X>> annotatedMethods = annotatedType.getMethods();
+
+ for(AnnotatedMethod<? super X> annotatedMethod: annotatedMethods)
+ {
+ if(annotatedMethod.isAnnotationPresent(Produces.class))
+ {
+ checkProducerMethodForDeployment(annotatedMethod);
+ boolean specialize = false;
+ if(annotatedMethod.isAnnotationPresent(Specializes.class))
+ {
+ if (annotatedMethod.isStatic())
+ {
+ throw new WebBeansConfigurationException("Specializing annotated producer method : " + annotatedMethod + " can not be static");
+ }
+
+ specialize = true;
+ }
+
+ ProducerMethodBean<X> producerMethodBean = new ProducerMethodBean<X>(bean, (Class<X>)ClassUtil.getClass(annotatedMethod.getBaseType()));
+ producerMethodBean.setCreatorMethod(annotatedMethod.getJavaMember());
+
+ if(specialize)
+ {
+ configureProducerSpecialization(producerMethodBean, (AnnotatedMethod<X>)annotatedMethod);
+ }
+
+ if (ClassUtil.isPrimitive(ClassUtil.getClass(annotatedMethod.getBaseType())))
+ {
+ producerMethodBean.setNullable(false);
+ }
+
+ DefinitionUtil.defineSerializable(producerMethodBean);
+ DefinitionUtil.defineStereoTypes(producerMethodBean, AnnotationUtil.getAnnotationsFromSet(annotatedMethod.getAnnotations()));
+ WebBeansUtil.setBeanEnableFlagForProducerBean(bean, producerMethodBean, AnnotationUtil.getAnnotationsFromSet(annotatedMethod.getAnnotations()));
+
+ Set<Type> types = annotatedMethod.getTypeClosure();
+ producerMethodBean.getTypes().addAll(types);
+ DefinitionUtil.defineScopeType(producerMethodBean, AnnotationUtil.getAnnotationsFromSet(annotatedMethod.getAnnotations()), "Annotated producer method : " + annotatedMethod + "must declare default @Scope annotation");
+ WebBeansUtil.checkProducerGenericType(producerMethodBean,annotatedMethod.getJavaMember());
+ DefinitionUtil.defineQualifiers(producerMethodBean, AnnotationUtil.getAnnotationsFromSet(annotatedMethod.getAnnotations()));
+ DefinitionUtil.defineName(producerMethodBean, AnnotationUtil.getAnnotationsFromSet(annotatedMethod.getAnnotations()), WebBeansUtil.getProducerDefaultName(annotatedMethod.getJavaMember().getName()));
+
+ addMethodInjectionPointMetaData(bean, annotatedMethod);
+ producerBeans.add(producerMethodBean);
+
+ }
+
+ }
+
+ return producerBeans;
+ }
+
+
+ /**
+ * Check producer method is ok for deployment.
+ *
+ * @param method producer method
+ * @param parentImplClazzName parent class name
+ */
+ public static <X> void checkProducerMethodForDeployment(AnnotatedMethod<X> annotatedMethod)
+ {
+ Asserts.assertNotNull(annotatedMethod, "annotatedMethod argument can not be null");
+
+ if (annotatedMethod.isAnnotationPresent(Inject.class) ||
+ annotatedMethod.isAnnotationPresent(Disposes.class) ||
+ annotatedMethod.isAnnotationPresent(Observes.class))
+ {
+ throw new WebBeansConfigurationException("Producer annotated method : " + annotatedMethod + " can not be annotated with" + " @Initializer/@Destructor annotation or has a parameter annotated with @Disposes/@Observes");
+ }
+ }
+
+
+ public static <X> void configureProducerSpecialization(AbstractBean<X> bean,AnnotatedMethod<X> annotatedMethod)
+ {
+ List<AnnotatedParameter<X>> annotatedParameters = annotatedMethod.getParameters();
+ List<Class<?>> parameters = new ArrayList<Class<?>>();
+ for(AnnotatedParameter<X> annotatedParam : annotatedParameters)
+ {
+ parameters.add(ClassUtil.getClass(annotatedParam.getBaseType()));
+ }
+
+ Method superMethod = ClassUtil.getClassMethodWithTypes(annotatedMethod.getDeclaringType().getJavaClass().getSuperclass(),
+ annotatedMethod.getJavaMember().getName(), parameters);
+ if (superMethod == null)
+ {
+ throw new WebBeansConfigurationException("Anontated producer method specialization is failed : " + annotatedMethod.getJavaMember().getName() + " not found in super class : " +
+ annotatedMethod.getDeclaringType().getJavaClass().getSuperclass().getName() + " for annotated method : " + annotatedMethod);
+ }
+
+ if (!AnnotationUtil.hasAnnotation(superMethod.getAnnotations(), Produces.class))
+ {
+ throw new WebBeansConfigurationException("Anontated producer method specialization is failed : " + annotatedMethod.getJavaMember().getName() + " found in super class : " +
+ annotatedMethod.getDeclaringType().getJavaClass().getSuperclass().getName() + " is not annotated with @Produces" + " for annotated method : " + annotatedMethod);
+ }
+
+ Annotation[] anns = AnnotationUtil.getQualifierAnnotations(superMethod.getAnnotations());
+
+ for (Annotation ann : anns)
+ {
+ bean.addQualifier(ann);
+ }
+
+ WebBeansUtil.configuredProducerSpecializedName(bean, annotatedMethod.getJavaMember(), superMethod);
+
+ bean.setSpecializedBean(true);
+ }
+
+ /**
+ * add the definitions for a @Initializer method.
+ */
+ private static <X> void checkForInjectedInitializerMethod(AbstractInjectionTargetBean<X> component, AnnotatedMethod<X> annotatedMethod)
+ {
+ Method method = annotatedMethod.getJavaMember();
+
+ TypeVariable<?>[] args = method.getTypeParameters();
+ if(args.length > 0)
+ {
+ throw new WebBeansConfigurationException("Error in defining injected methods in annotated method : " + annotatedMethod+
+ ". Reason : Initializer methods must not be generic.");
+ }
+
+ if (annotatedMethod.isAnnotationPresent(Produces.class))
+ {
+ throw new WebBeansConfigurationException("Error in defining injected methods in annotated method : " + annotatedMethod+
+ ". Reason : Initializer method can not be annotated with @Produces.");
+
+ }
+
+ List<AnnotatedParameter<X>> annotatedParameters = annotatedMethod.getParameters();
+ for (AnnotatedParameter<X> annotatedParameter : annotatedParameters)
+ {
+ WebBeansUtil.checkForNewQualifierForDeployment(annotatedParameter.getBaseType(), annotatedMethod.getDeclaringType().getJavaClass(),
+ method.getName(), AnnotationUtil.getAnnotationsFromSet(annotatedParameter.getAnnotations()));
+
+ if(annotatedParameter.isAnnotationPresent(Disposes.class) ||
+ annotatedParameter.isAnnotationPresent(Observes.class))
+ {
+ throw new WebBeansConfigurationException("Error in defining injected methods in annotated method : " + annotatedMethod+
+ ". Reason : Initializer method parameters does not contain @Observes or @Dispose annotations.");
+
+ }
+ }
+ }
+
+ /**
+ * CheckProducerMethodDisposal.
+ * @param disposalMethod disposal method
+ * @param definedBeanClassName bean class name
+ */
+ public static <X> void checkProducerMethodDisposal(AnnotatedMethod<X> annotatedMethod)
+ {
+ List<AnnotatedParameter<X>> parameters = annotatedMethod.getParameters();
+ boolean found = false;
+ for(AnnotatedParameter<X> parameter : parameters)
+ {
+ if(parameter.isAnnotationPresent(Disposes.class))
+ {
+ if(found)
+ {
+ throw new WebBeansConfigurationException("Error in definining disposal method of annotated method : " + annotatedMethod
+ + ". Multiple disposes annotation.");
+ }
+ else
+ {
+ found = true;
+ }
+ }
+ }
+
+ if(annotatedMethod.isAnnotationPresent(Inject.class)
+ || AnnotationUtil.hasAnnotatedMethodParameterAnnotation(annotatedMethod, Observes.class)
+ || annotatedMethod.isAnnotationPresent(Produces.class))
+ {
+ throw new WebBeansConfigurationException("Error in definining disposal method of annotated method : " + annotatedMethod
+ + ". Disposal methods can not be annotated with" + " @Initializer/@Destructor/@Produces annotation or has a parameter annotated with @Observes.");
+ }
+ }
+
+ public static <X> void checkObserverMethodConditions(AnnotatedMethod<X> annotatedMethod, Class<?> clazz)
+ {
+ Asserts.assertNotNull(annotatedMethod, "annotatedMethod parameter can not be null");
+ Asserts.nullCheckForClass(clazz);
+
+ Method candidateObserverMethod = annotatedMethod.getJavaMember();
+
+ if (AnnotationUtil.hasAnnotatedMethodMultipleParameterAnnotation(annotatedMethod, Observes.class))
+ {
+ throw new WebBeansConfigurationException("Observer method : " + candidateObserverMethod.getName() + " in class : " + clazz.getName() + " can not define two parameters with annotated @Observes");
+ }
+
+ if (annotatedMethod.isAnnotationPresent(Produces.class)
+ || annotatedMethod.isAnnotationPresent(Inject.class))
+ {
+ throw new WebBeansConfigurationException("Observer method : " + candidateObserverMethod.getName() + " in class : " + clazz.getName() + " can not annotated with annotation in the list {@Produces, @Initializer, @Destructor}");
+
+ }
+
+ if (AnnotationUtil.hasAnnotatedMethodParameterAnnotation(annotatedMethod, Disposes.class))
+ {
+ throw new WebBeansConfigurationException("Observer method : " + candidateObserverMethod.getName() + " in class : " + clazz.getName() + " can not annotated with annotation @Disposes");
+ }
+ }
+
+ /**
+ * Checks the implementation class for checking conditions.
+ *
+ * @param clazz implementation class
+ * @throws WebBeansConfigurationException if any configuration exception occurs
+ */
+ public static <X> void checkManagedBeanCondition(AnnotatedType<X> type) throws WebBeansConfigurationException
+ {
+ int modifier = type.getJavaClass().getModifiers();
+
+ if (type.isAnnotationPresent(Decorator.class) && type.isAnnotationPresent(Interceptor.class))
+ {
+ throw new WebBeansConfigurationException("Annotated type "+ type + " may not annotated with both @Interceptor and @Decorator annotation");
+ }
+
+ if (!type.isAnnotationPresent(Decorator.class) && !type.isAnnotationPresent(Interceptor.class))
+ {
+ checkManagedWebBeansInterceptorConditions(type);
+ }
+
+ if (ClassUtil.isInterface(modifier))
+ {
+ throw new WebBeansConfigurationException("ManagedBean implementation class : " + type.getJavaClass().getName() + " may not defined as interface");
+ }
+ }
+
+ public static <X> void checkManagedWebBeansInterceptorConditions(AnnotatedType<X> type)
+ {
+ Annotation[] anns = AnnotationUtil.getAnnotationsFromSet(type.getAnnotations());
+
+ Class<?> clazz = type.getJavaClass();
+ boolean hasClassInterceptors = false;
+ if (AnnotationUtil.getInterceptorBindingMetaAnnotations(anns).length > 0)
+ {
+ hasClassInterceptors = true;
+ }
+ else
+ {
+ Annotation[] stereoTypes = AnnotationUtil.getStereotypeMetaAnnotations(anns);
+ for (Annotation stero : stereoTypes)
+ {
+ if (AnnotationUtil.hasInterceptorBindingMetaAnnotation(stero.annotationType().getDeclaredAnnotations()))
+ {
+ hasClassInterceptors = true;
+ break;
+ }
+ }
+ }
+
+ if(ClassUtil.isFinal(clazz.getModifiers()) && hasClassInterceptors)
+ {
+ throw new WebBeansConfigurationException("Final managed bean class with name : " + clazz.getName() + " can not define any InterceptorBindings");
+ }
+
+ Set<AnnotatedMethod<? super X>> methods = type.getMethods();
+ for(AnnotatedMethod<? super X> methodA : methods)
+ {
+ Method method = methodA.getJavaMember();
+ int modifiers = method.getModifiers();
+ if (!ClassUtil.isStatic(modifiers) && !ClassUtil.isPrivate(modifiers) && ClassUtil.isFinal(modifiers))
+ {
+ if (hasClassInterceptors)
+ {
+ throw new WebBeansConfigurationException("Maanged bean class : " + clazz.getName() + " can not define non-static, non-private final methods. Because it is annotated with at least one @InterceptorBinding");
+ }
+ else
+ {
+ if (AnnotationUtil.hasInterceptorBindingMetaAnnotation(AnnotationUtil.getAnnotationsFromSet(methodA.getAnnotations())))
+ {
+ throw new WebBeansConfigurationException("Method : " + method.getName() + "in managed bean class : " + clazz.getName() + " can not be defined as non-static, non-private and final . Because it is annotated with at least one @InterceptorBinding");
+ }
+ }
+ }
+
+ }
+ }
+
+ public static <T> ManagedBean<T> defineManagedBean(AnnotatedType<T> type)
+ {
+ Class<T> clazz = type.getJavaClass();
+
+ ManagedBean<T> managedBean = new ManagedBean<T>(clazz,WebBeansType.MANAGED);
+ AnnotatedTypeBeanCreatorImpl<T> managedBeanCreator = new AnnotatedTypeBeanCreatorImpl<T>(managedBean);
+ managedBeanCreator.setAnnotatedType(type);
+
+ 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));
+ managedBeanCreator.checkCreateConditions();
+
+ //Check for Enabled via Alternative
+ WebBeansUtil.setBeanEnableFlag(managedBean);
+
+ managedBeanCreator.defineApiType();
+ managedBeanCreator.defineQualifier();
+ managedBeanCreator.defineName(WebBeansUtil.getManagedBeanDefaultName(clazz.getSimpleName()));
+ managedBeanCreator.defineConstructor();
+ managedBeanCreator.defineProducerMethods();
+ managedBeanCreator.defineProducerFields();
+ managedBeanCreator.defineInjectedFields();
+ managedBeanCreator.defineInjectedMethods();
+ managedBeanCreator.defineDecoratorStack();
+ managedBeanCreator.defineInterceptorStack();
+ managedBeanCreator.defineObserverMethods();
+
+
+ DecoratorUtil.checkManagedBeanDecoratorConditions(managedBean);
+ managedBeanCreator.defineDisposalMethods();//Define disposal method after adding producers
+
+ return managedBean;
+ }
+
+
+}
Propchange: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/WebBeansAnnotatedTypeUtil.java
------------------------------------------------------------------------------
svn:eol-style = native
Modified: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/WebBeansUtil.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/WebBeansUtil.java?rev=907247&r1=907246&r2=907247&view=diff
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/WebBeansUtil.java (original)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/util/WebBeansUtil.java Sat Feb 6 16:25:29 2010
@@ -1235,7 +1235,7 @@
return false;
}
- public static String getSimpleWebBeanDefaultName(String clazzName)
+ public static String getManagedBeanDefaultName(String clazzName)
{
Asserts.assertNotNull(clazzName);
Modified: openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/xml/WebBeansXMLConfigurator.java
URL: http://svn.apache.org/viewvc/openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/xml/WebBeansXMLConfigurator.java?rev=907247&r1=907246&r2=907247&view=diff
==============================================================================
--- openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/xml/WebBeansXMLConfigurator.java (original)
+++ openwebbeans/trunk/webbeans-impl/src/main/java/org/apache/webbeans/xml/WebBeansXMLConfigurator.java Sat Feb 6 16:25:29 2010
@@ -1519,12 +1519,12 @@
}
else
{
- component.setName(WebBeansUtil.getSimpleWebBeanDefaultName(component.getReturnType().getName()));
+ component.setName(WebBeansUtil.getManagedBeanDefaultName(component.getReturnType().getName()));
}
}
else
{
- DefinitionUtil.defineName(component, component.getReturnType().getDeclaredAnnotations(), WebBeansUtil.getSimpleWebBeanDefaultName(component.getReturnType().getSimpleName()));
+ DefinitionUtil.defineName(component, component.getReturnType().getDeclaredAnnotations(), WebBeansUtil.getManagedBeanDefaultName(component.getReturnType().getSimpleName()));
}
}