日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產(chǎn)品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
聊聊Spring容器啟動流程

一、前言知識

  • Spring會將所有交由Spring管理的類，掃描其class文件，將其解析成BeanDefinition，在BeanDefinition中會描述類的信息，例如:這個類是否是單例的，Bean的類型，是否是懶加載，依賴哪些類，自動裝配的模型。Spring創(chuàng)建對象時，就是根據(jù)BeanDefinition中的信息來創(chuàng)建Bean。
  • Spring容器在本文可以簡單理解為DefaultListableBeanFactory,它是BeanFactory的實現(xiàn)類，這個類有幾個非常重要的屬性：

beanDefinitionMap是一個map，用來存放bean所對應的BeanDefinition；

成都創(chuàng)新互聯(lián)公司認為，企業(yè)網(wǎng)站是要賦予品質(zhì)、思維、人性，深入到用戶內(nèi)心的細膩情感，才能真正稱得上企業(yè)網(wǎng)站。成都創(chuàng)新互聯(lián)公司根據(jù)每位用戶內(nèi)心最深的需求網(wǎng)站建設服務，堅實的設計執(zhí)行是品牌長期視覺塑造的重要支持。

beanDefinitionNames是一個List集合，用來存放所有bean的name；

singletonObjects是一個Map，用來存放所有創(chuàng)建好的單例Bean。

  • Spring中有很多后置處理器，但最終可以分為兩種，一種是BeanFactoryPostProcessor，一種是BeanPostProcessor。前者的用途是用來干預BeanFactory的創(chuàng)建過程，后者是用來干預Bean的創(chuàng)建過程。后置處理器的作用十分重要，bean的創(chuàng)建以及AOP的實現(xiàn)全部依賴后置處理器。

二、源碼解析

2.1 基于注解

流程概述

本文是基于 java-config 技術分析源碼，所以這里的入口是AnnotationConfigApplicationContext ，如果是使用 xml 分析，那么入口即為 ClassPathXmlApplicationContext ，它們倆的共同特征便是都繼承了 AbstractApplicationContext 類，而大名鼎鼎的 refresh()便是在這個類中定義的。我們接著分析 AnnotationConfigApplicationContext 類，入口如下：

AnnotationConfigApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(Config.class);

// 初始化容器
public AnnotationConfigApplicationContext(Class... annotatedClasses) {
    this();
    // 注冊配置類 BeanDefinition 到容器
    register(annotatedClasses);
    // 加載或者刷新容器中的Bean
    refresh();
}

整個Spring容器的啟動流程可以繪制成如下流程圖：

spring容器的初始化時，通過this()調(diào)用了無參構造函數(shù)，主要做了以下三個事情：

（1）實例化BeanFactory【DefaultListableBeanFactory】工廠，用于生成Bean對象。

（2）實例化BeanDefinitionReader注解配置讀取器，用于對特定注解（如@Service、@Repository）的類進行讀取轉(zhuǎn)化成 BeanDefinition 對象，（BeanDefinition 是 Spring 中極其重要的一個概念，它存儲了 bean 對象的所有特征信息，如是否單例，是否懶加載，factoryBeanName 等）

（3）實例化ClassPathBeanDefinitionScanner路徑掃描器，用于對指定的包目錄進行掃描查找 bean 對象。

完整流程

  • this()調(diào)用

this()會調(diào)用AnnotationConfigApplicationContext無參構造方法，而在Java的繼承中，會先調(diào)用父類的構造方法。所以會先調(diào)用AnnotationConfigApplicationContext的父類GeniricApplicationContext的構造方法，在父類中初始化beanFactory，即直接new了一個DefaultListableBeanFactory。

public GenericApplicationContext() {    
    this.beanFactory = new DefaultListableBeanFactory();
}

在this()中通過new AnnotatedBeanDefinitionReader(this)實例化了一個Bean讀取器，并向容器中添加后置處理器。

  1. 向容器中添加了2個beanFactory后置處理器：ConfigurationClassPostProcessor 和EventListenerMethodProcessor。
  2. 向容器中添加了兩個bean后置處理器：AutowiredAnnotationBeanPostProcessor 和CommonAnnotationBeanPostProcessor。
  3. 向容器中添加普通組件：DefaultEventListenerFactory。
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
		this(registry, getOrCreateEnvironment(registry));
	}

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		Assert.notNull(environment, "Environment must not be null");
		this.registry = registry;
		this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	}

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
		registerAnnotationConfigProcessors(registry, null);
	}


public static Set registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}

		Set beanDefs = new LinkedHashSet<>(8);

		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition();
			try {
				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
						AnnotationConfigUtils.class.getClassLoader()));
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
			}
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
		}

		return beanDefs;
	}

