上一篇介绍了BeanFactory体系的所有接口——Spring源码分析——BeanFactory体系之接口详细分析,本篇就接着介绍BeanFactory体系的抽象类和接口。

一、BeanFactory的基本类体系结构(类为主):

  上图可与 Spring源码分析——BeanFactory体系之接口详细分析 的图结合分析,一个以接口为主,一个以类为主(PS:Spring的体系结构要分析清楚,不得不曲线救国啊!不然27寸屏幕给我画估计都装不下。)。

具体:

  1、7层的类体系继承。

  2、AbstractBeanFactory实现了最重要的ConfigurableBeanFactory接口,DefaultSingletonBeanRegistry实现了SingletonBeanRegistry单例类注册接口,SimpleAliasRegistry实现了AliasRegistry别名注册接口。

  3、祖先类SimpleAliasRegistry、DefaultSingletonBeanRegistry和子孙类XmlBeanFactory、DefaultListableBeanFactory是完整的类,而中间的类FactoryBeanRegistrySupport、AbstractBeanFactory、AbstractAutowireCapableBeanFactory都是抽象类。

总结:

  具体上来说,XmlBeanFactory光是父类就有6个了,加上自身,总共7层了。实际上分析接口结构就会看到,作为IOC类工厂而言,XmlBeanFactory的类体系结构实际是从祖先AbstractBeanFactory这个类开始的,因为是它实现了BeanFactory的子接口ConfigurableBeanFactory,虽然它继承自FactoryBeanRegistrySupport,但可以说这只是工厂功能的扩充,扩展了对工厂Bean以及工厂所产生的Bean的操作。

二、简单的别名注册器——SimpleAliasRegistry

  上篇已经讲过AliasRegistry,非常简单的4个方法,体现了对别名注册的支持,而SimpleAliasRegistry就是它的简单实现。

源码:

public class SimpleAliasRegistry implements AliasRegistry {

