ConfigurationClassPostProcessor在SpringBoot启动流程中的刷新上下文中被执行，作为BeanDefinitionRegistry的后置处理器主要用来扫描加载类到Spring容器中。
ConfigurationClassPostProcessor作为BeanDefinitionRegistry后置处理器调用的方法：
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
int registryId = System.identityHashCode(registry);
if (this.registriesPostProcessed.contains(registryId)) {
throw new IllegalStateException("postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
} else if (this.factoriesPostProcessed.contains(registryId)) {
throw new IllegalStateException("postProcessBeanFactory already called on this post-processor against " + registry);
} else {
this.registriesPostProcessed.add(registryId);
// 扫描并处理BeanDefinition
this.processConfigBeanDefinitions(registry);
}
}
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List configCandidates = new ArrayList();
//
String[] candidateNames = registry.getBeanDefinitionNames();
String[] var4 = candidateNames;
int var5 = candidateNames.length;
for(int var6 = 0; var6 < var5; ++var6) {
String beanName = var4[var6];
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
// 检查是否是配置类，并根据@Configuration注解的proxyBeanMethods属性为BeanDefinition设置full/lite模式
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
// 获取当前registry中所有配置类
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
if (!configCandidates.isEmpty()) {
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
SingletonBeanRegistry sbr = null;
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry)registry;
if (!this.localBeanNameGeneratorSet) {
BeanNameGenerator generator = (BeanNameGenerator)sbr.getSingleton("org.springframework.context.annotation.internalConfigurationBeanNameGenerator");
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
}
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
// 初始化配置类解析器
ConfigurationClassParser parser = new ConfigurationClassParser(this.metadataReaderFactory, this.problemReporter, this.environment, this.resourceLoader, this.componentScanBeanNameGenerator, registry);
Set candidates = new linkedHashSet(configCandidates);
HashSet alreadyParsed = new HashSet(configCandidates.size());
do {
StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
// springBean扫描并注册@Component修饰的类，将扫描出的结果封装为ConfigurationClass对象
parser.parse(candidates);
// 对配置类的校验，如果配置类的@Configuration注解中的proxyBeanMethods属性的值为true，那么此类不能为final类、其中的所有非static方法可以重写
parser.validate();
Set configClasses = new linkedHashSet(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(registry, this.sourceExtractor, this.resourceLoader, this.environment, this.importBeanNameGenerator, parser.getimportRegistry());
}
// 将扫描出的ConfigurationClass（Spring Bean）注册到beanDefinitionMap中
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
processConfig.tag("classCount", () -> {
return String.valueOf(configClasses.size());
}).end();
candidates.clear();
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set oldCandidateNames = new HashSet(Arrays.asList(candidateNames));
Set alreadyParsedClasses = new HashSet();
Iterator var13 = alreadyParsed.iterator();
while(var13.hasNext()) {
ConfigurationClass configurationClass = (ConfigurationClass)var13.next();
alreadyParsedClasses.add(configurationClass.getmetadata().getClassName());
}
String[] var24 = newCandidateNames;
int var25 = newCandidateNames.length;
for(int var15 = 0; var15 < var25; ++var15) {
String candidateName = var24[var15];
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) && !alreadyParsedClasses.contains(bd.getBeanClassName())) {
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
} while(!candidates.isEmpty());
if (sbr != null && !sbr.containsSingleton(import_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(import_REGISTRY_BEAN_NAME, parser.getimportRegistry());
}
if (this.metadataReaderFactory instanceof CachingmetadataReaderFactory) {
((CachingmetadataReaderFactory)this.metadataReaderFactory).clearCache();
}
}
}
1.1. parse阶段
去classPath中扫描所有的.class文件，再根据includeFilters、excludeFilters进行过滤，以此创建对应的BeanDefinition并注册。
public void parse(SetconfigCandidates) { for (BeanDefinitionHolder holder : configCandidates) { BeanDefinition bd = holder.getBeanDefinition(); try { if (bd instanceof AnnotatedBeanDefinition) { parse(((AnnotatedBeanDefinition) bd).getmetadata(), holder.getBeanName()); } else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) { parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName()); } else { parse(bd.getBeanClassName(), holder.getBeanName()); } } catch (BeanDefinitionStoreException ex) { throw ex; } catch (Throwable ex) { throw new BeanDefinitionStoreException( "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex); } } this.deferredimportSelectorHandler.process(); }
上面代码主要为根据不同的BeanDefinition类型去执行不同的parse方法。
确定类型的方法有两种，一种是debug简单方便，另一种是通过源码硬分析，这是偏难一点的，但也是最考验逻辑能力的。正好我们来分析一波：
1）找到此BeanDefinition来源
从下往上分析：
public void parse(Set
=>parser.parse(candidates);
=>Set
=>configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
=>BeanDefinition beanDef = registry.getBeanDefinition(beanName);
可以得知，该BeanDefinition是从registry（beanDefinitionMap）中获取的。
2）分析创建BeanDefinition步骤
此处的配置类configCandidates目前只有一个，就是启动类，启动类是run => prepareContext方法中注册到beanDefinitionMap中的。那回到SpringBoot启动流程，启动类是在prepareContext方法中使用BeanDefinitionLoader对象的AnnotatedBeanDefinitionReader对象属性的register方法注册到registry（beanDefinitionMap）中的，创建BeanDefinition的代码段：
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
而AnnotatedGenericBeanDefinition继承自AnnotatedBeanDefinition，所以此处的BeanDefinition属于AnnotatedBeanDefinition类型。
进入具体执行的parse方法：
protected void processConfigurationClass(ConfigurationClass configClass, Predicatefilter) throws IOException { // 未被@Conditional注解或者被@Conditional注解且条件判断为true的 if (!this.conditionevaluator.shouldSkip(configClass.getmetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) { ConfigurationClass existingClass = (ConfigurationClass)this.configurationClasses.get(configClass); if (existingClass != null) { if (configClass.isimported()) { if (existingClass.isimported()) { existingClass.mergeimportedBy(configClass); } return; } this.configurationClasses.remove(configClass); this.knownSuperclasses.values().removeIf(configClass::equals); } // 封装SourceClass ConfigurationClassParser.SourceClass sourceClass = this.asSourceClass(configClass, filter); do { // 执行具体方法 sourceClass = this.doProcessConfigurationClass(configClass, sourceClass, filter); } while(sourceClass != null); this.configurationClasses.put(configClass, configClass); } }
@Nullable protected final SourceClass doProcessConfigurationClass( ConfigurationClass configClass, SourceClass sourceClass, Predicatefilter) throws IOException { if (configClass.getmetadata().isAnnotated(Component.class.getName())) { // Recursively process any member (nested) classes first processMemberClasses(configClass, sourceClass, filter); } // 处理PropertySources与PropertySource注解的属性 for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable( sourceClass.getmetadata(), PropertySources.class, org.springframework.context.annotation.PropertySource.class)) { if (this.environment instanceof ConfigurableEnvironment) { processPropertySource(propertySource); } else { logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getmetadata().getClassName() + "]. Reason: Environment must implement ConfigurableEnvironment"); } } // 处理ComponentScans与ComponentScan注解的属性 Set componentScans = AnnotationConfigUtils.attributesForRepeatable( sourceClass.getmetadata(), ComponentScans.class, ComponentScan.class); if (!componentScans.isEmpty() && !this.conditionevaluator.shouldSkip(sourceClass.getmetadata(), ConfigurationPhase.REGISTER_BEAN)) { for (AnnotationAttributes componentScan : componentScans) { // 根据ComponentScan属性扫描@Component注解修饰的类并生成BeanDefinitionHolder Set scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getmetadata().getClassName()); // 检查扫描的定义集是否有任何进一步的配置类，并在需要时进行递归解析 for (BeanDefinitionHolder holder : scannedBeanDefinitions) { BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition(); if (bdCand == null) { bdCand = holder.getBeanDefinition(); } if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) { parse(bdCand.getBeanClassName(), holder.getBeanName()); } } } } // 处理@import导入的类 processimports(configClass, sourceClass, getimports(sourceClass), filter, true); // 处理@importResource引入的资源 AnnotationAttributes importResource = AnnotationConfigUtils.attributesFor(sourceClass.getmetadata(), importResource.class); if (importResource != null) { String[] resources = importResource.getStringArray("locations"); Class readerClass = importResource.getClass("reader"); for (String resource : resources) { String resolvedResource = this.environment.resolveRequiredPlaceholders(resource); configClass.addimportedResource(resolvedResource, readerClass); } } // 处理带有@Bean注解的方法 Set beanMethods = retrieveBeanMethodmetadata(sourceClass); for (Methodmetadata methodmetadata : beanMethods) { configClass.addBeanMethod(new BeanMethod(methodmetadata, configClass)); } // 处理实现接口中的带有@Bean注解的方法 processInterfaces(configClass, sourceClass); // Process superclass, if any if (sourceClass.getmetadata().hasSuperClass()) { String superclass = sourceClass.getmetadata().getSuperClassName(); if (superclass != null && !superclass.startsWith("java") && !this.knownSuperclasses.containsKey(superclass)) { this.knownSuperclasses.put(superclass, configClass); // Superclass found, return its annotation metadata and recurse return sourceClass.getSuperClass(); } } // No superclass -> processing is complete return null; }
在this.componentScanParser.parse(componentScan, sourceClass.getmetadata().getClassName());中，使用ClassPathBeanDefinitionScanner去扫描类，scanner中内置默认过滤器，也可通过@ComponentScan中的includeFilters、excludeFilters进行添加。
源代码中，默认添加了三个注解类型的过滤器：
protected void registerDefaultFilters() {
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
try {
this.includeFilters.add(new AnnotationTypeFilter(
((Class) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
}
try {
this.includeFilters.add(new AnnotationTypeFilter(
((Class) ClassUtils.forName("javax.inject.Named", cl)), false));
logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
在我们的环境中，parse方法只会扫描并注册被@Component注解的类（@Service、@Configuration包含@Component，也会被注册）。
1.2. loadBeanDefinitions阶段加载未被@Component修饰的需要注册的SpringBean，如@Bean、@import等修饰的类。
public void loadBeanDefinitions(SetconfigurationModel) { TrackedConditionevaluator trackedConditionevaluator = new TrackedConditionevaluator(); for (ConfigurationClass configClass : configurationModel) { loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionevaluator); } }
private void loadBeanDefinitionsForConfigurationClass(
ConfigurationClass configClass, TrackedConditionevaluator trackedConditionevaluator) {
// 判断当前configClass是否应该被跳过
if (trackedConditionevaluator.shouldSkip(configClass)) {
String beanName = configClass.getBeanName();
// registry中去掉该BeanDefinition
if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
this.registry.removeBeanDefinition(beanName);
}
// importRegistry去除已经引入的该类
this.importRegistry.removeimportingClass(configClass.getmetadata().getClassName());
return;
}
// 是被@import导入的
if (configClass.isimported()) {
// 注册导入的Class的BeanDefinition
registerBeanDefinitionForimportedConfigurationClass(configClass);
}
// 注册被@Bean修饰的BeanDefinition
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
// 注册使用@importResource注解的类的BeanDefinition
loadBeanDefinitionsFromimportedResources(configClass.getimportedResources());
// 回调被@import引入的实现了importBeanDefinitionRegistrar类的registerBeanDefinitions方法以完成BeanDefinition注册
loadBeanDefinitionsFromRegistrars(configClass.getimportBeanDefinitionRegistrars());
}