通過new ClassPathBeanDefinitionScanner(this)實例化了一個可以對用戶指定的包目錄進行掃描查找 bean 對象的一個路徑掃描器。

  • register(annotatedClasses)將傳入的配置類annotatedClasses解析成BeanDefinition(實際類型為AnnotatedGenericBeanDefinition)，然后放入到BeanDefinitionMap中，這樣后面在ConfigurationClassPostProcessor中能解析annotatedClasses，此時只是注冊BeanDefinition信息，沒有實例化。
 void doRegisterBean(Class annotatedClass, @Nullable Supplier instanceSupplier, @Nullable String name,
		@Nullable Class[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
	// 解析傳入的配置類，實際上這個方法既可以解析配置類，也可以解析 Spring bean 對象
	AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
	// 判斷是否需要跳過，判斷依據(jù)是此類上有沒有 @Conditional 注解
	if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
		return;
	}

	abd.setInstanceSupplier(instanceSupplier);
	ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
	abd.setScope(scopeMetadata.getScopeName());
	String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
	// 處理類上的通用注解
	AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
	if (qualifiers != null) {
		for (Class qualifier : qualifiers) {
			if (Primary.class == qualifier) {
				abd.setPrimary(true);
			}
			else if (Lazy.class == qualifier) {
				abd.setLazyInit(true);
			}
			else {
				abd.addQualifier(new AutowireCandidateQualifier(qualifier));
			}
		}
	}
	// 封裝成一個 BeanDefinitionHolder
	for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
		customizer.customize(abd);
	}
	BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
	// 處理 scopedProxyMode
	definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);

	// 把 BeanDefinitionHolder 注冊到 registry
	BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
  • 執(zhí)行refresh()方法refresh()方法是整個Spring容器的核心，在這個方法中進行了bean的實例化、初始化、自動裝配、AOP等功能。

重點方法: AbstractApplicationContext.refresh( )

上文中我們知道了如何去初始化一個 IOC 容器，那么接下來就是讓這個 IOC 容器真正起作用的時候了：即先掃描出要放入容器的 bean，將其包裝成 BeanDefinition 對象，然后通過反射創(chuàng)建 bean，并完成賦值操作，這個就是 IOC 容器最簡單的功能了。但是看上圖，明顯 Spring 的初始化過程比這個多的多，下面我們就詳細分析一下這樣設計的意義：

如果用戶想在掃描完 bean 之后做一些自定義的操作：假設容器中包含了 a 和 b，那么就動態(tài)向容器中注入 c，不滿足就注入 d，這種操作 Spring 也是支持的，可以使用它提供的 BeanFactoryPostProcessor 后置處理器，對應的是上圖中的invokeBeanFactoryPostProcessors 操作。

如果用戶還想在 bean 的初始化前后做一些操作呢？比如生成代理對象，修改對象屬性等，Spring 為我們提供了 BeanPostProcessor 后置處理器，實際上 Spring 容器中的大多數(shù)功能都是通過 Bean 后置處理器完成的，Spring 也是給我們提供了添加入口，對應的是上圖中的registerBeanPostProcessors 操作。

容器創(chuàng)建過程中，如果用戶想監(jiān)聽容器啟動、刷新等事件，根據(jù)這些事件做一些自定義的操作？Spring 也早已為我們考慮到了，提供了添加監(jiān)聽器接口和容器事件通知接口，對應的是上圖中的 registerListeners 操作。

public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// Prepare this context for refreshing.
		// 1. 刷新前的預處理
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		// 2. 獲取 beanFactory，即前面創(chuàng)建的【DefaultListableBeanFactory】
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		// 3. 預處理 beanFactory，向容器中添加一些組件
		prepareBeanFactory(beanFactory);

		try {
			// Allows post-processing of the bean factory in context subclasses.
			// 4. 子類通過重寫這個方法可以在 BeanFactory 創(chuàng)建并與準備完成以后做進一步的設置
			postProcessBeanFactory(beanFactory);

			// Invoke factory processors registered as beans in the context.
			// 5. 執(zhí)行 BeanFactoryPostProcessor 方法，beanFactory 后置處理器
			invokeBeanFactoryPostProcessors(beanFactory);

			// Register bean processors that intercept bean creation.
			// 6. 注冊 BeanPostProcessors，bean 后置處理器
			registerBeanPostProcessors(beanFactory);

			// Initialize message source for this context.
			// 7. 初始化 MessageSource 組件（做國際化功能；消息綁定，消息解析）
			initMessageSource();

			// Initialize event multicaster for this context.
			// 8. 初始化事件派發(fā)器，在注冊監(jiān)聽器時會用到
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			// 9. 留給子容器（子類），子類重寫這個方法，在容器刷新的時候可以自定義邏輯，web 場景下會使用
			onRefresh();

			// Check for listener beans and register them.
			// 10. 注冊監(jiān)聽器，派發(fā)之前步驟產(chǎn)生的一些事件（可能沒有）
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			// 11. 初始化所有的非單實例 bean
			finishBeanFactoryInitialization(beanFactory);

			// Last step: publish corresponding event.
			// 12. 發(fā)布容器刷新完成事件
			finishRefresh();
		}

		...
		
	}
}

