Spring深度学习：IOC容器及源码解析

---

Spring深度学习：IOC容器及源码解析

一、序言

大家经常戏称Java工程师为Spring工程师，毫无疑问，这句话体现出Spring框架在Java开发中的重要性和普及度。

本文小豪将带大家深度学习Spring IOC底层源码，学习过程中不仅仅是了解Spring IOC的工作原理，更重要的是学会理解框架的底层逻辑，从而提升我们的思维能力。

文章最后附有思维导图，进一步帮我们梳理业务逻辑

二、前置知识

在正式进入分析源码之前，小豪在这里简单介绍一些Spring源码中涉及到的概念，以便我们更好的分析源码：

• Bean：Bean就是Spring应用的Java对象，它们被Spring IOC容器创建，装配和管理，其实就是Spring对我们的Java对象做了一层特殊封装。
• BeanDefinition：顾名思义就是对Bean信息的定义，直白来说，它就类似一张“说明书”，告诉Spring容器创建一个什么样的Bean，BeanDefinition里面提供创建和配置Bean所需的所有信息。
• BeanFactory：BeanFactory就是用来管理和控制Bean的工厂，即核心的IOC容器。
• xxxPostProcess：PostProcess结尾的一般称它为后置处理器，是Spring预留给我们进行自定义实现的，实现对原有对象的增强，也体现出Spring强大的扩展性，常见的包括BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor、BeanPostProcessor。

三、环境准备

具体Spring源码下载及环境搭建可参考其它博主，这里不再进行赘述。

小豪这里下载的是5.0.x版本的Spring源码，不同的Spring版本源码会有差异，但核心业务逻辑基本不变。

public class SpringDemo {
	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring-config.xml");
		User user = (User) applicationContext.getBean("user");
        //hello()方法中仅输出打印语句
		user.hello();
	}
}

执行SpringDemo类main()方法，控制台输出：

hello，spring

我们首先来看这三行代码完成了什么功能。

• ClassPathXmlApplicationContext：调用其构造方法，传入xml配置文件地址。
• 调用applicationContext对象getBean()方法，传入user名称。
• 调用user对象hello()方法，完成输出。

四、源码分析

我们从ClassPathXmlApplicationContext()方法进入，分析具体Spring IOC容器是如何创建出来的，进入ClassPathXmlApplicationContext()方法，具体源码如下：

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
		this(new String[] {configLocation}, true, null);
	}

发现它调用本类的另一个构造方法，传入的第一个参数为xml配置文件地址，第二个参数为true，继续往下分析，具体源码如下：

public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {

		// 调用父类构造方法，创建相关对象
		super(parent);
		// 设置配置路径
		setConfigLocations(configLocations);
		// refresh = true
		if (refresh) {
            // （核心）Spring容器的创建刷新
			refresh();
		}
	}

通过源码发现又包含三部分内容，分别是：

1. super(parent)：调用父类的构造方法，创建相关对象。
2. setConfigLocations(configLocations)：设置配置路径，即设置我们传入的xml配置文件地址。
3. refresh()：Spring容器的创建刷新，完成所有的Bean的创建以及初始化。

