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()
* */
