做一個合格的程式猿之淺析Spring IoC原始碼（十一）Spring refresh()方法解析之一

阿新 • • 發佈：2019-01-12

經過上面幾節的簡單介紹我們瞭解了spring的一些元件，現在我們來分析一下AbstractApplicationContext中的refresh()這個核心方法吧~

用我們上一節的程式碼，debug進入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.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 準備beanfactory來使用這個上下文.做一些準備工作，例如classloader，beanfactoryPostProcessor等
			prepareBeanFactory(beanFactory);

			try {
				//允許上下文的子類去執行postProcessor
				postProcessBeanFactory(beanFactory);

				// 開始執行註冊到該上下文的BeanFactoryPostProcessors
				invokeBeanFactoryPostProcessors(beanFactory);

				// 開始註冊BeanPostProcessor來攔截其他的bean的初始化過程
				registerBeanPostProcessors(beanFactory);

				// 初始化訊息源
				initMessageSource();

				//註冊上下文事件的廣播集
				initApplicationEventMulticaster();

				//初始化一些特殊的bean
				onRefresh();

				//查詢並校驗監聽器並註冊
				registerListeners();

				// 例項化所有非懶載入的所有bean
				finishBeanFactoryInitialization(beanFactory);

				//最後一步釋出所有的運用
				finishRefresh();
			}

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

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

				// Propagate exception to caller.
				throw ex;
			}
		}
	}

結合上一節我們給出的spring的一些元件例項化的初始化順序圖：

我們先看invokeBeanFactoryPostProcessors(beanFactory)這個方法