其中refresh()为本文介绍的核心方法，主要完成解析配置文件、进行BeanFactory的创建、Bean的实例化、代理等一系列的工作，我们再次跟进去，具体源码如下：

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Spring容器初始化前的预处理，做一些前置的准备工作，包括设置系统属性、验证环境变量等
			prepareRefresh();

			// 创建Spring容器，初始化BeanFactory，加载并解析配置文件
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// BeanFactory的准备工作，主要是设置BeanFactory的属性
			prepareBeanFactory(beanFactory);

			try {
				// 对BeanFactory的后置处理，默认未实现，由子类去实现
				postProcessBeanFactory(beanFactory);

				// 调用BeanFactory的后置处理器，可自定义处理器进行修改BeanDefinition
				invokeBeanFactoryPostProcessors(beanFactory);

				// 注册Bean的后置处理器
				registerBeanPostProcessors(beanFactory);

				// 初始化消息资源
				initMessageSource();

				// 初始化事件广播器
				initApplicationEventMulticaster();

				// 模板方法，默认未实现（springboot有具体实现）
				onRefresh();

				// 注册监听器，将所有Listener注册到广播器
				registerListeners();

				// 实例化所有非懒加载的单例Bean
				finishBeanFactoryInitialization(beanFactory);

				// 完成刷新
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

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

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

下面简单概括一下上面的初始化步骤：

1. prepareRefresh： Spring容器初始化前的预处理，做一些前置的准备工作，包括设置系统属性、验证环境变量等；
2. obtainFreshBeanFactory ：创建Spring容器，初始化BeanFactory，加载并解析配置文件；
3. prepareBeanFactory ：BeanFactory的准备工作，主要是设置BeanFactory的属性；
4. postProcessBeanFactory ： 对BeanFactory的后置处理，默认未实现，由子类去实现；
5. invokeBeanFactoryPostProcessors ： 调用BeanFactory的后置处理器，可自定义处理器进行修改BeanDefinition；
6. registerBeanPostProcessors ：注册Bean的后置处理器；
7. initMessageSource ：初始化消息资源；
8. initApplicationEventMulticaster ：初始化事件广播器；
9. onRefresh ：模板方法，默认未实现（SpringBoot有具体实现）；
10. registerListeners ：注册监听器，将所有Listener注册到广播器；
11. finishBeanFactoryInitialization ：实例化所有非懒加载的单例Bean
12. finishRefresh ：完成刷新。

接下来我们细致分析一下各方法具体做了哪些工作：

1.prepareRefresh

进入prepareRefresh()方法，具体源码如下：

protected void prepareRefresh() {
		// 设置Spring容器的启动时间
		this.startupDate = System.currentTimeMillis();
		// 设置Spring容器的当前状态
		this.closed.set(false);
		this.active.set(true);

		if (logger.isInfoEnabled()) {
			logger.info("Refreshing " + this);
		}

		// 初始化属性资源（子类覆盖实现）
		initPropertySources();

		// 初始化系统环境属性，验证必要属性是否已被解析
		getEnvironment().validateRequiredProperties();

		// 初始化earlyApplicationListeners，存放项目中定义的监听器
		if (this.earlyApplicationListeners == null) {
			this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
		}
		else {
			// Reset local application listeners to pre-refresh state.
			this.applicationListeners.clear();
			this.applicationListeners.addAll(this.earlyApplicationListeners);
		}

		// 初始化earlyApplicationEvents，存放项目中定义的监听事件
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}

观察源码发现prepareRefresh()方法大致做了如下工作：

1. 记录启动时间：标记Spring容器的开始时间。
2. 设置容器状态：将Spring容器的 closed 状态设置为 false，active 状态设置为 true。
3. 初始化属性源：配置和初始化属性资源。
4. 验证环境属性：检查所有必需的环境属性是否被解析。
5. 初始化早期事件监听器：保存早期的应用事件监听器。

由此可知，该方法主要为Spring容器创建和初始化提供必要的准备工作。

2.obtainFreshBeanFactory

进入obtainFreshBeanFactory()方法，具体源码如下：

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		// 创建BeanFactory，解析配置文件并生成BeanDefinition完成注册
		refreshBeanFactory();
		// 获取beanFactory实例
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

其中 refreshBeanFactory() 方法为比较重要的方法，主要进行解析xml配置文件并生成BeanDefinition完成注册，这里选择进入refreshBeanFactory() 方法的实现类 AbstractRefreshableApplicationContext ，具体源码如下：

protected final void refreshBeanFactory() throws BeansException {
		// 是否存在bean工厂，存在则销毁所有单例
		if (hasBeanFactory()) {

			destroyBeans();
			closeBeanFactory();
		}
		try {
			// 实例化BeanFactory，设置序列化Id等
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			// 定制BeanFactory，如是否支持循环依赖
			customizeBeanFactory(beanFactory);
			// （核心）加载BeanDefinition
			loadBeanDefinitions(beanFactory);
			this.beanFactory = beanFactory;
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

继续往下走，这里选择进入loadBeanDefinitions() 方法的实现类 XmlWebApplicationContext ，具体源码如下：

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// 实例化xml文件解析器XmlBeanDefinitionReader
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
		// 设置属性
		beanDefinitionReader.setEnvironment(getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		initBeanDefinitionReader(beanDefinitionReader);
		// （核心）加载BeanDefinitions
		loadBeanDefinitions(beanDefinitionReader);
	}

继续往下走，具体源码如下：

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
		// 获取xml配置文件路径
		String[] configLocations = getConfigLocations();
		if (configLocations != null) {
			for (String configLocation : configLocations) {
				// 根据配置文件加载BeanDefinitions
				reader.loadBeanDefinitions(configLocation);
			}
		}
	}

这里通过getConfigLocations()方法获取到xml配置文件路径，遍历调用loadBeanDefinitions()，继续跟进，具体源码如下：

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
		ResourceLoader resourceLoader = getResourceLoader();
		if (resourceLoader == null) {
			throw new BeanDefinitionStoreException(
					"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
		}

		if (resourceLoader instanceof ResourcePatternResolver) {
			// Resource pattern matching available.
			try {
				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				// 加载BeanDefinitions，继续进入
				int loadCount = loadBeanDefinitions(resources);
				if (actualResources != null) {
					for (Resource resource : resources) {
						actualResources.add(resource);
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
				}
				return loadCount;
			}
			catch (IOException ex) {
				throw new BeanDefinitionStoreException(
						"Could not resolve bean definition resource pattern [" + location + "]", ex);
			}
		}
		else {
			// Can only load single resources by absolute URL.
			Resource resource = resourceLoader.getResource(location);
			int loadCount = loadBeanDefinitions(resource);
			if (actualResources != null) {
				actualResources.add(resource);
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
			}
			return loadCount;
		}
	}

继续往下走，具体源码如下：

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
		Assert.notNull(encodedResource, "EncodedResource must not be null");
		if (logger.isInfoEnabled()) {
			logger.info("Loading XML bean definitions from " + encodedResource);
		}

		Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
		if (currentResources == null) {
			currentResources = new HashSet<>(4);
			this.resourcesCurrentlyBeingLoaded.set(currentResources);
		}
		if (!currentResources.add(encodedResource)) {
			throw new BeanDefinitionStoreException(
					"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
		}
		try {
			InputStream inputStream = encodedResource.getResource().getInputStream();
			try {
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
				// 加载BeanDefinitions，继续进入
				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
			}
			finally {
				inputStream.close();
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"IOException parsing XML document from " + encodedResource.getResource(), ex);
		}
		finally {
			currentResources.remove(encodedResource);
			if (currentResources.isEmpty()) {
				this.resourcesCurrentlyBeingLoaded.remove();
			}
		}
	}

Spring中do方法开头的方法一般为具体的做事方法，我们继续进入：

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
		try {
			// 根据路径加载xml文件，封装为Document
			Document doc = doLoadDocument(inputSource, resource);
			// （核心）解析配置文件，注册Bean
			return registerBeanDefinitions(doc, resource);
		}
		catch (BeanDefinitionStoreException ex) {
			throw ex;
		}
		catch (SAXParseException ex) {
			throw new XmlBeanDefinitionStoreException(resource.getDescription(),
					"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
		}
		catch (SAXException ex) {
			throw new XmlBeanDefinitionStoreException(resource.getDescription(),
					"XML document from " + resource + " is invalid", ex);
		}
		catch (ParserConfigurationException ex) {
			throw new BeanDefinitionStoreException(resource.getDescription(),
					"Parser configuration exception parsing XML from " + resource, ex);
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(resource.getDescription(),
					"IOException parsing XML document from " + resource, ex);
		}
		catch (Throwable ex) {
			throw new BeanDefinitionStoreException(resource.getDescription(),
					"Unexpected exception parsing XML document from " + resource, ex);
		}
	}

这里将xml文件封装为Document对象，再次进入：

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		int countBefore = getRegistry().getBeanDefinitionCount();
		// （核心）开始注册Bean
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}

继续往下走：

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		logger.debug("Loading bean definitions");
		// 获取xml配置文件根节点
		Element root = doc.getDocumentElement();
		// 由根节点开始遍历并注册
		doRegisterBeanDefinitions(root);
	}

继续进入do方法：

protected void doRegisterBeanDefinitions(Element root) {
		// Any nested <beans> elements will cause recursion in this method. In
		// order to propagate and preserve <beans> default-* attributes correctly,
		// keep track of the current (parent) delegate, which may be null. Create
		// the new (child) delegate with a reference to the parent for fallback purposes,
		// then ultimately reset this.delegate back to its original (parent) reference.
		// this behavior emulates a stack of delegates without actually necessitating one.
		BeanDefinitionParserDelegate parent = this.delegate;
		this.delegate = createDelegate(getReaderContext(), root, parent);

		if (this.delegate.isDefaultNamespace(root)) {
			String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
			if (StringUtils.hasText(profileSpec)) {
				String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
						profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
				if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
					if (logger.isInfoEnabled()) {
						logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
								"] not matching: " + getReaderContext().getResource());
					}
					return;
				}
			}
		}

		// 模板方法，可自定义扩展标签解析
		preProcessXml(root);
		// （核心）Spring具体解析过程
		parseBeanDefinitions(root, this.delegate);
		// 同preProcessXml类似，自定义扩展
		postProcessXml(root);

		this.delegate = parent;
	}

