Spring IOC - Bean的生命周期之实例化
在Spring启动流程文章中讲到，容器的初始化是从refresh方法开始的，其在初始化的过程中会调用finishBeanFactoryInitialization方法。
而在该方法中则会调用DefaultListableBeanFactory#preInstantiateSingletons方法，该方法的核心作用是初始化非延迟加载的Bean，且提供了两个扩展点。源码及注释如下：
@Override
public void preInstantiateSingletons() throws BeansException {
//该方法先复制一份BeanDefinition名称列表，为了防止在初始化过程中有新的BeanDefinition被注册，
//从而导致遍历过程中的并发修改异常
List beanNames = new ArrayList<>(this.beanDefinitionNames);
//对于每个非抽象、单例且非懒加载的 BeanDefinition，如果它是一个 FactoryBean，
//则获取 FactoryBean 的实例，如果 FactoryBean 实现了 `SmartFactoryBean` 接口,
//则调用 `isEagerInit` 方法判断是否需要预先实例化，默认为需要预先实例化。
//如果该 Bean 需要预先实例化，则调用 `getBean` 方法进行实例化。
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 不是抽象类&&是单例&&不是懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
FactoryBean factory = (FactoryBean) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(
(PrivilegedAction) ((SmartFactoryBean) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
// 这里就是普通单例Bean正式初始化了
getBean(beanName);
}
}
}
//对于每个实现了SmartInitializingSingleton接口的单例Bean,调用其afterSingletonsInstantiated方法
// 执行时机是在bean的生命周期最后，即在bean完成实例化、属性注入、相关初始化操作后
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction 对该方法可简单总结为以下三点：
-
对于实现了SmartFactoryBean的子类，如果isEagerInit(立即初始化)返回true，则对本是懒加载的getObject对象立即初始化；
-
否则，正常调用getBean方法开始bean的生命周期；
-
在bean的生命周期处理结束后，对实现了SmartInitializingSingleton接口的单例Bean,调用其afterSingletonsInstantiated方法
继续就是"干实事"的方法：AbstractBeanFactory#doGetBean，其逻辑流程图如下所示：
其中创建Bean的核心方法为AbstractAutowireCapableBeanFactory#createBean，源码及注释如下：
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
RootBeanDefinition mbdToUse = mbd;
//确保实际解析了bean Class类型
//并在动态解析类的情况下克隆beanDefinition，因为动态解析的类无法存储在共享的合并beanDefinition中
Class resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
// 预先标记没有重载的方法，以避免参数类型检查的开销
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 实例化前阶段：让BeanPostProcessors有机会返回代理而不是目标bean实例
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
// 创建bean真正"干实事"方法
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}在真正实例化之前，如果bean实现了InstantiationAwareBeanPostProcessor接口，则会调用其postProcessBeforeInstantiation方法，这就是bean生命周期的实例化前阶段。该接口提供的核心方法及作用如下表所示：
| 方法名称 |
作用阶段 |
作用 |
| postProcessBeforeInstantiation |
实例化前 |
该方法传入目标Bean类型与BeanName；该方法可以返回一个该Bean类型的对象，或对该Bean的一个代理对象； 当该方法返回了实例化对象后，后续的所有Bean实例化与初始化的动作将不再进行。只会调用后续的BeanPostProcessor#postProcessAfterInnitialization方法 |
| postProcessAfterInstantiation |
实例化后 |
该方法传入还没有装配属性的Bean对象以及BeanName 如果该方法返回false，则将跳过后续的属性装配动作，一般应该返回true |
| postProcessProperties |
实例化后 属性填充前 |
该方法传入在配置期间所配的PropertyValues以及BeanName 该方法返回的PropertyValues将最终装配到Bean对象中 |
接下来是doCreateBean方法，其逻辑流程图如下：
-
先检查
instanceWrapper变量是不是null，这里一般是null，除非当前正在创建的Bean在factoryBeanInstanceCache中存在这个是保存还没创建完成的FactoryBean的集合。 -
调用createBeanInstance方法实例化Bean，这个方法在后面会讲解
-
如果当前
RootBeanDefinition对象还没有调用过实现了的MergedBeanDefinitionPostProcessor接口的方法，则会进行调用 -
当满足以下三点 （1）是单例Bean （2）尝试解析bean之间的循环引用 （3）bean目前正在创建中 则会进一步检查是否实现了
SmartInstantiationAwareBeanPostProcessor接口如果实现了则调用是实现的getEarlyBeanReference方法 -
调用
populateBean方法进行属性填充 -
调用
initializeBean方法对Bean进行初始化
关键方法AbstractAutowireCapableBeanFactory#createBeanInstance源码及注释如下：
// 使用适当的实例化策略为指定的bean创建一个新实例：工厂方法、构造函数自动装配或简单实例化
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
// 获取bean的Class对象
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());
}
// 通过bd中提供的instanceSupplier来获取一个对象
// 正常bd中都不会有这个instanceSupplier属性，这里也是Spring提供的一个扩展点，但实际上不常用
Supplier instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// 如果工厂方法不为null,则使用工厂方法初始化策略
// bd中提供了factoryMethodsName属性，那么要使用工厂方法的方法来创建对象
// 工厂方法又会区分静态工厂方法跟实例工厂方法
if (mbd.getFactoryMethodName() != null) {
// 如果使用了工厂方法，则调用工厂方法创建bean实例。@Bean注解创建的实例会进入这里
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
// 在原型模式下，如果已经创建过一次这个Bean了，那么就不需要再次推断构造函数了
// 是否推断过构造函数
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);
}
}
// Candidate constructors for autowiring?
// 需要根据参数解析构造函数
Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
// 构造函数自动注入
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
// 获取首选构造函数，作为默认构造器
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
// 没有什么特殊的处理：简单使用无参构造方法
return instantiateBean(beanName, mbd);
}总结如下：
-
先检查Class是否已经关联了，并且对应的修饰符是否是public的
-
如果用户定义了Bean实例化的函数，则调用并返回
-
如果当前Bean实现了
FactoryBean接口则调用对应的FactoryBean接口的getObject方法 -
根据getBean时候是否传入构造参数进行处理
-
4.1 如果没有传入构造参数，则检查是否存在已经缓存的无参构造器，有则使用构造器直接创建，没有就会调用
instantiateBean方法先获取实例化的策略默认是CglibSubclassingInstantiationStrategy，然后实例化Bean。最后返回 -
4.2 如果传入了构造参数，则会先检查是否实现了
SmartInstantiationAwareBeanPostProcessor接口，如果实现了会调用determineCandidateConstructors获取返回的候选构造器。 -
4.3 检查4个条件是否满足一个 （1）构造器不为null， （2）从RootBeanDefinition中获取到的关联的注入方式是构造器注入（没有构造参数就是setter注入，有则是构造器注入） （3）含有构造参数 （4）getBean方法传入构造参数不是空 满足其中一个则会调用返回的候选构造器实例化Bean并返回，如果都不满足，则会根据构造参数选则合适的有参构造器然后实例化Bean并返回
-
如果上面都没有合适的构造器，则直接使用无参构造器创建并返回Bean。