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

Bean的生成過程

主要流程圖

1. 生成BeanDefinition

Spring啟動的時候會進行掃描，會先調用org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents(String basePackage) 掃描某個包路徑，並得到BeanDefinition的Set集合。

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

Spring掃描底層流程：//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對象。

Tags:

VirMach 便宜 VPS

QNews

QNews