introduced BeanDefinitionRegistryPostProcessor extension to BeanFactoryPostProcessor; @configuration classes support definition of BeanFactoryPostProcessor beans as well (SPR-6455, SPR-6611)

Author: jhoeller

org.springframework.context/src/main/java/org/springframework/context/annotation/ConfigurationClassBeanDefinitionReader.java

@@ -27,6 +27,7 @@
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+
 import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
 import org.springframework.beans.factory.annotation.Autowire;
 import org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor;
@@ -48,7 +49,6 @@
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.core.type.MethodMetadata;
 import org.springframework.core.type.StandardAnnotationMetadata;
-import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
 import org.springframework.core.type.classreading.MetadataReader;
 import org.springframework.core.type.classreading.MetadataReaderFactory;
 import org.springframework.stereotype.Component;
@@ -68,11 +68,11 @@
  */
 class ConfigurationClassBeanDefinitionReader {
 
-	static final String CONFIGURATION_CLASS_FULL = "full";
+	private static final String CONFIGURATION_CLASS_FULL = "full";
 
-	static final String CONFIGURATION_CLASS_LITE = "lite";
+	private static final String CONFIGURATION_CLASS_LITE = "lite";
 
-	static final String CONFIGURATION_CLASS_ATTRIBUTE =
+	private static final String CONFIGURATION_CLASS_ATTRIBUTE =
 		Conventions.getQualifiedAttributeName(ConfigurationClassPostProcessor.class, "configurationClass");
 
 	private static final Log logger = LogFactory.getLog(ConfigurationClassBeanDefinitionReader.class);
@@ -86,7 +86,6 @@ class ConfigurationClassBeanDefinitionReader {
 	private final MetadataReaderFactory metadataReaderFactory;
 
 
-
 	/**
 	 * Create a new {@link ConfigurationClassBeanDefinitionReader} instance that will be used
 	 * to populate the given {@link BeanDefinitionRegistry}.
@@ -95,6 +94,7 @@ class ConfigurationClassBeanDefinitionReader {
 	 */
 	public ConfigurationClassBeanDefinitionReader(BeanDefinitionRegistry registry, SourceExtractor sourceExtractor,
 			ProblemReporter problemReporter, MetadataReaderFactory metadataReaderFactory) {
+
 		this.registry = registry;
 		this.sourceExtractor = sourceExtractor;
 		this.problemReporter = problemReporter;
@@ -145,13 +145,15 @@ private void doLoadBeanDefinitionForConfigurationClassIfNecessary(ConfigurationC
 			if (logger.isDebugEnabled()) {
 				logger.debug(String.format("Registered bean definition for imported @Configuration class %s", configBeanName));
 			}
-		} else {
+		}
+		else {
 			try {
 				MetadataReader reader = this.metadataReaderFactory.getMetadataReader(className);
 				AnnotationMetadata metadata = reader.getAnnotationMetadata();
 				this.problemReporter.error(
 						new InvalidConfigurationImportProblem(className, reader.getResource(), metadata));
-			} catch (IOException ex) {
+			}
+			catch (IOException ex) {
 				throw new IllegalStateException("Could not create MetadataReader for class " + className);
 			}
 		}
@@ -181,7 +183,7 @@ private void loadBeanDefinitionsForModelMethod(ConfigurationClassMethod method)
 			this.registry.registerAlias(beanName, alias);
 		}
 
-		// has this already been overriden (i.e.: via XML)?
+		// has this already been overridden (e.g. via XML)?
 		if (this.registry.containsBeanDefinition(beanName)) {
 			BeanDefinition existingBeanDef = registry.getBeanDefinition(beanName);
 			// is the existing bean definition one that was created from a configuration class?
@@ -277,14 +279,15 @@ private void loadBeanDefinitionsFromImportedResources(Map<String, Class<?>> impo
 		}
 	}
 
+
 	/**
 	 * Check whether the given bean definition is a candidate for a configuration class,
 	 * and mark it accordingly.
 	 * @param beanDef the bean definition to check
 	 * @param metadataReaderFactory the current factory in use by the caller
 	 * @return whether the candidate qualifies as (any kind of) configuration class
 	 */
-	static boolean checkConfigurationClassCandidate(BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {
+	public static boolean checkConfigurationClassCandidate(BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {
 		AnnotationMetadata metadata = null;
 
 		// Check already loaded Class if present...
@@ -322,14 +325,22 @@ else if (metadata.isAnnotated(Component.class.getName()) ||
 		return false;
 	}
 
+	/**
+	 * Determine whether the given bean definition indicates a full @Configuration class.
+	 */
+	public static boolean isFullConfigurationClass(BeanDefinition beanDef) {
+		return CONFIGURATION_CLASS_FULL.equals(beanDef.getAttribute(CONFIGURATION_CLASS_ATTRIBUTE));
+	}
+
+
 	/**
 	 * {@link RootBeanDefinition} marker subclass used to signify that a bean definition
 	 * created from a configuration class as opposed to any other configuration source.
 	 * Used in bean overriding cases where it's necessary to determine whether the bean
 	 * definition was created externally.
 	 */
 	@SuppressWarnings("serial")
-	private class ConfigurationClassBeanDefinition extends RootBeanDefinition implements AnnotatedBeanDefinition {
+	private static class ConfigurationClassBeanDefinition extends RootBeanDefinition implements AnnotatedBeanDefinition {
 
 		private AnnotationMetadata annotationMetadata;
 

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

@@ -16,9 +16,6 @@
 
 package org.springframework.context.annotation;
 
-import static org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.CONFIGURATION_CLASS_ATTRIBUTE;
-import static org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.CONFIGURATION_CLASS_FULL;
-
 import java.io.IOException;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
@@ -40,6 +37,7 @@
 import org.springframework.beans.factory.parsing.SourceExtractor;
 import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
 import org.springframework.core.Ordered;
 import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
 import org.springframework.core.type.classreading.MetadataReaderFactory;
@@ -63,7 +61,7 @@
  * @author Juergen Hoeller
  * @since 3.0
  */
-public class ConfigurationClassPostProcessor implements BeanFactoryPostProcessor, BeanClassLoaderAware {
+public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor, BeanClassLoaderAware {
 
 	/** Whether the CGLIB2 library is present on the classpath */
 	private static final boolean cglibAvailable = ClassUtils.isPresent(
@@ -124,16 +122,18 @@ public int getOrder() {
 	}
 
 
+	/**
+	 * Derive further bean definitions from the configuration classes in the registry.
+	 */
+	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
+		processConfigBeanDefinitions(registry);
+	}
+
 	/**
 	 * Prepare the Configuration classes for servicing bean requests at runtime
 	 * by replacing them with CGLIB-enhanced subclasses.
 	 */
 	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
-		if (!(beanFactory instanceof BeanDefinitionRegistry)) {
-			throw new IllegalStateException(
-					"ConfigurationClassPostProcessor expects a BeanFactory that implements BeanDefinitionRegistry");
-		}
-		processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
 		enhanceConfigurationClasses(beanFactory);
 	}
 
@@ -174,8 +174,8 @@ public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
 		parser.validate();
 
 		// Read the model and create bean definitions based on its content
-		ConfigurationClassBeanDefinitionReader reader =
-			new ConfigurationClassBeanDefinitionReader(registry, this.sourceExtractor, this.problemReporter, this.metadataReaderFactory);
+		ConfigurationClassBeanDefinitionReader reader = new ConfigurationClassBeanDefinitionReader(
+				registry, this.sourceExtractor, this.problemReporter, this.metadataReaderFactory);
 		reader.loadBeanDefinitions(parser.getConfigurationClasses());
 	}
 
@@ -189,7 +189,7 @@ public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFact
 		Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<String, AbstractBeanDefinition>();
 		for (String beanName : beanFactory.getBeanDefinitionNames()) {
 			BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
-			if (CONFIGURATION_CLASS_FULL.equals(beanDef.getAttribute(CONFIGURATION_CLASS_ATTRIBUTE))) {
+			if (ConfigurationClassBeanDefinitionReader.isFullConfigurationClass(beanDef)) {
 				if (!(beanDef instanceof AbstractBeanDefinition)) {
 					throw new BeanDefinitionStoreException("Cannot enhance @Configuration bean definition '" +
 							beanName + "' since it is not stored in an AbstractBeanDefinition subclass");

org.springframework.context/src/main/java/org/springframework/context/support/AbstractApplicationContext.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2010 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.
@@ -39,6 +39,8 @@
 import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
 import org.springframework.beans.factory.config.BeanPostProcessor;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
 import org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor;
 import org.springframework.beans.support.ResourceEditorRegistrar;
 import org.springframework.context.ApplicationContext;
@@ -569,6 +571,21 @@ protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactor
 	 * <p>Must be called before singleton instantiation.
 	 */
 	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
+		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
+		if (beanFactory instanceof BeanDefinitionRegistry) {
+			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
+			for (BeanFactoryPostProcessor postProcessor : getBeanFactoryPostProcessors()) {
+				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
+					((BeanDefinitionRegistryPostProcessor) postProcessor).postProcessBeanDefinitionRegistry(registry);
+				}
+			}
+			Collection<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
+					beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class, true, false).values();
+			for (BeanDefinitionRegistryPostProcessor postProcessor : registryPostProcessors) {
+				postProcessor.postProcessBeanDefinitionRegistry(registry);
+			}
+		}
+
 		// Invoke factory processors registered with the context instance.
 		invokeBeanFactoryPostProcessors(getBeanFactoryPostProcessors(), beanFactory);
 

org.springframework.context/src/test/java/org/springframework/context/annotation/configuration/ConfigurationClassProcessingTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2010 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.
@@ -26,9 +26,13 @@
 import org.springframework.beans.factory.annotation.Required;
 import org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor;
 import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.beans.factory.parsing.BeanDefinitionParsingException;
 import org.springframework.beans.factory.support.DefaultListableBeanFactory;
 import org.springframework.beans.factory.support.RootBeanDefinition;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.annotation.AnnotationConfigUtils;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -58,6 +62,7 @@ private BeanFactory initBeanFactory(Class<?>... configClasses) {
 			factory.registerBeanDefinition(configBeanName, new RootBeanDefinition(configClass));
 		}
 		ConfigurationClassPostProcessor ccpp = new ConfigurationClassPostProcessor();
+		ccpp.postProcessBeanDefinitionRegistry(factory);
 		ccpp.postProcessBeanFactory(factory);
 		RequiredAnnotationBeanPostProcessor rapp = new RequiredAnnotationBeanPostProcessor();
 		rapp.setBeanFactory(factory);
@@ -123,6 +128,19 @@ public void configurationWithPrototypeScopedBeans() {
 		assertNotSame(bar.getSpouse(), baz);
 	}
 
+	@Test
+	public void configurationWithPostProcessor() {
+		BeanFactory factory = new AnnotationConfigApplicationContext(ConfigWithPostProcessor.class);
+
+		TestBean foo = factory.getBean("foo", TestBean.class);
+		ITestBean bar = factory.getBean("bar", ITestBean.class);
+		ITestBean baz = factory.getBean("baz", ITestBean.class);
+
+		assertEquals("foo-processed", foo.getName());
+		assertEquals("bar-processed", bar.getName());
+		assertEquals("baz-processed", baz.getName());
+	}
+
 
 	@Configuration
 	static class ConfigWithBeanWithCustomName {
@@ -152,7 +170,9 @@ static class SimplestPossibleConfig {
 
 	@Configuration
 	static class ConfigWithBeanWithAliases {
+
 		static TestBean testBean = new TestBean();
+
 		@Bean(name={"name1", "alias1", "alias2", "alias3"})
 		public TestBean methodName() {
 			return testBean;
@@ -177,7 +197,40 @@ static class ConfigWithPrototypeBean {
 
 		@Bean @Scope("prototype")
 		public TestBean baz() {
-			return new TestBean("bar");
+			return new TestBean("baz");
+		}
+	}
+
+
+	static class ConfigWithPostProcessor extends ConfigWithPrototypeBean {
+
+		@Bean
+		public BeanPostProcessor beanPostProcessor() {
+			return new BeanPostProcessor() {
+				String nameSuffix;
+				public void setNameSuffix(String nameSuffix) {
+					this.nameSuffix = nameSuffix;
+				}
+				public Object postProcessBeforeInitialization(Object bean, String beanName) {
+					if (bean instanceof ITestBean) {
+						((ITestBean) bean).setName(((ITestBean) bean).getName() + nameSuffix);
+					}
+					return bean;
+				}
+				public Object postProcessAfterInitialization(Object bean, String beanName) {
+					return bean;
+				}
+			};
+		}
+
+		@Bean
+		public BeanFactoryPostProcessor beanFactoryPostProcessor() {
+			return new BeanFactoryPostProcessor() {
+				public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
+					BeanDefinition bd = beanFactory.getBeanDefinition("beanPostProcessor");
+					bd.getPropertyValues().addPropertyValue("nameSuffix", "-processed");
+				}
+			};
 		}
 	}
 

org.springframework.context/src/test/java/org/springframework/context/annotation/configuration/ImportResourceTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2010 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.
@@ -16,16 +16,17 @@
 
 package org.springframework.context.annotation.configuration;
 
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-
 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.annotation.Before;
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
 import org.junit.Ignore;
 import org.junit.Test;
+import test.beans.TestBean;
+
 import org.springframework.aop.support.AopUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.beans.factory.support.PropertiesBeanDefinitionReader;
 import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
 import org.springframework.context.ApplicationContext;
@@ -34,26 +35,29 @@
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.ImportResource;
 
-import test.beans.TestBean;
-
 /**
  * Integration tests for {@link ImportResource} support.
  *
  * @author Chris Beams
+ * @author Juergen Hoeller
  */
 public class ImportResourceTests {
     @Test
     public void testImportXml() {
         AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(ImportXmlConfig.class);
         assertTrue("did not contain java-declared bean", ctx.containsBean("javaDeclaredBean"));
         assertTrue("did not contain xml-declared bean", ctx.containsBean("xmlDeclaredBean"));
+		TestBean tb = ctx.getBean("javaDeclaredBean", TestBean.class);
+		assertEquals("myName", tb.getName());
     }
 
     @Configuration
     @ImportResource("classpath:org/springframework/context/annotation/configuration/ImportXmlConfig-context.xml")
     static class ImportXmlConfig {
+		@Value("${name}")
+		private String name;
         public @Bean TestBean javaDeclaredBean() {
-            return new TestBean("java.declared");
+            return new TestBean(this.name);
         }
     }
 
@@ -63,6 +67,8 @@ public void testImportXmlWithRelativePath() {
         AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(ImportXmlWithRelativePathConfig.class);
         assertTrue("did not contain java-declared bean", ctx.containsBean("javaDeclaredBean"));
         assertTrue("did not contain xml-declared bean", ctx.containsBean("xmlDeclaredBean"));
+		TestBean tb = ctx.getBean("javaDeclaredBean", TestBean.class);
+		assertEquals("myName", tb.getName());
     }
 
     @Configuration