发现spring提供两个模板方法preProcessXml()和postProcessXml()，便于我们自定义扩展标签解析，这里我们继续深入核心方法parseBeanDefinitions()：

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
		if (delegate.isDefaultNamespace(root)) {
			NodeList nl = root.getChildNodes();
			for (int i = 0; i < nl.getLength(); i++) {
				Node node = nl.item(i);
				if (node instanceof Element) {
					Element ele = (Element) node;
					if (delegate.isDefaultNamespace(ele)) {
						// 默认标签解析
						parseDefaultElement(ele, delegate);
					}
					else {
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			delegate.parseCustomElement(root);
		}
	}

开始遍历解析标签，继续跟进，具体源码如下：：

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		// 主要是对import、alias、bean等标签的解析，根据配置标签走不同解析逻辑
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			importBeanDefinitionResource(ele);
		}
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			processAliasRegistration(ele);
		}
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
			// 主要看bean标签
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			doRegisterBeanDefinitions(ele);
		}
	}

根据不同标签类型，进入不同分支，我们主要看bean标签解析逻辑：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		// 解析element
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// 完成BeanDefinition的缓存注册
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}

再次进入registerBeanDefinition()方法：

public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// 获取BeanName
		String beanName = definitionHolder.getBeanName();
		// 完成注册
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// 注册别名
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}

