你能說(shuō)說(shuō)Spring框架中Bean的生命周期嗎？

作者：敖丙 2022-03-14 08:54:42

為啥這些面試官老愛問(wèn)Spring，特別是Bean的生命周期，到底啥是Bean的生命周期呀，那咱就來(lái)聊聊這個(gè)話題，本文主要分為兩點(diǎn)進(jìn)行闡述：什么是Bean的生命周期？Bean的生命周期是怎樣的？

前言

俗話說(shuō)：金三銀四，到了這種季節(jié)，有一種叫做程序員的生物就開始活躍了起來(lái)。

這倆天，同事出去面試，她回來(lái)就問(wèn)我：為啥這些面試官老愛問(wèn)Spring，特別是Bean的生命周期，到底啥是Bean的生命周期呀，跟我說(shuō)說(shuō)唄。

那咱就來(lái)聊聊這個(gè)話題，本文主要分為兩點(diǎn)進(jìn)行闡述：

1、什么是Bean的生命周期?

2、Bean的生命周期是怎樣的?

先給大家看一下完整的bean生命周期，不懂沒(méi)關(guān)系后面會(huì)講。

什么是Bean的生命周期

我們知道，在Java中，萬(wàn)物皆對(duì)象，這些對(duì)象有生命周期：實(shí)例化 -> gc回收，而Bean同樣也是Java中的對(duì)象，只是在這同時(shí)，Spring又賦予了它更多的意義。

于是乎，我們將Bean從在Spring中創(chuàng)建開始，到Bean被銷毀結(jié)束，這一過(guò)程稱之為Bean的生命周期。

那到底Bean在Spring中的創(chuàng)建過(guò)程是怎樣的呢?

Bean的生命周期是怎樣的在Spring中，Bean的創(chuàng)建過(guò)程看起來(lái)復(fù)雜，但實(shí)際上邏輯分明。

如果我們將所有擴(kuò)展性流程拋開，你會(huì)發(fā)現(xiàn)只剩下兩個(gè)流程：對(duì)象的實(shí)例化和屬性填充。

我們?cè)凇渡钊霚\出Spring架構(gòu)設(shè)計(jì)》文中手寫的Spring，也只是完成了這兩個(gè)流程，這足以說(shuō)明只需要這兩個(gè)流程就能完成一個(gè)簡(jiǎn)單的Spring框架，那其他的流程又是什么呢?他們又有什么作用?

那么我們現(xiàn)在就基于這兩個(gè)核心流程出發(fā)，嘗試完善整個(gè)Spring的Bean生命周期。

推導(dǎo)過(guò)程

開始時(shí)，我們只有兩個(gè)流程：對(duì)象的實(shí)例化和屬性填充。

我們知道，對(duì)象的實(shí)例化就是在Java里使用類構(gòu)造器進(jìn)行創(chuàng)建對(duì)象。而一個(gè)類中可能有很多的構(gòu)造器，那么我們?cè)趺床拍苤朗褂媚膫€(gè)構(gòu)造器進(jìn)行實(shí)例化對(duì)象呢?

所以說(shuō)，在實(shí)例化之前，還得先做一件事情：確定候選的構(gòu)造器，也稱之為構(gòu)造器推斷。

構(gòu)造器推斷

功能描述：找尋beanClass中所有符合候選條件的構(gòu)造器。
負(fù)責(zé)角色：AutowiredAnnotationBeanPostProcessor。
候選條件：構(gòu)造器上添加了@Autowired注解。

推斷流程：

1、獲取beanClass中的所有構(gòu)造器進(jìn)行遍歷，判斷構(gòu)造器上是否標(biāo)識(shí)@Autowired注解，是則將構(gòu)造器添加到候選構(gòu)造器集合中。

2、并進(jìn)一步判斷Autowired注解中required屬性是否為true(默認(rèn)為true)，是則表示該beanClass已存在指定實(shí)例化的構(gòu)造器，不可再有其他加了@Autowired注解的構(gòu)造器，如果有則拋出異常。

