1.  在Spring中对单列对象存储都会使用到三级缓存，三级缓存存在的目的主要是解决循环依赖问题。只有单例才会使用到缓存，其他对象创建不会放入到缓存中

一、类继承关系

  1.    ![image.png](https://cdn.nlark.com/yuque/0/2021/png/12747730/1637720649178-3e73e573-87c9-4498-b9d9-12f0e62a9368.png#clientId=ua1080df1-5858-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=307&id=u1657407b&margin=%5Bobject%20Object%5D&name=image.png&originHeight=614&originWidth=1118&originalType=binary&ratio=1&rotation=0&showTitle=false&size=45424&status=done&style=none&taskId=u3dd02e33-34c5-4093-ad16-bda8cf7d356&title=&width=559)

二、核心类和对象

1.

Spring 三级缓存模块中核心的类：defaultSingletonBeanRegistry 三级缓存对象：

  1. singletonObjects ：一级缓存，主要存储创建后完整的bean对象
  2. singletonFactories: 三级缓存，主要存储创建后的beanFactroy对象，并存储真正的bean对象
  3. earlySingletonObjects： 二级缓存，存储bean对象
  4. registeredSingletons: 已经完成注册的对象

核心方法：

  1. registerSingleton(): 注册单例对象
  2. addSingleton(): 添加单例对象到一级缓存中
    1. 添加对象进入到一级缓存
    2. 删除二、三级缓存对象
    3. 添加bean 对象 Set 集合
  3. getSingleton(): 通过beanName 获取 bean对象

�

  1. 基本对象属性 ```java public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    / Cache of singleton objects: bean name —> bean instance */ / 一级缓存 **/ private final Map singletonObjects = new ConcurrentHashMap<>(256);

    / Cache of singleton factories: bean name —> ObjectFactory */ / 三级缓存 **/ private final Map> singletonFactories = new HashMap<>(16);

    / Cache of early singleton objects: bean name —> bean instance */ / 二级缓存 **/ private final Map earlySingletonObjects = new HashMap<>(16);

    /* Set of registered singletons, containing the bean names in registration order / // 所有单列对象集合,并按照beanName 进行排序 private final Set registeredSingletons = new LinkedHashSet<>(256);

    /* Names of beans that are currently in creation / private final Set singletonsCurrentlyInCreation =

    1.      Collections.newSetFromMap(new ConcurrentHashMap<>(16));

    /* Names of beans currently excluded from in creation checks / private final Set inCreationCheckExclusions =

    1.      Collections.newSetFromMap(new ConcurrentHashMap<>(16));

    /* List of suppressed Exceptions, available for associating related causes / @Nullable private Set suppressedExceptions;

    /* Flag that indicates whether we’re currently within destroySingletons / private boolean singletonsCurrentlyInDestruction = false;

    /* Disposable bean instances: bean name —> disposable instance / private final Map disposableBeans = new LinkedHashMap<>();

    /* Map between containing bean names: bean name —> Set of bean names that the bean contains / private final Map> containedBeanMap = new ConcurrentHashMap<>(16);

    /* Map between dependent bean names: bean name —> Set of dependent bean names / private final Map> dependentBeanMap = new ConcurrentHashMap<>(64);

    /* Map between depending bean names: bean name —> Set of bean names for the bean’s dependencies / private final Map> dependenciesForBeanMap = new ConcurrentHashMap<>(64);

}

  2. 3. 基本方法
  3.    1. 注册单列对象
  4. ```java
  5. /**
  6.      * 注册单列对象 
  7.      * @param beanName the name of the bean
  8.      * @param singletonObject the existing singleton object
  9.      * @throws IllegalStateException
  10.      */
  11.     @Override
  12.     public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
  13.         Assert.notNull(beanName, "Bean name must not be null");
  14.         Assert.notNull(singletonObject, "Singleton object must not be null");
  15.         synchronized (this.singletonObjects) {
  16.             Object oldObject = this.singletonObjects.get(beanName);
  17.             if (oldObject != null) {
  18.                 throw new IllegalStateException("Could not register object [" + singletonObject +
  19.                         "] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
  20.             }
  21.             addSingleton(beanName, singletonObject);
  22.         }
  23.     }
  25.     /**
  26.      * Add the given singleton object to the singleton cache of this factory.
  27.      * <p>To be called for eager registration of singletons.
  28.      * @param beanName the name of the bean
  29.      * @param singletonObject the singleton object
  30.      */
  31.     protected void addSingleton(String beanName, Object singletonObject) {
  32.         synchronized (this.singletonObjects) {
  33.             this.singletonObjects.put(beanName, singletonObject);
  34.             this.singletonFactories.remove(beanName);
  35.             this.earlySingletonObjects.remove(beanName);
  36.             this.registeredSingletons.add(beanName);
  37.         }
  38.     }
  40.     /**
  41.      * Add the given singleton factory for building the specified singleton
  42.      * if necessary.
  43.      * <p>To be called for eager registration of singletons, e.g. to be able to
  44.      * resolve circular references.
  45.      * @param beanName the name of the bean
  46.      * @param singletonFactory the factory for the singleton object
  47.      */
  48.     protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
  49.         Assert.notNull(singletonFactory, "Singleton factory must not be null");
  50.         synchronized (this.singletonObjects) {
  51.             if (!this.singletonObjects.containsKey(beanName)) {
  52.                 this.singletonFactories.put(beanName, singletonFactory);
  53.                 this.earlySingletonObjects.remove(beanName);
  54.                 this.registeredSingletons.add(beanName);
  55.             }
  56.         }
  57.     }

  1. 获取对象 ```java @Override @Nullable public Object getSingleton(String beanName) { return getSingleton(beanName, true); }

    /**

    • Return the (raw) singleton object registered under the given name.

    • 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 */ @Nullable protected Object getSingleton(String beanName, boolean allowEarlyReference) { Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      1. synchronized (this.singletonObjects) {
      2.     singletonObject = this.earlySingletonObjects.get(beanName);
      3.     if (singletonObject == null && allowEarlyReference) {
      4.         ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
      5.         if (singletonFactory != null) {
      6.             singletonObject = singletonFactory.getObject();
      7.             this.earlySingletonObjects.put(beanName, singletonObject);
      8.             this.singletonFactories.remove(beanName);
      9.         }
      10.     }
      11. }
      } return singletonObject; }

    /**

    • 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, “Bean name must not be null”); synchronized (this.singletonObjects) {
      1. Object singletonObject = this.singletonObjects.get(beanName);
      2. if (singletonObject == null) {
      3.     if (this.singletonsCurrentlyInDestruction) {
      4.         throw new BeanCreationNotAllowedException(beanName,
      5.                 "Singleton bean creation not allowed while singletons of this factory are in destruction " +
      6.                 "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
      7.     }
      8.     if (logger.isDebugEnabled()) {
      9.         logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
      10.     }
      11.     beforeSingletonCreation(beanName);
      12.     boolean newSingleton = false;
      13.     boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
      14.     if (recordSuppressedExceptions) {
      15.         this.suppressedExceptions = new LinkedHashSet<>();
      16.     }
      17.     try {
      18.         singletonObject = singletonFactory.getObject();
      19.         newSingleton = true;
      20.     }
      21.     catch (IllegalStateException ex) {
      22.         // Has the singleton object implicitly appeared in the meantime ->
      23.         // if yes, proceed with it since the exception indicates that state.
      24.         singletonObject = this.singletonObjects.get(beanName);
      25.         if (singletonObject == null) {
      26.             throw ex;
      27.         }
      28.     }
      29.     catch (BeanCreationException ex) {
      30.         if (recordSuppressedExceptions) {
      31.             for (Exception suppressedException : this.suppressedExceptions) {
      32.                 ex.addRelatedCause(suppressedException);
      33.             }
      34.         }
      35.         throw ex;
      36.     }
      37.     finally {
      38.         if (recordSuppressedExceptions) {
      39.             this.suppressedExceptions = null;
      40.         }
      41.         afterSingletonCreation(beanName);
      42.     }
      43.     if (newSingleton) {
      44.         addSingleton(beanName, singletonObject);
      45.     }
      46. }
      47. return singletonObject;
      } }
  2.    3. a
  3.    3. <br />
  4.    3. <br />
  6. 4. 全部代码
  7. ```java
  8. public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
  10.     /** Cache of singleton objects: bean name --> bean instance */
  11.     /** 一级缓存 **/
  12.     private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  14.     /** Cache of singleton factories: bean name --> ObjectFactory */
  15.     /** 三级缓存 **/
  16.     private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
  18.     /** Cache of early singleton objects: bean name --> bean instance */
  19.     /** 二级缓存 **/
  20.     private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
  22.     /** Set of registered singletons, containing the bean names in registration order */
  23.     // 所有单列对象集合,并按照beanName 进行排序
  24.     private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
  26.     /** Names of beans that are currently in creation */
  27.     private final Set<String> singletonsCurrentlyInCreation =
  28.             Collections.newSetFromMap(new ConcurrentHashMap<>(16));
  30.     /** Names of beans currently excluded from in creation checks */
  31.     private final Set<String> inCreationCheckExclusions =
  32.             Collections.newSetFromMap(new ConcurrentHashMap<>(16));
  34.     /** List of suppressed Exceptions, available for associating related causes */
  35.     @Nullable
  36.     private Set<Exception> suppressedExceptions;
  38.     /** Flag that indicates whether we're currently within destroySingletons */
  39.     private boolean singletonsCurrentlyInDestruction = false;
  41.     /** Disposable bean instances: bean name --> disposable instance */
  42.     private final Map<String, Object> disposableBeans = new LinkedHashMap<>();
  44.     /** Map between containing bean names: bean name --> Set of bean names that the bean contains */
  45.     private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);
  47.     /** Map between dependent bean names: bean name --> Set of dependent bean names */
  48.     private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
  50.     /** Map between depending bean names: bean name --> Set of bean names for the bean's dependencies */
  51.     private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
  54.     @Override
  55.     public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
  56.         Assert.notNull(beanName, "Bean name must not be null");
  57.         Assert.notNull(singletonObject, "Singleton object must not be null");
  58.         synchronized (this.singletonObjects) {
  59.             Object oldObject = this.singletonObjects.get(beanName);
  60.             if (oldObject != null) {
  61.                 throw new IllegalStateException("Could not register object [" + singletonObject +
  62.                         "] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
  63.             }
  64.             addSingleton(beanName, singletonObject);
  65.         }
  66.     }
  68.     /**
  69.      * Add the given singleton object to the singleton cache of this factory.
  70.      * <p>To be called for eager registration of singletons.
  71.      * @param beanName the name of the bean
  72.      * @param singletonObject the singleton object
  73.      */
  74.     protected void addSingleton(String beanName, Object singletonObject) {
  75.         synchronized (this.singletonObjects) {
  76.             this.singletonObjects.put(beanName, singletonObject);
  77.             this.singletonFactories.remove(beanName);
  78.             this.earlySingletonObjects.remove(beanName);
  79.             this.registeredSingletons.add(beanName);
  80.         }
  81.     }
  83.     /**
  84.      * Add the given singleton factory for building the specified singleton
  85.      * if necessary.
  86.      * <p>To be called for eager registration of singletons, e.g. to be able to
  87.      * resolve circular references.
  88.      * @param beanName the name of the bean
  89.      * @param singletonFactory the factory for the singleton object
  90.      */
  91.     protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
  92.         Assert.notNull(singletonFactory, "Singleton factory must not be null");
  93.         synchronized (this.singletonObjects) {
  94.             if (!this.singletonObjects.containsKey(beanName)) {
  95.                 this.singletonFactories.put(beanName, singletonFactory);
  96.                 this.earlySingletonObjects.remove(beanName);
  97.                 this.registeredSingletons.add(beanName);
  98.             }
  99.         }
  100.     }
  102.     @Override
  103.     @Nullable
  104.     public Object getSingleton(String beanName) {
  105.         return getSingleton(beanName, true);
  106.     }
  108.     /**
  109.      * Return the (raw) singleton object registered under the given name.
  110.      * <p>Checks already instantiated singletons and also allows for an early
  111.      * reference to a currently created singleton (resolving a circular reference).
  112.      * @param beanName the name of the bean to look for
  113.      * @param allowEarlyReference whether early references should be created or not
  114.      * @return the registered singleton object, or {@code null} if none found
  115.      */
  116.     @Nullable
  117.     protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  118.         Object singletonObject = this.singletonObjects.get(beanName);
  119.         if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  120.             synchronized (this.singletonObjects) {
  121.                 singletonObject = this.earlySingletonObjects.get(beanName);
  122.                 if (singletonObject == null && allowEarlyReference) {
  123.                     ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
  124.                     if (singletonFactory != null) {
  125.                         singletonObject = singletonFactory.getObject();
  126.                         this.earlySingletonObjects.put(beanName, singletonObject);
  127.                         this.singletonFactories.remove(beanName);
  128.                     }
  129.                 }
  130.             }
  131.         }
  132.         return singletonObject;
  133.     }
  135.     /**
  136.      * Return the (raw) singleton object registered under the given name,
  137.      * creating and registering a new one if none registered yet.
  138.      * @param beanName the name of the bean
  139.      * @param singletonFactory the ObjectFactory to lazily create the singleton
  140.      * with, if necessary
  141.      * @return the registered singleton object
  142.      */
  143.     public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
  144.         Assert.notNull(beanName, "Bean name must not be null");
  145.         synchronized (this.singletonObjects) {
  146.             Object singletonObject = this.singletonObjects.get(beanName);
  147.             if (singletonObject == null) {
  148.                 if (this.singletonsCurrentlyInDestruction) {
  149.                     throw new BeanCreationNotAllowedException(beanName,
  150.                             "Singleton bean creation not allowed while singletons of this factory are in destruction " +
  151.                             "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
  152.                 }
  153.                 if (logger.isDebugEnabled()) {
  154.                     logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
  155.                 }
  156.                 beforeSingletonCreation(beanName);
  157.                 boolean newSingleton = false;
  158.                 boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
  159.                 if (recordSuppressedExceptions) {
  160.                     this.suppressedExceptions = new LinkedHashSet<>();
  161.                 }
  162.                 try {
  163.                     singletonObject = singletonFactory.getObject();
  164.                     newSingleton = true;
  165.                 }
  166.                 catch (IllegalStateException ex) {
  167.                     // Has the singleton object implicitly appeared in the meantime ->
  168.                     // if yes, proceed with it since the exception indicates that state.
  169.                     singletonObject = this.singletonObjects.get(beanName);
  170.                     if (singletonObject == null) {
  171.                         throw ex;
  172.                     }
  173.                 }
  174.                 catch (BeanCreationException ex) {
  175.                     if (recordSuppressedExceptions) {
  176.                         for (Exception suppressedException : this.suppressedExceptions) {
  177.                             ex.addRelatedCause(suppressedException);
  178.                         }
  179.                     }
  180.                     throw ex;
  181.                 }
  182.                 finally {
  183.                     if (recordSuppressedExceptions) {
  184.                         this.suppressedExceptions = null;
  185.                     }
  186.                     afterSingletonCreation(beanName);
  187.                 }
  188.                 if (newSingleton) {
  189.                     addSingleton(beanName, singletonObject);
  190.                 }
  191.             }
  192.             return singletonObject;
  193.         }
  194.     }
  196.     /**
  197.      * Register an Exception that happened to get suppressed during the creation of a
  198.      * singleton bean instance, e.g. a temporary circular reference resolution problem.
  199.      * @param ex the Exception to register
  200.      */
  201.     protected void onSuppressedException(Exception ex) {
  202.         synchronized (this.singletonObjects) {
  203.             if (this.suppressedExceptions != null) {
  204.                 this.suppressedExceptions.add(ex);
  205.             }
  206.         }
  207.     }
  209.     /**
  210.      * Remove the bean with the given name from the singleton cache of this factory,
  211.      * to be able to clean up eager registration of a singleton if creation failed.
  212.      * @param beanName the name of the bean
  213.      * @see #getSingletonMutex()
  214.      */
  215.     protected void removeSingleton(String beanName) {
  216.         synchronized (this.singletonObjects) {
  217.             this.singletonObjects.remove(beanName);
  218.             this.singletonFactories.remove(beanName);
  219.             this.earlySingletonObjects.remove(beanName);
  220.             this.registeredSingletons.remove(beanName);
  221.         }
  222.     }
  224.     @Override
  225.     public boolean containsSingleton(String beanName) {
  226.         return this.singletonObjects.containsKey(beanName);
  227.     }
  229.     @Override
  230.     public String[] getSingletonNames() {
  231.         synchronized (this.singletonObjects) {
  232.             return StringUtils.toStringArray(this.registeredSingletons);
  233.         }
  234.     }
  236.     @Override
  237.     public int getSingletonCount() {
  238.         synchronized (this.singletonObjects) {
  239.             return this.registeredSingletons.size();
  240.         }
  241.     }
  244.     public void setCurrentlyInCreation(String beanName, boolean inCreation) {
  245.         Assert.notNull(beanName, "Bean name must not be null");
  246.         if (!inCreation) {
  247.             this.inCreationCheckExclusions.add(beanName);
  248.         }
  249.         else {
  250.             this.inCreationCheckExclusions.remove(beanName);
  251.         }
  252.     }
  254.     public boolean isCurrentlyInCreation(String beanName) {
  255.         Assert.notNull(beanName, "Bean name must not be null");
  256.         return (!this.inCreationCheckExclusions.contains(beanName) && isActuallyInCreation(beanName));
  257.     }
  259.     protected boolean isActuallyInCreation(String beanName) {
  260.         return isSingletonCurrentlyInCreation(beanName);
  261.     }
  263.     /**
  264.      * Return whether the specified singleton bean is currently in creation
  265.      * (within the entire factory).
  266.      * @param beanName the name of the bean
  267.      */
  268.     public boolean isSingletonCurrentlyInCreation(String beanName) {
  269.         return this.singletonsCurrentlyInCreation.contains(beanName);
  270.     }
  272.     /**
  273.      * Callback before singleton creation.
  274.      * <p>The default implementation register the singleton as currently in creation.
  275.      * @param beanName the name of the singleton about to be created
  276.      * @see #isSingletonCurrentlyInCreation
  277.      */
  278.     protected void beforeSingletonCreation(String beanName) {
  279.         if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
  280.             throw new BeanCurrentlyInCreationException(beanName);
  281.         }
  282.     }
  284.     /**
  285.      * Callback after singleton creation.
  286.      * <p>The default implementation marks the singleton as not in creation anymore.
  287.      * @param beanName the name of the singleton that has been created
  288.      * @see #isSingletonCurrentlyInCreation
  289.      */
  290.     protected void afterSingletonCreation(String beanName) {
  291.         if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
  292.             throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
  293.         }
  294.     }
  297.     /**
  298.      * Add the given bean to the list of disposable beans in this registry.
  299.      * <p>Disposable beans usually correspond to registered singletons,
  300.      * matching the bean name but potentially being a different instance
  301.      * (for example, a DisposableBean adapter for a singleton that does not
  302.      * naturally implement Spring's DisposableBean interface).
  303.      * @param beanName the name of the bean
  304.      * @param bean the bean instance
  305.      */
  306.     public void registerDisposableBean(String beanName, DisposableBean bean) {
  307.         synchronized (this.disposableBeans) {
  308.             this.disposableBeans.put(beanName, bean);
  309.         }
  310.     }
  312.     /**
  313.      * Register a containment relationship between two beans,
  314.      * e.g. between an inner bean and its containing outer bean.
  315.      * <p>Also registers the containing bean as dependent on the contained bean
  316.      * in terms of destruction order.
  317.      * @param containedBeanName the name of the contained (inner) bean
  318.      * @param containingBeanName the name of the containing (outer) bean
  319.      * @see #registerDependentBean
  320.      */
  321.     public void registerContainedBean(String containedBeanName, String containingBeanName) {
  322.         synchronized (this.containedBeanMap) {
  323.             Set<String> containedBeans =
  324.                     this.containedBeanMap.computeIfAbsent(containingBeanName, k -> new LinkedHashSet<>(8));
  325.             if (!containedBeans.add(containedBeanName)) {
  326.                 return;
  327.             }
  328.         }
  329.         registerDependentBean(containedBeanName, containingBeanName);
  330.     }
  332.     /**
  333.      * Register a dependent bean for the given bean,
  334.      * to be destroyed before the given bean is destroyed.
  335.      * @param beanName the name of the bean
  336.      * @param dependentBeanName the name of the dependent bean
  337.      */
  338.     public void registerDependentBean(String beanName, String dependentBeanName) {
  339.         String canonicalName = canonicalName(beanName);
  341.         synchronized (this.dependentBeanMap) {
  342.             Set<String> dependentBeans =
  343.                     this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
  344.             if (!dependentBeans.add(dependentBeanName)) {
  345.                 return;
  346.             }
  347.         }
  349.         synchronized (this.dependenciesForBeanMap) {
  350.             Set<String> dependenciesForBean =
  351.                     this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
  352.             dependenciesForBean.add(canonicalName);
  353.         }
  354.     }
  356.     /**
  357.      * Determine whether the specified dependent bean has been registered as
  358.      * dependent on the given bean or on any of its transitive dependencies.
  359.      * @param beanName the name of the bean to check
  360.      * @param dependentBeanName the name of the dependent bean
  361.      * @since 4.0
  362.      */
  363.     protected boolean isDependent(String beanName, String dependentBeanName) {
  364.         synchronized (this.dependentBeanMap) {
  365.             return isDependent(beanName, dependentBeanName, null);
  366.         }
  367.     }
  369.     private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
  370.         if (alreadySeen != null && alreadySeen.contains(beanName)) {
  371.             return false;
  372.         }
  373.         String canonicalName = canonicalName(beanName);
  374.         Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
  375.         if (dependentBeans == null) {
  376.             return false;
  377.         }
  378.         if (dependentBeans.contains(dependentBeanName)) {
  379.             return true;
  380.         }
  381.         for (String transitiveDependency : dependentBeans) {
  382.             if (alreadySeen == null) {
  383.                 alreadySeen = new HashSet<>();
  384.             }
  385.             alreadySeen.add(beanName);
  386.             if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
  387.                 return true;
  388.             }
  389.         }
  390.         return false;
  391.     }
  393.     /**
  394.      * Determine whether a dependent bean has been registered for the given name.
  395.      * @param beanName the name of the bean to check
  396.      */
  397.     protected boolean hasDependentBean(String beanName) {
  398.         return this.dependentBeanMap.containsKey(beanName);
  399.     }
  401.     /**
  402.      * Return the names of all beans which depend on the specified bean, if any.
  403.      * @param beanName the name of the bean
  404.      * @return the array of dependent bean names, or an empty array if none
  405.      */
  406.     public String[] getDependentBeans(String beanName) {
  407.         Set<String> dependentBeans = this.dependentBeanMap.get(beanName);
  408.         if (dependentBeans == null) {
  409.             return new String[0];
  410.         }
  411.         synchronized (this.dependentBeanMap) {
  412.             return StringUtils.toStringArray(dependentBeans);
  413.         }
  414.     }
  416.     /**
  417.      * Return the names of all beans that the specified bean depends on, if any.
  418.      * @param beanName the name of the bean
  419.      * @return the array of names of beans which the bean depends on,
  420.      * or an empty array if none
  421.      */
  422.     public String[] getDependenciesForBean(String beanName) {
  423.         Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(beanName);
  424.         if (dependenciesForBean == null) {
  425.             return new String[0];
  426.         }
  427.         synchronized (this.dependenciesForBeanMap) {
  428.             return StringUtils.toStringArray(dependenciesForBean);
  429.         }
  430.     }
  432.     public void destroySingletons() {
  433.         if (logger.isDebugEnabled()) {
  434.             logger.debug("Destroying singletons in " + this);
  435.         }
  436.         synchronized (this.singletonObjects) {
  437.             this.singletonsCurrentlyInDestruction = true;
  438.         }
  440.         String[] disposableBeanNames;
  441.         synchronized (this.disposableBeans) {
  442.             disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
  443.         }
  444.         for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
  445.             destroySingleton(disposableBeanNames[i]);
  446.         }
  448.         this.containedBeanMap.clear();
  449.         this.dependentBeanMap.clear();
  450.         this.dependenciesForBeanMap.clear();
  452.         clearSingletonCache();
  453.     }
  455.     /**
  456.      * Clear all cached singleton instances in this registry.
  457.      * @since 4.3.15
  458.      */
  459.     protected void clearSingletonCache() {
  460.         synchronized (this.singletonObjects) {
  461.             this.singletonObjects.clear();
  462.             this.singletonFactories.clear();
  463.             this.earlySingletonObjects.clear();
  464.             this.registeredSingletons.clear();
  465.             this.singletonsCurrentlyInDestruction = false;
  466.         }
  467.     }
  469.     /**
  470.      * Destroy the given bean. Delegates to {@code destroyBean}
  471.      * if a corresponding disposable bean instance is found.
  472.      * @param beanName the name of the bean
  473.      * @see #destroyBean
  474.      */
  475.     public void destroySingleton(String beanName) {
  476.         // Remove a registered singleton of the given name, if any.
  477.         removeSingleton(beanName);
  479.         // Destroy the corresponding DisposableBean instance.
  480.         DisposableBean disposableBean;
  481.         synchronized (this.disposableBeans) {
  482.             disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
  483.         }
  484.         destroyBean(beanName, disposableBean);
  485.     }
  487.     /**
  488.      * Destroy the given bean. Must destroy beans that depend on the given
  489.      * bean before the bean itself. Should not throw any exceptions.
  490.      * @param beanName the name of the bean
  491.      * @param bean the bean instance to destroy
  492.      */
  493.     protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
  494.         // Trigger destruction of dependent beans first...
  495.         Set<String> dependencies;
  496.         synchronized (this.dependentBeanMap) {
  497.             // Within full synchronization in order to guarantee a disconnected Set
  498.             dependencies = this.dependentBeanMap.remove(beanName);
  499.         }
  500.         if (dependencies != null) {
  501.             if (logger.isDebugEnabled()) {
  502.                 logger.debug("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
  503.             }
  504.             for (String dependentBeanName : dependencies) {
  505.                 destroySingleton(dependentBeanName);
  506.             }
  507.         }
  509.         // Actually destroy the bean now...
  510.         if (bean != null) {
  511.             try {
  512.                 bean.destroy();
  513.             }
  514.             catch (Throwable ex) {
  515.                 logger.error("Destroy method on bean with name '" + beanName + "' threw an exception", ex);
  516.             }
  517.         }
  519.         // Trigger destruction of contained beans...
  520.         Set<String> containedBeans;
  521.         synchronized (this.containedBeanMap) {
  522.             // Within full synchronization in order to guarantee a disconnected Set
  523.             containedBeans = this.containedBeanMap.remove(beanName);
  524.         }
  525.         if (containedBeans != null) {
  526.             for (String containedBeanName : containedBeans) {
  527.                 destroySingleton(containedBeanName);
  528.             }
  529.         }
  531.         // Remove destroyed bean from other beans' dependencies.
  532.         synchronized (this.dependentBeanMap) {
  533.             for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
  534.                 Map.Entry<String, Set<String>> entry = it.next();
  535.                 Set<String> dependenciesToClean = entry.getValue();
  536.                 dependenciesToClean.remove(beanName);
  537.                 if (dependenciesToClean.isEmpty()) {
  538.                     it.remove();
  539.                 }
  540.             }
  541.         }
  543.         // Remove destroyed bean's prepared dependency information.
  544.         this.dependenciesForBeanMap.remove(beanName);
  545.     }
  547.     /**
  548.      * Exposes the singleton mutex to subclasses and external collaborators.
  549.      * <p>Subclasses should synchronize on the given Object if they perform
  550.      * any sort of extended singleton creation phase. In particular, subclasses
  551.      * should <i>not</i> have their own mutexes involved in singleton creation,
  552.      * to avoid the potential for deadlocks in lazy-init situations.
  553.      */
  554.     @Override
  555.     public final Object getSingletonMutex() {
  556.         return this.singletonObjects;
  557.     }
  559. }