继续往下走：

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		Assert.hasText(beanName, "Bean name must not be empty");
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");

		if (beanDefinition instanceof AbstractBeanDefinition) {
			try {
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}

		// 判断beanDefinitionMap是否存在此beanName
		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
		if (existingDefinition != null) {
			// 是否允许覆盖，默认为true
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
						"': There is already [" + existingDefinition + "] bound.");
			}
			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
				if (logger.isWarnEnabled()) {
					logger.warn("Overriding user-defined bean definition for bean '" + beanName +
							"' with a framework-generated bean definition: replacing [" +
							existingDefinition + "] with [" + beanDefinition + "]");
				}
			}
			else if (!beanDefinition.equals(existingDefinition)) {
				if (logger.isInfoEnabled()) {
					logger.info("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (logger.isDebugEnabled()) {
					logger.debug("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
			// Bean是否已经创建
			if (hasBeanCreationStarted()) {
				// 若已经被创建，存在线程安全问题，加锁确保同步
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					if (this.manualSingletonNames.contains(beanName)) {
						Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
						updatedSingletons.remove(beanName);
						this.manualSingletonNames = updatedSingletons;
					}
				}
			}
			else {
				// 将beanName与生成的beanDefinition放入beanDefinitionMap
				this.beanDefinitionMap.put(beanName, beanDefinition);
				this.beanDefinitionNames.add(beanName);
				this.manualSingletonNames.remove(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (existingDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
		else if (isConfigurationFrozen()) {
			clearByTypeCache();
		}
	}

好了，到此为止，流程基本结束，观察源码发现obtainFreshBeanFactory()方法大致做了如下工作：

1. 检查现有的BeanFactory：如果已经存在一个BeanFactory实例，那么首先销毁并关闭它。
2. 创建新的BeanFactory：实例化一个新的DefaultListableBeanFactory。
3. 自定义BeanFactory：对BeanFactory进行自定义配置，比如设置是否支持循环依赖。
4. 加载BeanDefinition
   • 创建XmlBeanDefinitionReader并设置属性，用它来读取和解析xml配置文件。
   • 调用loadBeanDefinitions(beanDefinitionReader)方法，开始从配置文件中加载Bean定义。
   • 封装xml配置文件为Document对象，由根节点开始遍历扫描。
   • 根据不同标签走不同解析逻辑，完成BeanDefinition的封装注册。
   • 注册时会根据BeanName判断是否被注册过，同时查看是否允许覆盖，默认为true。
   • 如果没有被注册，进一步判断Bean是否已经创建，最后将beanName与生成的BeanDefinition放入BeanDefinitionMap完成注册。
5. 返回BeanFactory实例

由此可知，该方法主要创建Spring容器，初始化BeanFactory，加载并解析xml配置文件，生成BeanDefinition。

3.prepareBeanFactory

进入prepareBeanFactory()方法，具体源码如下：

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 设置当前BeanFactory的类加载器
		beanFactory.setBeanClassLoader(getClassLoader());
		// 设置可支持的表达式解析器
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// 添加BeanPostProcessor（前置处理器）
		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.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// 添加BeanPostProcessor（后置处理器）
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// 添加对AspectJ的支持
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

		// 添加系统环境（使用单例模式注册）
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}

观察源码发现prepareBeanFactory()方法大致做了如下工作：

1. 设置类加载器：为BeanFactory设置类加载器。
2. 设置Bean表达式解释器：允许BeanFactory解析Bean表达式。
3. 注册属性编辑器：添加PropertyEditor属性编辑器，可将属性动态设置为Bean里面对应的属性类型。
4. 添加前置处理器：添加ApplicationContextAwareProcessor，实现Bean获取Aware接口的回调。
5. 跳过特定属性的自动注入：忽略一些特定的依赖接口。
6. 注册自动装配的特殊依赖：注册一些特殊的bean，包括BeanFactory、ResourceLoader、ApplicationEventPublisher和ApplicationContext，以支持自动装配到其他Bean中。
7. 添加AspectJ支持：如果发现LOAD_TIME_WEAVER_BEAN_NAME，则添加LoadTimeWeaverAwareProcessor。
8. 注册系统环境相关的bean：注册系统属性和环境变量相关的Bean，包括Environment、SystemProperties和SystemEnvironment。

由此可知，该方法主要进行BeanFactory 的准备工作，设置BeanFactory的属性，完成属性填充。

4.postProcessBeanFactory

进入postProcessBeanFactory()方法，具体源码如下：

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	}

查看源码发现postProcessBeanFactory()方法没有具体的实现，它是一个模板方法，留给子类覆写该方法。

5.invokeBeanFactoryPostProcessors

进入invokeBeanFactoryPostProcessors()方法，具体源码如下：

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {

		//具体执行方法
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

继续进入invokeBeanFactoryPostProcessors()方法：

public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

		// 主要是实例化并调⽤beanFactory中所有实现BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor接口的bean
		// 使用Set存储已经执行过的BeanFactoryPostProcessor，避免重复执行
		Set<String> processedBeans = new HashSet<>();

		// 判断BeanFactory类型是否为DefaultListableBeanFactory（Spring的beanFactory默认实现就是DefaultListableBeanFactory）
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			// 分组
			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				// 这里判断是否为为BeanDefinitionRegistryPostProcessor类型
				// 由于BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor
				// 先调BeanDefinition注册处理器
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					// 强转成BeanDefinitionRegistryPostProcessor
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					// 调用BeanDefinition的注册处理器
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}

			// 存放当前待执行的BeanDefinitionRegistryPostProcessor
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			// 首先，调用实现PriorityOrdered的BeanDefinitionRegistryPostProcessor
			// 获取所有实现BeanDefinitionRegistryPostProcessor接口的类名
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				// 判断类是否实现PriorityOrdered接口
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					// 将BeanDefinitionRegistryPostProcessor放入待执行队列currentRegistryProcessors
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					// 放入processedBeans，避免后续重复执行
					processedBeans.add(ppName);
				}
			}
			// 进行排序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			// 添加到集合，后续执行父接口的postProcessBeanFactory方法
			registryProcessors.addAll(currentRegistryProcessors);
			// 遍历集合，调用子类BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry()方法
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			// 清空currentRegistryProcessors
			currentRegistryProcessors.clear();

			// 第二步，调用实现Ordered的BeanDefinitionRegistryPostProcessors
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				// 这里需要判断当前bean没有被执行
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			// 这里与上面的操作一样，排序 -> 添加到registryProcessors -> 执行 -> 清空
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			// 最后调用没有实现PriorityOrdered与Ordered接口的BeanDefinitionRegistryPostProcessor
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					if (!processedBeans.contains(ppName)) {
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						reiterate = true;
					}
				}
				// 默认排序，非自定义排序
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
				currentRegistryProcessors.clear();
			}

			// 调用BeanFactoryPostProcessor.postProcessBeanFactory()方法
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			// Invoke factory processors registered with the context instance.
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		// 获取所有实现BeanFactoryPostProcessor接口的类名
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// 定义了三个集合，分别存放实现priorityOrdered接口、实现priorityOrdered接口和普通接口的BeanFactoryPostProcessor
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			// 判断是否已经执行过
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			// 判断，分别加入对应集合
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// 首先调用实现PriorityOrdered的BeanFactoryPostProcessor
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// 然后调用实现Ordered的BeanFactoryPostProcessors
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// 最后调用所有其它普通的BeanFactoryPostProcessor
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// // 清空缓存
		beanFactory.clearMetadataCache();
	}

