SpringIoc容器初始化主題流程

這是我參與更文挑戰的第5天，活動詳情查看：更文挑戰spring

1.1 Spring IoC的容器體系

IoC容器是Spring的核心模塊，是抽象了對象管理、依賴關係管理的框架解決方案。Spring 提供了不少的容器，其中 BeanFactory 是頂層容器(根容器)，不能被實例化，它定義了全部 IoC 容器必須聽從的一套原則，具體的容器實現能夠增長額外的功能，好比咱們經常使用到的ApplicationContext，其下更具體的實現如 ClassPathXmlApplicationContext 包含了解析 xml 等一系列的內容，
AnnotationConfigApplicationContext 則是包含了註解解析等一系列的內容。Spring IoC 容器繼承體系很是聰明，須要使用哪一個層次用哪一個層次便可，沒必要使用功能大而全的。
BeanFactory 頂級接口方法棧以下markdown

BeanFactory 容器繼承體系app

經過其接口設計，咱們能夠看到咱們一向使用的 ApplicationContext 除了繼承BeanFactory的子接口，還繼承了ResourceLoader、MessageSource等接口，所以其提供的功能也就更豐富了。
下面咱們以 ClasspathXmlApplicationContext 爲例，深刻源碼說明 IoC 容器的初始化流程。框架

1.2 Bean生命週期關鍵時機點

思路:建立一個類 LagouBean ，讓其實現幾個特殊的接口，並分別在接口實現的構造器、接口方法中斷點，觀察線程調用棧，分析出 Bean 對象建立和管理關鍵點的觸發時機。
TestBean類:ide

package com.lagou;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import
org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;
/** * @Author yuyuyu * @create 2021/06/07 11:46 */
public class TestBean implements InitializingBean{
/** * 構造函數 */
  public LagouBean(){
  System.out.println("TestBean 構造器..."); 
  }
  /** * InitializingBean 接口實現 */
  public void afterPropertiesSet() throws Exception {
    System.out.println("TestBean afterPropertiesSet...");
  } 
}
複製代碼

BeanPostProcessor 接口實現類函數

package com.lagou;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
/** * @Author yuyuyu * @create 2019/06/07 16:59 */
public class MyBeanPostProcessor implements BeanPostProcessor {
  public MyBeanPostProcessor() { 
    System.out.println("BeanPostProcessor 實現類構造函數...");
  }
  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    if("LagouBean".equals(beanName)) { 
      System.out.println("BeanPostProcessor 實現類 postProcessBeforeInitialization 方法被調用中......"); 
     }
    return bean;
  }
 @Override
 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    if("LagouBean".equals(beanName)) { 
        System.out.println("BeanPostProcessor 實現類 postProcessAfterInitialization 方法被調用中......"); }
    return bean;
  }
}
複製代碼

BeanFactoryPostProcessor 接口實現類源碼分析

package com.lagou;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;
/** * @Author yuyuyu * @create 2021/06/07 16:56 */
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
public MyBeanFactoryPostProcessor() { 
    System.out.println("BeanFactoryPostProcessor的實現類構造函數...");
}
@Override
  public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
      System.out.println("BeanFactoryPostProcessor的實現方法調用中......"); }
}
複製代碼

applicationContext.xmlpost

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="lagouBean" class="com.lagou.LagouBean"/> <bean id="myBeanFactoryPostProcessor" class="com.lagou.MyBeanFactoryPostProcessor"/> <bean id="myBeanPostProcessor" class="com.lagou.MyBeanPostProcessor"/> </beans>
複製代碼

IoC 容器源碼分析用例ui

/** * Ioc 容器源碼分析基礎案例 */
@Test
public void testIoC() {
  ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
  LagouBean lagouBean = applicationContext.getBean(LagouBean.class);
  System.out.println(lagouBean);
}
複製代碼

(1)分析 Bean 的建立是在容器初始化時仍是在 getBean 時this

根據斷點調試，咱們發現，在未設置延遲加載的前提下，Bean 的建立是在容器初始化過程當中完成的。
(2)分析構造函數調用狀況

