3.Spring之Bean生命週期源碼解析

Spring最重要的功能就是幫助程序員創建對象（也就是IOC），而啓動Spring就是爲創建Bean對象做準備，所以我們先明白Spring到底是怎麼去創建Bean的，也就是先弄明白Bean的生命週期。

Bean的生命週期就是指：在Spring中，一個Bean是如何生成的，如何銷燬的

Bean生命週期流程圖：https://www.processon.com/view/link/5f8588c87d9c0806f27358c1

附帶資料JFR介紹：https://zhuanlan.zhihu.com/p/122247741

Bean的生成過程

1. 生成BeanDefinition

Spring啓動的時候會進行掃描，會先調用 org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents(String basePackage)

掃描某個包路徑，並得到BeanDefinition的Set集合。

關於Spring啓動流程，後續會單獨的課詳細講，這裏先講一下Spring掃描的底層實現：

Spring掃描底層流程：https://www.processon.com/view/link/61370ee60e3e7412ecd95d43

1. 首先，通過ResourcePatternResolver獲得指定包路徑下的所有.class文件（Spring源碼中將此文件包裝成了Resource對象）
2. 遍歷每個Resource對象
3. 利用MetadataReaderFactory解析Resource對象得到MetadataReader（在Spring源碼中MetadataReaderFactory具體的實現類爲CachingMetadataReaderFactory，MetadataReader的具體實現類爲SimpleMetadataReader）
4. 利用MetadataReader進行excludeFilters和includeFilters，以及條件註解@Conditional的篩選（條件註解並不能理解：某個類上是否存在@Conditional註解，如果存在則調用註解中所指定的類的match方法進行匹配，匹配成功則通過篩選，匹配失敗則pass掉。）
5. 篩選通過後，基於metadataReader生成ScannedGenericBeanDefinition
6. 再基於metadataReader判斷是不是對應的類是不是接口或抽象類
7. 如果篩選通過，那麼就表示掃描到了一個Bean，將ScannedGenericBeanDefinition加入結果集

MetadataReader表示類的元數據讀取器，主要包含了一個AnnotationMetadata，功能有

1. 獲取類的名字、
2. 獲取父類的名字
3. 獲取所實現的所有接口名
4. 獲取所有內部類的名字
5. 判斷是不是抽象類
6. 判斷是不是接口
7. 判斷是不是一個註解
8. 獲取擁有某個註解的方法集合
9. 獲取類上添加的所有註解信息
10. 獲取類上添加的所有註解類型集合

值得注意的是，CachingMetadataReaderFactory解析某個.class文件得到MetadataReader對象是利用的ASM技術，並沒有加載這個類到JVM。並且，最終得到的ScannedGenericBeanDefinition對象，beanClass屬性存儲的是當前類的名字，而不是class對象。（beanClass屬性的類型是Object，它即可以存儲類的名字，也可以存儲class對象）

最後，上面是說的通過掃描得到BeanDefinition對象，我們還可以通過直接定義BeanDefinition，或解析spring.xml文件的<bean/>，或者@Bean註解得到BeanDefinition對象。（後續課程會分析@Bean註解是怎麼生成BeanDefinition的）。

2. 合併BeanDefinition

通過掃描得到所有BeanDefinition之後，就可以根據BeanDefinition創建Bean對象了，但是在Spring中支持父子BeanDefinition，和Java父子類類似，但是完全不是一回事。

父子BeanDefinition實際用的比較少，使用是這樣的，比如：

<bean id="parent" class="com.zhouyu.service.Parent" scope="prototype"/>
<bean id="child" class="com.zhouyu.service.Child"/>

這麼定義的情況下，child是單例Bean。

<bean id="parent" class="com.zhouyu.service.Parent" scope="prototype"/>
<bean id="child" class="com.zhouyu.service.Child" parent="parent"/>

但是這麼定義的情況下，child就是原型Bean了。

