Add @ImportConfigurationPropertiesBean support

Add repeatable `@ImportConfigurationPropertiesBean` annotation that can
be used to import types and treat them as `@ConfigurationProperties`
beans. This annotation is specifically designed to support third-party
classes that can't contain any Spring annotations.

Closes gh-23172

Author: philwebb

spring-boot-project/spring-boot-docs/src/docs/asciidoc/spring-boot-features.adoc

@@ -1227,7 +1227,7 @@ Spring Boot provides infrastructure to bind `@ConfigurationProperties` types and
 You can either enable configuration properties on a class-by-class basis or enable configuration property scanning that works in a similar manner to component scanning.
 
 Sometimes, classes annotated with `@ConfigurationProperties` might not be suitable for scanning, for example, if you're developing your own auto-configuration or you want to enable them conditionally.
-In these cases, specify the list of types to process using the `@EnableConfigurationProperties` annotation.
+In these cases, specify the list of types to process using the `@EnableConfigurationProperties` or `@ImportConfigurationPropertiesBean` annotations.
 This can be done on any `@Configuration` class, as shown in the following example:
 
 [source,java,indent=0]
@@ -1253,7 +1253,7 @@ If you want to define specific packages to scan, you can do so as shown in the f
 
 [NOTE]
 ====
-When the `@ConfigurationProperties` bean is registered using configuration property scanning or via `@EnableConfigurationProperties`, the bean has a conventional name: `<prefix>-<fqn>`, where `<prefix>` is the environment key prefix specified in the `@ConfigurationProperties` annotation and `<fqn>` is the fully qualified name of the bean.
+When the `@ConfigurationProperties` bean is registered using configuration property scanning or via `@EnableConfigurationProperties` or `@ImportConfigurationPropertiesBean`, the bean has a conventional name: `<prefix>-<fqn>`, where `<prefix>` is the environment key prefix specified in the `@ConfigurationProperties` annotation and `<fqn>` is the fully qualified name of the bean.
 If the annotation does not provide any prefix, only the fully qualified name of the bean is used.
 
 The bean name in the example above is `acme-com.example.AcmeProperties`.
