通過代碼分析spring中bean生命週期的過程

今天我們編寫一個簡單的demo來分析一下spring中整個bean的生命週期

編寫Demo

1. 首先我們定義一個BeanFactoryProcessor的類，目的是爲了看出PostProcessBeanFactory接口被調用的時間點

package cn.sue.spring.test.lifecycle;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

/**
 * <p>
 *
 * </p>
 *
 * @author Sue
 * @className MyBeanFactoryPostProcessor
 * @create 2023/4/25
 **/
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    public MyBeanFactoryPostProcessor() {
        super();
        System.out.println("【BeanFactoryPostProcessor】實現類的構造函數");
    }

    // 允許我們在工廠裏所有的bean被加載進來後但是還沒初始化前，對所有bean的屬性進行修改也可以add屬性值，該操作在對應bean的構造函數執行前
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory arg0) throws BeansException {
        System.out.println("BeanFactoryPostProcessor.postProcessBeanFactory()，來自MyBeanFactoryPostProcessor");
        //獲取到Spring中所有的beanName
        String[] beanStr = arg0.getBeanDefinitionNames();
        //循環打印
        for (String beanName : beanStr) {
            System.out.print("已加載的bean name:" + beanName + ";" + "\n");
        }
        System.out.println();
    }

}

2. 接着再寫一個實現了BeanPostProcessor的類，目的是爲了看出bean初始化前後的時間點

package cn.sue.spring.test.lifecycle;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

/**
 * <p>
 *
 * </p>
 *
 * @author Sue
 * @className MyBeanPostProcessor
 * @create 2023/4/25
 **/
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    public MyBeanPostProcessor() {
        super();
        System.out.println("BeanPostProcessor{}實現類的構造函數");
    }

    // 實例化、依賴注入完畢，在調用顯示的初始化之前完成一些定製的業務
    @Override
    public Object postProcessAfterInitialization(Object arg0, String arg1)
            throws BeansException {

        if (arg0.getClass() == TestBeanA.class || arg0.getClass() == TestBeanB.class) {
            System.out
                    .println("BeanPostProcessor.postProcessAfterInitialization() 來自MyBeanPostProcessor，beanName:" + arg1);
        }
        return arg0;
    }

    // 實例化、依賴注入、初始化後完成一些定製的業務
    @Override
    public Object postProcessBeforeInitialization(Object arg0, String arg1)
            throws BeansException {

        if (arg0.getClass() == TestBeanA.class || arg0.getClass() == TestBeanB.class) {
            System.out
                    .println("BeanPostProcessor.postProcessBeforeInitialization() 來自MyBeanPostProcessor，beanName:" + arg1);
        }
        return arg0;
    }

}

3. 再給出一個繼承了InstantiationAwareBeanPostProcessorAdapter的子類，目的是爲了看出postProcessBeforeInitialization、postProcessAfterInitialization、postProcessPropertyValues被調用的時間點

package cn.sue.spring.test.lifecycle;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.stereotype.Component;

import java.beans.PropertyDescriptor;

/**
 * <p>
 *
 * </p>
 *
 * @author Sue
 * @className MyInstantiationAwareBeanPostProcessor
 * @create 2023/4/25
 **/
@Component
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
    public MyInstantiationAwareBeanPostProcessor() {
        super();
        System.out
                .println("InstantiationAwareBeanPostProcessorAdapter{}實現類MyInstantiationAwareBeanPostProcessor{}的構造函數");
    }

    // 接口方法、實例化Bean之前調用
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

        if (bean.getClass() == TestBeanA.class || bean.getClass() == TestBeanB.class) {
            System.out
                    .println("InstantiationAwareBeanPostProcessorAdapter.postProcessBeforeInitialization() 來自MyInstantiationAwareBeanPostProcessor，beanName:" + beanName);

        }
        return bean;
    }

    // 接口方法、實例化Bean之後調用
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        if (bean.getClass() == TestBeanA.class || bean.getClass() == TestBeanB.class) {
            System.out
                    .println("InstantiationAwareBeanPostProcessorAdapter.postProcessAfterInitialization() 來自MyInstantiationAwareBeanPostProcessor，beanName:" + beanName);
        }

        return bean;
    }

    // 接口方法、設置某個屬性時調用
    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs,
                                                    PropertyDescriptor[] pds, Object bean, String beanName)
            throws BeansException {

        if (bean.getClass() == TestBeanA.class || bean.getClass() == TestBeanB.class) {
            System.out
                    .println("InstantiationAwareBeanPostProcessorAdapter.postProcessPropertyValues() 來自MyInstantiationAwareBeanPostProcessor，beanName:" + beanName);
        }

        return pvs;
    }

}

4. 再定義一個Bean，它使用applicationContext.xml進行註冊並實現了BeanFactoryAware, BeanNameAware,InitializingBean,DisposableBean四個接口類，目的是爲了清晰的看出以下好幾個接口被調用的時間點

package cn.sue.spring.test.lifecycle;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;

import javax.annotation.PostConstruct;

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

    private String name;
    private String address;
    private int phone;

    private BeanFactory beanFactory;
    private String beanName;

    @PostConstruct
    public void init() {
        System.out.println("TestBeanA{} @PostConstruct");
    }

    public TestBeanA() {
        System.out.println("TestBeanA{} 默認構造函數");
    }

    public TestBeanA(String name) {
        System.out.println("TestBeanA{} 有參構造函數");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public int getPhone() {
        return phone;
    }

    public void setPhone(int phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "TestBeanA [address=" + address + ", name=" + name + ", phone="
                + phone + "]";
    }

    // 這是BeanFactoryAware接口方法
    @Override
    public void setBeanFactory(BeanFactory arg0) throws BeansException {
        System.out
                .println("BeanFactoryAware.setBeanFactory() 來自TestBeanA");
        this.beanFactory = arg0;
    }

    // 這是BeanNameAware接口方法
    @Override
    public void setBeanName(String arg0) {
        System.out.println("BeanNameAware.setBeanName() 來自TestBeanA");
        this.beanName = arg0;
    }

    // 這是InitializingBean接口方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out
                .println("InitializingBean.afterPropertiesSet() 來自TestBeanA");
    }

    // 這是DiposibleBean接口方法
    @Override
    public void destroy() throws Exception {
        System.out.println("DiposibleBean.destory() 來自TestBeanA");
    }

    // 通過<bean>的init-method屬性指定的初始化方法
    public void myInit() {
        System.out.println("TestBeanA.myInit()");
    }

    // 通過<bean>的destroy-method屬性指定的初始化方法
    public void myDestory() {
        System.out.println("TestBeanA.destroy-method()");
    }
}

5. 最後，再定義一個TestBeanB，它的作用比較簡單，爲了看出內部數據成員有其他容器Bean的時候Spring是如何加載bean的

package cn.sue.spring.test.lifecycle;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class TestBeanB {

    @Autowired
    private TestBeanA testBeanA;

    public TestBeanB() {
        System.out.println("TestBeanB{} 默認構造器");
    }
}

6.applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="cn.sue.spring.test.lifecycle" >
    </context:component-scan>

<!--    <bean id="user" class="cn.sue.spring.test.core.UserService"></bean>-->
    <bean id="testBeanA" class="cn.sue.spring.test.lifecycle.TestBeanA" init-method="myInit" destroy-method="myDestory">
        <property name="name" value="Sue.test"/>
    </bean>
</beans>

7.加載容器進行測試

    @Test
    public void testLifeCycle() {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("spring.xml");
        classPathXmlApplicationContext.destroy();
    }

查看結果並分析

首先從

BeanFactoryPostProcessor{}實現類MyBeanFactoryPostProcessor{}的構造函數
BeanFactoryPostProcessor.postProcessBeanFactory()，來自MyBeanFactoryPostProcessor

BeanPostProcessor{}實現類MyBeanPostProcessor{}的構造函數
InstantiationAwareBeanPostProcessorAdapter{}實現類MyInstantiationAwareBeanPostProcessor{}的構造函數

可以看出執行順序是：

調用postProcessBeanFactory實現類的構造函數

BeanFactoryPostProcessor是bean工廠的處理器

調用postProcessBeanFactory實現類的postProcessBeanFactory實現函數

postProcessBeanFactory函數允許我們在工廠裏所有的bean被加載進來後但是還沒初始化前，對所有bean的屬性進行修改也可以add屬性值

調用BeanPostProcessor實現類的構造函數

完成bean實例化、配置以及其他初始化方法前後要添加一些自己邏輯處理則要實現接口BeanPostProcessor

調用InstantiationAwareBeanPostProcessorAdapter實現類的構造函數

適配器類，基類是BeanPostProcessor的實現類

再從

TestBeanB{} 默認構造器
InstantiationAwareBeanPostProcessorAdapter.postProcessPropertyValues() 來自MyInstantiationAwareBeanPostProcessor，beanName:testBeanB

可以看到，此處spring容器先掃描到了TestBeanB，因此調用順序是

TestBeanB的默認構造器【無參構造器】
調用InstantiationAwareBeanPostProcessorAdapter實現類的postProcessPropertyValues接口

postProcessPropertyValues在接口方法、設置某個屬性時調用，通過實驗看到實例化一個Bean的時候也會調用該接口方法

之後實例化TestBeanB的時候發現內部注入了TestBeanA，因此Spring轉而實例化TestBeanA。

接下來看到的是TestBeanA的實例化過程中調用的順序

TestBeanA{} 默認構造函數
InstantiationAwareBeanPostProcessorAdapter.postProcessPropertyValues() 來自MyInstantiationAwareBeanPostProcessor，beanName:testBeanA
BeanNameAware.setBeanName() 來自TestBeanA
BeanFactoryAware.setBeanFactory() 來自TestBeanA
BeanPostProcessor.postProcessBeforeInitialization() 來自MyBeanPostProcessor，beanName:testBeanA
InstantiationAwareBeanPostProcessorAdapter.postProcessBeforeInitialization() 來自MyInstantiationAwareBeanPostProcessor，beanName:testBeanA
TestBeanA{} @PostConstruct
InitializingBean.afterPropertiesSet() 來自TestBeanA
TestBeanA.myInit()
BeanPostProcessor.postProcessAfterInitialization() 來自MyBeanPostProcessor，beanName:testBeanA
InstantiationAwareBeanPostProcessorAdapter.postProcessAfterInitialization() 來自MyInstantiationAwareBeanPostProcessor，beanName:testBeanA

調用了TestBeanA的默認構造器
調用InstantiationAwareBeanPostProcessorAdapter實現類的postProcessPropertyValues接口
調用BeanNameAware的setBeanName接口

可以從源碼看到TestBeanA實現了接口BeanNameAware

調用BeanFactoryAware的setBeanFactory接口

可以從源碼看到TestBeanA實現了接口BeanFactoryAware

調用BeanPostProcessor的postProcessBeforeInitialization接口
調用InstantiationAwareBeanPostProcessorAdapter的postProcessBeforeInitialization接口
調用TestBeanA中註解了@PostConstruct的函數
調用了InitializingBean的afterPropertiesSet接口

可以從源碼看到TestBeanA實現了接口InitializingBean

調用了TestBeanA的myInit接口

可以看到該init-method接口是在applicationContext中init-method配置上的

調用BeanPostProcessor實現類的postProcessAfterInitialization接口
調用InstantiationAwareBeanPostProcessorAdapter子類的postProcessAfterInitialization接口

等TestBeanA實例化結束後，則繼續TestBeanB的實例化路程

BeanPostProcessor.postProcessBeforeInitialization() 來自MyBeanPostProcessor，beanName:testBeanB
InstantiationAwareBeanPostProcessorAdapter.postProcessBeforeInitialization() 來自MyInstantiationAwareBeanPostProcessor，beanName:testBeanB
BeanPostProcessor.postProcessAfterInitialization() 來自MyBeanPostProcessor，beanName:testBeanB
InstantiationAwareBeanPostProcessorAdapter.postProcessAfterInitialization() 來自MyInstantiationAwareBeanPostProcessor，beanName:testBeanB

調用BeanPostProcessor實現類的postProcessBeforeInitialization接口
調用InstantiationAwareBeanPostProcessorAdapter子類的postProcessBeforeInitialization接口
調用BeanPostProcessor實現類的postProcessAfterInitialization接口
調用InstantiationAwareBeanPostProcessorAdapter子類的postProcessAfterInitialization接口

