【Spring 源码】贯穿 Bean 生命周期的核心类之 AbstractAutowireCapableBeanFactory

引言

AbstractAutowireCapableBeanFactory 是 Spring 框架中至关重要的核心类之一，承担着整个 Bean 生命周期关键步骤的管理责任。其在 Bean 实例化、属性注入、初始化及代理处理等关键环节中发挥着关键作用，贯穿了整个 Bean 的声明周期。

核心方法：doCreateBean

深入研究 AbstractAutowireCapableBeanFactory 源码，将关注其中一个核心方法：doCreateBean。这个方法是贯穿 Bean 生命周期的纽带，涵盖了实例化、属性注入、初始化以及代理处理等关键任务。
【Spring 源码】贯穿 Bean 生命周期的核心类之 AbstractAutowireCapableBeanFactory-LMLPHP

	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.markAsPostProcessed();
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			populateBean(beanName, mbd, instanceWrapper);
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException bce && beanName.equals(bce.getBeanName())) {
				throw bce;
			}
			else {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName, ex.getMessage(), ex);
			}
		}

		if (earlySingletonExposure) {
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					if (!actualDependentBeans.isEmpty()) {
						throw new BeanCurrentlyInCreationException(beanName,
								"Bean with name '" + beanName + "' has been injected into other beans [" +
								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
								"] in its raw version as part of a circular reference, but has eventually been " +
								"wrapped. This means that said other beans do not use the final version of the " +
								"bean. This is often the result of over-eager type matching - consider using " +
								"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		// Register bean as disposable.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

1. 实例化 Bean

BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
    instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
    instanceWrapper = createBeanInstance(beanName, mbd, args);
}

在这一步中，doCreateBean 方法首先尝试从单例缓存中获取 Bean 的包装实例，以支持单例模式。如果未找到，它将通过 createBeanInstance 方法进行实例化。

2. 属性注入

populateBean(beanName, mbd, instanceWrapper);

populateBean 方法负责将属性注入到 Bean 实例中，包括将依赖项注入到 Bean 中，以建立 Bean 之间的关系。

3. 初始化 Bean

exposedObject = initializeBean(beanName, exposedObject, mbd);

在这一步，initializeBean 方法被调用，负责执行 Bean 的初始化。这包括调用任何与 Bean 生命周期相关的回调方法，以及应用任何与 Bean 相关的后处理器。

4. 代理处理

Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
    // 处理代理，获取早期半成品对象
    exposedObject = earlySingletonReference;
}

在初始化之后，如果存在代理，通过从二级缓存获取早期半成品对象，实现代理的替换。这对于 AOP 等方面的处理非常关键。

总结

AbstractAutowireCapableBeanFactory 类集中了 Bean 生命周期中的关键步骤，包括实例化、属性注入、初始化以及代理处理。通过深入理解这个类及其核心方法，我们能更好地把握 Spring 框架中 Bean 的创建和管理机制，从而更有效地进行应用程序开发。

开源项目

SpringCloud + Vue3 微服务商城

SpringBoot 3+ Vue3 单体权限管理系统

有来技术