refresh()主要用于容器的刷新，Spring 中的每一個容器都會調(diào)用 refresh() 方法進行刷新，無論是 Spring 的父子容器，還是 Spring Cloud Feign 中的 feign 隔離容器，每一個容器都會調(diào)用這個方法完成初始化。refresh()可劃分為上述的12個步驟，其中比較重要的步驟下面會有詳細說明。

先總結一下refresh()方法每一步主要的功能：

  • prepareRefresh()刷新前的預處理：
  1. initPropertySources()：初始化一些屬性設置，子類自定義個性化的屬性設置方法；
  2. getEnvironment().validateRequiredProperties()：檢驗屬性的合法性
  3. earlyApplicationEvents = new LinkedHashSet()：保存容器中的一些早期的事件；
  • obtainFreshBeanFactory()：獲取在容器初始化時創(chuàng)建的BeanFactory：
  1. refreshBeanFactory()：刷新BeanFactory，設置序列化ID；
  2. getBeanFactory()：返回初始化中的GenericApplicationContext創(chuàng)建的BeanFactory對象，即【DefaultListableBeanFactory】類型
  • prepareBeanFactory(beanFactory)：BeanFactory的預處理工作，向容器中添加一些組件：
  1. 設置BeanFactory的類加載器、設置表達式解析器等等
  2. 添加BeanPostProcessor【ApplicationContextAwareProcessor】
  3. 設置忽略自動裝配的接口：EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware；
  4. 注冊可以解析的自動裝配類，即可以在任意組件中通過注解自動注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
  5. 添加BeanPostProcessor【ApplicationListenerDetector】
  6. 添加編譯時的AspectJ；
  7. 給BeanFactory中注冊的3個組件：environment【ConfigurableEnvironment】、systemProperties【Map】、systemEnvironment【Map】
  • postProcessBeanFactory(beanFactory)：子類重寫該方法，可以實現(xiàn)在BeanFactory創(chuàng)建并預處理完成以后做進一步的設置。
  • invokeBeanFactoryPostProcessors(beanFactory)：在BeanFactory標準初始化之后執(zhí)行BeanFactoryPostProcessor的方法，即BeanFactory的后置處理器：
  1. 先執(zhí)行BeanDefinitionRegistryPostProcessor： postProcessor.postProcessBeanDefinitionRegistry(registry)
  1. 獲取所有的實現(xiàn)了BeanDefinitionRegistryPostProcessor接口類型的集合
  2. 先執(zhí)行實現(xiàn)了PriorityOrdered優(yōu)先級接口的BeanDefinitionRegistryPostProcessor
  3. 再執(zhí)行實現(xiàn)了Ordered順序接口的BeanDefinitionRegistryPostProcessor
  4. 最后執(zhí)行沒有實現(xiàn)任何優(yōu)先級或者是順序接口的BeanDefinitionRegistryPostProcessors
  1. 再執(zhí)行BeanFactoryPostProcessor的方法：postProcessor.postProcessBeanFactory(beanFactory)
  1. 獲取所有的實現(xiàn)了BeanFactoryPostProcessor接口類型的集合
  2. 先執(zhí)行實現(xiàn)了PriorityOrdered優(yōu)先級接口的BeanFactoryPostProcessor
  3. 再執(zhí)行實現(xiàn)了Ordered順序接口的BeanFactoryPostProcessor
  4. 最后執(zhí)行沒有實現(xiàn)任何優(yōu)先級或者是順序接口的BeanFactoryPostProcessor
  • registerBeanPostProcessors(beanFactory)：向容器中注冊Bean的后置處理器BeanPostProcessor，它的主要作用是干預Spring初始化bean的流程，從而完成代理、自動注入、循環(huán)依賴等功能
  1. 獲取所有實現(xiàn)了BeanPostProcessor接口類型的集合：
  2. 先注冊實現(xiàn)了PriorityOrdered優(yōu)先級接口的BeanPostProcessor；
  3. 再注冊實現(xiàn)了Ordered優(yōu)先級接口的BeanPostProcessor；
  4. 最后注冊沒有實現(xiàn)任何優(yōu)先級接口的BeanPostProcessor；
  5. 最終注冊MergedBeanDefinitionPostProcessor類型的BeanPostProcessor：beanFactory.addBeanPostProcessor(postProcessor);
  6. 給容器注冊一個ApplicationListenerDetector：用于在Bean創(chuàng)建完成后檢查是否是ApplicationListener，如果是，就把Bean放到容器中保存起來：applicationContext.addApplicationListener((ApplicationListener) bean);此時容器中默認有6個默認的BeanProcessor(無任何代理模式下)
  • initMessageSource()：初始化MessageSource組件，主要用于做國際化功能，消息綁定與消息解析：
  • initApplicationEventMulticaster()：初始化事件派發(fā)器，在注冊監(jiān)聽器時會用到
  1. 看BeanFactory容器中是否存在自定義的ApplicationEventMulticaster：如果有，直接從容器中獲取；如果沒有，則創(chuàng)建一個SimpleApplicationEventMulticaster
  2. 將創(chuàng)建的ApplicationEventMulticaster添加到BeanFactory中，以后其他組件就可以直接自動注入。
  • onRefresh()：留給子容器、子類重寫這個方法，在容器刷新的時候可以自定義邏輯。
  • registerListeners()：注冊監(jiān)聽器：將容器中所有的ApplicationListener注冊到事件派發(fā)器中，并派發(fā)之前步驟產(chǎn)生的事件：
  • finishBeanFactoryInitialization(beanFactory)：初始化所有剩下的單實例bean，核心方法是preInstantiateSingletons()，會調(diào)用getBean()方法創(chuàng)建對象；
  1. 獲取容器中的所有beanDefinitionName，依次進行初始化和創(chuàng)建對象
  2. 獲取Bean的定義信息RootBeanDefinition，它表示自己的BeanDefinition和可能存在父類的BeanDefinition合并后的對象
  3. 如果Bean滿足這三個條件：非抽象的，單實例，非懶加載，則執(zhí)行單例Bean創(chuàng)建流程：
  4. 所有Bean都利用getBean()創(chuàng)建完成以后，檢查所有的Bean是否為SmartInitializingSingleton接口的，如果是；就執(zhí)行afterSingletonsInstantiated()；
  • finishRefresh()：發(fā)布BeanFactory容器刷新完成事件：
  1. nitLifecycleProcessor()：初始化和生命周期有關的后置處理器：默認從容器中找是否有l(wèi)ifecycleProcessor的組件【LifecycleProcessor】，如果沒有，則創(chuàng)建一個DefaultLifecycleProcessor()加入到容器；
  2. getLifecycleProcessor().onRefresh()：拿到前面定義的生命周期處理器（LifecycleProcessor）回調(diào)onRefresh()方法
  3. publishEvent(new ContextRefreshedEvent(this))：發(fā)布容器刷新完成事件；
  4. liveBeansView.registerApplicationContext(this);

