Spring原始碼:Bean生命週期(五)

努力的小雨發表於2023-05-16

前言

在上一篇文章中,我們深入探討了 Spring 框架中 Bean 的例項化過程,該過程包括從 Bean 定義中載入當前類、尋找所有實現了 InstantiationAwareBeanPostProcessor 介面的類並呼叫例項化前的方法、進行例項化、呼叫 applyMergedBeanDefinitionPostProcessors 方法等多個步驟,最終生成了一個真正的 Bean 例項。但是,這個 Bean 例項還沒有被初始化和注入屬性,還不能真正發揮作用。

在今天的文章中,我們將深入探討 Bean 的屬性注入和初始化流程,從而使其成為一個真正意義上的 Bean。這個過程包括屬性注入、Aware 介面回撥、BeanPostProcessor 的前置和後置處理等多個步驟,透過本文的學習,讀者將能夠更深入地瞭解 Spring 框架中 Bean 的屬性注入和初始化過程,為後續的學習和實踐打下堅實的基礎。

populateBean

在 Spring 框架中,屬性注入是 Bean 初始化過程中的一個重要環節。在 Bean 例項化完成後,Spring 框架會根據 Bean 定義中的屬性設定進行屬性注入,同時還會呼叫一些 Aware 介面回撥方法,以及一些 BeanPostProcessor 的前置和後置處理方法,最終完成 Bean 的初始化過程。好的,拋去不用看的,我們來看下剩下的原始碼:

	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	}
