Spring容器加載過程

1. PrepareRefresh() 刷新前的預處理

• 　　initPropertySources()初始化一些屬性設置
• 　　getEnvironment().validateRequiredProperties(); 檢驗屬性的合法等
• 　　earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>; 保存容器中的一些早期時間

2. obtainFreshBeanFactory(); 獲取BeanFactory

• 　　refreshBeanFactory(); 刷新【創建】BeanFactory
• 　　getBeanFactory(); 返回剛才GenericApplicationContext創建的BeanFactory對象
• 　　將創建的BeanFactory對象【DefaultListableBeanFactory】返回

3. prepareBeanFactory(beanFactory); BeanFactory的預備准備工作（BeanFactory進行一些設置）

• 　　設置BeanFactory的類加載器、支持表達式解析器
• 　　添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
• 　　設置忽略的自動裝配的接口 EnvironmentAware、EmbeddedValueResolverAware。。。
• 　　注冊可以解析的自動裝配，我們能直接在任何組件中自動注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
• 　　添加BeanPostProcessor,【ApplicationListenerDetector】
• 　　添加編譯時的AspectJ支持
• 　　給BeanFactory中注冊一些能用的組件：environment【ConfigurableEnvironment】、SystemProperties【Map<String, Object>】、　　              systemEnvironment【Map<String, Object>】

4. postProcessBeanFactory(beanFactory); BeanFactory准備工作完成后進行的后置處理工作：

• 　　子類通過這個方法在BeanFactory創建並預准備完成后做的進一步設置

============================以上是BeanFactoty的創建和預准備工作==============================================

5. invokeBeanFactoryPostProcessor(beanFactory); 執行BeanFactoryPostProcessor

　　BeanFactoryPostProcessor：BeanFactory的后置處理器。在BeanFactory標准初始化之后執行的。

　　兩個接口，BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor

　　1) 執行BeanFactoryPostProcessor的方法：

　　　　先執行BeanDefinitionRegistryPostProcessor--

　　　　a. 獲取所有的BeanDefinitionRegistryPostProcessor

　　　　b. 先執行實現了PriorityOrdered優先級接口的BeanDefinitionRegistryPostProcessor

　　　　　　執行方法postProcessor.postProcessBeanDefinitionRegistry(registry)

　　　　c. 再執行實現了Ordered順序接口的BeanDefinitionRegistryPostProcessor

　　　　　　執行方法postProcessor.postProcessBeanDefinitionRegistry(registry)

　　　　d. 最后執行沒有實現任何優先級或者是順序接口的BeanDefinitionRegistryPostProcessor

　　　　　　執行方法postProcessor.postProcessBeanDefinitionRegistry(registry)

　　　　再執行BeanFactoryPostProcessor的方法--

　　　　a. 獲取所有的BeanFactoryPostProcessor

　　　　b. 先執行實現了PriorityOrdered優先級接口的BeanFacotryPostProcessor

　　　　　　執行方法postProcessor.postProcessBeanFactory(registry)

　　　　c. 再執行實現了Ordered順序接口的BeanFacotryPostProcessor

　　　　　　執行方法postProcessor.postProcessBeanFactory(registry)

　　　　d. 最后執行沒有實現任何優先級或者是順序接口的BeanFacotryPostProcessor

　　　　　　執行方法postProcessor.postProcessBeanFactory(registry)

6. registerBeanPostProcessor(beanFactory); 注冊BeanPostProcessor （Bean的后置處理器）

　　不同接口類型的BeanPostProcessor：在Bean創建前后的執行時機是不一樣的

　　BeanPostProcessor、

　　DestructionAwareBeanPostProcessor、

　　InstantiationAwareBeanPostProcessor、

　　SmartInstantiationAwareBeanPostProcessor、

　　MergedBeanDefinitionPostProcessor

　　1）獲取所有的BeanPostProcessor ；后置處理器都默認可以通過PriorityOrdered、Ordered接口來指定優先級

　　2）先注冊PriorityOrdered優先級接口的BeanPostProcessor

　　　　把每一個BeanPostProcessor添加到BeanFactory中

　　　　beanFactory.addBeanPostProcessor(postProcessor)

　　3) 再注冊Ordered優先級接口的BeanPostProcessor

