[weld-commits] Weld SVN: r6789 - in extensions/trunk/impl/src/main/java/org/jboss/weld/extensions: util and 1 other directory.
weld-commits at lists.jboss.org
weld-commits at lists.jboss.org
Fri Jul 23 18:41:56 EDT 2010
Author: pete.muir at jboss.org
Date: 2010-07-23 18:41:55 -0400 (Fri, 23 Jul 2010)
New Revision: 6789
Added:
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/ProducerInjectionTarget.java
Removed:
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/ProducerFieldInjectionTarget.java
Modified:
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanExtension.java
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/Reflections.java
Log:
tidy up
Modified: 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/GenericBeanExtension.java 2010-07-23 22:19:51 UTC (rev 6788)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanExtension.java 2010-07-23 22:41:55 UTC (rev 6789)
@@ -16,6 +16,9 @@
*/
package org.jboss.weld.extensions.bean.generic;
+import static org.jboss.weld.extensions.util.Reflections.EMPTY_ANNOTATION_ARRAY;
+import static org.jboss.weld.extensions.util.Reflections.getQualifiers;
+
import java.lang.annotation.Annotation;
import java.lang.reflect.Member;
import java.util.ArrayList;
@@ -61,7 +64,7 @@
private final Map<Class<?>, Set<AnnotatedType<?>>> genericBeans;
- private final Map<Class<?>, Map<Member, Annotation>> producerFields;
+ private final Map<Class<?>, Map<Member, Annotation>> producers;
// A map of a generic annotation type to all instances of that type found on beans
private final Map<Class<?>, Set<Annotation>> concreteGenerics;
@@ -71,7 +74,7 @@
GenericBeanExtension()
{
this.genericBeans = new HashMap<Class<?>, Set<AnnotatedType<?>>>();
- this.producerFields = new HashMap<Class<?>, Map<Member, Annotation>>();
+ this.producers = new HashMap<Class<?>, Map<Member, Annotation>>();
this.concreteGenerics = new HashMap<Class<?>, Set<Annotation>>();
this.syntheticProvider = new Synthetic.Provider("org.jboss.weld.extensions.bean.generic");
}
@@ -105,15 +108,15 @@
{
if (annotation.annotationType().isAnnotationPresent(GenericConfiguration.class))
{
- if (!producerFields.containsKey(type.getJavaClass()))
+ if (!producers.containsKey(type.getJavaClass()))
{
- producerFields.put(type.getJavaClass(), new HashMap<Member, Annotation>());
+ producers.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);
+ producers.get(type.getJavaClass()).put(field.getJavaMember(), annotation);
concreteGenerics.get(annotation.annotationType()).add(annotation);
}
}
@@ -129,15 +132,15 @@
{
if (annotation.annotationType().isAnnotationPresent(GenericConfiguration.class))
{
- if (!producerFields.containsKey(type.getJavaClass()))
+ if (!producers.containsKey(type.getJavaClass()))
{
- producerFields.put(type.getJavaClass(), new HashMap<Member, Annotation>());
+ producers.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);
+ producers.get(type.getJavaClass()).put(method.getJavaMember(), annotation);
concreteGenerics.get(annotation.annotationType()).add(annotation);
}
}
@@ -151,26 +154,27 @@
*/
<T> void processInjectionTarget(@Observes ProcessInjectionTarget<T> event, BeanManager beanManager)
{
- Class<?> javaClass = event.getAnnotatedType().getJavaClass();
- if (producerFields.containsKey(javaClass))
+ Class<?> clazz = event.getAnnotatedType().getJavaClass();
+ if (producers.containsKey(clazz))
{
- Map<Member, Annotation> producers = producerFields.get(javaClass);
+ Map<Member, Annotation> producersOnClass = producers.get(clazz);
List<Property<Object>> setters = new ArrayList<Property<Object>>();
- for (Member field : producers.keySet())
+ for (Member member : producersOnClass.keySet())
{
- Property<Object> property = Properties.createProperty(field);
+ Property<Object> property = Properties.createProperty(member);
setters.add(property);
}
- ProducerFieldInjectionTarget<T> it = new ProducerFieldInjectionTarget<T>(event.getInjectionTarget(), beanManager, setters, producers, syntheticProvider);
+ ProducerInjectionTarget<T> it = new ProducerInjectionTarget<T>(event.getInjectionTarget(), beanManager, setters, producersOnClass, syntheticProvider);
event.setInjectionTarget(it);
}
+
}
/**
* Installs the generic beans.
*/
- public void afterBeanDiscovery(@Observes AfterBeanDiscovery abd, BeanManager beanManager)
+ void afterBeanDiscovery(@Observes AfterBeanDiscovery event, BeanManager beanManager)
{
for (Entry<Class<?>, Set<AnnotatedType<?>>> entry : genericBeans.entrySet())
{
@@ -179,30 +183,30 @@
{
for (AnnotatedType<?> type : entry.getValue())
{
- for (Annotation conc : concretes)
+ for (Annotation concrete : concretes)
{
- abd.addBean(redefineType(type, conc, beanManager));
+ event.addBean(redefineType(type, concrete, beanManager));
}
}
}
}
}
- private <X> Bean<X> redefineType(AnnotatedType<X> at, Annotation conc, BeanManager beanManager)
+ private <X> Bean<X> redefineType(AnnotatedType<X> annotatedType, Annotation concrete, BeanManager beanManager)
{
- Synthetic newQualifier = syntheticProvider.get(conc);
+ Synthetic newQualifier = syntheticProvider.get(concrete);
- AnnotatedTypeBuilder<X> builder = AnnotatedTypeBuilder.newInstance(at).readAnnotationsFromUnderlyingType();
+ AnnotatedTypeBuilder<X> builder = AnnotatedTypeBuilder.newInstance(annotatedType).readAnnotationsFromUnderlyingType();
builder.addToClass(newQualifier);
- for (AnnotatedField<? super X> f : at.getFields())
+ for (AnnotatedField<? super X> field : annotatedType.getFields())
{
- if (f.isAnnotationPresent(Inject.class))
+ if (field.isAnnotationPresent(Inject.class))
{
// if this is a configuration injection point
- if (conc.annotationType().isAssignableFrom(f.getJavaMember().getType()))
+ if (concrete.annotationType().isAssignableFrom(field.getJavaMember().getType()))
{
- builder.removeFromField(f.getJavaMember(), Inject.class);
- builder.addToField(f.getJavaMember(), InjectConfiguration.INSTANCE);
+ builder.removeFromField(field.getJavaMember(), Inject.class);
+ builder.addToField(field.getJavaMember(), InjectConfiguration.INSTANCE);
}
else
{
@@ -213,30 +217,31 @@
// 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);
+ // TODO IMprove this
+ Annotation[] qualifiers = getQualifiers(field.getAnnotations(), beanManager).toArray(EMPTY_ANNOTATION_ARRAY);
+ Set<Bean<?>> beans = beanManager.getBeans(field.getJavaMember().getType(), qualifiers);
if (beans.isEmpty())
{
- builder.addToField(f.getJavaMember(), newQualifier);
+ builder.addToField(field.getJavaMember(), newQualifier);
}
}
}
- else if (f.isAnnotationPresent(Produces.class))
+ else if (field.isAnnotationPresent(Produces.class))
{
// TODO: register a producer with the appropriate qualifier
}
}
- for (AnnotatedMethod<?> m : at.getMethods())
+ for (AnnotatedMethod<?> method : annotatedType.getMethods())
{
// TODO: need to properly handle Observer methods and Disposal
// methods
- if (m.isAnnotationPresent(Produces.class))
+ if (method.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())
+ for (AnnotatedParameter<?> pm : method.getParameters())
{
- Class<?> paramType = m.getJavaMember().getParameterTypes()[pm.getPosition()];
+ Class<?> paramType = method.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
@@ -245,28 +250,28 @@
// 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);
+ Annotation[] qualifiers = getQualifiers(pm.getAnnotations(), beanManager).toArray(EMPTY_ANNOTATION_ARRAY);
+ Set<Bean<?>> beans = beanManager.getBeans(paramType, qualifiers);
if (beans.isEmpty())
{
- builder.addToMethod(m.getJavaMember(), newQualifier);
+ builder.addToMethod(method.getJavaMember(), newQualifier);
}
}
}
}
- for (AnnotatedConstructor<X> m : at.getConstructors())
+ for (AnnotatedConstructor<X> constructor : annotatedType.getConstructors())
{
- if (m.isAnnotationPresent(Inject.class))
+ if (constructor.isAnnotationPresent(Inject.class))
{
- for (AnnotatedParameter<X> pm : m.getParameters())
+ for (AnnotatedParameter<X> parameter : constructor.getParameters())
{
- Class<?> paramType = m.getJavaMember().getParameterTypes()[pm.getPosition()];
- Annotation[] qls = getQualifiers(pm.getAnnotations(), beanManager);
- Set<Bean<?>> beans = beanManager.getBeans(paramType, qls);
+ Class<?> paramType = constructor.getJavaMember().getParameterTypes()[parameter.getPosition()];
+ Annotation[] qualifiers = getQualifiers(parameter.getAnnotations(), beanManager).toArray(EMPTY_ANNOTATION_ARRAY);
+ Set<Bean<?>> beans = beanManager.getBeans(paramType, qualifiers);
if (beans.isEmpty())
{
- builder.addToConstructorParameter(m.getJavaMember(), pm.getPosition(), newQualifier);
+ builder.addToConstructorParameter(constructor.getJavaMember(), parameter.getPosition(), newQualifier);
}
}
}
@@ -274,27 +279,9 @@
AnnotatedType<X> newAnnotatedType = builder.create();
InjectionTarget<X> it = beanManager.createInjectionTarget(newAnnotatedType);
- it = new GenericBeanInjectionTargetWrapper<X>(newAnnotatedType, it, conc);
+ it = new GenericBeanInjectionTargetWrapper<X>(newAnnotatedType, it, concrete);
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/ProducerFieldInjectionTarget.java
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/ProducerFieldInjectionTarget.java 2010-07-23 22:19:51 UTC (rev 6788)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/ProducerFieldInjectionTarget.java 2010-07-23 22:41:55 UTC (rev 6789)
@@ -1,82 +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.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.Synthetic;
-import org.jboss.weld.extensions.util.properties.Property;
-
-/**
- * {@link InjectionTarget} wrapper used for beans that have generic producer fields
- *
- * @author Stuart Douglas <stuart at baileyroberts.com.au>
- *
- * @param <T>
- */
-public class ProducerFieldInjectionTarget<T> extends ForwardingInjectionTarget<T>
-{
- private final InjectionTarget<T> delegate;
-
- private final BeanManager beanManager;
- private final List<Property<Object>> properties;
- private final Map<Member, Annotation> producers;
- private final Synthetic.Provider syntheticProvider;
-
- public ProducerFieldInjectionTarget(InjectionTarget<T> delegate, BeanManager beanManager, List<Property<Object>> properties, Map<Member, Annotation> producers, Synthetic.Provider syntheticProvider)
- {
- this.delegate = delegate;
- this.beanManager = beanManager;
- this.properties = properties;
- this.producers = producers;
- this.syntheticProvider = syntheticProvider;
- }
-
- @Override
- protected InjectionTarget<T> delegate()
- {
- return delegate;
- }
-
- @Override
- public void inject(T instance, CreationalContext<T> ctx)
- {
- for (Property<Object> property: properties)
- {
- Synthetic qualifier = syntheticProvider.get(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);
- }
-
-}
Copied: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/ProducerInjectionTarget.java (from rev 6784, 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/ProducerInjectionTarget.java (rev 0)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/ProducerInjectionTarget.java 2010-07-23 22:41:55 UTC (rev 6789)
@@ -0,0 +1,82 @@
+/*
+ * 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.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.Synthetic;
+import org.jboss.weld.extensions.util.properties.Property;
+
+/**
+ * {@link InjectionTarget} wrapper used for beans that have generic producer fields
+ *
+ * @author Stuart Douglas <stuart at baileyroberts.com.au>
+ *
+ * @param <T>
+ */
+public class ProducerInjectionTarget<T> extends ForwardingInjectionTarget<T>
+{
+ private final InjectionTarget<T> delegate;
+
+ private final BeanManager beanManager;
+ private final List<Property<Object>> properties;
+ private final Map<Member, Annotation> producers;
+ private final Synthetic.Provider syntheticProvider;
+
+ public ProducerInjectionTarget(InjectionTarget<T> delegate, BeanManager beanManager, List<Property<Object>> properties, Map<Member, Annotation> producers, Synthetic.Provider syntheticProvider)
+ {
+ this.delegate = delegate;
+ this.beanManager = beanManager;
+ this.properties = properties;
+ this.producers = producers;
+ this.syntheticProvider = syntheticProvider;
+ }
+
+ @Override
+ protected InjectionTarget<T> delegate()
+ {
+ return delegate;
+ }
+
+ @Override
+ public void inject(T instance, CreationalContext<T> ctx)
+ {
+ for (Property<Object> property: properties)
+ {
+ Synthetic qualifier = syntheticProvider.get(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);
+ }
+
+}
Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/Reflections.java
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/Reflections.java 2010-07-23 22:19:51 UTC (rev 6788)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/util/Reflections.java 2010-07-23 22:41:55 UTC (rev 6789)
@@ -38,6 +38,8 @@
*/
public class Reflections
{
+
+ public static final Annotation[] EMPTY_ANNOTATION_ARRAY = new Annotation[0];
private Reflections()
{
More information about the weld-commits
mailing list