【源码】Spring —— BeanFactory 解读 3 AbstractAutowireCapableBeanFactory

前言
版本
AbstractAutowireCapableBeanFactory
- createBean
- doCreateBean
- getEarlyBeanReference
- populateBean
- initializeBean
- 其他方法
总结

前言

上一章节解读了顶层抽象实现类

AbstractBeanFactory

，它主要实现了

BeanFactory

HierarchicalBeanFactory

ConfigurableBeanFactory

定义的大多数方法

其中，

BeanFactory#getBean

方法的实现最终是委托在抽象方法

createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] arg

的，

AbstractAutowireCapableBeanFactory

便提供了该方法的实现，本文会重点解读该方法

版本

Spring 5.3.x

AbstractAutowireCapableBeanFactory

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory

AbstractAutowireCapableBeanFactory

是

AbstractBeanFactory

的子类，同时实现了

AutowireCapableBeanFactory

，之前提到

AutowireCapableBeanFactory

接口拓展了

自动装配

的能力，

AbstractAutowireCapableBeanFactory

便提供了相关实现

createBean

上文提到，

AbstractBeanFactory

实现

getBean

方法的逻辑最终是委托在抽象方法

createBean

的，

AbstractAutowireCapableBeanFactory

给出了该方法的实现

// 核心方法，创建bean实例、属性填充、后置处理等
	@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		RootBeanDefinition mbdToUse = mbd;

		// 解析类型（AbstractBeanFactory#resolveBeanClass）
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			// ...
		}

		try {
			// 这个地方，允许 后置处理器 提前返回一个代理实例
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				return bean;
			}
		}
		catch (Throwable ex) {
			// ...
		}

		try {
			// 创建bean
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			return beanInstance;
		}
		catch (Throwable ex) {
			// ...
		}
	}

	@Nullable
	protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {

					/**
					 * 如果 InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation
					 * 		返回一个非空实例，则 生命周期 短路，直接执行所有后置处理器的
					 * 		postProcessAfterInitialization 方法
					 */
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

代码如上，略去了打印日志等，做个概括：

在创建 bean实例 前，有个重要方法 resolveBeforeInstantiation ：此处会执行 InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation ，如果返回非 null ，则短路生命周期返回目标实例
如果上述方法返回 null （大多数场景），则由 doCreateBean 方法创建 bean实例

doCreateBean

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

		BeanWrapper instanceWrapper = null;

		// 如果是单例，从 工厂bean 缓存获取并清除缓存
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}

		// 如果为空，则创建对应的 BeanWrapper
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}

		// 取出包装的实例进行后续处理
		Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}
		
		// 执行所有的 MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					// ...
				}
				mbd.postProcessed = true;
			}
		}

		/**
		 * 如果允许 循环依赖，此处会创建对应的 单例工厂
		 *  	并将其缓存到 二级单例缓存（singletonFactories） 中
		 *  	getObject 方法委托给 getEarlyBeanReference 方法
		 */
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		Object exposedObject = bean;
		try {
			// 属性填充
			populateBean(beanName, mbd, instanceWrapper);

			// 初始化操作：工厂回调、初始化回调、后处理
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		catch (Throwable ex) {
			// ...
		}

		/**
		 * 对于循环依赖的 bean，此处尝试从三级缓存获取
		 */
		if (earlySingletonExposure) {
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				// ...
			}
		}

		// ...

		return exposedObject;
	}

createBeanInstance 方法用于创建 bean 实例对象，该过程是我认为创建 bean 过程中最最复杂的方法了，包括构造器的推断等诸多细节，此处不展开讨论
执行所有的 MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition ， @Autowired @Value 注解处理相关在此处有涉及
对于需要处理 循环依赖 的实例，此处会借助 工厂缓存 进行处理
核心方法 populateBean ：填充 bean实例 的属性
initializeBean 方法进行 bean实例 的后续处理：初始化回调等

getEarlyBeanReference

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
		Object exposedObject = bean;

		/**
		 * 如果存在 InstantiationAwareBeanPostProcessor，则遍历执行 
		 * 		getEarlyBeanReference，该过程可能返回一个 代理对象
		 */
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
				exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
			}
		}
		return exposedObject;
	}

doCreateBean

方法中创建了对应

bean实例对象

后，在允许

循环依赖

的情况下会缓存对应的

单例工厂

，该方法默认实现即

getEarlyBeanReference

：

这里如果存在 InstantiationAwareBeanPostProcessor ，便会依此执行 getEarlyBeanReference 方法，即此处是有可能返回 代理对象 的
此处创建出来的实例之后会被加入 三级缓存 ，以避免可能多次构造实例造成的性能损耗

