Additional configuration classes get detected when imported through XML or registrars

Issue: SPR-11430
Issue: SPR-11723

Author: jhoeller

spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassParser.java

@@ -113,6 +113,8 @@ public int compare(DeferredImportSelectorHolder o1, DeferredImportSelectorHolder
 
 	private final ComponentScanAnnotationParser componentScanParser;
 
+	private final ConditionEvaluator conditionEvaluator;
+
 	private final Map<ConfigurationClass, ConfigurationClass> configurationClasses =
 			new LinkedHashMap<ConfigurationClass, ConfigurationClass>();
 
@@ -125,8 +127,6 @@ public int compare(DeferredImportSelectorHolder o1, DeferredImportSelectorHolder
 
 	private final List<DeferredImportSelectorHolder> deferredImportSelectors = new LinkedList<DeferredImportSelectorHolder>();
 
-	private final ConditionEvaluator conditionEvaluator;
-
 
 	/**
 	 * Create a new {@link ConfigurationClassParser} instance that will be used
@@ -488,6 +488,10 @@ public Set<ConfigurationClass> getConfigurationClasses() {
 		return this.configurationClasses.keySet();
 	}
 
+	public int getPropertySourceCount() {
+		return this.propertySources.size();
+	}
+
 	public List<PropertySource<?>> getPropertySources() {
 		List<PropertySource<?>> propertySources = new LinkedList<PropertySource<?>>();
 		for (Map.Entry<String, List<ResourcePropertySource>> entry : this.propertySources.entrySet()) {

spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassPostProcessor.java

@@ -17,6 +17,7 @@
 package org.springframework.context.annotation;
 
 import java.beans.PropertyDescriptor;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
@@ -269,7 +270,9 @@ public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
 	 */
 	public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
 		Set<BeanDefinitionHolder> configCandidates = new LinkedHashSet<BeanDefinitionHolder>();
-		for (String beanName : registry.getBeanDefinitionNames()) {
+		String[] candidateNames = registry.getBeanDefinitionNames();
+
+		for (String beanName : candidateNames) {
 			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
 			if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
 					ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
@@ -302,32 +305,59 @@ else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.
 		ConfigurationClassParser parser = new ConfigurationClassParser(
 				this.metadataReaderFactory, this.problemReporter, this.environment,
 				this.resourceLoader, this.componentScanBeanNameGenerator, registry);
-		parser.parse(configCandidates);
-		parser.validate();
-
-		// Handle any @PropertySource annotations
-		List<PropertySource<?>> parsedPropertySources = parser.getPropertySources();
-		if (!parsedPropertySources.isEmpty()) {
-			if (!(this.environment instanceof ConfigurableEnvironment)) {
-				logger.warn("Ignoring @PropertySource annotations. " +
-						"Reason: Environment must implement ConfigurableEnvironment");
-			}
-			else {
-				MutablePropertySources envPropertySources = ((ConfigurableEnvironment) this.environment).getPropertySources();
-				for (PropertySource<?> propertySource : parsedPropertySources) {
-					envPropertySources.addLast(propertySource);
+
+		Set<ConfigurationClass> alreadyParsed = new HashSet<ConfigurationClass>(configCandidates.size());
+		int propertySourceCount = 0;
+		do {
+			parser.parse(configCandidates);
+			parser.validate();
+
+			// Handle any @PropertySource annotations
+			if (parser.getPropertySourceCount() > propertySourceCount) {
+				List<PropertySource<?>> parsedPropertySources = parser.getPropertySources();
+				if (!parsedPropertySources.isEmpty()) {
+					if (!(this.environment instanceof ConfigurableEnvironment)) {
+						logger.warn("Ignoring @PropertySource annotations. " +
+								"Reason: Environment must implement ConfigurableEnvironment");
+					}
+					else {
+						MutablePropertySources envPropertySources = ((ConfigurableEnvironment) this.environment).getPropertySources();
+						for (PropertySource<?> propertySource : parsedPropertySources) {
+							envPropertySources.addLast(propertySource);
+						}
+					}
 				}
+				propertySourceCount = parser.getPropertySourceCount();
 			}
-		}
 
-		// Read the model and create bean definitions based on its content
-		if (this.reader == null) {
-			this.reader = new ConfigurationClassBeanDefinitionReader(registry, this.sourceExtractor,
-					this.problemReporter, this.metadataReaderFactory, this.resourceLoader, this.environment,
-					this.importBeanNameGenerator);
-		}
+			Set<ConfigurationClass> configClasses = new LinkedHashSet<ConfigurationClass>(parser.getConfigurationClasses());
+			configClasses.removeAll(alreadyParsed);
 
-		this.reader.loadBeanDefinitions(parser.getConfigurationClasses());
+			// Read the model and create bean definitions based on its content
+			if (this.reader == null) {
+				this.reader = new ConfigurationClassBeanDefinitionReader(registry, this.sourceExtractor,
+						this.problemReporter, this.metadataReaderFactory, this.resourceLoader, this.environment,
+						this.importBeanNameGenerator);
+			}
+			this.reader.loadBeanDefinitions(configClasses);
+			alreadyParsed.addAll(configClasses);
+
+			configCandidates.clear();
+			if (registry.getBeanDefinitionCount() > candidateNames.length) {
+				String[] newCandidateNames = registry.getBeanDefinitionNames();
+				Set<String> oldCandidateNames = new HashSet<String>(Arrays.asList(candidateNames));
+				for (String candidateName : newCandidateNames) {
+					if (!oldCandidateNames.contains(candidateName)) {
+						BeanDefinition beanDef = registry.getBeanDefinition(candidateName);
+						if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
+							configCandidates.add(new BeanDefinitionHolder(beanDef, candidateName));
+						}
+					}
+				}
+				candidateNames = newCandidateNames;
+			}
+		}
+		while (!configCandidates.isEmpty());
 
 		// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
 		if (singletonRegistry != null) {

spring-context/src/test/java/org/springframework/context/annotation/ImportAwareTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2014 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,10 +22,9 @@
 import java.lang.annotation.Target;
 
 import org.junit.Test;
-import org.springframework.beans.BeansException;
+
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
-import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.BeanPostProcessor;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.support.GenericBeanDefinition;
@@ -42,6 +41,7 @@
  * annotation metadata of the @Configuration class that imported it.
  *
  * @author Chris Beams
+ * @author Juergen Hoeller
  * @since 3.1
  */
 public class ImportAwareTests {
@@ -51,8 +51,7 @@ public void directlyAnnotatedWithImport() {
 		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
 		ctx.register(ImportingConfig.class);
 		ctx.refresh();
-
-		ctx.getBean("importedConfigBean");
+		assertNotNull(ctx.getBean("importedConfigBean"));
 
 		ImportedConfig importAwareConfig = ctx.getBean(ImportedConfig.class);
 		AnnotationMetadata importMetadata = importAwareConfig.importMetadata;
@@ -68,8 +67,7 @@ public void indirectlyAnnotatedWithImport() {
 		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
 		ctx.register(IndirectlyImportingConfig.class);
 		ctx.refresh();
-
-		ctx.getBean("importedConfigBean");
+		assertNotNull(ctx.getBean("importedConfigBean"));
 
 		ImportedConfig importAwareConfig = ctx.getBean(ImportedConfig.class);
 		AnnotationMetadata importMetadata = importAwareConfig.importMetadata;
@@ -87,6 +85,7 @@ public void importRegistrar() throws Exception {
 		ctx.register(ImportingRegistrarConfig.class);
 		ctx.refresh();
 		assertNotNull(ctx.getBean("registrarImportedBean"));
+		assertNotNull(ctx.getBean("otherImportedConfigBean"));
 	}
 
 	@Test
@@ -96,9 +95,12 @@ public void importRegistrarWithImport() throws Exception {
 		ctx.register(ImportingRegistrarConfigWithImport.class);
 		ctx.refresh();
 		assertNotNull(ctx.getBean("registrarImportedBean"));
+		assertNotNull(ctx.getBean("otherImportedConfigBean"));
+		assertNotNull(ctx.getBean("importedConfigBean"));
 		assertNotNull(ctx.getBean(ImportedConfig.class));
 	}
 
+
 	@Configuration
 	@Import(ImportedConfig.class)
 	static class ImportingConfig {
@@ -140,28 +142,40 @@ public AsyncAnnotationBeanPostProcessor asyncBPP() {
 	}
 
 
+	@Configuration
+	static class OtherImportedConfig {
+
+		@Bean
+		public String otherImportedConfigBean() {
+			return "";
+		}
+	}
+
+
 	static class BPP implements BeanFactoryAware, BeanPostProcessor {
 
 		@Override
-		public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+		public Object postProcessBeforeInitialization(Object bean, String beanName) {
 			return bean;
 		}
 
 		@Override
-		public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
+		public Object postProcessAfterInitialization(Object bean, String beanName) {
 			return bean;
 		}
 
 		@Override
-		public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+		public void setBeanFactory(BeanFactory beanFactory) {
 		}
 	}
 
+
 	@Configuration
 	@EnableImportRegistrar
 	static class ImportingRegistrarConfig {
 	}
 
+
 	@Configuration
 	@EnableImportRegistrar
 	@Import(ImportedConfig.class)
@@ -174,18 +188,22 @@ static class ImportingRegistrarConfigWithImport {
 	public @interface EnableImportRegistrar {
 	}
 
+
 	static class ImportedRegistrar implements ImportBeanDefinitionRegistrar {
 
 		static boolean called;
 
 		@Override
-		public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
-				BeanDefinitionRegistry registry) {
-			BeanDefinition beanDefinition = new GenericBeanDefinition();
+		public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
+			GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
 			beanDefinition.setBeanClassName(String.class.getName());
-			registry.registerBeanDefinition("registrarImportedBean", beanDefinition );
-			Assert.state(called == false, "ImportedRegistrar called twice");
+			registry.registerBeanDefinition("registrarImportedBean", beanDefinition);
+			GenericBeanDefinition beanDefinition2 = new GenericBeanDefinition();
+			beanDefinition2.setBeanClass(OtherImportedConfig.class);
+			registry.registerBeanDefinition("registrarImportedConfig", beanDefinition2);
+			Assert.state(!called, "ImportedRegistrar called twice");
 			called = true;
 		}
 	}
+
 }