下面我們一起看一下上面標紅的重點方法的源碼

BeanFactory的預處理

org.springframework.context.support.AbstractApplicationContext#prepareBeanFactory

顧名思義，這個接口是為 beanFactory 工廠添加一些內(nèi)置組件，預處理過程。

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// Tell the internal bean factory to use the context's class loader etc.
	// 設置 classLoader
	beanFactory.setBeanClassLoader(getClassLoader());
	//設置 bean 表達式解析器
	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));

	// 設置忽略自動裝配的接口，即不能通過注解自動注入
	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.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】
	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.
	// 注冊 environment 組件，類型是【ConfigurableEnvironment】
	if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
	}
	// 注冊 systemProperties 組件，類型是【Map】
	if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
	}
	// 注冊 systemEnvironment 組件，類型是【Map】
	if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
	}
}

執(zhí)行BeanFactory的后置處理器

org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors

Spring 在掃描完所有的 bean 轉(zhuǎn)成 BeanDefinition 時候，我們是可以做一些自定義操作的，這得益于 Spring 為我們提供的 BeanFactoryPostProcessor 接口。

其中 BeanFactoryPostProcessor 又有一個子接口BeanDefinitionRegistryPostProcessor ，前者會把 ConfigurableListableBeanFactory 暴露給我們使用，后者會把 BeanDefinitionRegistry 注冊器暴露給我們使用，一旦獲取到注冊器，我們就可以按需注入了，例如搞定這種需求：假設容器中包含了 a 和 b，那么就動態(tài)向容器中注入 c，不滿足就注入 d。

同時 Spring 是允許我們控制同類型組件的順序，比如在 AOP 中我們常用的 @Order 注解，這里的 BeanFactoryPostProcessor 接口當然也是提供了順序，最先被執(zhí)行的是實現(xiàn)了 PriorityOrdered 接口的實現(xiàn)類，然后再到實現(xiàn)了 Ordered 接口的實現(xiàn)類，最后就是剩下來的常規(guī) BeanFactoryPostProcessor 類。

此時再看上圖，是不是發(fā)現(xiàn)比較簡單了，首先會回調(diào)postProcessBeanDefinitionRegistry() 方法，然后再回調(diào) postProcessBeanFactory() 方法，最后注意順序即可，下面一起看看具體的代碼實現(xiàn)吧。

