一、從AbstractApplicationContext的體系說起

• 第一，從類結構設計上看， 圍繞著是否需要Refresh容器衍生出兩個抽象類：

GenericApplicationContext： 是初始化的時候就創建容器，往后的每次refresh都不會更改

AbstractRefreshableApplicationContext：AbstractRefreshableApplicationContext及子類的每次refresh都是先清除已有(如果不存在就創建)的容器，然后再重新創建；

AbstractRefreshableApplicationContext及子類無法做到GenericApplicationContext混合搭配從不同源頭獲取bean的定義信息

• 第二， 從加載的源來看（比如xml,groovy,annotation等）， 衍生出眾多類型的ApplicationContext, 典型比如:

FileSystemXmlApplicationContext：從文件系統下的一個或多個xml配置文件中加載上下文定義，也就是說系統盤符中加載xml配置文件。

ClassPathXmlApplicationContext： 從類路徑下的一個或多個xml配置文件中加載上下文定義，適用于xml配置的方式。

AnnotationConfigApplicationContext：從一個或多個基于java的配置類中加載上下文定義，適用于java注解的方式。

ConfigurableApplicationContext： 擴展于 ApplicationContext，它新增加了兩個主要的方法： refresh()和 close()，讓ApplicationContext 具有啟動、刷新和關閉應用上下文的能力。在應用上下文關閉的情況下調用refresh()即可啟動應用上下文，在已經啟動的狀態下，調用refresh()則清除緩存并重新裝載配置信息，而調用close()則可關閉應用上下文。這些接口方法為容器的控制管理帶來了便利，但作為開發者，我們并不需要過多關心這些方法。

XmlWebApplicationContext: 繼承自AbstractRefreshableWebApplicationContext，接受能被XmlBeanDefinitionReader所理解的XML文檔配置。對于根上下文，默認的配置文件路徑是/WEB-INF/applicationContext.xml，對于命名空間為test-servlet的上下文，默認的配置文件路徑是/WEB-INF/test-servlet.xml（就像servlet-name為test的DispatcherServlet實例）。

AnnotationConfigWebApplicationContext: 繼承自AbstractRefreshableWebApplicationContext，接受注解的類作為輸入（特殊的@Configuration注解類，一般的@Component注解類，與JSR-330兼容的javax.inject注解）。允許一個一個的注入，同樣也能使用類路徑掃描。對于web環境，基本上是和AnnotationConfigApplicationContext等價的。使用AnnotatedBeanDefinitionReader來對注解的bean進行處理，使用ClassPathBeanDefinitionScanner來對類路徑下的bean進行掃描

這里可以參考這篇文章

二、本文以ClassPathXmlApplicationContext為例，這種方式包含了多種spring加載bean的方式

//如下：開啟spring應用 public static void main(String[] args) {ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");User bean = ac.getBean("user",User.class);System.out.println(bean); }

