- 逐行阅读Spring5.X源码（四） BeanFactory——
- 逐行阅读Spring5.X源码（五） 初探BeanFactory
- 逐行阅读Spring5.X源码（六） ClassPathBean
- 逐行阅读Spring5.X源码（一） BeanDefinitio
- 逐行阅读Spring5.X源码（二） BeanDefinitio
- 逐行阅读Spring5.X源码（三） BeanDefinitio
- 逐行阅读Spring5.X源码（番外篇）BeanDefiniti
- 逐行阅读Spring5.X源码（番外篇）AnnotatedBea
- 逐行阅读Spring5.X源码（十三）spring事务源码分析
- 逐行阅读Spring5.X源码（九）spring利用CGLIB实
BeanFactory是spring的IOC核心容器，前面我们讲了spring启动扫描业务类并封装成BeanDefinition，BeanDefinition就存储在bean工厂中，本文我们详细讲解BeanFactory家族。
继承关系
首先祭出BeanFactory家族继承关系图：
BeanFactory家族继承关系
我们对以上所有类做个详细的源码分析：
-
AliasRegistry。用于管理别名的公共接口,定义对别名的简单增删等操作。用作超级接口。
public interface AliasRegistry {
/**
* 注册表中给name注册一个别名alias
*/
void registerAlias(String name, String alias);
/**
* 移除注册表中的别名alias
*/
void removeAlias(String alias);
/**
* 校验注册表中是否存在别名name
*/
boolean isAlias(String name);
/**
* 在注册表中获取给定的所有别名信息
*/
String[] getAliases(String name);
}
-
BeanDefinitionRegistry。BeanDefinition的注册表接口，使BeanDefinition的注册表接口具有别名管理的功能。
public interface BeanDefinitionRegistry extends AliasRegistry {
/**
* 注册BeanDefinition到注册表
*/
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException;
/**
* 移除注册表中beanName的BeanDefinition
*/
void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
/**
* 获取注册表中beanName的BeanDefinition
*/
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
/**
* 检查此注册表是否包含具有给定名称的BeanDefinitio。
*/
boolean containsBeanDefinition(String beanName);
/**
* 返回此注册表中定义的所有bean的名称。
*/
String[] getBeanDefinitionNames();
/**
* 返回注册表中定义的bean的数目
*/
int getBeanDefinitionCount();
/**
* 确定给定bean名称是否已在该注册表中使用
*/
boolean isBeanNameInUse(String beanName);
}
-
SimpleAliasRegistry。实现 AliasRegistry完成别名操作，内部使用ConcurrentHashMap作为内存注册表，存储name-alias的映射关系。
public class SimpleAliasRegistry implements AliasRegistry {
//别名-规范名称的映射MAP，用于存储注册信息（内存注册表）
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
//注册表中注册别名
@Override
public void registerAlias(String name, String alias) {
//锁注册表
//因为CurrentHashMap只有put和remove是线程安全的
//此处要包装对CurrentHashMap的复合操作线程安全
synchronized (this.aliasMap) {
//判断别名与规范名称是否一样
if (alias.equals(name)) {
// 一样时，在注册表移除当前别名信息
this.aliasMap.remove(alias);
}
else {
//获取当前别名在注册表中的规范名称
String registeredName = this.aliasMap.get(alias);
if (registeredName != null) {
//规范名称存在，不需要注册，返回
if (registeredName.equals(name)) {
return;
}
//判断是否允许重写注册
if (!allowAliasOverriding()) {
throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
name + "': It is already registered for name '" + registeredName + "'.");
}
}
// 校验规范名称是否指向当前别名的
checkForAliasCircle(name, alias);
// 注册表注册别名与规范名称的映射
this.aliasMap.put(alias, name);
}
}
}
/**
* 是否允许重写注册表别名信息，默认true
*/
protected boolean allowAliasOverriding() {
return true;
}
/**
* 校验给定的name-alias映射是否已在注册表aliasMap中
*/
public boolean hasAlias(String name, String alias) {
//遍历注册表
for (Map.Entry<String, String> entry : this.aliasMap.entrySet()) {
//注册表中单映射的规范名称name
String registeredName = entry.getValue();
//判断name是否与传入name一致
if (registeredName.equals(name)) {
//获取注册表单项的别名
String registeredAlias = entry.getKey();
// hasAlias(registeredAlias, alias)) 检测是否存在循环引用
// 循环引用如下
// 注册表: A-B; C-A;D-C
// B对应的别名有ACD
// A对应的别名别名CD
// C对应的别名有D
// 是循环引用 此处需要校验
return (registeredAlias.equals(alias) || hasAlias(registeredAlias, alias));
}
}
return false;
}
/**
* 移除别名，在注册表aliasMap中
*/
@Override
public void removeAlias(String alias) {
synchronized (this.aliasMap) {
//移除别名，并判断是否移除成功
String name = this.aliasMap.remove(alias);
if (name == null) {
throw new IllegalStateException("No alias '" + alias + "' registered");
}
}
}
/**
* 校验是否包含给定的别名，在注册表中
*/
@Override
public boolean isAlias(String name) {
return this.aliasMap.containsKey(name);
}
/**
* 在注册表获取给定规范名称的所有别名信息
*/
@Override
public String[] getAliases(String name) {
List<String> result = new ArrayList<>();
synchronized (this.aliasMap) {
retrieveAliases(name, result);
}
return StringUtils.toStringArray(result);
}
/**
*
*/
private void retrieveAliases(String name, List<String> result) {
this.aliasMap.forEach((alias, registeredName) -> {
//判断当前别名的规范名称是否为要查询的
if (registeredName.equals(name)) {
result.add(alias);
//递归查询循环引用的别名
retrieveAliases(alias, result);
}
});
}
/**
*
*/
public void resolveAliases(StringValueResolver valueResolver) {
Assert.notNull(valueResolver, "StringValueResolver must not be null");
synchronized (this.aliasMap) {
Map<String, String> aliasCopy = new HashMap<>(this.aliasMap);
aliasCopy.forEach((alias, registeredName) -> {
String resolvedAlias = valueResolver.resolveStringValue(alias);
String resolvedName = valueResolver.resolveStringValue(registeredName);
if (resolvedAlias == null || resolvedName == null || resolvedAlias.equals(resolvedName)) {
this.aliasMap.remove(alias);
}
else if (!resolvedAlias.equals(alias)) {
String existingName = this.aliasMap.get(resolvedAlias);
if (existingName != null) {
if (existingName.equals(resolvedName)) {
// Pointing to existing alias - just remove placeholder
this.aliasMap.remove(alias);
return;
}
throw new IllegalStateException(
"Cannot register resolved alias '" + resolvedAlias + "' (original: '" + alias +
"') for name '" + resolvedName + "': It is already registered for name '" +
registeredName + "'.");
}
checkForAliasCircle(resolvedName, resolvedAlias);
this.aliasMap.remove(alias);
this.aliasMap.put(resolvedAlias, resolvedName);
}
else if (!registeredName.equals(resolvedName)) {
this.aliasMap.put(alias, resolvedName);
}
});
}
}
/**
* 校验给定的名称是否指向别名，不指向异常抛出
*/
protected void checkForAliasCircle(String name, String alias) {
if (hasAlias(alias, name)) {
throw new IllegalStateException("Cannot register alias '" + alias +
"' for name '" + name + "': Circular reference - '" +
name + "' is a direct or indirect alias for '" + alias + "' already");
}
}
/**
* 根据给定的别名获取规范名称
*/
public String canonicalName(String name) {
String canonicalName = name;
// Handle aliasing...
String resolvedName;
do {
//获取给定别名的规范名称，获取到跳出循环
resolvedName = this.aliasMap.get(canonicalName);
if (resolvedName != null) {
canonicalName = resolvedName;
}
}
while (resolvedName != null);
return canonicalName;
}
}
name-alias可以循环引用如: a->b ,c->a ,d->c。alias->name循环映射如下:
注册表有如下映射: A-B; C-A;D-C
1. B对应的alias有ACD
2. A对应的alias有CD
3. C对应的alias有D
例如：
public class TestMain {
public static void main(String[] args) {
SimpleAliasRegistry aliasRegistry = new SimpleAliasRegistry();
aliasRegistry.registerAlias("B", "A");
aliasRegistry.registerAlias("A", "C");
aliasRegistry.registerAlias("C", "D");
System.out.println("B的别名:" + Arrays.toString(aliasRegistry.getAliases("B")));
System.out.println("A的别名:" + Arrays.toString(aliasRegistry.getAliases("A")));
System.out.println("C的别名:" + Arrays.toString(aliasRegistry.getAliases("C")));
}
}
//打印结果：
B的别名:[A, C, D]
A的别名:[C, D]
C的别名:[D]
-
SingletonBeanRegistry。单例Bean的注册中心。
//检查此注册表是否包含具有给定名称的单例实例。
boolean containsSingleton(String beanName)
//返回在给定名称下注册的（原始）单例对象。
Object getSingleton(String beanName)
//返回在此注册表中注册的单例bean的数量。
int getSingletonCount()
//返回此注册表使用的单例互斥锁（对于外部协作者）。
Object getSingletonMutex()
//返回在此注册表中注册的单例bean的名称。
String[] getSingletonNames()
//在给定的bean名称下，在bean注册表中将给定的现有对象注册为singleton。
void registerSingleton(String beanName, Object singletonObject)
5.DefaultSingletonBeanRegistry。SingletionBean注册器的默认实现，同时继承SimpleAliasRegistry。因此这个类可以有别名注册的功能和单例bean注册的功能，并且他还支持注册DisposableBean实例;它依赖ObjectFactory接口和DisposableBean接口(关闭注册表时调用到了destroy方法)。侧重于Bean的注册,销毁,以及依赖关系(关联关系)的注册和销毁。
/**
* 共享bean实例的通用注册表，实现了SingletonBeanRegistry. 允许注册表中注册的单例应该被所有调用者共享，通过bean名称获得。
*
* 还支持登记的DisposableBean实例，（这可能会或不能正确的注册单例），关闭注册表时destroyed.
* 可以注册bean之间的依赖关系，执行适当的关闭顺序。
*
* 这个类主要用作基类的BeanFactory实现， 提供基本的管理
* singleton bean 实例功能。
*/
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
SingletonBeanRegistry {
//内部标记为一个空的单例对象： 并发 Maps( 不支持空值 )作为标志值。
protected static final Object NULL_OBJECT = new Object();
// 日记用来记录子类
protected final Log logger = LogFactory.getLog(getClass());
//是存放singleton对象的缓存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>();
// 是存放制造singleton的工厂对象的缓存
private final Map<String, ObjectFactory> singletonFactories = new HashMap<String, ObjectFactory>();
//是存放singletonFactory 制造出来的 singleton 的缓存早期单例对象缓存</span><span>
private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>();
//以上三个缓存是这个类存放单例bean的主要Map
//就是单例注册表</span><span>
private final Set<String> registeredSingletons = new LinkedHashSet<String>(
16);
//目前正在创建中的单例bean的名称的集合</span><span>
private final Set<String> singletonsCurrentlyInCreation = Collections
.synchronizedSet(new HashSet<String>());
//存放异常出现的相关的原因的集合</span><span>
private Set<Exception> suppressedExceptions;
//标志，指示我们目前是否在销毁单例中</span><span>
private boolean singletonsCurrentlyInDestruction = false;
//存放一次性bean的缓存</span><span>
private final Map<String, Object> disposableBeans = new LinkedHashMap<String, Object>();
//外部bean与被包含在外部bean的所有内部bean集合包含关系的缓存
private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<String, Set<String>>();
//指定bean与依赖指定bean的所有bean的依赖关系的缓存
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<String, Set<String>>();
//指定bean与创建这个bean所需要依赖的所有bean的依赖关系的缓存</span><span>
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<String, Set<String>>();
// SingletonBeanRegistry接口的registerSingleton方法的实现
public void registerSingleton(String beanName, Object singletonObject)
throws IllegalStateException {
Assert.notNull(beanName, "'beanName' must not be null");
synchronized (this.singletonObjects) {
Object oldObject = this.singletonObjects.get(beanName);
</span><span>//如果singletonObjects缓存找到有指定名称为beanName的对象，则表示该名称已被占用
if (oldObject != null) {
throw new IllegalStateException("Could not register object ["
+ singletonObject + "] under bean name '" + beanName
+ "': there is already object [" + oldObject
+ "] bound");
}
</span><span>//若该名称没被占用，真正的注册操作在这里实现
addSingleton(beanName, singletonObject);
}
}
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
// 因为singletonObjects类型是ConcurrentHashMap,并发Map不支持空值作为标志值，所以用NULL_OBJECT来代替
this.singletonObjects.put(beanName,
(singletonObject != null ? singletonObject : NULL_OBJECT));
// beanName已被注册存放在singletonObjects缓存，那么singletonFactories不应该再持有名称为beanName的工厂
this.singletonFactories.remove(beanName);
// beanName已被注册存放在singletonObjects缓存，那么earlySingletonObjects不应该再持有名称为beanName的bean。
this.earlySingletonObjects.remove(beanName);
// beanName放进单例注册表中
this.registeredSingletons.add(beanName);
}
}
/**
* 添加 名称为beanName的singletonFactory对象
*
*/
protected void addSingletonFactory(String beanName,
ObjectFactory singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
// 判断singletonObjects内名字为beanName是否被占用，若没有，进行注册操作
if (!this.singletonObjects.containsKey(beanName)) {
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}
// SingletonBeanRegistry接口的getSingleton方法的实现
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
// 如果singletonObjects指定beanName的对象是不存在的
if (singletonObject == null) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
// 如果earlySingletonObjects指定的beanName的对象是不存在的且allowEarlyReference是允许的
if (singletonObject == null && allowEarlyReference) {
ObjectFactory singletonFactory = this.singletonFactories
.get(beanName);
// 如果存在指定beanName的singletonFactory对象
if (singletonFactory != null) {
// singletonFactory创建指定的单例对象
singletonObject = singletonFactory.getObject();
// 这里可以看出earlySingletonObjects缓存应该是存放singletonFactory产生的singleton
this.earlySingletonObjects.put(beanName,
singletonObject);
// 这里表示指定的beanName已被占用，所以要在singletonFactories移除该名称
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
Assert.notNull(beanName, "'beanName' must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
// 如果singetonObjects缓存不存在名称为beanName的对象
if (singletonObject == null) {
// 如果目前在销毁singellton
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(
beanName,
"Singleton bean creation not allowed while the 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 recordSuppressedExceptions = (this.suppressedExceptions == null);
// 若没有，刚创建异常集合的实例
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
// 由参数给定的singletonFactory创建singleton对象,getObject方法的具体实现由ObjectFactory的子类决定
singletonObject = singletonFactory.getObject();
} catch (BeanCreationException ex) {
// 如果异常被抓取，在这里将出现异常的原因抛出
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
} finally {
// 结束前，将异常集合销毁掉
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// 单例创建之后的回调,默认的实现标志单例不要在创建了。
afterSingletonCreation(beanName);
}
// 注册创建后的单例
addSingleton(beanName, singletonObject);
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}
/**
* 注册 发生在singeton bean 实例创建之间发生的异常
*/
protected void onSuppressedException(Exception ex) {
synchronized (this.singletonObjects) {
if (this.suppressedExceptions != null) {
this.suppressedExceptions.add(ex);
}
}
}
/**
* 移除名称为beanName的单例,主要在四个集合中移除，
* 如singletonObjects,singletonFactories,earlySingletonObjects
* ,registeredSingletons
*
*/
protected void removeSingleton(String beanName) {
synchronized (this.singletonObjects) {
this.singletonObjects.remove(beanName);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.remove(beanName);
}
}
// singletonBeanRegistry接口的containsSingleton方法实现
public boolean containsSingleton(String beanName) {
return (this.singletonObjects.containsKey(beanName));
}
// singletonBeanRegistry接口的getSingletonNames方法实现
public String[] getSingletonNames() {
// 对singletonObjects加锁，可能是为了防止registeredSingletons和singletonObjects出现不一致的问题
synchronized (this.singletonObjects) {
return StringUtils.toStringArray(this.registeredSingletons);
}
}
// singletonBeanRegistry接口的getSingletonCount方法实现
public int getSingletonCount() {
synchronized (this.singletonObjects) {
return this.registeredSingletons.size();
}
}
/**
* 单例对象创建前的回调,默认实现singletonsCurrentlyInCreation集合注册正在创建的单例.
*
*/
protected void beforeSingletonCreation(String beanName) {
if (!this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
/**
* 单例创建之后的回调,默认实现singletonCurrentlyInCreation集合移除正在创建的单例</span><span>
*
*/
protected void afterSingletonCreation(String beanName) {
if (!this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName
+ "' isn't currently in creation");
}
}
/**
* 返回 存放正在创建单例的集合是否包含指定名称为beanName的单例存在
*
*/
public final boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
/**
* 一次性bean注册，存放在disponsableBeans集合中
*
*/
public void registerDisposableBean(String beanName, DisposableBean bean) {
synchronized (this.disposableBeans) {
this.disposableBeans.put(beanName, bean);
}
}
/**
* 注册两个bean之间的控制关系,例如内部bean和包含其的外部bean之间
*
*/
public void registerContainedBean(String containedBeanName,
String containingBeanName) {
synchronized (this.containedBeanMap) {
// 从containedBeanMap缓存中查找外部bean名为containingBeanName的内部bean集合
Set<String> containedBeans = this.containedBeanMap
.get(containingBeanName);
// 如果没有，刚新建一个存放内部bean的集合，并且存放在containedBeanMap缓存中
if (containedBeans == null) {
containedBeans = new LinkedHashSet<String>(8);
this.containedBeanMap.put(containingBeanName, containedBeans);
}
// 将名为containedBeanName的内部bean存放到内部bean集合
containedBeans.add(containedBeanName);
}
// 紧接着调用注册内部bean和外部bean的依赖关系的方法
registerDependentBean(containedBeanName, containingBeanName);
}
/**
* 注册给定bean的一个依赖bean，给定的bean销毁之前被销毁。
*
*/
public void registerDependentBean(String beanName, String dependentBeanName) {
// 调用SimpleAliasRegistry的canonicalName方法，这方法是将参数beanName当做别名寻找到注册名，并依此递归
String canonicalName = canonicalName(beanName);
synchronized (this.dependentBeanMap) {
// 从dependentBeanMap缓存中找到依赖名为canonicalName这个bean的 依赖bean集合
Set<String> dependentBeans = this.dependentBeanMap
.get(canonicalName);
// 如果为空，则新建一个依赖bean集合，并且存放到dependentBeanMap缓存中
if (dependentBeans == null) {
dependentBeans = new LinkedHashSet<String>(8);
this.dependentBeanMap.put(canonicalName, dependentBeans);
}
// 依赖bean集合添加参数2指定的dependentBeanName
dependentBeans.add(dependentBeanName);
}
synchronized (this.dependenciesForBeanMap) {
// 从dependenciesForBeanMap缓存中找到dependentBeanName要依赖的所有bean集合
Set<String> dependenciesForBean = this.dependenciesForBeanMap
.get(dependentBeanName);
if (dependenciesForBean == null) {
dependenciesForBean = new LinkedHashSet<String>(8);
this.dependenciesForBeanMap.put(dependentBeanName,
dependenciesForBean);
}
dependenciesForBean.add(canonicalName);
}
}
/**
* 确定是否还存在名为beanName的被依赖关系
*/
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];
}
return StringUtils.toStringArray(dependentBeans);
}
/**
* 返回指定的bean依赖于所有的bean的名称，如果有的话。
*
*/
public String[] getDependenciesForBean(String beanName) {
Set<String> dependenciesForBean = this.dependenciesForBeanMap
.get(beanName);
// 如果没有的话返回new String[0]而不是null
if (dependenciesForBean == null) {
return new String[0];
}
return dependenciesForBean.toArray(new String[dependenciesForBean
.size()]);
}
// 销毁单例
public void destroySingletons() {
if (logger.isInfoEnabled()) {
logger.info("Destroying singletons in " + this);
}
// 单例目前销毁标志开始
synchronized (this.singletonObjects) {
this.singletonsCurrentlyInDestruction = true;
}
// 销毁disponsableBeans缓存中所有单例bean
synchronized (this.disposableBeans) {
String[] disposableBeanNames = StringUtils
.toStringArray(this.disposableBeans.keySet());
for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
destroySingleton(disposableBeanNames[i]);
}
}
// containedBeanMap缓存清空,dependentBeanMap缓存清空，dependenciesForBeanMap缓存清空
this.containedBeanMap.clear();
this.dependentBeanMap.clear();
this.dependenciesForBeanMap.clear();
// singeltonObjects缓存清空，singletonFactories缓存清空，earlySingletonObjects缓存清空，registeredSingletons缓存清空
synchronized (this.singletonObjects) {
this.singletonObjects.clear();
this.singletonFactories.clear();
this.earlySingletonObjects.clear();
this.registeredSingletons.clear();
// 单例目前正在销毁标志为结束
this.singletonsCurrentlyInDestruction = false;
}
}
public void destroySingleton(String beanName) {
// Remove a registered singleton of the given name, if any.
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, DisposableBean bean) {
// Trigger destruction of dependent beans first...
// 这段代码告诉我们先移除要销毁依赖bean
Set<String> dependencies = this.dependentBeanMap.remove(beanName);
if (dependencies != null) {
if (logger.isDebugEnabled()) {
logger.debug("Retrieved dependent beans for bean '" + beanName
+ "': " + dependencies);
}
for (String dependentBeanName : dependencies) {
destroySingleton(dependentBeanName);
}
}
// Actually destroy the bean now...
// 销毁bean实例
if (bean != null) {
try {
bean.destroy();
} catch (Throwable ex) {
logger.error("Destroy method on bean with name '" + beanName
+ "' threw an exception", ex);
}
}
// Trigger destruction of contained beans...
// 从containedBeanMap缓存中移除要销毁的bean，递归移除它的包含内部bean集合
Set<String> containedBeans = this.containedBeanMap.remove(beanName);
if (containedBeans != null) {
for (String containedBeanName : containedBeans) {
destroySingleton(containedBeanName);
}
}
// Remove destroyed bean from other beans' dependencies.
// 从其它bean的依赖bean集合中移除要销毁的bean
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.
// 最后 从dependenciesForBeanMap缓存中移除要销毁的bean
this.dependenciesForBeanMap.remove(beanName);
}
/**
* Expose the singleton mutex to subclasses.
* <p>
* Subclasses should synchronize on the given Object if they perform any
* sort of extended singleton creation phase. In particular, subclasses
* should <i>not</i> have their own mutexes involved in singleton creation,
* to avoid the potential for deadlocks in lazy-init situations.
*/
protected final Object getSingletonMutex() {
return this.singletonObjects;
}
}
一看名字，就知道这是一个SingletonBean注册的地方，此类也实现了SingletonBeanRegistry接口，继承了SimpleAliasRegistry。这也可以理解，DefaultSingletonBeanRegistry既有管理SingletonBean的功能，又提供了别名的功能，那当然可以继承SimpleAliasRegistry了。
DefaultSingletonBeanRegistry是一个通用的存储共享bean实例的地方，通过bean的名字获得bean。同时，它也给提供一次性bean的注册功能。
这个类的主要作用是，给BeanFactory的实现，提供基本的管理singleton bean实例功能。
这个类中，使用了三个主要的存储器（map）来分别存储singletonObject，singletonFactory，earlySingletonObject。当注册一个singleton object的时候，会在 singletonObject 的存储器中加入此 object，而在其他的两个存储器中移除。当然，这样的行为是可以在子类中去复写的。
在 getSingleton的时候，spring的默认实现是，先从 singleton object 的存储器中去寻找，如果找不到，再从 early singleton object 存储器中寻找，再找不到，那就在寻找对应的 singleton factory，造出所需的 singleton object，然后返回。而 contains singleton 就是直接检查 singleton object 存储器了，其他的存储器不做检查。而 get singleton counts 也是统计 singleton object 的数量。
看完了代码，再仔细想想，为什么这个类要使用三个存储器呢？
我想， singletonObjects 就是直观的存储着 singleton 的，而 singletonFactories 是存储的制造 singleton 的工厂，还有一个 earlySingletonObject， 在看了代码之后，我更觉得这是一个 早期singletonFactory 制造出来的 singleton 的缓存。
-
FactoryBeanRegistrySupport。这是一个抽象类，抽象类继承了DefaultSingletonBeanRegistry类，增加了对FactoryBean的处理。
7.BeanFactory。BeanFactory是Spring IOC实现的基础,这边定义了一系列的接口，我们通过这些接口的学习，可以大致了解BeanFactory体系各接口如何分工合作。
package org.springframework.beans.factory;
public interface BeanFactory {
/**
* 用来引用一个实例，或把它和工厂产生的Bean区分开，就是说，如果一个FactoryBean的名字为a，那么，&a会得到那个Factory
*/
String FACTORY_BEAN_PREFIX = "&";
/*
* 四个不同形式的getBean方法，获取实例
*/
Object getBean(String name) throws BeansException;
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
<T> T getBean(Class<T> requiredType) throws BeansException;
Object getBean(String name, Object... args) throws BeansException;
boolean containsBean(String name); // 是否存在
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;// 是否为单实例
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;// 是否为原型（多实例）
boolean isTypeMatch(String name, Class<?> targetType)
throws NoSuchBeanDefinitionException;// 名称、类型是否匹配
Class<?> getType(String name) throws NoSuchBeanDefinitionException; // 获取类型
String[] getAliases(String name);// 根据实例的名字获取实例的别名
}
具体：
1、4个获取实例的方法。getBean的重载方法。
2、4个判断的方法。判断是否存在，是否为单例、原型，名称类型是否匹配。
3、1个获取类型的方法、一个获取别名的方法。根据名称获取类型、根据名称获取别名。一目了然！
总结：
这10个方法，很明显，这是一个典型的工厂模式的工厂接口。
-
ListableBeanFactory。顾名思义，定义查找bean的方法。
public interface ListableBeanFactory extends BeanFactory {
// 对于给定的名字是否含有BeanDefinition
boolean containsBeanDefinition(String beanName);
// 返回BeanDefinition总数
int getBeanDefinitionCount();
// 返回工厂中所有Bean的名字
String[] getBeanDefinitionNames();
//-------------------------------------------------------------------------
// 根据bean 的类型获取bean
//
// 这边的方法仅检查顶级bean.它不会检查嵌套的bean.FactoryBean创建的bean会匹配为FactoryBean而不是原始类型.
// 一样不会考虑父factory中的bean,非要用可以通过BeanFactoryUtils中的beanNamesForTypeIncludingAncestors.
// 其他方式注册的单例这边会纳入判断.
// 这个版本的getBeanNamesForType会匹配所有类型的bean,包括单例,原型,FactoryBean.返回的bean names会根据backend 配置的进行排序.
//-------------------------------------------------------------------------
String[] getBeanNamesForType(ResolvableType type);
// 获取给定类型的bean names(包括子类),通过bean 定义或者FactoryBean的getObjectType判断.
// 返回对于指定类型Bean（包括子类）的所有名字
String[] getBeanNamesForType(@Nullable Class<?> type);
/*
* 返回指定类型的名字 includeNonSingletons为false表示只取单例Bean，true则不是
* allowEagerInit为true表示立刻加载，false表示延迟加载。 注意：FactoryBeans都是立刻加载的。
*/
String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);
// 如果保护懒加载的类,FactoryBean初始化的类和工厂方法初始化的类会被初始化.就是说执行这个方法会执行对应的初始化.
// 根据类型（包括子类）返回指定Bean名和Bean的Map
<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;
<T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
throws BeansException;
// 查找使用注解的类
String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
// 根据注解类型，查找所有有这个注解的Bean名和Bean的Map
Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;
// 根据指定Bean名和注解类型查找指定的Bean
@Nullable
<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
throws NoSuchBeanDefinitionException;
}
-
HierarchicalBeanFactory。
public interface HierarchicalBeanFactory extends BeanFactory {
//返回本Bean工厂的父工厂
BeanFactory getParentBeanFactory();
//本地工厂(容器)是否包含这个Bean
boolean containsLocalBean(String name);
}
HierarchicalBeanFactory源码具体：
1、第一个方法返回本Bean工厂的父工厂。这个方法实现了工厂的分层。
2、第二个方法判断本地工厂是否包含这个Bean（忽略其他所有父工厂）。这也是分层思想的体现。
总结：这个工厂接口非常简单，实现了Bean工厂的分层。这个工厂接口也是继承自BeanFacotory，也是一个二级接口，相对于父接口，它只扩展了一个重要的功能——工厂分层。
-
AutowireCapableBeanFactory。
从宏观上看，AutowireCapableBeanFactory提供了如下能力：
- 为已经实例化的对象装配属性，这些属性对象都是Spring管理的；
- 实例化一个Bean，并自动装配，这些被装配的属性对象都是Spring管理的，但是实例化的Bean可以不被Spring管理（这点特别重要）。所以这个接口提供功能就是自动装配bean相关的。
自动装配的原对象可以不在Spring的IOC容器里，但是需要被依赖注入的成员，就必须是Spring容器管辖的Bean。此接口主要是针对框架之外，没有向Spring托管Bean的应用。通过暴露此功能，Spring框架之外的程序，也能具有自动装配的能力（此接口赋予它的）。
可以使用这个接口集成其它框架。捆绑并填充（注入）并不由Spring管理生命周期并已存在的实例。像集成WebWork的Actions 和Tapestry Page就很实用。
一般应用开发者不会使用这个接口，所以像ApplicationContext这样的外观实现类不会实现这个接口，但是提供了getAutowireCapableBeanFactory()方法允许你拿这个工具去做你需要的事。
public interface AutowireCapableBeanFactory01 extends BeanFactory {
/**
* 表明工厂没有自动装配的Bean
*/
int AUTOWIRE_NO = 0;
/**
* 表明根据名称自动装配
*/
int AUTOWIRE_BY_NAME = 1;
/**
* 表明根据类型自动装配
*/
int AUTOWIRE_BY_TYPE = 2;
/**
* 表明根据构造方法快速装配
*/
int AUTOWIRE_CONSTRUCTOR = 3;
@Deprecated
// 表明通过Bean的class的内部来自动装配 Spring3.0被弃用。
int AUTOWIRE_AUTODETECT = 4;
String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";
/**
* 创建一个指定class的实例
*/
<T> T createBean(Class<T> beanClass) throws BeansException;
/**
* 通过调用给定Bean的after-instantiation及post-processing接口，对bean进行配置
*/
void autowireBean(Object existingBean) throws BeansException;
/**
* 自动装配属性,填充属性值,使用诸如setBeanName,setBeanFactory这样的工厂回调填充属性,最好还要调用post processor
*/
Object configureBean(Object existingBean, String beanName) throws BeansException;
/**
* 创建一个指定class的实例，通过参数可以指定其自动装配模式（by-name or by-type）.
*/
Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
/**
* 通过指定的自动装配策略来初始化一个Bean
*/
Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
/**
* 通过指定的自动装配方式来对给定的Bean进行自动装配
*/
void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
throws BeansException;
/**
* 将参数中指定了那么的Bean，注入给定实例当中
*/
void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;
/**
* 初始化参数中指定的Bean，调用任何其注册的回调函数如setBeanName、setBeanFactory等。
*/
Object initializeBean(Object existingBean, String beanName) throws BeansException;
/**
* 调用参数中指定Bean的postProcessBeforeInitialization方法
*/
Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException;
/**
* 调用参数中指定Bean的postProcessAfterInitialization方法
*/
Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException;
/**
* 销毁参数中指定的Bean，同时调用此Bean上的DisposableBean和DestructionAwareBeanPostProcessors方法
*/
void destroyBean(Object existingBean);
/**
* 查找唯一符合指定类的实例，如果有，则返回实例的名字和实例本身
* 底层依赖于：BeanFactory中的getBean(Class)方法
*/
<T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;
/**
* 解析出在Factory中与指定Bean有指定依赖关系的Bean（@Autowired依赖注入的核心方法）
*/
Object resolveBeanByName(String name, DependencyDescriptor descriptor) throws BeansException;
@Nullable
Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;
@Nullable
Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;
}
-
ConfigurableBeanFactory
巨大的接口，看的我头痛，可以参考这篇博文。 -
ConfigurableListableBeanFactory。
工厂接口ConfigurableListableBeanFactory同时继承了3个接口，ListableBeanFactory、AutowireCapableBeanFactory和ConfigurableBeanFactory，提供bean definition的解析,注册功能,再对单例来个预加载(解决循环依赖问题)。
public interface ConfigurableListableBeanFactory
extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
// 设置忽略的依赖关系,注册找到的特殊依赖
void ignoreDependencyType(Class<?> type);
//忽略自动装配的依赖类型
void ignoreDependencyInterface(Class<?> ifc);
//注册一个可分解的依赖
void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);
//判断指定的Bean是否有资格作为自动装配的候选者
boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
throws NoSuchBeanDefinitionException;
//返回注册的Bean定义
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
Iterator<String> getBeanNamesIterator();
void clearMetadataCache();
// 锁定配置信息.在调用refresh时会使用到.
//暂时冻结所有的Bean配置
void freezeConfiguration();
//判断本工厂配置是否被冻结
boolean isConfigurationFrozen();
//使所有的非延迟加载的单例类都实例化。
void preInstantiateSingletons() throws BeansException;
}
13.AbstractBeanFactory。
作为一个抽象类，实现了三级接口ConfigurableBeanFactory大部分功能，牛逼的不行。参考这篇博文
14.DefaultListableBeanFactory。
以上讲的无论接口、实现类还是抽象类，最终汇合在DefaultListableBeanFactory，spring启动时候会new一个DefaultListableBeanFactory类型的bean工厂，就是IOC容器啦~重要性可想而知。参考这篇博文。
网友评论