Spring IOC 容器源码简单分析(一)——从xml文件开始

写在前面的话：

首先，这块代码无疑是难以理解的，之前好几次准备认真看看到一半被绕来绕去绕晕了，然后就放弃了。最近还是决定拾起来看了，但不同以往，这次我是备而来的！看了《Spring 揭密》这本书（虽然没看完，但这不是重点 ），这本书比较老了，但是Spring 核心这么多年也没变化太多，看的是一个这本书给的一个思路。同时特地跟着tiny-spring这个项目走了遍它的逻辑，有了这个基础去理解Spring Ioc这块的源码起码有点底子，非常感谢这个项目的作者。

其次，我觉得Spring代码很繁杂，很多方法没必要刨根问底，不该本末倒置太纠结细节，而应去了解关键方法，串成一个链，着重的应该是它的思路，及其运行过程，因此很多方法会略过介绍的。而且标题也写了是简单分析，因此不会很详细的！

前提

简单介绍一下需要了解的知识吧：

BeanFactory：基础类型IoC容器，一个生产Bean的工厂。没有特殊指定时，默认采用延迟初始化（lazy-load）。当需要容器中的某个Bean时，才对该Bean进行初始化以及依赖注入操作。

ApplicationContext：在BeanFactory的基础上构建，拥有BeanFactory的所有支持，以及事件发布、国际化信息支持等，默认容器启动时全部初始化并绑定完成。

BeanDefinition：我们熟知的Bean，在Spring中肯定不是简单的set、get，保存的格式是BeanDefinition，会注册到Spring的BeanDefinitionRegistry。BeanDefinition包含了Bean 信息，如该 Bean 类名、是否是单例的、依赖了哪些 Bean 等。

BeanFactoryPostProcessor：允许我们在容器实例化相应对象之前，对注册到容器的BeanDefinition所保存的信息做相应的修改。这就相当于在容器实现的第一阶段最后加入一道工序，让我们对最终的BeanDefinition做一些额外的操作，比如修改其中bean定义的某些属性，为bean定义增加其他信息等。

分析

从这个地方开启源码之路！

public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml");
}

点进ClassPathXmlApplicationContext构造方法。

public ClassPathXmlApplicationContext(String... configLocations) throws BeansException {
	this(configLocations, true, null);
}
...
public ClassPathXmlApplicationContext(
		String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
		throws BeansException {

	super(parent);
	// 将所给路径的文件，处理成配置文件数组。
	setConfigLocations(configLocations);
	if (refresh) {
		refresh();
	}
}

那核心必须是refresh()这个方法啊，点进去看。

refresh

public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// 准备刷新，设置启动日期和active标志以及文件中的占位符。
		prepareRefresh();

		// ！！重要，这个方法一路走下去就会解析xml文件为BeanDefinition, 同时注册进框架。
		// 当然，这个时候还没有初始化！！！！，只是解析好，并注册进了。
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// 配置工厂，如类加载器和BeanPostProcessor。
		prepareBeanFactory(beanFactory);

		try {
			// 在所有BeanDefinition已经加载完毕，但是还没有实例化bean。
			// 允许在某些ApplicationContext实现中注册特殊的BeanPostProcessors。 
			postProcessBeanFactory(beanFactory);

			// Invoke factory processors registered as beans in the context.
			invokeBeanFactoryPostProcessors(beanFactory);

			// Register bean processors that intercept bean creation.
			registerBeanPostProcessors(beanFactory);

			// Initialize message source for this context.
			initMessageSource();

			// Initialize event multicaster for this context.
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			onRefresh();

			// Check for listener beans and register them.
			registerListeners();

			// 实例化所有剩余的（非延迟初始化）单例！！！也是重点！！
			finishBeanFactoryInitialization(beanFactory);

			// Last step: publish corresponding event.
			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();
		}
	}
}

将xml转换为BeanDefinition

这个方法是很流程的东西，最核心的就是obtainFreshBeanFactory()方法，下面看一下该方法：

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	refreshBeanFactory();
	return getBeanFactory();
}

该方法里就只有两个方法， 继续点进去看，先看refreshBeanFactory():

protected final void refreshBeanFactory() throws BeansException {
	// 判断是否已经有了BeanFactory，如果已经有了，则销毁所有的beans, 关闭已有的BeanFactory
	if (hasBeanFactory()) {
		destroyBeans();
		closeBeanFactory();
	}
	try {
		// 初始化一个 DefaultListableBeanFactory，这个BeanFactory基本继承了所有的BeanFactory。
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		// 设置BeanFactory的序列化。
		beanFactory.setSerializationId(getId());
		// 设置 BeanFactory 是否允许 Bean 覆盖、是否允许循环引用。
		customizeBeanFactory(beanFactory);
		// 加载BeanDefinition。
		loadBeanDefinitions(beanFactory);
		synchronized (this.beanFactoryMonitor) {
			this.beanFactory = beanFactory;
		}
	}
	catch (IOException ex) {
		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
	}
}

