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，但是上游方法並沒有去接收這個返回值，所以這個方法的返回值也不是很重要了，當然方法內部給這個返回值賦值也不重要了。由於這個方法內容比較多，這里就把最核心的貼出來，這個方法的核心就是注冊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的子類：
3.執行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();
不過，這就是下一章的內容了。