Merge pull request #146 from philwebb/SPR-9796

* SPR-9796:
  Update cache to support concurrent reads
  Cache and late resolve annotations for performance
  Polish Property class
  Develop ConcurrentReferenceHashMap

Author: philwebb

spring-core/src/main/java/org/springframework/core/GenericTypeResolver.java

@@ -16,25 +16,22 @@
 
 package org.springframework.core;
 
-import java.lang.ref.Reference;
-import java.lang.ref.WeakReference;
 import java.lang.reflect.Array;
 import java.lang.reflect.GenericArrayType;
 import java.lang.reflect.Method;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
 import java.lang.reflect.WildcardType;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.WeakHashMap;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
+import org.springframework.util.ConcurrentReferenceHashMap;
 
 /**
  * Helper class for resolving generic types against type variables.
@@ -53,9 +50,8 @@ public abstract class GenericTypeResolver {
 	private static final Log logger = LogFactory.getLog(GenericTypeResolver.class);
 
 	/** Cache from Class to TypeVariable Map */
-	private static final Map<Class, Reference<Map<TypeVariable, Type>>> typeVariableCache =
-			Collections.synchronizedMap(new WeakHashMap<Class, Reference<Map<TypeVariable, Type>>>());
-
+	private static final Map<Class, Map<TypeVariable, Type>> typeVariableCache =
+			new ConcurrentReferenceHashMap<Class, Map<TypeVariable,Type>>();
 
 	/**
 	 * Determine the target type for the given parameter specification.
@@ -408,8 +404,8 @@ static Type getRawType(Type genericType, Map<TypeVariable, Type> typeVariableMap
 	 * all super types, enclosing types and interfaces.
 	 */
 	public static Map<TypeVariable, Type> getTypeVariableMap(Class clazz) {
-		Reference<Map<TypeVariable, Type>> ref = typeVariableCache.get(clazz);
-		Map<TypeVariable, Type> typeVariableMap = (ref != null ? ref.get() : null);
+		Map<TypeVariable, Type> ref = typeVariableCache.get(clazz);
+		Map<TypeVariable, Type> typeVariableMap = (ref != null ? ref : null);
 
 		if (typeVariableMap == null) {
 			typeVariableMap = new HashMap<TypeVariable, Type>();
@@ -441,7 +437,7 @@ public static Map<TypeVariable, Type> getTypeVariableMap(Class clazz) {
 				type = type.getEnclosingClass();
 			}
 
-			typeVariableCache.put(clazz, new WeakReference<Map<TypeVariable, Type>>(typeVariableMap));
+			typeVariableCache.put(clazz, typeVariableMap);
 		}
 
 		return typeVariableMap;

spring-core/src/main/java/org/springframework/core/convert/Property.java

@@ -17,13 +17,16 @@
 package org.springframework.core.convert;
 
 import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
 import org.springframework.core.GenericTypeResolver;
 import org.springframework.core.MethodParameter;
+import org.springframework.util.ConcurrentReferenceHashMap;
+import org.springframework.util.ObjectUtils;
 import org.springframework.util.ReflectionUtils;
 import org.springframework.util.StringUtils;
 
@@ -37,12 +40,16 @@
  * The built TypeDescriptor can then be used to convert from/to the property type.
  *
  * @author Keith Donald
+ * @author Phillip Webb
  * @since 3.1
  * @see TypeDescriptor#TypeDescriptor(Property)
  * @see TypeDescriptor#nested(Property, int)
  */
 public final class Property {
 
+	private static Map<Property, Annotation[]> annotationCache =
+			new ConcurrentReferenceHashMap<Property, Annotation[]>();
+
 	private final Class<?> objectType;
 
 	private final Method readMethod;
@@ -53,8 +60,7 @@ public final class Property {
 
 	private final MethodParameter methodParameter;
 
-	private final Annotation[] annotations;
-
+	private Annotation[] annotations;
 
 	public Property(Class<?> objectType, Method readMethod, Method writeMethod) {
 		this(objectType, readMethod, writeMethod, null);
@@ -65,13 +71,7 @@ public Property(Class<?> objectType, Method readMethod, Method writeMethod, Stri
 		this.readMethod = readMethod;
 		this.writeMethod = writeMethod;
 		this.methodParameter = resolveMethodParameter();
-		if (name != null) {
-			this.name = name;
-		}
-		else {
-			this.name = resolveName();
-		}
-		this.annotations = resolveAnnotations();
+		this.name = (name == null ? resolveName() : name);
 	}
 
 
@@ -118,6 +118,9 @@ MethodParameter getMethodParameter() {
 	}
 
 	Annotation[] getAnnotations() {
+		if(this.annotations == null) {
+			this.annotations = resolveAnnotations();
+		}
 		return this.annotations;
 	}
 
@@ -188,26 +191,26 @@ private MethodParameter resolveParameterType(MethodParameter parameter) {
 	}
 
 	private Annotation[] resolveAnnotations() {
-		Map<Class<?>, Annotation> annMap = new LinkedHashMap<Class<?>, Annotation>();
-		Method readMethod = getReadMethod();
-		if (readMethod != null) {
-			for (Annotation ann : readMethod.getAnnotations()) {
-				annMap.put(ann.annotationType(), ann);
-			}
-		}
-		Method writeMethod = getWriteMethod();
-		if (writeMethod != null) {
-			for (Annotation ann : writeMethod.getAnnotations()) {
-				annMap.put(ann.annotationType(), ann);
-			}
+		Annotation[] annotations = annotationCache.get(this);
+		if(annotations == null) {
+			Map<Class<? extends Annotation>, Annotation> annotationMap = new LinkedHashMap<Class<? extends Annotation>, Annotation>();
+			addAnnotationsToMap(annotationMap, getReadMethod());
+			addAnnotationsToMap(annotationMap, getWriteMethod());
+			addAnnotationsToMap(annotationMap, getField());
+			annotations = annotationMap.values().toArray(new Annotation[annotationMap.size()]);
+			annotationCache.put(this, annotations);
 		}
-		Field field = getField();
-		if (field != null) {
-			for (Annotation ann : field.getAnnotations()) {
-				annMap.put(ann.annotationType(), ann);
+		return annotations;
+	}
+
+	private void addAnnotationsToMap(
+		Map<Class<? extends Annotation>, Annotation> annotationMap,
+		AnnotatedElement object) {
+		if (object != null) {
+			for (Annotation annotation : object.getAnnotations()) {
+				annotationMap.put(annotation.annotationType(), annotation);
 			}
 		}
-		return annMap.values().toArray(new Annotation[annMap.size()]);
 	}
 
 	private Field getField() {
@@ -238,4 +241,34 @@ private Class<?> declaringClass() {
 		}
 	}
 
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int hashCode = 1;
+		hashCode = prime * hashCode + ObjectUtils.nullSafeHashCode(objectType);
+		hashCode = prime * hashCode + ObjectUtils.nullSafeHashCode(readMethod);
+		hashCode = prime * hashCode + ObjectUtils.nullSafeHashCode(writeMethod);
+		hashCode = prime * hashCode + ObjectUtils.nullSafeHashCode(name);
+		return hashCode;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj) {
+			return true;
+		}
+		if (obj == null) {
+			return false;
+		}
+		if (getClass() != obj.getClass()) {
+			return false;
+		}
+		Property other = (Property) obj;
+		boolean equals = true;
+		equals &= ObjectUtils.nullSafeEquals(objectType, other.objectType);
+		equals &= ObjectUtils.nullSafeEquals(readMethod, other.readMethod);
+		equals &= ObjectUtils.nullSafeEquals(writeMethod, other.writeMethod);
+		equals &= ObjectUtils.nullSafeEquals(name, other.name);
+		return equals;
+	}
 }