本文从已废弃的XmlBeanFactory出发，详细分析了Spring中BeanFactory系列的接口和类，包括AliasRegistry、SingletonBeanRegistry、BeanFactory、ListableBeanFactory等，以及它们在Spring容器中的作用。通过类图和示例代码，阐述了各接口功能和实现，为理解Spring源码打下基础。
目录
5.2、DefaultSingletonBeanRegistry 类
5.2、FactoryBeanRegistrySupport类
6.3、AutowireCapableBeanFactory
6.5、ConfigurableListableBeanFactory
6.7、AbstractAutowireCapableBeanFactory类
6.7、DefaultListableBeanFactory类
前言：
笔者从业两者有余，由于就业之路坎坷有缘参与过多个公司项目的开发工作，细数这些项目的架构都是直接或者间接以Spring框架为基础架构的，接触了这么长时间的Spring扪心自问对Spring的认知还是仅仅处于简单实用阶段，新年伊始突然萌生想法想要去窥探一下spring的源码，构建一个自己的知识储备，笔者打算用若干篇博文记录自己的一些笔记，为了方便以后加深理解以及和各位大神交流的想法。
目的：
- 摸清Spring流程原理
- 总结框架代码值得我们借鉴之处
一、XmlBeanFactory
1、 前提
初探Spring不易好高骛远 这里先以spring容器概念开始，这里笔者从已经废弃了的XmlBeanFactory类入手，根据其UML类图细细分析其关联的某些类接口的用处，功能。 spring 版本 5.2.1，gradle 5.6.1，JDK1.8，lombok插件
2、示例
定义一个java 并将其交由Spring管理，测试类里面获取到spring管理的实例Bean并打印其中的属性。
//依赖 spring-core spring-bean
dependencies {
testCompile group: 'junit', name: 'junit', version: '4.12'
compile group: 'org.springframework', name: 'spring-core', version: '5.2.1.RELEASE'
compile group: 'org.springframework', name: 'spring-beans', version: '5.2.1.RELEASE'
compile group: 'org.projectlombok', name: 'lombok', version: '1.18.10'
}
//定义一个实体Bean
@Data
@AllArgsConstructor
public class Student {
private String name;
}
<!-- 将Bean对象 交由spring初始化和管理 -->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="student" class="com.xiu.spring.bean.Student">
<constructor-arg name="name" value="张三" />
</bean>
</beans>
//测试类从Spring获取bean示例并使用
@Test
public void XmlBeanFactoryTest(){
XmlBeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("beans.xml"));
Student student = beanFactory.getBean("student", Student.class);
System.out.println("学生姓名："+student.getName());
}
一个简单的示例将spring容器的使用展示出来，简单分析如上代码的功能 大致分三步1、从xml中解析为Document2、最终转换为BeanDefinition类（spring中讲我们所有注册在Spring的实例转换为该类 不深究后面详解）3、实例化，容器启动完成，从spring容器中获取相应实例。从代码中我们可以看出XmlBeanFactory 是核心，下面我们来探究XmlBeanFactory 类
让我们简单了解一下如上UML类图中各个类的作用
- AliasRegistry 别名和名字管理接口 提供了注册、移除、获取、是否包含等功能
- SimpleAliasRegistry 对AliasRegistry 进行了实现 使用Map来管理别名
- BeanDefinitionRegistry 继承了AliasRegistry 实现了对BeanDefinition的注册、移除、获取、是否包含等功能
- SingletonBeanRegistry 定义对单例的注册、获取等功能
- DefaultSingletonBeanRegistry 继承SimpleAliasRegistry 并对 SingletonBeanRegistry进行了实现
- FactoryBeanRegistrySupport 继承DefaultSingletonBeanRegistry 并增加了对FactoryBean的特殊处理
- BeanFactory 获取bean 以及bean相关属性的接口
- ListableBeanFactory 继承BeanFactory 添加了一些根据 类型，名字，注解等条件获取bean、以及bean属性的方法
- HierarchicalBeanFactory 继承BeanFactory 添加了对ParentFactory 的支持
- ConfigurableBeanFactory 继承HierarchicalBeanFactory,提供了为BeanFactory 添加这个配置的方法 比如设置类加载器，异常解析器，类型转换器等
- AutowireCapableBeanFactory 提供创建bean 注入bean 设置bean后置处理器，销毁bean等方法
- AbstractBeanFactory 实现了BeanFactory 、HierarchicalBeanFactory、ConfigurableBeanFactory的绝大部分功能
- ConfigurableListableBeanFactory 提供配置文件相关的处理，以及忽略依赖和接口
- AbstractAutowireCapableBeanFactory 实现AutowireCapableBeanFactory 接口
- DefaultListableBeanFactory 实现了ConfigurableListableBeanFactory, BeanDefinitionRegistry 因为继承包含了如上的所有功能
4、AliasRegistry相关类
4.1、AliasRegistry类
| 方法 | 描述 |
| void registerAlias(String name, String alias) | 给一个名字注册一个别名 |
| void removeAlias(String alias) | 移除别名 |
| boolean isAlias(String name) | 判断名字是否含有别名 |
| String[] getAliases(String name) | 获取该名字下的所有别名 |
4.2、SimpleAliasRegistry类
SimpleAliasRegistry 该类提供了 一个Map结构来存储 名为aliasMap 的ConcurrentHashMap结构 别名和名字的对应关系 别名为key 名字为value。
| 方法 | 描述 |
| void registerAlias(String name, String alias) | 别名和名字一样 不注册 别名对应的已经存在(key一样) 名相同（value一样） 不用注册 名不同 （允许覆盖） 检查是否循环引用 A->B B->A 或者 A---->B | / | / | / |/ C |
| void removeAlias(String alias) | 移除alias map.remove() |
| boolean isAlias(String name) | map集合是否包含value 为name 的记录 |
| String[] getAliases(String name) | 该方法调用retrieveAliases(String name)方法 根据名字 获取其别名 又依据别名作为新的名字 递归的调用该方法 最终获取到name所有的别名类似 A->B B->C C->D 获取name是D的别名 会获取到C,B,A 三个 |
该类同时提供了 对aliasMap进行解析精简其为解析后的别名和名字的对应关系
| resolveAliases(StringValueResolver valueResolver) | 补充： StringValueResolver 这个接口是Spring从2.5版本就开始提供的,主要是提供一个String值的解析策略 我们可以把他当做 一个字符串的解析器对alias 和name按照特定类型去解析 （比如 com.xxx.xxx.student alias 解析为student 等等） |
| String canonicalName(String name) | 实现思路 将name作为alias 获取其对应的新的name 如此循环 如果 新的name为空着说明 以前一个name作为alias的值是最初始的bean的名字 |
5、SingletonBeanRegistry相关类
5.1、 SingletonBeanRegistry接口
| 方法 | 描述 |
|
注册单例对象 |
|
获取单例对象 |
|
判断是否包含该beanName对应的单例对象 |
|
获取所有的单例名称
|
|
获取单例对象个数 |
|
获取单例互斥对象 |
5.2、DefaultSingletonBeanRegistry 类
DefaultSingletonBeanRegistry 类实现了SingletonBeanRegistry接口
DefaultSingletonBeanRegistry是一个通用的存储共享bean实例的地方，通过bean的名字获得bean。同时，它也给提供一次性bean的注册功能。
这个类的主要作用是，给BeanFactory的实现，提供基本的管理 singleton bean 实例功能。
主要存储对象有三个分别存储
singletonObjects 主要的存储单例对象集合
singletonFactories 存储创建单例对象的工厂对象
earlySingletonObjects 存储singletonObject 没有的由singletonFactory 创建出来的单例对象
主要有包含bean的三个关联关系
containedBeanMap 存储beanName 与其包含其beanName的列表 beanName的包含关系
dependentBeanMap 存储beanName 与其被依赖beanName的列表 beanName的被依赖关系
dependenciesForBeanMap 存储beanName 与其依赖beanName的列表 beanName的依赖关系
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
//缓存单例对象的列表 并发Map
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
//缓存制造单例的工厂对象 列表
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
//缓存 由制造单例的工厂对象 创建出来的singleton对象 放入的都是在工厂对象获取singleton对象的时候放入的
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
//缓存单例对象的对象名列表 使用set集合 不包含对应的对象 只保存名字
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
//目前正在创建中的单例bean的名称的集合
private final Set<String> singletonsCurrentlyInCreation = Collections
.synchronizedSet(new HashSet<String>());
//目前需要排除的单例bean的名称的集合
private final Set<String> inCreationCheckExclusions =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
//存放该类异常集合
private Set<Exception> suppressedExceptions;
//是否销毁标识
private boolean singletonsCurrentlyInDestruction = false;
//一次性的可以丢弃的实例对象集合
private final Map<String, Object> disposableBeans = new LinkedHashMap<>();
/**各个SingletonObject之间的关系也是由几个map对象维护（containedBeanMap，dependentBeanMap，dependenciesForBeanMap）。
* containedBeanMap和dependentBeanMap两者维护的关系一致 key被value列表包含 value列表依赖key
* dependenciesForBeanMap又与上面的containedBeanMap和dependentBeanMap两者 相反
* 举例 dependentBeanMap A————>[B,C,D,E] 则dependenciesForBeanMap 包含关系为 B->[A] C->[A] D->[A] E->[A]
**/
// 保存所有单例对象的包含关系 map结构 key为被包含的bean的名称 value 为集合 表明包含该key对应的bean对象的所有bean集合
private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);
//被依赖关系:key被values所依赖):key是被依赖的bean，value则是依赖于该bean的所有bean。（在发生销毁时：value要先于bean被销毁）
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
//依赖关系:key依赖于value)：key表示的bean依赖于value表示的Bean。
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
//注册单例对象 单例对象名和其本身
@Override
public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
//形参判空
Assert.notNull(beanName, "Bean name must not be null");
Assert.notNull(singletonObject, "Singleton object must not be null");
//并发同步
synchronized (this.singletonObjects) {
//从单例对象列表魂村中获取单例对象 （先判断对应的beanName 是否已经注册了Singleton对象）
Object oldObject = this.singletonObjects.get(beanName);
//已经注册了 则抛出异常
if (oldObject != null) {
throw new IllegalStateException("Could not register object [" + singletonObject +
"] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
}
//没有注册进行注册操作
addSingleton(beanName, singletonObject);
}
}
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
//向对应的缓存Singleton对象类列表中 存放注册的Singleton对象
this.singletonObjects.put(beanName, singletonObject);
//Singleton对象已经缓存 则对应的创建该Singleton对象 工厂对象可以移除了
this.singletonFactories.remove(beanName);
//疑惑？？？ 看到源码中earlySingletonObjects 在该类的getSingleton 有唯一的添加
// 但是同时也会添加到singletonObjects 注册的时候该集合应该没有beanName对应对象 为什么要删除
// beanName已被注册存放在singletonObjects缓存，
//那么earlySingletonObjects不应该再持有名称为beanName的bean
this.earlySingletonObjects.remove(beanName);
//更新注册表（beanName列表）
this.registeredSingletons.add(beanName);
}
}
//添加 Singleton对象工厂
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
//Singleton对象列表不存在对应的Singleton对象 则将创建该对象的工厂对象添加进来
if (!this.singletonObjects.containsKey(beanName)) {
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
//更新注册表（beanName列表)
// 疑问：为什么创建对象工厂也需要维护不应该在singletonObjects存放的时候添加吗？
// 解答： 在获取该beanName对象的时候会调用getSingleton()工厂对象添加进来了意味着
// Singleton对象迟早被创建
this.registeredSingletons.add(beanName);
}
}
}
@Override
@Nullable
//根据名字获取单例对象
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
@Nullable
//根据名字获取单例对象（根据allowEarlyReference标识 判断是否需要将对象存放在earlySingletonObjects列表中）
//从三级缓存中获取到对应的单例对象
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//一级缓存 从singletonObjects 获取
Object singletonObject = this.singletonObjects.get(beanName);
//如果不存在 且该对象处于正在创建中（某些对象创建比较耗时）
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
//先从 二级缓存earlySingletonObjects中获取
singletonObject = this.earlySingletonObjects.get(beanName);
//如果没有且allowEarlyReference为true 由工厂对象创建并存放到earlySingletonObjects 移除对应的工厂对象
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
//这里可以看出earlySingletonObjects缓存应该是存放singletonFactory产生的singleton
this.earlySingletonObjects.put(beanName, singletonObject);
这里表示指定的beanName已被占用，所以要在singletonFactories移除该名称
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
//根据名字获取单例对象 不存在从工厂对象中获取
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
//先从singletonObjects 获取
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 + "'");
}
//单例对象创建前的回调
beforeSingletonCreation(beanName);
boolean newSingleton = false;
//创建保存异常的列表 为了保存后面创建可能出现的异常
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//工厂创建对象
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;
}
//创建对象完成后的回调
afterSingletonCreation(beanName);
}
if (newSingleton) {
//将其添加到缓存中
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
//添加异常
protected void onSuppressedException(Exception ex) {
synchronized (this.singletonObjects) {
if (this.suppressedExceptions != null) {
this.suppressedExceptions.add(ex);
}
}
}
//移除单例对象 从三个缓存中
protected void removeSingleton(String beanName) {
synchronized (this.singletonObjects) {
this.singletonObjects.remove(beanName);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.remove(beanName);
}
}
//判断是否存在名字对应的单例对象
@Override
public boolean containsSingleton(String beanName) {
return this.singletonObjects.containsKey(beanName);
}
//获取所有注册的单例对象名字
@Override
public String[] getSingletonNames() {
synchronized (this.singletonObjects) {
return StringUtils.toStringArray(this.registeredSingletons);
}
}
//获取单例对象的个数
@Override
public int getSingletonCount() {
synchronized (this.singletonObjects) {
return this.registeredSingletons.size();
}
}
//根据inCreation 判断是否将该对象放入不创建单例对象列表 中 inCreation true 创建则将其从不创建单例对象列移除
//否则将其加入到不创建单例对象列表中
public void setCurrentlyInCreation(String beanName, boolean inCreation) {
Assert.notNull(beanName, "Bean name must not be null");
if (!inCreation) {
this.inCreationCheckExclusions.add(beanName);
}
else {
this.inCreationCheckExclusions.remove(beanName);
}
}
//判断是否是在创建中
public boolean isCurrentlyInCreation(String beanName) {
Assert.notNull(beanName, "Bean name must not be null");
//如果不在排除创建的列表中 且在创建列表中则 返回true 说明Singleton对象为正在创建对象
return (!this.inCreationCheckExclusions.contains(beanName) && isActuallyInCreation(beanName));
}
//判断对象是否在创建列表
protected boolean isActuallyInCreation(String beanName) {
return isSingletonCurrentlyInCreation(beanName);
}
//判断对象是否在创建列表
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
//Singleton对象 创建之前的回调
protected void beforeSingletonCreation(String beanName) {
//在不需要创建的实例对象列表中 且将其放入正在创建列表成功 则才能校验通过 否则抛出异常 (没理解)
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
//Singleton对象 创建之后的回调
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
//注册可以丢弃的Singleton对象
public void registerDisposableBean(String beanName, DisposableBean bean) {
synchronized (this.disposableBeans) {
this.disposableBeans.put(beanName, bean);
}
}
/**
* 维护bean与bean之间包含关系
*/
//首先containedBeanMap key为被包含的bean的名称 value为以key为成员变量的所有bean集合
//举例来说 有A,B,C,D,E,F 五个类 其中B,C,D,E,F都是用A作为成员变量
//则该containedBeanMap 中存储一条关系为 key = A value为[B,C,D,E,F]列表
public void registerContainedBean(String containedBeanName, String containingBeanName) {
synchronized (this.containedBeanMap) {
//初始化 containingBeanName key对应的关联关系 不存在 则创建一个容量为8的set集合
// map的computeIfAbsent(key,function) key不存在或者为NULL 执行funcation方法
Set<String> containedBeans =
this.containedBeanMap.computeIfAbsent(containingBeanName, k -> new LinkedHashSet<>(8));
//添加以containedBeanName（被包含bean）为成员变量的bean 到集合中
if (!containedBeans.add(containedBeanName)) {
return;
}
}
registerDependentBean(containedBeanName, containingBeanName);
}
/**
* 维护bean与bean之间依赖关系
*/
//dependentBeanMap key为被依赖的bean的名称 value为依赖key的bean集合列表
//dependenciesForBeanMap 维护有关联关系的key结合dependentBeanMap 中的key 都会在dependenciesForBeanMap维护
//与registerContainedBean(String containedBeanName, String containingBeanName)相同
public void registerDependentBean(String beanName, String dependentBeanName) {
String canonicalName = canonicalName(beanName);
synchronized (this.dependentBeanMap) {
Set<String> dependentBeans =
this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
if (!dependentBeans.add(dependentBeanName)) {
return;
}
}
synchronized (this.dependenciesForBeanMap) {
Set<String> dependenciesForBean =
this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
dependenciesForBean.add(canonicalName);
}
}
protected boolean isDependent(String beanName, String dependentBeanName) {
synchronized (this.dependentBeanMap) {
return isDependent(beanName, dependentBeanName, null);
}
}
//判断beanName 与dependentBeanName 是否有关联关系
private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
if (alreadySeen != null && alreadySeen.contains(beanName)) {
return false;
}
//获取最初始的beanName
String canonicalName = canonicalName(beanName);
//从依赖关系中获取依赖列表
Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
//没有则说明两者没依赖
if (dependentBeans == null) {
return false;
}
//有依赖
if (dependentBeans.contains(dependentBeanName)) {
return true;
}
//判断依赖是否与dependentBeanName 有关联关系
//
/**
* 举例 dependentBeanMap 中的依赖关系如下
* A ——————>B,C
* B ——————>D,E
* D ——————>F,G
* 判断 A与F有无关联关系
* 该方法判断A与G有依赖关系
*/
for (String transitiveDependency : dependentBeans) {
if (alreadySeen == null) {
alreadySeen = new HashSet<>();
}
alreadySeen.add(beanName);
if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
return true;
}
}
return false;
}
//判断bean有没有依赖关系
protected boolean hasDependentBean(String beanName) {
return this.dependentBeanMap.containsKey(beanName);
}
//获取bean的所有依赖bean
public String[] getDependentBeans(String beanName) {
Set<String> dependentBeans = this.dependentBeanMap.get(beanName);
if (dependentBeans == null) {
return new String[0];
}
synchronized (this.dependentBeanMap) {
return StringUtils.toStringArray(dependentBeans);
}
}
//获取beanName 依赖的实例对象
public String[] getDependenciesForBean(String beanName) {
Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(beanName);
if (dependenciesForBean == null) {
return new String[0];
}
synchronized (this.dependenciesForBeanMap) {
return StringUtils.toStringArray(dependenciesForBean);
}
}
//销毁所有的单例对象
public void destroySingletons() {
if (logger.isTraceEnabled()) {
logger.trace("Destroying singletons in " + this);
}
//设置销毁标识为true
synchronized (this.singletonObjects) {
this.singletonsCurrentlyInDestruction = true;
}
//获取可以丢弃的实例列表
String[] disposableBeanNames;
synchronized (this.disposableBeans) {
disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
}
for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
destroySingleton(disposableBeanNames[i]);
}
//清空关联关系的依赖
this.containedBeanMap.clear();
this.dependentBeanMap.clear();
this.dependenciesForBeanMap.clear();
clearSingletonCache();
}
//清空所有的map缓存 重置销毁标识
protected void clearSingletonCache() {
synchronized (this.singletonObjects) {
this.singletonObjects.clear();
this.singletonFactories.clear();
this.earlySingletonObjects.clear();
this.registeredSingletons.clear();
this.singletonsCurrentlyInDestruction = false;
}
}
//递归的调用销毁方法 销毁bean的时候 会先获取其依赖bean 包含bean 被依赖的bean关系 依次销毁
public void destroySingleton(String beanName) {
// Remove a registered singleton of the given name, if any.
//清除指定的bean 从三个缓存中都清除
removeSingleton(beanName);
// Destroy the corresponding DisposableBean instance.
DisposableBean disposableBean;
synchronized (this.disposableBeans) {
disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
}
destroyBean(beanName, disposableBean);
}
protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
// Trigger destruction of dependent beans first...
//如果bean依赖bean 先销毁依赖的bean
Set<String> dependencies;
synchronized (this.dependentBeanMap) {
// Within full synchronization in order to guarantee a disconnected Set
//移除缓存
dependencies = this.dependentBeanMap.remove(beanName);
}
if (dependencies != null) {
if (logger.isTraceEnabled()) {
logger.trace("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
}
for (String dependentBeanName : dependencies) {
destroySingleton(dependentBeanName);
}
}
// Actually destroy the bean now...
if (bean != null) {
try {
//执行销毁方法
bean.destroy();
}
catch (Throwable ex) {
if (logger.isWarnEnabled()) {
logger.warn("Destruction of bean with name '" + beanName + "' threw an exception", ex);
}
}
}
//销毁包含的bean
// Trigger destruction of contained beans...
Set<String> containedBeans;
synchronized (this.containedBeanMap) {
// Within full synchronization in order to guarantee a disconnected Set
containedBeans = this.containedBeanMap.remove(beanName);
}
if (containedBeans != null) {
for (String containedBeanName : containedBeans) {
destroySingleton(containedBeanName);
}
}
// Remove destroyed bean from other beans' dependencies.
//移除dependenciesForBeanMap依赖关系
synchronized (this.dependentBeanMap) {
for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
Map.Entry<String, Set<String>> entry = it.next();
Set<String> dependenciesToClean = entry.getValue();
dependenciesToClean.remove(beanName);
if (dependenciesToClean.isEmpty()) {
it.remove();
}
}
}
// Remove destroyed bean's prepared dependency information.
this.dependenciesForBeanMap.remove(beanName);
}
/**
* 获取缓存在singletonObjects map中的对象
* @return
*/
@Override
public final Object getSingletonMutex() {
return this.singletonObjects;
}
}
5.2、FactoryBeanRegistrySupport类
下面按照XmlBeanFactory的 UML类图我们继续看看他的基础类FactoryBeanRegistrySupport,该类继承DefaultSingletonBeanRegistry类 具有了 SingletonBeanRegistry 单例对象注册管理功能和SimpleAliasRegistry 简单别名管理功能
在其基础上看名字分析其为FactoryBean在spring容器中的注册提供了支持。在详细了解该类之前我们先普及一下新的陌生接口FactoryBean,以及该接口与BeanFactory的区别。
参考：https://www.iteye.com/blog/chenzehe-1481476
总结：
- BeanFactory是spring对象工厂或者说容器工厂，是实现spring容器的基础规范。
- FactoryBean是为了应对比较复制的bean对象提供的实例化的工厂bean。通过getObject()获取真正实例化的对象getObjectType() 获取bean对象的class属性，isSingeton()是否单例。
话不多说直接上代码分析
package com.xiu.spring.aliaregistry;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.beans.factory.BeanCurrentlyInCreationException;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.FactoryBeanNotInitializedException;
import org.springframework.beans.factory.support.AbstractBeanFactory;
import org.springframework.beans.factory.support.DefaultSingletonBeanRegistry;
import org.springframework.beans.factory.support.NullBean;
import org.springframework.lang.Nullable;
public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {
//缓存由FactoryBean调用getObject()获取得单例对象列表
//缓存容器为支持并发的ConcurrentHashMap类 key为创建Bean实例的beanName value为由FactoryBean创建的Bean实例
private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>(16);
//调用传入的FactoryBean的getObjectType，获取其创建的的对象class属性
@Nullable
protected Class<?> getTypeForFactoryBean(final FactoryBean<?> factoryBean) {
try {
//在java的AccessController 安全框架上下文环境中获取ObjectType
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged((PrivilegedAction<Class<?>>)
factoryBean::getObjectType, getAccessControlContext());
}
else {
//直接获取ObjectType
return factoryBean.getObjectType();
}
}
catch (Throwable ex) {
logger.info("FactoryBean threw exception from getObjectType, despite the contract saying " +
"that it should return null if the type of its object cannot be determined yet", ex);
return null;
}
}
//根据bean名字从factoryBeanObjectCache缓存对象中获取FactoryBean
protected Object getCachedObjectForFactoryBean(String beanName) {
return this.factoryBeanObjectCache.get(beanName);
}
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
//判断factory 创建的对象为单例
//且该beanName 对应的单例对象是否包含在DefaultSingletonBeanRegistry的singletonObjects缓存中
if (factory.isSingleton() && containsSingleton(beanName)) {
//getSingletonMutex 获取的同样也是DefaultSingletonBeanRegistry的singletonObjects缓存对象 对其加锁
synchronized (getSingletonMutex()) {
//先从factoryBeanObjectCache缓存中获取丹丽对虾
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
//如果缓存中没有则执行该方法进行真正的获取对象
object = doGetObjectFromFactoryBean(factory, beanName);
//TODO 这块还不明白 为什么上面已经从缓存中拿了一次 为null了 这里再获取 肯定获取不到吧
//是不是因为有些bean实例在调用该方法获取的时候还在创建阶段，实例创建比较耗时
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
//根据传入的shouldPostProcess是否允许对bean进行后置处理
if (shouldPostProcess) {
//判断如果beanName对应的bean对象正在被创建 则直接返回 不缓存
if (isSingletonCurrentlyInCreation(beanName)) {
return object;
}
//bean实例创建前的准备操作
beforeSingletonCreation(beanName);
try {
//进行bean的后置处理
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
finally {
//bean实例创建完成后的一些操作
afterSingletonCreation(beanName);
}
}
//DefaultSingletonBeanRegistry的singletonObjects缓存中有beanName对应的实例则将该实例
// 也存放在factoryBeanObjectCache 表明该对象是由FactoryBean创建的
if (containsSingleton(beanName)) {
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
return object;
}
}
else {
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;
}
}
// 执行真正的获取实例对象的操作 本质上是通过调用FactoryBean对象的getObject() 获取实例对象
//这里根据条件判断是否是在安全上下文中获取实例对象 如果获取不到抛出异常
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
throws BeanCreationException {
Object object;
try {
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
// Do not accept a null value for a FactoryBean that's not fully
// initialized yet: Many FactoryBeans just return null then.
if (object == null) {
if (isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
object = new NullBean();
}
return object;
}
/**
* Post-process the given object that has been obtained from the FactoryBean.
* The resulting object will get exposed for bean references.
* <p>The default implementation simply returns the given object as-is.
* Subclasses may override this, for example, to apply post-processors.
* @param object the object obtained from the FactoryBean.
* @param beanName the name of the bean
* @return the object to expose
* @throws org.springframework.beans.BeansException if any post-processing failed
*/
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {
return object;
}
//获取FactoryBean 判断传入beanInstance 是否为FactoryBean 不是抛出异常 是直接强转
protected FactoryBean<?> getFactoryBean(String beanName, Object beanInstance) throws BeansException {
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanCreationException(beanName,
"Bean inst
最低0.47元/天 解锁文章
扫一扫
229
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
