org.springframework.context.annotation
Class ConfigurationClassParser

java.lang.Object
  org.springframework.context.annotation.ConfigurationClassParser

 class ConfigurationClassParser
extends java.lang.Object

Parses a Configuration class definition, populating a collection of ConfigurationClass objects (parsing a single Configuration class may result in any number of ConfigurationClass objects because one Configuration class may import another using the Import annotation).

This class helps separate the concern of parsing the structure of a Configuration class from the concern of registering BeanDefinition objects based on the content of that model.

This ASM-based implementation avoids reflection and eager class loading in order to interoperate effectively with lazy class loading in a Spring ApplicationContext.

Since:

3.0

Author:

Chris Beams, Juergen Hoeller

See Also:

ConfigurationClassBeanDefinitionReader

Nested Class Summary

private static class	ConfigurationClassParser.CircularImportProblem Problem registered upon detection of a circular Import.
(package private) static interface	ConfigurationClassParser.ImportRegistry
private static class	ConfigurationClassParser.ImportStack

Field Summary

private ComponentScanAnnotationParser	componentScanParser
private java.util.Set<ConfigurationClass>	configurationClasses
private Environment	environment
private ConfigurationClassParser.ImportStack	importStack
private MetadataReaderFactory	metadataReaderFactory
private ProblemReporter	problemReporter
private java.util.Stack<PropertySource<?>>	propertySources
private BeanDefinitionRegistry	registry
private ResourceLoader	resourceLoader

Constructor Summary

ConfigurationClassParser(MetadataReaderFactory metadataReaderFactory, ProblemReporter problemReporter, Environment environment, ResourceLoader resourceLoader, BeanDefinitionRegistry registry)
Create a new ConfigurationClassParser instance that will be used to populate the set of configuration classes.

Method Summary

protected void	doProcessConfigurationClass(ConfigurationClass configClass, AnnotationMetadata metadata)
java.util.Set<ConfigurationClass>	getConfigurationClasses()
ConfigurationClassParser.ImportRegistry	getImportRegistry()
java.util.Stack<PropertySource<?>>	getPropertySources()
void	parse(java.lang.Class<?> clazz, java.lang.String beanName) Parse the specified @Configuration class.
void	parse(java.lang.String className, java.lang.String beanName) Parse the specified @Configuration class.
protected void	processConfigurationClass(ConfigurationClass configClass)
private void	processImport(ConfigurationClass configClass, java.lang.String[] classesToImport, boolean checkForCircularImports)
void	validate() Validate each ConfigurationClass object.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

metadataReaderFactory

private final MetadataReaderFactory metadataReaderFactory

problemReporter

private final ProblemReporter problemReporter

importStack

private final ConfigurationClassParser.ImportStack importStack

configurationClasses

private final java.util.Set<ConfigurationClass> configurationClasses

propertySources

private final java.util.Stack<PropertySource<?>> propertySources

environment

private final Environment environment

resourceLoader

private final ResourceLoader resourceLoader

registry

private final BeanDefinitionRegistry registry

componentScanParser

private final ComponentScanAnnotationParser componentScanParser

Constructor Detail

ConfigurationClassParser

public ConfigurationClassParser(MetadataReaderFactory metadataReaderFactory,
                                ProblemReporter problemReporter,
                                Environment environment,
                                ResourceLoader resourceLoader,
                                BeanDefinitionRegistry registry)

Create a new ConfigurationClassParser instance that will be used to populate the set of configuration classes.

Method Detail

parse

public void parse(java.lang.String className,
                  java.lang.String beanName)
           throws java.io.IOException

Parse the specified @Configuration class.

Parameters:

className - the name of the class to parse

beanName - may be null, but if populated represents the bean id (assumes that this configuration class was configured via XML)

Throws:

java.io.IOException

parse

public void parse(java.lang.Class<?> clazz,
                  java.lang.String beanName)
           throws java.io.IOException

Parse the specified @Configuration class.

Parameters:

clazz - the Class to parse

beanName - may be null, but if populated represents the bean id (assumes that this configuration class was configured via XML)

Throws:

java.io.IOException

processConfigurationClass

protected void processConfigurationClass(ConfigurationClass configClass)
                                  throws java.io.IOException

Throws:

java.io.IOException

doProcessConfigurationClass

protected void doProcessConfigurationClass(ConfigurationClass configClass,
                                           AnnotationMetadata metadata)
                                    throws java.io.IOException

Throws:

java.io.IOException

processImport

private void processImport(ConfigurationClass configClass,
                           java.lang.String[] classesToImport,
                           boolean checkForCircularImports)
                    throws java.io.IOException

Throws:

java.io.IOException

validate

public void validate()

Validate each ConfigurationClass object.

See Also:

ConfigurationClass.validate(org.springframework.beans.factory.parsing.ProblemReporter)

getConfigurationClasses

public java.util.Set<ConfigurationClass> getConfigurationClasses()

getPropertySources

public java.util.Stack<PropertySource<?>> getPropertySources()

getImportRegistry

public ConfigurationClassParser.ImportRegistry getImportRegistry()