最後

DiposibleBean.destory() 來自TestBeanA
TestBeanA.destroy-method()

調用DiposibleBean實現類的destory接口

TestBeanA實現了DiposibleBean接口，實現了destroy接口

調用TestBeanA的myDestory函數

可以看到該myDestory接口是在applicationContext中destroy-method配置上的。

最終總結

【超重點，面試回答模板】

如果有bean實現了BeanFactoryPostProcessor接口類，則會實例化該bean，並且調用默認構造器，然後調用postProcessBeanFactory接口
如果有bean實現了BeanPostProcessor接口類，則會先實例化該bean，同樣調用默認構造器
如果有bean繼承了InstantiationAwareBeanPostProcessorAdapter類，則會先實例化該bean，同樣調用默認構造器

之後真正進入一個bean的生命週期過程

先調用bean的默認構造函數
如果有bean繼承了InstantiationAwareBeanPostProcessorAdapter類，此刻會調用postProcessPropertyValues函數
如果這個bean已經實現了BeanNameAware接口，會調用它實現的setBeanName方法，此處傳遞的就是applicationContext.xml配置文件中Bean的id值
如果這個bean已經實現了BeanFactoryAware接口，會調用它實現的setBeanFactory，傳遞的是Spring工廠自身
如果存在其他bean實現了BeanPostProcessor接口，將會調用postProcessBeforeInitialization(Object obj, String s)方法，BeanPostProcessor經常被用作是Bean內容的更改，並且由於這個是在Bean初始化結束時調用那個的方法，也可以被應用於內存或緩存技術；
如果存在其他bean繼承了InstantiationAwareBeanPostProcessorAdapter類，則會調用postProcessBeforeInitialization接口
如果這個bean中有函數加了@PostConstruct註解，則該函數會在此刻被調用
如果這個bean實現了InitializingBean接口重寫了afterPropertiesSet方法，該方法會在此刻被調用
如果這個bean在Spring配置文件中配置了init-method屬性，則會自動調用其配置的初始化方法。
如果存在其他bean實現了BeanPostProcessor接口，將會調用postProcessAfterInitialization(Object obj, String s)方法
如果存在其他bean繼承了InstantiationAwareBeanPostProcessorAdapter類，則會調用postProcessAfterInitialization接口

走到這一步以後就可以應用這個Bean了，而這個Bean是一個Singleton的，雖然在Spring配置文件中也可以配置非Singleton，這裏不做贅述。

走入銷燬階段

當bean不再需要時，會經過清理階段，如果這個bean實現了DisposableBean接口，會調用其實現的destroy()方法；
如果這個bean的applicationContext.xml配置中配置了destroy-method屬性，會自動調用其配置的銷燬方法。

本案例demo下載地址 suyang320/spring_study (github.com)

通過代碼分析spring中bean生命週期的過程

編寫Demo

1. 首先我們定義一個BeanFactoryProcessor的類，目的是爲了看出PostProcessBeanFactory接口被調用的時間點

2. 接着再寫一個實現了BeanPostProcessor的類，目的是爲了看出bean初始化前後的時間點

3. 再給出一個繼承了InstantiationAwareBeanPostProcessorAdapter的子類，目的是爲了看出postProcessBeforeInitialization、postProcessAfterInitialization、postProcessPropertyValues被調用的時間點

4. 再定義一個Bean，它使用applicationContext.xml進行註冊並實現了BeanFactoryAware, BeanNameAware,InitializingBean,DisposableBean四個接口類，目的是爲了清晰的看出以下好幾個接口被調用的時間點

5. 最後，再定義一個TestBeanB，它的作用比較簡單，爲了看出內部數據成員有其他容器Bean的時候Spring是如何加載bean的

6.applicationContext.xml

7.加載容器進行測試

查看結果並分析

最終總結

14.SpringMVC啓動與請求處理流程解析

通過代碼分析spring中bean生命週期的過程

13.Spring 6.0及SpringBoot 3.0新特性解析

12.Spring之事務底層源碼解析

11.Spring之AOP底層源碼解析（下）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結