public static void invokeBeanFactoryPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {
	// beanFactoryPostProcessors 這個參數(shù)是指用戶通過 AnnotationConfigApplicationContext.addBeanFactoryPostProcessor() 方法手動傳入的 BeanFactoryPostProcessor，沒有交給 spring 管理
	// Invoke BeanDefinitionRegistryPostProcessors first, if any.
	// 代表執(zhí)行過的 BeanDefinitionRegistryPostProcessor
	Set processedBeans = new HashSet<>();
 
	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		// 常規(guī)后置處理器集合，即實現(xiàn)了 BeanFactoryPostProcessor 接口
		List regularPostProcessors = new ArrayList<>();
		// 注冊后置處理器集合，即實現(xiàn)了 BeanDefinitionRegistryPostProcessor 接口
		List registryProcessors = new ArrayList<>();
		// 處理自定義的 beanFactoryPostProcessors（指調(diào)用 context.addBeanFactoryPostProcessor() 方法），一般這里都沒有
		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				// 調(diào)用 postProcessBeanDefinitionRegistry 方法
				registryProcessor.postProcessBeanDefinitionRegistry(registry);
				registryProcessors.add(registryProcessor);
			}
			else {
				regularPostProcessors.add(postProcessor);
			}
		}
 
		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let the bean factory post-processors apply to them!
		// Separate between BeanDefinitionRegistryPostProcessors that implement
		// PriorityOrdered, Ordered, and the rest.
		// 定義一個變量 currentRegistryProcessors，表示當前要處理的 BeanFactoryPostProcessors
		List currentRegistryProcessors = new ArrayList<>();
 
		// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
		// 首先，從容器中查找實現(xiàn)了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor 類型，這里只會查找出一個【ConfigurationClassPostProcessor】
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			// 判斷是否實現(xiàn)了 PriorityOrdered 接口
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				// 添加到 currentRegistryProcessors
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				// 添加到 processedBeans，表示已經(jīng)處理過這個類了
				processedBeans.add(ppName);
			}
		}
		// 設置排列順序
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		// 添加到 registry 中
		registryProcessors.addAll(currentRegistryProcessors);
		// 執(zhí)行 [postProcessBeanDefinitionRegistry] 回調(diào)方法
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		// 將 currentRegistryProcessors 變量清空，下面會繼續(xù)用到
		currentRegistryProcessors.clear();
 
		// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
		// 接下來，從容器中查找實現(xiàn)了 Ordered 接口的 BeanDefinitionRegistryPostProcessors 類型，這里可能會查找出多個
		// 因為【ConfigurationClassPostProcessor】已經(jīng)完成了 postProcessBeanDefinitionRegistry() 方法，已經(jīng)向容器中完成掃描工作，所以容器會有很多個組件
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			// 判斷 processedBeans 是否處理過這個類，且是否實現(xiàn) Ordered 接口
			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName);
			}
		}
		// 設置排列順序
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		// 添加到 registry 中
		registryProcessors.addAll(currentRegistryProcessors);
		// 執(zhí)行 [postProcessBeanDefinitionRegistry] 回調(diào)方法
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		// 將 currentRegistryProcessors 變量清空，下面會繼續(xù)用到
		currentRegistryProcessors.clear();
 
		// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
		// 最后，從容器中查找剩余所有常規(guī)的 BeanDefinitionRegistryPostProcessors 類型
		boolean reiterate = true;
		while (reiterate) {
			reiterate = false;
			// 根據(jù)類型從容器中查找
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				// 判斷 processedBeans 是否處理過這個類
				if (!processedBeans.contains(ppName)) {
					// 添加到 currentRegistryProcessors
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					// 添加到 processedBeans，表示已經(jīng)處理過這個類了
					processedBeans.add(ppName);
					// 將標識設置為 true，繼續(xù)循環(huán)查找，可能隨時因為防止下面調(diào)用了 invokeBeanDefinitionRegistryPostProcessors() 方法引入新的后置處理器
					reiterate = true;
				}
			}
			// 設置排列順序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			// 添加到 registry 中
			registryProcessors.addAll(currentRegistryProcessors);
			// 執(zhí)行 [postProcessBeanDefinitionRegistry] 回調(diào)方法
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			// 將 currentRegistryProcessors 變量清空，因為下一次循環(huán)可能會用到
			currentRegistryProcessors.clear();
		}
 
		// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
		// 現(xiàn)在執(zhí)行 registryProcessors 的 [postProcessBeanFactory] 回調(diào)方法
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
		// 執(zhí)行 regularPostProcessors 的 [postProcessBeanFactory] 回調(diào)方法，也包含用戶手動調(diào)用 addBeanFactoryPostProcessor() 方法添加的 BeanFactoryPostProcessor
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}
 
	else {
		// Invoke factory processors registered with the context instance.
		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
	}
 
	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let the bean factory post-processors apply to them!
	// 從容器中查找實現(xiàn)了 BeanFactoryPostProcessor 接口的類
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
 
	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.
	// 表示實現(xiàn)了 PriorityOrdered 接口的 BeanFactoryPostProcessor
	List priorityOrderedPostProcessors = new ArrayList<>();
	// 表示實現(xiàn)了 Ordered 接口的 BeanFactoryPostProcessor
	List orderedPostProcessorNames = new ArrayList<>();
	// 表示剩下來的常規(guī)的 BeanFactoryPostProcessors
	List nonOrderedPostProcessorNames = new ArrayList<>();
	for (String ppName : postProcessorNames) {
		// 判斷是否已經(jīng)處理過，因為 postProcessorNames 其實包含了上面步驟處理過的 BeanDefinitionRegistry 類型
		if (processedBeans.contains(ppName)) {
			// skip - already processed in first phase above
		}
		// 判斷是否實現(xiàn)了 PriorityOrdered 接口
		else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
		}
		// 判斷是否實現(xiàn)了 Ordered 接口
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		// 剩下所有常規(guī)的
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}
 
	// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
	// 先將 priorityOrderedPostProcessors 集合排序
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	// 執(zhí)行 priorityOrderedPostProcessors 的 [postProcessBeanFactory] 回調(diào)方法
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
 
	// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
	// 接下來，把 orderedPostProcessorNames 轉(zhuǎn)成 orderedPostProcessors 集合
	List orderedPostProcessors = new ArrayList<>();
	for (String postProcessorName : orderedPostProcessorNames) {
		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	// 將 orderedPostProcessors 集合排序
	sortPostProcessors(orderedPostProcessors, beanFactory);
	// 執(zhí)行 orderedPostProcessors 的 [postProcessBeanFactory] 回調(diào)方法
	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
 
	// Finally, invoke all other BeanFactoryPostProcessors.
	// 最后把 nonOrderedPostProcessorNames 轉(zhuǎn)成 nonOrderedPostProcessors 集合，這里只有一個，myBeanFactoryPostProcessor
	List nonOrderedPostProcessors = new ArrayList<>();
	for (String postProcessorName : nonOrderedPostProcessorNames) {
		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	// 執(zhí)行 nonOrderedPostProcessors 的 [postProcessBeanFactory] 回調(diào)方法
	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
 
	// Clear cached merged bean definitions since the post-processors might have
	// modified the original metadata, e.g. replacing placeholders in values...
	// 清除緩存
	beanFactory.clearMetadataCache();
}

流程小結

（1）先執(zhí)行BeanDefinitionRegistryPostProcessor： postProcessor.postProcessBeanDefinitionRegistry(registry)
    ① 獲取所有的實現(xiàn)了BeanDefinitionRegistryPostProcessor接口類型的集合
    ② 先執(zhí)行實現(xiàn)了PriorityOrdered優(yōu)先級接口的BeanDefinitionRegistryPostProcessor
    ③ 再執(zhí)行實現(xiàn)了Ordered順序接口的BeanDefinitionRegistryPostProcessor
    ④ 最后執(zhí)行沒有實現(xiàn)任何優(yōu)先級或者是順序接口的BeanDefinitionRegistryPostProcessors        
（2）再執(zhí)行BeanFactoryPostProcessor的方法：postProcessor.postProcessBeanFactory(beanFactory)
    ① 獲取所有的實現(xiàn)了BeanFactoryPostProcessor接口類型的集合
    ② 先執(zhí)行實現(xiàn)了PriorityOrdered優(yōu)先級接口的BeanFactoryPostProcessor
    ③ 再執(zhí)行實現(xiàn)了Ordered順序接口的BeanFactoryPostProcessor
    ④ 最后執(zhí)行沒有實現(xiàn)任何優(yōu)先級或者是順序接口的BeanFactoryPostProcessor

注冊Bean的后置處理器

org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors

這一步是向容器中注入 BeanPostProcessor 后置處理器，注意這里僅僅是向容器中注入而非使用。關于 BeanPostProcessor ，它的作用主要是會干預 Spring 初始化 bean 的流程，從而完成代理、自動注入、循環(huán)依賴等各種功能。

public static void registerBeanPostProcessors(
		ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
 
	// 從容器中獲取 BeanPostProcessor 類型
	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
 
	// Register BeanPostProcessorChecker that logs an info message when
	// a bean is created during BeanPostProcessor instantiation, i.e. when
	// a bean is not eligible for getting processed by all BeanPostProcessors.
	int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
	// 向容器中添加【BeanPostProcessorChecker】，主要是用來檢查是不是有 bean 已經(jīng)初始化完成了，
	// 如果沒有執(zhí)行所有的 beanPostProcessor（用數(shù)量來判斷），如果有就會打印一行 info 日志
	beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
 
	// Separate between BeanPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.
	// 存放實現(xiàn)了 PriorityOrdered 接口的 BeanPostProcessor
	List priorityOrderedPostProcessors = new ArrayList<>();
	// 存放 MergedBeanDefinitionPostProcessor 類型的 BeanPostProcessor
	List internalPostProcessors = new ArrayList<>();
	// 存放實現(xiàn)了 Ordered 接口的 BeanPostProcessor 的 name
	List orderedPostProcessorNames = new ArrayList<>();
	// 存放剩下來普通的 BeanPostProcessor 的 name
	List nonOrderedPostProcessorNames = new ArrayList<>();
	// 從 beanFactory 中查找 postProcessorNames 里的 bean，然后放到對應的集合中
	for (String ppName : postProcessorNames) {
		// 判斷有無實現(xiàn) PriorityOrdered 接口
		if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			priorityOrderedPostProcessors.add(pp);
			// 如果實現(xiàn)了 PriorityOrdered 接口，且屬于 MergedBeanDefinitionPostProcessor
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				// 把 MergedBeanDefinitionPostProcessor 類型的添加到 internalPostProcessors 集合中
				internalPostProcessors.add(pp);
			}
		}
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}
 
	// First, register the BeanPostProcessors that implement PriorityOrdered.
	// 給 priorityOrderedPostProcessors 排序
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	// 先注冊實現(xiàn)了 PriorityOrdered 接口的 beanPostProcessor
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
 
	// Next, register the BeanPostProcessors that implement Ordered.
	// 從 beanFactory 中查找 orderedPostProcessorNames 里的 bean，然后放到對應的集合中
	List orderedPostProcessors = new ArrayList<>();
	for (String ppName : orderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		orderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	// 給 orderedPostProcessors 排序
	sortPostProcessors(orderedPostProcessors, beanFactory);
	// 再注冊實現(xiàn)了 Ordered 接口的 beanPostProcessor
	registerBeanPostProcessors(beanFactory, orderedPostProcessors);
 
	// Now, register all regular BeanPostProcessors.
	List nonOrderedPostProcessors = new ArrayList<>();
	for (String ppName : nonOrderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		nonOrderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	// 再注冊常規(guī)的 beanPostProcessor
	registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
 
	// Finally, re-register all internal BeanPostProcessors.
	// 排序 MergedBeanDefinitionPostProcessor 這種類型的 beanPostProcessor
	sortPostProcessors(internalPostProcessors, beanFactory);
	// 最后注冊 MergedBeanDefinitionPostProcessor 類型的 beanPostProcessor
	registerBeanPostProcessors(beanFactory, internalPostProcessors);
 
	// Re-register post-processor for detecting inner beans as ApplicationListeners,
	// moving it to the end of the processor chain (for picking up proxies etc).
	// 給容器中添加【ApplicationListenerDetector】 beanPostProcessor，判斷是不是監(jiān)聽器，如果是就把 bean 放到容器中保存起來
	// 此時容器中默認會有 6 個內(nèi)置的 beanPostProcessor
		// 0 = {ApplicationContextAwareProcessor@1632}
		//	1 = {ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor@1633}
		//	2 = {PostProcessorRegistrationDelegate$BeanPostProcessorChecker@1634}
		//	3 = {CommonAnnotationBeanPostProcessor@1635}
		//	4 = {AutowiredAnnotationBeanPostProcessor@1636}
		//	5 = {ApplicationListenerDetector@1637}
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

初始化事件派發(fā)器

org.springframework.context.support.AbstractApplicationContext#initApplicationEventMulticaster：

在整個容器創(chuàng)建過程中，Spring 會發(fā)布很多容器事件，如容器啟動、刷新、關閉等，這個功能的實現(xiàn)得益于這里的ApplicationEventMulticaster 廣播器組件，通過它來派發(fā)事件通知。

protected void initApplicationEventMulticaster() {
	// 獲取 beanFactory
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	// 看看容器中是否有自定義的 applicationEventMulticaster
	if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
		// 有就從容器中獲取賦值
		this.applicationEventMulticaster =
				beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
		if (logger.isTraceEnabled()) {
			logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
		}
	}
	else {
		// 沒有，就創(chuàng)建一個 SimpleApplicationEventMulticaster
		this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
		// 將創(chuàng)建的 ApplicationEventMulticaster 添加到 BeanFactory 中， 其他組件就可以自動注入了
		beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
		if (logger.isTraceEnabled()) {
			logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
					"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
		}
	}
}

注冊ApplicationListener監(jiān)聽器

org.springframework.context.support.AbstractApplicationContext#registerListeners：

這一步主要是將容器中所有的ApplicationListener注冊到事件派發(fā)器中，并派發(fā)之前步驟產(chǎn)生的事件。

protected void registerListeners() {
	// Register statically specified listeners first.
	// 獲取之前步驟中保存的 ApplicationListener
	for (ApplicationListener listener : getApplicationListeners()) {
		// getApplicationEventMulticaster() 就是獲取之前步驟初始化的 applicationEventMulticaster
		getApplicationEventMulticaster().addApplicationListener(listener);
	}
 
	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let post-processors apply to them!
	// 從容器中獲取所有的 ApplicationListener
	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...
	// 派發(fā)之前步驟產(chǎn)生的 application events
	Set earlyEventsToProcess = this.earlyApplicationEvents;
	this.earlyApplicationEvents = null;
	if (earlyEventsToProcess != null) {
		for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
			getApplicationEventMulticaster().multicastEvent(earlyEvent);
		}
	}
}