　　4）然后再注冊沒有任何優先級接口的BeanPostProcessor

　　5）最終注冊MergedBeanDefinitionPostProcessor

　　6）注冊一個ApplicationListenerDetector: 再Bean創建完成后檢查是否是ApplicationListener，如果是則執行

　　　　applicationContext.addApplicaitonListener((ApplicationListener<?>) bean)

7. InitMessageSource()；初始化MessageSource組件（做國際化功能；消息綁定，消息解析）

　　1）獲取BeanFactory

　　2）看容器中是否有id為messageSource，類型是MssageSource的組件

　　　　如果有就賦值給messageSource，如果沒有就自己創建一個DelegatingMssageSource;

　　　　　　MssageSource: 取出國際化配置文件中某個key的值；能按照區域信息獲取；

　　3）把創建好的messageSource注冊到容器中，以后獲取國際化配置文件的時候，可以自動注入MssageSource，然后可以再調用它的getMessage方法　　　　beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource)

 8. initApplicationEventMulticaster(); 初始化事件派發器；

　　1）獲取BeanFactory

　　2）從BeanFactory中獲取applicationEventMulticaster的ApplicationEventMulticaster；

　　3）如果上一步沒有配置，那就會自己創建一個SimpleApplicationEventMulticaster，然后將創建的ApplicationEventMulticaster組件添加到BeanFactory中，以后其他組件可以直接z注入

9. onRefresh(); 留給子容器(子類)

　　1）子類重寫這個方法，在容器刷新的時候可以自定義邏輯

10. registerListeners()；將項目中所有ApplicationListener注冊進容器中

　　1）從容器中拿到所有的ApplicationListener

　　2）將每個監聽器添加到事件派發器中

　　　　getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName)

　　3）派發之前步驟產生的事件；

11. finishBeanFactoryInitialization(beanFactory)；初始化所有剩下的單實例Bean

　　1）beanFactory.preInstantiateSingletons()；初始化所有剩下的單實例Bean

　　　　a. 獲取容器中的所有bean, 依次進行初始化和創建對象

　　　　b. 獲取Bean的定義信息；RootBeanDefinition

　　　　c. Bean 不是抽象的，是單實例的，且不是懶加載的，

　　　　　　a) 判斷是不是FactoryBean；是否是實現FactoryBean接口的Bean

　　　　　　b) 如果不是FactoryBean；使用getBean(beanName)創建對象

　　　　　　　　0. getBean(beanName) -> ioc.getBean();

　　　　　　　　1. doGetBean(name, null, null, false)

　　　　　　　　2. 先獲取緩存中保存的單實例Bean。如果能獲取到，說明這個Bean之前被創建過（所有創建過的單實例Bean都會被緩存起來） 

　　　　　　　　　　從singletonObjects中獲取

　　　　　　　　3. 緩存中獲取不到，開始Bean的創建對象流程；

　　　　　　　　4. 標記當前Bean已經被創建

　　　　　　　　5. 獲取Bean的定義信息

　　　　　　　　6. 獲取當前Bean依賴的其它Bean；如果有，還是按照getBean() 把依賴的Bean先創建出來

　　　　　　　　7. 啟動單實例Bean的創建流程

　　　　　　　　　　1）createBean(beanName, mbd, args);

　　　　　　　　　　2）Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

　　　　　　　　　　　　讓BeanPostProcesser先攔截返回代理對象；

　　　　　　　　　　　　InstantiationAwareBeanPostProcessor提前執行

　　　　　　　　　　　   先觸發：postProcessBeforeInstantiation();

　　　　　　　　　　　　如果有返回值；再觸發postProcessAfterInstantiation()

　　　　　　　　　　3）如果前面的InstantiationAwareBeanPostProcessor沒有返回代理對象；調用 4）

　　　　　　　　　　4) Object beanInstance = doCreateBean(beanName, mbdToUse, args) 創建Bean

　　　　　　　　　　　　1） 創建Bean實例，createBeanInstance(beanName, mbd, args)

　　　　　　　　　　　　　　利用工廠方法或者對象的構造器創建出Bean實例

　　　　　　　　　　　　2）applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName)

　　　　　　　　　　　　　　調用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName)

