Spring 源码解析：finishBeanFactoryInitialization () 方法深度剖析

在 Spring 框架的启动过程中，finishBeanFactoryInitialization() 方法是一个关键环节，它负责完成 Bean 工厂的初始化工作，特别是实例化所有剩余的单例 Bean。本文将深入探讨这个方法的实现原理，分析其中的关键步骤和核心逻辑。

一、finishBeanFactoryInitialization () 方法概述

finishBeanFactoryInitialization() 方法位于 AbstractApplicationContext 类中，是 Spring 应用上下文刷新过程中的一个重要步骤。该方法的主要作用是完成 Bean 工厂的初始化，具体来说，就是实例化所有剩余的非懒加载单例 Bean。

该方法主要做了以下几件事：

1. 初始化转换服务（ConversionService），用于类型转换。
2. 处理 LoadTimeWeaverAware 类型的 Bean，这些 Bean 需要在类加载时进行织入处理。
3. 停止使用临时类加载器，并冻结所有 Bean 定义，确保 Bean 定义不会被修改。
4. 调用 beanFactory.preInstantiateSingletons() 方法实例化所有剩余的非懒加载单例 Bean。

源码如下：

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	// 初始化ConversionService（类型转换服务）
	if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
			beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
		beanFactory.setConversionService(
				beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
	}

	// 注册默认的嵌入式值解析器（如处理@Value注解）
	if (!beanFactory.hasEmbeddedValueResolver()) {
		beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
			@Override
			public String resolveStringValue(String strVal) {
				return getEnvironment().resolvePlaceholders(strVal);
			}
		});
	}

	// 提前实例化LoadTimeWeaverAware类型的Bean
	String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
	for (String weaverAwareName : weaverAwareNames) {
		getBean(weaverAwareName);
	}

	 // 停止使用临时类加载器进行类型匹配
	beanFactory.setTempClassLoader(null);

	 // 冻结所有Bean定义，说明注册的Bean定义不会被修改或进一步后处理
	beanFactory.freezeConfiguration();

	// 实例化所有剩余的（非延迟初始化）单例Bean
	beanFactory.preInstantiateSingletons();
}

其中beanFactory.preInstantiateSingletons() 是最核心的方法，接下来我们将重点分析这个方法。

二、preInstantiateSingletons () 方法解析

preInstantiateSingletons()方法定义在DefaultListableBeanFactory类中，主要作用是实例化所有非延迟加载的单例 Bean。其核心流程如下：

1. 首先获取所有 Bean 定义的名称列表
2. 遍历这个列表，对每个 Bean 定义进行检查：
   • 跳过抽象的、非单例的或懒加载的 Bean
   • 对于 FactoryBean 类型的 Bean，会先获取 FactoryBean 实例，然后根据其 isEagerInit 方法决定是否要通过 FactoryBean 创建实际的 Bean 实例
   • 对于普通 Bean，直接调用 getBean() 方法进行实例化
3. 最后，再次遍历所有 Bean，对实现了 SmartInitializingSingleton 接口的 Bean，调用其 afterSingletonsInstantiated() 方法，允许 Bean 在所有单例 Bean 初始化完成后执行额外的初始化逻辑

源码如下：

@Override
public void preInstantiateSingletons() throws BeansException {
	if (this.logger.isDebugEnabled()) {
		this.logger.debug("Pre-instantiating singletons in " + this);
	}

	// 获取所有Bean定义名称
	List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

	// 触发所有非延迟加载单例Bean的初始化
	for (String beanName : beanNames) {
		// 转换为规范名称（处理别名）
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		// 检查是否为非抽象、单例且非延迟加载的Bean
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			// 检查是否为FactoryBean
			if (isFactoryBean(beanName)) {
				// FactoryBean以&开头获取原始工厂实例，否则获取工厂生产的对象
				final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
				boolean isEagerInit;
				if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
					isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
						@Override
						public Boolean run() {
							return ((SmartFactoryBean<?>) factory).isEagerInit();
						}
					}, getAccessControlContext());
				}
				else {
					isEagerInit = (factory instanceof SmartFactoryBean &&
							((SmartFactoryBean<?>) factory).isEagerInit());
				}
				if (isEagerInit) {
					getBean(beanName);
				}
			}
			else {
				// 普通Bean直接实例化
				getBean(beanName);
			}
		}
	}

	// 对于实现了SmartInitializingSingleton接口的Bean，调用其afterSingletonsInstantiated()方法
	for (String beanName : beanNames) {
		Object singletonInstance = getSingleton(beanName);
		if (singletonInstance instanceof SmartInitializingSingleton) {
			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged(new PrivilegedAction<Object>() {
					@Override
					public Object run() {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}
				}, getAccessControlContext());
			}
			else {
				smartSingleton.afterSingletonsInstantiated();
			}
		}
	}
}

