所谓 Bean 的生命周期，就是一个 Bean 从创建到销毁，上一篇文章从源码角度解读了Bean生命周期之Bean创建的过程（地址：Spring之Bean生命周期源码解读上），今天我们继续从源码解读Bean的销毁过程。

Bean的销毁过程

Bean销毁是发送在Spring容器关闭过程中的。
在Spring容器关闭时，比如：

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = (UserService) context.getBean("userService");
userService.test();

// 容器关闭
context.close();

在Bean创建过程中，在最后（初始化之后），有一个步骤会去判断当前创建的Bean是不是DisposableBean：

1. 当前Bean是否实现了DisposableBean接口
2. 或者，当前Bean是否实现了AutoCloseable接口
3. BeanDefinition中是否指定了destroyMethod
4. 调用DestructionAwareBeanPostProcessor.requiresDestruction(bean)进行判断

a、ApplicationListenerDetector中直接使得ApplicationListener是DisposableBean

b、InitDestroyAnnotationBeanPostProcessor中使得拥有@PreDestroy注解了的方法就是DisposableBean

5. 把符合上述任意一个条件的Bean适配成DisposableBeanAdapter对象，并存入disposableBeans中（一个LinkedHashMap）

在Spring容器关闭过程：

1. 首先发布ContextClosedEvent事件
2. 调用lifecycleProcessor的onCloese()方法
3. 销毁单例Bean(销毁的单例bean,多例是由JVM回收，因为没有被存储；销毁：就是清空所有的单例map)

• 遍历disposableBeans

1.把每个disposableBean从单例池中移除
2.调用disposableBean的destroy()
3.如果这个disposableBean还被其他Bean依赖了，那么也得销毁其他Bean
4.如果这个disposableBean还包含了inner beans，将这些Bean从单例池中移除掉
(inner bean参考：https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-inner-beans)

• 清空manualSingletonNames，是一个Set，存的是用户手动注册的单例Bean的beanName
• 清空allBeanNamesByType，是一个Map，key是bean类型，value是该类型所有的beanName数组
• 清空singletonBeanNamesByType，和allBeanNamesByType类似，只不过只存了单例Bean

这里涉及到一个设计模式：适配器模式

在销毁时，Spring会找出实现了DisposableBean接口的Bean。

但是我们在定义一个Bean时，如果这个Bean实现了DisposableBean接口，或者实现了AutoCloseable接口，或者在BeanDefinition中指定了destroyMethodName，那么这个Bean都属于“DisposableBean”，这些Bean在容器关闭时都要调用相应的销毁方法。

所以，这里就需要进行适配，将实现了DisposableBean接口、或者AutoCloseable接口等适配成实现了DisposableBean接口，所以就用到了DisposableBeanAdapter。

会把实现了AutoCloseable接口的类封装成DisposableBeanAdapter，而DisposableBeanAdapter实现了DisposableBean接口。

Bean销毁源码解读：

public void close() {
    synchronized (this.startupShutdownMonitor) {
        // 销毁方法
        doClose();
        // If we registered a JVM shutdown hook, we don't need it anymore now:
        // We've already explicitly closed the context.
        if (this.shutdownHook != null) {
            try {
            	Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
            }
            catch (IllegalStateException ex) {
            	// ignore - VM is already shutting down
            }
        }
    }
}

protected void doClose() {
    // Check whether an actual close attempt is necessary...
    if (this.active.get() && this.closed.compareAndSet(false, true)) {
        if (logger.isDebugEnabled()) {
            logger.debug("Closing " + this);
        }

        if (!NativeDetector.inNativeImage()) {
            LiveBeansView.unregisterApplicationContext(this);
        }

        try {
            // 1、发布ContextClosedEvent事件
            publishEvent(new ContextClosedEvent(this));
        }
        catch (Throwable ex) {
            logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
        }

        // Stop all Lifecycle beans, to avoid delays during inpidual destruction.
        if (this.lifecycleProcessor != null) {
            try {
                // 2、调用lifecycleProcessor的onCloese()方法
                this.lifecycleProcessor.onClose();
            }
            catch (Throwable ex) {
                logger.warn("Exception thrown from LifecycleProcessor on context close", ex);
            }
        }

        // Destroy all cached singletons in the context's BeanFactory.
        // 3、销毁BeanFactory中的所有单例Bean
        destroyBeans();

        // Close the state of this context itself.
        // 销毁bean工厂的所有单例bean
        closeBeanFactory();

        // Let subclasses do some final clean-up if they wish...
        onClose();

        // Reset local application listeners to pre-refresh state.
        if (this.earlyApplicationListeners != null) {
            this.applicationListeners.clear();
            this.applicationListeners.addAll(this.earlyApplicationListeners);
        }

        // Switch to inactive.
        this.active.set(false);
    }
}