初始化所有的單例Bean

org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons：

在前面的步驟中，Spring 的大多數(shù)組件都已經(jīng)初始化完畢了，剩下來的這個步驟就是初始化所有剩余的單實例 bean，Spring主要是通過preInstantiateSingletons()方法把容器中的 bean 都初始化完畢。這里我們就不細講Bean的創(chuàng)建流程了。

public void preInstantiateSingletons() throws BeansException {
	if (logger.isTraceEnabled()) {
		logger.trace("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.
	// 獲取容器中的所有 beanDefinitionName
	List beanNames = new ArrayList<>(this.beanDefinitionNames);
 
	// Trigger initialization of all non-lazy singleton beans...
	// 循環(huán)進行初始化和創(chuàng)建對象
	for (String beanName : beanNames) {
		// 獲取 RootBeanDefinition，它表示自己的 BeanDefinition 和可能存在父類的 BeanDefinition 合并后的對象
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		// 如果是非抽象的，且單實例，非懶加載
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			// 如果是 factoryBean，利用下面這種方法創(chuàng)建對象
			if (isFactoryBean(beanName)) {
				// 如果是 factoryBean，則 加上 &，先創(chuàng)建工廠 bean
				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)
										((SmartFactoryBean) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			}
			else {
				// 不是工廠 bean，用這種方法創(chuàng)建對象
				getBean(beanName);
			}
		}
	}
 
	// Trigger post-initialization callback for all applicable beans...
	for (String beanName : beanNames) {
		Object singletonInstance = getSingleton(beanName);
		// 檢查所有的 bean 是否是 SmartInitializingSingleton 接口
		if (singletonInstance instanceof SmartInitializingSingleton) {
			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedAction) () -> {
					smartSingleton.afterSingletonsInstantiated();
					return null;
				}, getAccessControlContext());
			}
			else {
				// 回調(diào) afterSingletonsInstantiated() 方法，可以在回調(diào)中做一些事情
				smartSingleton.afterSingletonsInstantiated();
			}
		}
	}
}