因爲child的父BeanDefinition是parent，所以會繼承parent上所定義的scope屬性。

而在根據child來生成Bean對象之前，需要進行BeanDefinition的合併，得到完整的child的BeanDefinition。

3. 加載類

BeanDefinition合併之後，就可以去創建Bean對象了，而創建Bean就必須實例化對象，而實例化就必須先加載當前BeanDefinition所對應的class，在AbstractAutowireCapableBeanFactory類的createBean()方法中，一開始就會調用：

Class<?> resolvedClass = resolveBeanClass(mbd, beanName);

這行代碼就是去加載類，該方法是這麼實現的：

if (mbd.hasBeanClass()) {
    return mbd.getBeanClass();
}
if (System.getSecurityManager() != null) {
    return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
        doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
    }
else {
    return doResolveBeanClass(mbd, typesToMatch);
}

public boolean hasBeanClass() {
    return (this.beanClass instanceof Class);
}

如果beanClass屬性的類型是Class，那麼就直接返回，如果不是，則會根據類名進行加載（doResolveBeanClass方法所做的事情）
會利用BeanFactory所設置的類加載器來加載類，如果沒有設置，則默認使用ClassUtils.getDefaultClassLoader()所返回的類加載器來加載。

ClassUtils.getDefaultClassLoader()
1優先返回當前線程中的ClassLoader
2線程中類加載器爲null的情況下，返回ClassUtils類的類加載器
3如果ClassUtils類的類加載器爲空，那麼則表示是Bootstrap類加載器加載的ClassUtils類，那麼則返回系統類加載器

4. 實例化前

當前BeanDefinition對應的類成功加載後，就可以實例化對象了，但是...

在Spring中，實例化對象之前，Spring提供了一個擴展點，允許用戶來控制是否在某個或某些Bean實例化之前做一些啓動動作。這個擴展點叫InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()。比如：

@Component
public class ZhouyuBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("實例化前");
        }
        return null;
    }
}

如上代碼會導致，在userService這個Bean實例化前，會進行打印。

值得注意的是，postProcessBeforeInstantiation()是有返回值的，如果這麼實現：

@Component
public class ZhouyuBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("實例化前");
            return new UserService();
        }
        return null;
    }
}

userService這個Bean，在實例化前會直接返回一個由我們所定義的UserService對象。如果是這樣，表示不需要Spring來實例化了，並且後續的Spring依賴注入也不會進行了，會跳過一些步驟，直接執行初始化後這一步。

5. 實例化

在這個步驟中就會根據BeanDefinition去創建一個對象了。

5.1 Supplier創建對象

首先判斷BeanDefinition中是否設置了Supplier，如果設置了則調用Supplier的get()得到對象。

得直接使用BeanDefinition對象來設置Supplier，比如：

AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setInstanceSupplier(new Supplier<Object>() {
    @Override
    public Object get() {
        return new UserService();
    }
});
context.registerBeanDefinition("userService", beanDefinition);

5.2 工廠方法創建對象

如果沒有設置Supplier，則檢查BeanDefinition中是否設置了factoryMethod，也就是工廠方法，有兩種方式可以設置factoryMethod，比如：

方式一：

<bean id="userService" class="com.zhouyu.service.UserService" factory-method="createUserService" />

對應的UserService類爲：

public class UserService {

    public static UserService createUserService() {
        System.out.println("執行createUserService()");
        UserService userService = new UserService();
        return userService;
    }

    public void test() {
        System.out.println("test");
    }
}

方式二：

<bean id="commonService" class="com.zhouyu.service.CommonService"/>
<bean id="userService1" factory-bean="commonService" factory-method="createUserService" />

對應的CommonService的類爲：

public class CommonService {

    public UserService createUserService() {
        return new UserService();
    }
}

Spring發現當前BeanDefinition方法設置了工廠方法後，就會區分這兩種方式，然後調用工廠方法得到對象。