3、如果Autowired注解中required屬性為false，則可繼續(xù)添加其他@Autowired(required=false)標(biāo)識(shí)的構(gòu)造器。

4、如果候選構(gòu)造器集合不為空(有Autowired標(biāo)識(shí)的構(gòu)造器)，并且beanClass中還有個(gè)空構(gòu)造器，那么同樣將空構(gòu)造器也加入候選構(gòu)造器集合中。

5、如果候選構(gòu)造器集合為空，但是beanClass中只有一個(gè)構(gòu)造器且該構(gòu)造器有參，那么將該構(gòu)造器加入候選構(gòu)造器集合中。

流程圖：

當(dāng)構(gòu)造器遍歷完畢之后，還有些許邏輯。

以上判斷條件很多，但始終是圍繞這一個(gè)邏輯：這個(gè)beanClass中有沒(méi)有被Autowired標(biāo)識(shí)的構(gòu)造器，有的話required是true還是false，如果是true, 那其他的構(gòu)造器都不要了。如果是false，那想加多少個(gè)構(gòu)造器就加多少個(gè)。

咦，那要是沒(méi)有Autowired標(biāo)識(shí)的構(gòu)造器呢?

框架嘛，都是要兜底的，這里就是看beanClass中是不是只有一個(gè)構(gòu)造器且是有參的。

那我要是只有個(gè)無(wú)參的構(gòu)造器呢?

那確實(shí)就是沒(méi)有候選的構(gòu)造器了，但是Spring最后又兜底了一次，在沒(méi)有候選構(gòu)造器時(shí)默認(rèn)使用無(wú)參構(gòu)造器。

那我要是有很多個(gè)構(gòu)造器呢?

Spring表示那我也不知道用哪個(gè)呀，同樣進(jìn)入兜底策略：使用無(wú)參構(gòu)造器(沒(méi)有將拋出異常)。

那么這就是構(gòu)造器推斷流程了，我們將它加入到流程圖中。

在得到候選的構(gòu)造器之后，就可以對(duì)對(duì)象進(jìn)行實(shí)例化了，那么實(shí)例化的過(guò)程是怎樣的呢?

對(duì)象實(shí)例化

功能描述：根據(jù)候選構(gòu)造器集合中的構(gòu)造器優(yōu)先級(jí)對(duì)beanClass進(jìn)行實(shí)例化。
負(fù)責(zé)角色：ConstructorResolver。

對(duì)象實(shí)例化的過(guò)程主要有兩個(gè)方面需要關(guān)注：

1、構(gòu)造器的優(yōu)先級(jí)是怎樣的?

2、如果有多個(gè)構(gòu)造器，但是有部分構(gòu)造器的需要的bean并不存在于Spring容器中會(huì)發(fā)生什么?也就是出現(xiàn)了異常怎么處理?

一、構(gòu)造器的優(yōu)先級(jí)是怎樣的?

在Java中，多個(gè)構(gòu)造器稱之為構(gòu)造器重載，重載的方式有兩種：參數(shù)的數(shù)量不同，參數(shù)的類型不同。

在Spring中，優(yōu)先級(jí)則是由構(gòu)造器的修飾符(public or private)和參數(shù)的數(shù)量決定。

規(guī)則如下：

1、public修飾的構(gòu)造器 > private修飾的構(gòu)造器。

2、修飾符相同的情況下參數(shù)數(shù)量更多的優(yōu)先。

這段流程很簡(jiǎn)單，代碼只有兩行：

// 如果一個(gè)是public,一個(gè)不是,那么public優(yōu)先
int result = Boolean.compare(Modifier.isPublic(e2.getModifiers()), Modifier.isPublic(e1.getModifiers()));
// 都是public，參數(shù)多的優(yōu)先
return result != 0 ? result : Integer.compare(e2.getParameterCount(), e1.getParameterCount());

