從啟動類的run()方法開始debug，一步一步step into開啟spring原始碼之旅，目前還只能看個大概，慢慢來吧，得多咀嚼，細品味。
原始碼中太多的回撥、錯綜複雜的繼承、實現、反射等思想，一口氣想吞下恐怕是有點奢望，來日方長。
下面是別人總結的，我照著debug了一次，確實是這麼個流程。
看原始碼發現複雜的父子、實現類的關係導致不能直接的ctrl+左鍵進入物件或方法，需要在debug過程中step into或者檢視具體實現類/呼叫類是哪一個。

Spring容器的refresh()【建立重新整理】;

1、prepareRefresh()重新整理前的預處理;

1）、initPropertySources()初始化一些屬性設定;子類自定義個性化的屬性設定方法；
2）、getEnvironment().validateRequiredProperties();檢驗屬性的合法等
3）、earlyApplicationEvents= new LinkedHashSet<ApplicationEvent>();儲存容器中的一些早期的事件；

2、obtainFreshBeanFactory();獲取BeanFactory；

1）、refreshBeanFactory();重新整理【建立】BeanFactory；
		建立了一個this.beanFactory = new DefaultListableBeanFactory();
		設定id；
2）、getBeanFactory();返回剛才GenericApplicationContext建立的BeanFactory物件；
3）、將建立的BeanFactory【DefaultListableBeanFactory】返回；
 

3、prepareBeanFactory(beanFactory);BeanFactory的預準備工作（BeanFactory進行一些設定）；

1）、設定BeanFactory的類載入器、支援表示式解析器...
2）、新增部分BeanPostProcessor【ApplicationContextAwareProcessor】
3）、設定忽略的自動裝配的介面EnvironmentAware、EmbeddedValueResolverAware、xxx；
4）、註冊可以解析的自動裝配；我們能直接在任何元件中自動注入：
		BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
5）、新增BeanPostProcessor【ApplicationListenerDetector】
6）、新增編譯時的AspectJ；
7）、給BeanFactory中註冊一些能用的元件；
	environment【ConfigurableEnvironment】、
	systemProperties【Map<String, Object>】、
	systemEnvironment【Map<String, Object>】
 

4、postProcessBeanFactory(beanFactory);BeanFactory準備工作完成後進行的後置處理工作；

1）、子類通過重寫這個方法來在BeanFactory建立並預準備完成以後做進一步的設定

以上是BeanFactory的建立及預準備工作============

5、invokeBeanFactoryPostProcessors(beanFactory);執行BeanFactoryPostProcessor的方法；

BeanFactoryPostProcessor：BeanFactory的後置處理器。在BeanFactory標準初始化之後執行的；
兩個介面：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
1）、執行BeanFactoryPostProcessor的方法；
	先執行BeanDefinitionRegistryPostProcessor
	1）、獲取所有的BeanDefinitionRegistryPostProcessor；
	2）、看先執行實現了PriorityOrdered優先順序介面的BeanDefinitionRegistryPostProcessor、
		postProcessor.postProcessBeanDefinitionRegistry(registry)
	3）、在執行實現了Ordered順序介面的BeanDefinitionRegistryPostProcessor；
		postProcessor.postProcessBeanDefinitionRegistry(registry)
	4）、最後執行沒有實現任何優先順序或者是順序介面的BeanDefinitionRegistryPostProcessors；
		postProcessor.postProcessBeanDefinitionRegistry(registry)
		
	
	再執行BeanFactoryPostProcessor的方法
	1）、獲取所有的BeanFactoryPostProcessor
	2）、看先執行實現了PriorityOrdered優先順序介面的BeanFactoryPostProcessor、
		postProcessor.postProcessBeanFactory()
	3）、在執行實現了Ordered順序介面的BeanFactoryPostProcessor；
		postProcessor.postProcessBeanFactory()
	4）、最後執行沒有實現任何優先順序或者是順序介面的BeanFactoryPostProcessor；
		postProcessor.postProcessBeanFactory()

6、registerBeanPostProcessors(beanFactory);註冊BeanPostProcessor（Bean的後置處理器）【 intercept bean creation】

	不同介面型別的BeanPostProcessor；在Bean建立前後的執行時機是不一樣的
	BeanPostProcessor、
	DestructionAwareBeanPostProcessor、
	InstantiationAwareBeanPostProcessor、
	SmartInstantiationAwareBeanPostProcessor、
	MergedBeanDefinitionPostProcessor【internalPostProcessors】、
	
	1）、獲取所有的 BeanPostProcessor;後置處理器都預設可以通過PriorityOrdered、Ordered介面來執行優先順序
	2）、先註冊PriorityOrdered優先順序介面的BeanPostProcessor；
		把每一個BeanPostProcessor；新增到BeanFactory中
		beanFactory.addBeanPostProcessor(postProcessor);
	3）、再註冊Ordered介面的
	4）、最後註冊沒有實現任何優先順序介面的
	5）、最終註冊MergedBeanDefinitionPostProcessor；
	6）、註冊一個ApplicationListenerDetector；來在Bean建立完成後檢查是否是ApplicationListener，如果是
		applicationContext.addApplicationListener((ApplicationListener<?>) bean);

