[weld-commits] Weld SVN: r6796 - 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
Sat Jul 24 09:02:57 EDT 2010
Author: pete.muir at jboss.org
Date: 2010-07-24 09:02:56 -0400 (Sat, 24 Jul 2010)
New Revision: 6796
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/GenericBeanExtension.java
extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/core/CoreExtension.java
extensions/trunk/impl/src/test/java/org/jboss/weld/extensions/test/bean/generic/GenericBeanTest.java
Log:
refactor on AnnotatedTypeBuilder
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-24 12:23:29 UTC (rev 6795)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/annotated/AnnotatedTypeBuilder.java 2010-07-24 13:02:56 UTC (rev 6796)
@@ -32,8 +32,6 @@
import javax.enterprise.inject.spi.AnnotatedParameter;
import javax.enterprise.inject.spi.AnnotatedType;
-import org.jboss.weld.extensions.util.Reflections;
-
/**
* Class for constructing a new AnnotatedType. A new instance of builder must be
* used for each annotated type.
@@ -47,116 +45,34 @@
*/
public class AnnotatedTypeBuilder<X>
{
-
- public static <X> AnnotatedTypeBuilder<X> newInstance(Class<X> underlying)
- {
- return new AnnotatedTypeBuilder<X>(underlying);
- }
-
- public static <X> AnnotatedTypeBuilder<X> newInstance(AnnotatedType<X> underlying)
- {
- return new AnnotatedTypeBuilder<X>(underlying);
- }
-
- private final Class<X> underlyingType;
+ private Class<X> javaClass;
private final AnnotationBuilder typeAnnotations;
-
+
private final Map<Constructor<?>, AnnotationBuilder> constructors;
private final Map<Constructor<?>, Map<Integer, AnnotationBuilder>> constructorParameters;
private Map<Constructor<?>, Map<Integer, Type>> constructorParameterTypes;
-
+
private final Map<Field, AnnotationBuilder> fields;
private final Map<Field, Type> fieldTypes;
-
+
private final Map<Method, AnnotationBuilder> methods;
private final Map<Method, Map<Integer, AnnotationBuilder>> methodParameters;
private final Map<Method, Map<Integer, Type>> methodParameterTypes;
- protected AnnotatedTypeBuilder(Class<X> underlyingType)
+ public AnnotatedTypeBuilder()
{
- this.underlyingType = underlyingType;
this.typeAnnotations = new AnnotationBuilder();
this.constructors = new HashMap<Constructor<?>, AnnotationBuilder>();
- this.constructorParameters = new HashMap<Constructor<?>, Map<Integer,AnnotationBuilder>>();
- this.constructorParameterTypes = new HashMap<Constructor<?>, Map<Integer,Type>>();
+ this.constructorParameters = new HashMap<Constructor<?>, Map<Integer, AnnotationBuilder>>();
+ this.constructorParameterTypes = new HashMap<Constructor<?>, Map<Integer, Type>>();
this.fields = new HashMap<Field, AnnotationBuilder>();
this.fieldTypes = new HashMap<Field, Type>();
this.methods = new HashMap<Method, AnnotationBuilder>();
- this.methodParameters = new HashMap<Method, Map<Integer,AnnotationBuilder>>();
- this.methodParameterTypes = new HashMap<Method, Map<Integer,Type>>();
+ this.methodParameters = new HashMap<Method, Map<Integer, AnnotationBuilder>>();
+ this.methodParameterTypes = new HashMap<Method, Map<Integer, Type>>();
}
- protected AnnotatedTypeBuilder(AnnotatedType<X> underlyingType)
- {
- this(underlyingType.getJavaClass());
-
- }
-
- public AnnotatedTypeBuilder<X> readAnnotationsFromUnderlyingType()
- {
- for (Annotation annotation : underlyingType.getAnnotations())
- {
- typeAnnotations.add(annotation);
- }
-
- for (Field field : Reflections.getAllFields(underlyingType))
- {
- AnnotationBuilder annotationBuilder = new AnnotationBuilder();
- fields.put(field, annotationBuilder);
- field.setAccessible(true);
- for (Annotation annotation : field.getAnnotations())
- {
- annotationBuilder.add(annotation);
- }
- }
-
- for (Method method : Reflections.getAllMethods(underlyingType))
- {
- AnnotationBuilder annotationBuilder = new AnnotationBuilder();
- method.setAccessible(true);
- methods.put(method, annotationBuilder);
- for (Annotation annotation : method.getAnnotations())
- {
- annotationBuilder.add(annotation);
- }
- Map<Integer, AnnotationBuilder> parameters = new HashMap<Integer, AnnotationBuilder>();
- methodParameters.put(method, parameters);
- for (int i = 0; i < method.getParameterTypes().length; ++i)
- {
- AnnotationBuilder parameterAnnotationBuilder = new AnnotationBuilder();
- parameters.put(i, parameterAnnotationBuilder);
- for (Annotation annotation : method.getParameterAnnotations()[i])
- {
- parameterAnnotationBuilder.add(annotation);
- }
- }
- }
-
- for (Constructor<?> constructor : underlyingType.getDeclaredConstructors())
- {
- AnnotationBuilder annotationBuilder = new AnnotationBuilder();
- constructor.setAccessible(true);
- constructors.put(constructor, annotationBuilder);
- for (Annotation annotation : constructor.getAnnotations())
- {
- annotationBuilder.add(annotation);
- }
- Map<Integer, AnnotationBuilder> mparams = new HashMap<Integer, AnnotationBuilder>();
- constructorParameters.put(constructor, mparams);
- for (int i = 0; i < constructor.getParameterTypes().length; ++i)
- {
- AnnotationBuilder parameterAnnotationBuilder = new AnnotationBuilder();
- mparams.put(i, parameterAnnotationBuilder);
- for (Annotation annotation : constructor.getParameterAnnotations()[i])
- {
- parameterAnnotationBuilder.add(annotation);
- }
- }
- }
- return this;
- }
-
public AnnotatedTypeBuilder<X> addToClass(Annotation annotation)
{
typeAnnotations.add(annotation);
@@ -342,7 +258,7 @@
}
return this;
}
-
+
public <T extends Annotation> AnnotatedTypeBuilder<X> redefineMembers(Class<T> annotationType, MemberAnnotationRedefiner<T> redefinition)
{
for (Entry<Field, AnnotationBuilder> field : fields.entrySet())
@@ -374,24 +290,41 @@
}
/**
- * merges the annotations from an existing AnnotatedType. If they both have
- * the same annotation on an element overwriteExisting determines which one
- * to keep
+ * Reads in from an existing AnnotatedType. Any elements not present are
+ * added. The javaClass will be read in. If the annotation already exists on
+ * that element in the builder the read annotation will be used.
*
- * @param type
- * @param overwriteExisting
- * @return
+ * @param type The type to read from
*/
- public AnnotatedTypeBuilder<X> mergeAnnotations(AnnotatedType<X> type, boolean overwriteExisting)
+ public AnnotatedTypeBuilder<X> readFromType(AnnotatedType<X> type)
{
- mergeAnnotationsOnElement(type, overwriteExisting, typeAnnotations);
+ return readFromType(type, true);
+ }
+
+ /**
+ * Reads in from an existing AnnotatedType. Any elements not present are
+ * added. The javaClass will be read in if overwrite is true. If the
+ * annotation already exists on that element in the builder, overwrite
+ * determines whether the original or read annotation will be used.
+ *
+ * @param type The type to read from
+ * @param overwrite If true, the read annotation will replace any existing
+ * annotation
+ */
+ public AnnotatedTypeBuilder<X> readFromType(AnnotatedType<X> type, boolean overwrite)
+ {
+ if (javaClass == null || overwrite)
+ {
+ this.javaClass = type.getJavaClass();
+ }
+ mergeAnnotationsOnElement(type, overwrite, typeAnnotations);
for (AnnotatedField<? super X> field : type.getFields())
- {
+ {
if (fields.get(field.getJavaMember()) == null)
{
fields.put(field.getJavaMember(), new AnnotationBuilder());
}
- mergeAnnotationsOnElement(field, overwriteExisting, fields.get(field.getJavaMember()));
+ mergeAnnotationsOnElement(field, overwrite, fields.get(field.getJavaMember()));
}
for (AnnotatedMethod<? super X> method : type.getMethods())
{
@@ -399,7 +332,7 @@
{
methods.put(method.getJavaMember(), new AnnotationBuilder());
}
- mergeAnnotationsOnElement(method, overwriteExisting, methods.get(method.getJavaMember()));
+ mergeAnnotationsOnElement(method, overwrite, methods.get(method.getJavaMember()));
for (AnnotatedParameter<? super X> p : method.getParameters())
{
if (methodParameters.get(method.getJavaMember()) == null)
@@ -408,9 +341,9 @@
}
if (methodParameters.get(method.getJavaMember()).get(p.getPosition()) == null)
{
- methodParameters.get(method.getJavaMember()).put(p.getPosition(), new AnnotationBuilder());
+ methodParameters.get(method.getJavaMember()).put(p.getPosition(), new AnnotationBuilder());
}
- mergeAnnotationsOnElement(p, overwriteExisting, methodParameters.get(method.getJavaMember()).get(p.getPosition()));
+ mergeAnnotationsOnElement(p, overwrite, methodParameters.get(method.getJavaMember()).get(p.getPosition()));
}
}
for (AnnotatedConstructor<? super X> constructor : type.getConstructors())
@@ -419,7 +352,7 @@
{
constructors.put(constructor.getJavaMember(), new AnnotationBuilder());
}
- mergeAnnotationsOnElement(constructor, overwriteExisting, constructors.get(constructor.getJavaMember()));
+ mergeAnnotationsOnElement(constructor, overwrite, constructors.get(constructor.getJavaMember()));
for (AnnotatedParameter<? super X> p : constructor.getParameters())
{
if (constructorParameters.get(constructor.getJavaMember()) == null)
@@ -430,7 +363,7 @@
{
constructorParameters.get(constructor.getJavaMember()).put(p.getPosition(), new AnnotationBuilder());
}
- mergeAnnotationsOnElement(p, overwriteExisting, constructorParameters.get(constructor.getJavaMember()).get(p.getPosition()));
+ mergeAnnotationsOnElement(p, overwrite, constructorParameters.get(constructor.getJavaMember()).get(p.getPosition()));
}
}
return this;
@@ -496,7 +429,7 @@
}
}
- return new AnnotatedTypeImpl<X>(underlyingType, typeAnnotations.create(), fieldAnnotations, methodAnnotations, methodParameterAnnnotations, constructorAnnotations, constructorParameterAnnnotations, fieldTypes, methodParameterTypes, constructorParameterTypes);
+ return new AnnotatedTypeImpl<X>(javaClass, typeAnnotations.create(), fieldAnnotations, methodAnnotations, methodParameterAnnnotations, constructorAnnotations, constructorParameterAnnnotations, fieldTypes, methodParameterTypes, constructorParameterTypes);
}
public void overrideFieldType(Field field, Type type)
@@ -522,4 +455,15 @@
constructorParameterTypes.get(constructor).put(position, type);
}
+ public Class<X> getJavaClass()
+ {
+ return javaClass;
+ }
+
+ public AnnotatedTypeBuilder<X> setJavaClass(Class<X> javaClass)
+ {
+ this.javaClass = javaClass;
+ return this;
+ }
+
}
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-24 12:23:29 UTC (rev 6795)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/bean/generic/GenericBeanExtension.java 2010-07-24 13:02:56 UTC (rev 6796)
@@ -72,7 +72,7 @@
// 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 Synthetic.Provider syntheticProvider;
GenericBeanExtension()
@@ -126,7 +126,7 @@
}
}
}
-
+
// make note of any producer method that produce generic beans
for (AnnotatedMethod<?> method : type.getMethods())
{
@@ -172,12 +172,11 @@
ProducerInjectionTarget<T> it = new ProducerInjectionTarget<T>(event.getInjectionTarget(), beanManager, setters, producersOnClass, syntheticProvider);
event.setInjectionTarget(it);
}
-
-
+
}
/**
- * Installs the generic beans.
+ * Install the generic beans and generic configuration beans
*/
void afterBeanDiscovery(@Observes AfterBeanDiscovery event, BeanManager beanManager)
{
@@ -197,13 +196,12 @@
}
}
- // TODO Do we need to do something this complex, can't we just register the relevant beans?
private <X> Bean<X> redefineType(AnnotatedType<X> annotatedType, Annotation concrete, BeanManager beanManager, AfterBeanDiscovery event)
{
- Synthetic genericBeanSyntheticQualifier = syntheticProvider.get(concrete);
+ Synthetic genericBeanQualifier = syntheticProvider.get(concrete);
- AnnotatedTypeBuilder<X> builder = AnnotatedTypeBuilder.newInstance(annotatedType).readAnnotationsFromUnderlyingType();
- builder.addToClass(genericBeanSyntheticQualifier);
+ AnnotatedTypeBuilder<X> builder = new AnnotatedTypeBuilder<X>().readFromType(annotatedType);
+ builder.addToClass(genericBeanQualifier);
for (AnnotatedField<? super X> field : annotatedType.getFields())
{
if (field.isAnnotationPresent(Inject.class))
@@ -217,19 +215,19 @@
}
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
- // TODO IMprove this
+ /*
+ * 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
+ */
+ // 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(field.getJavaMember(), genericBeanSyntheticQualifier);
+ builder.addToField(field.getJavaMember(), genericBeanQualifier);
}
}
}
@@ -261,7 +259,7 @@
Set<Bean<?>> beans = beanManager.getBeans(paramType, qualifiers);
if (beans.isEmpty())
{
- builder.addToMethod(method.getJavaMember(), genericBeanSyntheticQualifier);
+ builder.addToMethod(method.getJavaMember(), genericBeanQualifier);
}
}
}
@@ -278,7 +276,7 @@
Set<Bean<?>> beans = beanManager.getBeans(paramType, qualifiers);
if (beans.isEmpty())
{
- builder.addToConstructorParameter(constructor.getJavaMember(), parameter.getPosition(), genericBeanSyntheticQualifier);
+ builder.addToConstructorParameter(constructor.getJavaMember(), parameter.getPosition(), genericBeanQualifier);
}
}
}
@@ -286,29 +284,25 @@
BeanBuilder<X> beanBuilder = new BeanBuilder<X>(beanManager).defineBeanFromAnnotatedType(builder.create());
return beanBuilder.create();
}
-
+
private Bean<Annotation> createConfigurationBean(BeanManager beanManager, final Annotation genericConfiguration, Annotation syntheticQualifier)
{
- BeanBuilder<Annotation> builder = new BeanBuilder<Annotation>(beanManager)
- .setJavaClass(genericConfiguration.annotationType())
- .setTypes(Arrays2.<Type>asSet(genericConfiguration.annotationType(), Object.class))
- .setScope(Dependent.class)
- .setQualifiers(Arrays2.asSet(syntheticQualifier))
- // TODO make this passivation capable?
- .setBeanLifecycle(new BeanLifecycle<Annotation>()
- {
-
- public void destroy(Bean<Annotation> bean, Annotation arg0, CreationalContext<Annotation> arg1)
+ BeanBuilder<Annotation> builder = new BeanBuilder<Annotation>(beanManager).setJavaClass(genericConfiguration.annotationType()).setTypes(Arrays2.<Type> asSet(genericConfiguration.annotationType(), Object.class)).setScope(Dependent.class).setQualifiers(Arrays2.asSet(syntheticQualifier))
+ // TODO make this passivation capable?
+ .setBeanLifecycle(new BeanLifecycle<Annotation>()
{
- // No-op
- }
-
- public Annotation create(Bean<Annotation> bean, CreationalContext<Annotation> arg0)
- {
- return genericConfiguration;
- }
- });
-
+
+ public void destroy(Bean<Annotation> bean, Annotation arg0, CreationalContext<Annotation> arg1)
+ {
+ // No-op
+ }
+
+ public Annotation create(Bean<Annotation> bean, CreationalContext<Annotation> arg0)
+ {
+ return genericConfiguration;
+ }
+ });
+
return builder.create();
}
Modified: extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/core/CoreExtension.java
===================================================================
--- extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/core/CoreExtension.java 2010-07-24 12:23:29 UTC (rev 6795)
+++ extensions/trunk/impl/src/main/java/org/jboss/weld/extensions/core/CoreExtension.java 2010-07-24 13:02:56 UTC (rev 6796)
@@ -69,7 +69,7 @@
return;
}
- AnnotatedTypeBuilder<X> builder = AnnotatedTypeBuilder.newInstance(pat.getAnnotatedType()).mergeAnnotations(pat.getAnnotatedType(), true);
+ AnnotatedTypeBuilder<X> builder = new AnnotatedTypeBuilder<X>().readFromType(pat.getAnnotatedType());
// support for @Named packages
Package pkg = pat.getAnnotatedType().getJavaClass().getPackage();
@@ -145,7 +145,7 @@
{
if (constructor.isAnnotationPresent(Constructs.class))
{
- AnnotatedTypeBuilder<X> annotatedTypeBuilder = AnnotatedTypeBuilder.newInstance(pat.getAnnotatedType()).mergeAnnotations(pat.getAnnotatedType(), true);
+ AnnotatedTypeBuilder<X> annotatedTypeBuilder = new AnnotatedTypeBuilder<X>().readFromType(pat.getAnnotatedType());
// remove class-level @Named annotation
annotatedTypeBuilder.removeFromClass(Named.class);
// remove bean constructors annotated @Inject
Modified: extensions/trunk/impl/src/test/java/org/jboss/weld/extensions/test/bean/generic/GenericBeanTest.java
===================================================================
--- extensions/trunk/impl/src/test/java/org/jboss/weld/extensions/test/bean/generic/GenericBeanTest.java 2010-07-24 12:23:29 UTC (rev 6795)
+++ extensions/trunk/impl/src/test/java/org/jboss/weld/extensions/test/bean/generic/GenericBeanTest.java 2010-07-24 13:02:56 UTC (rev 6796)
@@ -48,9 +48,9 @@
{
// Test that the generic configuration injection wiring is working!
assert baz1.getGarply() != null;
- assert baz1.getGarply().equals("hello1");
+ assert baz1.getGarply().value().equals("hello1");
assert baz2.getGarply() != null;
- assert baz2.getGarply().equals("hello2");
+ assert baz2.getGarply().value().equals("hello2");
assert baz1.getBar() != null;
assert baz1.getBar().getInjectedGarply() != null;
assert baz1.getBar().getInjectedGarply().value().equals("hello1");
More information about the weld-commits
mailing list