从AbstractAutowireCapableBeanFactory说起、AbstractAutowireCapableBeanFactory顾明思议、是带有自动注入功能的BeanFactory、我们先看他的类继承结构
如上图所示、AbstractAutowireCapableBeanFactory实现了AbstractBeanFactory说明其本身实现了BeanFactory的功能、包括bean的创建。
其次AbstractAutowireCapableBeanFactory也实现了AutowireCapableBeanFactory扩展接口、表明其具有自动注入属性的功能。由于其是一个抽象的类、所以由此猜测AbstractAutowireCapableBeanFactory实现了bean创建的默认行为以及基础的属性注入功能，来看spring源码对AbstractAutowireCapableBeanFactory的注释:
/**
* Abstract bean factory superclass that implements default bean creation,
* with the full capabilities specified by the {@link RootBeanDefinition} class.
* Implements the {@link org.springframework.beans.factory.config.AutowireCapableBeanFactory}
* interface in addition to AbstractBeanFactory's {@link #createBean} method.
*
* <p>Provides bean creation (with constructor resolution), property population,
* wiring (including autowiring), and initialization. Handles runtime bean
* references, resolves managed collections, calls initialization methods, etc.
* Supports autowiring constructors, properties by name, and properties by type.
*
* <p>The main template method to be implemented by subclasses is
* {@link #resolveDependency(DependencyDescriptor, String, Set, TypeConverter)},
* used for autowiring by type. In case of a factory which is capable of searching
* its bean definitions, matching beans will typically be implemented through such
* a search. For other factory styles, simplified matching algorithms can be implemented.
*
* <p>Note that this class does <i>not</i> assume or implement bean definition
* registry capabilities. See {@link DefaultListableBeanFactory} for an implementation
* of the {@link org.springframework.beans.factory.ListableBeanFactory} and
* {@link BeanDefinitionRegistry} interfaces, which represent the API and SPI
* view of such a factory, respectively.
*/
简单翻译以上意思是：
它是bean工厂的超类、此bean工厂实现了bean创建功能。创建的bean具有RootBeanDefinition指定的全部功能。并且实现了AbstractBeanFactory的createBean方法。同时它也实现了AutowireCapableBeanFactory接口
提供了bean的创建(带有构造器解析)，属性注入，和初始化。处理运行时bean引用。解析收管理的集合。调用初始化的方法等等功能，提供了构造器注入、通过名称注入属性、通过类型注入属性。
其中提供给子类覆盖的主要模板方法是resolveDependency(DependencyDescriptor, String, Set, TypeConverter)这个方法用于通过类型注入的时候、提供多态的机制。
注意一点是：
AbstractAutowireCapableBeanFactory没有bean定义注册的功能、因为他并没有实现BeanDefinitionRegistry接口、注意他和DefaultListableBeanFactory的区别、DefaultListableBeanFactory它即实现了ListableBeanFactory同时也实现了BeanDefinitionRegistry。看一个类图我们就明白了。
- AbstractBeanFactory---->doCreateBean开始说起:
/**
* Create a bean instance for the given merged bean definition (and arguments).
* The bean definition will already have been merged with the parent definition
* in case of a child definition.
* <p>All bean retrieval methods delegate to this method for actual bean creation.
*
* @param beanName the name of the bean
* @param mbd the merged bean definition for the bean
* @param args explicit arguments to use for constructor or factory method invocation
* @return a new instance of the bean
* @throws BeanCreationException if the bean could not be created
*/
protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException;
此方法在AbstractBeanFactory是一个protected类型的方法、方法签名表明该方法是用于创建bean实例的方法、调用该方法的时候所有的bean定义已经准备好、如果是子类的bean定义已经完全和父bean定义合并。所有的获取bean实例的方法都会委托给此方法去做真正的创建工作。
- AbstractAutowireCapableBeanFactory--->doCreateBean
//这里的beanName就是我们在xml中定义的bean定义名称。mbd是已经合并(如果是子类需要和父类合并属性)的bean定义对象。args表示如果是构造器注入需要传入的参数。
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
RootBeanDefinition mbdToUse = mbd;
=================================(参考2.1)==============================
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
// 解析 bean 的类型 此处使用来解析bean的类型。因为RootBeanDefinition保存的只是bean的定义信息、
// bean的定义信息中只是包含了 bean的名称、但是还没有利用反射解析出Bean的真正Class引用、故resolveBeanClass利用反射解析出
//bean的Class<?>信息存入到RootBeanDefinition的beanClass属性当中去。
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
=================================(参考2.2)==============================
// Prepare method overrides.
// 处理 lookup-method 和 replace-method 配置，Spring 将这两个配置统称为 override method
mbdToUse.prepareMethodOverrides();
=================================(参考2.3)==============================
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 在 bean 初始化前应用后置处理，如果后置处理返回的 bean 不为空，则直接返回
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
=================================(参考2.4)===============================
// 调用 doCreateBean 创建 bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
}
2.1. doCreateBean过程
2.2. doCreateBean过程
2.3. doCreateBean过程
2.4. doCreateBean过程
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
/*
* BeanWrapper 是一个基础接口，由接口名可看出这个接口的实现类用于包裹 bean 实例。
* 通过 BeanWrapper 的实现类可以方便的设置/获取 bean 实例的属性
*/
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 从缓存中获取 BeanWrapper，并清理相关记录
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
/*
* 创建 bean 实例，并将实例包裹在 BeanWrapper 实现类对象中返回。createBeanInstance
* 中包含三种创建 bean 实例的方式：
* 1. 通过工厂方法创建 bean 实例
* 2. 通过构造方法自动注入（autowire by constructor）的方式创建 bean 实例
* 3. 通过无参构造方法方法创建 bean 实例
*
* 若 bean 的配置信息中配置了 lookup-method 和 replace-method，则会使用 CGLIB
* 增强 bean 实例。关于这个方法，后面会专门写一篇文章介绍，这里先说这么多。
*/
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 此处的 bean 可以认为是一个原始的 bean 实例，暂未填充属性
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
// 这里又遇到后置处理了，此处的后置处理是用于处理已“合并的 BeanDefinition”。
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
/*
* earlySingletonExposure 是一个重要的变量，这里要说明一下。该变量用于表示是否提前暴露
* 单例 bean，用于解决循环依赖。earlySingletonExposure 由三个条件综合而成，如下：
* 条件1：mbd.isSingleton() - 表示 bean 是否是单例类型
* 条件2：allowCircularReferences - 是否允许循环依赖
* 条件3：isSingletonCurrentlyInCreation(beanName) - 当前 bean 是否处于创建的状态中
*
* earlySingletonExposure = 条件1 && 条件2 && 条件3
* = 单例 && 是否允许循环依赖 && 是否存于创建状态中。
*/
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");
}
// 添加工厂对象到 singletonFactories 缓存中
addSingletonFactory(beanName, () ->
// 获取早期 bean 的引用，如果 bean 中的方法被 AOP 切点所匹配到，此时 AOP 相关逻辑会介入
getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
// 向 bean 实例中填充属性，populateBean 所谓的属性注入都是发生在这个方法里面、详细解析
populateBean(beanName, mbd, instanceWrapper);
/*
* 进行余下的初始化工作，详细如下：
* 1. 判断 bean 是否实现了 BeanNameAware、BeanFactoryAware、
* BeanClassLoaderAware 等接口，并执行接口方法
* 2. 应用 bean 初始化前置操作
* 3. 如果 bean 实现了 InitializingBean 接口，则执行 afterPropertiesSet
* 方法。如果用户配置了 init-method，则调用相关方法执行自定义初始化逻辑
* 4. 应用 bean 初始化后置操作
*
* 另外，AOP 相关逻辑也会在该方法中织入切面逻辑，此时的 exposedObject 就变成了
* 一个代理对象了
*/
exposedObject = initializeBean(beanName, exposedObject, mbd);
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
// 若 initializeBean 方法未改变 exposedObject 的引用，则此处的条件为 true。
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);
}
}
}
}
}
// Register bean as disposable.
// 注册销毁逻辑
registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
}