    /*
*用一个支持高并发的ConcurrentHashMap来放置所有的别名
*/
private final Map<String, String> aliasMap = new ConcurrentHashMap<String, String>(
16); // AliasRegistry的接口方法,注册别名。不允许重复注册。
public void registerAlias(String name, String alias) {
Assert.hasText(name, "'name' must not be empty");
Assert.hasText(alias, "'alias' must not be empty");
if (alias.equals(name)) {
this.aliasMap.remove(alias);
} else {
if (!allowAliasOverriding()) {
String registeredName = this.aliasMap.get(alias);
if (registeredName != null && !registeredName.equals(name)) {
throw new IllegalStateException("Cannot register alias '"
+ alias + "' for name '" + name
+ "': It is already registered for name '"
+ registeredName + "'.");
}
}
checkForAliasCircle(name, alias);//alias不能等于name在map中最后的对应(详见checkForAliasCircle方法)
this.aliasMap.put(alias, name);//alias是key,name是value
}
} /**
* 返回是否允许Alias重写,默认为允许
*/
protected boolean allowAliasOverriding() {
return true;
} // AliasRegistry的接口方法,移除别名,如果别名未注册,则抛出异常
public void removeAlias(String alias) {
String name = this.aliasMap.remove(alias);
if (name == null) {
throw new IllegalStateException("No alias '" + alias
+ "' registered");
}
} // AliasRegistry的接口方法,给定名称判断是否为别名
public boolean isAlias(String name) {
return this.aliasMap.containsKey(name);
} // AliasRegistry的接口方法
public String[] getAliases(String name) {
List<String> result = new ArrayList<String>();
synchronized (this.aliasMap) {
retrieveAliases(name, result);
}
return StringUtils.toStringArray(result);
} /*
* 找出名字说对应的所有别名。
*/
private void retrieveAliases(String name, List<String> result) {
for (Map.Entry<String, String> entry : this.aliasMap.entrySet()) {//遍历aliasMap
String registeredName = entry.getValue();//取aliasMap的每个value
if (registeredName.equals(name)) {//如果value等于指定的这个name
String alias = entry.getKey();//取value对应的key
result.add(alias);//将alias加入
retrieveAliases(alias, result);//继续查看以alias为value的key
}
}
} /*
* 处理所有的别名,如果处理正确,把原来的用解析后的替换
*/
public void resolveAliases(StringValueResolver valueResolver) {
Assert.notNull(valueResolver, "StringValueResolver must not be null");
synchronized (this.aliasMap) {
Map<String, String> aliasCopy = new HashMap<String, String>(
this.aliasMap);
for (String alias : aliasCopy.keySet()) {
String registeredName = aliasCopy.get(alias);//取出key对应的value
String resolvedAlias = valueResolver.resolveStringValue(alias);//解析后的key
String resolvedName = valueResolver
.resolveStringValue(registeredName);//解析后的value
if (resolvedAlias.equals(resolvedName)) {//若解析后的key、name相等,就把它们从aliasMap中移除
this.aliasMap.remove(alias);
} else if (!resolvedAlias.equals(alias)) {//若解析后的key不等于原来的Key
String existingName = this.aliasMap.get(resolvedAlias);//取出解析后的key对应的value
if (existingName != null//如果不为空且不等于解析后的value,就抛出异常
&& !existingName.equals(resolvedName)) {
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);
}
}
}
} /*
* 根据name这个Key,在aliasMap中不断循环的取对应的value,如果取得到,就继续根据这个value取值,不断循环继续。
* 直到取不到,就把这个在aliasMap中无对应值的key返回。
*/
public String canonicalName(String name) {
String canonicalName = name; //规范名
// Handle aliasing...
String resolvedName;//已解析名
do {
resolvedName = this.aliasMap.get(canonicalName);//aliasMap中规范名对应的值赋值给已解析名
if (resolvedName != null) {//如果已解析名存在(即规范名在aliasMap中有对应的值)
canonicalName = resolvedName; // 这个已解析名赋值给标准名
}
} while (resolvedName != null);//不断循环,直到已解析名不存在
return canonicalName;
} /*
* 如果别名alias等于canonicalName(name)就抛出异常
*/
protected void checkForAliasCircle(String name, String alias) {
if (alias.equals(canonicalName(name))) {
throw new IllegalStateException("Cannot register alias '" + alias
+ "' for name '" + name + "': Circular reference - '"
+ name + "' is a direct or indirect alias for '" + alias
+ "' already");
}
} }

具体:

  1、1个支持高并发的ConcurrentHashMap来放置所有的别名,其中key是别名,value是真名。

  2、4个方法实现了SimpleAliasRegistry。

  3、3个用来辅助实现4个接口方法的方法。其中canonicalName(String name)的实现非常优雅,用来循环来回判断,把aliasMap中无对应值的key返回。

  4、2个添加额外功能的方法 retrieveAliases 和 resolveAliases ,前者是找出名字对应的所有别名,后者是用一个StringValueResolver处理解析所有的别名-名称。

总结:

  这是一个非常简单的别名注册器,一个简单的接口实现。不过其中包含了非常优雅的方法实现,值得一看!

三、默认单例注册类——DefaultSingletonBeanRegistry

源码:  

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    protected static final Object NULL_OBJECT = new Object();//空object

    /** Logger available to subclasses */
