Spring的IOC容器初始化源碼分析三：refresh（02）

3.	 prepareBeanFactory(beanFactory);

	//爲BeanFactory配置容器特性，例如類加載器、事件處理器等
	// 對beanFactory做一些設置，例如類加載器、SPEL解析器、指定bean的某些類型的成員變量對應某些對象.
	
	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
		// 設置BeanFactory的類加載器
		beanFactory.setBeanClassLoader(getClassLoader());
		// 設置支持表達式解析器
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.
		// 添加部分BeanPostProcessor[ApplicationContextAwareProcessor]
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		
		// 設置忽略的自動裝配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
		// 這些接口的實現類不能通過類型來自動注入
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

		// BeanFactory interface not registered as resolvable type in a plain factory.
		// MessageSource registered (and found for autowiring) as a bean.
		
		// 註冊可以解析的自動裝配；我們能直接在任何組件中自動注入：
		//BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
    	// 其他組件中可以通過下面方式直接註冊使用
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// Register early post-processor for detecting inner beans as ApplicationListeners.
		// 添加BeanPostProcessor【ApplicationListenerDetector】後置處理器，在bean初始化前後的一些工作
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// Detect a LoadTimeWeaver and prepare for weaving, if found.
		// 添加編譯時的AspectJ；
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			// Set a temporary ClassLoader for type matching.
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

		// Register default environment beans.
		// 、給BeanFactory中註冊一些能用的組件；
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			// 環境信息ConfigurableEnvironment
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			//系統屬性，systemProperties[Map<String, Object>]
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			//系統環境變量systemEnvironment[Map<String, Object>]
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}

 

//爲容器的某些子類指定特殊的BeanPost事件處理器
4.	postProcessBeanFactory(beanFactory);
	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	}

	//調用所有註冊的BeanFactoryPostProcessor的Bean，方法用來執行BeanFactory實例的後置處理器BeanFactoryPostProcessor的postProcessBeanFactory方法
5.	invokeBeanFactoryPostProcessors(beanFactory);
	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}
	
	//爲BeanFactory註冊BeanPost事件處理器.
	//BeanPostProcessor是Bean後置處理器，用於監聽容器觸發的事件
	就是找出所有的bean的後置處理器(注意，是bean的後置處理器，不是beanFactory的後置處理器，bean後置處理器處理的是bean實例，beanfactory後置處理器處理的是bean的定義)，然後將這些bean的後置處理器分爲三類：
實現了順序接口Ordered.class的，先放入orderedPostProcessors集合，排序後順序加入beanFactory的bean後處理集合中；
既沒有實現Ordered.class，也沒有實現PriorityOrdered.class的後置處理器，也加入到beanFactory的bean後處理集合中；
最後是實現了優先級接口PriorityOrdered.class的，排序後順序加入beanFactory的bean後處理集合中；
registerBeanPostProcessors方法執行完畢後，beanFactory中已經保存了有序的bean後置處理器，在bean實例化之後，會依次使用這些後置處理器對bean實例來做對應的處理；
6.	registerBeanPostProcessors(beanFactory);
	protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}
7.initMessageSource
initMessageSource方法用來準備國際化資源相關的，將實現了MessageSource接口的bean存放在ApplicationContext的成員變量中，先看是否有配置，如果有就實例化，否則就創建一個DelegatingMessageSource實例的bean
	protected void initMessageSource() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
			this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
			// Make MessageSource aware of parent MessageSource.
			if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
				HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
				if (hms.getParentMessageSource() == null) {
					// Only set parent context as parent MessageSource if no parent MessageSource
					// registered already.
					hms.setParentMessageSource(getInternalParentMessageSource());
				}
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Using MessageSource [" + this.messageSource + "]");
			}
		}
		else {
			// Use empty MessageSource to be able to accept getMessage calls.
			DelegatingMessageSource dms = new DelegatingMessageSource();
			dms.setParentMessageSource(getInternalParentMessageSource());
			this.messageSource = dms;
			beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
			if (logger.isDebugEnabled()) {
				logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
						"': using default [" + this.messageSource + "]");
			}
		}
	}


8.initApplicationEventMulticaster
spring中有事件、事件廣播器、事件監聽器等組成事件體系，在initApplicationEventMulticaster方法中對事件廣播器做初始化，如果找不到此bean的配置，就創建一個SimpleApplicationEventMulticaster實例作爲事件廣播器的bean，並且保存爲applicationContext的成員變量applicationEventMulticaster
initApplicationEventMulticaster();
	protected void initApplicationEventMulticaster() {
		//獲取BeanFactory
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		// 判斷是否存在
		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
			// 從容器中獲取ApplicationEventMulticaster對象
			this.applicationEventMulticaster =
					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
			if (logger.isDebugEnabled()) {
				logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
			}
		}
		else {
			// 初始一個SimpleApplicationEventMulticaster對象
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
			// 創建的對象註冊到BeanFactory中
			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
			if (logger.isDebugEnabled()) {
				logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
						APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
						"': using default [" + this.applicationEventMulticaster + "]");
			}
		}
	}
	
9.onRefresh
	//調用子類的某些特殊Bean初始化方法，onRefresh是個空方法，留給子類自己實現的，在實例化bean之前做一些ApplicationContext相關的操作
	onRefresh();
	
10.registerListeners
//爲事件傳播器註冊事件監聽器.
	protected void registerListeners() {
		// Register statically specified listeners first.
		// 註冊的都是特殊的事件監聽器，而並非配置中的bean
		for (ApplicationListener<?> listener : getApplicationListeners()) {
			getApplicationEventMulticaster().addApplicationListener(listener);
		}

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let post-processors apply to them!
		// 根據接口類型找出所有監聽器的名稱
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
		for (String listenerBeanName : listenerBeanNames) {
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

		// Publish early application events now that we finally have a multicaster...
		// 這裏只是把監聽器的名稱保存在廣播器中，並沒有將這些監聽器實例化！！！
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (earlyEventsToProcess != null) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
	}