SmartInitializingSingleton 是 Spring 框架中的一个接口，用于在所有单例 Bean 初始化完成后执行额外的初始化逻辑。它提供了一个回调方法 afterSingletonsInstantiated()，让 Bean 可以在容器完成所有单例 Bean 的创建后执行特定操作，比如注册组件、初始化缓存等。
核心作用：确保依赖的 Bean 都已初始化完成，再执行需要全局 Bean 上下文的操作。

三、Bean 创建的核心流程

在 preInstantiateSingletons() 方法中，最关键的操作是调用 getBean() 方法来创建 Bean。下面我们来梳理一下 Bean 创建的核心流程以及相关方法的调用关系。

方法调用关系

Bean 创建的核心流程涉及多个关键方法，它们的调用关系大致如下：

preInstantiateSingletons()
    -> getBean(beanName)
        -> doGetBean(beanName, ...)
           -> getSingleton(beanName, () -> { ... })
           -> createBean(beanName, mbd, args)
               -> doCreateBean(beanName, mbdToUse, args)
                   -> createBeanInstance(beanName, mbd, args)  // Bean 实例化
                   -> populateBean(beanName, mbd, instanceWrapper)  // Bean 属性填充
                   -> initializeBean(beanName, exposedObject, mbd)  // Bean 初始化
                       -> applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName)
                       -> invokeInitMethods(beanName, wrappedBean, mbd)
                       -> applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)

3.1. getBean () 和 doGetBean ()

getBean() 是 BeanFactory 接口定义的方法，它的实际实现是在 AbstractBeanFactory 类的 doGetBean() 方法中。

public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

protected <T> T doGetBean(
		final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
		throws BeansException {
		
	// 转换 Bean 名称（处理别名等情况）
	final String beanName = transformedBeanName(name);
	Object bean;

	// 检查缓存中是否有已创建的单例 Bean（处理循环引用）
	Object sharedInstance = getSingleton(beanName);
	if (sharedInstance != null && args == null) {
		if (logger.isDebugEnabled()) {
			if (isSingletonCurrentlyInCreation(beanName)) {
				logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
						"' that is not fully initialized yet - a consequence of a circular reference");
			}
			else {
				logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
			}
		}
		// 获取 Bean 实例（可能需要从 FactoryBean 获取对象）
		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}

	else {
		// 处理 Bean 正在创建中的情况（循环引用）
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}

		// 检查父 BeanFactory
		BeanFactory parentBeanFactory = getParentBeanFactory();
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
			// 未找到 Bean 定义，委托给父 BeanFactory
			String nameToLookup = originalBeanName(name);
			if (args != null) {
				return (T) parentBeanFactory.getBean(nameToLookup, args);
			}
			else {
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			}
		}
		
		// 标记 Bean 为已创建
		if (!typeCheckOnly) {
			markBeanAsCreated(beanName);
		}

		try {
			// 获取合并后的 Bean 定义
			final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			checkMergedBeanDefinition(mbd, beanName, args);

			// 处理依赖 Bean
			String[] dependsOn = mbd.getDependsOn();
			if (dependsOn != null) {
				for (String dep : dependsOn) {
					if (isDependent(beanName, dep)) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
					}
					registerDependentBean(dep, beanName);
					getBean(dep);
				}
			}

			// 创建单例 Bean
			if (mbd.isSingleton()) {
				sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
					@Override
					public Object getObject() throws BeansException {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							// Explicitly remove instance from singleton cache: It might have been put there
							// eagerly by the creation process, to allow for circular reference resolution.
							// Also remove any beans that received a temporary reference to the bean.
							destroySingleton(beanName);
							throw ex;
						}
					}
				});
				bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
			}
			// 创建原型 Bean
			else if (mbd.isPrototype()) {
				// It's a prototype -> create a new instance.
				Object prototypeInstance = null;
				try {
					beforePrototypeCreation(beanName);
					prototypeInstance = createBean(beanName, mbd, args);
				}
				finally {
					afterPrototypeCreation(beanName);
				}
				bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
			}
			// 创建其他作用域的 Bean
			else {
				String scopeName = mbd.getScope();
				final Scope scope = this.scopes.get(scopeName);
				if (scope == null) {
					throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
				}
				try {
					Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
						@Override
						public Object getObject() throws BeansException {
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							}
							finally {
								afterPrototypeCreation(beanName);
							}
						}
					});
					bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
				}
				catch (IllegalStateException ex) {
					throw new BeanCreationException(beanName,
							"Scope '" + scopeName + "' is not active for the current thread; consider " +
							"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
							ex);
				}
			}
		}
		catch (BeansException ex) {
			cleanupAfterBeanCreationFailure(beanName);
			throw ex;
		}
	}

	// 类型检查
	if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
		try {
			return getTypeConverter().convertIfNecessary(bean, requiredType);
		}
		catch (TypeMismatchException ex) {
			if (logger.isDebugEnabled()) {
				logger.debug("Failed to convert bean '" + name + "' to required type '" +
						ClassUtils.getQualifiedName(requiredType) + "'", ex);
			}
			throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
		}
	}
	return (T) bean;
}

