Extract TypeProcessor into separate class

Author: mhalbritter

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

@@ -16,37 +16,17 @@
 
 package org.springframework.boot.context.properties;
 
-import java.beans.BeanInfo;
-import java.beans.IntrospectionException;
-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.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
 
 import org.springframework.aot.generate.GenerationContext;
-import org.springframework.aot.hint.MemberCategory;
-import org.springframework.aot.hint.RuntimeHints;
 import org.springframework.aot.hint.support.RuntimeHintsUtils;
-import org.springframework.beans.BeanInfoFactory;
-import org.springframework.beans.ExtendedBeanInfoFactory;
 import org.springframework.beans.factory.aot.BeanFactoryInitializationAotContribution;
 import org.springframework.beans.factory.aot.BeanFactoryInitializationAotProcessor;
 import org.springframework.beans.factory.aot.BeanFactoryInitializationCode;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
-import org.springframework.boot.context.properties.bind.Bindable;
-import org.springframework.core.ResolvableType;
-import org.springframework.core.annotation.MergedAnnotations;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.CollectionUtils;
-import org.springframework.util.ReflectionUtils;
 
 /**
  * {@link BeanFactoryInitializationAotProcessor} that contributes runtime hints for
@@ -89,177 +69,8 @@ public void applyTo(GenerationContext generationContext,
 				BeanFactoryInitializationCode beanFactoryInitializationCode) {
 			RuntimeHintsUtils.registerAnnotation(generationContext.getRuntimeHints(), ConfigurationProperties.class);
 			for (Class<?> type : this.types) {
-				TypeProcessor.processConfigurationProperties(type, generationContext.getRuntimeHints());
-			}
-		}
-
-	}
-
-	/**
-	 * Process a given type for binding purposes, discovering any nested type it may
-	 * expose via a property.
-	 */
-	private static final class TypeProcessor {
-
-		private static final BeanInfoFactory beanInfoFactory = new ExtendedBeanInfoFactory();
-
-		private final Class<?> type;
-
-		private final Constructor<?> bindConstructor;
-
-		private final BeanInfo beanInfo;
-
-		private final Set<Class<?>> seen;
-
-		private TypeProcessor(Class<?> type, Constructor<?> bindConstructor, Set<Class<?>> seen) {
-			this.type = type;
-			this.bindConstructor = bindConstructor;
-			this.beanInfo = getBeanInfo(type);
-			this.seen = seen;
-		}
-
-		private static void processConfigurationProperties(Class<?> type, RuntimeHints runtimeHints) {
-			new TypeProcessor(type, getBindConstructor(type, false), new HashSet<>()).process(runtimeHints);
-		}
-
-		private void processNestedType(Class<?> type, RuntimeHints runtimeHints) {
-			processNestedType(type, getBindConstructor(type, true), runtimeHints);
-		}
-
-		private void processNestedType(Class<?> type, Constructor<?> bindConstructor, RuntimeHints runtimeHints) {
-			new TypeProcessor(type, bindConstructor, this.seen).process(runtimeHints);
-		}
-
-		private static Constructor<?> getBindConstructor(Class<?> type, boolean nestedType) {
-			Bindable<?> bindable = Bindable.of(type);
-			return ConfigurationPropertiesBindConstructorProvider.INSTANCE.getBindConstructor(bindable, nestedType);
-		}
-
-		private void process(RuntimeHints runtimeHints) {
-			if (this.seen.contains(this.type)) {
-				return;
-			}
-			this.seen.add(this.type);
-			runtimeHints.reflection().registerType(this.type, (hint) -> hint
-					.withMembers(MemberCategory.INVOKE_DECLARED_METHODS, MemberCategory.INVOKE_PUBLIC_METHODS));
-			handleConstructor(runtimeHints);
-			if (this.bindConstructor != null) {
-				handleValueObjectProperties(runtimeHints);
-			}
-			else if (this.beanInfo != null) {
-				handleJavaBeanProperties(runtimeHints);
-			}
-		}
-
-		private void handleConstructor(RuntimeHints runtimeHints) {
-			if (this.bindConstructor != null) {
-				runtimeHints.reflection().registerConstructor(this.bindConstructor);
-			}
-			else {
-				Arrays.stream(this.type.getDeclaredConstructors())
-						.filter((candidate) -> candidate.getParameterCount() == 0).findFirst()
-						.ifPresent((constructor) -> runtimeHints.reflection().registerConstructor(constructor));
-			}
-		}
-
-		private void handleValueObjectProperties(RuntimeHints runtimeHints) {
-			for (int i = 0; i < this.bindConstructor.getParameterCount(); i++) {
-				String propertyName = this.bindConstructor.getParameters()[i].getName();
-				ResolvableType propertyType = ResolvableType.forConstructorParameter(this.bindConstructor, i);
-				handleProperty(runtimeHints, propertyName, propertyType);
-			}
-		}
-
-		private void handleJavaBeanProperties(RuntimeHints runtimeHints) {
-			for (PropertyDescriptor propertyDescriptor : this.beanInfo.getPropertyDescriptors()) {
-				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(runtimeHints, propertyName, propertyType);
-				}
-			}
-		}
-
-		private void handleProperty(RuntimeHints runtimeHints, String propertyName, ResolvableType propertyType) {
-			Class<?> propertyClass = propertyType.resolve();
-			if (propertyClass == null) {
-				return;
-			}
-			if (propertyClass.equals(this.type)) {
-				return; // Prevent infinite recursion
-			}
-			Class<?> componentType = getComponentType(propertyType);
-			if (componentType != null) {
-				// Can be a list of simple types
-				if (!isJavaType(componentType)) {
-					processNestedType(componentType, runtimeHints);
-				}
-			}
-			else if (isNestedType(propertyName, propertyClass)) {
-				processNestedType(propertyClass, runtimeHints);
-			}
-		}
-
-		private boolean isSetterMandatory(String propertyName, ResolvableType propertyType) {
-			Class<?> propertyClass = propertyType.resolve();
-			if (propertyClass == null) {
-				return true;
-			}
-			if (getComponentType(propertyType) != null) {
-				return false;
-			}
-			return !isNestedType(propertyName, propertyClass);
-		}
-
-		private Class<?> getComponentType(ResolvableType propertyType) {
-			Class<?> propertyClass = propertyType.toClass();
-			if (propertyType.isArray()) {
-				return propertyType.getComponentType().toClass();
-			}
-			else if (Collection.class.isAssignableFrom(propertyClass)) {
-				return propertyType.as(Collection.class).getGeneric(0).toClass();
-			}
-			else if (Map.class.isAssignableFrom(propertyClass)) {
-				return propertyType.as(Map.class).getGeneric(1).toClass();
-			}
-			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);
-				if (beanInfo != null) {
-					return beanInfo;
-				}
-				return Introspector.getBeanInfo(beanType, Introspector.IGNORE_ALL_BEANINFO);
-			}
-			catch (IntrospectionException ex) {
-				return null;
+				ConfigurationPropertiesReflectionHintsRegistrar.processConfigurationProperties(type,
+						generationContext.getRuntimeHints().reflection());
 			}
 		}