为啥说这个BeanFactory是最牛的呢，请看图：

上个方法核心很明显是loadBeanDefinitions，加载BeanDefinition。下面看下这个。

loadBeanDefinitions 加载BeanDefinition

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// 为该BeanFactory创建一个新的XmlBeanDefinitionReader。
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		// 设置一些配置，因为不是核心，没仔细看。
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		// 初始化 BeanDefinitionReader，也不重要。
		initBeanDefinitionReader(beanDefinitionReader);
		// 核心是这个，加载BeanDefinition！！
		loadBeanDefinitions(beanDefinitionReader);
	}

看loadBeanDefinitions方法：

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
	Resource[] configResources = getConfigResources();
	if (configResources != null) {
		//  看这儿 <1>。
		reader.loadBeanDefinitions(configResources);
	}
	String[] configLocations = getConfigLocations();
	if (configLocations != null) {
		// 这个看着看着还是会回到上面的loadBeanDefinitions的。
		reader.loadBeanDefinitions(configLocations);
	}
}

// 对应的<1>的loadBeanDefinitions
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
	Assert.notNull(resources, "Resource array must not be null");
	// 表示加载了多少的BeanDefinition。
	int count = 0;
	for (Resource resource : resources) {
		// 加载BeanDefinition，有三种，看XmlBeanDefinitionReader的就行。
		count += loadBeanDefinitions(resource);
	}
	return count;
}

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
	return loadBeanDefinitions(new EncodedResource(resource));
}

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
	Assert.notNull(encodedResource, "EncodedResource must not be null");
	if (logger.isTraceEnabled()) {
		logger.trace("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());
			}
			// 我发现Spring中所有的doXxx才是真正的加载，因此绕了半天绕到这里才是真正开始加载。
			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();
		}
	}
}


/**
* 这个方法好多的catch，我给略过了。
*/
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
	try {
		// 将xml文件转成一个Document对象。
		Document doc = doLoadDocument(inputSource, resource);
		// 注册BeanDefinition们。
		int count = registerBeanDefinitions(doc, resource);
		if (logger.isDebugEnabled()) {
			logger.debug("Loaded " + count + " bean definitions from " + resource);
		}
		return count;
	}
	// 一堆catch。
}

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
	// 在注册前的BeanDefinition数量。
	int countBefore = getRegistry().getBeanDefinitionCount();
	// 注册。
	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
	// 现有注册数量 - 之前的注册数量 = 该次注册数量（在说废话...）。
	return getRegistry().getBeanDefinitionCount() - countBefore;
}

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
	this.readerContext = readerContext;
	// 我就说吧，doXxx才是干实事的！
	doRegisterBeanDefinitions(doc.getDocumentElement());
}

这些都是一连贯的，因此我们来看看干实事的doRegisterBeanDefinitions！

doRegisterBeanDefinitions 注册BeanDefinition

protected void doRegisterBeanDefinitions(Element root) {
	// 瞧瞧人家这名字，BeanDefinition转换代表，一看就与众不同。
	BeanDefinitionParserDelegate parent = this.delegate;
	this.delegate = createDelegate(getReaderContext(), root, parent);
	// 判断是不是默认的NameSpace -> http://www.springframework.org/schema/beans
	if (this.delegate.isDefaultNamespace(root)) {
		// 判断其profile，dev、test还是prod，如果不是当前环境定义的就过过过。
		String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
		if (StringUtils.hasText(profileSpec)) {
			String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
					profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			// We cannot use Profiles.of(...) since profile expressions are not supported
			// in XML config. See SPR-12458 for details.
			if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
							"] not matching: " + getReaderContext().getResource());
				}
				return;
			}
		}
	}

	preProcessXml(root);
	// 重点。
	parseBeanDefinitions(root, this.delegate);
	postProcessXml(root);

	this.delegate = parent;
}

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)) {
					// 点进去可以看见。
					// 解析默认的Elemtment, 就以下四种，import, alias, bean, beans。
					parseDefaultElement(ele, delegate);
				}
				else {
					// 那除了上面四种，就是其他的咯。
					delegate.parseCustomElement(ele);
				}
			}
		}
	}
	else {
		delegate.parseCustomElement(root);
	}
}

其他不关注了，就看怎么解析bean。点进parseDefaultElement再进processBeanDefinition。看processBeanDefinition：

