概述
面向资源(XML、Properties)、面向注解定义的 Bean 是如何被解析成 BeanDefinition(Bean 的“前身”),并保存至 BeanDefinitionRegistry 注册中心里面,实际也是通过 ConcurrentHashMap 进行保存。
Spring 底层 IoC 容器 DefaultListableBeanFactory,实现了 BeanFactory 和 BeanDefinitionRegistry 接口,这个时候它处于“就绪状态”,当我们显示或者隐式地调用 getBean(...) 方法时,会触发加载 Bean 阶段,获取对应的 Bean。在该方法中,如果是单例模式会先从缓存中获取,已有则直接返回,没有则根据 BeanDefinition 开始创建这个 Bean。
主体流程:getBean doGetBean createBean doCreateBean createBeanInstance、instantiate、populateBean、initializeBean、registerDisposableBeanIfNecessary(注册销毁方法)
手写Spring源码:参考我的学习手写纪录
https://gitee.com/JavaBigDataStudy/framework-handwriting
BeanFactory 体系结构
下来熟悉下Sprig容器BeanFactory的体系
![](https://img-blog.csdnimg.cn/img_convert/38a875ece3d1787e31bbc99e17219c6c.png)
org.springframework.beans.factory.BeanFactory,Spring IoC 容器最基础的接口,提供依赖查找单个 Bean 的功能
org.springframework.beans.factory.ListableBeanFactory,继承 BeanFactory 接口,提供依赖查找多个 Bean 的功能
org.springframework.beans.factory.HierarchicalBeanFactory,继承 BeanFactory 接口,提供获取父 BeanFactory 的功能,具有层次性
org.springframework.beans.factory.config.ConfigurableBeanFactory,继承 HierarchicalBeanFactory 接口,提供可操作内部相关组件的功能,具有可配置性
org.springframework.beans.factory.config.AutowireCapableBeanFactory,继承 BeanFactory 接口,提供可注入的功能,支持依赖注入
org.springframework.beans.factory.config.ConfigurableListableBeanFactory,继承上面所有接口,综合所有特性,还提供可提前初始化所有单例 Bean 的功能
org.springframework.beans.factory.support.DefaultListableBeanFactory,Spring 底层 IoC 容器,依赖注入的底层实现
getBean(String name) 方法,根据名称获取 Bean,当然还有许多重载方法
最终都会调用
doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) 方法
下面是编程方法获取Bean对象的方法
// 创建 BeanFactory 容器
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
// XML 配置文件 ClassPath 路径
String location = "classpath:dependency-lookup-context.xml";
// 加载配置
int beanDefinitionsCount = reader.loadBeanDefinitions(location);
System.out.println("Bean 定义加载的数量:" + beanDefinitionsCount);
// 依赖查找
System.out.println(beanFactory.getBean("user","1","jack2"));
按照这个代码调试整理成下图的流程图
下图是关于doGetBean 方法这一层的执行逻辑。其他的核心方法后面在更新文章。
![](https://img-blog.csdnimg.cn/img_convert/51f0edd58bb64dacc05461bec625a2fb.png)
![](https://img-blog.csdnimg.cn/img_convert/f570627d3e0431ca45d3d098fd000624.png)
总结
可以看到这个方法加载 Bean 的过程中,会先从缓存中获取单例模式的 Bean;
不管是从缓存中获取的还是新创建的,都会进行处理,如果是 FactoryBean 类型则调用其 getObject() 获取目标对象;
BeanFactory 可能有父容器,如果当前容器找不到 BeanDefinition 则会尝试让父容器创建;
创建 Bean 的任务交由 AbstractAutowireCapableBeanFactory 去完成;
如果获取到的 Bean 不是我们想要类型,会通过类型转换机制转换成目标类型
获取 beanName
从缓存中获取单例 Bean
// AbstractBeanFactory#doGetBean(...) 方法
Object sharedInstance = getSingleton(beanName);
单例模式的 Bean 被创建后会缓存,为了避免循环依赖注入,在创建过程会临时缓存正在创建的 Bean(早期 Bean),从缓存中获取对象过程如下:
// DefaultSingletonBeanRegistry.java
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// <1> **【一级 Map】**从单例缓存 `singletonObjects` 中获取 beanName 对应的 Bean
Object singletonObject = this.singletonObjects.get(beanName);
// <2> 如果**一级 Map**中不存在,且当前 beanName 正在创建
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// <2.1> 对 `singletonObjects` 加锁
synchronized (this.singletonObjects) {
// <2.2> **【二级 Map】**从 `earlySingletonObjects` 集合中获取,里面会保存从 **三级 Map** 获取到的正在初始化的 Bean
singletonObject = this.earlySingletonObjects.get(beanName);
// <2.3> 如果**二级 Map** 中不存在,且允许提前创建
if (singletonObject == null && allowEarlyReference) {
// <2.3.1> **【三级 Map】**从 `singletonFactories` 中获取对应的 ObjectFactory 实现类
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
// 如果从**三级 Map** 中存在对应的对象,则进行下面的处理
if (singletonFactory != null) {
// <2.3.2> 调用 ObjectFactory#getOject() 方法,获取目标 Bean 对象(早期半成品)
singletonObject = singletonFactory.getObject();
// <2.3.3> 将目标对象放入**二级 Map**
this.earlySingletonObjects.put(beanName, singletonObject);
// <2.3.4> 从**三级 Map**移除 `beanName`
this.singletonFactories.remove(beanName);
}
}
}
}
// <3> 返回从缓存中获取的对象
return singletonObject;
}
【一级 Map】从单例缓存 singletonObjects 中获取 beanName 对应的 Bean
如果一级 Map中不存在,且当前 beanName 正在创建
对 singletonObjects 加锁
【二级 Map】从 earlySingletonObjects 集合中获取,里面会保存从 三级 Map 获取到的正在初始化的 Bean
如果二级 Map 中不存在,且允许提前创建
【三级 Map】从 singletonFactories 中获取对应的 ObjectFactory 实现类,如果从三级 Map 中存在对应的对象,则进行下面的处理
调用 ObjectFactory#getOject() 方法,获取目标 Bean 对象(早期半成品)
将目标对象放入二级 Map
从三级 Map移除 beanName
返回从缓存中获取的对象
FactoryBean 的处理
一般情况下,Spring 通过反射机制利用 Bean 的 beanClass 属性指定实现类来实例化 Bean。某些情况下,Bean 的实例化过程比较复杂,如果按照传统的方式,则需要提供大量的配置信息,配置方式的灵活性有限,这时采用编码的方式可能会得到一个简单的方案。Spring 为此提供了一个 FactoryBean 的工厂 Bean 接口,用户可以通过实现该接口定制实例化 Bean 的逻辑。
FactoryBean 接口对于 Spring 框架本身也非常重要,其内部就提供了大量 FactoryBean 的实现。它们隐藏了实例化过程中一些复杂细节,给上层应用带来了便利
// AbstractBeanFactory#doGetBean(...) 方法
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
不管是从缓存中获取的还是新创建的,都会调用这个方法进行处理,如果是 FactoryBean 类型则调用其 getObject() 获取目标对象 (FactoryBean 类型 Bean 的名称(& 开头) 所以需要处理)
getObjectForBeanInstance 方法
// AbstractBeanFactory.java
protected Object getObjectForBeanInstance( Object beanInstance, String name, String beanName,
@Nullable RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
// <1> 若 `name` 以 `&` 开头,说明想要获取 FactoryBean,则校验其**正确性**
if (BeanFactoryUtils.isFactoryDereference(name)) {
// <1.1> 如果是 NullBean 空对象,则直接返回
if (beanInstance instanceof NullBean) {
return beanInstance;
}
// <1.2> 如果不是 FactoryBean 类型,则抛出异常
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
}
// Now we have the bean instance, which may be a normal bean or a FactoryBean.
// If it's a FactoryBean, we use it to create a bean instance, unless the caller actually wants a reference to the factory.
// 到这里我们就有了一个 Bean,可能是一个正常的 Bean,也可能是一个 FactoryBean
// 如果是 FactoryBean,则需要通过其 getObject() 方法获取目标对象
// <2> 如果 `beanInstance` 不是 FactoryBean 类型,不需要再处理则直接返回
// 或者(表示是 FactoryBean 类型) `name` 以 `&` 开头,表示你想要获取实际 FactoryBean 对象,则直接返回
// 还不符合条件的话,表示是 FactoryBean,需要获取 getObject() 返回目标对象
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
// <3> 如果入参没有传 BeanDefinition,则从 `factoryBeanObjectCache` 缓存中获取对应的 Bean 对象
// 入参传了 BeanDefinition 表示这个 Bean 是刚创建的,不走缓存,需要调用其 getObject() 方法获取目标对象
// `factoryBeanObjectCache`:FactoryBean#getObject() 调用一次后返回的目标对象缓存在这里
if (mbd == null) {
object = getCachedObjectForFactoryBean(beanName);
}
// <4> 若第 `3` 步获取的对象为空,则需要调用 FactoryBean#getObject() 获得对象
if (object == null) {
// Return bean instance from factory.
// <4.1> 将 `beanInstance` 转换成 FactoryBean 类型
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
// <4.2> 如果入参没有传 BeanDefinition 并且当前容器存在对应的 BeanDefinition
if (mbd == null && containsBeanDefinition(beanName)) {
// 获取对应的 RootBeanDefinition(合并后)
mbd = getMergedLocalBeanDefinition(beanName);
}
// 是否是用户定义的(不是 Spring 创建解析出来的)
boolean synthetic = (mbd != null && mbd.isSynthetic());
// <4.3> **【核心】**通过 FactoryBean 获得目标对象,单例模式会缓存在 `factoryBeanObjectCache` 中
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
若 name 以 & 开头,说明想要获取 FactoryBean,则校验其正确性
如果是 NullBean 空对象,则直接返回
如果不是 FactoryBean 类型,则抛出异常
如果 beanInstance 不是 FactoryBean 类型,不需要再处理则直接返回;或者(表示是 FactoryBean 类型) name 以 & 开头,表示你想要获取实际 FactoryBean 对象,则直接返回;还不符合条件的话,表示是 FactoryBean,需要获取 getObject() 返回目标对象,往下处理
如果入参没有传 BeanDefinition,则从 factoryBeanObjectCache 缓存中获取对应的 Bean 对象,如下:
// FactoryBeanRegistrySupport.java
protected Object getCachedObjectForFactoryBean(String beanName) {
return this.factoryBeanObjectCache.get(beanName);
}
factoryBeanObjectCache:FactoryBean#getObject() 调用一次后返回的目标对象缓存在这里
入参传了 BeanDefinition 表示这个 Bean 是刚创建的,不走缓存,需要调用其 getObject() 方法获取目标对象
若第 3 步获取的对象为空,则需要调用 FactoryBean#getObject() 获得对象
将 beanInstance 转换成 FactoryBean 类型
如果入参没有传 BeanDefinition 并且当前容器存在对应的 BeanDefinition,则获取对应的 RootBeanDefinition(合并后)
【核心】通过 FactoryBean 获得目标对象,单例模式会缓存在 factoryBeanObjectCache 中,调用 getObjectFromFactoryBean(FactoryBean<?>, String, boolean) 方法
getObjectFromFactoryBean 方法
getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) 方法,获取 FactoryBean 的目标对象,方法如下:
// FactoryBeanRegistrySupport.java
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
// <1> `factory` 为单例模式,且单例 Bean 缓存中存在 `beanName` 对应的 FactoryBean 对象
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) { // <1.1> 获取单例锁,保证安全
// <1.2> 从 `factoryBeanObjectCache` 缓存中获取 FactoryBean#getObject() 创建的目标对象
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
// <1.3> 则根据 `factory` 获取目标对象,调用 FactoryBean#getObject() 方法
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)
// <1.4> 这里再进行一次校验,看是否在缓存中存在 FactoryBean 创建的目标对象,如果有则优先从缓存中获取
// 保证 FactoryBean#getObject() 只能被调用一次
// 没有的话,则对刚获取到的目标对象进行接下来的处理
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
} else {
// <1.5> 是否需要后续处理,这个 FactoryBean 的前身 BeanDefinition 是否由 Spring 解析出来的,通常情况下都是
if (shouldPostProcess) {
// <1.5.1> 若该 FactoryBean 处于创建中,则直接返回这个目标对象,不进行接下来的处理过程
if (isSingletonCurrentlyInCreation(beanName)) {
//暂时返回未经后处理的对象,尚未存储它。
// Temporarily return non-post-processed object, not storing it yet..
return object;
}
// <1.5.2> 前置处理,将 `beanName` 标志为正在创建
beforeSingletonCreation(beanName);
try {
// <1.5.3> 对通过 FactoryBean 获取的目标对象进行后置处理
// 遍历所有的 BeanPostProcessor 的 postProcessAfterInitialization 方法(初始化的处理)
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
finally {
// <1.5.4> 后置处理,将 `beanName` 标志为不在创建中
afterSingletonCreation(beanName);
}
}
// <1.6> 如果缓存中存在 `beanName` 对应的 FactoryBean 对象
// 上面不是判断了吗?也可能在上面的处理过程会有所变化,所以这里在做一层判断
// 目的:缓存 FactoryBean 创建的目标对象,则需要保证 FactoryBean 本身这个对象存在缓存中
if (containsSingleton(beanName)) {
// <1.6.1> 将这个 FactoryBean 创建的目标对象保存至 `factoryBeanObjectCache`
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
// <1.7> 返回 FactoryBean 创建的目标对象
return object;
}
}
// <2> `factory` 非单例模式,或单例 Bean 缓存中不存在 `beanName` 对应的 FactoryBean 对象
else {
// <2.1> 则根据 `factory` 获取目标对象,调用 FactoryBean#getObject() 方法
Object object = doGetObjectFromFactoryBean(factory, beanName);
// <2.2> 是否需要后续处理,这个 FactoryBean 的前身 BeanDefinition 是否由 Spring 解析出来的,通常情况下都是
if (shouldPostProcess) {
try {
// <2.2.1> 对通过 FactoryBean 获取的目标对象进行后置处理
// 遍历所有的 BeanPostProcessor 的 postProcessAfterInitialization 方法(初始化的处理)
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
// <2.3> 返回 FactoryBean 创建的目标对象,非单例模式不会进行缓存
return object;
}
}
factory 为单例模式,且单例 Bean 缓存中存在 beanName 对应的 FactoryBean 对象
获取单例锁,保证安全
从 factoryBeanObjectCache 缓存中获取 FactoryBean#getObject() 创建的目标对象
则根据 factory 获取目标对象,调用 FactoryBean#getObject() 方法(反射机制)
这里再进行一次校验(第 1.2 已经判断过),看是否在缓存中存在 FactoryBean 创建的目标对象,如果有则优先从缓存中获取,保证 FactoryBean#getObject() 只能被调用一次;没有的话,则对刚获取到的目标对象进行接下来的处理
是否需要后续处理,这个 FactoryBean 的 BeanDefinition 是否由 Spring 解析出来的,通常情况下都是
若该 FactoryBean 处于创建中,则直接返回这个目标对象,不进行接下来的处理过程
前置处理,将 beanName 标志为正在创建
对通过 FactoryBean 获取的目标对象进行处理,遍历所有的 BeanPostProcessor 的 postProcessAfterInitialization 方法(初始化的处理)
后置处理,将 beanName 标志为不在创建中
如果缓存中存在 beanName 对应的 FactoryBean 对象,上面不是判断了吗(第 1 步判断过)?
也可能在上面的处理过程会有所变化,所以这里在做一层判断,目的:缓存 FactoryBean 创建的目标对象,则需要保证 FactoryBean 本身这个对象存在缓存中
将这个 FactoryBean 创建的目标对象保存至 factoryBeanObjectCache
返回 FactoryBean 创建的目标对象
factory 非单例模式,或单例 Bean 缓存中不存在 beanName 对应的 FactoryBean 对象
则根据 factory 获取目标对象,调用 FactoryBean#getObject() 方法(反射机制)
是否需要后续处理,这个 FactoryBean 的 BeanDefinition 是否由 Spring 解析出来的,通常情况下都是
对通过 FactoryBean 获取的目标对象进行处理,遍历所有的 BeanPostProcessor 的 postProcessAfterInitialization 方法(初始化的处理)
返回 FactoryBean 创建的目标对象,非单例模式不会进行缓存
概括:调用 FactoryBean#getObject() 获取目标对象,单例模式会缓存起来;过程中 Sping 考虑到各种情况,例如保证单例模式下 FactoryBean#getObject() 只调用一次,是否需要进行后置处理。
非单例模式依赖检查
// AbstractBeanFactory#doGetBean(...) 方法
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
protected boolean isPrototypeCurrentlyInCreation(String beanName) {
Object curVal = this.prototypesCurrentlyInCreation.get();
return (curVal != null && (curVal.equals(beanName) // 相等
|| (curVal instanceof Set && ((Set<?>) curVal).contains(beanName)))); // 包含
}
prototypesCurrentlyInCreation 中保存非单例模式下正在创建的 Bean 的名称,这里又重新创建,表示出现循环依赖,则直接抛出异常
Spring 对于非单例模式的 Bean 无法进行相关缓存,也就无法处理循环依赖的情况,选择了直接抛出异常
题外话:(缓存和提前暴露Bean 是解决循环依赖的核心)
BeanFactory 层次性加载 Bean 策略
// AbstractBeanFactory#doGetBean(...) 方法
BeanFactory parentBeanFactory = getParentBeanFactory();
// <5> 如果从当前容器中没有找到对应的 BeanDefinition,则从父容器中加载(如果存在父容器)
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
// <5.1> 获取 `beanName`,因为可能是别名,则进行处理
// 这里不需要对 `&` 进行处理,因为进入父容器重新依赖查找
String nameToLookup = originalBeanName(name);
// <5.2> 若为 AbstractBeanFactory 类型,委托父容器的 doGetBean 方法进行处理
// 否则,就是非 Spring IoC 容器,根据参数调用相应的 `getBean(...)`方法
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
如果当前 BeanFactory 没有对应的 BeanDefinition,也就无法创建 Bean,但是如果存在父 BeanFactory,则将接下来的操作交由父 BeanFactory,找不到会层层找上去,如果所有 BeanFactory 都找不到对应的 BeanDefinition 最终会抛出异常。
将 beanName 标记为已创建
// AbstractBeanFactory#doGetBean(...) 方法
// <6> 如果不是仅仅做类型检查,则表示需要创建 Bean,将 `beanName` 标记为已创建过
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
如果不是仅仅做类型检查,则调用 markBeanAsCreated(String beanName) 方法,如下:
// AbstractBeanFactory.java
protected void markBeanAsCreated(String beanName) {
// 没有创建
if (!this.alreadyCreated.contains(beanName)) {
// 加上全局锁
synchronized (this.mergedBeanDefinitions) {
// 再次检查一次:DCL 双检查模式
if (!this.alreadyCreated.contains(beanName)) {
// Let the bean definition get re-merged now that we're actually creating
// the bean... just in case some of its metadata changed in the meantime.
// 从 mergedBeanDefinitions 中删除 beanName,并在下次访问时重新创建它
clearMergedBeanDefinition(beanName);
// 添加到已创建 bean 集合中
this.alreadyCreated.add(beanName);
}
}
}
}
将这个 beanName 保存在 alreadyCreated 集合中,在后面的循环依赖检查中会使用到
获取 RootBeanDefinition
// AbstractBeanFactory#doGetBean(...) 方法
// <7> 从容器中获取 `beanName` 对应的的 RootBeanDefinition(合并后)
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查是否为抽象类
checkMergedBeanDefinition(mbd, beanName, args);
因为我们定义的 Bean 大多数都被 Spring 解析成 GenericBeanDefinition 类型,具有父子关系,则需要获取最终的 BeanDefinition;如果存在父子关系,则会进行一系列的合并,转换成 RootBeanDefinition 对象,调用 getMergedLocalBeanDefinition(String beanName) 方法,如下:
// AbstractBeanFactory.java
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
// Quick check on the concurrent map first, with minimal locking.
// 从 `mergedBeanDefinitions` 缓存中获取合并后的 RootBeanDefinition,存在则直接返回
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null) {
return mbd;
}
// 获取 BeanDefinition 并转换,如果存在父子关系则进行合并
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
throws BeanDefinitionStoreException {
return getMergedBeanDefinition(beanName, bd, null);
}
protected RootBeanDefinition getMergedBeanDefinition(
String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
throws BeanDefinitionStoreException {
// 加锁
synchronized (this.mergedBeanDefinitions) {
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) {
// 如果没有父类则直接转换成 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);
}
}
// 有父类则进行合并
else {
// Child bean definition: needs to be merged with parent.
BeanDefinition pbd;
try {
// 获取父类的对应的 BeanDefinition 对象
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.
mbd = new RootBeanDefinition(pbd);
// 父子合并
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()) {
// 放入缓存中
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
return mbd;
}
}
从 mergedBeanDefinitions 缓存中获取合并后的 RootBeanDefinition,存在则直接返回,不存在则进行后面的操作 (合并就是把父类属性方法 用子类覆盖)
获取合并后的 RootBeanDefinition 对象,逻辑并不复杂,将一些属性进行合并;这里对于父 BeanDefinition 的获取也存在层次性查找策略;注意,如果一个单例 BeanDefinition 包含在非单例 BeanDefinition,那么会变成非单例 Bean
后续还会对合并后的 RootBeanDefinition 对象进行检查,如果是抽象的,则抛出异常
依赖 Bean 的处理
// AbstractBeanFactory#doGetBean(...) 方法
// Guarantee initialization of beans that the current bean depends on.
// <8> 获取当前正在创建的 Bean 所依赖对象集合(`depends-on` 配置的依赖)
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// <8.1> 检测是否存在循环依赖,存在则抛出异常
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// <8.2> 将 `beanName` 与 `dep` 之间依赖的关系进行缓存
registerDependentBean(dep, beanName);
try {
// <8.3> 先创建好依赖的 Bean(重新调用 `getBean(...)` 方法)
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
每个 Bean 不一定是单独工作的,可以通过 depends-on 配置依赖的 Bean,其他 Bean 也可以依赖它
对于依赖的 Bean,会优先加载,所以在 Spring 的加载顺序中,在初始化某个 Bean 的时候,首先会初始化这个 Bean 的依赖对象
isDependent 方法
在初始化依赖的 Bean 之前,会调用 isDependent(String beanName, String dependentBeanName) 方法,判断是否出现循环依赖,方法如下:
DefaultSingletonBeanRegistry.java
protected boolean isDependent(String beanName, String dependentBeanName) {
synchronized (this.dependentBeanMap) {
return isDependent(beanName, dependentBeanName, null);
}
}
private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
// <1> `alreadySeen` 中已经检测过该 `beanName` 则直接返回 `false`
if (alreadySeen != null && alreadySeen.contains(beanName)) {
return false;
}
// <2> 获取最终的 `beanName`,因为可能是别名,需要进行相关处理
String canonicalName = canonicalName(beanName);
// <3> 从 `dependentBeanMap` 中获取依赖 `beanName` 的 Bean 集合
Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
// <4> 没有 Bean 依赖该 `beanName`,也就不存在循环依赖,返回 `false`
if (dependentBeans == null) {
return false;
}
// <5> 依赖 `beanName` 的 Bean 们包含 `dependentBeanName`,表示出现循环依赖,返回 `true`
if (dependentBeans.contains(dependentBeanName)) {
// `beanName` 与 `dependentBeanName` 相互依赖
return true;
}
// <6> 对依赖该 `beanName` 的 Bean 们进行检查,看它们是否与 `dependentBeanName` 存在依赖,递归处理
for (String transitiveDependency : dependentBeans) {
if (alreadySeen == null) {
alreadySeen = new HashSet<>();
}
alreadySeen.add(beanName);
if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
return true;
}
}
return false;
}
alreadySeen 中已经检测过该 beanName 则直接返回 false
获取最终的 beanName,因为可能是别名,需要进行相关处理
从 dependentBeanMap 中获取依赖 beanName 的 Bean 集合
没有 Bean 依赖该 beanName,也就不存在循环依赖,返回 false
依赖 beanName 的 Bean 们包含 dependentBeanName,表示出现循环依赖,返回 true
对依赖该 beanName 的 Bean 们进行检查,看它们是否与 dependentBeanName 存在依赖,递归处理
判断是否出现循环依赖的过程有点绕,需要花点时间理解一下。例如:现在检查 A ->(依赖)B,看是否出现循环依赖,我获取到依赖 A 的所有 Bean,看 B 是否依赖这里面的 Bean,如果出现 A -> B -> C -> A,那就出现循环依赖了。如果出现循环依赖,则会抛出异常。
registerDependentBean 方法
将 beanName 与 dep(beanName 的依赖)之间依赖的关系进行缓存,调用 registerDependentBean(String beanName, String dependentBeanName) 方法,如下:
DefaultSingletonBeanRegistry.java
public void registerDependentBean(String beanName, String dependentBeanName) {
String canonicalName = canonicalName(beanName);
// 对应关系:beanName -> 依赖 beanName 的集合 (其他Bean依赖你的)
synchronized (this.dependentBeanMap) {
、// 不存在对应key 会添加value
Set<String> dependentBeans = this.dependentBeanMap.computeIfAbsent(canonicalName,
k -> new LinkedHashSet<>(8));
if (!dependentBeans.add(dependentBeanName)) {
return;
}
}
// 对应关系:beanName - > beanName 的依赖的集合 (你依赖其他bean的)
synchronized (this.dependenciesForBeanMap) {
Set<String> dependenciesForBean = this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName,
k -> new LinkedHashSet<>(8));
dependenciesForBean.add(canonicalName);
}
}
dependentBeanMap和dependenciesForBean相互相反的依赖含义
将两者的依赖关系保存起来,目的是在 isDependent 方法中判断是否出现循环依赖(会调用它判断)
循环获取依赖的Bean 调用getBean方法加载 beanName 依赖的 Bean,同样是调用 AbstractBeanFactory#getBean(String dep) 方法
不同作用域的 Bean 的创建
单例模式
// AbstractBeanFactory#doGetBean(...) 方法
if (mbd.isSingleton()) { // <9.1> 单例模式
/*
* <9.1.1> 创建 Bean,成功创建则进行缓存,并移除缓存的早期对象
* 创建过程实际调用的下面这个 `createBean(...)` 方法
*/
sharedInstance = getSingleton(beanName,
// ObjectFactory 实现类
() -> {
try {
// **【核心】** 创建 Bean
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
// 如果创建过程出现异常,则显式地从缓存中删除当前 Bean 相关信息
// 在单例模式下为了解决循环依赖,创建过程会缓存早期对象,这里需要进行删除
destroySingleton(beanName);
throw ex;
}
});
// <9.1.2> 获取 Bean 的目标对象,`scopedInstance` 非 FactoryBean 类型直接返回
// 否则,调用 FactoryBean#getObject() 获取目标对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
如果是单例模式,创建过程大致如下:
调用 DefaultSingletonBeanRegistry#getSingleton(String beanName, ObjectFactory<?> singletonFactory) 方法
创建 Bean,成功创建则进行缓存,并移除缓存的早期对象,创建过程实际调用的下面这个 AbstractAutowireCapableBeanFactory#createBean(...) 方法
FactoryBean 的处理。
getSingleton 方法
DefaultSingletonBeanRegistry#getSingleton(String beanName, ObjectFactory<?> singletonFactory) 方法,单例模式下获取单例 Bean,如下:
// DefaultSingletonBeanRegistry.java
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
// 全局加锁
synchronized (this.singletonObjects) {
// <1> 从 `singletonObjects` 单例 Bean 的缓存中获取 Bean(再检查一遍),存在则直接返回,否则开始创建
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
// <2> 将 `beanName` 标记为单例模式正在创建
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
/**
* <3> 创建 Bean,实际调用
* {@link AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])} 方法
*/
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// <4> 将 `beanName` 标记为不在创建中,照应第 `2` 步
afterSingletonCreation(beanName);
}
// <5> 如果这里是新创建的单例模式 Bean,则在 `singletonObjects` 中进行缓存(无序),移除缓存的早期对象
// 并在 `registeredSingletons` 中保存 `beanName`,保证注册顺序
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
从 singletonObjects 单例 Bean 的缓存中获取 Bean(再检查一遍),存在则直接返回,否则开始创建
将 beanName 标记为单例模式正在创建
【核心】创建 Bean,实际调用 AbstractAutowireCapableBeanFactory#createBean(...) 方法
将 beanName 标记为不在创建中,照应第 2 步
如果这里是新创建的单例模式 Bean,则在 singletonObjects 中进行缓存(无序),移除缓存的早期对象,并在 registeredSingletons 中保存 beanName,保证注册顺序
createBean 方法
AbstractAutowireCapableBeanFactory#createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) 方法,创建 Bean,整个过程大致如下:
Bean 的实例化
属性赋值(包括依赖注入)
Aware 接口回调
调用初始化方法
上面涉及到 Bean 生命周期的大部分阶段
原型模式
// AbstractBeanFactory.java
// <9.2> 原型模式
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
// <9.2.1> 将 `beanName` 标记为**非单例模式**正在创建
beforePrototypeCreation(beanName);
// <9.2.2> **【核心】** 创建 Bean
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
// <9.2.3> 将 `beanName` 标记为不在创建中,照应第 `9.2.1` 步
afterPrototypeCreation(beanName);
}
// <9.2.4> 获取 Bean 的目标对象,`scopedInstance` 非 FactoryBean 类型直接返回
// 否则,调用 FactoryBean#getObject() 获取目标对象
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
将 beanName 标记为非单例模式正在创建
【核心】创建 Bean 也是调用 AbstractAutowireCapableBeanFactory#createBean(...) 方法,这里没有缓存,每次加载 Bean 都会创建一个对象
将 beanName 标记为不在创建中,照应第 1 步
FactoryBean 的处理
其他模式
![](https://img-blog.csdnimg.cn/img_convert/27dc1af115aa95985cf52cdaab053df9.png)
过程如下:
从当前容器获取该模式的 Scope 对象 scope,不存在则抛出异常
从 scope 中获取 beanName 对应的对象(看你的具体实现),不存在则执行原型模式的四个步骤进行创建
想要自定义一个作用域,可以实现 org.springframework.beans.factory.config.Scope 接口,并往 Spring 应用上下文注册即可 这个也是一个拓展接口
类型转换
![](https://img-blog.csdnimg.cn/img_convert/9bf225aaadfec61aa6bdddf4fa7896d8.png)
如果入参 requiredType 不为空,并且 Bean 不是该类型,则需要进行类型转换,过程如下:
通过类型转换机制,将 Bean 转换成 requiredType 类型,对 Spring 的类型转换机制参考 org.springframework.core.convert.support.DefaultConversionService
我们也可以基于此做拓展的。
转换后的 Bean 为空则抛出异常
返回类型转换后的 Bean 对象
归纳拓展
对 BeanFactory 接口的体系结构进行了分析,得知 DefaultListableBeanFactory 是 BeanFactory 的最底层实现,也就是 Spring 的底层 IoC 容器。接着分析了 AbstractBeanFactory 的 getBean(...) 方法,当我们显示或者隐式地调用这个方法时,会触发 Bean 的加载。上面对 Bean 的加载过程进行了分析。
不同作用域的 Bean 的创建,底层都会调用 AbstractAutowireCapableBeanFactory 的 createBean(...)方法进行创建,创建 Bean 的过程涉及到 Bean 生命周期的大部分阶段,例如实例化阶段、属性赋值阶段、Aware 接口回调阶段、初始化阶段都是在这个方法中完成的。