發(fā)布BeanFactory容器刷新完成事件


org.springframework.context.support.AbstractApplicationContext#finishRefresh：整個容器初始化完畢之后，會在這里進行一些掃尾工作，如清理緩存，初始化生命周期處理器，發(fā)布容器刷新事件等。
protected void finishRefresh() {
	// Clear context-level resource caches (such as ASM metadata from scanning).
	// 清理緩存
	clearResourceCaches();
 
	// Initialize lifecycle processor for this context.
	// 初始化和生命周期有關的后置處理器
	initLifecycleProcessor();
 
	// Propagate refresh to lifecycle processor first.
	// 拿到前面定義的生命周期處理器【LifecycleProcessor】回調(diào) onRefresh() 方法
	getLifecycleProcessor().onRefresh();
 
	// Publish the final event.
	// 發(fā)布容器刷新完成事件
	publishEvent(new ContextRefreshedEvent(this));
 
	// Participate in LiveBeansView MBean, if active.
	LiveBeansView.registerApplicationContext(this);
}
總的來說：
IoC（Inverse of Control:控制反轉(zhuǎn)）是一種設計思想，就是 將原本在程序中手動創(chuàng)建對象的控制權，交由Spring框架來管理。 IoC 在其他語言中也有應用，并非 Spirng 特有。
另一方面理解IOC就是容器， IOC 容器實際上就是個Map（key，value）, Map 中存放的是各種對象，采用三級緩存的方式管理不通狀態(tài)下的對象，從創(chuàng)建到銷毀的整個bean的生命周期都是由容器來管理。
IOC容器創(chuàng)建過程大致是這樣的:
    

  1. 實例化BeanFactory【DefaultListableBeanFactory】工廠，用于生成Bean對象。實例化BeanDefinitionReader bean定義信息讀取器，加載解析bean對象，創(chuàng)建bean對象的定義信息BeanDefinition。
    2. 

  2. prepareBeanFactory(beanFactory) BeanFactory的預處理，這個接口是為 beanFactory 工廠添加一些內(nèi)置組件，預處理過程。
    3. 

  3. 執(zhí)行beanFactory的后置處理器，像PlaceholderConfigurerSupport
    4. 

                                                

                                                網(wǎng)站題目：聊聊Spring容器啟動流程                                                

                                                標題路徑：http://www.dlmjj.cn/article/dppjsso.html