......
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			// MutablePropertyValues是PropertyValues具體的實現類
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// Add property values based on autowire by name if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// Add property values based on autowire by type if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}

		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

		PropertyDescriptor[] filteredPds = null;
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
				// 這裡會呼叫AutowiredAnnotationBeanPostProcessor的postProcessProperties()方法,會直接給物件中的屬性賦值
				// AutowiredAnnotationBeanPostProcessor內部並不會處理pvs,直接返回了
				PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
				if (pvsToUse == null) {
					if (filteredPds == null) {
						filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
					}
					pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						return;
					}
				}
				pvs = pvsToUse;
			}
		}
		......

		// 如果當前Bean中的BeanDefinition中設定了PropertyValues,那麼最終將是PropertyValues中的值,覆蓋@Autowired
		if (pvs != null) {
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

PropertyValues

在 Spring 框架中,PropertyValues 物件是從 Bean 定義中獲取的,而我們自己定義的 Bean 並沒有這個屬性值。一般情況下,這一步會被跳過,但如果需要注入屬性值,我們可以透過實現 MergedBeanDefinitionPostProcessor 介面的 postProcessMergedBeanDefinition 方法來對 Bean 定義進行修改,從而新增需要注入的屬性值。

具體來說,我們可以定義一個實現了 MergedBeanDefinitionPostProcessor 介面的類,比如下面這個例子::

@Component
public class MyInstantiationAwareBeanPostProcessors implements InstantiationAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor {

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

在這個例子中,我們判斷如果 Bean 的名稱是 "userService",則新增一個名為 "orderService" 的屬性,並將其值設定為 First 類的一個例項。需要注意的是,為了能夠正常注入屬性值,我們需要在 Bean 中定義一個名為 "setOrderService" 的 setter 方法,這樣就可以注入進去,當然我寫的這個是報錯的狀態,這樣大家可以找到他是在哪裡進行呼叫的。

autowireByName/autowireByType

講解之前,我先宣告一下他跟我們的@autowired註解沒有半毛錢關係,除了上面一種我們人為干預的,還有一種Spring自帶的方式,在我們配置類中:

	@Bean(autowire = Autowire.BY_NAME)
	public UserService userService(){
		return new UserService();
	}

這樣定義時,他就會自動掃描你這個當前類中所有的set方法,是所有的、而且不區分的。這裡以autowireByName為例講解,autowireByType類似:

	protected void autowireByName(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

		// 當前Bean中能進行自動注入的屬性名
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		// 遍歷每個屬性名,並去獲取Bean物件,並設定到pvs中
		for (String propertyName : propertyNames) {
			if (containsBean(propertyName)) {
				Object bean = getBean(propertyName);
				pvs.add(propertyName, bean);
				// 記錄一下propertyName對應的Bean被beanName給依賴了
				registerDependentBean(propertyName, beanName);
				if (logger.isTraceEnabled()) {
					logger.trace("Added autowiring by name from bean name '" + beanName +
							"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
				}
			}
			else {
				if (logger.isTraceEnabled()) {
					logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
							"' by name: no matching bean found");
				}
			}
		}
	}
  1. unsatisfiedNonSimpleProperties:找到所有set方法
  2. getBean:按照set方法名字獲取bean
  3. pvs.add(propertyName, bean):設定到MutablePropertyValues屬性中,不是對我們的bean進行屬性注入

那有些同學可能會想到了,為什麼Spring已經預設提供了一套注入方式還有弄一個@autowired註解呢?主要是因為它們各自有不同的優點和適用場景。

預設的注入方式非常靈活,它會遍歷 Bean 中所有的 setter 方法,對每個屬性進行注入,從而實現自動裝配。這種方式適用於大多數情況,因為它能夠自動識別並注入所有需要的依賴項,並且不需要進行任何額外的配置。

而 @Autowired 註解則提供了更加精細的控制,它可以指定需要注入的屬性或方法,並且還可以指定注入的方式、名稱、是否必須等屬性。這種方式適用於需要更加精細的控制和配置的情況,@Autowired 註解是一個可插拔的元件,它只有在 Spring 容器啟動時掃描到該註解時才能夠進行自動裝配。如果我們使用 XML 配置的方式啟動 Spring 容器,需要在配置檔案中新增 context:component-scan 元素來開啟自動掃描功能,否則即使寫了 @Autowired 註解也不會進行注入。

postProcessProperties

這一步將會對@autowired註解進行屬性注入,其他的不看,這裡只看下AutowiredAnnotationBeanPostProcessor對屬性或者方法的注入:

	private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
		// 如果一個Bean的型別是String...,那麼則根本不需要進行依賴注入
		if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
			return InjectionMetadata.EMPTY;
		}

		List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
		Class<?> targetClass = clazz;

		do {
			final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();

			// 遍歷targetClass中的所有Field
			ReflectionUtils.doWithLocalFields(targetClass, field -> {
				// field上是否存在@Autowired、@Value、@Inject中的其中一個
				MergedAnnotation<?> ann = findAutowiredAnnotation(field);
				if (ann != null) {
					// static filed不是注入點,不會進行自動注入
					if (Modifier.isStatic(field.getModifiers())) {
						if (logger.isInfoEnabled()) {
							logger.info("Autowired annotation is not supported on static fields: " + field);
						}
						return;
					}

					// 構造注入點
					boolean required = determineRequiredStatus(ann);
					currElements.add(new AutowiredFieldElement(field, required));
				}
			});

			// 遍歷targetClass中的所有Method
			ReflectionUtils.doWithLocalMethods(targetClass, method -> {

				Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
				if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
					return;
				}
				// method上是否存在@Autowired、@Value、@Inject中的其中一個
				MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
				if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
					// static method不是注入點,不會進行自動注入
					if (Modifier.isStatic(method.getModifiers())) {
						if (logger.isInfoEnabled()) {
							logger.info("Autowired annotation is not supported on static methods: " + method);
						}
						return;
					}
					// set方法最好有入參
					if (method.getParameterCount() == 0) {
						if (logger.isInfoEnabled()) {
							logger.info("Autowired annotation should only be used on methods with parameters: " +
									method);
						}
					}
					boolean required = determineRequiredStatus(ann);
					PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
					currElements.add(new AutowiredMethodElement(method, required, pd));
				}
			});

			elements.addAll(0, currElements);
			targetClass = targetClass.getSuperclass();
		}
		while (targetClass != null && targetClass != Object.class);

		return InjectionMetadata.forElements(elements, clazz);
	}
  1. 如果一個Bean的型別是String...,那麼則根本不需要進行依賴注入
  2. 遍歷targetClass中的所有Field,static filed不是注入點,不會進行自動注入
  3. 遍歷targetClass中的所有Method,static method不是注入點,不會進行自動注入
  4. 上面的注入點構造好後,會在外層直接invoke呼叫注入