文中描述的規(guī)則是public > private, 只是為了更好的理解，實(shí)際上比較的是public和非public。

二、Spring是如何處理實(shí)例化異常的?

當(dāng)一個(gè)beanClass中出現(xiàn)多個(gè)構(gòu)造器，但是有部分構(gòu)造器的需要的bean并不存在于Spring容器中，此時(shí)會(huì)發(fā)生什么呢?

比如以下案例中，InstanceA具有三個(gè)構(gòu)造方法，其中InstanceB并未注入到Spring中。

@Component
public class InstanceA {
 @Autowired(required = false)
 public InstanceA(InstanceB instanceB){
  System.out.println("instance B ...");
 }
 @Autowired(required = false)
 public InstanceA(InstanceC instanceC){
  System.out.println("instance C ...");
 }
 @Autowired(required = false)
 public InstanceA(InstanceB instanceB, InstanceC instanceC, InstanceD InstanceD){
  System.out.println("instance B C D...");
 }
}

那么啟動(dòng)時(shí)是報(bào)錯(cuò)呢?還是選擇只有InstanceC的構(gòu)造器進(jìn)行實(shí)例化?

運(yùn)行結(jié)果會(huì)告訴你：Spring最終使用了只有InstanceC的構(gòu)造器。

這一部分的具體過(guò)程如下：

1、將根據(jù)優(yōu)先級(jí)規(guī)則排序好的構(gòu)造器進(jìn)行遍歷。

2、逐個(gè)進(jìn)行嘗試查找構(gòu)造器中的需要的bean是否都在Spring容器中，如果成功找到將該構(gòu)造器標(biāo)記為有效構(gòu)造器，并立即退出遍歷。

3、否則記錄異常繼續(xù)嘗試使用下一個(gè)構(gòu)造器。

4、當(dāng)所有構(gòu)造器都遍歷完畢仍未找到有效的構(gòu)造器，拋出記錄的異常。

5、使用有效構(gòu)造器進(jìn)行實(shí)例化。

推導(dǎo)過(guò)程

到這里，beanClass實(shí)例化了一個(gè)bean，接下來(lái)需要做的便是對(duì)bean進(jìn)行賦值，但我們知道，Spring中可以進(jìn)行賦值的對(duì)象不僅有通過(guò)@Autowired標(biāo)識(shí)的屬性，還可以是@Value,@Resource,@Inject等等。

為此，Spring為了達(dá)到可擴(kuò)展性，將獲取被注解標(biāo)識(shí)的屬性的過(guò)程與實(shí)際賦值的過(guò)程進(jìn)行了分離。

該過(guò)程在Spring中被稱為處理beanDefinition。

處理beanDefinition

功能描述：處理BeanDefintion的元數(shù)據(jù)信息。

負(fù)責(zé)角色：

1、AutowiredAnnotationBeanPostProcessor：處理@Autowird,@Value,@Inject注解。

2、CommonAnnotationBeanPostProcessor：處理@PostConstruct,@PreDestroy,@Resource注解。

這兩個(gè)后置處理器的處理過(guò)程十分類似, 我們以AutowiredAnnotationBeanPostProcessor為例：

1、遍歷beanClass中的所有Field、Method(java中統(tǒng)稱為Member)。

2、判斷Member是否標(biāo)識(shí)@Autowird,@Value,@Inject注解。

3、是則將該Member保存，封裝到一個(gè)叫做InjectionMetadata的類中。

4、判斷Member是否已經(jīng)被解析過(guò)，比如一個(gè)Member同時(shí)標(biāo)識(shí)了@Autowired和@Resource注解，那么這個(gè)Member就會(huì)被這兩個(gè)后置處理器都處理一遍，就會(huì)造成重復(fù)保存。

5、如果沒(méi)被解析過(guò)就將該Member放置到已檢查的元素集合中，用于后續(xù)填充屬性時(shí)從這里直接拿到所有要注入的Member。