processBeanDefinition 解析为BeanDefinition

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	// 具体就不进去描述了，感兴趣的可以自己去看.
	// 反正总的来说就是解析了<bean>为一个BeanDefinitionHolder
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			// 注册咯。
			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));
	}
}

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

	// 获取bean名称。
	String beanName = definitionHolder.getBeanName();
	// 然后注册进Bean，看下面我引的方法解读。
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

	// 有别名的话，就注册别名。点进去一步步看能看出，是aliasMap, 其中key是alias，value是beanName。
	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);
		}
	}
	// 判断改BeanName是否已经存在。
	BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
	// 如果存在。
	if (existingDefinition != null) {
		// 且不允许覆盖，则，抛异常。
		if (!isAllowBeanDefinitionOverriding()) {
			throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
		}
		// 重写用户自定义的 Bean。
		else if (existingDefinition.getRole() < beanDefinition.getRole()) {
			// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
			if (logger.isInfoEnabled()) {
				logger.info("Overriding user-defined bean definition for bean '" + beanName +
						"' with a framework-generated bean definition: replacing [" +
						existingDefinition + "] with [" + beanDefinition + "]");
			}
		}
		// 如果不是同一bean，则覆盖。
		else if (!beanDefinition.equals(existingDefinition)) {
			if (logger.isDebugEnabled()) {
				logger.debug("Overriding bean definition for bean '" + beanName +
						"' with a different definition: replacing [" + existingDefinition +
						"] with [" + beanDefinition + "]");
			}
		}
		// 还是会覆盖。
		else {
			if (logger.isTraceEnabled()) {
				logger.trace("Overriding bean definition for bean '" + beanName +
						"' with an equivalent definition: replacing [" + existingDefinition +
						"] with [" + beanDefinition + "]");
			}
		}
		// 前面只是打日志，这才是实打实的覆盖。
		this.beanDefinitionMap.put(beanName, beanDefinition);
	}
	else {
		// 判断是否已有bean初始化了。
		if (hasBeanCreationStarted()) {
			// Cannot modify startup-time collection elements anymore (for stable iteration)
			synchronized (this.beanDefinitionMap) {
				// 终于放进这个map！
				this.beanDefinitionMap.put(beanName, beanDefinition);
				List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
				updatedDefinitions.addAll(this.beanDefinitionNames);
				updatedDefinitions.add(beanName);
				this.beanDefinitionNames = updatedDefinitions;
				removeManualSingletonName(beanName);
			}
		}
		else {
			// 没有就进这里，这里和上面差不多。
			this.beanDefinitionMap.put(beanName, beanDefinition);
			this.beanDefinitionNames.add(beanName);
			removeManualSingletonName(beanName);
		}
		this.frozenBeanDefinitionNames = null;
	}

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

至此，已经初始化了 Bean 容器，也转换为了BeanDefinition，也注册了各个 BeanDefinition 到注册中心了，但是还未初始化。以上就是obtainFreshBeanFactory方法一条链走下来的逻辑，简单梳理一下：

下面再看refresh 中的 finishBeanFactoryInitialization方法，其中里面会初始化所有的Bean！

初始化

finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	// 初始化 conversionService 的 Bean。
	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));
	}

	// 如果之前没有任何bean后处理器（例如PropertyPlaceholderConfigurer bean）之前进行过注册，
	// 注册一个默认的嵌入式值解析器，主要用于注释属性值的解析。
	if (!beanFactory.hasEmbeddedValueResolver()) {
		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
	}

	// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
	String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
	for (String weaverAwareName : weaverAwareNames) {
		getBean(weaverAwareName);
	}

	// Stop using the temporary ClassLoader for type matching.
	beanFactory.setTempClassLoader(null);

	// Allow for caching all bean definition metadata, not expecting further changes.
	beanFactory.freezeConfiguration();

	// 开始初始化咯。
	beanFactory.preInstantiateSingletons();
}

下面看preInstantiateSingletons方法，进行初始化。

public void preInstantiateSingletons() throws BeansException {
	if (logger.isTraceEnabled()) {
		logger.trace("Pre-instantiating singletons in " + this);
	}

	// beanDefinitionNames是已经解析好的bean name.
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	for (String beanName : beanNames) {
		// 合并父 Bean 中的配置，注意 <bean id="" class="" parent="" /> 中的 parent，用的不多吧。
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		// 如果是非抽象的，单例的，非延迟初始化的
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			// 判断是否是FactoryBean，FactoryBean 是一个特殊的Bean，能创建Bean。
			if (isFactoryBean(beanName)) {
				// 如果是，名字前加个 &。
				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<Boolean>)
										((SmartFactoryBean<?>) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			}
			else {	
				// 不是FactoryBean就是普通的呗，走这里。
				getBean(beanName);
			}
		}
	}

	// 此时所有的bean已经全部初始化好了，触发所有适用bean的初始化后回调。
	for (String beanName : beanNames) {
		Object singletonInstance = getSingleton(beanName);
		if (singletonInstance instanceof SmartInitializingSingleton) {
			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
					smartSingleton.afterSingletonsInstantiated();
					return null;
				}, getAccessControlContext());
			}
			else {
				smartSingleton.afterSingletonsInstantiated();
			}
		}
	}
}

重点就是getBean，介于篇幅原因，下篇再来。

最后，谢谢观看。本人才疏学浅，如有错误之处，欢迎指正，共同进步。