Revised RootBeanDefinition's externallyManaged* Sets to rely on postProcessingLock

This allows us to avoid early initialization of footprint-heavy ConcurrentHashMaps, and reuses the existing postProcessingLock which will typically be active already when registerExternallyManaged* calls come in from the bean factory's post-processing phase.

Issue: SPR-11343
(cherry picked from commit a599b57)

Author: jhoeller

spring-beans/src/main/java/org/springframework/beans/factory/support/ChildBeanDefinition.java

@@ -17,6 +17,7 @@
 package org.springframework.beans.factory.support;
 
 import org.springframework.beans.MutablePropertyValues;
+import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.ConstructorArgumentValues;
 import org.springframework.util.ObjectUtils;
 
@@ -127,7 +128,7 @@ public ChildBeanDefinition(
 	 * @param original the original bean definition to copy from
 	 */
 	public ChildBeanDefinition(ChildBeanDefinition original) {
-		super(original);
+		super((BeanDefinition) original);
 	}
 
 

spring-beans/src/main/java/org/springframework/beans/factory/support/RootBeanDefinition.java

@@ -18,8 +18,8 @@
 
 import java.lang.reflect.Member;
 import java.lang.reflect.Method;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.HashSet;
+import java.util.Set;
 
 import org.springframework.beans.MutablePropertyValues;
 import org.springframework.beans.factory.config.BeanDefinition;
@@ -48,19 +48,10 @@
 @SuppressWarnings("serial")
 public class RootBeanDefinition extends AbstractBeanDefinition {
 
-	// using a ConcurrentHashMap as a Set
-	private final Map<Member, Boolean> externallyManagedConfigMembers = new ConcurrentHashMap<Member, Boolean>(0);
-
-	// using a ConcurrentHashMap as a Set
-	private final Map<String, Boolean> externallyManagedInitMethods = new ConcurrentHashMap<String, Boolean>(0);
-
-	// using a ConcurrentHashMap as a Set
-	private final Map<String, Boolean> externallyManagedDestroyMethods = new ConcurrentHashMap<String, Boolean>(0);
+	boolean allowCaching = true;
 
 	private BeanDefinitionHolder decoratedDefinition;
 
-	boolean allowCaching = true;
-
 	private volatile Class<?> targetType;
 
 	boolean isFactoryMethodUnique = false;
@@ -87,6 +78,12 @@ public class RootBeanDefinition extends AbstractBeanDefinition {
 	/** Package-visible field that indicates a before-instantiation post-processor having kicked in */
 	volatile Boolean beforeInstantiationResolved;
 
+	private Set<Member> externallyManagedConfigMembers;
+
+	private Set<String> externallyManagedInitMethods;
+
+	private Set<String> externallyManagedDestroyMethods;
+
 
 	/**
 	 * Create a new RootBeanDefinition, to be configured through its bean
@@ -225,9 +222,9 @@ public RootBeanDefinition(String beanClassName, ConstructorArgumentValues cargs,
 	 * @param original the original bean definition to copy from
 	 */
 	public RootBeanDefinition(RootBeanDefinition original) {
-		super(original);
-		this.decoratedDefinition = original.decoratedDefinition;
+		super((BeanDefinition) original);
 		this.allowCaching = original.allowCaching;
+		this.decoratedDefinition = original.decoratedDefinition;
 		this.targetType = original.targetType;
 		this.isFactoryMethodUnique = original.isFactoryMethodUnique;
 	}
@@ -252,6 +249,20 @@ public void setParentName(String parentName) {
 		}
 	}
 
+	/**
+	 * Register a target definition that is being decorated by this bean definition.
+	 */
+	public void setDecoratedDefinition(BeanDefinitionHolder decoratedDefinition) {
+		this.decoratedDefinition = decoratedDefinition;
+	}
+
+	/**
+	 * Return the target definition that is being decorated by this bean definition, if any.
+	 */
+	public BeanDefinitionHolder getDecoratedDefinition() {
+		return this.decoratedDefinition;
+	}
+
 	/**
 	 * Specify the target type of this bean definition, if known in advance.
 	 */
@@ -294,37 +305,52 @@ public Method getResolvedFactoryMethod() {
 		}
 	}
 
-
 	public void registerExternallyManagedConfigMember(Member configMember) {
-		this.externallyManagedConfigMembers.put(configMember, Boolean.TRUE);
+		synchronized (this.postProcessingLock) {
+			if (this.externallyManagedConfigMembers == null) {
+				this.externallyManagedConfigMembers = new HashSet<Member>(1);
+			}
+			this.externallyManagedConfigMembers.add(configMember);
+		}
 	}
 
 	public boolean isExternallyManagedConfigMember(Member configMember) {
-		return this.externallyManagedConfigMembers.containsKey(configMember);
+		synchronized (this.postProcessingLock) {
+			return (this.externallyManagedConfigMembers != null &&
+					this.externallyManagedConfigMembers.contains(configMember));
+		}
 	}
 
 	public void registerExternallyManagedInitMethod(String initMethod) {
-		this.externallyManagedInitMethods.put(initMethod, Boolean.TRUE);
+		synchronized (this.postProcessingLock) {
+			if (this.externallyManagedInitMethods == null) {
+				this.externallyManagedInitMethods = new HashSet<String>(1);
+			}
+			this.externallyManagedInitMethods.add(initMethod);
+		}
 	}
 
 	public boolean isExternallyManagedInitMethod(String initMethod) {
-		return this.externallyManagedInitMethods.containsKey(initMethod);
+		synchronized (this.postProcessingLock) {
+			return (this.externallyManagedInitMethods != null &&
+					this.externallyManagedInitMethods.contains(initMethod));
+		}
 	}
 
 	public void registerExternallyManagedDestroyMethod(String destroyMethod) {
-		this.externallyManagedDestroyMethods.put(destroyMethod, Boolean.TRUE);
+		synchronized (this.postProcessingLock) {
+			if (this.externallyManagedDestroyMethods == null) {
+				this.externallyManagedDestroyMethods = new HashSet<String>(1);
+			}
+			this.externallyManagedDestroyMethods.add(destroyMethod);
+		}
 	}
 
 	public boolean isExternallyManagedDestroyMethod(String destroyMethod) {
-		return this.externallyManagedDestroyMethods.containsKey(destroyMethod);
-	}
-
-	public void setDecoratedDefinition(BeanDefinitionHolder decoratedDefinition) {
-		this.decoratedDefinition = decoratedDefinition;
-	}
-
-	public BeanDefinitionHolder getDecoratedDefinition() {
-		return this.decoratedDefinition;
+		synchronized (this.postProcessingLock) {
+			return (this.externallyManagedDestroyMethods != null &&
+					this.externallyManagedDestroyMethods.contains(destroyMethod));
+		}
 	}