值得注意的是，我們通過@Bean所定義的BeanDefinition，是存在factoryMethod和factoryBean的，也就是和上面的方式二非常類似，@Bean所註解的方法就是factoryMethod，AppConfig對象就是factoryBean。如果@Bean所所註解的方法是static的，那麼對應的就是方式一。

Spring發現當前BeanDefinition方法設置了工廠方法後，就會區分這兩種方式，然後調用工廠方法得到對象。

值得注意的是，我們通過@Bean所定義的BeanDefinition，是存在factoryMethod和factoryBean的，也就是和上面的方式二非常類似，@Bean所註解的方法就是factoryMethod，AppConfig對象就是factoryBean。如果@Bean所所註解的方法是static的，那麼對應的就是方式一。

@Component
public class UserService {

    private OrderService orderService;

    public void test() {
        OrderService orderService = createOrderService();
        System.out.println(orderService);
    }

    @Lookup("orderService")
    public OrderService createOrderService() {
        return null;
    }

}

6. BeanDefinition的後置處理

Bean對象實例化出來之後，接下來就應該給對象的屬性賦值了。在真正給屬性賦值之前，Spring又提供了一個擴展點MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()，可以對此時的BeanDefinition進行加工，比如：

@Component
public class ZhouyuMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {

    @Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        if ("userService".equals(beanName)) {
            beanDefinition.getPropertyValues().add("orderService", new OrderService());
        }
    }
}

在Spring源碼中，AutowiredAnnotationBeanPostProcessor就是一個MergedBeanDefinitionPostProcessor，它的postProcessMergedBeanDefinition()中會去查找注入點，並緩存在AutowiredAnnotationBeanPostProcessor對象的一個Map中（injectionMetadataCache）。

7. 實例化後

在處理完BeanDefinition後，Spring又設計了一個擴展點：InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()，比如：

@Component
public class ZhouyuInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {

        if ("userService".equals(beanName)) {
            UserService userService = (UserService) bean;
            userService.test();
        }

        return true;
    }
}

上述代碼就是對userService所實例化出來的對象進行處理。

這個擴展點，在Spring源碼中基本沒有怎麼使用。

8. 自動注入

這裏的自動注入指的是Spring的自動注入，後續依賴注入課程中單獨講

9. 處理屬性

這個步驟中，就會處理@Autowired、@Resource、@Value等註解，也是通過InstantiationAwareBeanPostProcessor.postProcessProperties()擴展點來實現的，比如我們甚至可以實現一個自己的自動注入功能，比如：

@Component
public class ZhouyuInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            for (Field field : bean.getClass().getFields()) {
                if (field.isAnnotationPresent(ZhouyuInject.class)) {
                    field.setAccessible(true);
                    try {
                        field.set(bean, "123");
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        return pvs;
    }
}

關於@Autowired、@Resource、@Value的底層源碼，會在後續的依賴注入課程中詳解。

10. 執行Aware

完成了屬性賦值之後，Spring會執行一些回調，包括：

1. BeanNameAware：回傳beanName給bean對象。
2. BeanClassLoaderAware：回傳classLoader給bean對象。
3. BeanFactoryAware：回傳beanFactory給對象。

11. 初始化前

初始化前，也是Spring提供的一個擴展點：BeanPostProcessor.postProcessBeforeInitialization()，比如

@Component
public class ZhouyuBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("初始化前");
        }

        return bean;
    }
}

利用初始化前，可以對進行了依賴注入的Bean進行處理。

在Spring源碼中：

1. InitDestroyAnnotationBeanPostProcessor會在初始化前這個步驟中執行@PostConstruct的方法，
2. ApplicationContextAwareProcessor會在初始化前這個步驟中進行其他Aware的回調：

