大家好，我是樓仔！

Spring Bean 的生命周期，面試時非常容易問，這不，前段時間就有個粉絲去字節(jié)面試，因為不會回答這個問題，一面都沒有過。

如果只講基礎(chǔ)知識，感覺和網(wǎng)上大多數(shù)文章沒有區(qū)別，但是我又想寫得稍微深入一點。

考慮很多同學(xué)不喜歡看源碼，我就把文章分為 2 大部分，前面是基礎(chǔ)知識，主要方便大家面試和學(xué)習(xí)，后面是源碼部分，對源碼感興趣的同學(xué)可以繼續(xù)往后面看。

1. 基礎(chǔ)知識

1.1 什么是 IoC ？

IoC，控制反轉(zhuǎn)，想必大家都知道，所謂的控制反轉(zhuǎn)，就是把 new 對象的權(quán)利交給容器，所有的對象都被容器控制，這就叫所謂的控制反轉(zhuǎn)。

IoC 很好地體現(xiàn)了面向?qū)ο笤O(shè)計法則之一 —— 好萊塢法則：“別找我們，我們找你”，即由 IoC 容器幫對象找相應(yīng)的依賴對象并注入，而不是由對象主動去找。

理解好 IoC 的關(guān)鍵是要明確 “誰控制誰，控制什么，為何是反轉(zhuǎn)（有反轉(zhuǎn)就應(yīng)該有正轉(zhuǎn)了），哪些方面反轉(zhuǎn)了”。

誰控制誰，控制什么？

傳統(tǒng) Java SE 程序設(shè)計，我們直接在對象內(nèi)部通過 new 進行創(chuàng)建對象，是程序主動去創(chuàng)建依賴對象。而 IoC 是由專門一個容器來創(chuàng)建這些對象，即由 IoC 容器來控制對象的創(chuàng)建。

• 誰控制誰？當(dāng)然是 IoC 容器控制了對象；
• 控制什么？主要控制了外部資源獲?。ú恢皇菍ο?，比如包括文件等）。

為何是反轉(zhuǎn)，哪些方面反轉(zhuǎn)了？

有反轉(zhuǎn)就有正轉(zhuǎn)，傳統(tǒng)應(yīng)用程序是由我們自己在對象中主動控制去直接獲取依賴對象，也就是正轉(zhuǎn)，而反轉(zhuǎn)則是由容器來幫忙創(chuàng)建及注入依賴對象。

• 為何是反轉(zhuǎn)？因為由容器幫我們查找及注入依賴對象，對象只是被動的接受依賴對象，所以是反轉(zhuǎn)；
• 哪些方面反轉(zhuǎn)了？依賴對象的獲取被反轉(zhuǎn)了。

1.2 Bean 生命周期

對 Prototype Bean 來說，當(dāng)用戶 getBean 獲得 Prototype Bean 的實例后，IOC 容器就不再對當(dāng)前實例進行管理，而是把管理權(quán)交由用戶，此后再 getBean 生成的是新的實例。

所以我們描述 Bean 的生命周期，都是指的 Singleton Bean。

Bean 生命周期過程：

• 實例化：第 1 步，實例化一個 Bean 對象；
• 屬性賦值：第 2 步，為 Bean 設(shè)置相關(guān)屬性和依賴；
• 初始化：初始化的階段的步驟比較多，5、6 步是真正的初始化，第 3、4 步為在初始化前執(zhí)行，第 7 步在初始化后執(zhí)行，初始化完成之后，Bean 就可以被使用了；
• 銷毀：第 8~10 步，第 8 步其實也可以算到銷毀階段，但不是真正意義上的銷毀，而是先在使用前注冊了銷毀的相關(guān)調(diào)用接口，為了后面第 9、10 步真正銷毀 Bean 時再執(zhí)行相應(yīng)的方法。

整個執(zhí)行流程稍微有些抽象，下面我們通過代碼，來演示執(zhí)行流程。

1.3 執(zhí)行流程

創(chuàng)建一個 LouzaiBean。

public class LouzaiBean implements InitializingBean, BeanFactoryAware, BeanNameAware, DisposableBean {