<span style="color:#000000;">protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		// 先執行BeanDefinitionRegistryPostProcessors，因為我們這邊沒有實現這個介面，先暫時忽略，這段程式碼
		Set<String> processedBeans = new HashSet<String>();
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
			List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
					new LinkedList<BeanDefinitionRegistryPostProcessor>();
			for (BeanFactoryPostProcessor postProcessor : getBeanFactoryPostProcessors()) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryPostProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
					registryPostProcessors.add(registryPostProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}
			Map<String, BeanDefinitionRegistryPostProcessor> beanMap =
					beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class, true, false);
			List<BeanDefinitionRegistryPostProcessor> registryPostProcessorBeans =
					new ArrayList<BeanDefinitionRegistryPostProcessor>(beanMap.values());
			OrderComparator.sort(registryPostProcessorBeans);
			for (BeanDefinitionRegistryPostProcessor postProcessor : registryPostProcessorBeans) {
				postProcessor.postProcessBeanDefinitionRegistry(registry);
			}
			invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(registryPostProcessorBeans, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
			processedBeans.addAll(beanMap.keySet());
		}
		else {
			// Invoke factory processors registered with the context instance.
			invokeBeanFactoryPostProcessors(getBeanFactoryPostProcessors(), beanFactory);
		}

		//在beanFactory中獲取實現BeanFactoryPostProcessor這個介面的bean的名稱
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// 將獲取到的BeanFactoryPostProcessors的bean分類，根據這些bean是否也實現了PriorityOrdered，Ordered這些介面，或者其他，因為我們的例子中
		// 並沒有實現這些介面，所以我們的"springMultiBean"這個在spring-init.xml中（程式碼見上一節）定義的bean將進入nonOrderedPostProcessorNames.add(ppName)這個程式碼塊
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		List<String> orderedPostProcessorNames = new ArrayList<String>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			else if (isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		//首先先執行實現“權重排序”的BeanFactoryPostProcessors，我們的bean“springMultiBean”並沒有實現，所以不管
		OrderComparator.sort(priorityOrderedPostProcessors);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// 然後執行實現“排序”的介面的BeanFactoryPostProcessors，我們也沒有實現，暫時不看這塊程式碼塊
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		OrderComparator.sort(orderedPostProcessors);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// 最後執行“其他”的BeanFactoryPostProcessors，這邊就即將執行我們的springMultiBean這個bean的BeanFactoryPostProcessors
		// 這邊新建了一個List型別是BeanFactoryPostProcessor，好了，這邊就開始需要例項化實現BeanFactoryPostProcessor的bean了，否則，
		// 無法放入List<BeanFactoryPostProcessor> 也就是說，如果想先執行BeanFactoryPostProcessor的方法，必須先例項化實現該介面的bean
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		//可能我們的配置檔案有很多的bean實現了BeanFactoryPostProcessors，迴圈bean的名字
		for (String postProcessorName : nonOrderedPostProcessorNames) {
		    //底下的方法塊是核心塊，getBean這個方法就是初始化實現BeanFactoryPostProcessor這個介面的bean了，例項化好了之後放入List<BeanFactoryPostProcessor>
			nonOrderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		//批量執行nonOrderedPostProcessors中的BeanFactoryPostProcessor
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
	}</span>

好了，到目前為止，我們應該知道了上一節的spring Bean例項化順序的執行截圖了：

也就是我們的上次總結的結論：

①首先執行的是建構函式

②然後執行的BeanNameAware這個介面中的方法

③然後執行的是BeanFactoryAware這個介面中的方法

④執行InitializingBean介面中的afterPropertiesSet的方法

⑤執行我們在xml中定義的init-method這個方法

⑥最後執行的是BeanFactoryPostProcessor這個方法

分析了invokeBeanFactoryPostProcessors這個方法，我們知道這個方法就是去執行BeanFactoryPostProcessor

這個介面中的方法去的，上面程式碼註釋也清楚的寫到如果想先執行BeanFactoryPostProcessor這個介面的方法，必須先去例項化實現這個介面的Bean,也就是getBean這個方法了，即在執行⑥之前，①~⑤這些方法全是在getBean這個方法中執行的：

我們接著分析一下getBean這個超級核心的方法：

<span style="color:#000000;">@SuppressWarnings("unchecked")
	protected <T> T doGetBean(
			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {

		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isDebugEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// Check if bean definition exists in this factory.
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}

			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dependsOnBean : dependsOn) {
						getBean(dependsOnBean);
						registerDependentBean(dependsOnBean, beanName);
					}
				}

				// Create bean instance.
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						public Object getObject() throws BeansException {
							try {
								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);
				}

				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else {
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
					}
					try {
						Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
							public Object getObject() throws BeansException {
								beforePrototypeCreation(beanName);
								try {
									return createBean(beanName, mbd, args);
								}
								finally {
									afterPrototypeCreation(beanName);
								}
							}
						});
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new BeanCreationException(beanName,
								"Scope '" + scopeName + "' is not active for the current thread; " +
								"consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
								ex);
					}
				}
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		// Check if required type matches the type of the actual bean instance.
		if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
			try {
				return getTypeConverter().convertIfNecessary(bean, requiredType);
			}
			catch (TypeMismatchException ex) {
				if (logger.isDebugEnabled()) {
					logger.debug("Failed to convert bean '" + name + "' to required type [" +
							ClassUtils.getQualifiedName(requiredType) + "]", ex);
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}
</span>

好吧~，這個getBean的具體實現貌似有點長，一步步分析吧

第一部分：

這個方法首先先去singleton快取中去找例項（這裡我們肯定沒找到，應該我們沒有把我們的bean手動放入singletonObjects這個Map裡面去）

第二部分：

這段程式碼是先獲取該beanFactory父factory，希望從這些factory中獲取，如果該beanfactory有父類，則希望用父類去例項化該bean，我們這邊的beanfactory為null，暫不討論~

接著看第三部分：

上圖中

第一部分先標記目前的bean的正在建立

第二部分獲取根據beanName該bean在beanfactory中的beanDefinitionMap的BeanDefinition,然後去獲取這個bean依賴的bean，如果依賴的bean還沒有建立，則先建立依賴的bean，遞迴呼叫，（Dependence Inject依賴注入的概念吧），如果找不到依賴，則忽略

第三部分：如果是單例（我們暫時只討論如何建立單例）

則呼叫createBean()這個方法

好了，我們暫不看Prototype建立的過程，我們接著跟蹤createBean()

上圖中

第①部分：確保該bean的class是真實存在的，也就是該bean是可以classload可以找到載入的

第②部分：準備方法的重寫

第③部分（很重要）：請注意，這邊有個return，也就是說這邊可以返回bean了，但看註釋：Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.這邊就很清晰了，我們以前在beanPostProcessor的章節講過，beanPostProcessor是可以臨時修改bean的，它的優先順序高於正常例項化bean的（也就是第四部分例項化的方法），如果beanPostProcessor能返回，則直接返回了，這邊程式碼下次分析，我們還是先分析主要流程：

看第四部分：

doCreateBean(beanName, mbd, args)這個方法