上篇文章我们对注册 Bean 的核心类 BeanDefinitionRegistry 进行了探讨，这里的注册 Bean 是指保存 Bean 的相关信息，也就是将 Bean 定义成 BeanDefinition，而后放入容器中。除此之外，Spring 还提供一个统一操作单例 Bean 实例的类 SingletonBeanRegistry，通过该类可直接对单例 Bean 的实例进行存储、注册等操作。
SingletonBeanRegistry 是一个接口，其定义了操作单例 Bean 实例的少量基础方法：
public interface SingletonBeanRegistry { // 注册单例 Bean。其实就是将该 Bean 保存到一个专门存储单例 Bean 实例的Map中，Key是 beanName，Value是对应的单例 Bean 实例 void registerSingleton(String beanName, Object singletonObject); // 通过 beanName 获取该单例 Bean 实例 Object getSingleton(String beanName); // 通过 beanName 判断该单例 Bean 实例能否存在 boolean containsSingleton(String beanName); // 返回所有单例 Bean 的名称 String[] getSingletonNames(); // 返回已注册的单例 Bean 实例数量 int getSingletonCount(); // 返回当前使用的单例锁，主要提供给外部协作者使用 Object getSingletonMutex();}这个接口的核心实现类是 DefaultSingletonBeanRegistry，该类不仅实现了这些基础方法，还针对单例 Bean 扩展了许多功能，如：存储 Bean 之间的依赖关系、存储 Bean 的包含关系（外部类包含内部类）、获取 Bean 所处的状态（正在创立、创立完毕等）、回调销毁 Bean 时触发的 destroy 方法等。
下面是 DefaultSingletonBeanRegistry 类中的核心属性和方法：
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry { /********** 1、定义的少量 Map 属性，用来保存单例 Bean 实例、 Bean 的依赖关系 **********/ // 缓存单例 Bean 实例，Key 是 beanName，Value 是单例 Bean 实例 private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); // 缓存 Bean 对应的 ObjectFactory // ObjectFactory 是获取 Bean 实例的工厂，只不过这里获取的 Bean 还未完全实例化，属于提早暴露的 Bean // 该属性在处理循环依赖时使用，后续会深入探讨 private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); // 缓存 singletonFactories 属性中通过 ObjectFactory 创立的 Bean // 该属性也是在处理循环依赖时使用，后续会深入探讨 private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); // 保存已注册的单例 Bean 名称 private final Set<String> registeredSingletons = new LinkedHashSet<>(256); // 保存当前正在创立的 Bean 的名称 private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16)); // 保存当前从创立检查中排除的 Bean 的名称 private final Set<String> inCreationCheckExclusions = Collections.newSetFromMap(new ConcurrentHashMap<>(16)); ... // 当前 Bean 能否处于销毁状态 private boolean singletonsCurrentlyInDestruction = false; // 保存实现了 DisposableBean 接口的 Bean，在销毁 Bean 时，会回调该 Bean 中的 destory 方法 private final Map<String, Object> disposableBeans = new LinkedHashMap<>(); // 保存 Bean 的包含关系，key 是 Bean 的名称，value 是 Bean 里面包含的其它 Bean 名称集合 private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16); // 保存 Bean 的依赖关系：key 是 Bean 的名称，value 是依赖于该 Bean 的其它 Bean 名称集合 private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64); // 保存 Bean 的依赖关系：key 是 Bean 的名称，value 是该 Bean 所依赖的其它 Bean 名称集合 private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64); /******************************** 2、注册单例 Bean 实例及对应的实例工厂 ********************************/ // 注册单例 Bean 实例 @Override public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException { Assert.notNull(beanName, "Bean name must not be null"); Assert.notNull(singletonObject, "Singleton object must not be null"); synchronized (this.singletonObjects) { // 通过 beanName 获取 Map 中对应的单例 Bean 实例 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 方法 addSingleton(beanName, singletonObject); } } // 缓存单例 Bean 实例 protected void addSingleton(String beanName, Object singletonObject) { synchronized (this.singletonObjects) { // 将单例 Bean 实例存放至 singletonObjects 集合 this.singletonObjects.put(beanName, singletonObject); // 当 beanName 对应的 Bean 实例已被存放至 singletonObjects 集合时，singletonFactories // 和 earlySingletonObjects 集合则不能再持有 beanName 对应的 ObjectFactory 和实例 // 其中起因会在后续循环依赖的文章深入探讨 this.singletonFactories.remove(beanName); this.earlySingletonObjects.remove(beanName); // 存储 Bean 名称 this.registeredSingletons.add(beanName); } } // 缓存 Bean 对应的 ObjectFactory 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); } } } /********************************* 3、获取单例 Bean 实例 *********************************/ @Override public Object getSingleton(String beanName) { // 该方法较为复杂，在后续结合循环依赖的场景探讨 } ... /***************************** 4、对单例 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); } } // 判断 beanName 对应的单例 Bean 实例时候存在 @Override public boolean containsSingleton(String beanName) { return this.singletonObjects.containsKey(beanName); } // 返回所有单例 Bean 的 beanName @Override public String[] getSingletonNames() { synchronized (this.singletonObjects) { return StringUtils.toStringArray(this.registeredSingletons); } } // 返回单例 Bean 实例数量 @Override public int getSingletonCount() { synchronized (this.singletonObjects) { return this.registeredSingletons.size(); } } ... /*************************************** 5、 Bean 的状态 **************************************/ // beanName 对应的 Bean 能否处于实例化阶段 public boolean isCurrentlyInCreation(String beanName) { Assert.notNull(beanName, "Bean name must not be null"); return (!this.inCreationCheckExclusions.contains(beanName) && isActuallyInCreation(beanName)); } protected boolean isActuallyInCreation(String beanName) { return isSingletonCurrentlyInCreation(beanName); } public boolean isSingletonCurrentlyInCreation(String beanName) { return this.singletonsCurrentlyInCreation.contains(beanName); } // 单例 Bean 实例化前执行，将正要创立的 Bean 加入 singletonsCurrentlyInCreation 集合 protected void beforeSingletonCreation(String beanName) { if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } } // 单例 Bean 实例化后执行，从 singletonsCurrentlyInCreation 集合中移除已创立的 Bean protected void afterSingletonCreation(String beanName) { if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) { throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation"); } } ... /********************* 6、 存储 Bean 之间的关系、判断 Bean 之间的关系 *********************/ // 保存具备包含关系的 Bean（内部类与外部类） public void registerContainedBean(String containedBeanName, String containingBeanName) { synchronized (this.containedBeanMap) { Set<String> containedBeans = this.containedBeanMap.computeIfAbsent(containingBeanName, k -> new LinkedHashSet<>(8)); if (!containedBeans.add(containedBeanName)) { return; } } registerDependentBean(containedBeanName, containingBeanName); } // 保存具备依赖关系的 Bean public void registerDependentBean(String beanName, String dependentBeanName) { String canonicalName = canonicalName(beanName); synchronized (this.dependentBeanMap) { Set<String> dependentBeans = this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8)); if (!dependentBeans.add(dependentBeanName)) { return; } } synchronized (this.dependenciesForBeanMap) { Set<String> dependenciesForBean = this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8)); dependenciesForBean.add(canonicalName); } } ... /***************************** 7、 销毁 Bean 的方法 *****************************/ ...}DefaultSingletonBeanRegistry 类中的属性及方法尽管很多，但也有规律可循的，大致分为对单例 Bean 实例的操作、管理 Bean 之间关系、针对 Bean 的不同状态进行操作及销毁 Bean 的操作。
该类中的核心还是那些 Map，类中的所有方法都是对这些 Map 进行操作，而这些 Map 中存储的是不同场景下的单例 Bean 。
关于 SingletonBeanRegistry 就详情到这，其主要还是针对单例 Bean 进行操作，外部调用者统一继承该类操作单例 Bean，其主要调用者还是 DefaultListableBeanFactory，前篇文章也说过，这是我们当前上下文环境中使用的 BeanFactory 工厂类，在工厂类中执行 getBean 操作时，会调用这些方法，后续会详细探讨 getBean 操作。最后值得注意是，Spring 也是在该类中处理循环依赖问题，这部分也会在后面详细探讨。