2019.11.12笔记——合并BeanDefinition

合并BeanDefinition

我们知道spring中的BeanDefinition有很多实现类，而且它们之间还可以存在父子关系，这个可以参见《BeanDefinition的分析》。

在spring中每一个bean基本上都会对应有一个BeanDefinition，对于它们的实例化和初始化的过程BeanDefinition也起着关键性作用，BeanDefinition存在父bd（BeanDefinition），可以继承它的父bd的属性，所以我们在实例化和初始化bean的时候必须考虑父bd。

spring也是这么做了，所以在spring初始化和实例化bean的前和过程中都去完成了以想工作——合并bd。在spring中的源码中与之相关的方法名几乎都存在Merged一词来修饰。

在spring bean的初始化流程中很多地方都出现了与合并bd相关的操作，特别是合并bd更是多次调用

下面会依据spring bean初始化流程分别介绍设计到合并bd的地方。

扫描bean

扫描bean的过程中涉及合并bd的操作主要发生在invokeBeanFactoryPostProcessors方法中，这个方法的解析可以参考下面的文章

《spring扫描分析之invokeBeanFactoryPostProcessors解析（BeanFactoryPostProcessor和BeanDefinition）》

调用链如下

在这个方法中调用了三次getBeanNamesForType方法，这个方法的本意是通过类型找到对应的bd的名字，但是我们不能直接从bd的map中去找，在找之前需要合并bd，这样可以避免漏找，所以在找之前会见bd合并，并把合并的bd放到一个map中去。

在扫描的过程中调用了三次getBeanNamesForType方法，对所有可能的bd完成了合并


将合并的bd放到mergedBeanDefinitions集合中去

实例化bean

在实例化之前拿到的合并bd并且也实现了bd的合并，这里主要的目的还是拿到bd，但是同样还是上面的原因，所以要先合并所有的bd。

这实例化的过程中总共调用了两次getMergedLocalBeanDefinition方法，这个方法的内部同样实现了合并bd和拿到合并后的bd的作用。

第一次是在preInstantiateSingletons方法中调用的


第二次是在doGetBean方法中调用的

初始化bean

在初始化bean的过程中解析合并的bean对象中的属性，同时将这些属性缓存住，这里是使用一个后置处理器完成的工作。

是在doCreateBean方法中完成的


在AutowiredAnnotationBeanPostProcessor后置处理器中处理的

解析出现的属性缓存在一个map中

为什么那么多地方存在合并bd

可以发现在上面spring内部在很多的地方去完成合并，为什么需要在那么多地方去实现bd的合并呢？在我看来这其中主要有两个原因：

1. 很多地方我们需要拿到完整的bd，不能只是一个子bd，如果有缺失，很多判断会有问题，所以每次拿到bd都需要合并bd。
2. 因为我们可以在很多地方将bd中的属性改变，所以我们不能只是在一个地方去合并bd，所以在很多地方需要合并bd。比如我们在BeanDefinitionRegistryPostProcessor或者BeanFactoryPostProcessor可以很简单的拿到bd甚至注册bd，所以我们可通过这种方式更改bd中的属性或者添加父bd，这个时候之前合并的bd就不准确了，所以需要多次合并bd。毕竟BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor的后调方法的执行时机并不是在某一个确定的地方。这个可以参考《spring扫描分析之invokeBeanFactoryPostProcessors解析（BeanFactoryPostProcessor和BeanDefinition）》。

合并bd的解析（getMergedBeanDefinition）

如果我们跟踪进上面几个合并bd的地方，会发现底层都是通过getMergedBeanDefinition方法实现的合并bd，下面是方法的源码和一些注释。

protected RootBeanDefinition getMergedBeanDefinition(
		String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
		throws BeanDefinitionStoreException {

	synchronized (this.mergedBeanDefinitions) {
		// 创建一个RootBeanDefinition对象，用来存放合并后的bd
		RootBeanDefinition mbd = null;

		// Check with full lock now in order to enforce the same merged instance.
		if (containingBd == null) {
			mbd = this.mergedBeanDefinitions.get(beanName);
		}

		if (mbd == null) {
			// 如果不存在父bd那么就直接由本身克隆出一个RootBeanDefinition
			if (bd.getParentName() == null) {
				// Use copy of given root bean definition.
				if (bd instanceof RootBeanDefinition) {
					mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
				}
				else {
					mbd = new RootBeanDefinition(bd);
				}
			}
			// 如果存在父bd
			else {
				// Child bean definition: needs to be merged with parent.
				BeanDefinition pbd;
				try {
					// 如果父bd也有父bd那么就先通过getMergedBeanDefinition方法得到合并后的父bd对象
					String parentBeanName = transformedBeanName(bd.getParentName());
					if (!beanName.equals(parentBeanName)) {
						pbd = getMergedBeanDefinition(parentBeanName);
					}
					else {
						BeanFactory parent = getParentBeanFactory();
						if (parent instanceof ConfigurableBeanFactory) {
							pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
						}
						else {
							throw new NoSuchBeanDefinitionException(parentBeanName,
									"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
									"': cannot be resolved without an AbstractBeanFactory parent");
						}
					}
				}
				catch (NoSuchBeanDefinitionException ex) {
					throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
							"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
				}
				// Deep copy with overridden values.
				// 由父bd创建出一个RootBeanDefinition对象
				mbd = new RootBeanDefinition(pbd);
				// 子bd覆盖父bd（覆盖属性之类的）
				mbd.overrideFrom(bd);
			}

			// Set default singleton scope, if not configured before.
			if (!StringUtils.hasLength(mbd.getScope())) {
				mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
			}

			// A bean contained in a non-singleton bean cannot be a singleton itself.
			// Let's correct this on the fly here, since this might be the result of
			// parent-child merging for the outer bean, in which case the original inner bean
			// definition will not have inherited the merged outer bean's singleton status.
			if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
				mbd.setScope(containingBd.getScope());
			}

			// Cache the merged bean definition for the time being
			// (it might still get re-merged later on in order to pick up metadata changes)
			if (containingBd == null && isCacheBeanMetadata()) {
				// 最后将合并后的bd放入mergedBeanDefinitions集合中
				this.mergedBeanDefinitions.put(beanName, mbd);
			}
		}

		return mbd;
	}
}

简单的流程如下：

1. 找到父bd，如果没有找到就直接将自身当作父bd，找到的话就看看父bd有没有父bd，并且通过getMergedBeanDefinition方法得到父bd合并之后的bd。
2. 合并bd，通过父bd创建出一个RootBeanDefinition对象，然后子bd覆盖父bd创建出来的对象（覆盖属性之类的）。
3. 将合并后的bd放入一个mergedBeanDefinitions集合中，最后将合并后的bd返回。

在其中我们需要注意其中几个地方：

• 合并后的bd是用RootBeanDefinition接收的，这也是为什么RootBeanDefinition到现在的版本依然还在使用，因为它还应用在合并bd的操作中。
• 需要注意不论有没有父bd都会发生合并的操作，而且父bd的合并可能在这其中执行。