SpringBoot关闭过程中是如何销毁一个DisposableBean的？

public void destroySingleton(String beanName) {
  // Remove a registered singleton of the given name, if any.
  // 从缓存中移除当前beanName
  removeSingleton(beanName);
  // Destroy the corresponding DisposableBean instance.
  // 从disposableBeans集合中移除当前 beanName
  DisposableBean disposableBean;
  synchronized (this.disposableBeans) {
    disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
  }
  // 这是核心方法
  destroyBean(beanName, disposableBean);
}

// DefaultSingletonBeanRegistry
protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
  // Trigger destruction of dependent beans first...
  Set<String> dependencies;
  //dependentBeanMap存放的是哪些bean依赖于key
  synchronized (this.dependentBeanMap) {
    // Within full synchronization in order to guarantee a disconnected Set
    dependencies = this.dependentBeanMap.remove(beanName);
  }
  // 首先触发那些依赖于当前beanName的bean的销毁流程
  if (dependencies != null) {
    if (logger.isTraceEnabled()) {
      logger.trace("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
    }
    for (String dependentBeanName : dependencies) {
      destroySingleton(dependentBeanName);
    }
  }
  // Actually destroy the bean now...
  // bean销毁的过程入口，触发DisposableBeanAdapter的destroy方法
  if (bean != null) {
    try {
      bean.destroy();
    }
    catch (Throwable ex) {
      if (logger.isWarnEnabled()) {
        logger.warn("Destruction of bean with name '" + beanName + "' threw an exception", ex);
      }
    }
  }
  // Trigger destruction of contained beans...
  // 获取当前beanName对应的containedBeans，如果有，则遍历触发销毁流程
  Set<String> containedBeans;
  synchronized (this.containedBeanMap) {
    // Within full synchronization in order to guarantee a disconnected Set
    containedBeans = this.containedBeanMap.remove(beanName);
  }
  if (containedBeans != null) {
    for (String containedBeanName : containedBeans) {
      destroySingleton(containedBeanName);
    }
  }
  // Remove destroyed bean from other beans' dependencies.
  // 遍历dependentBeanMap的value，移除掉当前beanName。
  //之后如果value为空，其从dependentBeanMap移除掉当前entry
  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.
  // 从 dependenciesForBeanMap中移除当前beanName对应的entry
  this.dependenciesForBeanMap.remove(beanName);
}

@Override
public void destroy() {
//获取当前实例维护的DestructionAwareBeanPostProcessor 触发其postProcessBeforeDestruction方法
  if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
    for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
      processor.postProcessBeforeDestruction(this.bean, this.beanName);
    }
  }
// 是否触发destroy方法
  if (this.invokeDisposableBean) {
    if (logger.isTraceEnabled()) {
      logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'");
    }
    try {
      if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
          ((DisposableBean) this.bean).destroy();
          return null;
        }, this.acc);
      }
      else {
        ((DisposableBean) this.bean).destroy();
      }
    }
    catch (Throwable ex) {
      String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'";
      if (logger.isDebugEnabled()) {
        logger.warn(msg, ex);
      }
      else {
        logger.warn(msg + ": " + ex);
      }
    }
  }
// 如果destroyMethod 不为null，则触发自定义销毁方法
  if (this.destroyMethod != null) {
    invokeCustomDestroyMethod(this.destroyMethod);
  }
  else if (this.destroyMethodName != null) {
  // 如果destroyMethodName 不为null，则获取并触发自定义销毁方法
    Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
    if (methodToInvoke != null) {
      invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
    }
  }
}