protected final Log logger = LogFactory.getLog(getClass()); /** 单例缓存: bean name --> bean instance */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(64); /** 单例工厂缓存: bean name --> ObjectFactory */
private final Map<String, ObjectFactory> singletonFactories = new HashMap<String, ObjectFactory>(16); /** 早期单例对象缓存: bean name --> bean instance */
private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16); /** 注册过的单例类(单例工厂) */
private final Set<String> registeredSingletons = new LinkedHashSet<String>(64); /** 即将创建的单例类 (using a ConcurrentHashMap as a Set) */
private final Map<String, Boolean> singletonsCurrentlyInCreation = new ConcurrentHashMap<String, Boolean>(16); /** 正在创建的单例类 (using a ConcurrentHashMap as a Set) */
private final Map<String, Boolean> inCreationCheckExclusions = new ConcurrentHashMap<String, Boolean>(16); /** 被压制的异常集合 */
private Set<Exception> suppressedExceptions; /** 单例类是否真正被销毁 */
private boolean singletonsCurrentlyInDestruction = false; /** Disposable接口的实例: bean name --> disposable instance */
private final Map<String, Object> = new LinkedHashMap<String, Object>(); /** bean名称和bean所有包含的Bean的名称的map: bean name --> Set of bean names that the bean contains */
private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<String, Set<String>>(16); /** bean名称和所有依赖于Bean的名称的map: bean name --> Set of dependent bean names */
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<String, Set<String>>(64); /** bean名称和bean所依赖的所有名称的map --> Set of bean names for the bean's dependencies */
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<String, Set<String>>(64); //SingletonBeanRegistry接口的实现类————注册单例Bean,不能重复注册
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);
if (oldObject != null) {
throw new IllegalStateException("Could not register object [" + singletonObject +
"] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
}
addSingleton(beanName, singletonObject);
}
} //注册一个单例类,注册之后,从singletonFactories、earlySingletonObjects中删去
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);//
this.registeredSingletons.add(beanName);//加入,注册过的单例类集合
}
} //注册一个单例工厂类,注册后从earlySingletonObjects移除
protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) { //单例工厂类不能和单例类同名
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
} //SingletonBeanRegistry接口的实现类
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
} //根据beanName返回单例类
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { // 如果取不到,且该bean正在创建
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) { // 如果从早期单例缓存中获取不到,且允许早期引用
ObjectFactory singletonFactory = this.singletonFactories.get(beanName); // 那么就从单例工厂缓存中获取单例工厂
if (singletonFactory != null) { // 如果还是获取不到,就创建一个单例工厂,并把它放进早期单例缓存中,并返回
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
} //获取指定的单例Bean,如果取不到就调用指定的singletonFactory的getObject来返回
public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
Assert.notNull(beanName, "'beanName' must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);//从单例缓存中获取
if (singletonObject == null) {
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 + "'");
}
//如果不在inCreationCheckExclusions中,且可以向singletonsCurrentlyInCreation中添加,就抛出异常
beforeSingletonCreation(beanName);
//是否有记录被压制的异常
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {//如果没有记录,即没有被压制的异常,就创建被压制的异常容器
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
singletonObject = singletonFactory.getObject();//以上都没有异常产生,那么就从指定的facgtory中取
}
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);//取成功就放进singletonObjects中
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
} //添加一个被压制的异常
protected void onSuppressedException(Exception ex) {
synchronized (this.singletonObjects) {
if (this.suppressedExceptions != null) {
this.suppressedExceptions.add(ex);
}
}
} //根据名称移除本容器中缓存的对应的单例Bean,把对应的单例从Bean集合、单例工厂集合、早期单例对象集合、注册过的单例集合都统统移除
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接口的实现类
public boolean containsSingleton(String beanName) {
return (this.singletonObjects.containsKey(beanName));
} //SingletonBeanRegistry接口的实现类
public String[] getSingletonNames() {
synchronized (this.singletonObjects) {
return StringUtils.toStringArray(this.registeredSingletons);
}
}
//SingletonBeanRegistry接口的实现类
public int getSingletonCount() {
synchronized (this.singletonObjects) {
return this.registeredSingletons.size();
}
} // 设置某个Bean是否正在创建
public void setCurrentlyInCreation(String beanName, boolean inCreation) {
Assert.notNull(beanName, "Bean name must not be null");
if (!inCreation) {
this.inCreationCheckExclusions.put(beanName, Boolean.TRUE);
}
else {
this.inCreationCheckExclusions.remove(beanName);
}
} //判断某个Bean是否正在被创建
public boolean isCurrentlyInCreation(String beanName) {
Assert.notNull(beanName, "Bean name must not be null");
return (!this.inCreationCheckExclusions.containsKey(beanName) && isActuallyInCreation(beanName));
} protected boolean isActuallyInCreation(String beanName) {
return isSingletonCurrentlyInCreation(beanName);
} //是否即将被创建
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.containsKey(beanName);
} //单例类创建开始之前调用
//如果不在正在创建的单例类集合中,且可以向即将创建的单例类中添加,就抛出异常
protected void beforeSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.containsKey(beanName) &&
this.singletonsCurrentlyInCreation.put(beanName, Boolean.TRUE) != null) {
throw new BeanCurrentlyInCreationException(beanName);
}
} //单例类创建之后调用
//如果不在正在创建的单例类中,也不在即将创建的单例类中移除失败,就抛出异常
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.containsKey(beanName) &&
!this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
} //往Disposable实例集合注册Disposable实例
public void registerDisposableBean(String beanName, DisposableBean bean) {
synchronized (this.disposableBeans) {
this.disposableBeans.put(beanName, bean);
}
} //注册一个被包含的Bean和一个包含它的Bean(子->父)
public void registerContainedBean(String containedBeanName, String containingBeanName) {
synchronized (this.containedBeanMap) {
Set<String> containedBeans = this.containedBeanMap.get(containingBeanName);
if (containedBeans == null) {
containedBeans = new LinkedHashSet<String>(8);//containedBeans的初始容量为8
this.containedBeanMap.put(containingBeanName, containedBeans);//注意!containedBeanMap的Key是父bean,value是其所包含的所有子Bean(父->子)
}
containedBeans.add(containedBeanName);
}
registerDependentBean(containedBeanName, containingBeanName);//因为包含也是依赖的一种,所以此时也要注册在dependentBeanMap中
} //给指定的Bean注册一个其依赖的Bean
public void registerDependentBean(String beanName, String dependentBeanName) {
String canonicalName = canonicalName(beanName);//在aliasMap中取规范名
synchronized (this.dependentBeanMap) { // 这里是注册依赖BeanMap,key是bean的名称,value是依赖这个bean的所有bean的名称
Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
if (dependentBeans == null) {
dependentBeans = new LinkedHashSet<String>(8);//dependentBeans的初始容量也为8
this.dependentBeanMap.put(canonicalName, dependentBeans);//dependentBeanMap中Key为beanName的规范名,value是依赖它的所有Bean的名称
}
dependentBeans.add(dependentBeanName);
}
synchronized (this.dependenciesForBeanMap) { // 这里相反,注册的是某个Bean和其所依赖的Bean的集合,key是这个beanName,value是这个Bean的依赖的所有Bean的Name
Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
if (dependenciesForBean == null) {
dependenciesForBean = new LinkedHashSet<String>(8);
this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
}
dependenciesForBean.add(canonicalName);
}
} //判断某个Bean是否被其他Bean所依赖
protected boolean hasDependentBean(String beanName) {
return this.dependentBeanMap.containsKey(beanName);
} //返回依赖于给定Bean的Bean名称的集合
public String[] getDependentBeans(String beanName) {
Set<String> dependentBeans = this.dependentBeanMap.get(beanName);
if (dependentBeans == null) {
return new String[0];
}
return StringUtils.toStringArray(dependentBeans);
} //返回某个Bean所依赖的所有Bean的名称
public String[] getDependenciesForBean(String beanName) {
Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(beanName);
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) {//首先标记,所有的单例Bean正在被销毁,那么getSingleton就无法获得单例Bean了
this.singletonsCurrentlyInDestruction = true;
} String[] disposableBeanNames;
synchronized (this.disposableBeans) {//然后把所有的disposableBean都放进数组,一个个按名称销毁
disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
}
for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
destroySingleton(disposableBeanNames[i]);
}
// 把本容器的所有的包含关系、依赖关系、被依赖关系的集合全部清空
this.containedBeanMap.clear();
this.dependentBeanMap.clear();
this.dependenciesForBeanMap.clear(); //然后把本容器的所有其他集合全部清空
synchronized (this.singletonObjects) {
this.singletonObjects.clear();
this.singletonFactories.clear();
this.earlySingletonObjects.clear();
this.registeredSingletons.clear();
this.singletonsCurrentlyInDestruction = false;
}
} //销毁某个单例Bean
public void destroySingleton(String beanName) {
// Remove a registered singleton of the given name, if any.
removeSingleton(beanName);//先把它销毁 DisposableBean disposableBean;//它相应的DisposableBean实例
synchronized (this.disposableBeans) {
disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);//从disposableBeans移除这个实例
}
destroyBean(beanName, disposableBean);
} // 销毁指定名称的Bean,且销毁依赖于它的所有Bean
protected void destroyBean(String beanName, DisposableBean bean) {
// 首先销毁依赖它的所有Bean
Set<String> dependencies = this.dependentBeanMap.remove(beanName);//取依赖于指定Bean的所有Bean
if (dependencies != null) {
if (logger.isDebugEnabled()) {
logger.debug("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
}
for (String dependentBeanName : dependencies) {
destroySingleton(dependentBeanName);//一个个销毁
}
} // 然后销毁它
if (bean != null) {
try {
bean.destroy();
}
catch (Throwable ex) {
logger.error("Destroy method on bean with name '" + beanName + "' threw an exception", ex);
}
} // 然后销毁它所包含的Bean
Set<String> containedBeans = this.containedBeanMap.remove(beanName);
if (containedBeans != null) {
for (String containedBeanName : containedBeans) {
destroySingleton(containedBeanName);
}
} // 然后把所有它依赖的Bean的依赖关系删除,首先删除dependentBeanMap中的依赖关系
synchronized (this.dependentBeanMap) {
//这样的for循环用法实在是经典
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();
}
}
} // 然后删除dependenciesForBeanMap中的依赖关系
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;
} }

