Select ambiguous write method based on read method (matching its return type)

Also avoids unnecessary checks in name-based PropertyDescriptor constructor.

See gh-29320

spring-beans/src/main/java/org/springframework/beans/PropertyDescriptorUtils.java

@@ -20,8 +20,10 @@ import java.beans.IntrospectionException;
 import java.beans.Introspector;
 import java.beans.PropertyDescriptor;
 import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Enumeration;
+import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
 
@@ -52,8 +54,10 @@ abstract class PropertyDescriptorUtils {
 	 * @see SimpleBeanInfoFactory
 	 * @see java.beans.Introspector#getBeanInfo(Class)
 	 */
-	public static Collection<PropertyDescriptor> determineBasicProperties(Class<?> beanClass) throws IntrospectionException {
+	public static Collection<? extends PropertyDescriptor> determineBasicProperties(Class<?> beanClass)
-		Map<String, PropertyDescriptor> pdMap = new TreeMap<>();
+			throws IntrospectionException {
+
+		Map<String, BasicPropertyDescriptor> pdMap = new TreeMap<>();
 
 		for (Method method : beanClass.getMethods()) {
 			String methodName = method.getName();
@@ -81,39 +85,26 @@ abstract class PropertyDescriptorUtils {
 				continue;
 			}
 
-			PropertyDescriptor pd = pdMap.get(propertyName);
+			BasicPropertyDescriptor pd = pdMap.get(propertyName);
 			if (pd != null) {
 				if (setter) {
 					if (pd.getWriteMethod() == null ||
 							pd.getWriteMethod().getParameterTypes()[0].isAssignableFrom(method.getParameterTypes()[0])) {
-						try {
+						pd.setWriteMethod(method);
-							pd.setWriteMethod(method);
+					}
-						}
+					else {
-						catch (IntrospectionException ex) {
+						pd.addWriteMethod(method);
-							// typically a type mismatch -> ignore
-						}
 					}
 				}
 				else {
 					if (pd.getReadMethod() == null ||
 							(pd.getReadMethod().getReturnType() == method.getReturnType() && method.getName().startsWith("is"))) {
-						try {
+						pd.setReadMethod(method);
-							pd.setReadMethod(method);
-						}
-						catch (IntrospectionException ex) {
-							// typically a type mismatch -> ignore
-						}
 					}
 				}
 			}
 			else {
-				pd = new BasicPropertyDescriptor(propertyName, beanClass);
+				pd = new BasicPropertyDescriptor(propertyName, (!setter ? method : null), (setter ? method : null));
-				if (setter) {
-					pd.setWriteMethod(method);
-				}
-				else {
-					pd.setReadMethod(method);
-				}
 				pdMap.put(propertyName, pd);
 			}
 		}
@@ -277,8 +268,12 @@ abstract class PropertyDescriptorUtils {
 		@Nullable
 		private Method writeMethod;
 
-		public BasicPropertyDescriptor(String propertyName, Class<?> beanClass) throws IntrospectionException {
+		private final List<Method> alternativeWriteMethods = new ArrayList<>();
-			super(propertyName, beanClass, null, null);
+
+		public BasicPropertyDescriptor(String propertyName, @Nullable Method readMethod, @Nullable Method writeMethod)
+				throws IntrospectionException {
+
+			super(propertyName, readMethod, writeMethod);
 		}
 
 		@Override
@@ -297,11 +292,33 @@ abstract class PropertyDescriptorUtils {
 			this.writeMethod = writeMethod;
 		}
 
+		public void addWriteMethod(Method writeMethod) {
+			if (this.writeMethod != null) {
+				this.alternativeWriteMethods.add(this.writeMethod);
+				this.writeMethod = null;
+			}
+			this.alternativeWriteMethods.add(writeMethod);
+		}
+
 		@Override
 		@Nullable
 		public Method getWriteMethod() {
+			if (this.writeMethod == null && !this.alternativeWriteMethods.isEmpty()) {
+				if (this.readMethod == null) {
+					return this.alternativeWriteMethods.get(0);
+				}
+				else {
+					for (Method method : this.alternativeWriteMethods) {
+						if (this.readMethod.getReturnType().isAssignableFrom(method.getParameterTypes()[0])) {
+							this.writeMethod = method;
+							break;
+						}
+					}
+				}
+			}
 			return this.writeMethod;
 		}
 	}
 
+
 }

spring-beans/src/main/java/org/springframework/beans/SimpleBeanInfoFactory.java

@@ -47,7 +47,9 @@ public class SimpleBeanInfoFactory implements BeanInfoFactory, Ordered {
 	@Override
 	@NonNull
 	public BeanInfo getBeanInfo(Class<?> beanClass) throws IntrospectionException {
-		Collection<PropertyDescriptor> pds = PropertyDescriptorUtils.determineBasicProperties(beanClass);
+		Collection<? extends PropertyDescriptor> pds =
+				PropertyDescriptorUtils.determineBasicProperties(beanClass);
+
 		return new SimpleBeanInfo() {
 			@Override
 			public PropertyDescriptor[] getPropertyDescriptors() {

spring-beans/src/test/java/org/springframework/beans/BeanWrapperTests.java

@@ -153,6 +153,16 @@ class BeanWrapperTests extends AbstractPropertyAccessorTests {
 		assertThat(accessor.getPropertyValue("object")).isEqualTo(8);
 	}
 
+	@Test
+	void setterOverload() {
+		SetterOverload target = new SetterOverload();
+		BeanWrapper accessor = createAccessor(target);
+		accessor.setPropertyValue("object", "a String");
+		assertThat(target.value).isEqualTo("a String");
+		assertThat(target.getObject()).isEqualTo("a String");
+		assertThat(accessor.getPropertyValue("object")).isEqualTo("a String");
+	}
+
 	@Test
 	void propertyDescriptors() throws Exception {
 		TestBean target = new TestBean();
@@ -348,6 +358,24 @@ class BeanWrapperTests extends AbstractPropertyAccessorTests {
 	}
 
 
+	public static class SetterOverload {
+
+		public String value;
+
+		public void setObject(Integer length) {
+			this.value = length.toString();
+		}
+
+		public void setObject(String object) {
+			this.value = object;
+		}
+
+		public String getObject() {
+			return this.value;
+		}
+	}
+
+
 	public static class GetterWithOptional {
 
 		public TestBean value;