Spring實現(xiàn)Bean的初始化和銷毀的方式

更新時間：2025年05月07日 08:43:11 作者：攢了一袋星辰

這篇文章主要介紹了Spring實現(xiàn)Bean的初始化和銷毀的方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教

在前面的章節(jié)當中介紹完畢了ApplicationContext，也就是應(yīng)用上下文。我們說BeanFactory是面向開發(fā)者的，ApplicationContext才是面向使用者的，實際上也是如此。在ApplicationContest當中我們對BeanFactory進行了進一步的集成，實現(xiàn)了自動化的XML文件讀取，注冊BeanFacoryPostProcess，注冊BeanPostProcess，以及提前初始化單列Bean。

以上都是屬于Bean生命周期的一部分，是通過Spring自動管理的，除此之外Spring還允許用戶自定義初始化與銷毀方法，同樣也可以通過Spring自動化調(diào)用。

一、Bean的初始化

在實現(xiàn)初始化與銷毀之前我們需要先考慮一下什么時候進行初始化，什么時候要銷毀。

很簡單，初始化發(fā)生在創(chuàng)建Bean的時候，而銷毀發(fā)生在容器或者虛擬機關(guān)閉的時候。那么對于初始化來說他是針對對應(yīng)的Bean的，也就是說在創(chuàng)建的時候執(zhí)行，而銷毀是一個統(tǒng)一的行為，當容器關(guān)閉時候需要對指定Bean進行統(tǒng)一的銷毀。

那么明白了上述邏輯后我們就開始我們的邏輯實現(xiàn)

首先容器的初始化行為是正對Bean本身，實際上和BeanPostProcessor非常類似，只不過初始化的行為更具象罷了。

首先我們需要在BeanDefinition當中添加初始化的方法名，該名稱用于用戶通過XML/注解方式自定義初始化的方法

private String initMethodName;

第二步，定義用于初始化的父類，這樣我們的Bean就可以集成該類，重寫初始化方法。

public interface InitializingBean {  
    void afterPropertiesSet();  
}

現(xiàn)在再回到AbstractAutowireCapableBeanFactory當中的初始化方法initializeBean當中，在這里執(zhí)行完了BeanPostProcess的前置增強之后，執(zhí)行用戶定義的初始化方法。

private void initializeBean(String beanName, Object bean,BeanDefinition beanDefinition) {  
    // 執(zhí)行初始化之前的BeanPostProcessor前置處理  
    Object wrappedBean  = applyBeanPostProcessorsBeforeInitialization(bean, beanName);  
  
    // 執(zhí)行初始化方法  
    try {  
        invokeInitMethods(beanName , wrappedBean , beanDefinition);  
    } catch (Exception e) {  
        throw new BeansException("調(diào)用 bean 的 init 方法[" + beanName + "] 失敗", e);  
    }  
  
    // 執(zhí)行初始化之前的BeanPostProcessor后置  
    wrappedBean = applyBeanPostProcessorsAfterInitialization(bean , beanName);  
}

初始化的邏輯也很簡單，首先判斷用戶是否實現(xiàn)了InitializingBean這個接口，如果實現(xiàn)了則調(diào)用其重寫的afterPropertiesSet初始化方法。之后再判斷用戶是否是自己指定了自定義的初始化方法，如果指定則通過反射獲取到該方法并執(zhí)行即可。

private void invokeInitMethods(String beanName, Object bean, BeanDefinition beanDefinition) throws Exception{  
    if (bean instanceof InitializingBean){  
        ((InitializingBean) bean).afterPropertiesSet();  
    }  
  
    // 處理用戶自定義的初始化方法  
    if (StrUtil.isNotEmpty(beanDefinition.getInitMethodName())){  
        Method initMethod = ClassUtil.getPublicMethod(bean.getClass(), beanDefinition.getInitMethodName());  
        if (initMethod == null) {  
            throw new BeansException(String.format("在Bean：%s 當中找不到名為：%s 的初始化方法",beanName,beanDefinition.getInitMethodName()));  
        }  
        initMethod.invoke(bean);  
    }  
}

二、Bean的銷毀

Bean的銷毀相對于初始化來說最大的區(qū)別在于，初始化時正對單個Bean，銷毀是針對所有要銷毀的Bean。

也就是說，我們需要定一個Map集合存儲所有要銷毀的Bean，在容器關(guān)閉時遍歷集合，執(zhí)行其銷毀方法。