    /**
     * 姓名
     */
    private String name;

    public LouzaiBean() {
        System.out.println("1.調(diào)用構(gòu)造方法：我出生了！");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("2.設(shè)置屬性：我的名字叫"+name);
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("3.調(diào)用BeanNameAware#setBeanName方法:我要上學(xué)了，起了個學(xué)名");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("4.調(diào)用BeanFactoryAware#setBeanFactory方法：選好學(xué)校了");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("6.InitializingBean#afterPropertiesSet方法：入學(xué)登記");
    }

    public void init() {
        System.out.println("7.自定義init方法：努力上學(xué)ing");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("9.DisposableBean#destroy方法：平淡的一生落幕了");
    }

    public void destroyMethod() {
        System.out.println("10.自定義destroy方法:睡了，別想叫醒我");
    }

    public void work(){
        System.out.println("Bean使用中：工作，只有對社會沒有用的人才放假。。");
    }
}

自定義一個后處理器 MyBeanPostProcessor。

public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("5.BeanPostProcessor.postProcessBeforeInitialization方法：到學(xué)校報名啦");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("8.BeanPostProcessor#postProcessAfterInitialization方法：終于畢業(yè)，拿到畢業(yè)證啦！");
        return bean;
    }
}

applicationContext.xml 配置文件（部分）。

<bean name="myBeanPostProcessor" class="demo.MyBeanPostProcessor" />
<bean name="louzaiBean" class="demo.LouzaiBean"
      init-method="init" destroy-method="destroyMethod">
    <property name="name" value="樓仔" />
</bean>

測試入口：

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context =new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        LouzaiBean louzaiBean = (LouzaiBean) context.getBean("louzaiBean");
        louzaiBean.work();
        ((ClassPathXmlApplicationContext) context).destroy();
    }
}

執(zhí)行結(jié)果：

1.調(diào)用構(gòu)造方法：我出生了！
2.設(shè)置屬性：我的名字叫樓仔
3.調(diào)用BeanNameAware#setBeanName方法:我要上學(xué)了，起了個學(xué)名
4.調(diào)用BeanFactoryAware#setBeanFactory方法：選好學(xué)校了
5.BeanPostProcessor.postProcessBeforeInitialization方法：到學(xué)校報名啦
6.InitializingBean#afterPropertiesSet方法：入學(xué)登記
7.自定義init方法：努力上學(xué)ing
8.BeanPostProcessor#postProcessAfterInitialization方法：終于畢業(yè)，拿到畢業(yè)證啦！
Bean使用中：工作，只有對社會沒有用的人才放假。。
9.DisposableBean#destroy方法：平淡的一生落幕了
10.自定義destroy方法:睡了，別想叫醒我

這個流程非常清晰，Bean 生命周期流程圖能完全對應(yīng)起來。

1.4 擴展方法

我們發(fā)現(xiàn)，整個生命周期有很多擴展過程，大致可以分為 4 類：

• Aware 接口：讓 Bean 能拿到容器的一些資源，例如 BeanNameAware 的setBeanName()，BeanFactoryAware 的setBeanFactory()；
• 后處理器：進行一些前置和后置的處理，例如 BeanPostProcessor 的postProcessBeforeInitialization()和postProcessAfterInitialization()；
• 生命周期接口：定義初始化方法和銷毀方法的，例如 InitializingBean 的afterPropertiesSet()，以及 DisposableBean 的destroy()；
• 配置生命周期方法：可以通過配置文件，自定義初始化和銷毀方法，例如配置文件配置的init()和destroyMethod()。

2. 源碼解讀

注意：Spring 的版本是 5.2.15.RELEASE，否則和我的代碼不一樣?。?！

上面的知識，網(wǎng)上其實都有，下面才是我們的重頭戲，讓你跟著我走一遍代碼流程。

2.1 代碼入口

這里需要多跑幾次，把前面的 beanName 跳過去，只看 louzaiBean。

進入 doGetBean()，從 getSingleton() 沒有找到對象，進入創(chuàng)建 Bean 的邏輯。