具体:

  1、一个静态不可变的空对象NULL_OBJECT、一个简单的日志对象。

  2、本类有如下集合:

    (1)、一个单例缓存集合——singletonObjects

    (2)、一个单例工厂缓存集合——singletonFactories

    (3)、一个早期单例对象缓存集合——earlySingletonObjects

    (4)、一个注册过的单例类(单例工厂)集合——registeredSingletons

    (5)、一个即将创建的单例类集合——singletonsCurrentlyInCreation

    (6)、一个正在创建的单例类集合——inCreationCheckExclusions

    (7)、一个被压制的异常集合——suppressedExceptions(这种设计模式实在是经典!)

    (8)、一个判断所有单例类是否马上被销毁的标记——singletonsCurrentlyInDestruction

    (9)、一个Disposable接口(即可以自定义回收资源的接口)实例的集合——disposableBeans

    (10)、一个bean名称和bean所有包含的Bean的名称的集合——containedBeanMap

    (11)、bean名称和所有依赖于Bean的名称的集合——dependentBeanMap

    (12)、bean名称和bean所依赖的所有名称的集合——dependenciesForBeanMap

  3、2个注册单例方法,实际是暴露在外的SingletonBeanRegistry接口的实现方法registerSingleton加锁后调用另一个addSingleton方法。

  4、1个注册单例工厂的方法。单例工厂类不能和单例类同名。

  5、3个获取单例类的方法。一种是从单例类集合中获取,如果获取不到,boolean控制要么返回空对象,要么返回一个单例工厂。另一种是从单例集合中获取,如果取不到,就从指定的工厂中获取。还有一种?呵,就是暴露在外的SingletonBeanRegistry接口方法呗,直接调用第一种。

  6、1个添加被压制的异常集合中添加异常的方法,我觉得这个设计非常经典。但需要记录异常,却不想处理的时候,可以采用这种设计模式。

  7、1个移除单例的方法、1个判断是否包含单例的方法、1个返回所有单例名数组的方法、1个返回单例总数目的方法。

  8、1个设置某个Bean是否正在创建的方法、1个判断某个Bean是否正在被创建的方法、2个判断某个Bean是否即将被创建的方法(一个调用另一个,用于重写)。

  9、1个单例类创建开始之前调用的方法、1个单单例类创建之后调用的方法

  10、1个往Disposable实例集合注册Disposable实例的方法,这个是Bean销毁前的准备。

  11、1个注册一个被包含的Bean和一个包含的Bean的名称到containedBeanMap集合的方法。这个方法设置了Bean之间的包含关系。

  12、1个给指定的Bean注册一个其依赖的Bean的方法。这个方法设置了Bean自己的依赖关系。

  13、1个判断是否被依赖的方法、1个返回给定Bean名称的所有依赖的数组的方法、1个返回依赖于给定Bean的所有Bean名的数组的方法。

  14、1个销毁所有单例类的方法(这个方法居然完全没有注释,有没搞错!)、1个销毁某个单例的方法、1个// 销毁指定名称的Bean,且销毁依赖于它的所有Bean的方法。

  15、1个返回子类单例类的互斥体的方法。这个暂且待下一篇分析子类再看。