观察源码发现invokeBeanFactoryPostProcessors()方法大致做了如下工作：

1. 调用BeanDefinitionRegistryPostProcessor：先调用所有实现了BeanDefinitionRegistryPostProcessor接口的处理器，因为BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口，BeanDefinitionRegistryPostProcessor可以支持添加或修改BeanDefinition。（根据实现PriorityOrdered接口、实现Ordered接口、普通BeanDefinitionRegistryPostProcessors的顺序执行）

2. 调用BeanFactoryPostProcessors：之后会调用那些实现了BeanFactoryPostProcessor接口的处理器。（同样根据顺序执行）

3. 清除数据缓存：最后，清除数据缓存。

由此可知，invokeBeanFactoryPostProcessors()方法主要是实例化并调⽤BeanFactory中所有实现BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor接口的Bean，提供了扩展点，在后续的开发中，我们可以通过实现BeanFactoryPostProcessor和 BeanDefinitionRegistryPostProcessor接口，完成对BeanFactory里面的 BeanDefinition进行修改并扩展。

5.1知识扩展

（1）BeanFactoryPostProcessor

BeanFactory的后置处理器，侧重点在于实现对BeanDefinition的属性修改

（2）BeanDefinitionRegistryPostProcessor

BeanDefinitionRegistry的后置处理器，侧重点在于注册额外的BeanDefinition、也可修改现有的BeanDefinition，BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor接口