從ClassPathXmlApplicationContext的構造方法開始查看

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)throws BeansException {// 1.初始化父類，這里一路加載到頂層父類AbstractApplicationContext中的構造方法// 才不再顯示的super(parent)super(parent);// 2.設置本地的配置信息setConfigLocations(configLocations);// 3.完成Spring容器的初始化if (refresh) {refresh();} }

super(parent)

public AbstractApplicationContext(ApplicationContext parent) {this();setParent(parent); }

• 那么看一下this()

public AbstractApplicationContext() {//在該構造方法對resourcePatternResolver 變量賦值。resourcePatternResolver 的作用是根據路徑得到類的Resource對象this.resourcePatternResolver = getResourcePatternResolver(); } protected ResourcePatternResolver getResourcePatternResolver() { //創建PathMatchingResourcePatternResolver對象的時候 //AbstractApplicationContext將自身作為ResourceLoader傳遞給了PathMatchingResourcePatternResolverreturn new PathMatchingResourcePatternResolver(this); } public PathMatchingResourcePatternResolver(ResourceLoader resourceLoader) {Assert.notNull(resourceLoader, "ResourceLoader must not be null");this.resourceLoader = resourceLoader; } @Override public Resource getResource(String location) {return getResourceLoader().getResource(location); }

• 再看一下setParent(parent)

@Override public void setParent(ApplicationContext parent) {this.parent = parent; // null//因為parent為null所以if語句中的代碼不會執行，所以此if中的代碼在此邏輯中不會執行，所以在此就沒有分析的必要了。//初始化的第一部分就分析完畢了，這部分的主要工作是為后續Resource處理準備好處理類if (parent != null) {Environment parentEnvironment = parent.getEnvironment();if (parentEnvironment instanceof ConfigurableEnvironment) {getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);}} }

setConfigLocations(configLocations)

//1.setConfigLocations主要工作有兩個：創建環境對象ConfigurableEnvironment 、處理ClassPathXmlApplicationContext傳入的字符串中的占位符； //2.環境對象ConfigurableEnvironment中包含了當前JVM的profile配置信息、環境變量、 Java進程變量； //3.處理占位符的關鍵是ConfigurableEnvironment、PropertyResolver、PropertyPlaceholderHelper之間的配合public void setConfigLocations(String... locations) {if (locations != null) {Assert.noNullElements(locations, "Config locations must not be null");this.configLocations = new String[locations.length];for (int i = 0; i < locations.length; i++) {//循環取出每一個path參數，在此處我們就只有一個“applicationContext.xml“”this.configLocations[i] = resolvePath(locations[i]).trim();}}else {this.configLocations = null;} } // 這個方法的目的是替換掉path字符串中的占位符${XXX}這樣的內容 protected String resolvePath(String path) {// 1.進入getEnvironment()// 2.進入resolveRequiredPlaceholders方法return getEnvironment().resolveRequiredPlaceholders(path); }

• getEnvironment()：創建了ConfigurableEnvironment 對象

public ConfigurableEnvironment getEnvironment() {if (this.environment == null) {this.environment = createEnvironment();}return this.environment; }

從提供的方法中可以看出兩個功能

處理profile：Profile是對測試、生產等不同環境下的bean配置，這里我們沒有特別設置，所以用到的profile是AbstractEnvironment的defaultProfiles

處理property

獲取系統環境信息

合并環境信息

• PropertyResolver：resolveRequiredPlaceholders(path)
  

@Overridepublic String resolveRequiredPlaceholders(String text) throws IllegalArgumentException {if (this.strictHelper == null) {this.strictHelper = createPlaceholderHelper(false);}return doResolvePlaceholders(text, this.strictHelper);}

處理占位符的方法：

• PropertyPlaceholderHelper

@Override public String resolveRequiredPlaceholders(String text) throws IllegalArgumentException {if (this.strictHelper == null) {// 創建PropertyPlaceholderHelper對象this.strictHelper = createPlaceholderHelper(false);}return doResolvePlaceholders(text, this.strictHelper); }

進入doResolvePlaceholders繼續查看

private String doResolvePlaceholders(String text, PropertyPlaceholderHelper helper) {return helper.replacePlaceholders(text, new PropertyPlaceholderHelper.PlaceholderResolver() {@Overridepublic String resolvePlaceholder(String placeholderName) {return getPropertyAsRawString(placeholderName);}}); }

getPropertyAsRawString的具體實現在PropertySourcesPropertyResolver類中

@Override protected String getPropertyAsRawString(String key) {return getProperty(key, String.class, false); }

繼續跟蹤helper.replacePlaceholders()，到了PropertyPlaceholderHelper.parseStringValue方法，這里面逐一找出每個占位符去做替換：

public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) {Assert.notNull(value, "'value' must not be null");return parseStringValue(value, placeholderResolver, new HashSet<String>()); }

parseStringValue方法中，找到了占位符后，會調用入參placeholderResolver的resolvePlaceholder(placeholder)方法，也就是上面匿名類的getPropertyAsRawString方法（實際上就是PropertySourcesPropertyResolver.getPropertyAsRawString方法），最終會在PropertySourcesPropertyResolver.getProperty方法中找出所有的屬性來匹配占位符

protected String parseStringValue(String strVal, PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders) {StringBuilder result = new StringBuilder(strVal);int startIndex = strVal.indexOf(this.placeholderPrefix);while (startIndex != -1) {int endIndex = findPlaceholderEndIndex(result, startIndex);if (endIndex != -1) {String placeholder = result.substring(startIndex + this.placeholderPrefix.length(), endIndex);String originalPlaceholder = placeholder;if (!visitedPlaceholders.add(originalPlaceholder)) {throw new IllegalArgumentException("Circular placeholder reference '" + originalPlaceholder + "' in property definitions");}// Recursive invocation, parsing placeholders contained in the placeholder key.placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);// Now obtain the value for the fully resolved key...String propVal = placeholderResolver.resolvePlaceholder(placeholder);if (propVal == null && this.valueSeparator != null) {int separatorIndex = placeholder.indexOf(this.valueSeparator);if (separatorIndex != -1) {String actualPlaceholder = placeholder.substring(0, separatorIndex);String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);if (propVal == null) {propVal = defaultValue;}}}if (propVal != null) {// Recursive invocation, parsing placeholders contained in the// previously resolved placeholder value.propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);result.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);if (logger.isTraceEnabled()) {logger.trace("Resolved placeholder '" + placeholder + "'");}startIndex = result.indexOf(this.placeholderPrefix, startIndex + propVal.length());}else if (this.ignoreUnresolvablePlaceholders) {// Proceed with unprocessed value.startIndex = result.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());}else {throw new IllegalArgumentException("Could not resolve placeholder '" +placeholder + "'" + " in string value \"" + strVal + "\"");}visitedPlaceholders.remove(originalPlaceholder);}else {startIndex = -1;}}return result.toString();}

總結：

剩下最核心的refresh()方法，單開一章

三、核心refresh()方法

public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {//做容器刷新前的準備工作//1.設置容器的啟動時間//2.設置活躍狀態為true//3.設置關閉狀態為false//4.獲取Environment對象，并加載當前系統的屬性值到Environment對象中//5.準備監聽器和事件的集合對象，默認為空的集合prepareRefresh();//創建容器對象:DefaultListableFactory//加載xml配置文件的屬性值到當前工廠中，最重要的就是BeanDefinitionConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();//beanFactory的準備工作，對各種屬性進行填充prepareBeanFactory(beanFactory);try {// 允許在上下文子類中對 bean 工廠進行后處理。此處我們一般不做任何擴展工作postProcessBeanFactory(beanFactory);// 調用在上下文中注冊為 beanFactory 處理器。invokeBeanFactoryPostProcessors(beanFactory);//注冊能攔截 bean 創建的 bean 處理器，此處只是注冊功能，真正調用的是getBeanregisterBeanPostProcessors(beanFactory);//為上下文初始化message源，即不同語言的消息體，國際化處理initMessageSource();//為此上下文初始化事件多播器initApplicationEventMulticaster();//留給子類來初始化其他beanonRefresh();//在所有注冊的bean中查找listener bean，注冊到消息廣播器中registerListeners();// 初始化剩下的單實例（非懶加載），多例是在getBean時才初始化finishBeanFactoryInitialization(beanFactory);//完成刷新過程，通知生命周期處理器lifecycleProcessor刷新過程，同時發出ContextRefreshEvent通知別人finishRefresh();}catch (BeansException ex) {if (logger.isWarnEnabled()) {logger.warn("Exception encountered during context initialization - " +"cancelling refresh attempt: " + ex);}//銷毀已經創建的單例以避免懸空資源destroyBeans();// Reset 'active' flag.//重置active標志cancelRefresh(ex);throw ex;}finally {//重置 Spring 核心中的常見自省緩存，因為我們可能不再需要單例 bean 的元數據resetCommonCaches();}}}

• 步驟：

• prepareRefresh
• obtainFreshBeanFactory
• prepareBeanFactory
• postProcessBeanFactory
• invokeBeanFactoryPostProcessors
• registerBeanPostProcessors
• initMessageSource
• initApplicationEventMulticaster
• onRefresh
• registerListeners
• finishBeanFactoryInitialization
• finishRefresh
• resetCommonCaches()

prepareRefresh()

作用：

obtainFreshBeanFactory()


createBeanFactory----創建bean工廠

進入loadBeanDefinition

走完loadBeanDefinitons后，beanFactory中的beandefinitionMap就不會為空了

然后一路再返回到AbstractApplicationContext

作用：

prepareBeanFactory(beanFactory)：beanFactory的準備工作，對各種屬性進行填充

作用：

postProcessBeanFactory(BeanFactory的后置處理器，留給其子類做擴展用的)

postProcessBeanFactory方法是留給子類擴展的，可以在bean實例初始化之前注冊后置處理器（類似prepareBeanFactory方法中的beanFactory.addBeanPostProcessor），空實現且沒有子類覆蓋。

invokeBeanFactoryPostProcessors（調用各種beanFactory處理器）

該方法執行BeanFactoryPostProcessor執行器

執行BeanFactoryPostProcessor 執行器

作用：

附表:常用的BeanFactoryPostProcessor

BeanFactoryPostProcessor類作用

CachingMetadataReaderFactoryPostProcessor(也實現了接口BeanDefinitionRegistryPostProcessor
ConfigurationWarningsPostProcessor(也實現了接口BeanDefinitionRegistryPostProcessor	主要作用就是把在注冊BeanDefinition實例過程中產生的告警信息傳給Check接口的實例進行處理，ConfigurationWarningsApplicationContextInitializer中只提供了一個Check的實現 ComponentScanPackageCheck,ConfigurationWarningsApplicationContextInitializer的作用是用來報告Spring容器的一些常見的錯誤配置的
ConfigurationClassPostProcessor (也實現了接口BeanDefinitionRegistryPostProcessor)	主要功能是參與BeanFactory的建造，主要功能如下： 解析加了@Configuration的配置類 解析@ComponentScan掃描的包 解析@ComponentScans掃描的包
PropertySourceOrderingPostProcessor	Bean工廠結束后對環境里的屬性源進行重排序 -> 把名字叫defaultProperties的屬性源放在最末位

注意: BeanDefinitionRegistryPostProcessor 繼承自 BeanFactoryPostProcessor，比 BeanFactoryPostProcessor 具有更高的優先級，主要用來在常規的 BeanFactoryPostProcessor 激活之前注冊一些 bean 定義。

registerBeanPostProcessors
注冊bean處理器，這里只是注冊功能，真正調用的是getBean方法

registerBeanPostProcessors方法的代碼略多，就不在此貼出來了，簡單的說，就是找出所有的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實例來做對應的處理；

作用：

initMessageSource

為上下文初始化message源，即不同語言的消息體，國際化處理

initApplicationEventMulticaster

初始化事件監聽多路廣播器

作用：

onRefresh
onRefresh是個空方法，留給子類自己實現的，在實例化bean之前做一些ApplicationContext相關的操作，以子類AbstractRefreshableWebApplicationContext為例，看看它的onRefresh方法

/*** Initialize the theme capability.*/ @Override protected void onRefresh() {this.themeSource = UiApplicationContextUtils.initThemeSource(this); }

registerListeners

方法名為registerListeners，看名字像是將監聽器注冊在事件廣播器中，但實際情況并非如此，只有一些特殊的監聽器被注冊了，那些在bean配置文件中實現了ApplicationListener接口的類還沒有實例化，所以此處只是將其name保存在廣播器中，將這些監聽器注冊在廣播器的操作是在bean的后置處理器中完成的，那時候bean已經實例化完成了，我們看代碼

作用：

finishBeanFactoryInitialization

初始化剩下的單實例（非懶加載的），多例在getBean時才初始化

• preInstantiateSingletons方法這個方法里就解決了循環依賴的問題

@Overridepublic 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.// 1.創建beanDefinitionNames的副本beanNames用于后續的遍歷，以允許init等方法注冊新的bean定義List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);// Trigger initialization of all non-lazy singleton beans...// 2.遍歷beanNames，觸發所有非懶加載單例bean的初始化for (String beanName : beanNames) {// 3.獲取beanName對應的MergedBeanDefinitionRootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);// 4.bd對應的Bean實例：不是抽象類 && 是單例 && 不是懶加載if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {// 5.判斷beanName對應的bean是否為FactoryBeanif (isFactoryBean(beanName)) {// 5.1 通過beanName獲取FactoryBean實例// 通過getBean(&beanName)拿到的是FactoryBean本身；通過getBean(beanName)拿到的是FactoryBean創建的Bean實例final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);// 5.2 判斷這個FactoryBean是否希望急切的初始化boolean isEagerInit;if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {@Overridepublic Boolean run() {return ((SmartFactoryBean<?>) factory).isEagerInit();}}, getAccessControlContext());} else {isEagerInit = (factory instanceof SmartFactoryBean &&((SmartFactoryBean<?>) factory).isEagerInit());}if (isEagerInit) {// 5.3 如果希望急切的初始化，則通過beanName獲取bean實例getBean(beanName);}} else {// 6.如果beanName對應的bean不是FactoryBean，只是普通Bean，通過beanName獲取bean實例getBean(beanName);}}}// Trigger post-initialization callback for all applicable beans...// 7.遍歷beanNames，觸發所有SmartInitializingSingleton的后初始化回調for (String beanName : beanNames) {// 7.1 拿到beanName對應的bean實例Object singletonInstance = getSingleton(beanName);// 7.2 判斷singletonInstance是否實現了SmartInitializingSingleton接口if (singletonInstance instanceof SmartInitializingSingleton) {final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;// 7.3 觸發SmartInitializingSingleton實現類的afterSingletonsInstantiated方法if (System.getSecurityManager() != null) {AccessController.doPrivileged(new PrivilegedAction<Object>() {@Overridepublic Object run() {smartSingleton.afterSingletonsInstantiated();return null;}}, getAccessControlContext());} else {smartSingleton.afterSingletonsInstantiated();}

這里接下來的調用鏈條是：

getBean() -> doGetBean() -> createBean() -> doCreateBean() -> populateBean()//填充屬性 -> initializeBean()//初始化(這里涉及到代理的創建)

initializeBean方法中會執行applyBeanPostProcessorsAfterInitialization方法

applyBeanPostProcessorsAfterInitialization具體的代碼如下：

@Override public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)throws BeansException {Object result = existingBean;for (BeanPostProcessor processor : getBeanPostProcessors()) {Object current = processor.postProcessAfterInitialization(result, beanName);if (current == null) {return result;}result = current;}return result; }

邏輯比較簡單，就是遍歷所有實現了BeanPostProcessor接口的類，其中AnnotationAwareAspectJAutoProxyCreator(由EnableAspectJAutoProxy導入的)就是會實現AOP動態代理，然后返回代理對象。所以如果沒有導入@EnableAspectJAutoProxy,自然不會創建代理. 這里也可以看出applicationContext構造的過程,就會創建好代理.而且在創建代理的過程中,如果涉及到循環依賴還是提前創建代理并放入earlyProxyReferences集合，用于表示進行了提前的動態代理.這里可以參考這篇文章.注意,多實例對象并不會提前創建,當兩個多實例對象循環引用且設計代理的創建時,就會報錯

附表:SpringBoot常用的BeanPostProcessor清單

BeanPostProcessor類介紹

ApplicationContextAwareProcessor	功能:bean創建時調用bean所實現的各種Aware接口方法設置相應的屬性
WebApplicationContextServletContextAwareProcessor	功能:Springboot Servlet Web應用中bean創建時調用bean實現的ServletContextAware或者ServletConfigAware接口為bean設置ServletContext或者ServletConfig屬性引入時機:在ServletWebServerApplicationContex#postProcessBeanFactory中登記到應用上下文
PostProcessorRegistrationDelegate$BeanPostProcessorChecker	TBD
ConfigurationPropertiesBindingPostProcessor	功能: 綁定配置文件中的配置屬性項到配置屬性對象,比如server開頭的配置項設置到配置屬性bean對象ServerProperties上
AnnotationAwareAspectJAutoProxyCreator	功能: 如果某個bean匹配了某些定義的切面advise或者Spring Advisor,則為這個bean創建AOP代理對象
DataSourceInitializerPostProcessor	功能: 一旦檢測到數據源DataSource bean被初始化，執行數據源的初始化:創建相應的表格(create schema)和填充相應的數據(init schema)
MethodValidationPostProcessor	默認不添加，需要手動添加。支持方法級別的JSR-303規范。需要在類上加上@Validated注解，以及在方法的參數中加上驗證注解，比如@Max，@Min，@NotEmpty …。
BeanValidationPostProcessor	默認不添加，需要手動添加。主要提供對JSR-303驗證的支持，內部有個boolean類型的屬性afterInitialization，默認是false。如果是false，在postProcessBeforeInitialization過程中對bean進行驗證，否則在postProcessAfterInitialization過程對bean進行驗證。
PersistenceExceptionTranslationPostProcessor	它將每個Repository組件bean包裝成一個代理對象并為該代理對象添加一個PersistenceExceptionTranslationAdvisor。該PersistenceExceptionTranslationAdvisor會攔截Repository組件bean的方法調用產生的異常并將其轉換成Spring框架標準異常
WebServerFactoryCustomizerBeanPostProcessor	這個處理器類會獲取TomcatServletWebServerFactoryCustomizer定制器，并調用customize方法進行定制，這時候工廠類起作用，調用getWebServer方法進行Tomcat屬性配置和引擎設置等等，再創建TomcatWebServer啟動Tomcat容器
ErrorPageRegistrarBeanPostProcessor	功能: 在ErrorPageRegistry bean創建時初始化前將容器中的所有ErrorPageRegistrar bean注冊進來。
DataSourceInitializedPublisher	用于發布DataSourceInitializedEvent事件
PersistenceAnnotationBeanPostProcessor	功能: 識別bean上的持久化注解@PersistenceUnit/@PersistenceContext,并完成相應的屬性EntityManagerFactory/EntityManager注入。
CommonAnnotationBeanPostProcessor	功能: 對JSR-250 @Resource、@PostConstruct 、@PreDestroy等注解的處理
AutowiredAnnotationBeanPostProcessor	功能: 對每個bean執行真正的依賴"注入",缺省支持三種自動裝配注解@Autowired,@Value @Inject
ApplicationListenerDetector	功能: 檢測單例ApplicationListener bean將它們注冊到應用上下文的事件多播器上，并在這些bean銷毀之前將它們從事件多播器上移除
RequiredAnnotationBeanPostProcessor	主要處理@Required注解的實現(@Required注解只能修飾方法)
ScheduledAnnotationBeanPostProcessor	默認不添加，使用@EnableScheduling注解后，會被注冊到Spring容器中。主要使用Spring Scheduling功能對bean中使用了@Scheduled注解的方法進行調度處理。
AsyncAnnotationBeanPostProcessor	默認不添加，使用@EnableAsync注解后，會被注冊到Spring容器中。AsyncAnnotationBeanPostProcessor內部使用aop處理方法的調用。

protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)throws BeansException {// 1.解析beanName，主要是解析別名、去掉FactoryBean的前綴“&”final String beanName = transformedBeanName(name);Object bean;// Eagerly check singleton cache for manually registered singletons.// 2.嘗試從緩存中獲取beanName對應的實例Object sharedInstance = getSingleton(beanName);if (sharedInstance != null && args == null) {// 3.如果beanName的實例存在于緩存中,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 + "'");}}// 3.1 返回beanName對應的實例對象（主要用于FactoryBean的特殊處理，普通Bean會直接返回sharedInstance本身）bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);} else {// Fail if we're already creating this bean instance:// We're assumably within a circular reference.// 4.scope為prototype的循環依賴校驗：如果beanName已經正在創建Bean實例中，而此時我們又要再一次創建beanName的實例，則代表出現了循環依賴，需要拋出異常。// 例子：如果存在A中有B的屬性，B中有A的屬性，那么當依賴注入的時候，就會產生當A還未創建完的時候因為對于B的創建再次返回創建A，造成循環依賴if (isPrototypeCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName);}// Check if bean definition exists in this factory.// 5.獲取parentBeanFactoryBeanFactory parentBeanFactory = getParentBeanFactory();// 5.1 如果parentBeanFactory存在，并且beanName在當前BeanFactory不存在Bean定義，則嘗試從parentBeanFactory中獲取bean實例if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {// Not found -> check parent.// 5.2 將別名解析成真正的beanNameString nameToLookup = originalBeanName(name);// 5.3 嘗試在parentBeanFactory中獲取bean對象實例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) {// 6.如果不是僅僅做類型檢測，而是創建bean實例，這里要將beanName放到alreadyCreated緩存markBeanAsCreated(beanName);}try {// 7.根據beanName重新獲取MergedBeanDefinition（步驟6將MergedBeanDefinition刪除了，這邊獲取一個新的）final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);// 7.1 檢查MergedBeanDefinitioncheckMergedBeanDefinition(mbd, beanName, args);// Guarantee initialization of beans that the current bean depends on.// 8.拿到當前bean依賴的bean名稱集合，在實例化自己之前，需要先實例化自己依賴的beanString[] dependsOn = mbd.getDependsOn();if (dependsOn != null) {// 8.1 遍歷當前bean依賴的bean名稱集合for (String dep : dependsOn) {// 8.2 檢查dep是否依賴于beanName，即檢查是否存在循環依賴if (isDependent(beanName, dep)) {// 8.3 如果是循環依賴則拋異常throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");}// 8.4 將dep和beanName的依賴關系注冊到緩存中registerDependentBean(dep, beanName);// 8.5 獲取dep對應的bean實例，如果dep還沒有創建bean實例，則創建dep的bean實例getBean(dep);}}// Create bean instance.// 9.針對不同的scope進行bean的創建if (mbd.isSingleton()) {// 9.1 scope為singleton的bean創建（新建了一個ObjectFactory，并且重寫了getObject方法）sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {@Overridepublic Object getObject() throws BeansException { //try {// 9.1.1 創建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;}}});// 9.1.2 返回beanName對應的實例對象bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);} else if (mbd.isPrototype()) {// 9.2 scope為prototype的bean創建// It's a prototype -> create a new instance.Object prototypeInstance = null;try {// 9.2.1 創建實例前的操作（將beanName保存到prototypesCurrentlyInCreation緩存中）beforePrototypeCreation(beanName);// 9.2.2 創建Bean實例prototypeInstance = createBean(beanName, mbd, args);} finally {// 9.2.3 創建實例后的操作（將創建完的beanName從prototypesCurrentlyInCreation緩存中移除）afterPrototypeCreation(beanName);}// 9.2.4 返回beanName對應的實例對象bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);} else {// 9.3 其他scope的bean創建，可能是request之類的// 9.3.1 根據scopeName，從緩存拿到scope實例String scopeName = mbd.getScope();final Scope scope = this.scopes.get(scopeName);if (scope == null) {throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");}try {// 9.3.2 其他scope的bean創建（新建了一個ObjectFactory，并且重寫了getObject方法）Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {@Overridepublic Object getObject() throws BeansException {// 9.3.3 創建實例前的操作（將beanName保存到prototypesCurrentlyInCreation緩存中）beforePrototypeCreation(beanName);try {// 9.3.4 創建bean實例return createBean(beanName, mbd, args);} finally {// 9.3.5 創建實例后的操作（將創建完的beanName從prototypesCurrentlyInCreation緩存中移除）afterPrototypeCreation(beanName);}}});// 9.3.6 返回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) {// 如果創建bean實例過程中出現異常，則將beanName從alreadyCreated緩存中移除cleanupAfterBeanCreationFailure(beanName);throw ex;}}// Check if required type matches the type of the actual bean instance.// 10.檢查所需類型是否與實際的bean對象的類型匹配if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {try {// 10.1 類型不對，則嘗試轉換bean類型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());}}// 11.返回創建出來的bean實例對象return (T) bean;}

作用：

finishRefresh

最后一個方法是finishRefresh，這是在bean的實例化、初始化等完成后的一些操作

• 完成刷新過程，通知生命周期處理器lifecycleProcessor刷新過程，
• 同時發出ContextRefreshEvent通知別人\

protected void finishRefresh() {// Clear context-level resource caches (such as ASM metadata from scanning).// 清除上下文級別的資源緩存（如掃描的ASM元數據）// 清空在資源加載器中所有的資源緩存clearResourceCaches();// Initialize lifecycle processor for this context.// 為這個上下文初始化生命周期處理器// 初始化LifecycleProcessor，如果上下文中找到LifecycleProcessor的LifecycleProcessor bean對象，則使用DefaultLifecycleProcessorinitLifecycleProcessor();// Propagate refresh to lifecycle processor first.// 首先將刷新傳播到生命周期處理器，上下文刷新的通知，例如自啟動的組件getLifecycleProcessor().onRefresh();// Publish the final event.// 發布最終事件// 新建ContextRefreshEvent事件對象，將其發布到所有監聽器publishEvent(new ContextRefreshedEvent(this));// Participate in LiveBeansView MBean, if active.// 參與LiveBeansView MBean,如果是活動的。LiveBeansView ：Spring用于支持JMX服務的類// 注冊當前上下文LiveBeansView，以支持JMX服務LiveBeansView.registerApplicationContext(this);}

作用:

resetCommonCaches()

在spring的核心中重置常見的內省緩存，因為我們可能不再需要singleton bean的元數據了

四、總結

prepareRefresh：準備好環境變量，配置變量

obtainFreshBeanFactory：創建或獲取bean工廠,并加載BeanDefinition

prepareBeanFactory：beanFactory的準備工作，對各種屬性進行填充

postProcessBeanFactory：留給子類子類去擴展bean工廠

invokeBeanFactoryPostProcessors：自定義beanFactory后置處理器去擴展bean工廠

registerBeanPostProcessors：注冊bean后置處理器

initMessageSource：為spring容器提供國際化功能

initApplicationEventMulticaster：為spring容器提供事件發布器

onRefresh：留給子類對spring容器進行擴展

registerListeners：為spring容器注冊監聽器

finishBeanFactoryInitialization：初始化剩余的非懶加載單例bean，執行bean后置處理器擴展

finishRefresh：準備spring容器生命周期管理器，發布contextRefreshed事件

resetCommonCaches: 緩存重置

參考文章

總結

以上是生活随笔為你收集整理的Spring加载流程源码的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。