往期博客：
《Spring源码深度解析 郝佳 第2版》容器的基本实现与XML文件的加载
往期博客完成了xml文件加载和内容解析，将BeanDefinition相关信息保存在容器中，接着就是bean的加载即getBean()的流程
本文已参与「新人创作礼」活动，一起开启掘金创作之路。
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("beanFactory.xml"));
// 就是对下面语句的分析，手动getBean流程
//注意：对于单例，如果没有配置lazy-init，那么spring容器启动的时候，就会提前创建，而对于多例，则是用到的时候才创建
Object sichaolong = beanFactory.getBean("sichaolong");
目录
一、需要了解
- FactoryBean
- ObjectFactory
二、getBean()流程分析
- 主要流程
- 重要流程
getSingleton(beanName)尝试从缓存获取bean，获取的到接着调用getObjectForBeanInstance()完善从缓存获取的bean- 缓存中不存在bean，并且该bean不在创建中
- 判断是不是原型模式，如果是，因为原型模式未处理循环依赖，每次都会创建bean，此时发现当前bean正在创建，即发生了循环依赖，直接报错
- 处理
<bean>配置了depends-on其他的bean，需要递归的getBean(该bean depends-on的bean) - 调用单例的
getSingleton(beanName，ObjectFactory factory)，其实是调用内部调用ObjectFactory#factory.getObject()，进而createBean()以及前后处理器- 调用
prepareMethodOverrides()验证覆盖方法 - 调用resolveBeforeInstantiation进行实例化前处理器
postProcessBeforeInstantitation()和 实例化后置处理器postBeanAfterInitialization()（因为调用处理器之后直接返回bean不在进行doCreateBean()调用），return bean - 调用
doCreateBean()进行构造函数半实例化（还没填充属性populateBean()和初始化initializeBean()），这里面判断是否允许提前曝光ObjectFactory，调用addSingletonFactory()将ObjectFactory加入三级缓存 - 后续
populateBean()和initializeBean()。return bean
- 调用
三、如何解决的循环依赖？
- 构造器注入
- setter注入
四、doCreateBean()创建bean详细分析
- 根据bean指定的策略半实例化
- 是否允许提前曝光ObjectFactory，加入三级缓存
- 对bean的各个属性填充populateBean()
- 初始化initializeBean()
一、需要了解
1、FactoryBean
一般情况下Spring通过xml配置bean信息通过反射创建对象，但是需要配置很多的属性在xml中，这时候如果能在代码中提供一种简单的方式就好了
FactoryBean就是为了解决这个问题，它是一个工厂类接口，用户可以通过实现该接口定制实例化bean的逻辑，如只需要输入一串包含信息的字符串，配合实现类XxxFactoryBean的getObject()解析类内封装的信息属性字段，就可以定制实例，避免一个一个的配置实例属性
Spring本身就带有70个FactoryBean的实现，3.0之后开始支持泛型。如MyBatis中的sqlSessionFactoryBean就是此类型。
public interface FactoryBean<T> {
String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
@Nullable
T getObject() throws Exception;
@Nullable
Class<?> getObjectType();
default boolean isSingleton() {
return true;
}
}
当配置的<bean>标签内的class的实现类是FactoryBean时候，通过getBean()方法返回的不是Factory本身，而是他的getObject()方法返回的我们需要的bean，相当于getObject()方法代理了getBean()方法
2、ObjectFactory
ObjectFactory和FactoryBean有点类似，它主要用作于三级缓存中来解决单例循环依赖问题
ObjectFactory就是一个普通的工厂对象接口，对于spring在doGetBean处的使用时，在于创建对象的过程由框架通过ObjectFactory定义，而创建的时机交给拓展接口Scope。除此之外ObjectFactory就是一个普通的接口
此外在将给依赖注入列表注册一个ObjectFactory类型的对象，在注入过程中会调用objectFactory.getObject()来创建目标对象注入进去。（如beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());）此时SessionObjectFactory就会生成一个可以引用到的半实例SessionObject，至于该实例是否完成全部实例化操作不确定
package org.springframework.beans.factory;
import org.springframework.beans.BeansException;
@FunctionalInterface
public interface ObjectFactory<T> {
T getObject() throws BeansException;
}
他们二者的区别： 简单来说就是通过FactoryBean你可以控制对象如何创建，而ObjectFactory借助Scope接口自定义scope你可以控制对象的创建时机
二、getBean()的流程
核心三个类
整个流程主要的三个类
- AbstractBeanFactory
- DefaultSingletonBeanRegistry
- AbstractAutowiredCapableBeanFactory
1、先看AbstractFactory类的调用流程
getBean(String name)调用doGetBean(String name)- 转换对应的beanName：传入的String可能不是beanName而是别名，也可能是FactoryBean(前面需要加上
&) - 尝试从缓存中加载单例
getSingleton(beanName)：检查一、二、三级缓存，首次创建缓存肯定没有 - 缓存中存在，还需要进行bean的完全实例化：为了解决循环依赖即使缓存中存在bean也可能是FactoryBean类型，使用工厂模式的
getObjectForBeanInstance()才能获取到完全实例化的bean，然后return bean - 缓存中不存在：
5. 需要原型模式依赖检查，只有单例模式下才能解决循环依赖，原型模式存在循环依赖直接报错。
6. 检测parentFactory：如果beanDefinitionMap不包含beanName，尝试从parentFactory查找
7. 将GenericBeanDefinition转为RootBeanDefinition便于后续处理，当bean是某个bean的子bean的时候会合并父bean的相关属性，即ChildrenBeanDefinition和并RootBeanDefinition中的属性
8. 寻找bean内的depends-on，递归调用
getBean(dob)先将依赖的bean初始化 9. 针对不同scope的bean进行创建，如Singleton、prototype、request等，此处调用相应的getSingleton(beanName，objectoryBean)，然后经过一系列流程（也就是这里解决的循环依赖问题），最后还需一步处理bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);10. 类型转换，如将创建的bean转为requireType的类型
// 实现子类AbstractBeanFactory#getBean()
public Object getBean(String name) throws BeansException {
return this.doGetBean(name, (Class)null, (Object[])null, false);
}
//重载方法
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
// 1、转换对应BeanName
String beanName = this.transformedBeanName(name);
/**
检查一、二级缓存或者三级缓存（实例工厂）是否有对应的实例
Spring为了解决循环依赖，在bean刚开始创建未完成创建的时候，就将bean的ObjectFactory提早曝光到三级缓存
**/
// 2、直接尝试从缓存中获取，为了解决循环依赖
Object sharedInstance = this.getSingleton(beanName);
Object bean;
// 一、缓存中存在
if (sharedInstance != null && args == null) {
if (this.logger.isTraceEnabled()) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
} else {
this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 3、返回完全实例化的bean，因为从缓存中取得bean可能是半实例化的
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
}
// 二、缓存中还未存在
else {
// 4、原型情况下存在循环依赖就报错
if (this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
BeanFactory parentBeanFactory = this.getParentBeanFactory();
// 5、如果beanDefinitionMap不包含beanName，尝试从parentFactory查找
if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
String nameToLookup = this.originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
}
if (args != null) {
return parentBeanFactory.getBean(nameToLookup, args);
}
if (requiredType != null) {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
return parentBeanFactory.getBean(nameToLookup);
}
// 6、如果不是仅仅做类型检查而是创建bean,这里需要记录
if (!typeCheckOnly) {
this.markBeanAsCreated(beanName);
}
try {
// 7、将存在DefaultListableBeanDefinitionFactory变量beanDefinitionMap中
//的GenericBeanDefinition转为RootBeanDefinition
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
// 8、当bean是某个bean的子bean的时候会合并父bean的相关属性，即ChildrenBeanDefinition和并RootBeanDefinition中的属性
this.checkMergedBeanDefinition(mbd, beanName, args);
// 9、若该bean 在<bean> 配置了depends-on=beanA,需要先初始化beanA
String[] dependsOn = mbd.getDependsOn();
String[] var11;
if (dependsOn != null) {
var11 = dependsOn;
int var12 = dependsOn.length;
for(int var13 = 0; var13 < var12; ++var13) {
String dep = var11[var13];
if (this.isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
this.registerDependentBean(dep, beanName);
try {
this.getBean(dep);
} catch (NoSuchBeanDefinitionException var24) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
}
}
}
// 10、实例化依赖的那些bean就可以实例化自己了，拿着自己的BeanDefinition
// （1）单例
if (mbd.isSingleton()) {
sharedInstance = this.getSingleton(beanName, () -> {
try {
// 11、createBean()实例化，注意这里是半实例化，为了解决循环依赖
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
// 12、已经解决了循环依赖，获取完全实例化的bean
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// （2）原型
else if (mbd.isPrototype()) {
var11 = null;
Object prototypeInstance;
try {
this.beforePrototypeCreation(beanName);
prototypeInstance = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//（3）其他
else {
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
Scope scope = (Scope)this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
this.beforePrototypeCreation(beanName);
Object var4;
try {
var4 = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
return var4;
});
bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException var23) {
throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var23);
}
}
} catch (BeansException var26) {
this.cleanupAfterBeanCreationFailure(beanName);
throw var26;
}
}
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
} else {
return convertedBean;
}
} catch (TypeMismatchException var25) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
} else {
return bean;
}
}
// 尝试从缓存中获取getSingleton()，为了解决循环依赖，检查三级缓存
这三级缓存在DefaultSingletonBeanRegistry类定义
- singletonObjects：用于存放完全初始化好的 bean，从该缓存中取出的 bean 可以直接使用
- earlySingletonObjects：提前曝光的单例对象的cache，存放原始的 bean 对象（尚未填充属性），用于解决循环依赖，可以使用getBean(）拿到半实例化的bean
- singletonFactories：单例对象工厂的cache，存放 bean 工厂对象ObjectFactory，用于解决循环依赖
需要注意：当 一级缓存不存在，并且bean正在创建中，也就是在SingletonCurrentInCreation的缓存中，才尝试从二、三级缓存中获取，因为正在创建中的bean他的ObjectFactory已经暴露在三级缓存了
// DefalutSingletonBeanRegistry#getSingleton()
@Nullable
public Object getSingleton(String beanName) {
// 设置参数true表示只允许早期依赖
return this.getSingleton(beanName, true);
}
// 重载
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//1、尝试从一级缓存获取 singletonObjects
Object singletonObject = this.singletonObjects.get(beanName);
// 一级缓存不存在，并且bean正在创建中
if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
// 2、尝试从二级缓存中获取 earlySingletonObjects
singletonObject = this.earlySingletonObjects.get(beanName);
// 二级缓存获取不到，并且支持循环引用，并且该bean正在创建中，
if (singletonObject == null && allowEarlyReference) {
// 加锁
synchronized(this.singletonObjects) {
// 3、再次尝试从一级缓存获取
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// 4、再次尝试从二级缓存获取
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
// 5、尝试从三级缓存中获取该bean对应的ObjectFactory
ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
// 能从三级缓存中获取到该bean对应的ObjectFactory
if (singletonFactory != null) {
// 6、使用ObjectFactory的getObject()方法获取bean
singletonObject = singletonFactory.getObject();
// 7、将该半实例化的bean从三级缓存移除，添加到二级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
// 完善缓存中可能返回完全实例化的bean，需要调用getObjectForBeanInstance()
无论是从缓存中获取的bean还是根据不同的scope策略加载bean，得到bean之后第一步就是调用这个方法检查一下正确性，其实就是检查当前bean的类型是不是FactoryBean，是的话需要getObject()得到真正需要的bean
- 对FactoryBean正确性的验证
- 对非FactoryBean不做处理直接返回
- 对bean进行转化
- 将从Factory中解析bean的委托给getObjectFromFactoryBean()
// AbstractBeanFactory#getObjectForBeanInstance()
protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// 1、如果指定bean是工厂相关的（以&为前缀）
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
// 验证不通过，直接抛异常
} else if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
} else {
if (mbd != null) {
// 设置RootBeanDefinition的属性isFactoryBean
mbd.isFactoryBean = true;
}
return beanInstance;
}
}
// 2、是直接的bean,直接返回
else if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
} else {
// 3、加载FactoryBean
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
} else {
object = this.getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
FactoryBean<?> factory = (FactoryBean)beanInstance;
if (mbd == null && this.containsBeanDefinition(beanName)) {
mbd = this.getMergedLocalBeanDefinition(beanName);
}
// 是否是用户定义的而不是应用程序定义的
boolean synthetic = mbd != null && mbd.isSynthetic();
// 3、委托从Factory解析bean
object = this.getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
}
// 委托getObjectFromFactoryBean()从Factory获取bean
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
if (factory.isSingleton() && this.containsSingleton(beanName)) {
synchronized(this.getSingletonMutex()) {
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
// 4、真正执行
object = this.doGetObjectFromFactoryBean(factory, beanName);
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
} else {
if (shouldPostProcess) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
return object;
}
this.beforeSingletonCreation(beanName);
try {
object = this.postProcessObjectFromFactoryBean(object, beanName);
} catch (Throwable var14) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's singleton object failed", var14);
} finally {
this.afterSingletonCreation(beanName);
}
}
if (this.containsSingleton(beanName)) {
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
return object;
}
} else {
// 真正执行
Object object = this.doGetObjectFromFactoryBean(factory, beanName);
if (shouldPostProcess) {
try {
object = this.postProcessObjectFromFactoryBean(object, beanName);
} catch (Throwable var17) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", var17);
}
}
return object;
}
}
// 委托doGetObjectFromFactoryBean
private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
Object object;
try {
if (System.getSecurityManager() != null) {
AccessControlContext acc = this.getAccessControlContext();
try {
// 5、相当于调用factory.getObject()
object = AccessController.doPrivileged(factory::getObject, acc);
} catch (PrivilegedActionException var6) {
throw var6.getException();
}
} else {
// 5、调用factory.getObject()
object = factory.getObject();
}
} catch (FactoryBeanNotInitializedException var7) {
throw new BeanCurrentlyInCreationException(beanName, var7.toString());
} catch (Throwable var8) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", var8);
}
if (object == null) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName, "FactoryBean which is currently in creation returned null from getObject");
}
object = new NullBean();
}
return object;
}
... ...
// 调用单例getSingleton(beanName，objectFactory)
一级缓存中不存在，并且bean不再创建中。需要首次创建Bean。实际调用的是DefaultSingletonBeanRegistry的getSingleton(beanName，objectFactory)。
- createBean()的入口是使用ObjectFactory的getObject()定制的
- ObjectFactory为函数式接口，内部如果调用objectFactory.getObject()就是调用的是传入的createBean()
//AbstractBeanFactory#doGetBean()
// 判断单例
if (mbd.isSingleton()) {
// DefaultSingletonBeanRegistry#getSingleton(beanName,objectFactory)入口
sharedInstance = this.getSingleton(beanName, () -> {
//ObjectFactory为函数式接口，内部getObject()返回的是createBean()返回的半实例化的bean
try {
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
var11 = null;
Object prototypeInstance;
try {
this.beforePrototypeCreation(beanName);
prototypeInstance = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else { ... }
2、再看DefaultSingletonBeanRegistry调用流程
AbstractBeanFactory#getSingleton(beanName，objectFactory)内部调用ObjectFactory#factory.getObject()，
进而调用 AbstractBeanFactory#createBean()以及前后处理器，实际调用的是AbstractAutowiredCapableBeanFactory#createBean()
// DefaultSingletonBeanRegistry#getSingleton(beanName,ObjectFactory)
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
// 1、锁住一级缓存
synchronized(this.singletonObjects) {
// 2、再次尝试从一级缓存中获取
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction (Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (this.logger.isDebugEnabled()) {
this.logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
// 3、前置处理
this.beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = this.suppressedExceptions == null;
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet();
}
try {
================ 重要 ===============
//AbstractBeanFactory#createBean()实际调用的是AbstractAutowiredCapableBeanFactory#createBean()
singletonObject = singletonFactory.getObject();
newSingleton = true;
} catch (IllegalStateException var16) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw var16;
}
} catch (BeanCreationException var17) {
BeanCreationException ex = var17;
if (recordSuppressedExceptions) {
Iterator var8 = this.suppressedExceptions.iterator();
while(var8.hasNext()) {
Exception suppressedException = (Exception)var8.next();
ex.addRelatedCause(suppressedException);
}
}
throw ex;
} finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// 5、后置处理
this.afterSingletonCreation(beanName);
}
if (newSingleton) {
// 6、bean已经创建完成
this.addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
3、再看AbstractAutowiredCapableBeanFactory类调用流程
AbstractBeanFactory#createBean()实际调用的是AbstractAutowiredCapableBeanFactory#createBean()
进而内部调用的是AbstractAutowiredCapableBeanFactory#doCreateBean()
// 由AbstractBeanFactory的实现类AbstractAutowireCapableBeanFactory重写createBean()方法
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// 8、解析bean的Class
Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
// 9、验证准备覆盖的方法
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException var9) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
}
Object beanInstance;
try {
// 10、给BeanPostProcessors一个机会来返回代理来代理真正的实例
beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
if (beanInstance != null) {
return beanInstance;
}
} catch (Throwable var10) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
}
try {
// 11、委托给doCreateBean()
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
if (this.logger.isTraceEnabled()) {
this.logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
throw var7;
} catch (Throwable var8) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
}
}
// 调用prepareMethodOverrides()验证准备覆盖的方法
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
if (this.hasMethodOverrides()) {
this.getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
}
}
protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
int count = ClassUtils.getMethodCountForName(this.getBeanClass(), mo.getMethodName());
if (count == 0) {
throw new BeanDefinitionValidationException("Invalid method override: no method with name '" + mo.getMethodName() + "' on class [" + this.getBeanClassName() + "]");
} else {
if (count == 1) {
mo.setOverloaded(false);
}
}
}
// 调用resolveBeforeInstantiation()添加BeanPostProcessor实例化前处理器
给BeanPostProcessors一个机会来返回代理来代理真正的bean，主要是方便易以后拓展，AOP处理器就是在applyBeanPostProcessorsAfterInitialization() 这里加上的，如
- bean实例化前的后置处理：InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation()
- bean实例化后的后置处理：BeanPostProcessor#postProcessAfterInitialization()
注意前后处理有可能直接返回bean，之后不再进行后续doCreateBean()流程
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = this.determineTargetType(beanName, mbd);
if (targetType != null) {
// 实例化前处理
bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 实例化后处理
==== 就是在这里激活的 bean实例化后的AOP处理器 ====
bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = bean != null;
}
return bean;
}
// 实例化前处理
@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
Iterator var3 = this.getBeanPostProcessors().iterator();
while(var3.hasNext()) {
BeanPostProcessor bp = (BeanPostProcessor)var3.next();
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
// 实例化后处理
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
Object result = existingBean;
Object current;
for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
BeanPostProcessor processor = (BeanPostProcessor)var4.next();
current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
}
return result;
}
// 调用doCreateBean()暴露ObjectFactory到三级缓存
调用createBeanInstance(beanName,mbd,args) 创建半实例
然后可以看到解决循环依赖的关键，就是在半实例化bean之后通过ObjectFactory暴露引用，其他bean可以从三级缓存拿到ObjectFactory
进而调用getObject()是getEarlyBeanReference()拿到此半实例化的bean
后面会分析怎么解决循环依赖...
// AbstractAutowireCapableBeanFactory#doCreateBean()
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
// 调用createBeanInstance(beanName,mbd,args)
if (instanceWrapper == null) {
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized(mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable var17) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
}
mbd.postProcessed = true;
}
}
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
========= 解决循环依赖的关键！！======
// 将ObjectFactory的单例工厂方法加入到三级缓存
this.addSingletonFactory(beanName, () -> {
// 接着调用
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
Object exposedObject = bean;
try {
this.populateBean(beanName, mbd, instanceWrapper);
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
} catch (Throwable var18) {
if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
throw (BeanCreationException)var18;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
}
if (earlySingletonExposure) {
Object earlySingletonReference = this.getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
String[] dependentBeans = this.getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dependentBean = var12[var14];
if (!this.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 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
try {
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
}
// 调用createBeanInstance(beanName,mbd,args)进行构造方法半实例化（仅实例化不填充属性）
先分析如何解决循环依赖的，后面再分析createBeanInstance()、populateBean()、initalizationBean()....
三、如何解决的循环依赖？
循环依赖就是循环引用，就是两个或多个bean相互之间持有对方。首先需要知道注入方式
- 构造器注入
- setter注入
- singleton
- prototype
1、构造器注入
在XML文件中配置<bean>标签下的<constructor-arg index="0" ref = "依赖bean">，此依赖无法解决，只能抛出BeanCurrentlyInCreationException异常表示循环依赖
- Sring容器将每一个正在创建的bean加入CurrentlyInCreation缓存中。当bean创建过程中发现自己已经在这个缓存中，就会抛出异常，当bean创建完成之后才会从该缓存中移除。如果创建A的时候，构造器需要B，那就去创建B，这时候又发现构造器参数有A，从而形成一个环，没办法创建。
2、setter注入
在XML文件中配置<bean>标签下的<property ref = "依赖bean">或者使用SpringBoot的@Autowired注解（本身也是setter注入），并且提供一个无参的构造器。只能解决Singleton单例的bean：Spring容器提前暴露出刚完成构造方法，但是未完成其他步骤如setter属性填充的bean，通过ObjectFactory暴露一个工厂方法，从而使其他bean能引用到bean。
注意：对于Singleton作用域的bean，可以使用setAllowCircularReferences(false)来禁用循环引用
- (1) 首次创建A的时候，在缓存中获取不到A，进而在
getBean()、doGetBean()、createBean()、doCreateBean()- 在doCreateBean()中首先无参构造创建半实例化的beanA，然后暴露ObjectFactory到三级缓存之后，B能拿到一个正在创建中的A。并将A放到SingletonCurrentlyInCreation缓存。然后才是后续的属性填充和初始化
- (2)A属性填充使用setter注入B，首次也在缓存中获取不到B，那就去创建B，也就是
getBean()、doGetBean()、createBean()、doCreateBean()- 在doCreateBean()中首先无参构造创建半实例化的beanB，然后暴露ObjectFactory到三级缓存，A能拿到用一个正在创建中的B。并将B放到SingletonCurrentlyInCreation缓存。然后才是后续的属性填充和初始化
- (4)B属性填充使用setter注入依赖A，可以通过A暴露的ObjectFactory使用工厂方法从缓存拿到半实例的A。并将半实例A放到二级缓存
- (5) B进行后续实例化。
- (5) A进行后续实例化。
//AbstractAutowireCapableBeanFactory#doCreateBean()
if (earlySingletonExposure) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
// 解决循环依赖的关键！！
// 将ObjectFactory的单例工厂方法加入到三级缓存，
// 其他beanB查询三级缓存存在beanA对应的ObjectFactory:
// 1、调用factory.getObject()可以拿到当前半实例化的beanA,
// 2、并将beanA放到二级缓存
this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
四、doCreateBean()创建bean详细分析
回到createBean()中，在验证完准备覆盖的方法之后，接着添加BeanPostProcessor实例化前置处理器，其实是实现类InstantiationAwareBeanPostProcessor的postProcessorBeforeInstantiation()方法，如果这里修改了bean，那么直接return了。
否则需要进行下面的doCreateBean()，主要就是下面这些
- 如果是单例则首先需要清除缓存factoryBeanInstanceCache
- 实例化bean调用createBeanInstance()，将BeanDefinition转为BeanWrapper
- 如果存在工厂方法则使用工厂方法初始化
- 如果有参构造函数初始化，需要根据参数锁定对应的构造函数
- 如果上述都不满足，使用默认空参构造
- 实例化后置处理器MergedBeanDefinitionPostProcessor应用，bean合并后的处理，Autowired注解正是通过此方法实现的预解析
- 依赖处理，是否单例，暴露ObjectFactory解决循环依赖，调用addSingletonFactory()加入三级缓存singletonFactories
- 属性填充populateBean()：其他beanB属性填充拿到半实例化beanA之后，将beanA从三级缓存移到二级缓存
- 初始化initializeBean()
- 循环依赖检查actualDependentBeans()
- 注册DisposableBean
- 完成创建并返回bean
// AbstractAutowireCapableBeanFactory#doCreateBean()
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 1、清除单例缓存
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 2、 根据bean指定的策略实例化，如工厂方法、构造函数、简单实例化
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized(mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// 3、实例化后置处理器
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable var17) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
}
mbd.postProcessed = true;
}
}
// 4、是否允许提前曝光ObjectFactory
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
// 允许
if (earlySingletonExposure) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
// 解决循环依赖的关键！！
// 将ObjectFactory的单例工厂方法加入到三级缓存
this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
Object exposedObject = bean;
try {
//5、对bean的各个属性填充，包括依赖，可能会递归创建其他bean
this.populateBean(beanName, mbd, instanceWrapper);
//6、调用初始化方法，开始从实例化---》初始化
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
} catch (Throwable var18) {
if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
throw (BeanCreationException)var18;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
}
// 7、只有检测到循环依赖下才不为空
if (earlySingletonExposure) {
Object earlySingletonReference = this.getSingleton(beanName, false);
if (earlySingletonReference != null) {
// 8、实例化过程中没有通过BeanPostProcessor增强
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
// 检测依赖
String[] dependentBeans = this.getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dependentBean = var12[var14];
if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
// 检测依赖
actualDependentBeans.add(dependentBean);
}
}
// 解决循环依赖之后，bean初始化之后依赖的bean一定也是初始化过的
// 只有actualDependentBeans不为空表示当前bean初始化之后依赖的bean没有初始化，证明还存在循环依赖
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 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
try {
//8、根据scope注册bean
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
}
// 2、 根据bean指定的策略实例化，如工厂方法、构造函数、简单实例化
以无参构造为例， 实例化策略委托给SimpleInstantiationStrategy#instantiate()
实例化策略
- 如果没有需要动态增强的方法，直接反射获得实例即可
- 如果有需要覆盖或者动态替换的方法，需要使用Cglib进行动态代理，因为可以在创建代理的同时增强
// AbstractAutowireCapableBeanFactory#createBeanInstance()
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
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());
} else {
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return this.obtainFromSupplier(instanceSupplier, beanName);
} else if (mbd.getFactoryMethodName() != null) {
// 工厂方法获得bean
return this.instantiateUsingFactoryMethod(beanName, mbd, args);
} else {
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized(mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
// 无参实例化和有参实例化
return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd);
} else {
Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
// 无参实例化
if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
ctors = mbd.getPreferredConstructors();
// 无参实例化，调用instantiateBean()
return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
} else {
// 有参实例化
return this.autowireConstructor(beanName, mbd, ctors, args);
}
}
}
}
}
// 带参数的构造方法实例化比较复杂，不带参数的简单instantiateBean()
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
try {
Object beanInstance;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(() -> {
return this.getInstantiationStrategy().instantiate(mbd, beanName, this);
}, this.getAccessControlContext());
} else {
beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
this.initBeanWrapper(bw);
return bw;
} catch (Throwable var5) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", var5);
}
// 实例化策略委托给SimpleInstantiationStrategy#instantiate()
/**
实例化策略
1. 如果没有需要动态增强的方法，直接反射获得实例即可
2. 如果有需要覆盖或者动态替换的方法，需要使用Cglib进行动态代理，因为可以在创建代理的同时增强
*/
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
if (!bd.hasMethodOverrides()) {
Constructor constructorToUse;
synchronized(bd.constructorArgumentLock) {
// 反射，获取无参构造方法
constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
clazz.getClass();
constructorToUse = (Constructor)AccessController.doPrivileged(() -> {
return clazz.getDeclaredConstructor();
});
} else {
constructorToUse = clazz.getDeclaredConstructor();
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
} catch (Throwable var9) {
throw new BeanInstantiationException(clazz, "No default constructor found", var9);
}
}
}
// 有无参构造直接开始反射，或者 Cglib动态代理
return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
} else {
return this.instantiateWithMethodInjection(bd, beanName, owner);
}
}
// public class CglibSubclassingInstantiationStrategy extends SimpleInstantiationStrategy
public Object instantiate(@Nullable Constructor<?> ctor, Object... args) {
Class<?> subclass = this.createEnhancedSubclass(this.beanDefinition);
Object instance;
if (ctor == null) {
instance = BeanUtils.instantiateClass(subclass);
} else {
try {
Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
instance = enhancedSubclassConstructor.newInstance(args);
} catch (Exception var6) {
throw new BeanInstantiationException(this.beanDefinition.getBeanClass(), "Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", var6);
}
}
Factory factory = (Factory)instance;
factory.setCallbacks(new Callback[]{NoOp.INSTANCE, new CglibSubclassingInstantiationStrategy.LookupOverrideMethodInterceptor(this.beanDefinition, this.owner), new CglibSubclassingInstantiationStrategy.ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
return instance;
}
private Class<?> createEnhancedSubclass(RootBeanDefinition beanDefinition) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(beanDefinition.getBeanClass());
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
if (this.owner instanceof ConfigurableBeanFactory) {
ClassLoader cl = ((ConfigurableBeanFactory)this.owner).getBeanClassLoader();
enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(cl));
}
enhancer.setCallbackFilter(new CglibSubclassingInstantiationStrategy.MethodOverrideCallbackFilter(beanDefinition));
enhancer.setCallbackTypes(CALLBACK_TYPES);
return enhancer.createClass();
}
// 4、是否允许提前曝光ObjectFactory到三级缓存
// 4、是否允许提前曝光ObjectFactory
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
// 允许
if (earlySingletonExposure) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
// 解决循环依赖的关键！！
// 将ObjectFactory的单例工厂方法getEarlyBeanReference加入到三级缓存
this.addSingletonFactory(beanName, () -> {
// 接着调用getEarlyBeanReference
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
// 其他beanB从三级缓存中调用beanA的ObjectFactory的getObject()就是调用getEarlyBeanReference()
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
Iterator var5 = this.getBeanPostProcessors().iterator();
while(var5.hasNext()) {
BeanPostProcessor bp = (BeanPostProcessor)var5.next();
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor)bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
//5、populateBean需要获取注入的对象，三级缓存移动到二级缓存
// AbstractAutowireCapableBeanFactory#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 {
if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
Iterator var4 = this.getBeanPostProcessors().iterator();
while(var4.hasNext()) {
BeanPostProcessor bp = (BeanPostProcessor)var4.next();
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
PropertyValues pvs = mbd.hasPropertyValues() ? mbd.getPropertyValues() : null;
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == 1 || resolvedAutowireMode == 2) {
MutablePropertyValues newPvs = new MutablePropertyValues((PropertyValues)pvs);
if (resolvedAutowireMode == 1) {
this.autowireByName(beanName, mbd, bw, newPvs);
}
if (resolvedAutowireMode == 2) {
this.autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = mbd.getDependencyCheck() != 0;
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
Iterator var9 = this.getBeanPostProcessors().iterator();
while(var9.hasNext()) {
BeanPostProcessor bp = (BeanPostProcessor)var9.next();
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
PropertyValues pvsToUse = ibp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
this.checkDependencies(beanName, mbd, filteredPds, (PropertyValues)pvs);
}
if (pvs != null) {
this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
}
}
}
需要获取注入的对象实例，因此从缓存中获取， 注意这里beanB从三级缓存中获得ObjectFactory的工厂方法，其实就是调用getEarlyBeanReference获取半实例的的beanA，然后放到二级缓存
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
synchronized(this.singletonObjects) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 注意这里beanB从三级缓存中获得ObjectFactory的工厂方法，其实就是调用getEarlyBeanReference
//获取半实例的的beanA
singletonObject = singletonFactory.getObject();
// 其他beanB从三级缓存通过工厂方法拿到半实例化的beanA,然后放到二级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
//6、initializeBean初始化
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(() -> {
this.invokeAwareMethods(beanName, bean);
return null;
}, this.getAccessControlContext());
} else {
this.invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
}
try {
this.invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable var6) {
throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
}
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
