Spring 源码阅读：XmlBeanFactory 的继承结构

XmlBeanFactory 可以说是 Spring 中一个最简单的 BeanFactory，通过它可以了解 Spring 的设计思路。

BeanFactory 管理了所有 bean 实例，这些实例包括 Singleton 的、非 Singleton 的（Prototype 类型的等等）。对于 Singleton 类型的 bean，需要保证全局唯一，因此创建完之后需要保存起来，用的时候再去获取，Singleton 的管理可以交给专门的类去做。在使用 bean 的时候，有时需要使用别名来获取 bean 实例，这样更加灵活，因此还需要有专门的类负责别名的管理。

XmlBeanFactory 是 BeanFactory 的实现类，它的继承结构如下图所示

image

其中 BeanFactory 是最核心的管理 bean 的接口，SingletonBeanRegistry 用于管理 Singleton 类型的 bean 实例，AliasRegistry 则是提供别名管理的能力。下面从这三个接口开始，看看 XmlBeanFactory 继承结构上的接口和类的作用，以及它们都提供了哪些功能或能力。

AliasRegistry

用于管理别名：注册别名、移除别名、判断是否为别名、获取所有的别名

image-20200321011750202

SimpleAliasRegistry

AliasRegistry 接口的一个简单实现，内部使用一个 map 存储别名映射关系。

1
2

/** key: 别名, value: 原名 */
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);

image-20200321012421586

BeanDefinitionRegistry

BeanDefinition 的注册中心接口，用于管理 BeanDefinition：注册 BeanDefinition、移除 BeanDefinition、获取 BeanDefinition、判断是否包含 BeanDefinition、判断给定的 bean name 是否已使用。它继承了 AliasRegistry 接口，用于提供别名管理的能力。

image-20200321012639849

SingletonBeanRegistry

SingletonBean 的注册中心接口，用于管理 SingletonBean：注册 Singleton 实例、获取 Singleton 实例、判断是否包含指定 bean name 的 Singleton 实例、获取所有 Singleton 的名字、获取所有 Singleton 的数量

image-20200321013150903

DefaultSingletonBeanRegistry

它是 SingletonBeanRegistry 接口的默认实现类，提供了管理 Singleton 类型 bean 的能力，同时还继承了 SimpleAliasRegistry 类，提供别名管理的能力。

要了解 Spring 中 Singleton 是怎么注册的、getSingleton 时循环依赖的处理，可花点时间研究下 DefaultSingletonBeanRegistry 的源码实现

image-20200321013832059

FactoryBeanRegistrySupport

FactoryBeanRegistrySupport 继承了 DefaultSingletonBeanRegistry，提供了管理 factoryBean 实例的能力。

1
2
3
4
5
6

/**
 * 保存了通过 FactoryBeans 创建的 Singleton 实例
 * key: FactoryBean name，不带前缀 & 符号
 * value: 创建的实例
 */
private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>(16);

image-20200321020824914

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

/**
 * Obtain an object to expose from the given FactoryBean.
 * @param factory the FactoryBean instance
 * @param beanName the name of the bean
 * @param shouldPostProcess whether the bean is subject to post-processing
 * @return the object obtained from the FactoryBean
 * @throws BeanCreationException if FactoryBean object creation failed
 * @see org.springframework.beans.factory.FactoryBean#getObject()
 */
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
	if (factory.isSingleton() && containsSingleton(beanName)) {
		synchronized (getSingletonMutex()) {
			Object object = this.factoryBeanObjectCache.get(beanName);
			if (object == null) {
				// 通过 FactoryBean 创建实例
				object = doGetObjectFromFactoryBean(factory, beanName);
				// Only post-process and store if not put there already during getObject() call above
				// (e.g. because of circular reference processing triggered by custom getBean calls)
				Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
				if (alreadyThere != null) {
					object = alreadyThere;
				}
				else {
					// 是否需要进行后处理
					if (shouldPostProcess) {
						// 已经在创建中了，直接返回未进行后处理的实例
						if (isSingletonCurrentlyInCreation(beanName)) {
							// Temporarily return non-post-processed object, not storing it yet..
							return object;
						}

						// 创建之前的回调
						beforeSingletonCreation(beanName);
						try {
							// 后处理
							object = postProcessObjectFromFactoryBean(object, beanName);
						}
						catch (Throwable ex) {
							throw new BeanCreationException(beanName,
									"Post-processing of FactoryBean's singleton object failed", ex);
						}
						finally {
							// 创建之后的回调
							afterSingletonCreation(beanName);
						}
					}
					if (containsSingleton(beanName)) {
						// 放到缓存中
						this.factoryBeanObjectCache.put(beanName, object);
					}
				}
			}
			return object;
		}
	}
	else {
		// 不是 singleton 的，每次都创建一个新的实例
		Object object = doGetObjectFromFactoryBean(factory, beanName);
		if (shouldPostProcess) {
			try {
				// 需要进行后处理
				object = postProcessObjectFromFactoryBean(object, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
			}
		}
		return object;
	}
}

BeanFactory

bean 工厂，至于功能，还是直接看图吧，名字都很好理解

image-20200321021259960

ListableBeanFactory

继承了 BeanFactory 接口，是它的扩展，提供了枚举所有 bean 实例的功能，而不需要根据 bean 的名字一个一个地去查找。顺便说下 Listable 的含义：能列在单子上的

image-20200321021446001

HierarchicalBeanFactory

继承了 BeanFactory 接口，用于表示有继承结构的 BeanFactory

image-20200321021737305

ConfigurableBeanFactory

提供了配置 BeanFactory 的功能，例如 setParentBeanFactory、setBeanClassLoader、setTempClassLoader、setCacheBeanMetadata、setBeanExpressionResolver、setConversionService、addPropertyEditorRegistrar、registerCustomEditor、setTypeConverter、addEmbeddedValueResolver 等等

image-20200321021919943

AutowireCapableBeanFactory

继承了 BeanFactory 接口，提供了各种 autowire 的能力

image-20200321022351776

AbstractBeanFactory

BeanFactory 的抽象基类，提供了 ConfigurableBeanFactory 接口的实现，同时还继承了 FactoryBeanRegistrySupport，可用于管理 Singleton 实例。这里类方法比较多，可多花点时间研究研究

image-20200321022750939

AbstractAutowireCapableBeanFactory

继承了 AbstractBeanFactory，具有了 ConfigurableBeanFactory 配置 BeanFactory 的能力，以及 DefaultSingletonBeanRegistry 管理 Singleton 的能力。它同时还实现了 AutowireCapableBeanFactory 接口，具有了处理 Autowire 的能力。同样很大，值得一看

image-20200321022942287

ConfigurableListableBeanFactory

一个功能全面的 BeanFactory 接口

继承了 ListableBeanFactory 接口，提供了列出 bean 的能力

继承了 AutowireCapableBeanFactory 接口，提供了 autowire 的能力

继承了 ConfigurableBeanFactory 接口，提供了配置 BeanFactory 的能力，以及管理 Singleton 的能力，还支持继承结构的 BeanFactory

image-20200321023117991

DefaultListableBeanFactory

一个成熟的 BeanFactory

实现了 BeanDefinitionRegistry 接口，提供了管理 BeanDefinition 的能力

实现了 ConfigurableListableBeanFactory 接口，提供了列出 bean、autowire、配置 BeanFactory、管理 Singleton 等能力

继承了 AbstractAutowireCapableBeanFactory

image-20200321023227845