这里举个例子：

public class MyBeanDefinitionRegistry implements BeanDefinitionRegistryPostProcessor {

	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		// 获取user的BeanDefinition
		BeanDefinition user = registry.getBeanDefinition("user");
		user.setAttribute("name","xiaohao");
		System.out.println("初始化name：【" + user.getAttribute("name") + "】");
	}

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		
		BeanDefinition user = beanFactory.getBeanDefinition("user");
		// 修改name属性的值
		user.setAttribute("name","hello，xiaohao");
		System.out.println("修改后name：【" + user.getAttribute("name") + "】");
	}
}

修改xml配置文件：

<!--配置Bean: User-->
<bean id="user" class="com.xiaohao.MyBeanDefinitionRegistry"/>

执行后，控制台输出：

初始化name：【xiaohao】
修改后name：【hello，xiaohao】

6.registerBeanPostProcessors

进入registerBeanPostProcessors()方法，具体源码如下：

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}

继续进入：

public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

		// 具体操作与invokeBeanFactoryPostProcessors类似，这里主要是对BeanPostProcessors进行注册
		// 大致过程是获取所有实现BeanPostProcessor的Bean，按照顺序进行排序，加载进beanFactory，当Bean进行初始化的时候完成调用
		// 获取所有实现BeanPostProcessor接口的类名
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// 定义4个不同集合区分实现PriorityOrdered接口的BeanPostProcessor、Spring内部的BeanPostProcessor、实现Ordered接口的BeanPostProcessor和普通BeanPostProcessor
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// 首先，注册实现PriorityOrdered接口的BeanPostProcessors
		// 排序后进行注册
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		// 这里注册前都会先进行移除，保证唯一性
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// 注册实现Ordered接口的BeanPostProcessors
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// 注释普通的BeanPostProcessors
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// 最后，重新注册所有Spring内部的BeanPostProcessor
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

分析源码可知，registerBeanPostProcessors()方法和我们上面 invokeBeanFactoryPostProcessors()方法类似， 大致工作如下：

1. 获取所有BeanPostProcessor：查找所有实现了BeanPostProcessor接口的类。
2. 分类BeanPostProcessor：然后，将这些BeanPostProcessor分为不同的类别。
3. 注册所有BeanPostProcessor：接着，会按照优先级顺序注册所有的BeanPostProcessor，优先级是实现PriorityOrdered接口的BeanPostProcessor、实现Ordered接口的BeanPostProcessor、普通BeanPostProcessor和Spring内部的BeanPostProcessor。

由此可知，registerBeanPostProcessors()方法是对Bean的后置处理器进行注册，加载进BeanFactory，但不会在这里进行调用，在Bean进行初始化的时候完成调用。

