Spring源碼閱讀-IOC(二)

前言

今天開始跟你們一塊兒進入spring源碼閱讀階段,咱們將從一個你們比較熟悉的高級容器-ClassPathXmlApplicationContext爲入口去了解spring容器的加載過程。

IOC容器的加載

ClassPathXmlApplicationContext有許多構造函數，咱們找到真的調用的入口。
複製代碼

public ClassPathXmlApplicationContext(String[] paths, Class<?> clazz, @Nullable ApplicationContext parent)
			throws BeansException {
        //加載容器前的一些處理
		super(parent);
		Assert.notNull(paths, "Path array must not be null");
		Assert.notNull(clazz, "Class argument must not be null");
		this.configResources = new Resource[paths.length];
		for (int i = 0; i < paths.length; i++) {
			this.configResources[i] = new ClassPathResource(paths[i], clazz);
		}
		//真正開始加載容器的方法
		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.
            // 	建立bean工廠
            //	加載解析XML文件，並完成BeanDefinition的加載和註冊
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
                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.
				// 實例化剩餘的單例bean（非懶加載方式）
                // Bean的IoC、DI和AOP都是發生在這個過程當中
                finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
                finishRefresh();
			}
        。。。。。
	}
複製代碼

spring容器的加載有多個步驟，咱們主要關係裏面的兩個步驟

• obtainFreshBeanFactory():該方法主要是建立springBean工廠，同時加載xml配置文件，將配置文件中的bean標籤，解析成一個個BeanDefinition對象，並註冊到spring容器中
• finishBeanFactoryInitialization(beanFactory)：該方法是實例化spring中非懶加載的單例bean，同時spring中的依賴注入和產生代理對象都是在這個過程當中完成的。

而剩餘的其餘步驟，主要初始哈一些BeanPostProcessor，然括對BeanDefinition的一些處理，初始化一些特殊的bean，而後註冊監聽器，最後廣播加載完成的消息等一些功能。這些功能分支，你們有興趣的能夠本身進行了解，在這裏就不一一詳細說明了。今天，咱們主要是來看springBean的加載，及初始化流程。也就是，咱們主要看finishBeanFactoryInitialization該方法完成的內容。

下面咱們就接着看finishBeanFactoryInitialization這個方法到底完成了些什麼事情:

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	
	。。。。。。。。。

		// Instantiate all remaining (non-lazy-init) singletons.
		// 完成單例Bean的初始化
		beanFactory.preInstantiateSingletons();
	}
複製代碼

這個方法前面的一些內容咱們並不須要太多關注，咱們看到方法最後，這個preInstantiateSingletons()就是實例化咱們單例bean的入口:

