Spring Bean的生命周期只有這四個階段。把這四個階段和每個階段對應(yīng)的擴(kuò)展點(diǎn)糅合在一起雖然沒有問題，但是這樣非常凌亂，難以記憶。要徹底搞清楚Spring的生命周期，首先要把這四個階段牢牢記住。實(shí)例化和屬性賦值對應(yīng)構(gòu)造方法和setter方法的注入，初始化和銷毀是用戶能自定義擴(kuò)展的兩個階段。在這四步之間穿插的各種擴(kuò)展點(diǎn)，稍后會講。
- 實(shí)例化 Instantiation
- 屬性賦值 Populate
- 初始化 Initialization
- 銷毀 Destruction
實(shí)例化 -> 屬性賦值 -> 初始化 -> 銷毀
主要邏輯都在doCreate()方法中，邏輯很清晰，就是順序調(diào)用以下三個方法，這三個方法與三個生命周期階段一一對應(yīng)，非常重要，在后續(xù)擴(kuò)展接口分析中也會涉及。
- createBeanInstance() -> 實(shí)例化
- populateBean() -> 屬性賦值
- initializeBean() -> 初始化
源碼如下，能證明實(shí)例化，屬性賦值和初始化這三個生命周期的存在。關(guān)于本文的Spring源碼都將忽略無關(guān)部分，便于理解：
// 忽略了無關(guān)代碼
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (instanceWrapper == null) {
// 實(shí)例化階段！
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 屬性賦值階段！
populateBean(beanName, mbd, instanceWrapper);
// 初始化階段！
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
至于銷毀，是在容器關(guān)閉時調(diào)用的，詳見ConfigurableApplicationContext#close()
常用擴(kuò)展點(diǎn)
Spring生命周期相關(guān)的常用擴(kuò)展點(diǎn)非常多，所以問題不是不知道，而是記不住或者記不牢。其實(shí)記不住的根本原因還是不夠了解，這里通過源碼+分類的方式幫大家記憶。
第一大類：影響多個Bean的接口
實(shí)現(xiàn)了這些接口的Bean會切入到多個Bean的生命周期中。正因為如此，這些接口的功能非常強(qiáng)大，Spring內(nèi)部擴(kuò)展也經(jīng)常使用這些接口，例如自動注入以及AOP的實(shí)現(xiàn)都和他們有關(guān)。
- BeanPostProcessor
- InstantiationAwareBeanPostProcessor
這兩兄弟可能是Spring擴(kuò)展中最重要的兩個接口！InstantiationAwareBeanPostProcessor作用于實(shí)例化階段的前后，BeanPostProcessor作用于初始化階段的前后。正好和第一、第三個生命周期階段對應(yīng)。通過圖能更好理解：
InstantiationAwareBeanPostProcessor實(shí)際上繼承了BeanPostProcessor接口，嚴(yán)格意義上來看他們不是兩兄弟，而是兩父子。但是從生命周期角度我們重點(diǎn)關(guān)注其特有的對實(shí)例化階段的影響，圖中省略了從BeanPostProcessor繼承的方法。
InstantiationAwareBeanPostProcessor extends BeanPostProcessor
InstantiationAwareBeanPostProcessor源碼分析：
- postProcessBeforeInstantiation調(diào)用點(diǎn)，忽略無關(guān)代碼：
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// postProcessBeforeInstantiation方法調(diào)用點(diǎn)，這里就不跟進(jìn)了，
// 有興趣的同學(xué)可以自己看下，就是for循環(huán)調(diào)用所有的InstantiationAwareBeanPostProcessor
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
try {
// 上文提到的doCreateBean方法，可以看到
// postProcessBeforeInstantiation方法在創(chuàng)建Bean之前調(diào)用
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
}
可以看到，postProcessBeforeInstantiation在doCreateBean之前調(diào)用，也就是在bean實(shí)例化之前調(diào)用的，英文源碼注釋解釋道該方法的返回值會替換原本的Bean作為代理，這也是Aop等功能實(shí)現(xiàn)的關(guān)鍵點(diǎn)。
- postProcessAfterInstantiation調(diào)用點(diǎn)，忽略無關(guān)代碼：
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
boolean continueWithPropertyPopulation = true;
// InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation()
// 方法作為屬性賦值的前置檢查條件，在屬性賦值之前執(zhí)行，能夠影響是否進(jìn)行屬性賦值！
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
// 忽略后續(xù)的屬性賦值操作代碼
}
可以看到該方法在屬性賦值方法內(nèi)，但是在真正執(zhí)行賦值操作之前。其返回值為boolean，返回false時可以阻斷屬性賦值階段（continueWithPropertyPopulation = false;）。
關(guān)于BeanPostProcessor執(zhí)行階段的源碼穿插在下文Aware接口的調(diào)用時機(jī)分析中，因為部分Aware功能的就是通過他實(shí)現(xiàn)的!只需要先記住BeanPostProcessor在初始化前后調(diào)用就可以了。
第二大類：只調(diào)用一次的接口
這一大類接口的特點(diǎn)是功能豐富，常用于用戶自定義擴(kuò)展。
第二大類中又可以分為兩類：
- Aware類型的接口
- 生命周期接口
無所不知的Aware
Aware類型的接口的作用就是讓我們能夠拿到Spring容器中的一些資源?；径寄軌蛞娒?，Aware之前的名字就是可以拿到什么資源，例如BeanNameAware可以拿到BeanName，以此類推。調(diào)用時機(jī)需要注意：所有的Aware方法都是在初始化階段之前調(diào)用的！
Aware接口眾多，這里同樣通過分類的方式幫助大家記憶。
Aware接口具體可以分為兩組，至于為什么這么分，詳見下面的源碼分析。如下排列順序同樣也是Aware接口的執(zhí)行順序，能夠見名知意的接口不再解釋。
Aware Group1
- BeanNameAware
- BeanClassLoaderAware
- BeanFactoryAware
Aware Group2
- EnvironmentAware
- EmbeddedValueResolverAware 這個知道的人可能不多，實(shí)現(xiàn)該接口能夠獲取Spring EL解析器，用戶的自定義注解需要支持spel表達(dá)式的時候可以使用，非常方便。
- ApplicationContextAware(ResourceLoaderAware\ApplicationEventPublisherAware\MessageSourceAware) 這幾個接口可能讓人有點(diǎn)懵，實(shí)際上這幾個接口可以一起記，其返回值實(shí)質(zhì)上都是當(dāng)前的ApplicationContext對象，因為ApplicationContext是一個復(fù)合接口，如下：
public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
MessageSource, ApplicationEventPublisher, ResourcePatternResolver {}
這里涉及到另一道面試題，ApplicationContext和BeanFactory的區(qū)別，可以從ApplicationContext繼承的這幾個接口入手，除去BeanFactory相關(guān)的兩個接口就是ApplicationContext獨(dú)有的功能，這里不詳細(xì)說明。
Aware調(diào)用時機(jī)源碼分析
詳情如下，忽略了部分無關(guān)代碼。代碼位置就是我們上文提到的initializeBean方法詳情，這也說明了Aware都是在初始化階段之前調(diào)用的！
// 見名知意，初始化階段調(diào)用的方法
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
// 這里調(diào)用的是Group1中的三個Bean開頭的Aware
invokeAwareMethods(beanName, bean);
Object wrappedBean = bean;
// 這里調(diào)用的是Group2中的幾個Aware，
// 而實(shí)質(zhì)上這里就是前面所說的BeanPostProcessor的調(diào)用點(diǎn)！
// 也就是說與Group1中的Aware不同，這里是通過BeanPostProcessor（ApplicationContextAwareProcessor）實(shí)現(xiàn)的。
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
// 下文即將介紹的InitializingBean調(diào)用點(diǎn)
invokeInitMethods(beanName, wrappedBean, mbd);
// BeanPostProcessor的另一個調(diào)用點(diǎn)
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
return wrappedBean;
}
可以看到并不是所有的Aware接口都使用同樣的方式調(diào)用。Bean××Aware都是在代碼中直接調(diào)用的，而ApplicationContext相關(guān)的Aware都是通過BeanPostProcessor#postProcessBeforeInitialization()實(shí)現(xiàn)的。感興趣的可以自己看一下ApplicationContextAwareProcessor這個類的源碼，就是判斷當(dāng)前創(chuàng)建的Bean是否實(shí)現(xiàn)了相關(guān)的Aware方法，如果實(shí)現(xiàn)了會調(diào)用回調(diào)方法將資源傳遞給Bean。
至于Spring為什么這么實(shí)現(xiàn)，應(yīng)該沒什么特殊的考量。也許和Spring的版本升級有關(guān)?；趯π薷年P(guān)閉，對擴(kuò)展開放的原則，Spring對一些新的Aware采用了擴(kuò)展的方式添加。
BeanPostProcessor的調(diào)用時機(jī)也能在這里體現(xiàn)，包圍住invokeInitMethods方法，也就說明了在初始化階段的前后執(zhí)行。
關(guān)于Aware接口的執(zhí)行順序，其實(shí)只需要記住第一組在第二組執(zhí)行之前就行了。每組中各個Aware方法的調(diào)用順序其實(shí)沒有必要記，有需要的時候點(diǎn)進(jìn)源碼一看便知。
簡單的兩個生命周期接口
至于剩下的兩個生命周期接口就很簡單了，實(shí)例化和屬性賦值都是Spring幫助我們做的，能夠自己實(shí)現(xiàn)的有初始化和銷毀兩個生命周期階段。
- InitializingBean 對應(yīng)生命周期的初始化階段，在上面源碼的
invokeInitMethods(beanName, wrappedBean, mbd);方法中調(diào)用。
有一點(diǎn)需要注意，因為Aware方法都是執(zhí)行在初始化方法之前，所以可以在初始化方法中放心大膽的使用Aware接口獲取的資源，這也是我們自定義擴(kuò)展Spring的常用方式。
除了實(shí)現(xiàn)InitializingBean接口之外還能通過注解或者xml配置的方式指定初始化方法，至于這幾種定義方式的調(diào)用順序其實(shí)沒有必要記。因為這幾個方法對應(yīng)的都是同一個生命周期，只是實(shí)現(xiàn)方式不同，我們一般只采用其中一種方式。 - DisposableBean 類似于InitializingBean，對應(yīng)生命周期的銷毀階段，以ConfigurableApplicationContext#close()方法作為入口，實(shí)現(xiàn)是通過循環(huán)取所有實(shí)現(xiàn)了DisposableBean接口的Bean然后調(diào)用其destroy()方法 。感興趣的可以自行跟一下源碼。
擴(kuò)展閱讀: BeanPostProcessor 注冊時機(jī)與執(zhí)行順序
注冊時機(jī)
我們知道BeanPostProcessor也會注冊為Bean，那么Spring是如何保證BeanPostProcessor在我們的業(yè)務(wù)Bean之前初始化完成呢？
請看我們熟悉的refresh()方法的源碼，省略部分無關(guān)代碼：
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 所有BeanPostProcesser初始化的調(diào)用點(diǎn)
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
// 所有單例非懶加載Bean的調(diào)用點(diǎn)
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
}
可以看出，Spring是先執(zhí)行registerBeanPostProcessors()進(jìn)行BeanPostProcessors的注冊，然后再執(zhí)行finishBeanFactoryInitialization初始化我們的單例非懶加載的Bean。
執(zhí)行順序
BeanPostProcessor有很多個，而且每個BeanPostProcessor都影響多個Bean，其執(zhí)行順序至關(guān)重要，必須能夠控制其執(zhí)行順序才行。關(guān)于執(zhí)行順序這里需要引入兩個排序相關(guān)的接口：PriorityOrdered、Ordered
PriorityOrdered是一等公民，首先被執(zhí)行，PriorityOrdered公民之間通過接口返回值排序
Ordered是二等公民，然后執(zhí)行，Ordered公民之間通過接口返回值排序
都沒有實(shí)現(xiàn)是三等公民，最后執(zhí)行
在以下源碼中，可以很清晰的看到Spring注冊各種類型BeanPostProcessor的邏輯，根據(jù)實(shí)現(xiàn)不同排序接口進(jìn)行分組。優(yōu)先級高的先加入，優(yōu)先級低的后加入。
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
// 首先，加入實(shí)現(xiàn)了PriorityOrdered接口的BeanPostProcessors，順便根據(jù)PriorityOrdered排了序
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
// 然后，加入實(shí)現(xiàn)了Ordered接口的BeanPostProcessors，順便根據(jù)Ordered排了序
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
// 最后加入其他常規(guī)的BeanPostProcessors
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
根據(jù)排序接口返回值排序，默認(rèn)升序排序，返回值越低優(yōu)先級越高。
/**
* Useful constant for the highest precedence value.
* @see java.lang.Integer#MIN_VALUE
*/
int HIGHEST_PRECEDENCE = Integer.MIN_VALUE;
/**
* Useful constant for the lowest precedence value.
* @see java.lang.Integer#MAX_VALUE
*/
int LOWEST_PRECEDENCE = Integer.MAX_VALUE;
PriorityOrdered、Ordered接口作為Spring整個框架通用的排序接口，在Spring中應(yīng)用廣泛，也是非常重要的接口。
總結(jié)
Spring Bean的生命周期分為四個階段和多個擴(kuò)展點(diǎn)。擴(kuò)展點(diǎn)又可以分為影響多個Bean和影響單個Bean。整理如下：
四個階段
- 實(shí)例化 Instantiation
- 屬性賦值 Populate
- 初始化 Initialization
- 銷毀 Destruction
多個擴(kuò)展點(diǎn)
- 影響多個Bean
- BeanPostProcessor
- InstantiationAwareBeanPostProcessor
- 影響單個Bean
- Aware
- Aware Group1
- BeanNameAware
- BeanClassLoaderAware
- BeanFactoryAware
- Aware Group2
- EnvironmentAware
- EmbeddedValueResolverAware
- ApplicationContextAware(ResourceLoaderAware\ApplicationEventPublisherAware\MessageSourceAware)
- Aware Group1
- 生命周期
- InitializingBean
- DisposableBean
- Aware
