Sync with 3.1.x

* 3.1.x:
  Demonstrate use of @Configuration as meta-annotation
  Prune dead code from JmsTransactionManager#doBegin
  Apply @Configuration BeanNameGenerator consistently
  Improve @Configuration bean name discovery
  Fix infinite recursion bug in nested @Configuration
  Polish static imports
  Minor fix in ServletResponseMethodArgumentResolver
  extracted ResourceUtils.useCachesIfNecessary(URLConnection) method (SP
  prepared for 3.1.1 release
  CustomSQLExceptionTranslatorRegistry/Registrar etc
  revised CustomSQLExceptionTranslatorRegistry/Registrar method naming
  use custom InputStream traversal instead of a full byte array (SPR-911
  PathMatchingResourcePatternResolver preserves caching for JNLP jar con
  Resource "contentLength()" implementations work with OSGi bundle resou
  fixed MethodInvokingJobDetailFactoryBean for compatibility with Quartz
  fixed MethodInvokingJobDetailFactoryBean for compatibility with Quartz

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

@@ -16,8 +16,6 @@
 
 package org.springframework.context.annotation;
 
-import static org.springframework.context.annotation.MetadataUtils.attributesFor;
-
 import java.lang.annotation.Annotation;
 
 import org.springframework.core.GenericTypeResolver;
@@ -25,6 +23,8 @@ import org.springframework.core.annotation.AnnotationAttributes;
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.util.Assert;
 
+import static org.springframework.context.annotation.MetadataUtils.*;
+
 /**
  * Convenient base class for {@link ImportSelector} implementations that select imports
  * based on an {@link AdviceMode} value from an annotation (such as the {@code @Enable*}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2012 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.
@@ -109,6 +109,8 @@ public class AnnotationConfigApplicationContext extends GenericApplicationContex
 	public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator) {
 		this.reader.setBeanNameGenerator(beanNameGenerator);
 		this.scanner.setBeanNameGenerator(beanNameGenerator);
+		this.getBeanFactory().registerSingleton(
+				AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
 	}
 
 	/**

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

@@ -16,8 +16,6 @@
 
 package org.springframework.context.annotation;
 
-import static org.springframework.context.annotation.MetadataUtils.attributesFor;
-
 import java.util.LinkedHashSet;
 import java.util.Set;
 
@@ -32,6 +30,8 @@ import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.util.ClassUtils;
 
+import static org.springframework.context.annotation.MetadataUtils.*;
+
 /**
  * Utility class that allows for convenient registration of common
  * {@link org.springframework.beans.factory.config.BeanPostProcessor} and
@@ -56,6 +56,17 @@ public class AnnotationConfigUtils {
 	public static final String CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME =
 			"org.springframework.context.annotation.internalConfigurationAnnotationProcessor";
 
+	/**
+	 * The bean name of the internally managed BeanNameGenerator for use when processing
+	 * {@link Configuration} classes. Set by {@link AnnotationConfigApplicationContext}
+	 * and {@code AnnotationConfigWebApplicationContext} during bootstrap in order to make
+	 * any custom name generation strategy available to the underlying
+	 * {@link ConfigurationClassPostProcessor}.
+	 * @since 3.1.1
+	 */
+	public static final String CONFIGURATION_BEAN_NAME_GENERATOR =
+			"org.springframework.context.annotation.internalConfigurationBeanNameGenerator";
+
 	/**
 	 * The bean name of the internally managed Autowired annotation processor.
 	 */
@@ -249,4 +260,5 @@ public class AnnotationConfigUtils {
 		return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
 	}
 
+
 }

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

@@ -16,8 +16,6 @@
 
 package org.springframework.context.annotation;
 
-import static org.springframework.context.annotation.MetadataUtils.attributesFor;
-
 import java.lang.annotation.Annotation;
 
 import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
@@ -25,6 +23,8 @@ import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.core.annotation.AnnotationAttributes;
 import org.springframework.util.Assert;
 
+import static org.springframework.context.annotation.MetadataUtils.*;
+
 /**
  * A {@link ScopeMetadataResolver} implementation that by default checks for
  * the presence of Spring's {@link Scope} annotation on the bean class.

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

@@ -16,13 +16,13 @@
 
 package org.springframework.context.annotation;
 
-import static org.springframework.context.annotation.MetadataUtils.attributesFor;
-
 import org.springframework.aop.config.AopConfigUtils;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.core.annotation.AnnotationAttributes;
 import org.springframework.core.type.AnnotationMetadata;
 
+import static org.springframework.context.annotation.MetadataUtils.*;
+
 /**
  * Registers an {@link org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator
  * AnnotationAwareAspectJAutoProxyCreator} against the current {@link BeanDefinitionRegistry}

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

@@ -30,9 +30,9 @@ import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.context.ResourceLoaderAware;
 import org.springframework.core.annotation.AnnotationAttributes;
-import org.springframework.core.env.StandardEnvironment;
 import org.springframework.core.env.Environment;
 import org.springframework.core.env.EnvironmentCapable;
+import org.springframework.core.env.StandardEnvironment;
 import org.springframework.core.io.Resource;
 import org.springframework.core.io.ResourceLoader;
 import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2012 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.
@@ -77,8 +77,14 @@ public @interface ComponentScan {
 	/**
 	 * The {@link BeanNameGenerator} class to be used for naming detected components
 	 * within the Spring container.
+	 * <p>The default value of the {@link BeanNameGenerator} interface itself indicates
+	 * that the scanner used to process this {@code @ComponentScan} annotation should
+	 * use its inherited bean name generator, e.g. the default
+	 * {@link AnnotationBeanNameGenerator} or any custom instance supplied to the
+	 * application context at bootstrap time.
+	 * @see AnnotationConfigApplicationContext#setBeanNameGenerator(BeanNameGenerator)
 	 */
-	Class<? extends BeanNameGenerator> nameGenerator() default AnnotationBeanNameGenerator.class;
+	Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
 
 	/**
 	 * The {@link ScopeMetadataResolver} to be used for resolving the scope of detected components.

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

@@ -51,11 +51,16 @@ class ComponentScanAnnotationParser {
 
 	private final BeanDefinitionRegistry registry;
 
+	private final BeanNameGenerator beanNameGenerator;
+
 
 	public ComponentScanAnnotationParser(
-			ResourceLoader resourceLoader, Environment environment, BeanDefinitionRegistry registry) {
+			ResourceLoader resourceLoader, Environment environment,
+			BeanNameGenerator beanNameGenerator, BeanDefinitionRegistry registry) {
+
 		this.resourceLoader = resourceLoader;
 		this.environment = environment;
+		this.beanNameGenerator = beanNameGenerator;
 		this.registry = registry;
 	}
 
@@ -71,7 +76,10 @@ class ComponentScanAnnotationParser {
 		scanner.setResourceLoader(this.resourceLoader);
 
 		Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
-		scanner.setBeanNameGenerator(BeanUtils.instantiateClass(generatorClass));
+		boolean useInheritedGenerator = BeanNameGenerator.class.equals(generatorClass);
+		scanner.setBeanNameGenerator(useInheritedGenerator
+				? this.beanNameGenerator
+				: BeanUtils.instantiateClass(generatorClass));
 
 		ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
 		if (scopedProxyMode != ScopedProxyMode.DEFAULT) {

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

@@ -16,7 +16,6 @@
 
 package org.springframework.context.annotation;
 
-import java.io.IOException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -29,6 +28,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.AnnotatedGenericBeanDefinition;
 import org.springframework.beans.factory.annotation.Autowire;
 import org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor;
 import org.springframework.beans.factory.config.BeanDefinition;
@@ -37,12 +37,10 @@ import org.springframework.beans.factory.parsing.Location;
 import org.springframework.beans.factory.parsing.Problem;
 import org.springframework.beans.factory.parsing.ProblemReporter;
 import org.springframework.beans.factory.parsing.SourceExtractor;
-import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.AbstractBeanDefinitionReader;
 import org.springframework.beans.factory.support.BeanDefinitionReader;
-import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
-import org.springframework.beans.factory.support.GenericBeanDefinition;
+import org.springframework.beans.factory.support.BeanNameGenerator;
 import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.core.annotation.AnnotationAttributes;
 import org.springframework.core.env.Environment;
@@ -50,8 +48,8 @@ import org.springframework.core.io.Resource;
 import org.springframework.core.io.ResourceLoader;
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.core.type.MethodMetadata;
-import org.springframework.core.type.classreading.MetadataReader;
 import org.springframework.core.type.classreading.MetadataReaderFactory;
+import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
 
 import static org.springframework.context.annotation.MetadataUtils.*;
@@ -85,6 +83,8 @@ class ConfigurationClassBeanDefinitionReader {
 
 	private final Environment environment;
 
+	private final BeanNameGenerator beanNameGenerator;
+
 
 	/**
 	 * Create a new {@link ConfigurationClassBeanDefinitionReader} instance that will be used
@@ -92,16 +92,20 @@ class ConfigurationClassBeanDefinitionReader {
 	 * @param problemReporter 
 	 * @param metadataReaderFactory 
 	 */
-	public ConfigurationClassBeanDefinitionReader(BeanDefinitionRegistry registry, SourceExtractor sourceExtractor,
+	public ConfigurationClassBeanDefinitionReader(
+			BeanDefinitionRegistry registry, SourceExtractor sourceExtractor,
 			ProblemReporter problemReporter, MetadataReaderFactory metadataReaderFactory,
-			ResourceLoader resourceLoader, Environment environment) {
+			ResourceLoader resourceLoader, Environment environment,
+			BeanNameGenerator beanNameGenerator) {
 
+		Assert.notNull(beanNameGenerator, "BeanNameGenerator must not be null");
 		this.registry = registry;
 		this.sourceExtractor = sourceExtractor;
 		this.problemReporter = problemReporter;
 		this.metadataReaderFactory = metadataReaderFactory;
 		this.resourceLoader = resourceLoader;
 		this.environment = environment;
+		this.beanNameGenerator = beanNameGenerator;
 	}
 
 
@@ -135,39 +139,21 @@ class ConfigurationClassBeanDefinitionReader {
 			return;
 		}
 
-		BeanDefinition configBeanDef = new GenericBeanDefinition();
-		String className = configClass.getMetadata().getClassName();
+		AnnotationMetadata metadata = configClass.getMetadata();
+		BeanDefinition configBeanDef = new AnnotatedGenericBeanDefinition(metadata);
+		String className = metadata.getClassName();
 		configBeanDef.setBeanClassName(className);
-		MetadataReader reader;
-		try {
-			reader = this.metadataReaderFactory.getMetadataReader(className);
-		}
-		catch (IOException ex) {
-			throw new IllegalStateException("Could not create MetadataReader for class " + className);
-		}
 		if (ConfigurationClassUtils.checkConfigurationClassCandidate(configBeanDef, this.metadataReaderFactory)) {
-			Map<String, Object> configAttributes =
-					reader.getAnnotationMetadata().getAnnotationAttributes(Configuration.class.getName());
-
-			// has the 'value' attribute of @Configuration been set?
-			String configBeanName = (String) configAttributes.get("value");
-			if (StringUtils.hasText(configBeanName)) {
-				// yes -> register the configuration class bean with this name
-				this.registry.registerBeanDefinition(configBeanName, configBeanDef);
-			}
-			else {
-				// no -> register the configuration class bean with a generated name
-				configBeanName = BeanDefinitionReaderUtils.registerWithGeneratedName((AbstractBeanDefinition)configBeanDef, this.registry);
-			}
+			String configBeanName = this.beanNameGenerator.generateBeanName(configBeanDef, this.registry);
+			this.registry.registerBeanDefinition(configBeanName, configBeanDef);
 			configClass.setBeanName(configBeanName);
 			if (logger.isDebugEnabled()) {
 				logger.debug(String.format("Registered bean definition for imported @Configuration class %s", configBeanName));
 			}
 		}
 		else {
-			AnnotationMetadata metadata = reader.getAnnotationMetadata();
 			this.problemReporter.error(
-					new InvalidConfigurationImportProblem(className, reader.getResource(), metadata));
+					new InvalidConfigurationImportProblem(className, configClass.getResource(), metadata));
 		}
 	}
 

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