其中，AutowiredAnnotationBeanPostProcessor和InjectionMetadata的結(jié)構(gòu)如下：

同樣，我們將這一部分流程也加入到流程圖中。

現(xiàn)在，beanClass中的可注入屬性都找出來(lái)了，接下來(lái)就真的要進(jìn)行屬性填充了。

屬性填充

功能：對(duì)bean中需要自動(dòng)裝配的屬性進(jìn)行填充。

角色：

1、AutowiredAnnotationBeanPostProcessor。

2、CommonAnnotationBeanPostProcessor。

在上一個(gè)流程中，我們已經(jīng)找到了所有需要自動(dòng)裝配的Member，所以這一部流程就顯得非常簡(jiǎn)單了。

我們同樣以AutowiredAnnotationBeanPostProcessor為例。

1、使用beanName為key，從緩存中取出InjectionMetadata。

2、遍歷InjectionMetadata中的checkedElements集合。

3、取出Element中的Member，根據(jù)Member的類型在Spring中獲取Bean。

4、使用反射將獲取到的Bean設(shè)值到屬性中。

推導(dǎo)過(guò)程

在Spring中，Bean填充屬性之后還可以做一些初始化的邏輯，比如Spring的線程池ThreadPoolTaskExecutor在填充屬性之后的創(chuàng)建線程池邏輯，RedisTemplate的設(shè)置默認(rèn)值。

Spring的初始化邏輯共分為4個(gè)部分：

1、invokeAwareMethods：調(diào)用實(shí)現(xiàn)特定Aware接口的方法。

2、applyBeanPostProcessorsBeforeInitialization：初始化前的處理。

3、invokeInitMethods：調(diào)用初始化方法。

4、applyBeanPostProcessorsAfterInitialization：初始化后的處理。

invokeAwareMethods

這塊邏輯非常簡(jiǎn)單，我直接把源碼粘出來(lái)給大家看看就明白了。

private void invokeAwareMethods(String beanName, Object bean) {
  if (bean instanceof Aware) {
   if (bean instanceof BeanNameAware) {
    ((BeanNameAware) bean).setBeanName(beanName);
   }
   if (bean instanceof BeanClassLoaderAware) {
    ClassLoader bcl = getBeanClassLoader();
    if (bcl != null) {
     ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
    }
   }
   if (bean instanceof BeanFactoryAware) {
    ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
   }
  }
 }

初始化前的處理

功能：調(diào)用初始化方法前的一些操作。

角色：

1、InitDestroyAnnotationBeanPostProcessor：處理@PostContrust注解。

2、ApplicationContextAwareProcessor：處理一系列Aware接口的回調(diào)方法。

這一步驟的功能沒(méi)有太大的關(guān)聯(lián)性，完全按照使用者自己的意愿決定想在初始化方法前做些什么，我們一個(gè)一個(gè)來(lái)過(guò)。

一、InitDestroyAnnotationBeanPostProcessor

這里的邏輯與屬性填充過(guò)程非常相似，屬性填充過(guò)程是取出自動(dòng)裝配相關(guān)的InjectionMetadata進(jìn)行處理，而這一步則是取@PostContrust相關(guān)的Metadata進(jìn)行處理，這個(gè)Metadata同樣也是在處理BeanDefinition過(guò)程解析緩存的。

1、取出處理BeanDefinition過(guò)程解析的LifecycleMetadata。

2、遍歷LifecycleMetadata中的checkedInitMethods集合。

3、使用反射進(jìn)行調(diào)用。

二、ApplicationContextAwareProcessor

這一步與invokeAwareMethods大同小異，只不過(guò)是其他的一些Aware接口，同樣直接粘上代碼：

 private void invokeAwareInterfaces(Object bean) {
  if (bean instanceof EnvironmentAware) {
   ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
  }
  if (bean instanceof EmbeddedValueResolverAware) {
   ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
  }
  if (bean instanceof ResourceLoaderAware) {
   ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
  }
  if (bean instanceof ApplicationEventPublisherAware) {
   ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
  }
  if (bean instanceof MessageSourceAware) {
   ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
  }
  if (bean instanceof ApplicationContextAware) {
   ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
  }
 }