7、initMessageSource();初始化MessageSource元件（做國際化功能；訊息繫結，訊息解析）；

	1）、獲取BeanFactory
	2）、看容器中是否有id為messageSource的，型別是MessageSource的元件
		如果有賦值給messageSource，如果沒有自己建立一個DelegatingMessageSource；
			MessageSource：取出國際化配置檔案中的某個key的值；能按照區域資訊獲取；
	3）、把建立好的MessageSource註冊在容器中，以後獲取國際化配置檔案的值的時候，可以自動注入MessageSource；
		beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);	
		MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);

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

	1）、獲取BeanFactory
	2）、從BeanFactory中獲取applicationEventMulticaster的ApplicationEventMulticaster；
	3）、如果上一步沒有配置；建立一個SimpleApplicationEventMulticaster
	4）、將建立的ApplicationEventMulticaster新增到BeanFactory中，以後其他元件直接自動注入

9、onRefresh();留給子容器（子類）

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

10、registerListeners();給容器中將所有專案裡面的ApplicationListener註冊進來；

	1、從容器中拿到所有的ApplicationListener
	2、將每個監聽器新增到事件派發器中；
		getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
	3、派發之前步驟產生的事件；

11、finishBeanFactoryInitialization(beanFactory);初始化所有剩下的單例項bean；

1、beanFactory.preInstantiateSingletons();初始化後剩下的單例項bean
	1）、獲取容器中的所有Bean，依次進行初始化和建立物件
	2）、獲取Bean的定義資訊；RootBeanDefinition
	3）、Bean不是抽象的，是單例項的，是懶載入；
		1）、判斷是否是FactoryBean；是否是實現FactoryBean介面的Bean；
		2）、不是工廠Bean。利用getBean(beanName);建立物件
			0、getBean(beanName)； ioc.getBean();	【org.springframework.beans.factory.support.DefaultListableBeanFactory】
			1、doGetBean(name, null, null, false);
			2、先獲取快取中儲存的單例項Bean。如果能獲取到說明這個Bean之前被建立過（所有建立過的單例項Bean都會被快取起來）
				從private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);獲取的
			3、快取中獲取不到，開始Bean的建立物件流程；
			4、標記當前bean已經被建立
			5、獲取Bean的定義資訊；
			6、【獲取當前Bean依賴的其他Bean;如果有按照getBean()把依賴的Bean先創建出來；】
			7、啟動單例項Bean的建立流程；
				1）、createBean(beanName, mbd, args); 【org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory】
				2）、Object bean = resolveBeforeInstantiation(beanName, mbdToUse);讓BeanPostProcessor先攔截返回代理物件；
					【InstantiationAwareBeanPostProcessor】：提前執行；
					先觸發：postProcessBeforeInstantiation()；
					如果有返回值：觸發postProcessAfterInitialization()；
				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);
					 	賦值之前：
					 	1）、拿到InstantiationAwareBeanPostProcessor後置處理器；
					 		postProcessAfterInstantiation()；
					 	2）、拿到InstantiationAwareBeanPostProcessor後置處理器；
					 		postProcessPropertyValues()；
					 	=====賦值之前：===
					 	3）、應用Bean屬性的值；為屬性利用setter方法等進行賦值；
					 		applyPropertyValues(beanName, mbd, bw, pvs);
					 4）、【Bean初始化】initializeBean(beanName, exposedObject, mbd);
					 	1）、【執行Aware介面方法】invokeAwareMethods(beanName, bean);執行xxxAware介面的方法
					 		BeanNameAware\BeanClassLoaderAware\BeanFactoryAware
					 	2）、【執行後置處理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
					 		BeanPostProcessor.postProcessBeforeInitialization（）;
					 	3）、【執行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
					 		1）、是否是InitializingBean介面的實現；執行介面規定的初始化；
					 		2）、是否自定義初始化方法；
					 	4）、【執行後置處理器初始化之後】applyBeanPostProcessorsAfterInitialization
					 		BeanPostProcessor.postProcessAfterInitialization()；
					 5）、註冊Bean的銷燬方法；
				5）、將建立的Bean新增到快取中singletonObjects；
			ioc容器就是這些Map；很多的Map裡面儲存了單例項Bean，環境資訊。。。。；
	所有Bean都利用getBean建立完成以後；
		檢查所有的Bean是否是SmartInitializingSingleton介面的；如果是；就執行afterSingletonsInstantiated()；

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

	1）、initLifecycleProcessor();初始化和生命週期有關的後置處理器；LifecycleProcessor
		預設從容器中找是否有lifecycleProcessor的元件【LifecycleProcessor】；如果沒有new DefaultLifecycleProcessor();
		加入到容器；
		
		寫一個LifecycleProcessor的實現類，可以在BeanFactory
			void onRefresh();
			void onClose();	
	2）、	getLifecycleProcessor().onRefresh();
		拿到前面定義的生命週期處理器（BeanFactory）；回撥onRefresh()；
	3）、publishEvent(new ContextRefreshedEvent(this));釋出容器重新整理完成事件；
	4）、liveBeansView.registerApplicationContext(this);

======總結===========
1）、Spring容器在啟動的時候，先會儲存所有註冊進來的Bean的定義資訊；
	1）、xml註冊bean；<bean>
	2）、註解註冊Bean；@Service、@Component、@Bean、xxx
2）、Spring容器會合適的時機建立這些Bean
	1）、用到這個bean的時候；利用getBean建立bean；建立好以後儲存在容器中；
	2）、統一建立剩下所有的bean的時候；finishBeanFactoryInitialization()；
3）、後置處理器；BeanPostProcessor
	1）、每一個bean建立完成，都會使用各種後置處理器進行處理；來增強bean的功能；
		AutowiredAnnotationBeanPostProcessor:處理自動注入
		AnnotationAwareAspectJAutoProxyCreator:來做AOP功能；
		xxx....
		增強的功能註解：
		AsyncAnnotationBeanPostProcessor
		....
4）、事件驅動模型；
	ApplicationListener；事件監聽；
	ApplicationEventMulticaster；事件派發；