Fixed type resolution for uninitialized factory-method declaration

Issue: SPR-11112

Author: jhoeller

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

@@ -657,10 +657,10 @@ protected Class<?> getTypeForFactoryMethod(String beanName, RootBeanDefinition m
 
 		// If all factory methods have the same return type, return that type.
 		// Can't clearly figure out exact method due to type converting / autowiring!
+		Class<?> commonType = null;
 		boolean cache = false;
 		int minNrOfArgs = mbd.getConstructorArgumentValues().getArgumentCount();
 		Method[] candidates = ReflectionUtils.getUniqueDeclaredMethods(factoryClass);
-		Set<Class<?>> returnTypes = new HashSet<Class<?>>(1);
 		for (Method factoryMethod : candidates) {
 			if (Modifier.isStatic(factoryMethod.getModifiers()) == isStatic &&
 					factoryMethod.getName().equals(mbd.getFactoryMethodName()) &&
@@ -694,7 +694,7 @@ protected Class<?> getTypeForFactoryMethod(String beanName, RootBeanDefinition m
 								factoryMethod, args, getBeanClassLoader());
 						if (returnType != null) {
 							cache = true;
-							returnTypes.add(returnType);
+							commonType = ClassUtils.determineCommonAncestor(returnType, commonType);
 						}
 					}
 					catch (Throwable ex) {
@@ -704,18 +704,17 @@ protected Class<?> getTypeForFactoryMethod(String beanName, RootBeanDefinition m
 					}
 				}
 				else {
-					returnTypes.add(factoryMethod.getReturnType());
+					commonType = ClassUtils.determineCommonAncestor(factoryMethod.getReturnType(), commonType);
 				}
 			}
 		}
 
-		if (returnTypes.size() == 1) {
+		if (commonType != null) {
 			// Clear return type found: all factory methods return same type.
-			Class<?> result = returnTypes.iterator().next();
 			if (cache) {
-				mbd.resolvedFactoryMethodReturnType = result;
+				mbd.resolvedFactoryMethodReturnType = commonType;
 			}
-			return result;
+			return commonType;
 		}
 		else {
 			// Ambiguous return types found: return null to indicate "not determinable".

spring-beans/src/test/java/org/springframework/beans/factory/xml/FactoryMethods.java

@@ -54,11 +54,11 @@ protected static FactoryMethods newInstance(TestBean tb, int num, String name) {
 		return new FactoryMethods(tb, name, num);
 	}
 
-	static FactoryMethods newInstance(TestBean tb, int num, Integer something) {
+	static ExtendedFactoryMethods newInstance(TestBean tb, int num, Integer something) {
 		if (something != null) {
 			throw new IllegalStateException("Should never be called with non-null value");
 		}
-		return new FactoryMethods(tb, null, num);
+		return new ExtendedFactoryMethods(tb, null, num);
 	}
 
 	@SuppressWarnings("unused")
@@ -119,4 +119,12 @@ public void setName(String name) {
 		this.name = name;
 	}
 
+
+	public static class ExtendedFactoryMethods extends FactoryMethods {
+
+		ExtendedFactoryMethods(TestBean tb, String name, int num) {
+			super(tb, name, num);
+		}
+	}
+
 }

spring-core/src/main/java/org/springframework/util/ClassUtils.java

@@ -1143,6 +1143,39 @@ public static Class<?> createCompositeInterface(Class<?>[] interfaces, ClassLoad
 		return Proxy.getProxyClass(classLoader, interfaces);
 	}
 
+	/**
+	 * Determine the common ancestor of the given classes, if any.
+	 * @param clazz1 the class to introspect
+	 * @param clazz2 the other class to introspect
+	 * @return the common ancestor (i.e. common superclass, one interface
+	 * extending the other), or {@code null} if none found. If any of the
+	 * given classes is {@code null}, the other class will be returned.
+	 * @since 3.2.6
+	 */
+	public static Class<?> determineCommonAncestor(Class<?> clazz1, Class<?> clazz2) {
+		if (clazz1 == null) {
+			return clazz2;
+		}
+		if (clazz2 == null) {
+			return clazz1;
+		}
+		if (clazz1.isAssignableFrom(clazz2)) {
+			return clazz1;
+		}
+		if (clazz2.isAssignableFrom(clazz1)) {
+			return clazz2;
+		}
+		Class<?> ancestor = clazz1;
+		do {
+			ancestor = ancestor.getSuperclass();
+			if (ancestor == null || Object.class.equals(ancestor)) {
+				return null;
+			}
+		}
+		while (!ancestor.isAssignableFrom(clazz2));
+		return ancestor;
+	}
+
 	/**
 	 * Check whether the given class is visible in the given ClassLoader.
 	 * @param clazz the class to check (typically an interface)