doGetBean() 方法的主要逻辑包括：

1. 检查缓存中是否已有该 Bean 实例（如果有 则赋值给返回值引用）
2. 若缓存中没有 则创建
   1. 处理父 BeanFactory 的情况
   2. 获取合并后的 Bean 定义
   3. 处理依赖 Bean
   4. 根据 Bean 的作用域（单例、原型等）创建 Bean 实例，调用createBean()
3. 进行类型检查和转换

3.2. createBean () 和 doCreateBean ()

createBean() 方法是实际创建 Bean 的入口，它主要做一些准备工作，然后委托给 doCreateBean() 方法

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
	if (logger.isDebugEnabled()) {
		logger.debug("Creating instance of bean '" + beanName + "'");
	}
	RootBeanDefinition mbdToUse = mbd;

	// ...
	
	// 创建bean的具体逻辑
	Object beanInstance = doCreateBean(beanName, mbdToUse, args);
	
	if (logger.isDebugEnabled()) {
		logger.debug("Finished creating instance of bean '" + beanName + "'");
	}
	return beanInstance;
}

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

	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		// 【一、bean 实例化】
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
	
	// ...

	// 提前暴露创建中的 Bean 实例（提前放到三级缓存中）
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
			isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		if (logger.isDebugEnabled()) {
			logger.debug("Eagerly caching bean '" + beanName +
					"' to allow for resolving potential circular references");
		}
		// 将创建中的 Bean 提前暴露到三级缓存中（实例化之后、属性注入之前，会提前把自己的工厂放入三级缓存）
		addSingletonFactory(beanName, new ObjectFactory<Object>() {
			@Override
			public Object getObject() throws BeansException {
				return getEarlyBeanReference(beanName, mbd, bean);
			}
		});
	}


	Object exposedObject = bean;
	try {
		//【二、bean 属性填充】
		populateBean(beanName, mbd, instanceWrapper);
		if (exposedObject != null) {
			//【三、bean 初始化】
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
	}
	// 其他逻辑，例如'循环依赖处理 和 Bean 包装检测'... 
	return exposedObject;
}

doCreateBean 方法的主要功能可以概括为三个步骤：

1. 实例化 Bean：通过反射或工厂方法创建 Bean 的原始实例。调用createBeanInstance()
2. 属性填充：对 Bean 进行依赖注入，将需要的依赖通过 setter 方法或字段注入到 Bean 中。调用populateBean()
3. 初始化 Bean：调用 Bean 的初始化方法。调用initializeBean()

3.3. createBeanInstance () - Bean 实例化

