6.AliasRegistry和BeanFactory
站长
· 阅读数 14
BeanFactory是spring的IOC核心容器，前面我们讲了spring启动扫描业务类并封装成BeanDefinition，BeanDefinition就存储在bean工厂中，本文我们详细讲解BeanFactory家族。
继承关系
首先祭出BeanFactory家族继承关系图：
我们对以上所有类做个详细的源码分析：
AliasRegistry接口
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接口:继承了AliasRegistry
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实现类
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]
也就是通过ABCD都可以找到这一个bean
SingletonBeanRegistry接口
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)
DefaultSingletonBeanRegistry:SingletonBeanRegistry实现类
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 的缓存。
一级缓存保存的是:成品
二级缓存保存的是:半成品
三级缓存保存的是:制造 singleton 的工厂
FactoryBeanRegistrySupport:抽象类
FactoryBeanRegistrySupport。这是一个抽象类，抽象类继承了DefaultSingletonBeanRegistry类，增加了对FactoryBean的处理。
BeanFactory接口
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接口
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;
}
AbstractBeanFactory抽象类
作为一个抽象类，实现了三级接口ConfigurableBeanFactory大部分功能，牛逼的不行。参考这篇博文
DefaultListableBeanFactory:默认可查找BeanFactory实现
以上讲的无论接口、实现类还是抽象类，最终汇合在DefaultListableBeanFactory，spring启动时候会new一个DefaultListableBeanFactory类型的bean工厂，就是IOC容器啦~重要性可想而知。参考这篇博文。
DefaultListableBeanFactory继承了DefaultSingletonBeanRegistry。DefaultSingletonBeanRegistry
实例化的时机是在DefaultListableBeanFactory实例化的时候。实例化DefaultListableBeanFactory的时候需要初始化父类。因此会初始化DefaultSingletonBeanRegistry。
/**
* 而这个beanFactory是AnnotationConfigApplicationContext
* 在执行自己的构造方法this()时
* 先去执行了父类GenericApplicationContext的构造方法
* 完成了this.beanFactory = new DefaultListableBeanFactory()
* */