技術文章 » 進階：spring-bean生命週期流程

進階：spring-bean生命週期流程

2022-09-14 18:05:48

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註解得到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的，那麼對應的就是方式一。

5.3 推斷構造方法

第一節已經講過一遍大概原理了，後面有一節課單獨分析原始碼實現。推斷完構造方法後，就會使用構造方法來進行範例化了。

額外的，在推斷構造方法邏輯中除開會去選擇構造方法以及查詢入參物件意外，會還判斷是否在對應的類中是否存在使用@Lookup註解了方法。如果存在則把該方法封裝為LookupOverride物件並新增到BeanDefinition中。

在範例化時，如果判斷出來當前BeanDefinition中沒有LookupOverride，那就直接用構造方法反射得到一個範例物件。如果存在LookupOverride物件，也就是類中存在@Lookup註解了的方法，那就會生成一個代理物件。

@Lookup註解就是方法注入，使用demo如下：

@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物件。