销毁BeanFactory中的所有单例Bean源码

protected void destroyBeans() {
	getBeanFactory().destroySingletons();
}

public void destroySingletons() {
   super.destroySingletons();
   // 清空manualSingletonNames集合
   updateManualSingletonNames(Set::clear, set -> !set.isEmpty());
   clearByTypeCache();
}

销毁所有的单列bean

public void destroySingletons() {
    if (logger.isTraceEnabled()) {
        logger.trace("Destroying singletons in " + this);
    }
    synchronized (this.singletonObjects) {
        this.singletonsCurrentlyInDestruction = true;
    }
    // 1.把每个disposableBean从单例池中移除(取出的是beanName)
    String[] disposableBeanNames;
    synchronized (this.disposableBeans) {
        disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
    }
    // 2.遍历disposableBeans
    for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
        // 3.调用disposableBean的destroy()方法执行定义的销毁方法
        destroySingleton(disposableBeanNames[i]);
    }

    this.containedBeanMap.clear();
    this.dependentBeanMap.clear();
    this.dependenciesForBeanMap.clear();

    clearSingletonCache();
}

销毁单列bean

public void destroySingleton(String beanName) {
    // Remove a registered singleton of the given name, if any.
    // 删除单列bean
    removeSingleton(beanName);
    
    // Destroy the corresponding DisposableBean instance.
    DisposableBean disposableBean;
    synchronized (this.disposableBeans) {
        disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
    }
    // 销毁单列bean
    destroyBean(beanName, disposableBean);
}

如果disposableBean还被其他Bean依赖了，那么也得销毁其他Bean。

protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
    // dependentBeanMap表示某bean被哪些bean依赖了
    // 所以现在要销毁某个bean时，如果这个Bean还被其他Bean依赖了，那么也得销毁其他Bean
    // Trigger destruction of dependent beans first...
    Set dependencies;
    synchronized (this.dependentBeanMap) {
        // Within full synchronization in order to guarantee a disconnected Set
        dependencies = this.dependentBeanMap.remove(beanName);
    }
    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...
    if (bean != null) {
        try {
            // 执行bean的destroy()方法，在销毁之前会执行执行postProcessBeforeDestruction()方法，
            // 这是一个bean销毁的扩展点，我们可以在bean销毁之前做一些其他事情。比如：销毁之前关闭其他的一些服务等。
            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...
    Set 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.
    synchronized (this.dependentBeanMap) {
        for (Iterator>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
            Map.Entry> entry = it.next();
            Set dependenciesToClean = entry.getValue();
            dependenciesToClean.remove(beanName);
            if (dependenciesToClean.isEmpty()) {
                it.remove();
            }
        }
    }

    // Remove destroyed bean's prepared dependency information.
  	// 从dependenciesForBeanMap移除bean
    this.dependenciesForBeanMap.remove(beanName);
}

这里是要执行的postProcessBeforeDestruction()方法的源码

public interface DisposableBean {
		void destroy() throws Exception;
}

DisposableBean的实现类DisposableBeanAdapter，其中对destroy()方法的实现源码

public void destroy() {
    if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
        for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
            // 执行postProcessBeforeDestruction()方法
            processor.postProcessBeforeDestruction(this.bean, this.beanName);
        }
    }

    if (this.invokeDisposableBean) {
        if (logger.isTraceEnabled()) {
            logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'");
        }
        try {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedExceptionAction