去字節面試，直接讓人出門左拐：Bean 生命週期都不知道！詳情 - 後端,spring,bean,生命週期,java 濤聲依舊博客

前言

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

如果只講基礎知識，感覺和網上大多數文章沒有區別，但是我又想寫得稍微深入一點。

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

1. 基礎知識

1.1 什麼是 IoC ？

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

IoC 很好地體現了面向對象設計法則之一 —— 好萊塢法則：“別找我們，我們找你”，即由 IoC 容器幫對象找相應的依賴對象並注入，而不是由對象主動去找。

理解好 IoC 的關鍵是要明確 “誰控制誰，控制什麼，為何是反轉（有反轉就應該有正轉了），哪些方面反轉了”。

誰控制誰，控制什麼？

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

誰控制誰？當然是 IoC 容器控制了對象；
控制什麼？主要控制了外部資源獲取（不只是對象，比如包括文件等）。

為何是反轉，哪些方面反轉了？

有反轉就有正轉，傳統應用程序是由我們自己在對象中主動控制去直接獲取依賴對象，也就是正轉，而反轉則是由容器來幫忙創建及注入依賴對象。

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

1.2 Bean 生命週期

對 Prototype Bean 來説，當用户 getBean 獲得 Prototype Bean 的實例後，IOC 容器就不再對當前實例進行管理，而是把管理權交由用户，此後再 getBean 生成的是新的實例。

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

Bean 生命週期過程：

實例化：第 1 步，實例化一個 Bean 對象；
屬性賦值：第 2 步，為 Bean 設置相關屬性和依賴；
初始化：初始化的階段的步驟比較多，5、6 步是真正的初始化，第 3、4 步為在初始化前執行，第 7 步在初始化後執行，初始化完成之後，Bean 就可以被使用了；
銷燬：第 8~10 步，第 8 步其實也可以算到銷燬階段，但不是真正意義上的銷燬，而是先在使用前註冊了銷燬的相關調用接口，為了後面第 9、10 步真正銷燬 Bean 時再執行相應的方法。

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

1.3 執行流程

創建一個 LouzaiBean。

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

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

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

    public String getName() {
        return name;
    }

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

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

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

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

    public void init() {
        System.out.println("7.自定義init方法：努力上學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方法：到學校報名啦");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("8.BeanPostProcessor#postProcessAfterInitialization方法：終於畢業，拿到畢業證啦！");
        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();
    }
}

執行結果：

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

這個流程非常清晰，Bean 生命週期流程圖能完全對應起來。

1.4 擴展方法

我們發現，整個生命週期有很多擴展過程，大致可以分為 4 類：

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