[weld-commits] Weld SVN: r6783 - in extensions/trunk/impl/src/main/java/org/jboss/weld/extensions: bean/generic and 2 other directories.
weld-commits at lists.jboss.org
weld-commits at lists.jboss.org
Fri Jul 23 17:42:52 EDT 2010
Author: pete.muir at jboss.org
Date: 2010-07-23 17:42:50 -0400 (Fri, 23 Jul 2010)
New Revision: 6783
Added:
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanExtension.java
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/SyntheticQualifierManager.java
Removed:
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/FieldSetter.java
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericExtension.java
Modified:
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/annotated/AnnotatedTypeBuilder.java
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/ProducerFieldInjectionTarget.java
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInstanceProvider.java
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInvocationHandler.java
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/FieldPropertyImpl.java
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/MethodPropertyImpl.java
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Properties.java
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Property.java
Log:
Initial refactor of GenericBean onto Property
Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/annotated/AnnotatedTypeBuilder.java
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/annotated/AnnotatedTypeBuilder.java 2010-07-23 21:41:46 UTC (rev 6782)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/annotated/AnnotatedTypeBuilder.java 2010-07-23 21:42:50 UTC (rev 6783)
@@ -100,7 +100,7 @@
typeAnnotations.add(annotation);
}
- for (Field field : Reflections.getFields(underlyingType))
+ for (Field field : Reflections.getAllFields(underlyingType))
{
AnnotationBuilder annotationBuilder = new AnnotationBuilder();
fields.put(field, annotationBuilder);
@@ -111,7 +111,7 @@
}
}
- for (Method method : Reflections.getMethods(underlyingType))
+ for (Method method : Reflections.getAllMethods(underlyingType))
{
AnnotationBuilder annotationBuilder = new AnnotationBuilder();
method.setAccessible(true);
Deleted: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/FieldSetter.java
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/FieldSetter.java 2010-07-23 21:41:46 UTC (rev 6782)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/FieldSetter.java 2010-07-23 21:42:50 UTC (rev 6783)
@@ -1,69 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source
- * Copyright 2010, Red Hat, Inc., and individual contributors
- * by the @authors tag. See the copyright.txt in the distribution for a
- * full listing of individual contributors.
- *
- * Licensed 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.jboss.weld.extensions.bean.generic;
-
-import java.lang.reflect.Field;
-
-import javax.enterprise.context.spi.CreationalContext;
-import javax.enterprise.inject.UnsatisfiedResolutionException;
-import javax.enterprise.inject.spi.Bean;
-import javax.enterprise.inject.spi.BeanManager;
-
-/**
- * Class that is responsible for setting the values of generic producer fields
- *
- * @author Stuart Douglas <stuart at baileyroberts.com.au>
- *
- */
-class FieldSetter
-{
- private final Field field;
- private final SyntheticQualifier qualifier;
- private final BeanManager beanManager;
-
- FieldSetter(BeanManager beanManager, Field field, SyntheticQualifier qualifier)
- {
- this.field = field;
- this.field.setAccessible(true);
- this.qualifier = qualifier;
- this.beanManager = beanManager;
- }
-
- public void set(Object instance, CreationalContext<?> ctx)
- {
- Bean<?> bean = beanManager.resolve(beanManager.getBeans(field.getType(), qualifier));
- if (bean == null)
- {
- throw new UnsatisfiedResolutionException("Could not resolve bean for Generic Producer field " + field.getDeclaringClass() + "." + field.getName() + " Type: " + field.getType() + " Qualifiers:" + qualifier);
- }
- Object value = beanManager.getReference(bean, field.getType(), ctx);
- try
- {
- field.set(instance, value);
- }
- catch (IllegalArgumentException e)
- {
- throw new RuntimeException(e);
- }
- catch (IllegalAccessException e)
- {
- throw new RuntimeException(e);
- }
-
- }
-
-}
Copied: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanExtension.java (from rev 6772, extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericExtension.java)
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanExtension.java (rev 0)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanExtension.java 2010-07-23 21:42:50 UTC (rev 6783)
@@ -0,0 +1,299 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2010, Red Hat, Inc., and individual contributors
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * Licensed 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.jboss.weld.extensions.bean.generic;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Member;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+
+import javax.enterprise.event.Observes;
+import javax.enterprise.inject.Produces;
+import javax.enterprise.inject.spi.AfterBeanDiscovery;
+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.BeanManager;
+import javax.enterprise.inject.spi.BeforeBeanDiscovery;
+import javax.enterprise.inject.spi.Extension;
+import javax.enterprise.inject.spi.InjectionTarget;
+import javax.enterprise.inject.spi.ProcessAnnotatedType;
+import javax.enterprise.inject.spi.ProcessInjectionTarget;
+import javax.inject.Inject;
+
+import org.jboss.weld.extensions.annotated.AnnotatedTypeBuilder;
+import org.jboss.weld.extensions.bean.BeanBuilder;
+import org.jboss.weld.extensions.util.properties.Properties;
+import org.jboss.weld.extensions.util.properties.Property;
+
+/**
+ * Extension that wires in Generic Beans
+ *
+ * @author Pete Muir
+ * @author Stuart Douglas <stuart at baileyroberts.com.au>
+ *
+ */
+class GenericBeanExtension implements Extension
+{
+
+ private final Map<Class<?>, Set<AnnotatedType<?>>> genericBeans;
+
+ private final Map<Class<?>, Map<Member, Annotation>> producerFields;
+
+ // A map of a generic annotation type to all instances of that type found on beans
+ private final Map<Class<?>, Set<Annotation>> concreteGenerics;
+
+ private final SyntheticQualifierManager syntheticQualifierManager;
+
+ GenericBeanExtension()
+ {
+ this.genericBeans = new HashMap<Class<?>, Set<AnnotatedType<?>>>();
+ this.producerFields = new HashMap<Class<?>, Map<Member, Annotation>>();
+ this.concreteGenerics = new HashMap<Class<?>, Set<Annotation>>();
+ this.syntheticQualifierManager = new SyntheticQualifierManager();
+ }
+
+ void beforeBeanDiscovery(@Observes BeforeBeanDiscovery event)
+ {
+ event.addQualifier(SyntheticQualifier.class);
+ }
+
+ void processAnnotatedType(@Observes ProcessAnnotatedType<?> event)
+ {
+ AnnotatedType<?> type = event.getAnnotatedType();
+ if (type.isAnnotationPresent(Generic.class))
+ {
+ Generic generic = type.getAnnotation(Generic.class);
+ if (!genericBeans.containsKey(generic.value()))
+ {
+ genericBeans.put(generic.value(), new HashSet<AnnotatedType<?>>());
+ }
+ genericBeans.get(generic.value()).add(type);
+ // we will install (multiple copies of) this bean later
+ event.veto();
+
+ }
+ // make note of any producer fields that produce generic beans
+ for (AnnotatedField<?> field : type.getFields())
+ {
+ if (field.isAnnotationPresent(Produces.class))
+ {
+ for (Annotation annotation : field.getAnnotations())
+ {
+ if (annotation.annotationType().isAnnotationPresent(GenericAnnotation.class))
+ {
+ if (!producerFields.containsKey(type.getJavaClass()))
+ {
+ producerFields.put(type.getJavaClass(), new HashMap<Member, Annotation>());
+ }
+ if (!concreteGenerics.containsKey(annotation.annotationType()))
+ {
+ concreteGenerics.put(annotation.annotationType(), new HashSet<Annotation>());
+ }
+ producerFields.get(type.getJavaClass()).put(field.getJavaMember(), annotation);
+ concreteGenerics.get(annotation.annotationType()).add(annotation);
+ }
+ }
+ }
+ }
+
+ // make note of any producer method that produce generic beans
+ for (AnnotatedMethod<?> method : type.getMethods())
+ {
+ if (method.isAnnotationPresent(Produces.class))
+ {
+ for (Annotation annotation : method.getAnnotations())
+ {
+ if (annotation.annotationType().isAnnotationPresent(GenericAnnotation.class))
+ {
+ if (!producerFields.containsKey(type.getJavaClass()))
+ {
+ producerFields.put(type.getJavaClass(), new HashMap<Member, Annotation>());
+ }
+ if (!concreteGenerics.containsKey(annotation.annotationType()))
+ {
+ concreteGenerics.put(annotation.annotationType(), new HashSet<Annotation>());
+ }
+ producerFields.get(type.getJavaClass()).put(method.getJavaMember(), annotation);
+ concreteGenerics.get(annotation.annotationType()).add(annotation);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * wraps InjectionTarget to initialise producer fields that produce generic
+ * beans
+ */
+ <T> void processInjectionTarget(@Observes ProcessInjectionTarget<T> event, BeanManager beanManager)
+ {
+ Class<?> javaClass = event.getAnnotatedType().getJavaClass();
+ if (producerFields.containsKey(javaClass))
+ {
+ Map<Member, Annotation> producers = producerFields.get(javaClass);
+ List<Property<Object>> setters = new ArrayList<Property<Object>>();
+ for (Member field : producers.keySet())
+ {
+ Property<Object> property = Properties.createProperty(field);
+ setters.add(property);
+ }
+ ProducerFieldInjectionTarget<T> it = new ProducerFieldInjectionTarget<T>(event.getInjectionTarget(), beanManager, setters, producers, syntheticQualifierManager);
+ event.setInjectionTarget(it);
+ }
+
+ }
+
+ /**
+ * Installs the generic beans.
+ */
+ public void afterBeanDiscovery(@Observes AfterBeanDiscovery abd, BeanManager beanManager)
+ {
+ for (Entry<Class<?>, Set<AnnotatedType<?>>> entry : genericBeans.entrySet())
+ {
+ Set<Annotation> concretes = concreteGenerics.get(entry.getKey());
+ if (concretes != null)
+ {
+ for (AnnotatedType<?> type : entry.getValue())
+ {
+ for (Annotation conc : concretes)
+ {
+ abd.addBean(redefineType(type, conc, beanManager));
+ }
+ }
+ }
+ }
+ }
+
+ private <X> Bean<X> redefineType(AnnotatedType<X> at, Annotation conc, BeanManager beanManager)
+ {
+ SyntheticQualifier newQualifier = syntheticQualifierManager.getQualifierForGeneric(conc);
+
+ AnnotatedTypeBuilder<X> builder = AnnotatedTypeBuilder.newInstance(at).readAnnotationsFromUnderlyingType();
+ builder.addToClass(newQualifier);
+ for (AnnotatedField<? super X> f : at.getFields())
+ {
+ if (f.isAnnotationPresent(Inject.class))
+ {
+ // if this is a configuration injection point
+ if (conc.annotationType().isAssignableFrom(f.getJavaMember().getType()))
+ {
+ builder.removeFromField(f.getJavaMember(), Inject.class);
+ builder.addToField(f.getJavaMember(), InjectConfiguration.INSTANCE);
+ }
+ else
+ {
+ // check to see if we should be injecting a generic bean
+ // we do this by checking if there are any beans that can be
+ // injected into this point
+ // if there is not then we assume it is a generic injection
+ // point
+ // this has the downside that if it is actually a deployment
+ // error then it will confuse the user
+ Annotation[] qls = getQualifiers(f.getAnnotations(), beanManager);
+ Set<Bean<?>> beans = beanManager.getBeans(f.getJavaMember().getType(), qls);
+ if (beans.isEmpty())
+ {
+ builder.addToField(f.getJavaMember(), newQualifier);
+ }
+ }
+ }
+ else if (f.isAnnotationPresent(Produces.class))
+ {
+ // TODO: register a producer with the appropriate qualifier
+ }
+ }
+ for (AnnotatedMethod<?> m : at.getMethods())
+ {
+ // TODO: need to properly handle Observer methods and Disposal
+ // methods
+ if (m.isAnnotationPresent(Produces.class))
+ {
+ // TODO: we need to register the producer bean, so this is not
+ // very useful at the moment
+ for (AnnotatedParameter<?> pm : m.getParameters())
+ {
+ Class<?> paramType = m.getJavaMember().getParameterTypes()[pm.getPosition()];
+
+ // check to see if we should be injecting a generic bean
+ // we do this by checking if there are any beans that can be
+ // injected into this point
+ // if there is not then we assume it is a generic injection
+ // point
+ // this has the downside that if it is actually a deployment
+ // error then it will confuse the user
+ Annotation[] qls = getQualifiers(pm.getAnnotations(), beanManager);
+ Set<Bean<?>> beans = beanManager.getBeans(paramType, qls);
+ if (beans.isEmpty())
+ {
+ builder.addToMethod(m.getJavaMember(), newQualifier);
+ }
+ }
+ }
+ }
+
+ for (AnnotatedConstructor<X> m : at.getConstructors())
+ {
+ if (m.isAnnotationPresent(Inject.class))
+ {
+ for (AnnotatedParameter<X> pm : m.getParameters())
+ {
+ Class<?> paramType = m.getJavaMember().getParameterTypes()[pm.getPosition()];
+ Annotation[] qls = getQualifiers(pm.getAnnotations(), beanManager);
+ Set<Bean<?>> beans = beanManager.getBeans(paramType, qls);
+ if (beans.isEmpty())
+ {
+ builder.addToConstructorParameter(m.getJavaMember(), pm.getPosition(), newQualifier);
+ }
+ }
+ }
+ }
+ AnnotatedType<X> newAnnotatedType = builder.create();
+ InjectionTarget<X> it = beanManager.createInjectionTarget(newAnnotatedType);
+
+ it = new GenericBeanInjectionTargetWrapper<X>(newAnnotatedType, it, conc);
+ BeanBuilder<X> beanBuilder = new BeanBuilder<X>(newAnnotatedType, beanManager).defineBeanFromAnnotatedType().setInjectionTarget(it);
+ return beanBuilder.create();
+ }
+
+ static Annotation[] getQualifiers(Set<Annotation> annotations, BeanManager manager)
+ {
+ List<Annotation> qualifiers = new ArrayList<Annotation>();
+ for (Annotation a : annotations)
+ {
+ if (manager.isQualifier(a.annotationType()))
+ {
+ qualifiers.add(a);
+ }
+ }
+ Annotation[] qls = new Annotation[qualifiers.size()];
+ for (int j = 0; j < qls.length; ++j)
+ {
+ qls[j] = qualifiers.get(j);
+ }
+ return qls;
+ }
+
+}
Deleted: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericExtension.java
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericExtension.java 2010-07-23 21:41:46 UTC (rev 6782)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericExtension.java 2010-07-23 21:42:50 UTC (rev 6783)
@@ -1,280 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source
- * Copyright 2010, Red Hat, Inc., and individual contributors
- * by the @authors tag. See the copyright.txt in the distribution for a
- * full listing of individual contributors.
- *
- * Licensed 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.jboss.weld.extensions.bean.generic;
-
-import java.lang.annotation.Annotation;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.Map.Entry;
-
-import javax.enterprise.event.Observes;
-import javax.enterprise.inject.Produces;
-import javax.enterprise.inject.spi.AfterBeanDiscovery;
-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.BeanManager;
-import javax.enterprise.inject.spi.BeforeBeanDiscovery;
-import javax.enterprise.inject.spi.Extension;
-import javax.enterprise.inject.spi.InjectionTarget;
-import javax.enterprise.inject.spi.ProcessAnnotatedType;
-import javax.enterprise.inject.spi.ProcessInjectionTarget;
-import javax.inject.Inject;
-
-import org.jboss.weld.extensions.annotated.AnnotatedTypeBuilder;
-import org.jboss.weld.extensions.bean.BeanBuilder;
-import org.jboss.weld.extensions.util.AnnotationInstanceProvider;
-
-public class GenericExtension implements Extension
-{
-
- private AnnotationInstanceProvider annotationProvider = new AnnotationInstanceProvider();
-
- private Map<Class<?>, Set<AnnotatedType<?>>> genericBeans = new HashMap<Class<?>, Set<AnnotatedType<?>>>();
-
- private Map<Class<?>, Map<AnnotatedField<?>, Annotation>> producerFields = new HashMap<Class<?>, Map<AnnotatedField<?>, Annotation>>();
-
- /**
- * map of a generic annotation type to all instances of that type found on
- * beans
- */
- private Map<Class<?>, Set<Annotation>> concreteGenerics = new HashMap<Class<?>, Set<Annotation>>();
-
- /**
- * Map of generic Annotation instance to a SyntheticQualifier
- */
- private Map<Annotation, SyntheticQualifier> qualifierMap = new HashMap<Annotation, SyntheticQualifier>();
-
- long count = 0;
-
- public void beforeBeanDiscovery(@Observes BeforeBeanDiscovery event)
- {
- event.addQualifier(SyntheticQualifier.class);
- }
-
- public void processAnnotatedType(@Observes ProcessAnnotatedType<?> event)
- {
- AnnotatedType<?> type = event.getAnnotatedType();
- if (type.isAnnotationPresent(Generic.class))
- {
- Generic an = type.getAnnotation(Generic.class);
- if (!genericBeans.containsKey(an.value()))
- {
- genericBeans.put(an.value(), new HashSet<AnnotatedType<?>>());
- }
- genericBeans.get(an.value()).add(type);
- // we will install (multiple copies of) this bean later
- event.veto();
-
- }
- // make note of any producer fields that produce generic beans
- for (Object f : type.getFields())
- {
- AnnotatedField<?> field = (AnnotatedField<?>) f;
- if (field.isAnnotationPresent(Produces.class))
- {
- for (Annotation a : field.getAnnotations())
- {
- if (a.annotationType().isAnnotationPresent(GenericAnnotation.class))
- {
- if (!producerFields.containsKey(type.getJavaClass()))
- {
- producerFields.put(type.getJavaClass(), new HashMap<AnnotatedField<?>, Annotation>());
- }
- if (!concreteGenerics.containsKey(a.annotationType()))
- {
- concreteGenerics.put(a.annotationType(), new HashSet<Annotation>());
- }
- producerFields.get(type.getJavaClass()).put(field, a);
- concreteGenerics.get(a.annotationType()).add(a);
- }
- }
- }
- }
- }
-
- /**
- * wraps InjectionTarget to initialise producer fields that produce generic
- * beans
- */
- public <T> void processInjectionTarget(@Observes ProcessInjectionTarget<T> event, BeanManager beanManager)
- {
- Class<?> javaClass = event.getAnnotatedType().getJavaClass();
- if (producerFields.containsKey(javaClass))
- {
- Map<AnnotatedField<?>, Annotation> producers = producerFields.get(javaClass);
- List<FieldSetter> setters = new ArrayList<FieldSetter>();
- for (AnnotatedField<?> a : producers.keySet())
- {
- SyntheticQualifier qual = this.getQualifierForGeneric(producers.get(a));
- FieldSetter f = new FieldSetter(beanManager, a.getJavaMember(), qual);
- setters.add(f);
- }
- ProducerFieldInjectionTarget<T> it = new ProducerFieldInjectionTarget<T>(event.getInjectionTarget(), setters);
- event.setInjectionTarget(it);
- }
- }
-
- /**
- * Installs the generic beans.
- */
- public void afterBeanDiscovery(@Observes AfterBeanDiscovery abd, BeanManager beanManager)
- {
- for (Entry<Class<?>, Set<AnnotatedType<?>>> entry : genericBeans.entrySet())
- {
- Set<Annotation> concretes = concreteGenerics.get(entry.getKey());
- if (concretes != null)
- {
- for (AnnotatedType<?> type : entry.getValue())
- {
- for (Annotation conc : concretes)
- {
- abd.addBean(redefineType(type, conc, beanManager));
- }
- }
- }
- }
- }
-
- private <X> Bean<X> redefineType(AnnotatedType<X> at, Annotation conc, BeanManager beanManager)
- {
- SyntheticQualifier newQualifier = getQualifierForGeneric(conc);
-
- AnnotatedTypeBuilder<X> builder = AnnotatedTypeBuilder.newInstance(at).readAnnotationsFromUnderlyingType();
- builder.addToClass(newQualifier);
- for (AnnotatedField<? super X> f : at.getFields())
- {
- if (f.isAnnotationPresent(Inject.class))
- {
- // if this is a configuration injection point
- if (conc.annotationType().isAssignableFrom(f.getJavaMember().getType()))
- {
- builder.removeFromField(f.getJavaMember(), Inject.class);
- builder.addToField(f.getJavaMember(), InjectConfiguration.INSTANCE);
- }
- else
- {
- // check to see if we should be injecting a generic bean
- // we do this by checking if there are any beans that can be
- // injected into this point
- // if there is not then we assume it is a generic injection
- // point
- // this has the downside that if it is actually a deployment
- // error then it will confuse the user
- Annotation[] qls = getQualifiers(f.getAnnotations(), beanManager);
- Set<Bean<?>> beans = beanManager.getBeans(f.getJavaMember().getType(), qls);
- if (beans.isEmpty())
- {
- builder.addToField(f.getJavaMember(), newQualifier);
- }
- }
- }
- else if (f.isAnnotationPresent(Produces.class))
- {
- // TODO: register a producer with the appropriate qualifier
- }
- }
- for (AnnotatedMethod<?> m : at.getMethods())
- {
- // TODO: need to properly handle Observer methods and Disposal
- // methods
- if (m.isAnnotationPresent(Produces.class))
- {
- // TODO: we need to register the producer bean, so this is not
- // very useful at the moment
- for (AnnotatedParameter<?> pm : m.getParameters())
- {
- Class<?> paramType = m.getJavaMember().getParameterTypes()[pm.getPosition()];
-
- // check to see if we should be injecting a generic bean
- // we do this by checking if there are any beans that can be
- // injected into this point
- // if there is not then we assume it is a generic injection
- // point
- // this has the downside that if it is actually a deployment
- // error then it will confuse the user
- Annotation[] qls = getQualifiers(pm.getAnnotations(), beanManager);
- Set<Bean<?>> beans = beanManager.getBeans(paramType, qls);
- if (beans.isEmpty())
- {
- builder.addToMethod(m.getJavaMember(), newQualifier);
- }
- }
- }
- }
-
- for (AnnotatedConstructor<X> m : at.getConstructors())
- {
- if (m.isAnnotationPresent(Inject.class))
- {
- for (AnnotatedParameter<X> pm : m.getParameters())
- {
- Class<?> paramType = m.getJavaMember().getParameterTypes()[pm.getPosition()];
- Annotation[] qls = getQualifiers(pm.getAnnotations(), beanManager);
- Set<Bean<?>> beans = beanManager.getBeans(paramType, qls);
- if (beans.isEmpty())
- {
- builder.addToConstructorParameter(m.getJavaMember(), pm.getPosition(), newQualifier);
- }
- }
- }
- }
- AnnotatedType<X> newAnnotatedType = builder.create();
- InjectionTarget<X> it = beanManager.createInjectionTarget(newAnnotatedType);
-
- it = new GenericBeanInjectionTargetWrapper<X>(newAnnotatedType, it, conc);
- BeanBuilder<X> beanBuilder = new BeanBuilder<X>(newAnnotatedType, beanManager).defineBeanFromAnnotatedType().setInjectionTarget(it);
- return beanBuilder.create();
- }
-
- public SyntheticQualifier getQualifierForGeneric(Annotation a)
- {
- if (!qualifierMap.containsKey(a))
- {
- SyntheticQualifier qualifier = annotationProvider.get(SyntheticQualifier.class, (Map) Collections.singletonMap("value", count++));
- qualifierMap.put(a, qualifier);
- }
- return qualifierMap.get(a);
- }
-
- static Annotation[] getQualifiers(Set<Annotation> annotations, BeanManager manager)
- {
- List<Annotation> qualifiers = new ArrayList<Annotation>();
- for (Annotation a : annotations)
- {
- if (manager.isQualifier(a.annotationType()))
- {
- qualifiers.add(a);
- }
- }
- Annotation[] qls = new Annotation[qualifiers.size()];
- for (int j = 0; j < qls.length; ++j)
- {
- qls[j] = qualifiers.get(j);
- }
- return qls;
- }
-
-}
Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/ProducerFieldInjectionTarget.java
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/ProducerFieldInjectionTarget.java 2010-07-23 21:41:46 UTC (rev 6782)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/ProducerFieldInjectionTarget.java 2010-07-23 21:42:50 UTC (rev 6783)
@@ -16,12 +16,19 @@
*/
package org.jboss.weld.extensions.bean.generic;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Member;
import java.util.List;
+import java.util.Map;
import javax.enterprise.context.spi.CreationalContext;
+import javax.enterprise.inject.UnsatisfiedResolutionException;
+import javax.enterprise.inject.spi.Bean;
+import javax.enterprise.inject.spi.BeanManager;
import javax.enterprise.inject.spi.InjectionTarget;
import org.jboss.weld.extensions.bean.ForwardingInjectionTarget;
+import org.jboss.weld.extensions.util.properties.Property;
/**
* {@link InjectionTarget} wrapper used for beans that have generic producer fields
@@ -33,12 +40,19 @@
public class ProducerFieldInjectionTarget<T> extends ForwardingInjectionTarget<T>
{
private final InjectionTarget<T> delegate;
- private final List<FieldSetter> fieldSetters;
+
+ private final BeanManager beanManager;
+ private final List<Property<Object>> properties;
+ private final Map<Member, Annotation> producers;
+ private final SyntheticQualifierManager syntheticQualifierManager;
- public ProducerFieldInjectionTarget(InjectionTarget<T> delegate, List<FieldSetter> fieldSetters)
+ public ProducerFieldInjectionTarget(InjectionTarget<T> delegate, BeanManager beanManager, List<Property<Object>> properties, Map<Member, Annotation> producers, SyntheticQualifierManager syntheticQualifierManager)
{
this.delegate = delegate;
- this.fieldSetters = fieldSetters;
+ this.beanManager = beanManager;
+ this.properties = properties;
+ this.producers = producers;
+ this.syntheticQualifierManager = syntheticQualifierManager;
}
@Override
@@ -50,9 +64,16 @@
@Override
public void inject(T instance, CreationalContext<T> ctx)
{
- for (FieldSetter f : fieldSetters)
+ for (Property<Object> property: properties)
{
- f.set(instance, ctx);
+ SyntheticQualifier qualifier = syntheticQualifierManager.getQualifierForGeneric(producers.get(property.getMember()));
+ Bean<?> bean = beanManager.resolve(beanManager.getBeans(property.getBaseType(), qualifier));
+ if (bean == null)
+ {
+ throw new UnsatisfiedResolutionException("Could not resolve bean for Generic Producer " + property.toString() + ". Type: " + property.getJavaClass() + " Qualifiers:" + qualifier);
+ }
+ Object value = beanManager.getReference(bean, property.getBaseType(), ctx);
+ property.setValue(instance, value);
}
delegate().inject(instance, ctx);
}
Added: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/SyntheticQualifierManager.java
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/SyntheticQualifierManager.java (rev 0)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/SyntheticQualifierManager.java 2010-07-23 21:42:50 UTC (rev 6783)
@@ -0,0 +1,38 @@
+package org.jboss.weld.extensions.bean.generic;
+
+import java.lang.annotation.Annotation;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.jboss.weld.extensions.util.AnnotationInstanceProvider;
+
+class SyntheticQualifierManager
+{
+
+
+ private final AnnotationInstanceProvider annotationProvider;
+
+ //Map of generic Annotation instance to a SyntheticQualifier
+ private final Map<Annotation, SyntheticQualifier> qualifierMap;
+
+ private long count;
+
+ SyntheticQualifierManager()
+ {
+ this.qualifierMap = new HashMap<Annotation, SyntheticQualifier>();
+ this.annotationProvider = new AnnotationInstanceProvider();
+ this.count = 0;
+ }
+
+ SyntheticQualifier getQualifierForGeneric(Annotation annotation)
+ {
+ if (!qualifierMap.containsKey(annotation))
+ {
+ SyntheticQualifier qualifier = annotationProvider.get(SyntheticQualifier.class, Collections.singletonMap("value", count++));
+ qualifierMap.put(annotation, qualifier);
+ }
+ return qualifierMap.get(annotation);
+ }
+
+}
Property changes on: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/SyntheticQualifierManager.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Name: svn:eol-style
+ native
Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInstanceProvider.java
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInstanceProvider.java 2010-07-23 21:41:46 UTC (rev 6782)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInstanceProvider.java 2010-07-23 21:42:50 UTC (rev 6783)
@@ -46,7 +46,7 @@
* Returns an instance of the given annotation type with member values
* specified in the map.
*/
- public <T extends Annotation> T get(Class<T> annotation, Map<String, Object> values)
+ public <T extends Annotation> T get(Class<T> annotation, Map<String, ?> values)
{
if (annotation == null)
{
Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInvocationHandler.java
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInvocationHandler.java 2010-07-23 21:41:46 UTC (rev 6782)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/AnnotationInvocationHandler.java 2010-07-23 21:42:50 UTC (rev 6783)
@@ -57,10 +57,10 @@
private static class SerializationProxy
{
- private final Map<String, Object> valueMap;
+ private final Map<String, ?> valueMap;
private final Class<? extends Annotation> annotationType;
- private SerializationProxy(Map<String, Object> valueMap, Class<? extends Annotation> annotationType)
+ private SerializationProxy(Map<String, ?> valueMap, Class<? extends Annotation> annotationType)
{
this.valueMap = valueMap;
this.annotationType = annotationType;
@@ -81,7 +81,7 @@
private final Method[] members;
- AnnotationInvocationHandler(Map<String, Object> values, Class<? extends Annotation> annotationType)
+ AnnotationInvocationHandler(Map<String, ?> values, Class<? extends Annotation> annotationType)
{
this.valueMap = new HashMap<String, Object>();
valueMap.putAll(values);
Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/FieldPropertyImpl.java
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/FieldPropertyImpl.java 2010-07-23 21:41:46 UTC (rev 6782)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/FieldPropertyImpl.java 2010-07-23 21:42:50 UTC (rev 6783)
@@ -4,6 +4,7 @@
package org.jboss.weld.extensions.util.properties;
import java.lang.reflect.Field;
+import java.lang.reflect.Member;
import java.lang.reflect.Type;
/**
@@ -46,6 +47,11 @@
{
return field;
}
+
+ public Member getMember()
+ {
+ return field;
+ }
@SuppressWarnings("unchecked")
public Class<V> getJavaClass()
@@ -100,4 +106,22 @@
{
return false;
}
+
+ @Override
+ public String toString()
+ {
+ return field.toString();
+ }
+
+ @Override
+ public int hashCode()
+ {
+ return field.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object obj)
+ {
+ return field.equals(obj);
+ }
}
\ No newline at end of file
Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/MethodPropertyImpl.java
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/MethodPropertyImpl.java 2010-07-23 21:41:46 UTC (rev 6782)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/MethodPropertyImpl.java 2010-07-23 21:42:50 UTC (rev 6783)
@@ -3,8 +3,10 @@
*/
package org.jboss.weld.extensions.util.properties;
+import static org.jboss.weld.extensions.util.Reflections.invokeMethod;
+
import java.beans.Introspector;
-import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
@@ -59,6 +61,11 @@
return getterMethod;
}
+ public Member getMember()
+ {
+ return getterMethod;
+ }
+
public V getValue(Object instance)
{
return getJavaClass().cast(invokeMethod(getterMethod, instance));
@@ -69,46 +76,6 @@
invokeMethod(setterMethod, instance, value);
}
- private static String buildInvokeMethodErrorMessage(Method method, Object obj, Object... args)
- {
- StringBuilder message = new StringBuilder(String.format("Exception invoking method [%s] on object [%s], using arguments [", method.getName(), obj));
- if (args != null)
- for (int i = 0; i < args.length; i++)
- message.append((i > 0 ? "," : "") + args[i]);
- message.append("]");
- return message.toString();
- }
-
- private static Object invokeMethod(Method method, Object obj, Object... args)
- {
- try
- {
- return method.invoke(obj, args);
- }
- catch (IllegalAccessException ex)
- {
- throw new RuntimeException(buildInvokeMethodErrorMessage(method, obj, args), ex);
- }
- catch (IllegalArgumentException ex)
- {
- throw new IllegalArgumentException(buildInvokeMethodErrorMessage(method, obj, args), ex.getCause());
- }
- catch (InvocationTargetException ex)
- {
- throw new RuntimeException(buildInvokeMethodErrorMessage(method, obj, args), ex);
- }
- catch (NullPointerException ex)
- {
- NullPointerException ex2 = new NullPointerException(buildInvokeMethodErrorMessage(method, obj, args));
- ex2.initCause(ex.getCause());
- throw ex2;
- }
- catch (ExceptionInInitializerError e)
- {
- throw new RuntimeException(buildInvokeMethodErrorMessage(method, obj, args), e);
- }
- }
-
private static Method getSetterMethod(Class<?> clazz, String name)
{
Method[] methods = clazz.getMethods();
@@ -161,5 +128,47 @@
{
return setterMethod == null;
}
+
+ @Override
+ public String toString()
+ {
+ StringBuilder builder = new StringBuilder();
+ if (isReadOnly())
+ {
+ builder.append("read-only ").append(setterMethod.toString()).append("; ");
+ }
+ builder.append(getterMethod.toString());
+ return builder.toString();
+ }
+
+ @Override
+ public int hashCode()
+ {
+ int hash = 1;
+ hash = hash * 31 + (setterMethod == null ? 0 : setterMethod.hashCode());
+ hash = hash * 31 + getterMethod.hashCode();
+ return hash;
+ }
+
+ @Override
+ public boolean equals(Object obj)
+ {
+ if (obj instanceof MethodPropertyImpl<?>)
+ {
+ MethodPropertyImpl<?> that = (MethodPropertyImpl<?>) obj;
+ if (this.setterMethod == null)
+ {
+ return that.setterMethod == null && this.getterMethod.equals(that.getterMethod);
+ }
+ else
+ {
+ return this.setterMethod.equals(that.setterMethod) && this.getterMethod.equals(that.getterMethod);
+ }
+ }
+ else
+ {
+ return false;
+ }
+ }
}
\ No newline at end of file
Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Properties.java
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Properties.java 2010-07-23 21:41:46 UTC (rev 6782)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Properties.java 2010-07-23 21:42:50 UTC (rev 6783)
@@ -1,6 +1,7 @@
package org.jboss.weld.extensions.util.properties;
import java.lang.reflect.Field;
+import java.lang.reflect.Member;
import java.lang.reflect.Method;
/**
@@ -38,4 +39,28 @@
{
return new MethodPropertyImpl<V>(method);
}
+
+ /**
+ * Create a JavaBean style property from the specified member
+ *
+ * @param <V>
+ * @param member
+ * @return
+ * @throws IllegalArgumentException if the method does not match JavaBean conventions
+ */
+ public static <V> Property<V> createProperty(Member member)
+ {
+ if (member instanceof Method)
+ {
+ return new MethodPropertyImpl<V>(Method.class.cast(member));
+ }
+ else if (member instanceof Field)
+ {
+ return new FieldPropertyImpl<V>(Field.class.cast(member));
+ }
+ else
+ {
+ throw new IllegalArgumentException("Cannot make a property of " + member + " - it is neither a method or a field");
+ }
+ }
}
Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Property.java
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Property.java 2010-07-23 21:41:46 UTC (rev 6782)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/properties/Property.java 2010-07-23 21:42:50 UTC (rev 6783)
@@ -1,6 +1,7 @@
package org.jboss.weld.extensions.util.properties;
import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Member;
import java.lang.reflect.Type;
/**
@@ -40,13 +41,20 @@
public Class<V> getJavaClass();
/**
- * Get the element backing the property
+ * Get the element responsible for retrieving the property value
*
* @return
*/
public AnnotatedElement getAnnotatedElement();
/**
+ * Get the member responsible for retrieving the property value
+ *
+ * @return
+ */
+ public Member getMember();
+
+ /**
* Returns the property value for the specified bean. The property to be
* returned is either a field or getter method.
*
More information about the weld-commits
mailing list