From b9bfac4ac6c7a0037b3cc99643ffd62e39d92d57 Mon Sep 17 00:00:00 2001 From: Stuart Douglas Date: Mon, 15 Nov 2010 22:21:30 +1100 Subject: [PATCH] Build type closures lazily where possible --- .../java/org/jboss/weld/bean/ManagedBean.java | 2 +- .../org/jboss/weld/bean/ProducerField.java | 2 +- .../org/jboss/weld/bean/ProducerMethod.java | 2 +- .../TypeClosureLazyValueHolder.java | 61 +++++++++++++++++++ .../jlr/AbstractWeldAnnotated.java | 9 +-- .../jlr/AbstractWeldCallable.java | 3 +- .../introspector/jlr/AbstractWeldMember.java | 3 +- .../introspector/jlr/WeldAnnotationImpl.java | 4 +- .../weld/introspector/jlr/WeldClassImpl.java | 11 ++-- .../introspector/jlr/WeldConstructorImpl.java | 9 +-- .../weld/introspector/jlr/WeldFieldImpl.java | 10 +-- .../weld/introspector/jlr/WeldMethodImpl.java | 9 +-- .../introspector/jlr/WeldParameterImpl.java | 9 +-- 13 files changed, 101 insertions(+), 33 deletions(-) create mode 100644 impl/src/main/java/org/jboss/weld/introspector/TypeClosureLazyValueHolder.java diff --git a/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java b/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java index d2d93ea6b19..58751108c62 100644 --- a/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java +++ b/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java @@ -324,7 +324,7 @@ protected ManagedBean(WeldClass type, String idSuffix, BeanManagerImpl beanMa initTypes(); initQualifiers(); initConstructor(); - this.proxiable = Proxies.isTypeProxyable(type.getBaseType()); + this.proxiable = Proxies.isTypesProxyable(type.getTypeClosure()); } /** diff --git a/impl/src/main/java/org/jboss/weld/bean/ProducerField.java b/impl/src/main/java/org/jboss/weld/bean/ProducerField.java index 65d1e08a874..469e85a02fe 100644 --- a/impl/src/main/java/org/jboss/weld/bean/ProducerField.java +++ b/impl/src/main/java/org/jboss/weld/bean/ProducerField.java @@ -82,7 +82,7 @@ protected ProducerField(WeldField field, AbstractClassBean decl initTypes(); initQualifiers(); initStereotypes(); - this.proxiable = Proxies.isTypeProxyable(field.getBaseType()); + this.proxiable = Proxies.isTypesProxyable(field.getTypeClosure()); } protected static String createId(WeldField field, AbstractClassBean declaringBean) diff --git a/impl/src/main/java/org/jboss/weld/bean/ProducerMethod.java b/impl/src/main/java/org/jboss/weld/bean/ProducerMethod.java index 600f888af25..ab0a6b3660c 100644 --- a/impl/src/main/java/org/jboss/weld/bean/ProducerMethod.java +++ b/impl/src/main/java/org/jboss/weld/bean/ProducerMethod.java @@ -86,7 +86,7 @@ protected ProducerMethod(WeldMethod method, AbstractClassBean d this.id = createId(method, declaringBean); initStereotypes(); initProducerMethodInjectableParameters(); - this.proxiable = Proxies.isTypeProxyable(method.getBaseType()); + this.proxiable = Proxies.isTypesProxyable(method.getTypeClosure()); } protected String createId(WeldMethod method, AbstractClassBean declaringBean) diff --git a/impl/src/main/java/org/jboss/weld/introspector/TypeClosureLazyValueHolder.java b/impl/src/main/java/org/jboss/weld/introspector/TypeClosureLazyValueHolder.java new file mode 100644 index 00000000000..8b113454e99 --- /dev/null +++ b/impl/src/main/java/org/jboss/weld/introspector/TypeClosureLazyValueHolder.java @@ -0,0 +1,61 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, 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.introspector; + +import java.lang.reflect.Type; +import java.util.Set; + +import org.jboss.weld.util.LazyValueHolder; +import org.jboss.weld.util.reflection.HierarchyDiscovery; + +/** + * {@link LazyValueHolder} that calculates a type closue. In many cases this + * will not be needed, so computing it on demand saves memory and startup time. + * + * @author Stuart Douglas + * + */ +public class TypeClosureLazyValueHolder extends LazyValueHolder> +{ + + private final Type type; + + private final Set types; + + public TypeClosureLazyValueHolder(Type type) + { + this.type = type; + this.types = null; + } + + public TypeClosureLazyValueHolder(Set types) + { + this.type = null; + this.types = types; + } + + @Override + protected Set computeValue() + { + if (types != null) + { + return types; + } + return new HierarchyDiscovery(type).getTypeClosure(); + } + +} diff --git a/impl/src/main/java/org/jboss/weld/introspector/jlr/AbstractWeldAnnotated.java b/impl/src/main/java/org/jboss/weld/introspector/jlr/AbstractWeldAnnotated.java index e01c355d4c1..3119365b4e9 100644 --- a/impl/src/main/java/org/jboss/weld/introspector/jlr/AbstractWeldAnnotated.java +++ b/impl/src/main/java/org/jboss/weld/introspector/jlr/AbstractWeldAnnotated.java @@ -36,6 +36,7 @@ import org.jboss.weld.literal.DefaultLiteral; import org.jboss.weld.metadata.TypeStore; import org.jboss.weld.resources.ClassTransformer; +import org.jboss.weld.util.LazyValueHolder; import org.jboss.weld.util.collections.ArraySet; import org.jboss.weld.util.collections.ArraySetMultimap; import org.jboss.weld.util.collections.Arrays2; @@ -128,7 +129,7 @@ private static void addMetaAnnotation(ArraySetMultimap rawType; private final Type[] actualTypeArguments; private final Type type; - private final Set typeClosure; + private final LazyValueHolder> typeClosure; /** * Constructor @@ -139,7 +140,7 @@ private static void addMetaAnnotation(ArraySetMultimap, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, ClassTransformer classTransformer, Class rawType, Type type, Set typeClosure) + public AbstractWeldAnnotated(Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, ClassTransformer classTransformer, Class rawType, Type type, final LazyValueHolder> typeClosure) { if (annotationMap == null) { @@ -168,7 +169,7 @@ public AbstractWeldAnnotated(Map, Annotation> annota { this.actualTypeArguments = new Type[0]; } - this.typeClosure = Collections.unmodifiableSet(new ArraySet(typeClosure)); + this.typeClosure = typeClosure; } protected AbstractWeldAnnotated(Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, TypeStore typeStore) @@ -239,7 +240,7 @@ public Type getBaseType() public Set getTypeClosure() { - return typeClosure; + return typeClosure.get(); } public Set getAnnotations() diff --git a/impl/src/main/java/org/jboss/weld/introspector/jlr/AbstractWeldCallable.java b/impl/src/main/java/org/jboss/weld/introspector/jlr/AbstractWeldCallable.java index 113cc6b8898..f091f147258 100644 --- a/impl/src/main/java/org/jboss/weld/introspector/jlr/AbstractWeldCallable.java +++ b/impl/src/main/java/org/jboss/weld/introspector/jlr/AbstractWeldCallable.java @@ -25,6 +25,7 @@ import org.jboss.weld.introspector.WeldCallable; import org.jboss.weld.introspector.WeldClass; import org.jboss.weld.resources.ClassTransformer; +import org.jboss.weld.util.LazyValueHolder; /** * @author pmuir @@ -33,7 +34,7 @@ public abstract class AbstractWeldCallable extends AbstractWeldMember implements WeldCallable { - protected AbstractWeldCallable(Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, ClassTransformer classTransformer, Member member, Class rawType, Type type, Set typeClosure, WeldClass declaringType) + protected AbstractWeldCallable(Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, ClassTransformer classTransformer, Member member, Class rawType, Type type, LazyValueHolder> typeClosure, WeldClass declaringType) { super(annotationMap, declaredAnnotationMap, classTransformer, member, rawType, type, typeClosure, declaringType); } diff --git a/impl/src/main/java/org/jboss/weld/introspector/jlr/AbstractWeldMember.java b/impl/src/main/java/org/jboss/weld/introspector/jlr/AbstractWeldMember.java index 23f3faee154..e3059bb7c35 100644 --- a/impl/src/main/java/org/jboss/weld/introspector/jlr/AbstractWeldMember.java +++ b/impl/src/main/java/org/jboss/weld/introspector/jlr/AbstractWeldMember.java @@ -26,6 +26,7 @@ import org.jboss.weld.introspector.WeldClass; import org.jboss.weld.introspector.WeldMember; import org.jboss.weld.resources.ClassTransformer; +import org.jboss.weld.util.LazyValueHolder; import org.jboss.weld.util.reflection.Reflections; /** @@ -50,7 +51,7 @@ public abstract class AbstractWeldMember extends Abstrac * * @param annotationMap The annotation map */ - protected AbstractWeldMember(Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, ClassTransformer classTransformer, Member member, Class rawType, Type type, Set typeClosure, WeldClass declaringType) + protected AbstractWeldMember(Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, ClassTransformer classTransformer, Member member, Class rawType, Type type, LazyValueHolder> typeClosure, WeldClass declaringType) { super(annotationMap, declaredAnnotationMap, classTransformer, rawType, type, typeClosure); this.declaringType = declaringType; diff --git a/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldAnnotationImpl.java b/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldAnnotationImpl.java index e415c11178b..8a0590e9511 100644 --- a/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldAnnotationImpl.java +++ b/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldAnnotationImpl.java @@ -25,11 +25,11 @@ import java.util.Map; import java.util.Set; +import org.jboss.weld.introspector.TypeClosureLazyValueHolder; import org.jboss.weld.introspector.WeldAnnotation; import org.jboss.weld.introspector.WeldMethod; import org.jboss.weld.resources.ClassTransformer; import org.jboss.weld.util.collections.HashSetSupplier; -import org.jboss.weld.util.reflection.HierarchyDiscovery; import org.jboss.weld.util.reflection.SecureReflections; import com.google.common.collect.Multimaps; @@ -75,7 +75,7 @@ public static WeldAnnotation of(Class annotationTyp */ protected WeldAnnotationImpl(Class annotationType, Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, ClassTransformer classTransformer) { - super(annotationType, annotationType, null, new HierarchyDiscovery(annotationType).getTypeClosure(), annotationMap, declaredAnnotationMap, classTransformer); + super(annotationType, annotationType, null, new TypeClosureLazyValueHolder(annotationType), annotationMap, declaredAnnotationMap, classTransformer); this.clazz = annotationType; members = new HashSet>(); annotatedMembers = Multimaps.newSetMultimap(new HashMap, Collection>>(), HashSetSupplier.>instance()); diff --git a/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java b/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java index 63004968165..e7f48cd8d3c 100644 --- a/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java +++ b/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java @@ -42,15 +42,16 @@ import org.jboss.weld.introspector.ConstructorSignature; import org.jboss.weld.introspector.ExternalAnnotatedType; import org.jboss.weld.introspector.MethodSignature; +import org.jboss.weld.introspector.TypeClosureLazyValueHolder; import org.jboss.weld.introspector.WeldClass; import org.jboss.weld.introspector.WeldConstructor; import org.jboss.weld.introspector.WeldField; import org.jboss.weld.introspector.WeldMethod; import org.jboss.weld.resources.ClassTransformer; +import org.jboss.weld.util.LazyValueHolder; import org.jboss.weld.util.collections.ArraySet; import org.jboss.weld.util.collections.ArraySetMultimap; import org.jboss.weld.util.reflection.Formats; -import org.jboss.weld.util.reflection.HierarchyDiscovery; import org.jboss.weld.util.reflection.Reflections; import org.jboss.weld.util.reflection.SecureReflections; @@ -109,20 +110,20 @@ public class WeldClassImpl extends AbstractWeldAnnotated> impleme public static WeldClass of(Class clazz, ClassTransformer classTransformer) { - return new WeldClassImpl(clazz, clazz, null, new HierarchyDiscovery(clazz).getTypeClosure(), buildAnnotationMap(clazz.getAnnotations()), buildAnnotationMap(clazz.getDeclaredAnnotations()), classTransformer); + return new WeldClassImpl(clazz, clazz, null, new TypeClosureLazyValueHolder(clazz), buildAnnotationMap(clazz.getAnnotations()), buildAnnotationMap(clazz.getDeclaredAnnotations()), classTransformer); } public static WeldClass of(AnnotatedType annotatedType, ClassTransformer classTransformer) { - return new WeldClassImpl(annotatedType.getJavaClass(), annotatedType.getBaseType(), annotatedType, annotatedType.getTypeClosure(), buildAnnotationMap(annotatedType.getAnnotations()), buildAnnotationMap(annotatedType.getAnnotations()), classTransformer); + return new WeldClassImpl(annotatedType.getJavaClass(), annotatedType.getBaseType(), annotatedType, new TypeClosureLazyValueHolder(annotatedType.getTypeClosure()), buildAnnotationMap(annotatedType.getAnnotations()), buildAnnotationMap(annotatedType.getAnnotations()), classTransformer); } public static WeldClass of(Class rawType, Type type, ClassTransformer classTransformer) { - return new WeldClassImpl(rawType, type, null, new HierarchyDiscovery(type).getTypeClosure(), buildAnnotationMap(rawType.getAnnotations()), buildAnnotationMap(rawType.getDeclaredAnnotations()), classTransformer); + return new WeldClassImpl(rawType, type, null, new TypeClosureLazyValueHolder(type), buildAnnotationMap(rawType.getAnnotations()), buildAnnotationMap(rawType.getDeclaredAnnotations()), classTransformer); } - protected WeldClassImpl(Class rawType, Type type, AnnotatedType annotatedType, Set typeClosure, Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, ClassTransformer classTransformer) + protected WeldClassImpl(Class rawType, Type type, AnnotatedType annotatedType, LazyValueHolder> typeClosure, Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, ClassTransformer classTransformer) { super(annotationMap, declaredAnnotationMap, classTransformer, rawType, type, typeClosure); diff --git a/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldConstructorImpl.java b/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldConstructorImpl.java index 4529164f518..2d3d684328e 100644 --- a/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldConstructorImpl.java +++ b/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldConstructorImpl.java @@ -33,14 +33,15 @@ import org.jboss.weld.exceptions.DefinitionException; import org.jboss.weld.introspector.ConstructorSignature; +import org.jboss.weld.introspector.TypeClosureLazyValueHolder; import org.jboss.weld.introspector.WeldClass; import org.jboss.weld.introspector.WeldConstructor; import org.jboss.weld.introspector.WeldParameter; import org.jboss.weld.logging.messages.ReflectionMessage; import org.jboss.weld.manager.BeanManagerImpl; import org.jboss.weld.resources.ClassTransformer; +import org.jboss.weld.util.LazyValueHolder; import org.jboss.weld.util.reflection.Formats; -import org.jboss.weld.util.reflection.HierarchyDiscovery; import org.jboss.weld.util.reflection.Reflections; import org.jboss.weld.util.reflection.SecureReflections; @@ -66,12 +67,12 @@ public class WeldConstructorImpl extends AbstractWeldCallable WeldConstructor of(Constructor constructor, WeldClass declaringClass, ClassTransformer classTransformer) { - return new WeldConstructorImpl(constructor, constructor.getDeclaringClass(), constructor.getDeclaringClass(), null, new HierarchyDiscovery(constructor.getDeclaringClass()).getTypeClosure(), buildAnnotationMap(constructor.getAnnotations()), buildAnnotationMap(constructor.getDeclaredAnnotations()), declaringClass, classTransformer); + return new WeldConstructorImpl(constructor, constructor.getDeclaringClass(), constructor.getDeclaringClass(), null, new TypeClosureLazyValueHolder(constructor.getDeclaringClass()), buildAnnotationMap(constructor.getAnnotations()), buildAnnotationMap(constructor.getDeclaredAnnotations()), declaringClass, classTransformer); } public static WeldConstructor of(AnnotatedConstructor annotatedConstructor, WeldClass declaringClass, ClassTransformer classTransformer) { - return new WeldConstructorImpl(annotatedConstructor.getJavaMember(), annotatedConstructor.getJavaMember().getDeclaringClass(), annotatedConstructor.getBaseType(), annotatedConstructor, annotatedConstructor.getTypeClosure(), buildAnnotationMap(annotatedConstructor.getAnnotations()), buildAnnotationMap(annotatedConstructor.getAnnotations()), declaringClass, classTransformer); + return new WeldConstructorImpl(annotatedConstructor.getJavaMember(), annotatedConstructor.getJavaMember().getDeclaringClass(), annotatedConstructor.getBaseType(), annotatedConstructor, new TypeClosureLazyValueHolder(annotatedConstructor.getTypeClosure()), buildAnnotationMap(annotatedConstructor.getAnnotations()), buildAnnotationMap(annotatedConstructor.getAnnotations()), declaringClass, classTransformer); } /** @@ -82,7 +83,7 @@ public static WeldConstructor of(AnnotatedConstructor annotatedConstru * @param constructor The constructor method * @param declaringClass The declaring class */ - private WeldConstructorImpl(Constructor constructor, final Class rawType, final Type type, AnnotatedConstructor annotatedConstructor, Set typeClosure, Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, WeldClass declaringClass, ClassTransformer classTransformer) + private WeldConstructorImpl(Constructor constructor, final Class rawType, final Type type, AnnotatedConstructor annotatedConstructor, LazyValueHolder> typeClosure, Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, WeldClass declaringClass, ClassTransformer classTransformer) { super(annotationMap, declaredAnnotationMap, classTransformer, constructor, rawType, type, typeClosure, declaringClass); this.constructor = constructor; diff --git a/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldFieldImpl.java b/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldFieldImpl.java index 8d0c69ae84f..c2186bbc2de 100644 --- a/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldFieldImpl.java +++ b/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldFieldImpl.java @@ -17,7 +17,6 @@ package org.jboss.weld.introspector.jlr; import static org.jboss.weld.logging.messages.UtilMessage.ACCESS_ERROR_ON_FIELD; -import static org.jboss.weld.util.reflection.Reflections.cast; import java.lang.annotation.Annotation; import java.lang.reflect.Field; @@ -28,11 +27,12 @@ import javax.enterprise.inject.spi.AnnotatedField; import org.jboss.weld.exceptions.WeldException; +import org.jboss.weld.introspector.TypeClosureLazyValueHolder; import org.jboss.weld.introspector.WeldClass; import org.jboss.weld.introspector.WeldField; import org.jboss.weld.resources.ClassTransformer; +import org.jboss.weld.util.LazyValueHolder; import org.jboss.weld.util.reflection.Formats; -import org.jboss.weld.util.reflection.HierarchyDiscovery; import org.jboss.weld.util.reflection.Reflections; import org.jboss.weld.util.reflection.SecureReflections; @@ -53,12 +53,12 @@ public class WeldFieldImpl extends AbstractWeldMember impleme public static WeldFieldImpl of(Field field, WeldClass declaringClass, ClassTransformer classTransformer) { - return new WeldFieldImpl(field, Reflections.>cast(field.getType()), field.getGenericType(), new HierarchyDiscovery(field.getGenericType()).getTypeClosure(), buildAnnotationMap(field.getAnnotations()), buildAnnotationMap(field.getDeclaredAnnotations()), declaringClass, classTransformer); + return new WeldFieldImpl(field, Reflections.> cast(field.getType()), field.getGenericType(), new TypeClosureLazyValueHolder(field.getGenericType()), buildAnnotationMap(field.getAnnotations()), buildAnnotationMap(field.getDeclaredAnnotations()), declaringClass, classTransformer); } public static WeldFieldImpl of(AnnotatedField annotatedField, WeldClass declaringClass, ClassTransformer classTransformer) { - return new WeldFieldImpl(annotatedField.getJavaMember(), Reflections.>cast(annotatedField.getJavaMember().getType()), annotatedField.getBaseType(), annotatedField.getTypeClosure(), buildAnnotationMap(annotatedField.getAnnotations()), buildAnnotationMap(annotatedField.getAnnotations()), declaringClass, classTransformer); + return new WeldFieldImpl(annotatedField.getJavaMember(), Reflections.> cast(annotatedField.getJavaMember().getType()), annotatedField.getBaseType(), new TypeClosureLazyValueHolder(annotatedField.getTypeClosure()), buildAnnotationMap(annotatedField.getAnnotations()), buildAnnotationMap(annotatedField.getAnnotations()), declaringClass, classTransformer); } /** @@ -70,7 +70,7 @@ public static WeldFieldImpl of(AnnotatedField annotatedFiel * @param field The actual field * @param declaringClass The abstraction of the declaring class */ - private WeldFieldImpl(Field field, final Class rawType, final Type type, Set typeClosure, Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, WeldClass declaringClass, ClassTransformer classTransformer) + private WeldFieldImpl(Field field, final Class rawType, final Type type, LazyValueHolder> typeClosure, Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, WeldClass declaringClass, ClassTransformer classTransformer) { super(annotationMap, declaredAnnotationMap, classTransformer, field, rawType, type, typeClosure, declaringClass); this.field = field; diff --git a/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldMethodImpl.java b/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldMethodImpl.java index af47a9a47a5..f42bbae32e5 100644 --- a/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldMethodImpl.java +++ b/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldMethodImpl.java @@ -32,13 +32,14 @@ import org.jboss.weld.exceptions.DefinitionException; import org.jboss.weld.introspector.MethodSignature; +import org.jboss.weld.introspector.TypeClosureLazyValueHolder; import org.jboss.weld.introspector.WeldClass; import org.jboss.weld.introspector.WeldMethod; import org.jboss.weld.introspector.WeldParameter; import org.jboss.weld.logging.messages.ReflectionMessage; import org.jboss.weld.resources.ClassTransformer; +import org.jboss.weld.util.LazyValueHolder; import org.jboss.weld.util.reflection.Formats; -import org.jboss.weld.util.reflection.HierarchyDiscovery; import org.jboss.weld.util.reflection.Reflections; import org.jboss.weld.util.reflection.SecureReflections; @@ -67,12 +68,12 @@ public class WeldMethodImpl extends AbstractWeldCallable imp public static WeldMethodImpl of(Method method, WeldClass declaringClass, ClassTransformer classTransformer) { - return new WeldMethodImpl(method, Reflections.>cast(method.getReturnType()), method.getGenericReturnType(), new HierarchyDiscovery(method.getGenericReturnType()).getTypeClosure(), null, buildAnnotationMap(method.getAnnotations()), buildAnnotationMap(method.getDeclaredAnnotations()), declaringClass, classTransformer); + return new WeldMethodImpl(method, Reflections.> cast(method.getReturnType()), method.getGenericReturnType(), new TypeClosureLazyValueHolder(method.getGenericReturnType()), null, buildAnnotationMap(method.getAnnotations()), buildAnnotationMap(method.getDeclaredAnnotations()), declaringClass, classTransformer); } public static WeldMethodImpl of(AnnotatedMethod method, WeldClass declaringClass, ClassTransformer classTransformer) { - return new WeldMethodImpl(method.getJavaMember(), Reflections.>cast(method.getJavaMember().getReturnType()), method.getBaseType(), method.getTypeClosure(), method, buildAnnotationMap(method.getAnnotations()), buildAnnotationMap(method.getAnnotations()), declaringClass, classTransformer); + return new WeldMethodImpl(method.getJavaMember(), Reflections.> cast(method.getJavaMember().getReturnType()), method.getBaseType(), new TypeClosureLazyValueHolder(method.getTypeClosure()), method, buildAnnotationMap(method.getAnnotations()), buildAnnotationMap(method.getAnnotations()), declaringClass, classTransformer); } /** @@ -84,7 +85,7 @@ public static WeldMethodImpl of(AnnotatedMethod method, * @param method The underlying method * @param declaringClass The declaring class abstraction */ - private WeldMethodImpl(Method method, final Class rawType, final Type type, Set typeClosure, AnnotatedMethod annotatedMethod, Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, WeldClass declaringClass, ClassTransformer classTransformer) + private WeldMethodImpl(Method method, final Class rawType, final Type type, LazyValueHolder> typeClosure, AnnotatedMethod annotatedMethod, Map, Annotation> annotationMap, Map, Annotation> declaredAnnotationMap, WeldClass declaringClass, ClassTransformer classTransformer) { super(annotationMap, declaredAnnotationMap, classTransformer, method, rawType, type, typeClosure, declaringClass); this.method = method; diff --git a/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldParameterImpl.java b/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldParameterImpl.java index 128a2a23321..bf11d502f9d 100644 --- a/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldParameterImpl.java +++ b/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldParameterImpl.java @@ -26,11 +26,12 @@ import javax.enterprise.inject.spi.AnnotatedCallable; import org.jboss.weld.exceptions.IllegalArgumentException; +import org.jboss.weld.introspector.TypeClosureLazyValueHolder; import org.jboss.weld.introspector.WeldCallable; import org.jboss.weld.introspector.WeldClass; import org.jboss.weld.introspector.WeldParameter; import org.jboss.weld.resources.ClassTransformer; -import org.jboss.weld.util.reflection.HierarchyDiscovery; +import org.jboss.weld.util.LazyValueHolder; /** * Represents a parameter @@ -46,12 +47,12 @@ public class WeldParameterImpl extends AbstractWeldAnnotated im public static WeldParameter of(Annotation[] annotations, Class rawType, Type type, WeldCallable declaringMember, int position, ClassTransformer classTransformer) { - return new WeldParameterImpl(annotations, rawType, type, new HierarchyDiscovery(type).getTypeClosure(), declaringMember, position, classTransformer); + return new WeldParameterImpl(annotations, rawType, type, new TypeClosureLazyValueHolder(type), declaringMember, position, classTransformer); } public static WeldParameter of(Set annotations, Class rawType, Type type, WeldCallable declaringMember, int position, ClassTransformer classTransformer) { - return new WeldParameterImpl(annotations.toArray(EMPTY_ANNOTATIONS), rawType, type, new HierarchyDiscovery(type).getTypeClosure(), declaringMember, position, classTransformer); + return new WeldParameterImpl(annotations.toArray(EMPTY_ANNOTATIONS), rawType, type, new TypeClosureLazyValueHolder(type), declaringMember, position, classTransformer); } private final int position; @@ -63,7 +64,7 @@ public static WeldParameter of(Set annotations, Class rawType, Type type, Set typeClosure, WeldCallable declaringMember, int position, ClassTransformer classTransformer) + protected WeldParameterImpl(Annotation[] annotations, Class rawType, Type type, LazyValueHolder> typeClosure, WeldCallable declaringMember, int position, ClassTransformer classTransformer) { super(buildAnnotationMap(annotations), buildAnnotationMap(annotations), classTransformer, rawType, type, typeClosure); this.declaringMember = declaringMember;