Fix nested type discovery in ConfigurationPropertiesReflectionHintsProcessor

The old implementation picked up nested types only if they have been
annotated with NestedConfigurationProperty, which not all nested
properties are. Now the processor takes into account all referenced
types. It ignores only types in the java package and interfaces.

This commit also moves some of the tests from
ConfigurationPropertiesBeanFactoryInitializationAotProcessorTests to
ConfigurationPropertiesReflectionHintsProcessorTests for easier
discoverability

Closes gh-31708

Author: mhalbritter

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/ConfigurationPropertiesReflectionHintsProcessor.java

@@ -21,7 +21,6 @@
 import java.beans.Introspector;
 import java.beans.PropertyDescriptor;
 import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.Collection;
@@ -35,12 +34,10 @@
 import org.springframework.beans.ExtendedBeanInfoFactory;
 import org.springframework.boot.context.properties.bind.Bindable;
 import org.springframework.core.ResolvableType;
-import org.springframework.core.annotation.MergedAnnotations;
-import org.springframework.util.ReflectionUtils;
 
 /**
  * Registers a given type on {@link ReflectionHints} for binding purposes, discovering any
- * nested type it may expose via a property.
+ * referenced types it may expose via a property.
  *
  * @author Andy Wilkinson
  * @author Moritz Halbritter
@@ -77,12 +74,22 @@ public static void processConfigurationProperties(Class<?> type, ReflectionHints
 				.process(reflectionHints);
 	}
 
-	private void processNestedType(Class<?> type, ReflectionHints reflectionHints) {
-		processNestedType(type, getBindConstructor(type, true), reflectionHints);
+	private void processType(Class<?> type, ReflectionHints reflectionHints) {
+		if (isTypeIgnored(type)) {
+			return;
+		}
+		new ConfigurationPropertiesReflectionHintsProcessor(type, getBindConstructor(type, true), this.seen)
+				.process(reflectionHints);
 	}
 
-	private void processNestedType(Class<?> type, Constructor<?> bindConstructor, ReflectionHints reflectionHints) {
-		new ConfigurationPropertiesReflectionHintsProcessor(type, bindConstructor, this.seen).process(reflectionHints);
+	private boolean isTypeIgnored(Class<?> type) {
+		if (type.getPackageName().startsWith("java.")) {
+			return true;
+		}
+		if (type.isInterface()) {
+			return true;
+		}
+		return false;
 	}
 
 	private static Constructor<?> getBindConstructor(Class<?> type, boolean nestedType) {
@@ -118,9 +125,8 @@ private void handleConstructor(ReflectionHints reflectionHints) {
 
 	private void handleValueObjectProperties(ReflectionHints reflectionHints) {
 		for (int i = 0; i < this.bindConstructor.getParameterCount(); i++) {
-			String propertyName = this.bindConstructor.getParameters()[i].getName();
 			ResolvableType propertyType = ResolvableType.forConstructorParameter(this.bindConstructor, i);
-			handleProperty(reflectionHints, propertyName, propertyType);
+			registerType(reflectionHints, propertyType);
 		}
 	}
 
@@ -129,16 +135,12 @@ private void handleJavaBeanProperties(ReflectionHints reflectionHints) {
 			Method readMethod = propertyDescriptor.getReadMethod();
 			if (readMethod != null) {
 				ResolvableType propertyType = ResolvableType.forMethodReturnType(readMethod, this.type);
-				String propertyName = propertyDescriptor.getName();
-				if (isSetterMandatory(propertyName, propertyType) && propertyDescriptor.getWriteMethod() == null) {
-					continue;
-				}
-				handleProperty(reflectionHints, propertyName, propertyType);
+				registerType(reflectionHints, propertyType);
 			}
 		}
 	}
 
-	private void handleProperty(ReflectionHints reflectionHints, String propertyName, ResolvableType propertyType) {
+	private void registerType(ReflectionHints reflectionHints, ResolvableType propertyType) {
 		Class<?> propertyClass = propertyType.resolve();
 		if (propertyClass == null) {
 			return;
@@ -148,25 +150,11 @@ private void handleProperty(ReflectionHints reflectionHints, String propertyName
 		}
 		Class<?> componentType = getComponentType(propertyType);
 		if (componentType != null) {
-			// Can be a list of simple types
-			if (!isJavaType(componentType)) {
-				processNestedType(componentType, reflectionHints);
-			}
-		}
-		else if (isNestedType(propertyName, propertyClass)) {
-			processNestedType(propertyClass, reflectionHints);
-		}
-	}
-
-	private boolean isSetterMandatory(String propertyName, ResolvableType propertyType) {
-		Class<?> propertyClass = propertyType.resolve();
-		if (propertyClass == null) {
-			return true;
+			processType(componentType, reflectionHints);
 		}
-		if (getComponentType(propertyType) != null) {
-			return false;
+		else {
+			processType(propertyClass, reflectionHints);
 		}
-		return !isNestedType(propertyName, propertyClass);
 	}
 
 	private Class<?> getComponentType(ResolvableType propertyType) {
@@ -183,27 +171,6 @@ else if (Map.class.isAssignableFrom(propertyClass)) {
 		return null;
 	}
 
-	/**
-	 * Specify whether the specified property refer to a nested type. A nested type
-	 * represents a sub-namespace that need to be fully resolved.
-	 * @param propertyName the name of the property
-	 * @param propertyType the type of the property
-	 * @return whether the specified {@code propertyType} is a nested type
-	 */
-	private boolean isNestedType(String propertyName, Class<?> propertyType) {
-		if (this.type.equals(propertyType.getDeclaringClass())) {
-			return true;
-		}
-		else {
-			Field field = ReflectionUtils.findField(this.type, propertyName);
-			return field != null && MergedAnnotations.from(field).isPresent(NestedConfigurationProperty.class);
-		}
-	}
-
-	private boolean isJavaType(Class<?> candidate) {
-		return candidate.getPackageName().startsWith("java.");
-	}
-
 	private static BeanInfo getBeanInfo(Class<?> beanType) {
 		try {
 			BeanInfo beanInfo = beanInfoFactory.getBeanInfo(beanType);