6.1知识扩展

（1）BeanPostProcessor

Bean的后置处理器，主要在Bean初始化前后进行工作，回调BeanPostProcessor中定义的两个方法（AOP在此实现）：

• postProcessBeforeInitialization：Bean对象初始化之前进行调用。
• postProcessAfterInitialization：Bean对象的初始化之后进行调用。

这里举个例子：

public class MyBeanPostProcessor implements BeanPostProcessor {

	// Bean对象初始化之前进行调用
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("进行Bean初始化前逻辑处理");
		return bean;
	}

	// Bean对象初始化之后进行调用
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("进行Bean初始化后逻辑处理");
		return bean;
	}
}

修改xml配置文件：

<!--配置Bean: User-->
<bean id="user" class="com.xiaohao.User"/>

<!-- 注册处理器 -->
<bean class="com.xiaohao.MyBeanPostProcessor"></bean>

执行后，控制台输出：

进行Bean初始化前逻辑处理
进行Bean的初始化
进行Bean初始化后逻辑处理

7.initMessageSource

进入initMessageSource()方法，具体源码如下：

protected void initMessageSource() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
			// 获取名称为MESSAGE_SOURCE_BEAN_NAME的资源文件Bean
			this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
			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 {
			// 没有获取到则使用默认的资源文件
			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 + "]");
			}
		}
	}

查看源码发现，initMessageSource()方法逻辑也比较简单，获取MESSAGE_SOURCE资源文件Bean，提取配置中定义的MessageSource，并设置给Spring容器。如果没有获取到资源文件，使用Spring默认的配置 DelegatingMessageSource，该方法主要是初始化Spring容器中的国际化信息资源。

8.initApplicationEventMulticaster

进入initApplicationEventMulticaster()方法，具体源码如下：

protected void initApplicationEventMulticaster() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		// 具体逻辑也比较简单，如果BeanFactory中没有则新建一个广播器注册到BeanFactory
		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
			this.applicationEventMulticaster =
					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
			if (logger.isDebugEnabled()) {
				logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
			}
		}
		else {
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(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 + "]");
			}
		}
	}

分析源码可知，initApplicationEventMulticaster()方法和上面的initMessageSource()方法大致相同， 也分了两种情况：

1. 如果BeanFactory中有广播器，则使用自定义的广播器
2. 如果BeanFactory中没有广播器，则新建一个广播器注册到BeanFactory

由此可知，该方法主要是初始化事件广播器。

9.onRefresh

进入onRefresh()方法，具体源码如下：

protected void onRefresh() throws BeansException {
		// For subclasses: do nothing by default.
	}

进入源码发现onRefresh()方法与postProcessBeanFactory()类似，在Spring中均默认没有任何实现，也属于可被覆盖的模板方法。

但在SpringBoot容器中有具体的实现，这里我们选择进入onRefresh()方法在SpringBoot中的实现类ServletWebServerApplicationContext，具体源码如下：

protected void onRefresh() {
		super.onRefresh();
		try {
            // （核心）创建启动web容器
			createWebServer();
		}
		catch (Throwable ex) {
			throw new ApplicationContextException("Unable to start web server", ex);
		}
	}

继续进入createWebServer()方法：

private void createWebServer() {
		WebServer webServer = this.webServer;
		ServletContext servletContext = getServletContext();
		if (webServer == null && servletContext == null) {
			// 获取webServer工厂类，也就是web容器的工厂（容器有Jetty、Tomcat、Mock）
            // 创建ServletWebServerFactory类（TomcatServletWebServerFactory）
			ServletWebServerFactory factory = getWebServerFactory();
			// 创建tomcat
			this.webServer = factory.getWebServer(getSelfInitializer());
		}
		else if (servletContext != null) {
			try {
				getSelfInitializer().onStartup(servletContext);
			}
			catch (ServletException ex) {
				throw new ApplicationContextException("Cannot initialize servlet context", ex);
			}
		}
		// 初始化资源
		initPropertySources();
	}

由此可知，该方法主要是Spring提供的模板方法，便于自定义扩展，在SpringBoot中通过实现该方法完成了tomcat容器的内嵌。

10.registerListeners

进入registerListeners()方法，具体源码如下：