populateBean

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		// 空处理
		if (bw == null) {
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				return;
			}
		}

		/**
		 * 此处是调用所有的 InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation
		 * 		但凡有返回 false，此处就 return 不继续注入了，目前的默认实现都是 true
		 */
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
				if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					return;
				}
			}
		}

		// 从 BeanDefinition 获取 PropertyValues
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		/**
		 * 解析注入模式
		 * AUTOWIRE_BY_NAME：根据名称注入
		 * AUTOWIRE_BY_TYPE：根据类型注入
		 * 一般情况 resolvedAutowireMode == AUTOWIRE_NO
		 */
		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			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;
		/**
		 * 如果存在 InstantiationAwareBeanPostProcessor
		 * 则执行所有 InstantiationAwareBeanPostProcessor#postProcessProperties
		 * 		辅助完成属性填充，诸如基于 @Autowired 等注解的属性注入就发生在此处
		 */
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
				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;
			}
		}
		// 依赖校验
		if (needsDepCheck) {
			if (filteredPds == null) {
				filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			}
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}

		// 属性绑定
		if (pvs != null) {
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

核心方法：属性填充，方法概括：

填充前会执行所有 InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation ，但凡有返回 false 的就不再继续，默认实现都是返回 true
根据解析的 AutowireMode 处理 名称注入 和 类型注入 两种情况，一般情况下注入模式是 AUTOWIRE_NO ，即不进行上述处理
执行所有 InstantiationAwareBeanPostProcessor#postProcessProperties 来辅助完成顺序填充，其中的代表处理器有 AutowiredAnnotationBeanPostProcessor CommonAnnotationBeanPostProcessor ：基于 @Autowired @Value 等注解进行属性注入
最后基于 BeanWrapper 和上述 PropertyValues 进行属性填充

initializeBean

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {

		/**
		 * invokeAwareMethods：
		 * 执行 BeanNameAware BeanClassLoaderAware BeanFactoryAware 回调
		 */
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		/**
		 * 执行所有 BeanPostProcessor#postProcessBeforeInitialization：初始化前处理
		 */
		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			/**
			 * 初始化：
			 * 1）InitializingBean#afterPropertiesSet
			 * 2）init-method 回调
			 */
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			
		}
		/**
		 * 执行所有 BeanPostProcessor#postProcessAfterInitialization：初始化后处理
		 */
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

此时的

bean实例

已构造完成并且填充好属性，

实例化

完成并进入

初始化

阶段：

初始化前处理：执行所有 BeanPostProcessor#postProcessBeforeInitialization 方法
初始化操作主要是：1）执行所有实现了 InitializingBean 接口的 afterPropertiesSet 方法 2）执行所有 init-method ，比如 @Bean 注解上指定的、 @PostConstruct 注解标注的方法等
初始化后处理：执行所有 BeanPostProcessor#postProcessAfterInitialization 方法

其他方法

AbstractAutowireCapableBeanFactory

实现了

AbstractBeanFactory

定义的抽象方法

createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

，它基于

容器

扫描的

BeanDefinition

提供了全生命周期

bean实例

的构造，包括

bean实例对象

的构造、各种后处理回调的执行、属性的填充、初始化操作等

同时，作为

AutowireCapableBeanFactory

接口的实现，它对各生命周期的实现也是分离开的，并暴露出对应的方法供以调用，譬如：

@Override
	@SuppressWarnings("unchecked")
	public <T> T createBean(Class<T> beanClass) throws BeansException {
		RootBeanDefinition bd = new RootBeanDefinition(beanClass);
		// 默认原型
		bd.setScope(SCOPE_PROTOTYPE);
		bd.allowCaching = ClassUtils.isCacheSafe(beanClass, getBeanClassLoader());
		return (T) createBean(beanClass.getName(), bd, null);
	}

基于给定

Class

构造

RootBeanDefinition

，来创建

bean实例

@Override
	public void autowireBean(Object existingBean) {
		RootBeanDefinition bd = new RootBeanDefinition(ClassUtils.getUserClass(existingBean));
		bd.setScope(SCOPE_PROTOTYPE);
		bd.allowCaching = ClassUtils.isCacheSafe(bd.getBeanClass(), getBeanClassLoader());
		BeanWrapper bw = new BeanWrapperImpl(existingBean);
		initBeanWrapper(bw);
		populateBean(bd.getBeanClass().getName(), bd, bw);
	}

给定实例填充属性并执行初始化操作

等等

总结

作为 AbstractBeanFactory 的子类， AbstractAutowireCapableBeanFactory 实现了核心抽象方法 createBean ，该方法用于构造一个执行全生命周期的 bean实例
作为 AutowireCapableBeanFactory 的实现类， AbstractAutowireCapableBeanFactory 提供了 各阶段生命周期 的细粒度实现，比如熟悉的 applyBeanPostProcessorsAfterInitialization 方法等

上一篇：【源码】Spring —— BeanFactory 解读 2 AbstractBeanFactory

下一篇：【源码】Spring —— BeanFactory 解读 4 关于循环依赖

【源码】Spring —— BeanFactory 解读 3 AbstractAutowireCapableBeanFactory前言版本AbstractAutowireCapableBeanFactory总结

【源码】Spring —— BeanFactory 解读 3 AbstractAutowireCapableBeanFactory

前言

版本

AbstractAutowireCapableBeanFactory

createBean

doCreateBean

getEarlyBeanReference

populateBean

initializeBean

其他方法

总结

继续阅读

驯服烂代码_驯服Tomcat：Tomcat 5的过滤技巧

基于Springboot+VUE+Mysql的大学生校园疫情防控管理系统

Using MessageConverter

驯服烂代码_C＃中的驯服配置

如何提高个人开源网站源码开发利用率

Spring Cloud整合Sleuth，当请求完成后，Zipkin没有链路信息

JAVA自学之路——马士兵

Rabbitmq命令行手动创建队列

整合 Spring 开发框架及服务端技术

SSM整合02---Spring-SpringMVC层一、添加web框架支持二、web.xml三、spring-mvc.xml

SSM框架（二）------------表现层的SpringMVC

Intellij idea基于Maven 的SSM 框架整合

Spring数据和Redis

SpringMVC的启动过程源码分析1 SpringMVC 配置XML的方式启动2 SpringMVC纯注解模式启动

Java Spring 框架

SpringCloud微服务（四）之ribbon笔记ribbon是什么？入门案例自定义均衡负载算法