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

前言

在上一篇文章中，我們深入探討了 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");
				}
			}
		}
	}

unsatisfiedNonSimpleProperties：找到所有set方法
getBean：按照set方法名字獲取bean
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);
	}

如果一個Bean的類型是String...，那麼則根本不需要進行依賴註入
遍歷targetClass中的所有Field,static filed不是註入點，不會進行自動註入
遍歷targetClass中的所有Method,static method不是註入點，不會進行自動註入
上面的註入點構造好後，會在外層直接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;
	}

findLifecycleMetadata：好奇的小伙伴可以看下這個方法，他會構造@PostConstruct、@PreDestroy執行點
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);
			}
		}
	}

如果當前類實現了InitializingBean介面，那麼執行afterPropertiesSet方法進行初始化
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的初始化，主要流程如下:

屬性註入，執行@autowired、PropertyValues註入等
初始化前置方法，執行@PostConstruct方法、回調Aware介面等
初始化，調用afterPropertiesSet或者initMethod
初始化後置方法

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

ps：以上內容，純屬個人見解，有任何問題下方評論！關註博主公眾號，源碼專題、面試精選、AI最新擴展等你來看！原創編寫不易，轉載請說明出處！

Spring源碼：Bean生命周期（五）

前言