這裡強調一下在對方法注入點進行注入時,會先判斷一下是否有PropertyValues,如果有的話則跳過注入,AutowiredMethodElement原始碼如下:

		protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
			// 如果pvs中已經有當前注入點的值了,則跳過注入
			if (checkPropertySkipping(pvs)) {
				return;
			}
			......
		}

applyPropertyValues

直接應用PropertyValues注入屬性,可以看到這一步在我們的@autowired解析注入之後,如果你有的屬性欄位已經被@autowired注入了,但是又有一個PropertyValues那麼這個set方法會把你的@Autowired之前注入進去的物件值覆蓋,原始碼很多為了篇幅就不看了。知道這個方法是幹啥的就行。

initializeBean

屬性填充完之後,終於進入到了初始化階段,為什麼需要初始化這一步呢?這是對bean的最終處理,該方法返回的物件才是Spring管理的最終物件,Spring AOP就是對初始化這一步做 的擴充套件。

	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;

		// 初始化前
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		// 初始化
		try {
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}

		// 初始化後 AOP
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

invokeAwareMethods

該方法就是Aware介面的實現

	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);
			}
		}
	}

applyBeanPostProcessorsBeforeInitialization

初始化前的類處理,我們主講兩個類:ApplicationContextAwareProcessor、

InitDestroyAnnotationBeanPostProcessor透過這兩個類看看可以初始化前我們可以做哪些內容:

ApplicationContextAwareProcessor

	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
				bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
				bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware ||
				bean instanceof ApplicationStartupAware)) {
			return bean;
		}
......
			// 執行aware方法
			invokeAwareInterfaces(bean);
		}
		return bean;
	}

初始化前會判斷當前是否是某個Aware類,那麼則執行aware方法進行回撥。

InitDestroyAnnotationBeanPostProcessor

	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
		try {
			metadata.invokeInitMethods(bean, beanName);
		}
		catch (InvocationTargetException ex) {
			throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
		}
		return bean;
	}
  1. findLifecycleMetadata:好奇的小夥伴可以看下這個方法,他會構造@PostConstruct、@PreDestroy執行點
  2. metadata.invokeInitMethods:執行帶有@PostConstruct方法

invokeInitMethods

	protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {

		boolean isInitializingBean = (bean instanceof InitializingBean);
		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
			......
				((InitializingBean) bean).afterPropertiesSet();
			}
		}

		if (mbd != null && bean.getClass() != NullBean.class) {
			String initMethodName = mbd.getInitMethodName();
			if (StringUtils.hasLength(initMethodName) &&
					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
					!mbd.isExternallyManagedInitMethod(initMethodName)) {
				invokeCustomInitMethod(beanName, bean, mbd);
			}
		}
	}
  1. 如果當前類實現了InitializingBean介面,那麼執行afterPropertiesSet方法進行初始化
  2. initMethodName:如果當前類指定了初始方法,那麼直接invoke執行

applyBeanPostProcessorsAfterInitialization

	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;

		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			Object current = processor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

執行完postProcessAfterInitialization方法後,那麼這個物件終於初始化成功了

總結

今天我們主講bean的初始化,主要流程如下:

  1. 屬性注入,執行@autowired、PropertyValues注入等
  2. 初始化前置方法,執行@PostConstruct方法、回撥Aware介面等
  3. 初始化,呼叫afterPropertiesSet或者initMethod
  4. 初始化後置方法

最後一節我們會講bean的銷燬,那麼bean的生命週期系列文章會結束,實際上 Spring 框架還有很多其他的功能和特性,例如 AOP、事務管理、Web 開發等等,博主還會進行對Spring系列繼續更新,請大家繼續跟緊學習。

公眾號