详解Spring的Bean销毁

Love The Way You Lie 2023-10-02 11:41 2阅读 0赞

### 一、注册Bean销毁逻辑 ###

Bean的生命周期中，在完成了Bean的创建之后，会注册Bean销毁的逻辑

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {
        
        ……
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
        ……
    }

在注册Bean销毁逻辑时，首先需要通过!mbd.isPrototype()保证该Bean不是原型Bean，因为Spring容器并不会缓存原型Bean，就没有销毁一说

接着通过requiresDestruction()判断该Bean是否需要销毁，对需要销毁的Bean通过适配器模式生成DisposableBeanAdapter对象，最后调用registerDisposableBean()将DisposableBeanAdapter对象放入disposableBeans缓存中，当Spring容器关闭的时候，可以直接从该缓存中取出销毁调用，调用它们的销毁方法

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
        
    		AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
    		if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
        
    			if (mbd.isSingleton()) {
        
    				// Register a DisposableBean implementation that performs all destruction
    				// work for the given bean: DestructionAwareBeanPostProcessors,
    				// DisposableBean interface, custom destroy method.
    				registerDisposableBean(beanName, new DisposableBeanAdapter(
    						bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));
    			}
                ……
    		}
    	}

##### 1.1 判断当前Bean是否需要销毁 #####

requiresDestruction()方法源码如下：

protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {
        
        return (bean.getClass() != NullBean.class && (DisposableBeanAdapter.hasDestroyMethod(bean, mbd) ||
                                                      (hasDestructionAwareBeanPostProcessors() && DisposableBeanAdapter.hasApplicableProcessors(
                                                          bean, getBeanPostProcessorCache().destructionAware))));
    }

