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

前言

上一章节解读了顶层抽象实现类 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;

		// 如果是单例，从单例缓存获取并清除
		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，此处会”强行“放入三级缓存
		 * 		如果当前 bean 以及被循环依赖过，那么它以及在三级缓存了，此处相当于无操作
		 */
		if (earlySingletonExposure) {
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				// ...
			}
		}

		// ...

		return exposedObject;
	}

• createBeanInstance 方法用于创建 bean 实例对象，该过程涉及很多细节：比如指定了基于构造方法的自动依赖注入（AUTOWIRE_CONSTRUCTOR）或者后处理器推断出唯一的构造方法（@Autowired 注解的构造方法）又或者有对应的 factoryMethod（@Bean 注解形式注册的 bean）等情况下都会基于构造方法的参数进行依赖的自动注入，其他情况则通常是对象的实例化（即 new 一个，在后续阶段填充属性）
• 执行所有的 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) {
		
		// ...

		/**
		 * 此处是调用所有的 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 进行属性填充
• 这里总结一下，基于 构造方法（或工厂方法） 的自动依赖注入是发生在 createBeanInstance 阶段的，其次是该方法阶段中的 byType byName 自动依赖注入，再其次就是基于 注解后处理驱动 的依赖注入，最后才是基于 PropertyValues 的属性注入（直接在 BeanDefinition 中定义的那种，或者 xml 驱动时的 标签）

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

createBean

	@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实例

autowireBean

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

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

resolveBeanByName

	@Override
	public Object resolveBeanByName(String name, DependencyDescriptor descriptor) {
		InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
		try {
			// 基于 name 的依赖获取，比如 @Resource 的处理
			return getBean(name, descriptor.getDependencyType());
		}
		finally {
			ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
		}
	}

• 基于 beanName 的依赖查找
• @Resource 注解的解析就基于该方法

resolveDependency

	@Override
	@Nullable
	public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException {
		return resolveDependency(descriptor, requestingBeanName, null, null);
	}

	@Nullable
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;

• 类型优先的属性注入基于此方法，比如 @Autowired 注解的解析
• 最终由子类实现

还有大量的方法不一一了解

总结

• 作为 AbstractBeanFactory 的子类，AbstractAutowireCapableBeanFactory 实现了核心抽象方法 createBean，该方法用于构造一个执行全生命周期的 bean实例
• 作为 AutowireCapableBeanFactory 的实现类，AbstractAutowireCapableBeanFactory 提供了 各阶段生命周期 的细粒度实现，比如熟悉的 applyBeanPostProcessorsAfterInitialization 方法等
• 提供抽象方法 resolveDependency 交给子类实现，主要是注入依赖的解析

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

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