@@ -16,8 +16,6 @@
 
 package org.springframework.context.annotation;
 
-import static org.springframework.context.annotation.MetadataUtils.attributesFor;
-
 import java.io.IOException;
 import java.lang.annotation.Annotation;
 import java.util.ArrayList;
@@ -38,6 +36,7 @@ import org.springframework.beans.factory.parsing.Problem;
 import org.springframework.beans.factory.parsing.ProblemReporter;
 import org.springframework.beans.factory.support.BeanDefinitionReader;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.beans.factory.support.BeanNameGenerator;
 import org.springframework.core.annotation.AnnotationAttributes;
 import org.springframework.core.env.Environment;
 import org.springframework.core.env.PropertySource;
@@ -51,6 +50,8 @@ import org.springframework.core.type.classreading.MetadataReaderFactory;
 import org.springframework.core.type.filter.AssignableTypeFilter;
 import org.springframework.util.StringUtils;
 
+import static org.springframework.context.annotation.MetadataUtils.*;
+
 /**
  * Parses a {@link Configuration} class definition, populating a collection of
  * {@link ConfigurationClass} objects (parsing a single Configuration class may result in
@@ -77,6 +78,8 @@ class ConfigurationClassParser {
 
 	private final ImportStack importStack = new ImportStack();
 
+	private final Set<String> knownSuperclasses = new LinkedHashSet<String>();
+
 	private final Set<ConfigurationClass> configurationClasses =
 		new LinkedHashSet<ConfigurationClass>();
 
@@ -98,14 +101,16 @@ class ConfigurationClassParser {
 	 */
 	public ConfigurationClassParser(MetadataReaderFactory metadataReaderFactory,
 			ProblemReporter problemReporter, Environment environment,
-			ResourceLoader resourceLoader, BeanDefinitionRegistry registry) {
+			ResourceLoader resourceLoader, BeanNameGenerator beanNameGenerator,
+			BeanDefinitionRegistry registry) {
+
 		this.metadataReaderFactory = metadataReaderFactory;
 		this.problemReporter = problemReporter;
 		this.environment = environment;
 		this.resourceLoader = resourceLoader;
 		this.registry = registry;
-		this.componentScanParser =
-			new ComponentScanAnnotationParser(this.resourceLoader, this.environment, this.registry);
+		this.componentScanParser = new ComponentScanAnnotationParser(
+				resourceLoader, environment, beanNameGenerator, registry);
 	}
 
 