*  判断当前Bean是否有销毁方法
    
    如果当前Bean继承了DisposableBean或AutoCloseable接口，重写接口中的destroy()和close()方法，这两个方法都是销毁方法
    
        public static boolean hasDestroyMethod(Object bean, RootBeanDefinition beanDefinition) {
              
            if (bean instanceof DisposableBean || bean instanceof AutoCloseable) {
              
                return true;
            }
            return inferDestroyMethodIfNecessary(bean, beanDefinition) != null;
        }
    
    如果没有继承这两个接口，则判断当前Bean的RootBeanDefinition是否设置销毁方法名为"(inferred)"
    
    设置初始化和销毁方法名都是在Bean实例化后BeanDefinition的后置处理，即MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()中完成的
    
    如果在BeanDefinition的后置处理中设置销毁方法名为"(inferred)"，则会将该Bean中close()和shutdown()作为销毁方法(前提是Bean里面有这两个方法)
    
        private static String inferDestroyMethodIfNecessary(Object bean, RootBeanDefinition beanDefinition) {
              
            String destroyMethodName = beanDefinition.resolvedDestroyMethodName;
            if (destroyMethodName == null) {
              
                destroyMethodName = beanDefinition.getDestroyMethodName(); //
                if (AbstractBeanDefinition.INFER_METHOD.equals(destroyMethodName)) {
              
                    destroyMethodName = null;
                    if (!(bean instanceof DisposableBean)) {
              
                        try {
              
                            destroyMethodName = bean.getClass().getMethod(CLOSE_METHOD_NAME).getName();
                        }
                        catch (NoSuchMethodException ex) {
              
                            destroyMethodName = bean.getClass().getMethod(SHUTDOWN_METHOD_NAME).getName();
                        }
                    }
                }
                beanDefinition.resolvedDestroyMethodName = (destroyMethodName != null ? destroyMethodName : "");
            }
            return (StringUtils.hasLength(destroyMethodName) ? destroyMethodName : null);
        }
 *  判断是否有Bean实现了DestructionAwareBeanPostProcessor接口且requiresDestruction()方法返回True
    
    DestructionAwareBeanPostProcessor接口主要用于Bean销毁的，其中的requiresDestruction()判断Bean是否需要销毁，而postProcessBeforeDestruction()实现具体的销毁逻辑
    
    在[《创建Bean》][Bean]的最后面，讲到了@PreDestroy注解，它主要用于定义销毁方法(被该注解修饰的方法都是销毁方法)，而该注解的扫描的是在InitDestroyAnnotationBeanPostProcessor类中完成，InitDestroyAnnotationBeanPostProcessor实现了DestructionAwareBeanPostProcessor接口，它会缓存每个Bean以及它的父类哪些方法是被@PreDestroy修饰的
    
    hasDestructionAwareBeanPostProcessors()主要判断是否缓存的有实现了DestructionAwareBeanPostProcessor的Bean
    
        protected boolean hasDestructionAwareBeanPostProcessors() {
              
            return !getBeanPostProcessorCache().destructionAware.isEmpty();
        }
    
    然后调用DestructionAwareBeanPostProcessor的requiresDestruction()判断是否需要销毁
    
        public static boolean hasApplicableProcessors(Object bean, List<DestructionAwareBeanPostProcessor> postProcessors) {
              
            if (!CollectionUtils.isEmpty(postProcessors)) {
              
                for (DestructionAwareBeanPostProcessor processor : postProcessors) {
              
                    if (processor.requiresDestruction(bean)) {
              
                        return true;
                    }
                }
            }
            return false;
        }
    
    以InitDestroyAnnotationBeanPostProcessor.requiresDestruction(bean)为例，查看其实现过程：
    
    在[《创建Bean》][Bean]中介绍@PostConstruct和@PreDestroy的时候，已经详细介绍过findLifecycleMetadata()，通过判断是否有@PreDestroy定义的销毁方法，判断当前Bean是否需要销毁
    
        public boolean requiresDestruction(Object bean) {
              
            return findLifecycleMetadata(bean.getClass()).hasDestroyMethods();
        }
        
        private LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
              
            if (this.lifecycleMetadataCache == null) {
              
                // Happens after deserialization, during destruction...
                return buildLifecycleMetadata(clazz);
            }
            LifecycleMetadata metadata = this.lifecycleMetadataCache.get(clazz);
            if (metadata == null) {
              
                synchronized (this.lifecycleMetadataCache) {
              
                    metadata = this.lifecycleMetadataCache.get(clazz);
                    if (metadata == null) {
              
                        metadata = buildLifecycleMetadata(clazz);
                        this.lifecycleMetadataCache.put(clazz, metadata);
                    }
                    return metadata;
                }
            }
            return metadata;
        }

##### 1.2 注册可以销毁的Bean #####

判断完Bean是否可以销毁之后，需要注册销毁的Bean，代码如下：

registerDisposableBean()中缓存的是DisposableBeanAdapter对象，即不论该Bean是实现了DisposableBean或AutoCloseable接口，或者是通过BeanDifinition后置处理指定了”(inferred)“销毁方法名或其他方法销毁方法， 还是通过@PreDestroy指定的销毁方法，对于各种销毁逻辑，这里都会将Bean适配成一个DisposableBeanAdapter对象

// Register a DisposableBean implementation that performs all destruction
    // work for the given bean: DestructionAwareBeanPostProcessors,
    // DisposableBean interface, custom destroy method.
    registerDisposableBean(beanName, new DisposableBeanAdapter(
        bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));

public void registerDisposableBean(String beanName, DisposableBean bean) {
        
        synchronized (this.disposableBeans) {
        
            this.disposableBeans.put(beanName, bean);
        }
    }

在DisposableBeanAdapter的构造方法中，会推断出构造方法，并过滤出所有实现了DestructionAwareBeanPostProcessor接口但requiresDestruction()方法返回True的Bean，销毁的时候会调用它们的postProcessBeforeDestruction()