1. EnvironmentAware：回傳環境變量
2. EmbeddedValueResolverAware：回傳佔位符解析器
3. ResourceLoaderAware：回傳資源加載器
4. ApplicationEventPublisherAware：回傳事件發佈器
5. MessageSourceAware：回傳國際化資源
6. ApplicationStartupAware：回傳應用其他監聽對象，可忽略
7. ApplicationContextAware：回傳Spring容器ApplicationContext

12. 初始化

1. 查看當前Bean對象是否實現了InitializingBean接口，如果實現了就調用其afterPropertiesSet()方法
2. 執行BeanDefinition中指定的初始化方法

13. 初始化後

這是Bean創建生命週期中的最後一個步驟，也是Spring提供的一個擴展點：BeanPostProcessor.postProcessAfterInitialization()，比如：

@Component
public class ZhouyuBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("初始化後");
        }

        return bean;
    }
}

可以在這個步驟中，對Bean最終進行處理，Spring中的AOP就是基於初始化後實現的，初始化後返回的對象纔是最終的Bean對象。

總結BeanPostProcessor

1. InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
2. 實例化
3. MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()
4. InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()
5. 自動注入
6. InstantiationAwareBeanPostProcessor.postProcessProperties()
7. Aware對象
8. BeanPostProcessor.postProcessBeforeInitialization()
9. 初始化
10. BeanPostProcessor.postProcessAfterInitialization()

Bean的銷燬過程

Bean銷燬是發送在Spring容器關閉過程中的。

在Spring容器關閉時，比如： 

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = (UserService) context.getBean("userService");
userService.test();

// 容器關閉
context.close();

在Bean創建過程中，在最後（初始化之後），有一個步驟會去判斷當前創建的Bean是不是DisposableBean：

1. 當前Bean是否實現了DisposableBean接口
2. 或者，當前Bean是否實現了AutoCloseable接口
3. BeanDefinition中是否指定了destroyMethod
4. 調用DestructionAwareBeanPostProcessor.requiresDestruction(bean)進行判斷

1. ApplicationListenerDetector中直接使得ApplicationListener是DisposableBean
2. InitDestroyAnnotationBeanPostProcessor中使得擁有@PreDestroy註解了的方法就是DisposableBean

5. 把符合上述任意一個條件的Bean適配成DisposableBeanAdapter對象，並存入disposableBeans中（一個LinkedHashMap）

在Spring容器關閉過程時：

1. 首先發布ContextClosedEvent事件
2. 調用lifecycleProcessor的onCloese()方法
3. 銷燬單例Bean

　　　　a. 遍歷disposableBeans

• 把每個disposableBean從單例池中移除
• 調用disposableBean的destroy()
• 如果這個disposableBean還被其他Bean依賴了，那麼也得銷燬其他Bean
• 如果這個disposableBean還包含了inner beans，將這些Bean從單例池中移除掉 (inner bean參考https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-inner-beans)

　　　　b. 清空manualSingletonNames，是一個Set，存的是用戶手動註冊的單例Bean的beanName

　　　　c. 清空allBeanNamesByType，是一個Map，key是bean類型，value是該類型所有的beanName數組

　　　　d. 清空singletonBeanNamesByType，和allBeanNamesByType類似，只不過只存了單例Bean

這裏涉及到一個設計模式：適配器模式

在銷燬時，Spring會找出實現了DisposableBean接口的Bean。

但是我們在定義一個Bean時，如果這個Bean實現了DisposableBean接口，或者實現了AutoCloseable接口，或者在BeanDefinition中指定了destroyMethodName，那麼這個Bean都屬於“DisposableBean”，這些Bean在容器關閉時都要調用相應的銷燬方法。

所以，這裏就需要進行適配，將實現了DisposableBean接口、或者AutoCloseable接口等適配成實現了DisposableBean接口，所以就用到了DisposableBeanAdapter。

會把實現了AutoCloseable接口的類封裝成DisposableBeanAdapter，而DisposableBeanAdapter實現了DisposableBean接口。

本系列文章來自圖靈學院周瑜老師分享，本博客整理並搬運