經過如上觀察，咱們發現構造函數的調用時機在AbstractApplicationContext類refresh方法的 finishBeanFactoryInitialization(beanFactory)處;
(3)分析 InitializingBean 之 afterPropertiesSet 初始化方法調用狀況

經過如上觀察，咱們發現 InitializingBean中afterPropertiesSet 方法的調用時機也是在 AbstractApplicationContext類refresh方法的finishBeanFactoryInitialization(beanFactory);
(4)分析BeanFactoryPostProcessor 初始化和調用狀況 分別在構造函數、postProcessBeanFactory 方法處打斷點，觀察調用棧，
發現 BeanFactoryPostProcessor 初始化在AbstractApplicationContext類refresh方法的 invokeBeanFactoryPostProcessors(beanFactory);
postProcessBeanFactory 調用在AbstractApplicationContext類refresh方法的 invokeBeanFactoryPostProcessors(beanFactory);
(5)分析 BeanPostProcessor 初始化和調用狀況
分別在構造函數、postProcessBeanFactory 方法處打斷點，觀察調用棧，發現
BeanPostProcessor 初始化在AbstractApplicationContext類refresh方法的 registerBeanPostProcessors(beanFactory);
postProcessBeforeInitialization 調用在AbstractApplicationContext類refresh方法的 finishBeanFactoryInitialization(beanFactory);
postProcessAfterInitialization 調用在AbstractApplicationContext類refresh方法的 finishBeanFactoryInitialization(beanFactory);
(6)總結
根據上面的調試分析，咱們發現 Bean對象建立的幾個關鍵時機點代碼層級的調用都在 AbstractApplicationContext 類的 refresh 方法中，可⻅這個方法對於Spring IoC 容器初始化來講至關關鍵，彙總以下:

關鍵點	觸發代碼
構造器	refresh#finishBeanFactoryInitialization(beanFactory)(beanFactory)
BeanFactoryPostProcessor 初始化	refresh#invokeBeanFactoryPostProcessors(beanFactory)
BeanFactoryPostProcessor 方法調用	refresh#invokeBeanFactoryPostProcessors(beanFactory)
BeanPostProcessor 初始化	registerBeanPostProcessors(beanFactory)
BeanPostProcessor 方法調用	refresh#finishBeanFactoryInitialization(beanFactory)

1.3 Spring IoC容器初始化主流程

由上分析可知，Spring IoC 容器初始化的關鍵環節就在 AbstractApplicationContext#refresh() 方法中，咱們查看 refresh 方法來俯瞰容器建立的主體流程，主體流程下的具體子流程咱們後面再來討論。

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
                        // 第一步:刷新前的預處理
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
                        /* 第二步: 獲取BeanFactory;默認實現是DefaultListableBeanFactory 加載BeanDefition 並註冊到 BeanDefitionRegistry */
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
                        // 第三步:BeanFactory的預準備工做(BeanFactory進行一些設置，好比context的類加 載器等)
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
                                // 第四步:BeanFactory準備工做完成後進行的後置處理工做
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
                                // 第五步:實例化並調用實現了BeanFactoryPostProcessor接口的Bean
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
                                // 第六步:註冊BeanPostProcessor(Bean的後置處理器)，在建立bean的先後等執行
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
                                // 第七步:初始化MessageSource組件(作國際化功能;消息綁定，消息解析)
				initMessageSource();

				// Initialize event multicaster for this context.
                                // 第八步:初始化事件派發器
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
                                // 第九步:子類重寫這個方法，在容器刷新的時候能夠自定義邏輯
				onRefresh();

				// Check for listener beans and register them.
                                // 第十步:註冊應用的監聽器。就是註冊實現了ApplicationListener接口的監聽器
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
                                /* 第十一步: 初始化全部剩下的非懶加載的單例bean 初始化建立非懶加載方式的單例Bean實例(未設置屬性) 填充屬性 初始化方法調用(好比調用afterPropertiesSet方法、init-method方法) 調用BeanPostProcessor(後置處理器)對實例bean進行後置處 */
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}
		}
	}
複製代碼