createBeanInstance() 方法负责创建 Bean 的实例，它会根据 Bean 定义选择合适的实例化策略（构造函数自动注入、工厂方法等）。

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
	// 确保 Bean 类已加载
	Class<?> beanClass = resolveBeanClass(mbd, beanName);

	if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
				"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
	}

	// 处理工厂方法创建 Bean
	if (mbd.getFactoryMethodName() != null)  {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}

	// 短路径检查：是否有缓存的构造函数或工厂方法
	boolean resolved = false;
	boolean autowireNecessary = false;
	if (args == null) {
		synchronized (mbd.constructorArgumentLock) {
			if (mbd.resolvedConstructorOrFactoryMethod != null) {
				resolved = true;
				autowireNecessary = mbd.constructorArgumentsResolved;
			}
		}
	}
	if (resolved) {
		if (autowireNecessary) {
			return autowireConstructor(beanName, mbd, null, null);
		}
		else {
			return instantiateBean(beanName, mbd);
		}
	}

	// 确定构造函数
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	if (ctors != null ||
			mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
		return autowireConstructor(beanName, mbd, ctors, args);
	}

	// 默认使用无参构造函数
	return instantiateBean(beanName, mbd);
}

这个方法的主要逻辑是：

1. 首先检查是否通过工厂方法来创建 Bean 实例。
2. 如果没有指定上述方式，则尝试确定合适的构造函数。
3. 如果有构造函数参数或指定了构造函数自动注入模式，则使用构造函数自动注入。
4. 否则，使用默认的无参构造函数创建 Bean 实例。

3.4. populateBean () - Bean 属性填充

populateBean() 方法负责填充 Bean 的属性，包括依赖注入。

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
	PropertyValues pvs = mbd.getPropertyValues();

	// ...

	// 通过 InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation 扩展点干预
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				// 若返回 false，终止属性填充（如某些场景需跳过自动注入）
				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					continueWithPropertyPopulation = false;
					break;
				}
			}
		}
	}

	// 解析自动装配模式（按名称或类型注入）
	if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
			mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

		 // 按属性名查找依赖 Bean 并记录到 pvs
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}

		// 按属性类型解析依赖（含泛型匹配）
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}

		pvs = newPvs;
	}

	// ...
	// 【重要：后置处理器动态修改属性值】 
	if (hasInstAwareBpps || needsDepCheck) {
		PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
		if (hasInstAwareBpps) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					// 【重要】@Autowired 与 @Value 由 AutowiredAnnotationBeanPostProcessor 在 postProcessProperties 阶段处理
					// 【重要】@Resource：由 CommonAnnotationBeanPostProcessor 处理，优先按名称匹配，其次按类型。
					pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
					if (pvs == null) {
						return;
					}
				}
			}
		}
		if (needsDepCheck) {
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}
	}
	// 应用属性值
	applyPropertyValues(beanName, mbd, bw, pvs);
}

这个方法的主要步骤包括：

1. 应用 InstantiationAwareBeanPostProcessor 的后置实例化处理
2. 处理自动注入模式（按名称或按类型）
3. 应用 InstantiationAwareBeanPostProcessor 的属性值处理
4. 应用属性值

相信大家对@Autowired的处理逻辑比较感兴趣，带大家一起看一下AutowiredAnnotationBeanPostProcessor 处理@Autowired的源码

3.4.1 AutowiredAnnotationBeanPostProcessor处理@Autowired源码解析

从入口AutowiredAnnotationBeanPostProcessor的postProcessPropertyValues方法开始看

public PropertyValues postProcessPropertyValues(
		PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {
	// 查找注入元数据（可能触发 buildAutowiringMetadata）
	InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
	try {
		// 执行注入
		metadata.inject(bean, beanName, pvs);
	} //...
	
	return pvs;
}

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, PropertyValues pvs) {
	// 检查缓存
	String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
	InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
	if (InjectionMetadata.needsRefresh(metadata, clazz)) {
		synchronized (this.injectionMetadataCache) {
			metadata = this.injectionMetadataCache.get(cacheKey);
			if (InjectionMetadata.needsRefresh(metadata, clazz)) {
				// ...
				try {
					// 构建注入元数据（扫描 @Autowired 注解）
					metadata = buildAutowiringMetadata(clazz);
					this.injectionMetadataCache.put(cacheKey, metadata);
				}
				// ...
			}
		}
	}
	return metadata;
}

