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

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

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

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

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

AliasRegistry

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

SimpleAliasRegistry

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

1
2

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

BeanDefinitionRegistry

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

SingletonBeanRegistry

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

DefaultSingletonBeanRegistry

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

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

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);

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 工厂，至于功能，还是直接看图吧，名字都很好理解

ListableBeanFactory

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

HierarchicalBeanFactory

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

ConfigurableBeanFactory

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

AutowireCapableBeanFactory

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

AbstractBeanFactory

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

AbstractAutowireCapableBeanFactory

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

ConfigurableListableBeanFactory

一个功能全面的 BeanFactory 接口

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

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

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

DefaultListableBeanFactory

一个成熟的 BeanFactory

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

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

继承了 AbstractAutowireCapableBeanFactory