@@ -1325,12 +1325,26 @@ To configure a bean from the `Environment` properties, add `@ConfigurationProper
 ----
 	@ConfigurationProperties(prefix = "another")
 	@Bean
-	public AnotherComponent anotherComponent() {
+	public ExampleItem exampleItem() {
 		...
 	}
 ----
 
-Any JavaBean property defined with the `another` prefix is mapped onto that `AnotherComponent` bean in manner similar to the preceding `AcmeProperties` example.
+Any JavaBean property defined with the `another` prefix is mapped onto that `ExampleItem` bean in manner similar to the preceding `AcmeProperties` example.
+
+If you want to use constructor binding with a third-party class, you can't use a `@Bean` method since Spring will need to create the object instance.
+For those situations, you can use an `@ImportConfigurationPropertiesBean` annotation on your `@Configuration` or `@SpringBootApplication` class.
+
+[source,java,indent=0]
+----
+	@SpringBootApplication
+	@ImportConfigurationPropertiesBean(type = ExampleItem.class, prefix = "another")
+	public class MyApp {
+		...
+	}
+----
+
+TIP: `@ImportConfigurationPropertiesBean` also works for JavaBean bindings as long as the type has a single no-arg constructor
 
 
 

spring-boot-project/spring-boot-tools/spring-boot-configuration-processor/src/main/java/org/springframework/boot/configurationprocessor/ConfigurationMetadataAnnotationProcessor.java

@@ -22,6 +22,7 @@
 import java.time.Duration;
 import java.util.Collections;
 import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -40,6 +41,7 @@
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.VariableElement;
 import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
 import javax.lang.model.util.ElementFilter;
 import javax.tools.Diagnostic.Kind;
 
@@ -60,29 +62,28 @@
 @SupportedAnnotationTypes({ "*" })
 public class ConfigurationMetadataAnnotationProcessor extends AbstractProcessor {
 
-	static final String ADDITIONAL_METADATA_LOCATIONS_OPTION = "org.springframework.boot."
-			+ "configurationprocessor.additionalMetadataLocations";
+	static final String ADDITIONAL_METADATA_LOCATIONS_OPTION = "org.springframework.boot.configurationprocessor.additionalMetadataLocations";
 
-	static final String CONFIGURATION_PROPERTIES_ANNOTATION = "org.springframework.boot."
-			+ "context.properties.ConfigurationProperties";
+	static final String CONFIGURATION_PROPERTIES_ANNOTATION = "org.springframework.boot.context.properties.ConfigurationProperties";
 
-	static final String NESTED_CONFIGURATION_PROPERTY_ANNOTATION = "org.springframework.boot."
-			+ "context.properties.NestedConfigurationProperty";
+	static final String NESTED_CONFIGURATION_PROPERTY_ANNOTATION = "org.springframework.boot.context.properties.NestedConfigurationProperty";
 
-	static final String DEPRECATED_CONFIGURATION_PROPERTY_ANNOTATION = "org.springframework.boot."
-			+ "context.properties.DeprecatedConfigurationProperty";
+	static final String DEPRECATED_CONFIGURATION_PROPERTY_ANNOTATION = "org.springframework.boot.context.properties.DeprecatedConfigurationProperty";
 
 	static final String CONSTRUCTOR_BINDING_ANNOTATION = "org.springframework.boot.context.properties.ConstructorBinding";
 
 	static final String DEFAULT_VALUE_ANNOTATION = "org.springframework.boot.context.properties.bind.DefaultValue";
 
 	static final String ENDPOINT_ANNOTATION = "org.springframework.boot.actuate.endpoint.annotation.Endpoint";
 
-	static final String READ_OPERATION_ANNOTATION = "org.springframework.boot.actuate."
-			+ "endpoint.annotation.ReadOperation";
+	static final String READ_OPERATION_ANNOTATION = "org.springframework.boot.actuate.endpoint.annotation.ReadOperation";
 
 	static final String NAME_ANNOTATION = "org.springframework.boot.context.properties.bind.Name";
 
+	static final String IMPORT_CONFIGURATION_PROPERTIES_BEAN_ANNOATION = "org.springframework.boot.context.properties.ImportConfigurationPropertiesBean";
+
+	static final String IMPORT_CONFIGURATION_PROPERTIES_BEANS_ANNOATION = "org.springframework.boot.context.properties.ImportConfigurationPropertiesBeans";
+
 	private static final Set<String> SUPPORTED_OPTIONS = Collections
 			.unmodifiableSet(Collections.singleton(ADDITIONAL_METADATA_LOCATIONS_OPTION));
 
@@ -124,6 +125,14 @@ protected String nameAnnotation() {
 		return NAME_ANNOTATION;
 	}
 
+	protected String importConfigurationPropertiesBeanAnnotation() {
+		return IMPORT_CONFIGURATION_PROPERTIES_BEAN_ANNOATION;
+	}
+
+	protected String importConfigurationPropertiesBeansAnnotation() {
+		return IMPORT_CONFIGURATION_PROPERTIES_BEANS_ANNOATION;
+	}
+
 	@Override
 	public SourceVersion getSupportedSourceVersion() {
 		return SourceVersion.latestSupported();
@@ -142,22 +151,16 @@ public synchronized void init(ProcessingEnvironment env) {
 		this.metadataEnv = new MetadataGenerationEnvironment(env, configurationPropertiesAnnotation(),
 				nestedConfigurationPropertyAnnotation(), deprecatedConfigurationPropertyAnnotation(),
 				constructorBindingAnnotation(), defaultValueAnnotation(), endpointAnnotation(),
-				readOperationAnnotation(), nameAnnotation());
+				readOperationAnnotation(), nameAnnotation(), importConfigurationPropertiesBeanAnnotation(),
+				importConfigurationPropertiesBeansAnnotation());
 	}
 
 	@Override
 	public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
 		this.metadataCollector.processing(roundEnv);
-		TypeElement annotationType = this.metadataEnv.getConfigurationPropertiesAnnotationElement();
-		if (annotationType != null) { // Is @ConfigurationProperties available
-			for (Element element : roundEnv.getElementsAnnotatedWith(annotationType)) {
-				processElement(element);
-			}
-		}
-		TypeElement endpointType = this.metadataEnv.getEndpointAnnotationElement();
-		if (endpointType != null) { // Is @Endpoint available
-			getElementsAnnotatedOrMetaAnnotatedWith(roundEnv, endpointType).forEach(this::processEndpoint);
-		}
+		processConfigurationProperties(roundEnv);
+		processEndpoint(roundEnv);
+		processImportConfigurationPropertiesBean(roundEnv);
 		if (roundEnv.processingOver()) {
 			try {
 				writeMetaData();
@@ -169,6 +172,40 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
 		return false;
 	}
 
+	private void processConfigurationProperties(RoundEnvironment roundEnv) {
+		TypeElement annotationType = this.metadataEnv.getConfigurationPropertiesAnnotationElement();
+		if (annotationType != null) {
+			for (Element element : roundEnv.getElementsAnnotatedWith(annotationType)) {
+				processElement(element);
+			}
+		}
+	}
+
+	private void processEndpoint(RoundEnvironment roundEnv) {
+		TypeElement endpointType = this.metadataEnv.getEndpointAnnotationElement();
+		if (endpointType != null) {
+			getElementsAnnotatedOrMetaAnnotatedWith(roundEnv, endpointType).forEach(this::processEndpoint);
+		}
+	}
+
+	private void processImportConfigurationPropertiesBean(RoundEnvironment roundEnv) {
+		TypeElement importConfigurationPropertiesBeanType = this.metadataEnv
+				.getImportConfigurationPropertiesBeanAnnotationElement();
+		TypeElement importConfigurationPropertiesBeansType = this.metadataEnv
+				.getImportConfigurationPropertiesBeansAnnotationElement();
+		if (importConfigurationPropertiesBeanType == null && importConfigurationPropertiesBeansType == null) {
+			return;
+		}
+		Set<Element> elements = new LinkedHashSet<>();
+		if (importConfigurationPropertiesBeanType != null) {
+			elements.addAll(roundEnv.getElementsAnnotatedWith(importConfigurationPropertiesBeanType));
+		}
+		if (importConfigurationPropertiesBeansType != null) {
+			elements.addAll(roundEnv.getElementsAnnotatedWith(importConfigurationPropertiesBeansType));
+		}
+		elements.forEach(this::processImportConfigurationPropertiesBean);
+	}
+
 	private Map<Element, List<Element>> getElementsAnnotatedOrMetaAnnotatedWith(RoundEnvironment roundEnv,
 			TypeElement annotation) {
 		Map<Element, List<Element>> result = new LinkedHashMap<>();
@@ -187,7 +224,7 @@ private void processElement(Element element) {
 			if (annotation != null) {
 				String prefix = getPrefix(annotation);
 				if (element instanceof TypeElement) {
-					processAnnotatedTypeElement(prefix, (TypeElement) element, new Stack<>());
+					processAnnotatedTypeElement(prefix, (TypeElement) element, false, new Stack<>());
 				}
 				else if (element instanceof ExecutableElement) {
 					processExecutableElement(prefix, (ExecutableElement) element, new Stack<>());
@@ -199,10 +236,11 @@ else if (element instanceof ExecutableElement) {
 		}
 	}
 
-	private void processAnnotatedTypeElement(String prefix, TypeElement element, Stack<TypeElement> seen) {
+	private void processAnnotatedTypeElement(String prefix, TypeElement element, boolean fromImport,
+			Stack<TypeElement> seen) {
 		String type = this.metadataEnv.getTypeUtils().getQualifiedName(element);
 		this.metadataCollector.add(ItemMetadata.newGroup(prefix, type, type, null));
-		processTypeElement(prefix, element, null, seen);
+		processTypeElement(prefix, element, fromImport, null, seen);
 	}
 
 	private void processExecutableElement(String prefix, ExecutableElement element, Stack<TypeElement> seen) {
@@ -220,25 +258,26 @@ private void processExecutableElement(String prefix, ExecutableElement element,
 				}
 				else {
 					this.metadataCollector.add(group);
-					processTypeElement(prefix, (TypeElement) returns, element, seen);
+					processTypeElement(prefix, (TypeElement) returns, false, element, seen);
 				}
 			}
 		}
 	}
 
-	private void processTypeElement(String prefix, TypeElement element, ExecutableElement source,
+	private void processTypeElement(String prefix, TypeElement element, boolean fromImport, ExecutableElement source,
 			Stack<TypeElement> seen) {
 		if (!seen.contains(element)) {
 			seen.push(element);
-			new PropertyDescriptorResolver(this.metadataEnv).resolve(element, source).forEach((descriptor) -> {
-				this.metadataCollector.add(descriptor.resolveItemMetadata(prefix, this.metadataEnv));
-				if (descriptor.isNested(this.metadataEnv)) {
-					TypeElement nestedTypeElement = (TypeElement) this.metadataEnv.getTypeUtils()
-							.asElement(descriptor.getType());
-					String nestedPrefix = ConfigurationMetadata.nestedPrefix(prefix, descriptor.getName());
-					processTypeElement(nestedPrefix, nestedTypeElement, source, seen);
-				}
-			});
+			new PropertyDescriptorResolver(this.metadataEnv).resolve(element, fromImport, source)
+					.forEach((descriptor) -> {
+						this.metadataCollector.add(descriptor.resolveItemMetadata(prefix, this.metadataEnv));
+						if (descriptor.isNested(this.metadataEnv)) {
+							TypeElement nestedTypeElement = (TypeElement) this.metadataEnv.getTypeUtils()
+									.asElement(descriptor.getType());
+							String nestedPrefix = ConfigurationMetadata.nestedPrefix(prefix, descriptor.getName());
+							processTypeElement(nestedPrefix, nestedTypeElement, false, source, seen);
+						}
+					});
 			seen.pop();
 		}
 	}
@@ -275,6 +314,21 @@ private void processEndpoint(AnnotationMirror annotation, TypeElement element) {
 		}
 	}
 
+	private void processImportConfigurationPropertiesBean(Element element) {
+		this.metadataEnv.getImportConfigurationPropertiesBeanAnnotations(element)
+				.forEach(this::processImportConfigurationPropertiesBean);
+	}
+
+	@SuppressWarnings("unchecked")
+	private void processImportConfigurationPropertiesBean(AnnotationMirror annotation) {
+		String prefix = getPrefix(annotation);
+		List<TypeMirror> types = (List<TypeMirror>) this.metadataEnv.getAnnotationElementValues(annotation).get("type");
+		for (TypeMirror type : types) {
+			Element element = this.metadataEnv.getTypeUtils().asElement(type);
+			processAnnotatedTypeElement(prefix, (TypeElement) element, true, new Stack<>());
+		}
+	}
+
 	private boolean hasMainReadOperation(TypeElement element) {
 		for (ExecutableElement method : ElementFilter.methodsIn(element.getEnclosedElements())) {
 			if (this.metadataEnv.getReadOperationAnnotation(method) != null

spring-boot-project/spring-boot-tools/spring-boot-configuration-processor/src/main/java/org/springframework/boot/configurationprocessor/MetadataGenerationEnvironment.java

@@ -97,10 +97,15 @@ class MetadataGenerationEnvironment {
 
 	private final String nameAnnotation;
 
+	private final String importConfigurationPropertiesBeanAnnotation;
+
+	private final String importConfigurationPropertiesBeansAnnotation;
+
 	MetadataGenerationEnvironment(ProcessingEnvironment environment, String configurationPropertiesAnnotation,
 			String nestedConfigurationPropertyAnnotation, String deprecatedConfigurationPropertyAnnotation,
 			String constructorBindingAnnotation, String defaultValueAnnotation, String endpointAnnotation,
-			String readOperationAnnotation, String nameAnnotation) {
+			String readOperationAnnotation, String nameAnnotation, String importConfigurationPropertiesBeanAnnotation,
+			String importConfigurationPropertiesBeansAnnotation) {
 		this.typeUtils = new TypeUtils(environment);
 		this.elements = environment.getElementUtils();
 		this.messager = environment.getMessager();
@@ -113,6 +118,8 @@ class MetadataGenerationEnvironment {
 		this.endpointAnnotation = endpointAnnotation;
 		this.readOperationAnnotation = readOperationAnnotation;
 		this.nameAnnotation = nameAnnotation;
+		this.importConfigurationPropertiesBeanAnnotation = importConfigurationPropertiesBeanAnnotation;
+		this.importConfigurationPropertiesBeansAnnotation = importConfigurationPropertiesBeansAnnotation;
 	}
 
 	private static FieldValuesParser resolveFieldValuesParser(ProcessingEnvironment env) {
@@ -258,6 +265,14 @@ TypeElement getConfigurationPropertiesAnnotationElement() {
 		return this.elements.getTypeElement(this.configurationPropertiesAnnotation);
 	}
 
+	TypeElement getImportConfigurationPropertiesBeanAnnotationElement() {
+		return this.elements.getTypeElement(this.importConfigurationPropertiesBeanAnnotation);
+	}
+
+	TypeElement getImportConfigurationPropertiesBeansAnnotationElement() {
+		return this.elements.getTypeElement(this.importConfigurationPropertiesBeansAnnotation);
+	}
+
 	AnnotationMirror getConfigurationPropertiesAnnotation(Element element) {
 		return getAnnotation(element, this.configurationPropertiesAnnotation);
 	}
@@ -282,6 +297,22 @@ AnnotationMirror getNameAnnotation(Element element) {
 		return getAnnotation(element, this.nameAnnotation);
 	}
 
+	List<AnnotationMirror> getImportConfigurationPropertiesBeanAnnotations(Element element) {
+		List<AnnotationMirror> annotations = new ArrayList<>();
+		AnnotationMirror importBean = getAnnotation(element, this.importConfigurationPropertiesBeanAnnotation);
+		if (importBean != null) {
+			annotations.add(importBean);
+		}
+		AnnotationMirror importBeans = getAnnotation(element, this.importConfigurationPropertiesBeansAnnotation);
+		if (importBeans != null) {
+			AnnotationValue value = importBeans.getElementValues().values().iterator().next();
+			for (Object contained : (List<?>) value.getValue()) {
+				annotations.add((AnnotationMirror) contained);
+			}
+		}
+		return Collections.unmodifiableList(annotations);
+	}
+
 	boolean hasNullableAnnotation(Element element) {
 		return getAnnotation(element, NULLABLE_ANNOTATION) != null;
 	}

spring-boot-project/spring-boot-tools/spring-boot-configuration-processor/src/main/java/org/springframework/boot/configurationprocessor/PropertyDescriptorResolver.java

@@ -49,16 +49,19 @@ class PropertyDescriptorResolver {
 	 * specified {@link TypeElement type} based on the specified {@link ExecutableElement
 	 * factory method}, if any.
 	 * @param type the target type
+	 * @param fromImport it the type was imported via a
+	 * {@code @ImportConfigurationPropertiesBean}
 	 * @param factoryMethod the method that triggered the metadata for that {@code type}
 	 * or {@code null}
 	 * @return the candidate properties for metadata generation
 	 */
-	Stream<PropertyDescriptor<?>> resolve(TypeElement type, ExecutableElement factoryMethod) {
+	Stream<PropertyDescriptor<?>> resolve(TypeElement type, boolean fromImport, ExecutableElement factoryMethod) {
 		TypeElementMembers members = new TypeElementMembers(this.environment, type);
 		if (factoryMethod != null) {
 			return resolveJavaBeanProperties(type, factoryMethod, members);
 		}
-		return resolve(ConfigurationPropertiesTypeElement.of(type, this.environment), factoryMethod, members);
+		return resolve(ConfigurationPropertiesTypeElement.of(type, fromImport, this.environment), factoryMethod,
+				members);
 	}
 
 	private Stream<PropertyDescriptor<?>> resolve(ConfigurationPropertiesTypeElement type,
@@ -178,20 +181,29 @@ private ExecutableElement findBoundConstructor() {
 			return boundConstructor;
 		}
 
-		static ConfigurationPropertiesTypeElement of(TypeElement type, MetadataGenerationEnvironment env) {
-			boolean constructorBoundType = isConstructorBoundType(type, env);
+		static ConfigurationPropertiesTypeElement of(TypeElement type, boolean fromImport,
+				MetadataGenerationEnvironment env) {
 			List<ExecutableElement> constructors = ElementFilter.constructorsIn(type.getEnclosedElements());
 			List<ExecutableElement> boundConstructors = constructors.stream()
 					.filter(env::hasConstructorBindingAnnotation).collect(Collectors.toList());
+			boolean constructorBoundType = isConstructorBoundType(type, fromImport, constructors, env);
 			return new ConfigurationPropertiesTypeElement(type, constructorBoundType, constructors, boundConstructors);
 		}
 
-		private static boolean isConstructorBoundType(TypeElement type, MetadataGenerationEnvironment env) {
+		private static boolean isConstructorBoundType(TypeElement type, boolean fromImport,
+				List<ExecutableElement> constructors, MetadataGenerationEnvironment env) {
 			if (env.hasConstructorBindingAnnotation(type)) {
 				return true;
 			}
 			if (type.getNestingKind() == NestingKind.MEMBER) {
-				return isConstructorBoundType((TypeElement) type.getEnclosingElement(), env);
+				return isConstructorBoundType((TypeElement) type.getEnclosingElement(), false, constructors, env);
+			}
+			if (fromImport) {
+				for (ExecutableElement constructor : constructors) {
+					if (!constructor.getParameters().isEmpty()) {
+						return true;
+					}
+				}
 			}
 			return false;
 		}