private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
	LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<InjectionMetadata.InjectedElement>();
	Class<?> targetClass = clazz;
	// 递归扫描类及其父类的字段和方法
	do {
		final LinkedList<InjectionMetadata.InjectedElement> currElements =
				new LinkedList<InjectionMetadata.InjectedElement>();
		// 【处理字段上的 @Autowired】
		ReflectionUtils.doWithLocalFields(targetClass, new ReflectionUtils.FieldCallback() {
			@Override
			public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
				AnnotationAttributes ann = findAutowiredAnnotation(field);
				if (ann != null) {
					if (Modifier.isStatic(field.getModifiers())) {
						if (logger.isWarnEnabled()) {
							logger.warn("Autowired annotation is not supported on static fields: " + field);
						}
						return;
					}
					boolean required = determineRequiredStatus(ann);
					currElements.add(new AutowiredFieldElement(field, required));
				}
			}
		});

		// 【处理方法上的 @Autowired】
		ReflectionUtils.doWithLocalMethods(targetClass, new ReflectionUtils.MethodCallback() {
			@Override
			public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
				Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
				if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
					return;
				}
				AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
				if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
					if (Modifier.isStatic(method.getModifiers())) {
						if (logger.isWarnEnabled()) {
							logger.warn("Autowired annotation is not supported on static methods: " + method);
						}
						return;
					}
					if (method.getParameterTypes().length == 0) {
						if (logger.isWarnEnabled()) {
							logger.warn("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 new InjectionMetadata(clazz, elements);
}

public void inject(Object target, String beanName, PropertyValues pvs) throws Throwable {
		// ...
		for (InjectedElement element : elementsToIterate) {
			// 执行注入逻辑
			element.inject(target, beanName, pvs);
		}
}

protected void inject(Object target, String requestingBeanName, PropertyValues pvs) throws Throwable {
	// 通过反射的方式注入
	if (this.isField) {
		Field field = (Field) this.member;
		ReflectionUtils.makeAccessible(field);
		field.set(target, getResourceToInject(target, requestingBeanName));
	}
	else {
		if (checkPropertySkipping(pvs)) {
			return;
		}
		try {
			Method method = (Method) this.member;
			ReflectionUtils.makeAccessible(method);
			method.invoke(target, getResourceToInject(target, requestingBeanName));
		}
		catch (InvocationTargetException ex) {
			throw ex.getTargetException();
		}
	}
}

3.5. initializeBean () - Bean 初始化

initializeBean() 方法负责完成 Bean 的初始化工作，包括调用初始化方法和应用 BeanPostProcessor。

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
	if (System.getSecurityManager() != null) {
		// ...
	}
	else {
		// 调用 Aware 接口方法
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
		// 应用 BeanPostProcessor 的前置初始化处理
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
		// 调用初始化方法
		invokeInitMethods(beanName, wrappedBean, mbd);
	}
	// ...

	if (mbd == null || !mbd.isSynthetic()) {
		// 应用 BeanPostProcessor 的后置初始化处理（AOP 在此处织入）
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}
	return wrappedBean;
}

这个方法的主要步骤包括：

1. 调用 Bean 的 Aware 接口方法（如 BeanNameAware、BeanFactoryAware 等）。
2. 应用 BeanPostProcessor 的前置初始化处理。
3. 调用 Bean 的初始化方法（如 @PostConstruct 注解的方法或实现 InitializingBean 接口的 afterPropertiesSet() 方法）。
4. 应用 BeanPostProcessor 的后置初始化处理（AOP 代理在此处生成）。

四、完结

通过对 finishBeanFactoryInitialization() 方法及其核心子方法的分析，我们深入了解了 Spring Bean 生命周期的各个阶段源码逻辑。整个过程涉及 Bean 的实例化、属性填充、初始化

其实bean生命周期过程中还有一些重要的知识点待总结和学习，例如: [属性填充阶段的“三级缓存与循环引用处理”]、[初始化后置处理阶段的“AOP 代理的生成时机”]
请期待后续总结 ✿ヽ(°▽°)ノ✿