protected void registerListeners() {
		// 首先注册特殊的事件监听器，这里不是配置中的bean
		for (ApplicationListener<?> listener : getApplicationListeners()) {
			getApplicationEventMulticaster().addApplicationListener(listener);
		}

		// 获取所有实现ApplicationListener接口的类名
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
		for (String listenerBeanName : listenerBeanNames) {
			// 注册到广播器
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

		// 发布一些早期事件
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (earlyEventsToProcess != null) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
	}

查看源码发现registerListeners()方法大致做了如下工作：

1. 注册静态监听器：注册特殊的事件监听器。
2. 获取实现ApplicationListener接口的类名：从Spring容器中获取所有实现了ApplicationListener接口的bean的名称。
3. 注册到ApplicationListenerbeans：将这些实现ApplicationListener 的Bean注册到广播器中。
4. 发布早期应用事件：判断如果存在早期的事件，会在当前被发布出去。

由此可知，该方法主要是注册监听器，将所有Listener监听器注册到广播器，同时发布一些早期事件。

11.finishBeanFactoryInitialization

进入finishBeanFactoryInitialization()方法，具体源码如下：

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 判断BeanFactory中包含ConversionService的bean，并且类型为ConversionService，那么将它们设置为ConversionService
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		// 注册嵌入式解析器
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// 获取所有实现LoadTimeWeaverAware接口的类，进行初始化
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// 进行使用临时ClassLoader进行类型匹配
		beanFactory.setTempClassLoader(null);

		// 冻结所有的beanDefinition信息，不允许修改，即将进行实例化bean对象
		beanFactory.freezeConfiguration();

		// （核心）实例化所有剩下的非懒加载单例
		beanFactory.preInstantiateSingletons();
	}

查看源码发现finishBeanFactoryInitialization()方法大致做了如下工作：

1. 初始化转换服务：判断BeanFactory中包含ConversionService的bean，并且类型为ConversionService，那么将它们设置为ConversionService。
2. 注册默认的嵌入值解析器：判断BeanFactory有没有注册任何嵌入值解析器，没有则会注册一个默认的嵌入值解析器，主要用于注解属性值的解析。
3. 初始化LoadTimeWeaverAware：初始化实现了LoadTimeWeaverAware接口的bean。
4. 冻结所有beanDefinition：冻结BeanDefinition，不允许进行修改，因为后续要创建bean实例对象。
5. 实例化所有剩余的非懒加载单例：实例化所有剩余的（非懒加载）单例bean。

本方法是非常重要的一步，之前已经完成了BeanFactory和BeanDefinition的准备工作，开始正式进入实例化单例Bean，其中第五步beanFactory.preInstantiateSingletons()实例化所有剩下的非懒加载单例为该方法的核心，有关Bean对象的构造、依赖注入、初始化、AOP等均在此步完成，本文暂不深入细致分析，会在后续单独进行关于Bean的生命周期的详解。

12.finishRefresh

进入finishRefresh()方法，具体源码如下：

protected void finishRefresh() {
		// 清除资源缓存
		clearResourceCaches();

		// 初始化LifecycleProcessor
		initLifecycleProcessor();

		// 启动所有实现Lifecycle接口的bean
		getLifecycleProcessor().onRefresh();

		// 发布事件
		publishEvent(new ContextRefreshedEvent(this));

		// 注册ApplicationContext
		LiveBeansView.registerApplicationContext(this);
	}

查看源码发现finishRefresh()方法大致做了如下工作：

1. 清除资源缓存：清除资源缓存，包括在扫描过程中的ASM缓存。
2. 初始化生命周期处理器：获取Spring容器中实现Lifecycle接口的bean，并执行start()方法，初始化生命周期。
3. 发布事件：发布ContextRefreshedEvent事件，通知所有相应的ApplicationListener进行响应操作。

由此可知，该方法是refresh()方法的最后一项工作，主要是清除缓存，初始化生命周期处理器，发送刷新结束事件，注册ApplicationContext，至此Spring IOC容器就创建完成了。

五、思维导图

六、后记

本文从Spring IOC前置知识介绍引申到源码解读，相信大家也初步对Spring IOC容器有了认识，到底何为Spring IOC？

小豪理解他就像是一个“对象管家（BeanFactory）”，一家顶级酒店的管家，他负责安排客人入住、行李搬运等各项服务。在Spring IOC的世界中，我们只需要告诉这位管家我们的需求（依赖注入），比如需要一个服务员（Bean），他就会负责把适合的服务员调到我身边，完全不用我们自己操心。

后续小豪也会更新Spring底层源码其它系列文章，新来的小伙伴可以点点关注哦~