文章目錄
此類是一個後置工廠處理器，比較核心重要，主要用於處理@Configuration註解修飾的類。
類圖如下：
在前序文章《spring5源碼閱讀（五）Post Processors類型及作用詳解》中的第一節，曾簡單描述過此類的作用，可以那篇文章看起；本就其執行過程，再詳細分析一下。
此類實現了BeanDefinitionRegistryPostProcessor接口，最終實現了BeanFactoryPostProcessor接口。
下面詳細分析下實現的兩個接口方法；
1. postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
/**
* Derive further bean definitions from the configuration classes in the registry.
* 從註冊表中的配置類,派生進一步的bean定義
*/
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
int registryId = System.identityHashCode(registry);
//理論上啓動過程中只會執行一次，這個if進不去
if (this.registriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
}
if (this.factoriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + registry);
}
this.registriesPostProcessed.add(registryId);
//核心邏輯再這裏
processConfigBeanDefinitions(registry);
}
繼續打開核心邏輯代碼，這方法名字上就能看出，是解析配置類的bean定義，經過這個方法，@Configuration註解修飾的配置類上的所有其他註解，都會被解析，比如@ComponentScan，因此經過這個方法，我們自定義的bean（被@Component等註解修飾的）都會被掃描到並進行註冊。
代碼比較長，注意看代碼註釋：
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
//存放@Configuration修飾的類
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
//得到所有已經註冊的bean名字
//到這裏一般只有那6個post process和我們自定義的config類
String[] candidateNames = registry.getBeanDefinitionNames();
//1.遍歷查找@Configuration修飾的類，走到這裏，只會有一個appConfig複合條件，因爲其他bean都還沒註冊
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
//這裏才設置了full和lite屬性，所以即使一個bean上有@Configuration註解，也不能進入上邊的判斷
//能進入上邊的if判斷，說明bean已經被處理過了
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// Return immediately if no @Configuration classes were found
if (configCandidates.isEmpty()) {
return;
}
// Sort by previously determined @Order value, if applicable
//2.根據order大小排序，越小優先級越高，也就是升序排列
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
// Detect any custom bean name generation strategy supplied through the enclosing application context
//檢測自定義bean名稱生成策略
SingletonBeanRegistry sbr = null;
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet) {
BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
}
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
//3. Parse each @Configuration class
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
//存放configCandidates的備份，臨時變量，
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
//已經parse處理的Configuration類
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
//經過這一步，我們在項目中定義的@Componet/@Repository等，都會被註冊bean定義
//因爲這一步解析了Configuration類型類的各種註解，比如@ComponentScan
//這一步也有可能產生新的config類，因爲Configuration類上可以使用@import註解導入他的配置類
parser.parse(candidates);
parser.validate();
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
// Read the model and create bean definitions based on its content
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
//此方法中處理了@Import註解中的ImportBeanDefinitionRegistrar
//這裏可能會註冊代理bean，比如AnnotationAwareAspectJAutoProxyCreator
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
//candidates parse完了，清空
candidates.clear();
//上邊parse了config類型的類後，可能產生新的bean定義註冊
//所以這裏很可能是大於candidateNames.length的
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set<String> alreadyParsedClasses = new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
//走到這說明經過上面的parse方法，產生了新的Configuration類
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
}
//如果又有新的candidates出現，則繼續循環
while (!candidates.isEmpty());
//將ImportRegistry註冊爲bean
// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
// Clear cache in externally provided MetadataReaderFactory; this is a no-op
// for a shared cache since it'll be cleared by the ApplicationContext.
((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
}
}
方法邏輯總結：
- 首先遍歷查找@Configuration修飾的類，走到這裏，只會有一個appConfig複合條件，因爲其他bean都還沒註冊；
- 按照@Order執行順序排序
- 遍歷解析各個@Configuration註解修飾的類，遍歷結束後，還要判斷是否產生了新的配置類，如果有的話，還要循環解析，直到不在有新的配置類產生；
上面這麼長的代碼，其實核心的代碼就是如下方法：
ConfigurationClassParser#parse(candidates)
跟進去ConfigurationClassParser#parse(candidates)
public void parse(Set<BeanDefinitionHolder> configCandidates) {
this.deferredImportSelectors = new LinkedList<>();
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);
}
}
processDeferredImportSelectors();
}
進入parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(metadata, beanName));
}
繼續進入processConfigurationClass（）如下：
//處理@Configuration修飾的類
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
//根據@Conditional註解情況判斷是否跳過
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
ConfigurationClass existingClass = this.configurationClasses.get(configClass);
if (existingClass != null) {
if (configClass.isImported()) {
if (existingClass.isImported()) {
existingClass.mergeImportedBy(configClass);
}
// Otherwise ignore new imported config class; existing non-imported class overrides it.
return;
} else {
// Explicit bean definition found, probably replacing an import.
// Let's remove the old one and go with the new one.
this.configurationClasses.remove(configClass);
this.knownSuperclasses.values().removeIf(configClass::equals);
}
}
//遞歸處理configuration class和其父類，得到類上所有註解
// Recursively process the configuration class and its superclass hierarchy.
SourceClass sourceClass = asSourceClass(configClass);
do {
//關鍵這一步解析各種註解
sourceClass = doProcessConfigurationClass(configClass, sourceClass);
}
while (sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
上面方法中由個關鍵方法doProcessConfigurationClass(configClass, sourceClass) 如下：
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
// Recursively process any member (nested) classes first
//遞歸處理內部類
processMemberClasses(configClass, sourceClass);
// Process any @PropertySource annotations
//1. 處理@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.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
// Process any @ComponentScan annotations
//2. 處理@ComponentScan
Set<AnnotationAttributes> 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配置的包路徑
// The config class is annotated with @ComponentScan -> perform the scan immediately
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
//遍歷檢查每一個掃描到的bean，是否又有@Configuration註解，有的話要遞歸解析其配置信息
// Check the set of scanned definitions for any further config classes and parse recursively if needed
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());
}
}
}
}
// 3. Process any @Import annotations
processImports(configClass, sourceClass, getImports(sourceClass), true);
//4. Process any @ImportResource annotations
AnnotationAttributes importResource =
AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
String[] resources = importResource.getStringArray("locations");
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
for (String resource : resources) {
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
//5. Process individual @Bean methods
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
//6. Process default methods on interfaces
//接口中的默認方法
processInterfaces(configClass, sourceClass);
//7. 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;
}
此方法處理了@Configuration註解修飾的類，也就是依次獲取以下註解內容並進行解析（如果由的話）：@PropertySource/@ComponentScan/@Import /@ImportResource/@Bean 等註解 ，如果這些註解又引入了此類註解，那麼就進行遞歸處理。比如@Import註解可能導入其他@configuration配置類。
2. postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
上面執行完postProcessBeanDefinitionRegistry方法後，
因爲ConfigurationClassPostProcessor類也實現了BeanFactoryPostProcessor接口，這裏看下具體的實現內容。
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
int factoryId = System.identityHashCode(beanFactory);
if (this.factoriesPostProcessed.contains(factoryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + beanFactory);
}
this.factoriesPostProcessed.add(factoryId);
if (!this.registriesPostProcessed.contains(factoryId)) {
// BeanDefinitionRegistryPostProcessor hook apparently not supported...
// Simply call processConfigurationClasses lazily at this point then.
processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
}
//增強Configuration類
enhanceConfigurationClasses(beanFactory);
//往容器中增加了一個ImportAwareBeanPostProcessor實例對象
beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}
該方法在bean定義註冊結束後，bean實例化之前執行。
該方法主要做了兩件事情：
- enhanceConfigurationClasses(beanFactory) 使用cglib動態代理增強了Configuration
- 往容器中增加了一個ImportAwareBeanPostProcessor實例對象
針對第一個，我們展開看下：
public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
for (String beanName : beanFactory.getBeanDefinitionNames()) {
BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
//找到@Configuation註解修飾的配置類
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef)) {
if (!(beanDef instanceof AbstractBeanDefinition)) {
throw new BeanDefinitionStoreException("Cannot enhance @Configuration bean definition '" +
beanName + "' since it is not stored in an AbstractBeanDefinition subclass");
} else if (logger.isWarnEnabled() && beanFactory.containsSingleton(beanName)) {
logger.warn("Cannot enhance @Configuration bean definition '" + beanName +
"' since its singleton instance has been created too early. The typical cause " +
"is a non-static @Bean method with a BeanDefinitionRegistryPostProcessor " +
"return type: Consider declaring such methods as 'static'.");
}
configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
}
}
if (configBeanDefs.isEmpty()) {
// nothing to enhance -> return immediately
return;
}
ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
AbstractBeanDefinition beanDef = entry.getValue();
// If a @Configuration class gets proxied, always proxy the target class
//preserveTargetClass設置爲true，表示開啓cglib動態代理
beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
try {
// Set enhanced subclass of the user-specified bean class
Class<?> configClass = beanDef.resolveBeanClass(this.beanClassLoader);
if (configClass != null) {
//得到增強的代理類
Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
if (configClass != enhancedClass) {
if (logger.isDebugEnabled()) {
logger.debug(String.format("Replacing bean definition '%s' existing class '%s' with " +
"enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));
}
//修改bean的class爲代理類
beanDef.setBeanClass(enhancedClass);
}
}
} catch (Throwable ex) {
throw new IllegalStateException("Cannot load configuration class: " + beanDef.getBeanClassName(), ex);
}
}
}
- 首先找到所有@Configuration修飾的配置類
- 遍歷每個配置類，使用ConfigurationClassEnhancer工具類進行增強；也就是使用cglib動態代理，產生代理子類，用於處理配置類中@Bean註解修飾的方法，實現在配置類中實例化對象效果。