Top Description Inners Fields Constructors Methods
org.springframework.context.annotation

pack-priv Class ConfigurationClassParser

extends Object
Class Inheritance
Imports
java.io.IOException, java.lang.annotation.Annotation, java.util.ArrayDeque, .ArrayList, .Collection, .Collections, .Comparator, .Deque, .HashMap, .Iterator, .LinkedHashMap, .LinkedHashSet, .List, .Map, .Set, .StringJoiner, java.util.function.Predicate, org.apache.commons.logging.Log, .LogFactory, org.springframework.beans.factory.BeanDefinitionStoreException, org.springframework.beans.factory.annotation.AnnotatedBeanDefinition, org.springframework.beans.factory.config.BeanDefinition, .BeanDefinitionHolder, org.springframework.beans.factory.parsing.Location, .Problem, .ProblemReporter, org.springframework.beans.factory.support.AbstractBeanDefinition, .BeanDefinitionReader, .BeanDefinitionRegistry, .BeanNameGenerator, org.springframework.context.annotation.ConfigurationCondition.ConfigurationPhase, .DeferredImportSelector.Group, org.springframework.core.OrderComparator, .Ordered, org.springframework.core.annotation.AnnotationAttributes, .AnnotationAwareOrderComparator, .AnnotationUtils, .MergedAnnotation, org.springframework.core.env.ConfigurableEnvironment, .Environment, org.springframework.core.io.ResourceLoader, org.springframework.core.io.support.PropertySourceDescriptor, .PropertySourceProcessor, org.springframework.core.type.AnnotationMetadata, .MethodMetadata, .StandardAnnotationMetadata, org.springframework.core.type.classreading.MetadataReader, .MetadataReaderFactory, org.springframework.core.type.filter.AssignableTypeFilter, org.springframework.lang.Nullable, org.springframework.stereotype.Component, org.springframework.util.Assert, .ClassUtils, .CollectionUtils, .LinkedMultiValueMap, .MultiValueMap

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 (with the exception of @ComponentScan annotations which need to be registered immediately).

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

Authors
Chris Beams, Juergen Hoeller, Phillip Webb, Sam Brannen, Stephane Nicoll
Since
3.0
See Also
ConfigurationClassBeanDefinitionReader

Nested and Inner Type Summary

Modifier and TypeClass and Description
private static class
ConfigurationClassParser.CircularImportProblem

Problem registered upon detection of a circular Import.

private static class
private static class
private class
private class
private static class
private static class
private class
ConfigurationClassParser.SourceClass

Simple wrapper that allows annotated source classes to be dealt with in a uniform manner, regardless of how they are loaded.

Field Summary

Modifier and TypeField and Description
private final ComponentScanAnnotationParser
private final ConditionEvaluator
private final Map<ConfigurationClass, ConfigurationClass>
private static final Predicate<String>
private static final Comparator<ConfigurationClassParser.DeferredImportSelectorHolder>
private final ConfigurationClassParser.DeferredImportSelectorHandler
private final Environment
private final ConfigurationClassParser.ImportStack
private final Map<String, ConfigurationClass>
private final Log
private final MetadataReaderFactory
private final ConfigurationClassParser.SourceClass
private final ProblemReporter
private final PropertySourceRegistry
private final BeanDefinitionRegistry
private final ResourceLoader

Constructor Summary

AccessConstructor and Description
public
ConfigurationClassParser(MetadataReaderFactory metadataReaderFactory, ProblemReporter problemReporter, Environment environment, ResourceLoader resourceLoader, BeanNameGenerator componentScanBeanNameGenerator, BeanDefinitionRegistry registry)

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

Method Summary

Modifier and TypeMethod and Description
private ConfigurationClassParser.SourceClass
asSourceClass(ConfigurationClass configurationClass, Predicate<String> filter)

Factory method to obtain a SourceClass from a ConfigurationClass.

pack-priv ConfigurationClassParser.SourceClass
asSourceClass(Class<?> classType, Predicate<String> filter)

Factory method to obtain a SourceClass from a Class.

pack-priv ConfigurationClassParser.SourceClass
asSourceClass(String className, Predicate<String> filter)

Factory method to obtain a SourceClass from a class name.

private Collection<ConfigurationClassParser.SourceClass>
asSourceClasses(String[] classNames, Predicate<String> filter)

Factory method to obtain a SourceClass collection from class names.

private void
collectImports(ConfigurationClassParser.SourceClass
the class to search
sourceClass
,
Set<ConfigurationClassParser.SourceClass>
the imports collected so far
imports
,
Set<ConfigurationClassParser.SourceClass>
used to track visited classes to prevent infinite recursion
visited
)

Recursively collect all declared @Import values.

protected final ConfigurationClassParser.SourceClass

Returns:

the superclass, or null if none found or previously processed
doProcessConfigurationClass
(ConfigurationClass
the configuration class being build
configClass
,
ConfigurationClassParser.SourceClass
a source class
sourceClass
,
Predicate<String> filter)

Apply processing and build a complete ConfigurationClass by reading the annotations, members and methods from the source class.

public Set<ConfigurationClass>
pack-priv ImportRegistry
private Set<ConfigurationClassParser.SourceClass>
getImports(ConfigurationClassParser.SourceClass sourceClass)

Returns @Import class, considering all meta-annotations.

pack-priv List<PropertySourceDescriptor>
private boolean
public void
parse(Set<BeanDefinitionHolder> configCandidates)

protected final void
parse(String className, String beanName)

protected final void
parse(Class<?> clazz, String beanName)

protected final void
parse(AnnotationMetadata metadata, String beanName)

protected void
private void
processImports(ConfigurationClass configClass, ConfigurationClassParser.SourceClass currentSourceClass, Collection<ConfigurationClassParser.SourceClass> importCandidates, Predicate<String> exclusionFilter, boolean checkForCircularImports)

private void
processInterfaces(ConfigurationClass configClass, ConfigurationClassParser.SourceClass sourceClass)

Register default methods on interfaces implemented by the configuration class.

private void
processMemberClasses(ConfigurationClass configClass, ConfigurationClassParser.SourceClass sourceClass, Predicate<String> filter)

Register member (nested) classes that happen to be configuration classes themselves.

private Set<MethodMetadata>
retrieveBeanMethodMetadata(ConfigurationClassParser.SourceClass sourceClass)

Retrieve the metadata for all @Bean methods.

public void
validate()

Validate each ConfigurationClass object.

Inherited from java.lang.Object:
cloneequalsfinalizegetClasshashCodenotifynotifyAlltoStringwaitwaitwait