public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition,
                                 List<DestructionAwareBeanPostProcessor> postProcessors, @Nullable AccessControlContext acc) {
        
        ……
        String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition);
        if (destroyMethodName != null && !(this.invokeDisposableBean && "destroy".equals(destroyMethodName)) &&
            !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) {
        
            this.destroyMethodName = destroyMethodName;
            Method destroyMethod = determineDestroyMethod(destroyMethodName);
            if (destroyMethod == null) {
        
                ……
            }
            else {
        
                ……
                destroyMethod = ClassUtils.getInterfaceMethodIfPossible(destroyMethod);
            }
            this.destroyMethod = destroyMethod;
        }
        this.beanPostProcessors = filterPostProcessors(postProcessors, bean);
    }

private static List<DestructionAwareBeanPostProcessor> filterPostProcessors(
        List<DestructionAwareBeanPostProcessor> processors, Object bean) {
        
    
        List<DestructionAwareBeanPostProcessor> filteredPostProcessors = null;
        if (!CollectionUtils.isEmpty(processors)) {
        
            filteredPostProcessors = new ArrayList<>(processors.size());
            for (DestructionAwareBeanPostProcessor processor : processors) {
        
                if (processor.requiresDestruction(bean)) {
        
                    filteredPostProcessors.add(processor);
                }
            }
        }
        return filteredPostProcessors;
    }

在Bean销毁的时候，会调用DisposableBeanAdapter的destroy()，这个销毁方法里面会执行各种销毁逻辑

public void destroy() {
        
        // 调用所有DestructionAwareBeanPostProcessor.postProcessBeforeDestruction方法
        if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
        
            for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
        
                // @PreDestroy定义的销毁方法就是在这一步执行
                processor.postProcessBeforeDestruction(this.bean, this.beanName);
            }
        }
        ……
    }

### 二、Bean销毁过程 ###

在Spring容器关闭的时候，会去销毁所有的单例Bean，并不是只有注册了销毁逻辑的Bean才被销毁，注册了销毁逻辑的单例Bean在销毁之前，会调用它们注册的销毁逻辑

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    context.close();

容器的close()会调用doClose()，doClose()会调用来销毁单例Bean

public void close() {
        
        synchronized (this.startupShutdownMonitor) {
        
            doClose();
            ……
        }
    }
    
    protected void doClose() {
        
        ……
        destroyBeans();
        ……
    }

在destroySingletons()中会取出disposableBeans缓存中定了销毁逻辑的Bean的beanName，然后遍历进行销毁

protected void destroyBeans() {
        
        getBeanFactory().destroySingletons();
    }
    
    public void destroySingletons() {
        
        ……
        String[] disposableBeanNames;
        synchronized (this.disposableBeans) {
        
            disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
        }
        for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
        
            destroySingleton(disposableBeanNames[i]);
        }
        ……
    }

在进行销毁的时候，先从单例池等缓存中移除Bean，然后从disposableBeans移除当前DisposableBean并获取该对象，然后调用destroyBean(beanName, disposableBean)执行对象注册的销毁逻辑

public void destroySingleton(String beanName) {
        
        // Remove a registered singleton of the given name, if any.
        // 先从单例池中移除掉
        removeSingleton(beanName);
    
        // Destroy the corresponding DisposableBean instance.
        DisposableBean disposableBean;
        synchronized (this.disposableBeans) {
        
            disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
        }
        destroyBean(beanName, disposableBean);
    }
    // 从缓存中移除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);
        }
    }

在销毁当前Bean的时候，会获取依赖当前Bean的其他Bean的beanName，然后递归调用destroySingleton()方法，保证没有被任何其他Bean依赖的Bean先销毁，在进行销毁时，会先调用DisposableBean的destroy()方法，注册Bean销毁逻辑时已经讲过该方法，然后再去调用其他的销毁逻辑，其他的销毁逻辑无非就是从各种缓存中根据BeanName，清除缓存

protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
        
    
        // dependentBeanMap表示某bean被哪些bean依赖了
        // 所以现在要销毁某个bean时，如果这个Bean还被其他Bean依赖了，那么也得销毁其他Bean
        // Trigger destruction of dependent beans first...
        Set<String> 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) {
        
            bean.destroy();
        }
        ……
    }

[Bean]: https://blog.csdn.net/sermonlizhi/article/details/120748334