Spring IOC源码：简单易懂的Spring IOC 思路介绍 Spring IOC源码：核心流程介绍 Spring IOC源码：ApplicationContext刷新前准备工作 Spring IOC源码：obtainFreshBeanFactory 详解（上） Spring IOC源码：obtainFreshBeanFactory 详解（中） Spring IOC源码：obtainFreshBeanFactory 详解（下） Spring IOC源码：＜context:component-scan＞源码详解 Spring IOC源码：invokeBeanFactoryPostProcessors 后置处理器详解 Spring IOC源码：registerBeanPostProcessors 详解 Spring IOC源码：实例化前的准备工作 Spring IOC源码：finishBeanFactoryInitialization详解 Spring IoC源码：getBean 详解 Spring IoC源码：createBean（ 上） Spring IoC源码：createBean（ 中） Spring IoC源码：createBean（ 下） Spring IoC源码：finishRefresh 完成刷新详解
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {//如果是单例并且是FactoryBean则尝试移除
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) { //创建Bean实例，通过策略进行创建，如果选择有参构造或无参构造
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//获取当前实例对象
final Object bean = instanceWrapper.getWrappedInstance();
//当前实例的Calss对象
ClassbeanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) { //设置当前bean定义信息的目标类型
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try {//执行MergedBeanDefinitionPostProcessor类型后置处理器的postProcessMergedBeanDefinition方法，
//如@Autowire注解，就是通过该后置处理器进行解析
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
//如果是单例，允许循环依赖，并且beanName正在创建中
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");
}
//包装成FactoryObject对象，并添加到三级缓存中
addSingletonFactory(beanName, () ->getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try { //初始化过程，进行属性注入。该过程递归创建其依赖的属性。如果A中有B，B中有C，则创建B跟C。
populateBean(beanName, mbd, instanceWrapper);
//该过程执行后置处理器的before方法，bean的init方法，后置处理器的after方法，可能会生成新的bean对象
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex;
}
else { throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) { //从缓存中获取，因为上面我们将其添加到三级缓存中，从三级缓存中获取会调用FactoryObject对象的getObject方法，可能会触发AOP代理。返回代理对象
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) { //如果bean对象还是原来的，则将三级缓存中获取的对象赋值过去
if (exposedObject == bean) {exposedObject = earlySingletonReference;
}
//如果exposedObject在initializeBean方法中被增强 && 不允许在循环引用的情况下使用注入原始bean实例
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {// 获取依赖当前beanName的所有bean名称
String[] dependentBeans = getDependentBeans(beanName);
SetactualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
//尝试移除这些bean的实例，因为这些bean依赖的bean已经被增强了，他们依赖的bean相当于脏数据
for (String dependentBean : dependentBeans) {if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try { //注册用于销毁的bean，执行销毁操作的有三种：自定义destroy方法、DisposableBean接口、DestructionAwareBeanPostProcessor
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) { throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