@@ -138,23 +143,12 @@ class ConfigurationClassParser {
 			}
 		}
 
-		while (metadata != null) {
-			doProcessConfigurationClass(configClass, metadata);
-			String superClassName = metadata.getSuperClassName();
-			if (superClassName != null && !Object.class.getName().equals(superClassName)) {
-				if (metadata instanceof StandardAnnotationMetadata) {
-					Class<?> clazz = ((StandardAnnotationMetadata) metadata).getIntrospectedClass();
-					metadata = new StandardAnnotationMetadata(clazz.getSuperclass(), true);
-				}
-				else {
-					MetadataReader reader = this.metadataReaderFactory.getMetadataReader(superClassName);
-					metadata = reader.getAnnotationMetadata();
-				}
-			}
-			else {
-				metadata = null;
-			}
+		// recursively process the configuration class and its superclass hierarchy
+		do {
+			metadata = doProcessConfigurationClass(configClass, metadata);
 		}
+		while (metadata != null);
+
 		if (this.configurationClasses.contains(configClass) && configClass.getBeanName() != null) {
 			// Explicit bean definition found, probably replacing an import.
 			// Let's remove the old one and go with the new one.
@@ -164,7 +158,11 @@ class ConfigurationClassParser {
 		this.configurationClasses.add(configClass);
 	}
 
-	protected void doProcessConfigurationClass(ConfigurationClass configClass, AnnotationMetadata metadata) throws IOException {
+	/**
+	 * @return annotation metadata of superclass, null if none found or previously processed
+	 */
+	protected AnnotationMetadata doProcessConfigurationClass(
+			ConfigurationClass configClass, AnnotationMetadata metadata) throws IOException {
 
 		// recursively process any member (nested) classes first
 		for (String memberClassName : metadata.getMemberClassNames()) {
@@ -227,8 +225,26 @@ class ConfigurationClassParser {
 		for (MethodMetadata methodMetadata : beanMethods) {
 			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
 		}
-	}
 
+		// process superclass, if any
+		if (metadata.hasSuperClass()) {
+			String superclass = metadata.getSuperClassName();
+			if (this.knownSuperclasses.add(superclass)) {
+				// superclass found, return its annotation metadata and recurse
+				if (metadata instanceof StandardAnnotationMetadata) {
+					Class<?> clazz = ((StandardAnnotationMetadata) metadata).getIntrospectedClass();
+					return new StandardAnnotationMetadata(clazz.getSuperclass(), true);
+				}
+				else {
+					MetadataReader reader = this.metadataReaderFactory.getMetadataReader(superclass);
+					return reader.getAnnotationMetadata();
+				}
+			}
+		}
+
+		// no superclass, processing is complete
+		return null;
+	}
 
 	/**
 	 * Return a list of attribute maps for all declarations of the given annotation

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

@@ -46,6 +46,7 @@ import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
+import org.springframework.beans.factory.support.BeanNameGenerator;
 import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.context.EnvironmentAware;
 import org.springframework.context.ResourceLoaderAware;
@@ -65,6 +66,8 @@ import org.springframework.core.type.classreading.SimpleMetadataReaderFactory;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
+import static org.springframework.context.annotation.AnnotationConfigUtils.*;
+
 /**
  * {@link BeanFactoryPostProcessor} used for bootstrapping processing of
  * {@link Configuration @Configuration} classes.
@@ -112,6 +115,8 @@ public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPo
 
 	private ConfigurationClassBeanDefinitionReader reader;
 
+	private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
+
 
 	/**
 	 * Set the {@link SourceExtractor} to use for generated bean definitions
@@ -142,6 +147,26 @@ public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPo
 		this.setMetadataReaderFactoryCalled = true;
 	}
 
+	/**
+	 * Set the {@link BeanNameGenerator} to be used when registering imported and nested
+	 * {@link Configuration} classes. The default is {@link AnnotationBeanNameGenerator}.
+	 * <p>Note that this strategy does <em>not</em> apply to {@link Bean} methods.
+	 * <p>This setter is typically only appropriate when configuring the post-processor as
+	 * a standalone bean definition in XML, e.g. not using the dedicated
+	 * {@code AnnotationConfig*} application contexts or the {@code
+	 * <context:annotation-config>} element. Any bean name generator specified against
+	 * the application context will take precedence over any value set here.
+	 * @param beanNameGenerator the strategy to use when generating configuration class
+	 * bean names
+	 * @since 3.1.1
+	 * @see AnnotationConfigApplicationContext#setBeanNameGenerator(BeanNameGenerator)
+	 * @see AnnotationConfigUtils#CONFIGURATION_BEAN_NAME_GENERATOR
+	 */
+	public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator) {
+		Assert.notNull(beanNameGenerator, "BeanNameGenerator must not be null");
+		this.beanNameGenerator = beanNameGenerator;
+	}
+
 	public void setEnvironment(Environment environment) {
 		Assert.notNull(environment, "Environment must not be null");
 		this.environment = environment;
@@ -197,14 +222,6 @@ public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPo
 		enhanceConfigurationClasses(beanFactory);
 	}
 
-	private ConfigurationClassBeanDefinitionReader getConfigurationClassBeanDefinitionReader(BeanDefinitionRegistry registry) {
-		if (this.reader == null) {
-			this.reader = new ConfigurationClassBeanDefinitionReader(registry, this.sourceExtractor,
-					this.problemReporter, this.metadataReaderFactory, this.resourceLoader, this.environment);
-		}
-		return this.reader;
-	}
-
 	/**
 	 * Build and validate a configuration model based on the registry of
 	 * {@link Configuration} classes.
@@ -223,9 +240,19 @@ public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPo
 			return;
 		}
 
+		// Detect any custom bean name generation strategy supplied through the enclosing application context
+		SingletonBeanRegistry singletonRegistry = null;
+		if (registry instanceof SingletonBeanRegistry) {
+			singletonRegistry = (SingletonBeanRegistry) registry;
+			if (singletonRegistry.containsSingleton(CONFIGURATION_BEAN_NAME_GENERATOR)) {
+				this.beanNameGenerator = (BeanNameGenerator) singletonRegistry.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
+			}
+		}
+
 		// Parse each @Configuration class
 		ConfigurationClassParser parser = new ConfigurationClassParser(
-				this.metadataReaderFactory, this.problemReporter, this.environment, this.resourceLoader, registry);
+				this.metadataReaderFactory, this.problemReporter, this.environment,
+				this.resourceLoader, this.beanNameGenerator, registry);
 		for (BeanDefinitionHolder holder : configCandidates) {
 			BeanDefinition bd = holder.getBeanDefinition();
 			try {
@@ -258,12 +285,18 @@ public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPo
 		}
 
 		// Read the model and create bean definitions based on its content
-		this.getConfigurationClassBeanDefinitionReader(registry).loadBeanDefinitions(parser.getConfigurationClasses());
+		if (this.reader == null) {
+			this.reader = new ConfigurationClassBeanDefinitionReader(
+					registry, this.sourceExtractor, this.problemReporter,
+					this.metadataReaderFactory, this.resourceLoader, this.environment,
+					this.beanNameGenerator);
+		}
+		this.reader.loadBeanDefinitions(parser.getConfigurationClasses());
 
 		// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
-		if (registry instanceof SingletonBeanRegistry) {
-			if (!((SingletonBeanRegistry) registry).containsSingleton("importRegistry")) {
-				((SingletonBeanRegistry) registry).registerSingleton("importRegistry", parser.getImportRegistry());
+		if (singletonRegistry != null) {
+			if (!singletonRegistry.containsSingleton("importRegistry")) {
+				singletonRegistry.registerSingleton("importRegistry", parser.getImportRegistry());
 			}
 		}
 	}

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

@@ -16,8 +16,6 @@
 
 package org.springframework.context.annotation;
 
-import static org.springframework.context.weaving.AspectJWeavingEnabler.ASPECTJ_AOP_XML_RESOURCE;
-
 import org.springframework.beans.factory.BeanClassLoaderAware;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.config.BeanDefinition;
@@ -30,6 +28,8 @@ import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.instrument.classloading.LoadTimeWeaver;
 import org.springframework.util.Assert;
 
+import static org.springframework.context.weaving.AspectJWeavingEnabler.*;
+
 /**
  * {@code @Configuration} class that registers a {@link LoadTimeWeaver} bean.
  *

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 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.
@@ -17,6 +17,7 @@
 package org.springframework.context.annotation;
 
 import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
+import org.springframework.beans.factory.annotation.AnnotatedGenericBeanDefinition;
 import org.springframework.beans.factory.support.GenericBeanDefinition;
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.core.type.classreading.MetadataReader;
@@ -27,16 +28,22 @@ import org.springframework.util.Assert;
  * class, based on an ASM ClassReader, with support for annotation metadata exposed
  * through the {@link AnnotatedBeanDefinition} interface.
  *
- * <p>This class does <i>not</i> load the bean <code>Class</code> early.
+ * <p>This class does <i>not</i> load the bean {@code Class} early.
  * It rather retrieves all relevant metadata from the ".class" file itself,
- * parsed with the ASM ClassReader.
+ * parsed with the ASM ClassReader. It is functionally equivalent to
+ * {@link AnnotatedGenericBeanDefinition#AnnotatedGenericBeanDefinition(AnnotationMetadata)}
+ * but distinguishes by type beans that have been <em>scanned</em> vs those that have
+ * been otherwise registered or detected by other means.
  *
  * @author Juergen Hoeller
+ * @author Chris Beams
  * @since 2.5
  * @see #getMetadata()
  * @see #getBeanClassName()
  * @see org.springframework.core.type.classreading.MetadataReaderFactory
+ * @see AnnotatedGenericBeanDefinition
  */
+@SuppressWarnings("serial")
 public class ScannedGenericBeanDefinition extends GenericBeanDefinition implements AnnotatedBeanDefinition {
 
 	private final AnnotationMetadata metadata;