2.2 實例化

進入 doCreateBean() 后，調(diào)用 createBeanInstance()。

進入 createBeanInstance() 后，調(diào)用 instantiateBean()。

走進示例 LouzaiBean 的方法，實例化 LouzaiBean。

2.3 屬性賦值

再回到 doCreateBean()，繼續(xù)往后走，進入 populateBean()。

這個方法非常重要，里面其實就是依賴注入的邏輯，不過這個不是我們今天的重點，大家如果對依賴注入和循環(huán)依賴感興趣，可以翻閱我之前的文章。

進入 populateBean() 后，執(zhí)行 applyPropertyValues()

進入 applyPropertyValues()，執(zhí)行 bw.setPropertyValues()

進入 processLocalProperty()，執(zhí)行 ph.setValue()。

走進示例 LouzaiBean 的方法，給 LouzaiBean 賦值 name。

到這里，populateBean() 就執(zhí)行完畢，下面開始初始化 Bean。

2.4 初始化

我們繼續(xù)回到 doCreateBean()，往后執(zhí)行 initializeBean()。

走進示例 LouzaiBean 的方法，給 LouzaiBean 設(shè)置 BeanName。

回到 invokeAwareMethods()。

走進示例 LouzaiBean 的方法，給 LouzaiBean 設(shè)置 BeanFactory。

第一次回到 initializeBean()，執(zhí)行下面邏輯。

這里需要多循環(huán)幾次，找到 MyBeanPostProcessor 的策略方法。

我們自己定義的后置處理方法。

第二次回到 initializeBean()，執(zhí)行下面邏輯。

走進示例 LouzaiBean 的方法，執(zhí)行 afterPropertiesSet()。

返回 invokeInitMethods()，執(zhí)行下面邏輯。

進入 invokeCustomInitMethod()，執(zhí)行下面邏輯。

走進示例 LouzaiBean 的方法，執(zhí)行 init()。

第三次回到 initializeBean()，執(zhí)行下面邏輯。

我們自己定義的后置處理方法。

到這里，初始化的流程全部結(jié)束，都是圍繞 initializeBean() 展開。

2.4 銷毀

當(dāng) louzaiBean 生成后，后面開始執(zhí)行銷毀操作，整個流程就比較簡單。

走進示例 LouzaiBean 的方法，執(zhí)行 destroy()。

回到 destroy()，執(zhí)行下面邏輯。

走進示例 LouzaiBean 的方法，執(zhí)行 destroyMethod()。

到這里，所有的流程全部結(jié)束，文章詳細描述所有的代碼邏輯流轉(zhuǎn)，你可以完全根據(jù)上面的邏輯，自己 debug 一遍。

3. 寫在最后

我們再回顧一下幾個重要的方法：

• doCreateBean()：這個是入口；
• createBeanInstance()：用來初始化 Bean，里面會調(diào)用對象的構(gòu)造方法；
• populateBean()：屬性對象的依賴注入，以及成員變量初始化；
• initializeBean()：里面有 4 個方法，

先執(zhí)行 aware 的 BeanNameAware、BeanFactoryAware 接口；

再執(zhí)行 BeanPostProcessor 前置接口；

然后執(zhí)行 InitializingBean 接口，以及配置的 init()；

最后執(zhí)行 BeanPostProcessor 的后置接口。

destory()：先執(zhí)行 DisposableBean 接口，再執(zhí)行配置的 destroyMethod()。

對于 populateBean()，里面的核心其實是對象的依賴注入，這里也是?？嫉闹R點，比如循環(huán)依賴，大家如果對這塊也感興趣，可以私下和我交流。

今天的源碼解析就到這，Spring 相關(guān)的源碼，還有哪些是大家想學(xué)習(xí)的呢，可以給樓仔留言。

這篇文章肝了我一個星期，原創(chuàng)不易，大家的點贊和分享，是我繼續(xù)創(chuàng)作的最大動力！

參考文章

三分惡的《Spring Bean生命周期，好像人的一生。?！罚篽ttps://juejin.cn/post/7075168883744718856