上一篇介紹了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容器對單例類的監聽考慮之完備，令人佩服。閱讀源碼，對系統構建和功能實現的理解實在有用！嗯！要加快進度才行！