笔记整理自《Spring源码深度解析》（第2版），同时也参考了一些网上资源，具体参考链接在文末
文章目录
整体分析
从以下代码入手分析bean的加载过程
MyTestBean bean=(MyTestBean) bf.getBean("myTestBean");
doGetBan分析
源码解析
| ClassPathResource.java |
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
进入到doGetBean
@SuppressWarnings("unchecked")
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 转换beanName
final String beanName = transformedBeanName(name);
Object bean;
/**
*检查缓存中或者实例工厂中是否有对应的实例
*因为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖
*Spring创建bean的原则是不等bean创建完成就会将创建bean的OjectFactory提早曝光
*也就是将ObjectFactory加入到缓中，一旦下个bean创建时候需要依赖上个bean则直 *接使用ObjectFactory
*/
//尝试从缓存中获取或者 singletonFactories中的ObjectFactory中获取
Object sharedInstance = getSingleton(beanName);
// 单例对象是否存在参数是否为空
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//从FactoryBean实例中获取对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
//如果缓存中没有的话，则需要从头开始bean的创建过程
else {
//只有在单例情况才会尝试解决循环依赖，原型模式情况下，如果存在
//A中有B的属性，B中有A的属性，那么当依赖注入的时候，就会产生A还未创建完的时候
//因为对于B的创建再次返回创建A，造成循环依赖，也就是下面的情况
// 循环依赖的问题
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
BeanFactory parentBeanFactory = getParentBeanFactory();
//如果beanDefinitionMap中也就是在所有已经加载的类中不包括beanName则尝试从
//parentBeanFactory中检测
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
String nameToLookup = originalBeanName(name);
//递归到BeanFactory中寻找
// 父bean工厂 类型判断
if (parentBeanFactory instanceof AbstractBeanFactory) {
// 再次获取
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
//如果不是仅仅做类型检查则是创建bean，这里要进行记录
if (!typeCheckOnly) {
// 将bean 标记为已创建
markBeanAsCreated(beanName);
}
try {
//将存储XML配置文件的GErnericBeanDefinition转换为RootBeanDefinition
//如果指定BeanName是子Bean的话同时会合并父类的相关属性
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 需要依赖的bean
String[] dependsOn = mbd.getDependsOn();
//若存在依赖则需要递归实例化依赖的bean
if (dependsOn != null) {
for (String dep : dependsOn) {
// 是否依赖
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 缓存依赖调用
registerDependentBean(dep, beanName);
try {
// 获取bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
//实例化依赖的bean后便可以实例化mbd本身了
//singleton模式的创建
if (mbd.isSingleton()) {
// 获取bean单例bean
sharedInstance = getSingleton(beanName, () -> {
try {
// 创建bean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
// 摧毁单例的bean
destroySingleton(beanName);
throw ex;
}
});
// 获取 bean 实例
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 原型模式创建
// 是否是原型模式
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
// 创建之前的行为
beforePrototypeCreation(beanName);
// 创建
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
// 创建后的行为
afterPrototypeCreation(beanName);
}
// 创建
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
// 获取作用域名称
String scopeName = mbd.getScope();
// 从作用域容器中获取当前作用域名称对应的作用域接口 scope
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
// 从 scope 接口卓获取
Object scopedInstance = scope.get(beanName, () -> {
// 创建之前做的行为
beforePrototypeCreation(beanName);
try {
// 创建 bean
return createBean(beanName, mbd, args);
}
finally {
// 创建之后做的行为
afterPrototypeCreation(beanName);
}
});
// 获取 bean 实例
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
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",
ex);
}
}
}
catch (BeansException ex) {
// bean 创建失败后的处理
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 类型和需要的类型是否匹配
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
// 获取类型转换器 , 通过类型转换器进行能转换
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
时序图解析
步骤流程
第一步：转换对应beanName
传入的参数可能为别名、FactoryBean，所以要进行一系列解析
- 去除FactoryBean的修饰符，也就是如果name="&aa"，那么会首先去除&而使name=“a”.
- 取指定alias所表示的最终beanName，例如别名A指向名称为B的bean则返回B；若别名A指向别名B，别名B又指向名称为C的bean则返回C
第二步：尝试从缓存中加载单例
单例只会被创建一次，后续再获取bean，就直接从单例缓存中获取了。
-
如果存在
从FactoryBean实例中获取对象( 缓存中有 )
如果从缓存中得到了bean的原始状态，则需要从FactoryBean实例中获取对象
缓存中记录的只是最原始的bean状态，并不一定是最终想要的bean。
-
不存在，从头开始创建
-
原型模式的依赖检查（缓存中没有，从头开始创建）
只有在单例情况下才会尝试解决循环依赖。
-
检测parentBeantFactory
如果检测到当前加载的XML配置文件中不包含beanName所对应的配置，且存在父类工厂的话，就只能到parentBeanFactory去尝试加载
-
将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition
因为从XML配置文件中读取到的bean信息是存储在GernericBeanDefinition中的，但是所有的bean后续处理都是针对于RooiBeanDefinition的，所以这里需要进行一个转换，转换的同时如果父类bean不为空的话，则会一并合并父类的属性。
-
寻找依赖
初始化过程中很有可能某些属性依赖于其他的bean，需要先加载依赖的bean
-
针对不同的scope进行bean的创建
默认的是singleton，还有prototype、request等
-
第三步：类型转换
返回的类型可能跟需要的类型不一致，需要进行转换
源码分析
getSingleton
缓存中获取单例bean
| DefaultSingletonBeanRegistry.java |
public Object getSingleton(String beanName) {
//参数设置标识允许早期依赖
return getSingleton(beanName, true);
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//检查缓存中是否存在实例
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
//如果缓存中没有，且当前bean正在创建的话，则可以从earlySingletonObjects中获取
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
//如果则可以从earlySingletonObjects中没有，且允许早期依赖；这锁定全局并进行处理
synchronized (this.singletonObjects) {
//再次检查缓存是否存在实例
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
//再次检查earlySingletonObjects是否存在bean
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
//当某些方法需要提前初始化的时候则会调用addSingletonFactory方法将对应的ObjectFactory初始话策略存储在singletonFactories中
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//调用预先设定的getObject方法
singletonObject = singletonFactory.getObject();
//记录在缓存中，earlySingletonObjects跟singletonFactories互斥
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
总结：
-
首先尝试从singletonObjects里面获取实例
-
如果获取不到再从earlySingletonObjectFactory里面获取
-
如果获取不到，再尝试从singletonFactories里面获取beanName对应的ObjectFactory
-
然后再调用这个ObjectFactory的getObject来创建bean，并放到earlySingletonObjects里面去，
-
从singletonFactories里面remove掉这个ObjectFactory
使用到的各个map
- singletonObjects：用于保存BeanName和创建bean实例之间的关系，bean name—> bean instance.
- singletonFactories：用于保存BeanName和创建bean的工厂之间的关系，bean name->ObjectFactory
- earlySingletonObjects：也是保存BeanName和创建bean实例之间的关系，与singletonObjects的不同之处在于，当一个单例bean被放到这里面后，那么当bean还在创建过程中，就可以通过getBean方法获取到了，其目的是用来检测循环引用。
- registeredSingletons：用来保存当前所有已注册的bean.
getObjectForBeanInstance
从bean实例中获取对象
当我们得到bean的实例后要做的第一步就是调用这个方法检测当前bean是否是FactoryBean的Bean，如果是，那么需要调用该bean对应的FactoryBean实例中的getObject()作为返回值。这里的返回值是处理过的对象。
| AbstractBeanFactory.java |
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
//如果是工厂相关（以&为前缀）
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
//工厂相关且不是FactoryBean类型，验证不通过
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
//是FactoryBean类型
if (mbd != null) {
mbd.isFactoryBean = true;
}
return beanInstance;
}
//如果不是工厂实现类，不处理
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
//加载FactoryBean
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
}
else {
//尝试从缓存中加载bean
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
//到这里明确知道beanInstance一定是FactoryBean类型
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
//containsBeanDefinition检测beanDEfinitionMap中也就是在所有已经加载的类中检测是否定义beanName
if (mbd == null && containsBeanDefinition(beanName)) {
//将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefiniton，如果指定BeanName是子Bean的话会同时合并父类的相关属性
mbd = getMergedLocalBeanDefinition(beanName);
}
//是否是用户定义的而不是应用程序本身定义的
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
流程如下：
- 对Factory正确性的验证
- 对非FactoryBean不做任何处理
- 对bean进行转换
- 将从Factory中解析bean的工作委托给getObjectFromFactoryBean
核心代码在getObjectFromFactoryBean，但进入方法后发现该方法只是保证返回的单例的bean是全局唯一。真正工作移交到了doGetObjectFromFactoryBean方法中。
| FactoryBeanRegistrySupport.java |
private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
Object object;
try {
//需要权限验证
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
//直接调用getObject方法
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
// Do not accept a null value for a FactoryBean that's not fully
// initialized yet: Many FactoryBeans just return null then.
if (object == null) {
if (isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
object = new NullBean();
}
return object;
}
可以看到在这里调用了factory.getObject()，返回处理过的对象。
getSingleton（重载方法）
如果缓存中没有已经加载的单例bean，则需要从头开始bean的加载过程。使用getSingleton的重载方法实现bean的加载过程
| DefaultSingletonBeanRegistry.java |
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
//全局变量需要同步
synchronized (this.singletonObjects) {
//首先检查对应的bean是否已经加载过，因为singleton模式其实就是复用以创建的bean
Object singletonObject = this.singletonObjects.get(beanName);
//如果为空才可以进行singleton的bean初始化
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 (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
//加载单例前记录加载状态，这样可以对循环依赖进行检测
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//初始化bean
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
//加载单例后的处理方法调用
afterSingletonCreation(beanName);
}
if (newSingleton) {
//加入缓存
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
流程分析：
-
检查缓存是否已经加载过，已经加载过直接返回
-
若没有加载，则记录beanName的正在加载状态。
-
通过调用 参数传入的ObjectFactory的 个体Object方法实例化bean
-
加载单例后的处理方法调用
当bean加载结束后需要移除缓存中对该bean的正在加载状态的记录
-
将结果记录至缓存并删除加载bean过程中所记录的各种辅助状态
-
返回处理结果
-
createBean
准备创建Bean
| AbstractAutowireCapableBeanFactory.java |
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
...
RootBeanDefinition mbdToUse = mbd;
//锁定class，根据设置的class属性或者根据className来解析Class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
//验证及准备覆盖的方法
//对override属性进行标记及验证
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
...
}
try {
//应用初始化的前的后处理器
//给BeanPostProcessors一个机会来返回代理来替代真正的实例
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
//短路判断，如果经过前置处理后的结果不为空，就直接返回
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
...
}
try {
//核心代码，常规bean的创建
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
...
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
...
}
}
流程分析：
- 根据设置的class属性或者根据className来解析Class
- 对override属性进行标记及验证。
- 应用初始化前的后处理器，如果经过前置处理后的结果不为空，就直接返回
- 创建常规bean
对override属性进行标记及验证的作用：
-
在Spring配置中存在lookup-method和replace-method两个配置功能，而这两个配置的加载其实就是将配置统一存放在BeanDefinition的methodOverrrides属性里。这里就是对这个歌属性进行配置
-
如果当前类没有被重载时，这里会做标记，后续调用的时候就不用太通过参数类型进行匹配了，因为方法只有一个。
-
可以提前对方法存在性进行验证
resolveBeforeInstantiation
| AbstractAutowireCapableBeanFactory.java |
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
重点关注两个地方
1.applyBeanPostProcessorsBeforeInstantiation
这个是bean实例化前的后处理器，实例化前调用，也就是将AbstractBeanDefinition转换为BeanWrapper处理。给子类一个修改BeanDefinition的机会。
经过这个方法后，bean可能成为一个经过处理的代理bean，可能是通过cglib生成的，也可能是通过其他技术。
2.applyBeanPostProcessorsAfterInitialization
实例化后的后处理器应用
循环依赖问题
定义
循环依赖就 循环引用，就是两个或多个 bean 相互之间的持有对方，比如 CircleA 引用 CircleB , CircleB 引用 CircleC, CircleC 引用 CircleA ，则它们最终反映为 个环。此处不是循环调用，循环调用是方法之间的环调用。
循环调用是无法解决的，除非有终结条件，否则就是死循环，最终导致内存溢出错误
如何解决
Spring容器将每一个正在创建的bean标识符放在一个“当前创建bean池”中，bean标识符在创建过程中将一直保持在这个池中，因此如果在创建bean过程中发现自己已经在“当前创建bean池”里时，将抛出BeanCurrentlylnCreationException异常表示循环依赖；而对于创建完毕的bean将从“当前创建bean池"中清除掉。
-
构造器循环依赖
表示通过构造器注入构成的循环依赖，此依赖是无法解决的，只能抛出异常
-
settler循环依赖
表示通过setter注入方式构成的循环依赖。对于setter注入造成的依赖是通过Spring容器提前暴露刚完成构造器注入但未完成其他步骤（如setter注人）的bean来完成的，而且只能解决单例作用域的bean循环依赖。通过提前暴露一个单例工厂方法，从而使其他bean能引用到该bean。
-
prototype范围的依赖处理
对于"prototype"作用域bean，Spring容器无法完成依赖注人，因为Spring容器不进行缓存"prototype"作用域的bean，因此无法提前暴露一个创建中的bean。
doCreateBean
| AbstractAutowireCapableBeanFactory.java |
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// 第一部分
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
//如果是单例则需要清除缓存
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
//instanceWrapper不存在的话
if (instanceWrapper == null) {
//根据指定bean使用对应的策略创建新的实例，如：工厂方法、构造函数自动注入、简单初始化
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 第二部分
// 获取 实例
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//应用MergedBeanDefinitionPostProcessor
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
...
}
mbd.postProcessed = true;
}
}
// 第三部分
/**
* 是否需要提早曝光：单例 & 允许循环依赖 & 当前bean正在创建中，检查循环依赖
*/
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
...
//为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 第四部分
// 实例化bean
// Initialize the bean instance.
Object exposedObject = bean;
try {
//对bean进行填充，将各个属性值自动注入，其中，可能存在依赖于其他bean的属性，则会递归初始化依赖bean
populateBean(beanName, mbd, instanceWrapper);
//调用初始化方法，比如init-method
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
...
}
// 第五部分
// 依赖相关处理
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
//只有在检测到有循环依赖的情况下才会不为空
if (earlySingletonReference != null) {
//如果exposedObject没有在初始化方法中被改变，也就是没有被增强
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
// 当前bean的依赖列表
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
//检测依赖，将没有创建好的依赖bean添加进actualDependentBeans
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
/**
* 因为bean创建后其所依赖的bean一定是已经创建的，actualDependentBeans不为空则表示当前bean创建后其依赖的bean却没有没全部创建完
* 也就是说存在循环依赖
*/
if (!actualDependentBeans.isEmpty()) {
...
}
}
}
}
// 第六部分
// Register bean as disposable.
try {
//根据scopse注册bean
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
...
}
return exposedObject;
}
流程分析：
第一部分
-
如果是单例则需要首先清除缓存
-
实例化bean，将BeanDefinition转换为BeanWrapper
- 如果存在工厂方法则使用工厂方法进行初始化。
- 一个类有多个构造函数，每个构造函数都有不同的参数，所以需要根据参数锁定构造函数并进行初始化。
- 如果既不存在工厂方法也不存在带有参数的构造函数，则使用默认的构造函数进行bean的实例化。
-
MergedBeanDefinitionPostProcessor的应用
bean合并后的处理，Autowired注解正是通过此方法实现诸如类型的预解析
-
依赖处理
-
属性填充。将所有的属性填充至bean的实例中
-
调用用户设定的初始方法，即init-method属性配置的方法，来初始化bean
同时还做了一些其他工作
-
激活Aware方法
-
应用处理器
在调用客户自定义初始化方法前以及调用自定义初始化方法后分别会调用
BeanPostProcessor的postProcess BeforeInitialization和postProcessAfterInitialization方法，使用户可以根据自己的业务需求进行响应的处理。 -
激活自定义的init方法
这个跟init-method配置不同，这个是自定义的bean实现InitializingBean接口，并在afterPropertiesSet中实现自己的初始化业务逻辑。
执行顺序是afterPropertiesSet先执行，init-method后执行
-
-
循环依赖检查
检测已经加载的bean是否已经出现了依赖循环，并判断是否需要抛出异常
-
注册DisposableBean
- 如果配置destroy-method，这里需要注册以便于在销毁的时候调用
- 注册后处理器DestructionAwareBeanPostProcessor来统一处理bean的销毁方法
-
完成创建并返回
从代码中深入分析如何解决循环依赖
重点关注这个地方的代码
//为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
在B中创建依赖A时通过Objetfactory提供的实例化方法来中断A中的属性填充，使B中持有的A仅仅是刚刚初始化并没有填充任何属性的A
而这正初始化A的步骤还是在最开始创建A的时候进行的，但是因为A与B中的A所表示的属性地址是一样的，所以在A中创建好的属性填充自然可以通过B中的A获取，这样就解决了循环依赖的问题。
参考链接：