总结:

  类如其名,默认的单例注册器。这个工厂的写法实在功能丰富,为了监控到一个单例类构建过程中的方方面面,简直就是不择手段啊,居然准备了12个集合,除了一个一个被压制的异常集合,其余全是跟单例类有直接关系的。可以说,这个单例注册器监听、实现了Spring单例注册的各个过程,具体的解读分析,在上面的源代码中可以看到,读者阅读我注释过的源代码应该会很轻松。

  源码分析,路漫漫其修远啊。这个DefaultSingletonBeanRegistry实在是让我有些元气大伤。一个简单的单例注册,复杂的让人咋舌!Spring容器对单例类的监听考虑之完备,令人佩服。阅读源码,对系统构建和功能实现的理解实在有用!嗯!要加快进度才行!

最新文章

  1. ASE周会记录
  2. 删除win8的网络连接记录
  3. JavaScript高级程序设计学习笔记--基本概念
  4. 01_Swift2基础之Swift简介+创建
  5. MySQL 如何修改字符集 utf8 改为 utf8mb4
  6. Mysql-提示java.sql.SQLException: Cannot convert value &#39;0000-00-00 00:00:00&#39; from column 7 to TIMESTAMP.
  7. mysql线程缓存和表缓存
  8. linux笔记:用户管理命令和用户组管理命令
  9. .net发邮件 附件文件名乱码
  10. json xmpp
  11. 对Lucene PhraseQuery的slop的理解[转载]
  12. 浅谈:配置本地yum源(centos)
  13. MySQL的grant,revoke使用
  14. dubbo核心要点及下载(dubbo二)
  15. 【Java每日一题】20170118
  16. LeetCode算法题-Intersection of Two Linked Lists(Java实现)
  17. java远程下载图片
  18. 阿里云api调用做简单的cmdb
  19. jQuery中bind() live() delegate() on() 的区别
  20. MySQL group replication介绍

热门文章

  1. java web学习总结(六) -------------------servlet开发(二)
  2. [转载]C#中as和is关键字的用法
  3. jQuery Ion.Calendar 日期/日历
  4. canvas绘制经典折线图(一)
  5. Dynamics XRM Tools 2015 2016
  6. Google C++单元测试框架GoogleTest---GTest的Sample1和编写单元测试的步骤
  7. iOS 动画绘制线条颜色渐变的折线图
  8. Android5.0 TimePicker,DatePicker恢复成低版本滚动模式
  9. ionic 使用sqlite
  10. git操作命令