首先我們需要在BeanDefinition當中添加銷毀的方法名，該名稱用于用戶通過XML/注解方式自定義銷毀的方法

private String destroyMethodName;

第二步，定義用于銷毀的父類，這樣我們的Bean就可以集成該類，重寫銷毀方法。

public interface DisposableBean {  
  
    public void destroy();  
}

然后我們需要回到ConfigurableApplicationContext，因為實際上Bean的銷毀時應(yīng)用上下文的行為，在我們關(guān)閉ApplicationContext的時候才會執(zhí)行。

public interface ConfigurableApplicationContext extends ApplicationContext {  
    /**  
     * 刷新容器，重新加載并初始化所有配置和Bean  
     */    
    void refresh();  
  
    /**  
     * 關(guān)閉ApplicationContext  
     */    
    void close();  
  
  
    void registerShutdownHook();  
}

在AbstractApplicationContext實現(xiàn)這些方法，先看下面的代碼，這里可能會有一個疑問就是getBeanFactory().destroySingletons(); 通過完整的代碼我們可以知道getBeanFactory()返回的是一個DefaultListableBeanFactory的對象，那么我們也要在其父類當中實現(xiàn)該方法。

/**  
 * 關(guān)閉ApplicationContext  
 */@Override  
public void close() {  
    doClose();  
}  
  
private void doClose() {  
    destroyBeans();  
  
}  
  
private void destroyBeans() {  
    getBeanFactory().destroySingletons();  
}  
  
@Override  
public void registerShutdownHook() {  
    Thread shutdownHook = new Thread(this::doClose);  
    Runtime.getRuntime().addShutdownHook(shutdownHook);  
}

首先我們要明確一點，在Spring當中所有接口都被指責化了，也就是說不同接口有著不同的功能，而Bean的銷毀也屬于單列Bean的生命周期當中，所以我們要在DefaultSingletonBeanRegistry當中實現(xiàn)該方法，除此之外destroySingletons該方法我們還需要在ConfigurableBeanFactory當中定義。

其中ConfigurableBeanFactory與DefaultSingletonBeanRegistry之間都繼承于SingletonBeanRegistry，但是我們不在SingletonBeanRegistry當中定義destroySingletons接口，二者時通過組合繼承實現(xiàn)的

public void destroySingletons(){  
    Set<String> beanNames = disposableBeans.keySet();  
    for (String beanName : beanNames) {  
        DisposableBean disposableBean = disposableBeans.remove(beanName);  
        // 執(zhí)行銷毀方法  
        disposableBean.destroy();  
    }  
  
}

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {  
  
    /**  
     * 添加一個 BeanPostProcessor 到工廠中。  
     * BeanPostProcessor 可以在 Bean 初始化前后執(zhí)行自定義邏輯。  
     *  
     * @param beanPostProcessor 要添加的 BeanPostProcessor 實例  
     */  
    void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);  
  
  
    /**  
     * 銷毀單例bean  
     */    
    void destroySingletons();  
}

其實到這里所有的邏輯就結(jié)束了，下面寫一個測試

package org.qlspringframework.beans.ioc.bean;  
  
import org.qlspringframework.beans.factory.DisposableBean;  
import org.qlspringframework.beans.factory.InitializingBean;  
  
/**  
 * @author jixu  
 * @title People  
 * @date 2025/4/7 09:54  
 */public class People implements DisposableBean, InitializingBean {  
  
    private String name;  
    private Integer age;  
  
    private Car car;  
  
    public Car getCar() {  
        return car;  
    }  
  
    public void setCar(Car car) {  
        this.car = car;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public Integer getAge() {  
        return age;  
    }  
  
    public void setAge(Integer age) {  
        this.age = age;  
    }  
  
    @Override  
    public String toString() {  
        return "People{" +  
                "name='" + name + '\'' +  
                ", age=" + age +  
                ", car=" + car +  
                '}';  
    }  
  
    @Override  
    public void destroy() {  
        System.out.println("People destroy");  
    }  
  
    @Override  
    public void afterPropertiesSet() {  
        System.out.println("People init");  
    }  
}

public class InitAndDestroyMethodTest {  
  
    @Test  
    public void testInitAndDestroy(){  
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("classpath:spring.xml");  
        classPathXmlApplicationContext.registerShutdownHook();  
    }  
}