這是春節後的第一篇博客，我在構思這篇博客的時候，一度想放棄，想想要不要換個東西寫，因爲畢竟個人水平有限，Spring源碼實在博大精深，不是我這個菜的摳腳的菜雞可以駕馭的，怕誤人子弟，還有就是源碼分析類的博客實在是太難寫了，和一般的博客真心不同，可能寫了很多，自己都不知道自己在寫些什麼，但是還是要堅持，從接觸博客的那一天開始，就非常佩服那些大神，樂於分享，無私奉獻，我也從那些博客中學到了不少東西，慢慢的從一個嫩嫩的小菜雞變成了禿頭大菜雞，其中最佩服的就是那些源碼分析類的博客，雖然看不懂，但是從博客中，我分明讀出了大神們對技術的熱愛，對技術的堅持，對技術的執著。堅持！
在上一篇Spring源碼解析中，我們分析了
//根據參數類型可以知道，其實可以傳入多個annotatedClasses，但是這種情況出現的比較少
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
//調用無參構造函數，會先調用父類GenericApplicationContext的構造函數
//父類的構造函數裏面就是初始化DefaultListableBeanFactory，並且賦值給beanFactory
//本類的構造函數裏面，初始化了一個讀取器：AnnotatedBeanDefinitionReader read，一個掃描器ClassPathBeanDefinitionScanner scanner
//scanner的用處不是很大，它僅僅是在我們外部手動調用 .scan 等方法纔有用，常規方式是不會用到scanner對象的
this();
//把傳入的類進行註冊，這裏有兩個情況，
//傳入傳統的配置類
//傳入bean（雖然一般沒有人會這麼做
//看到後面會知道spring把傳統的帶上@Configuration的配置類稱之爲FULL配置類，不帶@Configuration的稱之爲Lite配置類
//但是我們這裏先把帶上@Configuration的配置類稱之爲傳統配置類，不帶的稱之爲普通bean
register(annotatedClasses);
//刷新
refresh();
}
中的前兩行代碼，回顧下，這兩行代碼，主要是把我們的配置類和內置的幾個後置處理器放到了兩個集合中：
//beanDefinitionMap是Map<String, BeanDefinition>，
//這裏就是把beanName作爲key，beanDefinition作爲value，推到map裏面
this.beanDefinitionMap.put(beanName, beanDefinition);
//beanDefinitionNames就是一個List<String>,這裏就是把beanName放到List中去
this.beanDefinitionNames.add(beanName);
今天，我們來分析下第三行代碼，即：
//刷新
refresh();
這個方法做了很多事情，讓我們點開這個方法：
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
//刷新預處理，和主流程關係不大，就是保存了容器的啓動時間，啓動標誌等
prepareRefresh();
//DefaultListableBeanFactory
// Tell the subclass to refresh the internal bean factory.
//和主流程關係也不大，最終獲得了DefaultListableBeanFactory，
// DefaultListableBeanFactory實現了ConfigurableListableBeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
//還是一些準備工作，添加了兩個後置處理器：ApplicationContextAwareProcessor，ApplicationListenerDetector
//還設置了 忽略自動裝配 和 允許自動裝配 的接口,如果不存在某個bean的時候，spring就自動註冊singleton bean
//還設置了bean表達式解析器 等
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
//這是一個空方法
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
//執行自定義的BeanFactoryProcessor和內置的BeanFactoryProcessor
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 註冊BeanPostProcessor
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
// 空方法
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
裏面有很多小方法，我們今天的目標是分析前五個小方法：
prepareRefresh
從命名來看，就知道這個方法主要做了一些刷新前的準備工作，和主流程關係不大，主要是保存了容器的啓動時間，啓動標誌等。
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()
這個方法和主流程關係也不是很大，可以簡單的認爲，就是把beanFactory取出來而已。
prepareBeanFactory
//還是一些準備工作，添加了兩個後置處理器：ApplicationContextAwareProcessor，ApplicationListenerDetector
//還設置了 忽略自動裝配 和 允許自動裝配 的接口,如果不存在某個bean的時候，spring就自動註冊singleton bean
//還設置了bean表達式解析器 等
prepareBeanFactory(beanFactory);
這代碼相比前面兩個就比較重要了，我們需要點進去好好看看，做了什麼操作:
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader etc.
beanFactory.setBeanClassLoader(getClassLoader());//設置類加載器
//設置bean表達式解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
//屬性編輯器支持
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
//添加一個後置處理器：ApplicationContextAwareProcessor，此後置處理處理器實現了BeanPostProcessor接口
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//以下接口，忽略自動裝配
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
//以下接口，允許自動裝配,第一個參數是自動裝配的類型，，第二個字段是自動裝配的值
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
//添加一個後置處理器：ApplicationListenerDetector，此後置處理器實現了BeanPostProcessor接口
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
//如果沒有註冊過bean名稱爲XXX，spring就自己創建一個名稱爲XXX的singleton bean
//Register default environment beans.
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
主要做了如下的操作：
- 設置了一個類加載器
- 設置了bean表達式解析器
- 添加了屬性編輯器的支持
- 添加了一個後置處理器：ApplicationContextAwareProcessor，此後置處理器實現了BeanPostProcessor接口
- 設置了一些忽略自動裝配的接口
- 設置了一些允許自動裝配的接口，並且進行了賦值操作
- 在容器中還沒有XX的bean的時候，幫我們註冊beanName爲XX的singleton bean
postProcessBeanFactory(beanFactory)
//這是一個空方法
postProcessBeanFactory(beanFactory);
這是一個空方法，可能以後Spring會進行擴展把。
invokeBeanFactoryPostProcessors(beanFactory)
//執行自定義的BeanFactoryProcessor和內置的BeanFactoryProcessor
invokeBeanFactoryPostProcessors(beanFactory);
重點代碼終於來了，可以說 這句代碼是目前爲止最重要，也是內容最多的代碼了，我們有必要好好分析下：
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//getBeanFactoryPostProcessors真是坑，第一次看到這裏的時候，愣住了，總覺得獲得的永遠都是空的集合，掉入坑裏，久久無法自拔
//後來才知道spring允許我們手動添加BeanFactoryPostProcessor
//即：annotationConfigApplicationContext.addBeanFactoryPostProcessor(XXX);
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
讓我們看看第一個小方法的第二個參數：
public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
return this.beanFactoryPostProcessors;
}
這裏獲得的是BeanFactoryPostProcessor，當我看到這裏的時候，愣住了，通過IDEA的查找引用功能，我發現這個集合永遠都是空的，根本沒有代碼爲這個集合添加數據，很久都沒有想通，後來才知道我們在外部可以手動添加一個後置處理器，而不是交給Spring去掃描，即：
AnnotationConfigApplicationContext annotationConfigApplicationContext =
new AnnotationConfigApplicationContext(AppConfig.class);
annotationConfigApplicationContext.addBeanFactoryPostProcessor(XXX);
只有這樣，這個集合纔不會爲空，但是應該沒有人這麼做吧，當然也有可能是我孤陋寡聞。
讓我們點開invokeBeanFactoryPostProcessors方法：
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
Set<String> processedBeans = new HashSet<>();
//beanFactory是DefaultListableBeanFactory，是BeanDefinitionRegistry的實現類，所以肯定滿足if
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
//regularPostProcessors 用來存放BeanFactoryPostProcessor，
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
//registryProcessors 用來存放BeanDefinitionRegistryPostProcessor
//BeanDefinitionRegistryPostProcessor擴展了BeanFactoryPostProcessor
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
// 循環傳進來的beanFactoryPostProcessors，正常情況下，beanFactoryPostProcessors肯定沒有數據
// 因爲beanFactoryPostProcessors是獲得手動添加的，而不是spring掃描的
// 只有手動調用annotationConfigApplicationContext.addBeanFactoryPostProcessor(XXX)纔會有數據
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
// 判斷postProcessor是不是BeanDefinitionRegistryPostProcessor，因爲BeanDefinitionRegistryPostProcessor
// 擴展了BeanFactoryPostProcessor，所以這裏先要判斷是不是BeanDefinitionRegistryPostProcessor
// 是的話，直接執行postProcessBeanDefinitionRegistry方法，然後把對象裝到registryProcessors裏面去
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {//不是的話，就裝到regularPostProcessors
regularPostProcessors.add(postProcessor);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
//一個臨時變量，用來裝載BeanDefinitionRegistryPostProcessor
//BeanDefinitionRegistry繼承了PostProcessorBeanFactoryPostProcessor
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
// 獲得實現BeanDefinitionRegistryPostProcessor接口的類的BeanName:org.springframework.context.annotation.internalConfigurationAnnotationProcessor
// 並且裝入數組postProcessorNames，我理解一般情況下，只會找到一個
// 這裏又有一個坑，爲什麼我自己創建了一個實現BeanDefinitionRegistryPostProcessor接口的類，也打上了@Component註解
// 配置類也加上了@Component註解，但是這裏卻沒有拿到
// 因爲直到這一步，Spring還沒有去掃描，掃描是在ConfigurationClassPostProcessor類中完成的，也就是下面的第一個
// invokeBeanDefinitionRegistryPostProcessors方法
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//獲得ConfigurationClassPostProcessor類，並且放到currentRegistryProcessors
//ConfigurationClassPostProcessor是很重要的一個類，它實現了BeanDefinitionRegistryPostProcessor接口
//BeanDefinitionRegistryPostProcessor接口又實現了BeanFactoryPostProcessor接口
//ConfigurationClassPostProcessor是極其重要的類
//裏面執行了掃描Bean，Import，ImportResouce等各種操作
//用來處理配置類（有兩種情況 一種是傳統意義上的配置類，一種是普通的bean）的各種邏輯
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
//把name放到processedBeans，後續會根據這個集合來判斷處理器是否已經被執行過了
processedBeans.add(ppName);
}
}
//處理排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
//合併Processors，爲什麼要合併，因爲registryProcessors是裝載BeanDefinitionRegistryPostProcessor的
//一開始的時候，spring只會執行BeanDefinitionRegistryPostProcessor獨有的方法
//而不會執行BeanDefinitionRegistryPostProcessor父類的方法，即BeanFactoryProcessor的方法
//所以這裏需要把處理器放入一個集合中，後續統一執行父類的方法
registryProcessors.addAll(currentRegistryProcessors);
//可以理解爲執行ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法
//Spring熱插播的體現，像ConfigurationClassPostProcessor就相當於一個組件，Spring很多事情就是交給組件去管理
//如果不想用這個組件，直接把註冊組件的那一步去掉就可以
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//因爲currentRegistryProcessors是一個臨時變量，所以需要清除
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
// 再次根據BeanDefinitionRegistryPostProcessor獲得BeanName，看這個BeanName是否已經被執行過了，有沒有實現Ordered接口
// 如果沒有被執行過，也實現了Ordered接口的話，把對象推送到currentRegistryProcessors，名稱推送到processedBeans
// 如果沒有實現Ordered接口的話，這裏不把數據加到currentRegistryProcessors，processedBeans中，後續再做處理
// 這裏纔可以獲得我們定義的實現了BeanDefinitionRegistryPostProcessor的Bean
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
//處理排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
//合併Processors
registryProcessors.addAll(currentRegistryProcessors);
//執行我們自定義的BeanDefinitionRegistryPostProcessor
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//清空臨時變量
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
// 上面的代碼是執行了實現了Ordered接口的BeanDefinitionRegistryPostProcessor，
// 下面的代碼就是執行沒有實現Ordered接口的BeanDefinitionRegistryPostProcessor
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
//registryProcessors集合裝載BeanDefinitionRegistryPostProcessor
//上面的代碼是執行子類獨有的方法，這裏需要再把父類的方法也執行一次
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
//regularPostProcessors裝載BeanFactoryPostProcessor，執行BeanFactoryPostProcessor的方法
//但是regularPostProcessors一般情況下，是不會有數據的，只有在外面手動添加BeanFactoryPostProcessor，纔會有數據
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
//找到BeanFactoryPostProcessor實現類的BeanName數組
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
//循環BeanName數組
for (String ppName : postProcessorNames) {
//如果這個Bean被執行過了，跳過
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
//如果實現了PriorityOrdered接口，加入到priorityOrderedPostProcessors
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
//如果實現了Ordered接口，加入到orderedPostProcessorNames
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
//如果既沒有實現PriorityOrdered，也沒有實現Ordered。加入到nonOrderedPostProcessorNames
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
//排序處理priorityOrderedPostProcessors，即實現了PriorityOrdered接口的BeanFactoryPostProcessor
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
//執行priorityOrderedPostProcessors
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
//執行實現了Ordered接口的BeanFactoryPostProcessor
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 執行既沒有實現PriorityOrdered接口，也沒有實現Ordered接口的BeanFactoryPostProcessor
// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}
首先判斷beanFactory是不是BeanDefinitionRegistry的實例，當然肯定是的，然後執行如下操作：
定義了一個Set，裝載BeanName，後面會根據這個Set，來判斷後置處理器是否被執行過了。
定義了兩個List，一個是regularPostProcessors，用來裝載BeanFactoryPostProcessor，一個是registryProcessors用來裝載BeanDefinitionRegistryPostProcessor，其中BeanDefinitionRegistryPostProcessor擴展了BeanFactoryPostProcessor。BeanDefinitionRegistryPostProcessor有兩個方法，一個是獨有的postProcessBeanDefinitionRegistry方法，一個是父類的postProcessBeanFactory方法。
循環傳進來的beanFactoryPostProcessors，上面已經解釋過了，一般情況下，這裏永遠都是空的，只有手動add beanFactoryPostProcessor，這裏纔會有數據。我們假設beanFactoryPostProcessors有數據，進入循環，判斷postProcessor是不是BeanDefinitionRegistryPostProcessor，因爲BeanDefinitionRegistryPostProcessor擴展了BeanFactoryPostProcessor，所以這裏先要判斷是不是BeanDefinitionRegistryPostProcessor，是的話，執行postProcessBeanDefinitionRegistry方法，然後把對象裝到registryProcessors裏面去，不是的話，就裝到regularPostProcessors。
定義了一個臨時變量：currentRegistryProcessors，用來裝載BeanDefinitionRegistryPostProcessor。
getBeanNamesForType，顧名思義，是根據類型查到BeanNames，這裏有一點需要注意，就是去哪裏找，點開這個方法的話，就知道是循環beanDefinitionNames去找，這個方法以後也會經常看到。這裏傳了BeanDefinitionRegistryPostProcessor.class，就是找到類型爲BeanDefinitionRegistryPostProcessor的後置處理器，並且賦值給postProcessorNames。一般情況下，只會找到一個，就是org.springframework.context.annotation.internalConfigurationAnnotationProcessor，也就是ConfigurationAnnotationProcessor。這個後置處理器在上一節中已經說明過了，十分重要。這裏有一個問題，爲什麼我自己寫了個類，實現了BeanDefinitionRegistryPostProcessor接口，也打上了@Component註解，但是這裏沒有獲得，因爲直到這一步，Spring還沒有完成掃描，掃描是在ConfigurationClassPostProcessor類中完成的，也就是下面第一個invokeBeanDefinitionRegistryPostProcessors方法。
循環postProcessorNames，其實也就是org.springframework.context.annotation.internalConfigurationAnnotationProcessor，判斷此後置處理器是否實現了PriorityOrdered接口（ConfigurationAnnotationProcessor也實現了PriorityOrdered接口），
如果實現了，把它添加到currentRegistryProcessors這個臨時變量中，再放入processedBeans，代表這個後置處理已經被處理過了。當然現在還沒有處理，但是馬上就要處理了。。。進行排序，PriorityOrdered是一個排序接口，如果實現了它，就說明此後置處理器是有順序的，所以需要排序。當然目前這裏只有一個後置處理器，就是ConfigurationClassPostProcessor。
把currentRegistryProcessors合併到registryProcessors，爲什麼需要合併？因爲一開始spring只會執行BeanDefinitionRegistryPostProcessor獨有的方法，而不會執行BeanDefinitionRegistryPostProcessor父類的方法，即BeanFactoryProcessor接口中的方法，所以需要把這些後置處理器放入一個集合中，後續統一執行BeanFactoryProcessor接口中的方法。當然目前這裏只有一個後置處理器，就是ConfigurationClassPostProcessor。
可以理解爲執行currentRegistryProcessors中的ConfigurationClassPostProcessor中的postProcessBeanDefinitionRegistry方法，這就是Spring設計思想的體現了，在這裏體現的就是其中的熱插拔，插件化開發的思想。Spring中很多東西都是交給插件去處理的，這個後置處理器就相當於一個插件，如果不想用了，直接不添加就是了。這個方法特別重要，我們後面會詳細說來。
清空currentRegistryProcessors，因爲currentRegistryProcessors是一個臨時變量，已經完成了目前的使命，所以需要清空，當然後面還會用到。
再次根據BeanDefinitionRegistryPostProcessor獲得BeanName，然後進行循環，看這個後置處理器是否被執行過了，如果沒有被執行過，也實現了Ordered接口的話，把此後置處理器推送到currentRegistryProcessors和processedBeans中。
這裏就可以獲得我們定義的，並且打上@Component註解的後置處理器了，因爲Spring已經完成了掃描，但是這裏需要注意的是，由於ConfigurationClassPostProcessor在上面已經被執行過了，所以雖然可以通過getBeanNamesForType獲得，但是並不會加入到currentRegistryProcessors和processedBeans。處理排序。
合併Processors，合併的理由和上面是一樣的。
執行我們自定義的BeanDefinitionRegistryPostProcessor。
清空臨時變量。
在上面的方法中，僅僅是執行了實現了Ordered接口的BeanDefinitionRegistryPostProcessor，這裏是執行沒有實現Ordered接口的BeanDefinitionRegistryPostProcessor。
上面的代碼是執行子類獨有的方法，這裏需要再把父類的方法也執行一次。
執行regularPostProcessors中的後置處理器的方法，需要注意的是，在一般情況下，regularPostProcessors是不會有數據的，只有在外面手動添加BeanFactoryPostProcessor，纔會有數據。
查找實現了BeanFactoryPostProcessor的後置處理器，並且執行後置處理器中的方法。和上面的邏輯差不多，不再詳細說明。
這就是這個方法中做的主要的事情了，可以說是比較複雜的。但是邏輯還是比較清晰的，在第9步的時候，我說有一個方法會詳細說來，現在就讓我們好好看看這個方法究竟做了什麼吧。
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
String[] candidateNames = registry.getBeanDefinitionNames();//獲得所有的BeanDefinition的Name，放入candidateNames數組
//循環candidateNames數組
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);//根據beanName獲得BeanDefinition
// 內部有兩個標記位來標記是否已經處理過了
// 這裏會引發一連串知識盲點
// 當我們註冊配置類的時候，可以不加Configuration註解，直接使用Component ComponentScan Import ImportResource註解，稱之爲Lite配置類
// 如果加了Configuration註解，就稱之爲Full配置類
// 如果我們註冊了Lite配置類，我們getBean這個配置類，會發現它就是原本的那個配置類
// 如果我們註冊了Full配置類，我們getBean這個配置類，會發現它已經不是原本那個配置類了，而是已經被cgilb代理的類了
// 寫一個A類，其中有一個構造方法，打印出“你好”
// 再寫一個配置類，裏面有兩個bean註解的方法
// 其中一個方法new了A 類，並且返回A的對象，把此方法稱之爲getA
// 第二個方法又調用了getA方法
// 如果配置類是Lite配置類，會發現打印了兩次“你好”，也就是說A類被new了兩次
// 如果配置類是Full配置類，會發現只打印了一次“你好”，也就是說A類只被new了一次，因爲這個類被cgilb代理了，方法已經被改寫
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
//判斷是否爲配置類（有兩種情況 一種是傳統意義上的配置類，一種是普通的bean），
//在這個方法內部，會做判斷，這個配置類是Full配置類，還是Lite配置類，並且做上標記
//滿足條件，加入到configCandidates
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
//處理排序
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
SingletonBeanRegistry sbr = null;
// DefaultListableBeanFactory最終會實現SingletonBeanRegistry接口，所以可以進入到這個if
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet) {
//spring中可以修改默認的bean命名方式，這裏就是看用戶有沒有自定義bean命名方式，雖然一般沒有人會這麼做
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();
}
// Parse each @Configuration class
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
//解析配置類（傳統意義上的配置類或者是普通bean，核心來了）
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());
}
this.reader.loadBeanDefinitions(configClasses);//直到這一步才把Import的類，@Bean @ImportRosource 轉換成BeanDefinition
alreadyParsed.addAll(configClasses);//把configClasses加入到alreadyParsed，代表
candidates.clear();
//獲得註冊器裏面BeanDefinition的數量 和 candidateNames進行比較
//如果大於的話，說明有新的BeanDefinition註冊進來了
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();//從註冊器裏面獲得BeanDefinitionNames
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));//candidateNames轉換set
Set<String> alreadyParsedClasses = new HashSet<>();
//循環alreadyParsed。把類名加入到alreadyParsedClasses
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())) {
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());
// 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();
}
}
- 獲得所有的BeanName，放入candidateNames數組。
- 循環candidateNames數組，根據beanName獲得BeanDefinition，判斷此BeanDefinition是否已經被處理過了。
- 判斷是否是配置類，如果是的話。加入到configCandidates數組，在判斷的時候，還會標記配置類屬於Full配置類，還是Lite配置類，這裏會引發一連串的知識盲點：
3.1 當我們註冊配置類的時候，可以不加@Configuration註解，直接使用@Component @ComponentScan @Import @ImportResource等註解，Spring把這種配置類稱之爲Lite配置類， 如果加了@Configuration註解，就稱之爲Full配置類。
3.2 如果我們註冊了Lite配置類，我們getBean這個配置類，會發現它就是原本的那個配置類，如果我們註冊了Full配置類，我們getBean這個配置類，會發現它已經不是原本那個配置類了，而是已經被cgilb代理的類了。
3.3 寫一個A類，其中有一個構造方法，打印出“你好”，再寫一個配置類，裏面有兩個被@bean註解的方法，其中一個方法new了A類，並且返回A的對象，把此方法稱之爲getA，第二個方法又調用了getA方法，如果配置類是Lite配置類，會發現打印了兩次“你好”，也就是說A類被new了兩次，如果配置類是Full配置類，會發現只打印了一次“你好”，也就是說A類只被new了一次，因爲這個類被cgilb代理了，方法已經被改寫。
3.4 具體的可以看我的這篇博客：https://www.jianshu.com/p/d001f96933cf，裏面有詳細的說明。 - 如果沒有配置類直接返回。
- 處理排序。
- 解析配置類，可能是Full配置類，也有可能是Lite配置類，這個小方法是此方法的核心，稍後具體說明。
- 在第6步的時候，只是註冊了部分Bean，像 @Import @Bean等，是沒有被註冊的，這裏統一對這些進行註冊。
下面是解析配置類的過程：
public void parse(Set<BeanDefinitionHolder> configCandidates) {
this.deferredImportSelectors = new LinkedList<>();
//循環傳進來的配置類
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();//獲得BeanDefinition
try {
//如果獲得BeanDefinition是AnnotatedBeanDefinition的實例
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);
}
}
//執行DeferredImportSelector
processDeferredImportSelectors();
}
因爲可以有多個配置類，所以需要循環處理。我們的配置類的BeanDefinition是AnnotatedBeanDefinition的實例，所以會進入第一個if：
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(metadata, beanName));
}
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
//判斷是否需要跳過
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);
}
}
// 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放入一個Map，會在上面第7步中用到。
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
//遞歸處理內部類，一般不會寫內部類
// Recursively process any member (nested) classes first
processMemberClasses(configClass, sourceClass);
// Process any @PropertySource annotations
//處理@PropertySource註解，@PropertySource註解用來加載properties文件
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
//獲得ComponentScan註解具體的內容，ComponentScan註解除了最常用的basePackage之外，還有includeFilters，excludeFilters等
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
//如果沒有打上ComponentScan，或者被@Condition條件跳過，就不再進入這個if
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
//循環處理componentScans
for (AnnotationAttributes componentScan : componentScans) {
// The config class is annotated with @ComponentScan -> perform the scan immediately
//componentScan就是@ComponentScan上的具體內容，sourceClass.getMetadata().getClassName()就是配置類的名稱
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// 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)) {
//遞歸調用，因爲可能組件類有被@Bean標記的方法，或者組件類本身也有ComponentScan等註解
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// Process any @Import annotations
//處理@Import註解
//@Import註解是spring中很重要的一個註解，Springboot大量應用這個註解
//@Import三種類，一種是Import普通類，一種是Import ImportSelector，還有一種是Import ImportBeanDefinitionRegistrar
//getImports(sourceClass)是獲得import的內容，返回的是一個set
processImports(configClass, sourceClass, getImports(sourceClass), true);
// Process any @ImportResource annotations
//處理@ImportResource註解
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);
}
}
//處理@Bean的方法，可以看到獲得了帶有@Bean的方法後，不是馬上轉換成BeanDefinition，而是先用一個set接收
// Process individual @Bean methods
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces
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;
}
- 遞歸處理內部類，一般不會使用內部類。
- 處理@PropertySource註解，@PropertySource註解用來加載properties文件。
- 獲得ComponentScan註解具體的內容，ComponentScan註解除了最常用的basePackage之外，還有includeFilters，excludeFilters等。
- 判斷有沒有被@ComponentScans標記，或者被@Condition條件帶過，如果滿足條件的話，進入if，進行如下操作：
4.1 執行掃描操作，把掃描出來的放入set，這個方法稍後再詳細說明。
4.2 循環set，判斷是否是配置類，是的話，遞歸調用parse方法，因爲被掃描出來的類，還是一個配置類，有@ComponentScans註解，或者其中有被@Bean標記的方法 等等，所以需要再次被解析。 - 處理@Import註解，@Import是Spring中很重要的一個註解，正是由於它的存在，讓Spring非常靈活，不管是Spring內部，還是與Spring整合的第三方技術，都大量的運用了@Import註解，@Import有三種情況，一種是Import普通類，一種是Import ImportSelector，還有一種是Import ImportBeanDefinitionRegistrar，getImports(sourceClass)是獲得import的內容，返回的是一個set，這個方法稍後再詳細說明。
- 處理@ImportResource註解。
- 處理@Bean的方法，可以看到獲得了帶有@Bean的方法後，不是馬上轉換成BeanDefinition，而是先用一個set接收。
我們先來看4.1中的那個方法：
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
//掃描器，還記不記在new AnnotationConfigApplicationContext的時候
//會調用AnnotationConfigApplicationContext的構造方法
//構造方法裏面有一句 this.scanner = new ClassPathBeanDefinitionScanner(this);
//當時說這個對象不重要，這裏就是證明了。常規用法中，實際上執行掃描的只會是這裏的scanner對象
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
//判斷是否重寫了默認的命名規則
Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
BeanUtils.instantiateClass(generatorClass));
ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
scanner.setScopedProxyMode(scopedProxyMode);
}
else {
Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
}
scanner.setResourcePattern(componentScan.getString("resourcePattern"));
//addIncludeFilter addExcludeFilter,最終是往List<TypeFilter>裏面填充數據
//TypeFilter是一個函數式接口，函數式接口在java8的時候大放異彩，只定義了一個虛方法的接口被稱爲函數式接口
//當調用scanner.addIncludeFilter scanner.addExcludeFilter 僅僅把 定義的規則塞進去，並麼有真正去執行匹配過程
//處理includeFilters
for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addIncludeFilter(typeFilter);
}
}
//處理excludeFilters
for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addExcludeFilter(typeFilter);
}
}
boolean lazyInit = componentScan.getBoolean("lazyInit");
if (lazyInit) {
scanner.getBeanDefinitionDefaults().setLazyInit(true);
}
Set<String> basePackages = new LinkedHashSet<>();
String[] basePackagesArray = componentScan.getStringArray("basePackages");
for (String pkg : basePackagesArray) {
String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
Collections.addAll(basePackages, tokenized);
}
// 從下面的代碼可以看出ComponentScans指定掃描目標，除了最常用的basePackages，還有兩種方式
// 1.指定basePackageClasses，就是指定多個類，只要是與這幾個類同級的，或者在這幾個類下級的都可以被掃描到，這種方式其實是spring比較推薦的
// 因爲指定basePackages沒有IDE的檢查，容易出錯，但是指定一個類，就有IDE的檢查了，不容易出錯，經常會用一個空的類來作爲basePackageClasses
// 2.直接不指定，默認會把與配置類同級，或者在配置類下級的作爲掃描目標
for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
basePackages.add(ClassUtils.getPackageName(clazz));
}
if (basePackages.isEmpty()) {
basePackages.add(ClassUtils.getPackageName(declaringClass));
}
//把規則填充到排除規則：List<TypeFilter>，這裏就把 註冊類自身當作排除規則，真正執行匹配的時候，會把自身給排除
scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
@Override
protected boolean matchClassName(String className) {
return declaringClass.equals(className);
}
});
//basePackages是一個LinkedHashSet<String>，這裏就是把basePackages轉爲字符串數組的形式
return scanner.doScan(StringUtils.toStringArray(basePackages));
}
- 定義了一個掃描器scanner，還記不記在new AnnotationConfigApplicationContext的時候，會調用AnnotationConfigApplicationContext的構造方法，構造方法裏面有一句 this.scanner = new ClassPathBeanDefinitionScanner(this);當時說這個對象不重要，這裏就是證明了。常規用法中，實際上執行掃描的只會是這裏的scanner對象。
- 處理includeFilters，就是把規則添加到scanner。
- 處理excludeFilters，就是把規則添加到scanner。
- 解析basePackages，獲得需要掃描哪些包。
- 添加一個默認的排除規則：排除自身。
- 執行掃描，稍後詳細說明。
這裏需要做一個補充說明，添加規則的時候，只是把具體的規則放入規則類的集合中去，規則類是一個函數式接口，只定義了一個虛方法的接口被稱爲函數式接口，函數式接口在java8的時候大放異彩，這裏只是把規則方塞進去，並沒有真正執行匹配規則。
我們來看看到底是怎麼執行掃描的：
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
//循環處理basePackages
for (String basePackage : basePackages) {
//根據包名找到符合條件的BeanDefinition集合
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
//由findCandidateComponents內部可知，這裏的candidate是ScannedGenericBeanDefinition
//而ScannedGenericBeanDefinition是AbstractBeanDefinition和AnnotatedBeanDefinition的之類
//所以下面的兩個if都會進入
if (candidate instanceof AbstractBeanDefinition) {
//內部會設置默認值
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
//如果是AnnotatedBeanDefinition，還會再設置一次值
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
因爲basePackages可能有多個，所以需要循環處理，最終會進行Bean的註冊。下面再來看看findCandidateComponents方法：
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
//spring支持component索引技術，需要引入一個組件，因爲大部分情況不會引入這個組件
//所以不會進入到這個if
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
}
else {
return scanCandidateComponents(basePackage);
}
}
Spring支持component索引技術，需要引入一個組件，大部分項目沒有引入這個組件，所以會進入scanCandidateComponents方法：
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
//把 傳進來的類似 命名空間形式的字符串轉換成類似類文件地址的形式，然後在前面加上classpath*:
//即：com.xx=>classpath*:com/xx/**/*.class
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
//根據packageSearchPath，獲得符合要求的文件
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
//循環資源
for (Resource resource : resources) {
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
if (resource.isReadable()) {//判斷資源是否可讀，並且不是一個目錄
try {
//metadataReader 元數據讀取器，解析resource，也可以理解爲描述資源的數據結構
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
//在isCandidateComponent方法內部會真正執行匹配規則
//註冊配置類自身會被排除，不會進入到這個if
if (isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug("Identified candidate component class: " + resource);
}
candidates.add(sbd);
}
else {
if (debugEnabled) {
logger.debug("Ignored because not a concrete top-level class: " + resource);
}
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because not matching any filter: " + resource);
}
}
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to read candidate component class: " + resource, ex);
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because not readable: " + resource);
}
}
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}
- 把傳進來的類似命名空間形式的字符串轉換成類似類文件地址的形式，然後在前面加上classpath，即：com.xx=>classpath:com/xx/*/.class。
- 根據packageSearchPath，獲得符合要求的文件。
- 循環符合要求的文件，進一步進行判斷。
最終會把符合要求的文件，轉換爲BeanDefinition，並且返回。
直到這裏，上面說的4.1中提到的方法終於分析完畢了，讓我們再看看上面提到的第5步中的處理@Import註解方法：
//這個方法內部相當相當複雜，importCandidates是Import的內容，調用這個方法的時候，已經說過可能有三種情況
//這裏再說下，1.Import普通類，2.Import ImportSelector，3.Import ImportBeanDefinitionRegistrar
//循環importCandidates，判斷屬於哪種情況
//如果是普通類，會進到else，調用processConfigurationClass方法
//這個方法是不是很熟悉，沒錯，processImports這個方法就是在processConfigurationClass方法中被調用的
//processImports又主動調用processConfigurationClass方法，是一個遞歸調用，因爲Import的普通類，也有可能被加了Import註解，@ComponentScan註解 或者其他註解，所以普通類需要再次被解析
//如果Import ImportSelector就跑到了第一個if中去，首先執行Aware接口方法，所以我們在實現ImportSelector的同時，還可以實現Aware接口
//然後判斷是不是DeferredImportSelector，DeferredImportSelector擴展了ImportSelector
//如果不是的話，調用selectImports方法，獲得全限定類名數組，在轉換成類的數組，然後再調用processImports，又特麼的是一個遞歸調用...
//可能又有三種情況，一種情況是selectImports的類是一個普通類，第二種情況是selectImports的類是一個ImportBeanDefinitionRegistrar類，第三種情況是還是一個ImportSelector類...
//所以又需要遞歸調用
//如果Import ImportBeanDefinitionRegistrar就跑到了第二個if，還是會執行Aware接口方法，這裏終於沒有遞歸了，會把數據放到ConfigurationClass中的Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> importBeanDefinitionRegistrars中去
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
Collection<SourceClass> importCandidates, boolean checkForCircularImports) {
if (importCandidates.isEmpty()) {
return;
}
if (checkForCircularImports && isChainedImportOnStack(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
} else {
this.importStack.push(configClass);
try {
for (SourceClass candidate : importCandidates) {
if (candidate.isAssignable(ImportSelector.class)) {
// Candidate class is an ImportSelector -> delegate to it to determine imports
Class<?> candidateClass = candidate.loadClass();
ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
ParserStrategyUtils.invokeAwareMethods(
selector, this.environment, this.resourceLoader, this.registry);
if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
this.deferredImportSelectors.add(
new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
} else {
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
processImports(configClass, currentSourceClass, importSourceClasses, false);
}
} else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
// Candidate class is an ImportBeanDefinitionRegistrar ->
// delegate to it to register additional bean definitions
Class<?> candidateClass = candidate.loadClass();
ImportBeanDefinitionRegistrar registrar =
BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
ParserStrategyUtils.invokeAwareMethods(
registrar, this.environment, this.resourceLoader, this.registry);
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
} else {
// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
// process it as an @Configuration class
this.importStack.registerImport(
currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
processConfigurationClass(candidate.asConfigClass(configClass));
}
}
} catch (BeanDefinitionStoreException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to process import candidates for configuration class [" +
configClass.getMetadata().getClassName() + "]", ex);
} finally {
this.importStack.pop();
}
}
}
這個方法大概的作用已經在註釋中已經寫明瞭，就不再重複了。
直到這裏，才把ConfigurationClassPostProcessor中的processConfigBeanDefinitions方法簡單的過了一下。
但是這還沒有結束，processConfigBeanDefinitions是BeanDefinitionRegistryPostProcessor接口中的方法，BeanDefinitionRegistryPostProcessor擴展了BeanFactoryPostProcessor，還有postProcessBeanFactory方法沒有分析，這個方法是幹嘛的，簡單的來說，就是判斷配置類是Lite配置類，還是Full配置類，如果是配置類，就會被Cglib代理，目的就是保證Bean的作用域。關於這個方法實在是比較複雜，限於篇幅原因，這裏就不再繼續了，有興趣的朋友可以到我的GitHub看下，裏面有簡單的分析（當然其實還有很多東西無法在博客中體現，如果都貼出來的話，實在是太長了，但是在GitHub上面都有註釋）。
我們來做一個總結，ConfigurationClassPostProcessor中的processConfigBeanDefinitions方法十分重要，主要是完成掃描，最終註冊我們定義的Bean。