初始化方法

在Spring中的初始化方法有兩種：

1、實(shí)現(xiàn)InitializingBean接口的afterPropertiesSet方法。

2、@Bean注解中的initMethod屬性。

調(diào)用順序是先調(diào)用afterPropertiesSet再initMethod。

1、判斷Bean是否實(shí)現(xiàn)InitializingBean接口。

2、是則將Bean強(qiáng)轉(zhuǎn)成InitializingBean，調(diào)用afterPropertiesSet方法。

3、判斷BeanDefinition中是否有initMethod。

4、是則找到對(duì)應(yīng)的initMethod，通過(guò)反射進(jìn)行調(diào)用。

初始化后的處理

在Spring的內(nèi)置的后置處理器中，該步驟只有ApplicationListenerDetector有相應(yīng)處理邏輯：將實(shí)現(xiàn)了ApplicationListener接口的bean添加到事件監(jiān)聽器列表中.

如果使用了Aop相關(guān)功能，則會(huì)使用到AbstractAutoProxyCreator，進(jìn)行創(chuàng)建代理對(duì)象。

ApplicationListenerDetector的流程如下：

1、判斷Bean是否是個(gè)ApplicationListener。

2、是則將bean存放到applicationContext的監(jiān)聽器列表中。

補(bǔ)充流程圖

到這里，Bean的生命周期主要部分已經(jīng)介紹完了，我們將流程圖補(bǔ)充一下。

同樣還有其他的一些邏輯。

一、中止創(chuàng)建Bean的過(guò)程

該過(guò)程處于Bean生命周期的最開始部分。

功能：由后置處理器返回Bean，達(dá)到中止創(chuàng)建Bean的效果。
角色：無(wú)，Spring的內(nèi)置后置處理器中，無(wú)實(shí)現(xiàn)。

Bean的生命周期十分復(fù)雜，Spring允許你直接攔截，即在創(chuàng)建Bean之前由自定義的后置處理器直接返回一個(gè)Bean給Spring，那么Spring就會(huì)使用你給的Bean，不會(huì)再走Bean生命周期流程。

案例演示：

@Component
public class Car {
 @Autowired
 private Person person;
 public void checkPerson(){
  if(person == null){
   System.out.println("person is null");
  }
 }
}

由于在Person屬性上加了@Autowired,所以正常來(lái)說(shuō)person必然不能為空，因?yàn)檫@是必須要注入的。

現(xiàn)在我們自定義一個(gè)BeanPostProcessor進(jìn)行攔截。

@Component
public class InterruptBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
 @Override
 public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
  if("car".equals(beanName)){
   try {
    return beanClass.newInstance();
   } catch (InstantiationException | IllegalAccessException e) {
    e.printStackTrace();
   }
  }
  return null;
 }
}

測(cè)試結(jié)果如下:

二、提前緩存剛實(shí)例化的對(duì)象

該步驟跟隨在Spring實(shí)例化bean之后，將bean進(jìn)行緩存，其目的是為了解決循環(huán)依賴問(wèn)題。

該過(guò)程暫時(shí)按下不表，單獨(dú)提出放于循環(huán)依賴章節(jié)。

三、中止填充屬性操作

與中止創(chuàng)建Bean邏輯相同，Spring同樣也允許你在屬性填充前進(jìn)行攔截。在Spring的內(nèi)置處理器中同樣無(wú)該實(shí)現(xiàn)。

實(shí)現(xiàn)手段為實(shí)現(xiàn)InstantiationAwareBeanPostProcessor接口，在postProcessAfterInstantiation方法中返回false。

@Component
public class InterruptBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
 @Override
 public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
  if(beanName.equals("car")){
   return false;
  }
  return true;
 }
}