Spring，相信每個Java開發都用過，而且是每天都在用，那強大又神祕的IoC，AOP，讓我們的開發變得越來越簡單，只需要一個註解搞定一切，但是它內部到底是什麼樣子的呢？跟着我，一起探究Spring源碼把。
寫在前面的話：Spring項目距今已有15年左右的歷史了，是衆多Java大神們的傑作，由於我個人水平有限，時間有限，不保證我說的全部都是正確的，但是我可以保證每一句話都是反覆推敲，經過驗證，絕沒有複製粘貼。當然在這裏，也不可能把每個方法都進行深層次的分析，只能把重點集中在重要的方法上，有些（其實是絕大部分）只能採取黑盒理論，即：不去探究方法內部到底做了什麼，只大概的知道執行這個方法後發生了什麼。
本文中採用的Spring版本是5.0.0
由於現在JavaConfig風格+註解的方式來使用Spring，是Spring官方主推的，也是現在的主流方式，所以我們從這裏出發：
AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(AppConfig.class);
讓我們先來看看AnnotationConfigApplicationContext的關係圖：
可以看到這個關係夠複雜的，我們現在完全不需要特意全部記住，只要有一個大概的印象就可以了，後面隨着源碼分析的深入，自然而然會記住其中的一些關係。
創建AnnotationConfigApplicationContext對象，首先會跑到這裏：
//根據參數類型可以知道，其實可以傳入多個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();
}
這個方法第一眼看上去，很簡單，無非就是三行代碼，但是這三行代碼包含了大千世界。
我們先來爲構造方法做一個簡單的說明：
這是一個有參的構造方法，可以接收多個配置類，不過一般情況下，只會傳入一個配置類。
這個配置類有兩種情況，一種是傳統意義上的帶上@Configuration註解的配置類，還有一種是沒有帶上@Configuration，但是帶有@Component，@Import，@ImportResouce，@Service，@ComponentScan等註解的配置類，在Spring內部把前者稱爲Full配置類，把後者稱之爲Lite配置類。在本源碼分析中，有些地方也把Lite配置類稱爲普通Bean。
我們先來看一下第一行代碼：通過this()調用此類無參的構造方法，代碼會跑到下面：
public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
//註解bean定義讀取器，主要作用是用來讀取被註解的了bean
private final AnnotatedBeanDefinitionReader reader;
//掃描器，它僅僅是在我們外部手動調用 .scan 等方法纔有用，常規方式是不會用到scanner對象的
private final ClassPathBeanDefinitionScanner scanner;
/**
* Create a new AnnotationConfigApplicationContext that needs to be populated
* through {@link #register} calls and then manually {@linkplain #refresh refreshed}.
*/
public AnnotationConfigApplicationContext() {
//會隱式調用父類的構造方法，初始化DefaultListableBeanFactory
//初始化一個Bean讀取器
this.reader = new AnnotatedBeanDefinitionReader(this);
//初始化一個掃描器，它僅僅是在我們外部手動調用 .scan 等方法纔有用，常規方式是不會用到scanner對象的
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
}
首先映入眼簾的是reader和scanner，無參構造方法中就是對reader和scanner進行了實例化，reader的類型是AnnotatedBeanDefinitionReader，從字面意思就可以看出它是一個 “打了註解的Bean定義讀取器”，scanner的類型是ClassPathBeanDefinitionScanner，其實這個字段並不重要，它僅僅是在我們外面手動調用.scan方法，或者調用參數爲String的構造方法，傳入需要掃描的包名，纔會用到，像我們這樣傳入配置類是不會用到這個scanner對象的。
AnnotationConfigApplicationContext類是有繼承關係的，會隱式調用父類的構造方法：
public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
private final DefaultListableBeanFactory beanFactory;
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
}
這個代碼很簡單，就是初始化了DefaultListableBeanFactory。
我們再來看看DefaultListableBeanFactory的關係圖：
DefaultListableBeanFactory是相當重要的，從字面意思就可以看出它是一個Bean的工廠，什麼是Bean的工廠？當然就是用來生產和獲得Bean的。
讓我們把目光回到AnnotationConfigApplicationContext的無參構造方法，讓我們看看Spring在初始化AnnotatedBeanDefinitionReader的時候做了什麼：
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
this(registry, getOrCreateEnvironment(registry));
}
這裏的BeanDefinitionRegistry當然就是AnnotationConfigApplicationContext的實例了，這裏又直接調用了此類其他的構造方法：
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
Assert.notNull(environment, "Environment must not be null");
this.registry = registry;
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
讓我們把目光移動到這個方法的最後一行，進入registerAnnotationConfigProcessors方法：
public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
registerAnnotationConfigProcessors(registry, null);
}
這又是一個門面方法，再點進去，這個方法的返回值Set<BeanDefinitionHolder>，但是上游方法並沒有去接收這個返回值，所以這個方法的返回值也不是很重要了，當然方法內部給這個返回值賦值也不重要了。由於這個方法內容比較多，這裏就把最核心的貼出來，這個方法的核心就是註冊Spring內置的多個Bean：
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
判斷容器中是否已經存在了ConfigurationClassPostProcessor Bean
如果不存在（當然這裏肯定是不存在的），就通過RootBeanDefinition的構造方法獲得ConfigurationClassPostProcessor的BeanDefinition，RootBeanDefinition是BeanDefinition的子類：
- 執行registerPostProcessor方法，registerPostProcessor方法內部就是註冊Bean。
當然這裏註冊其他Bean也是一樣的流程。
BeanDefinition是什麼，顧名思義，它是用來描述Bean的，裏面存放着關於Bean的一系列信息，比如Bean的作用域，Bean所對應的Class，是否懶加載，是否Primary等等，這個BeanDefinition也相當重要，我們以後會常常和它打交道。
registerPostProcessor方法：
private static BeanDefinitionHolder registerPostProcessor(
BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(beanName, definition);
return new BeanDefinitionHolder(definition, beanName);
}
這方法爲BeanDefinition設置了一個Role，ROLE_INFRASTRUCTURE代表這是spring內部的，並非用戶定義的，然後又調用了registerBeanDefinition方法，再點進去，Oh No，你會發現它是一個接口，沒辦法直接點進去了，首先要知道registry實現類是什麼，那麼它的實現是什麼呢？答案是DefaultListableBeanFactory：
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
}
這又是一個門面方法，再點進去，核心在於下面兩行代碼：
//beanDefinitionMap是Map<String, BeanDefinition>，
//這裏就是把beanName作爲key，ScopedProxyMode作爲value，推到map裏面
this.beanDefinitionMap.put(beanName, beanDefinition);
//beanDefinitionNames就是一個List<String>,這裏就是把beanName放到List中去
this.beanDefinitionNames.add(beanName);
從這裏可以看出DefaultListableBeanFactory就是我們所說的容器了，裏面放着beanDefinitionMap，beanDefinitionNames，beanDefinitionMap是一個hashMap，beanName作爲Key,beanDefinition作爲Value，beanDefinitionNames是一個集合，裏面存放了beanName。打個斷點，第一次運行到這裏，監視這兩個變量：
DefaultListableBeanFactory中的beanDefinitionMap，beanDefinitionNames也是相當重要的，以後會經常看到它，最好看到它，第一時間就可以反應出它裏面放了什麼數據
這裏僅僅是註冊，可以簡單的理解爲把一些原料放入工廠，工廠還沒有真正的去生產。
上面已經介紹過，這裏會一連串註冊好幾個Bean，在這其中最重要的一個Bean（沒有之一）就是BeanDefinitionRegistryPostProcessor Bean。
ConfigurationClassPostProcessor實現BeanDefinitionRegistryPostProcessor接口，BeanDefinitionRegistryPostProcessor接口又擴展了BeanFactoryPostProcessor接口，BeanFactoryPostProcessor是Spring的擴展點之一，ConfigurationClassPostProcessor是Spring極爲重要的一個類，必須牢牢的記住上面所說的這個類和它的繼承關係。
除了註冊了ConfigurationClassPostProcessor，還註冊了其他Bean，其他Bean也都實現了其他接口，比如BeanPostProcessor接口。
BeanPostProcessor接口也是Spring的擴展點之一。
至此，實例化AnnotatedBeanDefinitionReader reader分析完畢。
由於常規使用方式是不會用到AnnotationConfigApplicationContext裏面的scanner的，所以這裏就不看scanner是如何被實例化的了。
把目光回到最開始，再分析第二行代碼：
register(annotatedClasses);
這裏傳進去的是一個數組，最終會循環調用如下方法：
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
//AnnotatedGenericBeanDefinition可以理解爲一種數據結構，是用來描述Bean的，這裏的作用就是把傳入的標記了註解的類
//轉爲AnnotatedGenericBeanDefinition數據結構，裏面有一個getMetadata方法，可以拿到類上的註解
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
//判斷是否需要跳過註解，spring中有一個@Condition註解，當不滿足條件，這個bean就不會被解析
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(instanceSupplier);
//解析bean的作用域，如果沒有設置的話，默認爲單例
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
//獲得beanName
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
//解析通用註解，填充到AnnotatedGenericBeanDefinition，解析的註解爲Lazy，Primary，DependsOn，Role，Description
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
//限定符處理，不是特指@Qualifier註解，也有可能是Primary,或者是Lazy，或者是其他（理論上是任何註解，這裏沒有判斷註解的有效性），如果我們在外面，以類似這種
//AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(Appconfig.class);常規方式去初始化spring，
//qualifiers永遠都是空的，包括上面的name和instanceSupplier都是同樣的道理
//但是spring提供了其他方式去註冊bean，就可能會傳入了
if (qualifiers != null) {
//可以傳入qualifier數組，所以需要循環處理
for (Class<? extends Annotation> qualifier : qualifiers) {
//Primary註解優先
if (Primary.class == qualifier) {
abd.setPrimary(true);
}
//Lazy註解
else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
}
//其他，AnnotatedGenericBeanDefinition有個Map<String,AutowireCandidateQualifier>屬性，直接push進去
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
customizer.customize(abd);
}
//這個方法用處不大，就是把AnnotatedGenericBeanDefinition數據結構和beanName封裝到一個對象中
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
//註冊，最終會調用DefaultListableBeanFactory中的registerBeanDefinition方法去註冊，
//DefaultListableBeanFactory維護着一系列信息，比如beanDefinitionNames，beanDefinitionMap
//beanDefinitionNames是一個List<String>,用來保存beanName
//beanDefinitionMap是一個Map,用來保存beanName和beanDefinition
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
在這裏又要說明下，以常規方式去註冊配置類，此方法中除了第一個參數，其他參數都是默認值。
-
通過AnnotatedGenericBeanDefinition的構造方法，獲得配置類的BeanDefinition，這裏是不是似曾相似，在註冊ConfigurationClassPostProcessor類的時候，也是通過構造方法去獲得BeanDefinition的，只不過當時是通過RootBeanDefinition去獲得，現在是通過AnnotatedGenericBeanDefinition去獲得。
![]()
判斷需不需要跳過註冊，Spring中有一個@Condition註解，如果不滿足條件，就會跳過這個類的註冊。
然後是解析作用域，如果沒有設置的話，默認爲單例。
獲得BeanName。
解析通用註解，填充到AnnotatedGenericBeanDefinition，解析的註解爲Lazy，Primary，DependsOn，Role，Description。
限定符處理，不是特指@Qualifier註解，也有可能是Primary，或者是Lazy，或者是其他（理論上是任何註解，這裏沒有判斷註解的有效性）。
把AnnotatedGenericBeanDefinition數據結構和beanName封裝到一個對象中（這個不是很重要，可以簡單的理解爲方便傳參）。
註冊，最終會調用DefaultListableBeanFactory中的registerBeanDefinition方法去註冊：
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
//獲取beanName
// Register bean definition under primary name.
String beanName = definitionHolder.getBeanName();
//註冊bean
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
//Spring支持別名
// Register aliases for bean name, if any.
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
這個registerBeanDefinition是不是又有一種似曾相似的感覺，沒錯，在上面註冊Spring內置的Bean的時候，已經解析過這個方法了，這裏就不重複了，此時，讓我們再觀察下beanDefinitionMap beanDefinitionNames兩個變量，除了Spring內置的Bean，還有我們傳進來的Bean，這裏的Bean當然就是我們的配置類了：
到這裏註冊配置類也分析完畢了。
大家可以看到其實到這裏，Spring還沒有進行掃描，只是實例化了一個工廠，註冊了一些內置的Bean和我們傳進去的配置類，真正的大頭是在第三行代碼：
refresh();
不過，這就是下一章的內容了。