public void preInstantiateSingletons() throws BeansException {
		if (this.logger.isDebugEnabled()) {
			this.logger.debug("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		// 加載全部非懶加載方式的單例bena
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						final FactoryBean<?> factory = (FactoryBean<?>) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
											((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else { // 普通bean走下面的方法
					getBean(beanName);
				}
			}
		}
複製代碼

咱們來一步步看下這個方法

• 便利全部的beanName,而後從BeanDefinition集合中獲取到對應的BeanDefinition對象
• 接着判斷該對象若是不是抽象類，是個單例對象，不是懶加載方式的就進入執行if()下面的代碼
• 接着判斷若是這個bean是個特殊的工廠bean，就執行對應的方法。
• 最後就是加載普通的bean

接着咱們順着getBean方法往下點，最終會來到AbstractBeanFactory中真正建立bean的doCreateBean方法

這裏面的代碼很長，在這裏咱們就不貼出來了，你們跟着個人思路往下看就能夠了 *

Object sharedInstance = getSingleton(beanName);
複製代碼

首先咱們看到句代碼，這個實際上是從spring的緩存容器中獲取bean對象，spring容器中一共有三層緩存，一級緩存就是存放spring加載完成的bean對象。而二三級緩存主要是爲了解決spring中的循環依賴這個問題（這個問題比較重要，咱們後面會在具體的說明這個問題）。

// 從一級緩存也就是map容器中獲取對象
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				// 從二級緩存中嘗試獲取單例bean
				singletonObject = this.earlySingletonObjects.get(beanName);
				// allowEarlyReference 
				//是否容許從三級緩存中獲取對象就是是否容許循環依賴
				if (singletonObject == null && allowEarlyReference) {
					//嘗試從三級緩存中獲取單例bean
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						//經過單例工廠獲取單例bean
						singletonObject = singletonFactory.getObject();
						//將bean放到二級緩存
						this.earlySingletonObjects.put(beanName, singletonObject);
						//將bean從三級緩存中刪除
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
複製代碼

這個就是獲取單例bean的過程，其中三級緩存中存放的是bean的工廠對象。

接着咱們繼續看doCreateBean下面的代碼

• 接着就是判斷是否獲取到了bean對象,若是獲取到的是一個Factory對象，就產生對應的bean實例
• 若是沒有獲取到bean對象，就進入else去建立該bean對象
• 接着就看到咱們最主要的建立單例bean的方法

if (mbd.isSingleton()) {
			sharedInstance = getSingletion(beanName, () -> {
				try {
					// 建立單例Bean的主要方法
					return createBean(beanName, mbd, args);
				}
				catch (BeansException ex) {
					// Explicitly remove instance from singleton cache: It might have been put there
					// eagerly by the creation process, to allow for circular reference resolution.
					// Also remove any beans that received a temporary reference to the bean.
					destroySingleton(beanName);
					throw ex;
				}
			});
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
		}
複製代碼

• 這個方法中用了lamda表達式，你們能夠直接點進去getSingleton這個方法中。 裏面的方法很長咱們主要先關注這兩句代碼

singletonObject = singletonFactory.getObject();
	newSingleton = true;
複製代碼

這個getObject()方法真正的實現是以前的這個createBean(beanName, mbd, args); 這個方法是真正去建立一個bean的方法。這個咱們等下在看。 這個getSingletion方法的最後就是將建立好的bean加入到map容器中，同時刪除二三級緩存

addSingleton(beanName, singletonObject);
複製代碼

protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			// 加入到一級緩存
			this.singletonObjects.put(beanName, singletonObject);
			// 刪除三級緩存
			this.singletonFactories.remove(beanName);
			// 刪除二級緩存
			this.earlySingletonObjects.remove(beanName);
			// 將beanName加入到已經建立的beanName集合中
			this.registeredSingletons.add(beanName);
		}
	}
複製代碼

如今咱們就去看下最後一個creatBean這個建立bean的方法

。。。。
try {
			// 完成Bean實例的建立包括-實例化，依賴注入(填充屬性值)，初始化(調用初始化方法)
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isDebugEnabled()) {
				logger.debug("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
。。。
複製代碼

裏面咱們關注這個doCreateBean()，咱們接着往下找,終於來到了具體建立bean的代碼,這代碼有點長，咱們截取一些片斷

// Instantiate the bean.
		。。。
		//1. 實例化bean對象
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		//實例化後的Bean對象
		。。。。。
		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		// 若是該對象是單例的，容許循環依賴，且正在建立中
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		// 爲解決循環依賴提早暴露單例Bean，將該Bean放入三級緩存中
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			// 把剛建立的bean放入三級緩存中
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			// 屬性填充也就是DI的過程
			populateBean(beanName, mbd, instanceWrapper);
			//調用初始化方法，完成初始化操做
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
。。。。。。。
		return exposedObject;
複製代碼

這裏面主要能夠分紅三步

• 實例化單例Bean,且將單例bean放入二級緩存
• 進行bean的屬性填充
• 對bean進行初始化，就是調用初始化方法完成bean的初始化操做

結語

至此，咱們已經看完了springIOC的主要加載流程，咱們主要對bean的建立過程進行了解讀，知道了bean是如何建立出來並加入到容器中。而這裏也剩下一個循環依賴的問題，及屬性填充的過程咱們尚未進行理解和閱讀，這兩個問題咱們留到下面的文章爲你們講解，但願你們多多關注，謝謝閱讀。複製代碼