　　　　　　　　　　　　3) 給Bean屬性賦值，調用populateBean(beanName, mbd, instanceWrapper)

　　　　　　　　　　　　　賦值之前：

　　　　　　　　　　　　　　a. 拿到InstantiationAwareBeanPostProcessor后置處理器

　　　　　　　　　　　　　　　　執行postProcessAfterInstantiation()

　　　　　　　　　　　　　　b. 拿到InstantiationAwareBeanPostProcessor后置處理器

　　　　　　　　　　　　　　　　執行postProcessPropertyValues()：

 　　　　　　　　　　　　　　c. 應用Bean屬性的值：為屬性利用setter方法進行賦值（反射）

　　　　　　　　　　　　　　　　applyPropertyValues(beanName, mbd, bw, pvs)

　　　　　　　　　　　　　4）初始化Bean；initializeBean(beanName, exposedObject, mbd);

　　　　　　　　　　　　　　a. 【執行Aware接口方法】 invokeAwareMethods(beanName, bean);執行xxxAware接口的方法

　　　　　　　　　　　　　　　　BeanNameAware\BeanClassLoaderAware\BeanFactoryAware

　　　　　　　　　　　　　　b）【執行后置處理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName)

　　　　　　　　　　　　　　　　BeanPostProcessor.postProcessBeforeInitialization();

　　　　　　　　　　　　　　c）【執行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);

　　　　　　　　　　　　　　　　a. 是否是InitializingBean接口的實現：執行接口規定的初始化

　　　　　　　　　　　　　　　　b. 是否自定義初始化方法

　　　　　　　　　　　　　　d）【執行后置處理器初始化之后】applyBeanPostProcessorsAfterInitialization

　　　　　　　　　　　　　　　　BeanPostProcessor.postProcessAfterInitialization();

　　　　　　　　　　　　　　e）注冊Bean的銷毀方法

　　　　　　　　　　　　5）將創建的Bean添加到緩存中 - singletonObjects [Map對象]

　　　　　　　IOC容器就是這些Map；很多的Map里保存了單實例Bean，環境信息、、、

　　　　　　　所有Bean都利用getBean創建完成以后；再來檢查所有Bean是否是SmartInitializingSingleton接口的實現類，

　　　　　　　　如果是，就執行afterSingletonsInstantiated();

12. finishRefresh(); 完成BeanFactory的初始化創建工作；IOC容器就創建完成；

　　1）initLifecycleProcessor(); 初始化和生命周期相關的后置處理器；LifecycleProcessor

　　　　默認從容器中找是否有lifecycleProcessor的組件【LifecycleProcessor】；如果沒有，創建/使用默認的生命周期組件 new DefaultLifecycleProcessor(); 再加入到容器中；

　　　　寫一個 LifecycleProcessor的實現類，可以在BeanFactory的下面兩個方法刷新和關閉前后進行攔截調用

　　　　　　　　　　　　　　　　　　　　　　　　onRefresh()

　　　　　　　　　　　　　　　　　　　　　　　　onClose()

　　2）getLifecycleProcessor().onRefresh();

　　　　拿到前面定義的生命周期處理器（BeanFactory）；回調.onRefresh();

　　3）publishEvent(new ContextRefreshedEvent(this)); 發布容器刷新完成時間；

　　4）liveBeansView.registerApplicationContext();

=============總結===============

1）spring容器在啟動的時候，先回保存所有注冊進來的Bean的定義信息

　　a. xml注冊bean：<bean>

　　b. 注解注冊Bean：@Service、@Repository、@Component、@Bean、xxx

2）Spring容器會在合適的時機創建這些Bean

　　a.用到這個bean的時候，利用getBean創建Bean，創建好以后保存在容器中。

　　b. 統一創建剩下的所有bean的時候：finishBeanFactoryInitialization();

3) 后置處理器：

　　a. 每一個bean創建完成，都會使用各種后置處理器處理，來增強bean的功能；

　　 例如： AutoWiredAnnotationBeanPostProcessor: 處理自動注入功能

　　　　　AnnotationAwareAspectJAutoProxyCreator: 來做AOP功能

4）事件驅動模型：

　　ApplicationListener: 事件監聽

　　ApplicationEventMulticaster: 事件派發