DefaultSingletonBeanRegistry源码解析

DefaultSingletonBeanRegistry是SingletionBean注册器的默认实现。

来学习下DefaultSingletonBeanRegistry的源码：

 package org.springframework.beans.factory.support;

 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;

 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.beans.factory.BeanCreationNotAllowedException;
 import org.springframework.beans.factory.BeanCurrentlyInCreationException;
 import org.springframework.beans.factory.DisposableBean;
 import org.springframework.beans.factory.ObjectFactory;
 import org.springframework.beans.factory.config.SingletonBeanRegistry;
 import org.springframework.core.SimpleAliasRegistry;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;

 /**
  * Generic registry for shared bean instances, implementing the
  * {@link org.springframework.beans.factory.config.SingletonBeanRegistry}.
  * Allows for registering singleton instances that should be shared
  * for all callers of the registry, to be obtained via bean name.
  *
  * <p>Also supports registration of
  * {@link org.springframework.beans.factory.DisposableBean} instances,
  * (which might or might not correspond to registered singletons),
  * to be destroyed on shutdown of the registry. Dependencies between
  * beans can be registered to enforce an appropriate shutdown order.
  *
  * <p>This class mainly serves as base class for
  * {@link org.springframework.beans.factory.BeanFactory} implementations,
  * factoring out the common management of singleton bean instances. Note that
  * the {@link org.springframework.beans.factory.config.ConfigurableBeanFactory}
  * interface extends the {@link SingletonBeanRegistry} interface.
  *
  * <p>Note that this class assumes neither a bean definition concept
  * nor a specific creation process for bean instances, in contrast to
  * {@link AbstractBeanFactory} and {@link DefaultListableBeanFactory}
  * (which inherit from it). Can alternatively also be used as a nested
  * helper to delegate to.
  *
  * @author Juergen Hoeller
  * @since 2.0
  * @see #registerSingleton
  * @see #registerDisposableBean
  * @see org.springframework.beans.factory.DisposableBean
  * @see org.springframework.beans.factory.config.ConfigurableBeanFactory
  */
 public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

     /**
      * Internal marker for a null singleton object:
      * used as marker value for concurrent Maps (which don't support null values).
      */
     //由于Map不能存放null，因此用一个特殊的对象表示null
     protected static final Object NULL_OBJECT = new Object();

     /** Logger available to subclasses */
     protected final Log logger = LogFactory.getLog(getClass());

     /** Cache of singleton objects: bean name --> bean instance */
     //单例Bean的缓存，bean name 对应 bean 实例
     private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

     /** Cache of singleton factories: bean name --> ObjectFactory */
     //ObjectFactory的缓存，bean name 对应 特定ObjectFactory;ObjectFactory的getObject方法返回bean的实例
     private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

     /** Cache of early singleton objects: bean name --> bean instance */
     //早期bean实例的缓存， bean name 对应 early bean instance
     private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

     /** Set of registered singletons, containing the bean names in registration order */
     //单例bean的注册表
     private final Set<String> registeredSingletons = new LinkedHashSet<String>(256);

     /** Names of beans that are currently in creation */
     //正在创建的singleton的bean name的集合
     private final Set<String> singletonsCurrentlyInCreation =
             Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));

     /** Names of beans currently excluded from in creation checks */
     //检查正在创建bean时,出去该集合中的bean
     private final Set<String> inCreationCheckExclusions =
             Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));

     /** List of suppressed Exceptions, available for associating related causes */
     //用来存储异常
     private Set<Exception> suppressedExceptions;

     /** Flag that indicates whether we're currently within destroySingletons */
     //当前是否有singleton被销毁
     private boolean singletonsCurrentlyInDestruction = false;

     /** Disposable bean instances: bean name --> disposable instance */
     //bean对应的DisposableBean， DisposableBean接口有一个destroy()。为bean指定DisposableBean,作用类似于设置destroy-method
     private final Map<String, Object> disposableBeans = new LinkedHashMap<String, Object>();

     /** Map between containing bean names: bean name --> Set of bean names that the bean contains */
     //bean包含关系的缓存：bean name  对应 该bean包含的所有bean的name
     private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<String, Set<String>>(16);

     /** Map between dependent bean names: bean name --> Set of dependent bean names */
     //bean依赖关系的缓存：bean name 对应 依赖于该bean的所有bean的name (value中bean要先于key表示的bean被销毁)
     private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<String, Set<String>>(64);

     /** Map between depending bean names: bean name --> Set of bean names for the bean's dependencies */
     //bean依赖关系的缓存：bean name 对应 该bean依赖的所有bean的name
     private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<String, Set<String>>(64);

     //注册singletion
     @Override
     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);
         }
     }

     /**
      * Add the given singleton object to the singleton cache of this factory.
      * <p>To be called for eager registration of singletons.
      * @param beanName the name of the bean
      * @param singletonObject the singleton object
      */
     //真正的注册实现
     protected void addSingleton(String beanName, Object singletonObject) {
         synchronized (this.singletonObjects) {
             //添加至单例bean的缓存中
             this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
             //已经存在该单例bean的实例，因此对应的工厂和earlySingleton不再需要
             this.singletonFactories.remove(beanName);
             this.earlySingletonObjects.remove(beanName);
             //添加进注册表
             this.registeredSingletons.add(beanName);
         }
     }

     /**
      * Add the given singleton factory for building the specified singleton
      * if necessary.
      * <p>To be called for eager registration of singletons, e.g. to be able to
      * resolve circular references.
      * @param beanName the name of the bean
      * @param singletonFactory the factory for the singleton object
      */
     //添加ObjectFactory
     protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
         Assert.notNull(singletonFactory, "Singleton factory must not be null");
         synchronized (this.singletonObjects) {
             //如果还不存在该bean的实例,则加添对应的ObjectFactory
             if (!this.singletonObjects.containsKey(beanName)) {
                 this.singletonFactories.put(beanName, singletonFactory);
                 this.earlySingletonObjects.remove(beanName);
                 this.registeredSingletons.add(beanName);
             }
         }
     }

     //获取bean实例
     @Override
     public Object getSingleton(String beanName) {
         return getSingleton(beanName, true);
     }

     /**
      * Return the (raw) singleton object registered under the given name.
      * <p>Checks already instantiated singletons and also allows for an early
      * reference to a currently created singleton (resolving a circular reference).
      * @param beanName the name of the bean to look for
      * @param allowEarlyReference whether early references should be created or not
      * @return the registered singleton object, or {@code null} if none found
      */
     protected Object getSingleton(String beanName, boolean allowEarlyReference) {
         Object singletonObject = this.singletonObjects.get(beanName);
         //如果beanName对应的实例不存在但是正在创建
         if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
             synchronized (this.singletonObjects) {
                 //获取early的bean实例
                 singletonObject = this.earlySingletonObjects.get(beanName);
                 //如果允许创建早期对象,则通过singletionFactory创建
                 if (singletonObject == null && allowEarlyReference) {
                     ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                     if (singletonFactory != null) {
                         singletonObject = singletonFactory.getObject();
                         this.earlySingletonObjects.put(beanName, singletonObject);
                         //移除对应的ObjectFactory
                         this.singletonFactories.remove(beanName);
                     }
                 }
             }
         }
         return (singletonObject != NULL_OBJECT ? singletonObject : null);
     }

     /**
      * Return the (raw) singleton object registered under the given name,
      * creating and registering a new one if none registered yet.
      * @param beanName the name of the bean
      * @param singletonFactory the ObjectFactory to lazily create the singleton
      * with, if necessary
      * @return the registered singleton object
      */
     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) {
                 //不允许在有singletion被销毁的时候创建
                 if (this.singletonsCurrentlyInDestruction) {
                     throw new BeanCreationNotAllowedException(beanName,
                             "Singleton bean creation not allowed while 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 newSingleton = false;
                 boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                 if (recordSuppressedExceptions) {
                     this.suppressedExceptions = new LinkedHashSet<Exception>();
                 }
                 try {
                     //通过ObjectFactory来获取singleton的实例
                     singletonObject = singletonFactory.getObject();
                     newSingleton = true;
                 }
                 catch (IllegalStateException ex) {
                     // Has the singleton object implicitly appeared in the meantime ->
                     // if yes, proceed with it since the exception indicates that state.
                     singletonObject = this.singletonObjects.get(beanName);
                     if (singletonObject == null) {
                         throw ex;
                     }
                 }
                 catch (BeanCreationException ex) {
                     if (recordSuppressedExceptions) {
                         for (Exception suppressedException : this.suppressedExceptions) {
                             ex.addRelatedCause(suppressedException);
                         }
                     }
                     throw ex;
                 }
                 finally {
                     if (recordSuppressedExceptions) {
                         this.suppressedExceptions = null;
                     }
                     afterSingletonCreation(beanName);
                 }
                 //创建成功，则注册实例
                 if (newSingleton) {
                     addSingleton(beanName, singletonObject);
                 }
             }
             return (singletonObject != NULL_OBJECT ? singletonObject : null);
         }
     }

     /**
      * Register an Exception that happened to get suppressed during the creation of a
      * singleton bean instance, e.g. a temporary circular reference resolution problem.
      * @param ex the Exception to register
      */
     protected void onSuppressedException(Exception ex) {
         synchronized (this.singletonObjects) {
             if (this.suppressedExceptions != null) {
                 this.suppressedExceptions.add(ex);
             }
         }
     }

     /**
      * Remove the bean with the given name from the singleton cache of this factory,
      * to be able to clean up eager registration of a singleton if creation failed.
      * @param beanName the name of the bean
      * @see #getSingletonMutex()
      */
     //删除注册的singleton
     protected void removeSingleton(String beanName) {
         synchronized (this.singletonObjects) {
             this.singletonObjects.remove(beanName);
             this.singletonFactories.remove(beanName);
             this.earlySingletonObjects.remove(beanName);
             this.registeredSingletons.remove(beanName);
         }
     }
     //是否包含指定的bean name
     @Override
     public boolean containsSingleton(String beanName) {
         return this.singletonObjects.containsKey(beanName);
     }
     //获取注册的bean name
     @Override
     public String[] getSingletonNames() {
         synchronized (this.singletonObjects) {
             return StringUtils.toStringArray(this.registeredSingletons);
         }
     }

     //获取注册的bean的数目
     @Override
     public int getSingletonCount() {
         synchronized (this.singletonObjects) {
             return this.registeredSingletons.size();
         }
     }

     public void setCurrentlyInCreation(String beanName, boolean inCreation) {
         Assert.notNull(beanName, "Bean name must not be null");
         if (!inCreation) {
             this.inCreationCheckExclusions.add(beanName);
         }
         else {
             this.inCreationCheckExclusions.remove(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);
     }

     /**
      * Return whether the specified singleton bean is currently in creation
      * (within the entire factory).
      * @param beanName the name of the bean
      */
     //判断该bean name 是否正在被创建
     public boolean isSingletonCurrentlyInCreation(String beanName) {
         return this.singletonsCurrentlyInCreation.contains(beanName);
     }

     /**
      * Callback before singleton creation.
      * <p>The default implementation register the singleton as currently in creation.
      * @param beanName the name of the singleton about to be created
      * @see #isSingletonCurrentlyInCreation
      */
     protected void beforeSingletonCreation(String beanName) {
         if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
             throw new BeanCurrentlyInCreationException(beanName);
         }
     }

     /**
      * Callback after singleton creation.
      * <p>The default implementation marks the singleton as not in creation anymore.
      * @param beanName the name of the singleton that has been created
      * @see #isSingletonCurrentlyInCreation
      */
     protected void afterSingletonCreation(String beanName) {
         if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
             throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
         }
     }

     /**
      * Add the given bean to the list of disposable beans in this registry.
      * <p>Disposable beans usually correspond to registered singletons,
      * matching the bean name but potentially being a different instance
      * (for example, a DisposableBean adapter for a singleton that does not
      * naturally implement Spring's DisposableBean interface).
      * @param beanName the name of the bean
      * @param bean the bean instance
      */
     //注册一次性Bean
     public void registerDisposableBean(String beanName, DisposableBean bean) {
         synchronized (this.disposableBeans) {
             this.disposableBeans.put(beanName, bean);
         }
     }

     /**
      * Register a containment relationship between two beans,
      * e.g. between an inner bean and its containing outer bean.
      * <p>Also registers the containing bean as dependent on the contained bean
      * in terms of destruction order.
      * @param containedBeanName the name of the contained (inner) bean
      * @param containingBeanName the name of the containing (outer) bean
      * @see #registerDependentBean
      */
     //注册Bean的包含关系，及依赖关系 containedBeanName
     public void registerContainedBean(String containedBeanName, String containingBeanName) {
         // A quick check for an existing entry upfront, avoiding synchronization...
         // 注册依赖关系
         Set<String> containedBeans = this.containedBeanMap.get(containingBeanName);
         if (containedBeans != null && containedBeans.contains(containedBeanName)) {
             return;
         }

         // No entry yet -> fully synchronized manipulation of the containedBeans Set
         synchronized (this.containedBeanMap) {
             containedBeans = this.containedBeanMap.get(containingBeanName);
             if (containedBeans == null) {
                 containedBeans = new LinkedHashSet<String>(8);
                 this.containedBeanMap.put(containingBeanName, containedBeans);
             }
             containedBeans.add(containedBeanName);
         }
         registerDependentBean(containedBeanName, containingBeanName);
     }

     /**
      * Register a dependent bean for the given bean,
      * to be destroyed before the given bean is destroyed.
      * @param beanName the name of the bean
      * @param dependentBeanName the name of the dependent bean
      */
     //注册依赖于这个bean name的
     public void registerDependentBean(String beanName, String dependentBeanName) {
         // A quick check for an existing entry upfront, avoiding synchronization...
         String canonicalName = canonicalName(beanName);
         Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
         if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) {
             return;
         }

         // No entry yet -> fully synchronized manipulation of the dependentBeans Set
         // 准备该beanName被依赖的关系
         synchronized (this.dependentBeanMap) {
             dependentBeans = this.dependentBeanMap.get(canonicalName);
             if (dependentBeans == null) {
                 dependentBeans = new LinkedHashSet<String>(8);
                 this.dependentBeanMap.put(canonicalName, dependentBeans);
             }
             dependentBeans.add(dependentBeanName);
         }
         //注册dependentBeanName的依赖关系
         synchronized (this.dependenciesForBeanMap) {
             Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
             if (dependenciesForBean == null) {
                 dependenciesForBean = new LinkedHashSet<String>(8);
                 this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
             }
             dependenciesForBean.add(canonicalName);
         }
     }

     /**
      * Determine whether the specified dependent bean has been registered as
      * dependent on the given bean or on any of its transitive dependencies.
      * @param beanName the name of the bean to check
      * @param dependentBeanName the name of the dependent bean
      * @since 4.0
      */
     protected boolean isDependent(String beanName, String dependentBeanName) {
         return isDependent(beanName, dependentBeanName, null);
     }

     private boolean isDependent(String beanName, String dependentBeanName, Set<String> alreadySeen) {
         if (alreadySeen != null && alreadySeen.contains(beanName)) {
             return false;
         }
         String canonicalName = canonicalName(beanName);
         Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
         if (dependentBeans == null) {
             return false;
         }
         if (dependentBeans.contains(dependentBeanName)) {
             return true;
         }
         //递归检查，是否存在传递性的依赖
         for (String transitiveDependency : dependentBeans) {
             if (alreadySeen == null) {
                 alreadySeen = new HashSet<String>();
             }
             alreadySeen.add(beanName);
             if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
                 return true;
             }
         }
         return false;
     }

     /**
      * Determine whether a dependent bean has been registered for the given name.
      * @param beanName the name of the bean to check
      */
     protected boolean hasDependentBean(String beanName) {
         return this.dependentBeanMap.containsKey(beanName);
     }

     /**
      * Return the names of all beans which depend on the specified bean, if any.
      * @param beanName the name of the bean
      * @return the array of dependent bean names, or an empty array if none
      */
     //返回这个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);
     }

     /**
      * Return the names of all beans that the specified bean depends on, if any.
      * @param beanName the name of the bean
      * @return the array of names of beans which the bean depends on,
      * or an empty array if none
      */
     //返回这个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()]);
     }

     //销毁全部的singletion
     public void destroySingletons() {
         if (logger.isDebugEnabled()) {
             logger.debug("Destroying singletons in " + this);
         }
         synchronized (this.singletonObjects) {
             this.singletonsCurrentlyInDestruction = true;
         }

         String[] disposableBeanNames;
         synchronized (this.disposableBeans) {
             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;
         }
     }

     /**
      * Destroy the given bean. Delegates to {@code destroyBean}
      * if a corresponding disposable bean instance is found.
      * @param beanName the name of the bean
      * @see #destroyBean
      */
     public void destroySingleton(String beanName) {
         // Remove a registered singleton of the given name, if any.
         // 清楚几个缓存
         removeSingleton(beanName);

         // Destroy the corresponding DisposableBean instance.
         // 查找该Bean对应的临时性bean
         DisposableBean disposableBean;
         synchronized (this.disposableBeans) {
             disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
         }
         destroyBean(beanName, disposableBean);
     }

     /**
      * Destroy the given bean. Must destroy beans that depend on the given
      * bean before the bean itself. Should not throw any exceptions.
      * @param beanName the name of the bean
      * @param bean the bean instance to destroy
      */
     protected void destroyBean(String beanName, DisposableBean bean) {
         // Trigger destruction of dependent beans first...
         // 返回依赖于这个beanName的所有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...
         //调用destroy方法，用来释放资源等
         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...
         // 清除需要包含这个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 name
         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.
         // 清除这个bean所依赖的缓存
         this.dependenciesForBeanMap.remove(beanName);
     }

     /**
      * Exposes the singleton mutex to subclasses and external collaborators.
      * <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.
      */
     public final Object getSingletonMutex() {
         return this.singletonObjects;
     }

 }

DefaultSingletonBeanRegistry主要是通过内部的几个map对象（SingletonFactories，earlySingletonObjects，singletonObjects）来保存注册的Bean。

对应关系是：

　　SingletonFactories维护了这个beanName的ObjectFactory。ObjectFactory通过getObject方法获取到了earlySingletonBean，然后在由earlySingletonBean成为bean的实例。

各个SingletonObject之间的关系也是由几个map对象维护（containedBeanMap，dependentBeanMap，dependenciesForBeanMap）。

containedBeanMap(被包含关系:key被value所包含)：key是被包含的bean, value则是包含该Bean的所有的bean。(在发现销毁时:value也要被销毁）

dependentBeanMap(被依赖关系:key被value锁依赖):key是被依赖的bean，value则是依赖于该bean的所有bean。（在发生销毁时：value要先于bean被销毁）

dependenciesForBeanMap(依赖关系:key依赖于value)：key表示的bean依赖于value表示的Bean。

在注册两个bean包含关系的时候，同时要注册他们的依赖关系。