上一篇介绍了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容器对单例类的监听考虑之完备，令人佩服。阅读源码，对系统构建和功能实现的理解实在有用！嗯！要加快进度才行！