Spring——循环依赖&示例解析（图文并茂）

觉得可以的话点个关注，加个收藏呗，陆续奉上干货~~~~

先上个整体流程图，有个初始印象，后面比较详细的解析~~

从BeanFactory中获取单例对象最终调用的方法是doGetBean方法，内部首先调用getSingleton方法来判断当前要获取的bean是否已经被创建或者是正在创建。

BeanFactory中有三个map类型的属性：

• singletonObjects：存放实例化并初始化完成的单例对象引用
• earlySingletonObjects：存放单例对象提前曝光的对象引用
• singletonFactories：存放提供创建早期单例引用的对象工厂，该工厂实例创建的对象会存放到earlySingletonObjects中

三者关系：

• singletonObjects中存在beanName=A时，其他两个不存在
• singletonObjects中不存在beanName=A时，其他两个要么也不存在，要么只有一个存在

getSingleton方法获取对象时访问这三个map对象的顺序【此时allowEarlyReference=true】：

• 访问singletonObjects，如果返回空，下一步
• 访问earlySingletonObjects，如果返回空，下一步
• 访问singletonFactories，如果返回空，则开始创建单例对象；如果返回不为空，返回的就是ObjectFactory，然后调用ObjectFactory的getObject方法，然后从singletonFactories中移除该ObjectFactory然后将getObject调用结果存入earlySingletonObject

示例解析：

如下有两个服务实现类A和B

@Service("A")
public class AServiceImpl implements IAService {
    @Autowired
    private IBService bService;
}
@Service("B")
public class BServiceImpl implements IBService {
    @Autowired
    private IAService aService;
}

再加深点印象：

步骤解析【假设在bean的实例化中先实例化A】：

• 从singletonObjects这个map对象中获取beanName为A的对象，为空，继续
• 从earlySingletonObjects这个map对象中获取beanName为A的早期对象，为空，继续
• 从singletonFactories这个map对象中获取beanName为A的ObjectFactory对象，为空，则进行A的单例对象的实例化，步骤如下：
• 通过doCreateBean方法创建A的实例，记为实例A@aaa，简单理解就是通过构造方法反射创建了A的实例，此时实例A@aaa的成员变量bService为null
• 往singletonFactories中put一个对应beanName为A的ObjectFactory的对象，代码如下：

if (earlySingletonExposure) { // 默认是为true的,允许及早曝光
   addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

• 填充实例A@aaa中的成员变量bService，但此时B类型的实例并未创建，因此开始创建B的实例，步骤如下：

1、从singletonObjects、earlySingletonObjects、singletonFactories这个map对象中获取beanName为B的相关对象，都为空，继续

2、通过doCreateBean方法创建B的实例,记为实例B@bbb，简单理解就是通过构造方法反射创建了B的实例，此时实例B@bbb的成员变量aService为null

3、往singletonFactories中put一个对应beanName为B的ObjectFactory的对象

4、填充实例B@bbb的成员变量aService，此时会从BeanFactory中获取A类型的实例对象：从singletonObjects中获取A的单例对象-->为空继续，从earlySingletonObjects中获取A的早期对象-->为空继续，从singletonFactories获取A的ObjectFactory-->不为空，因为创建A的实例A@aaa的之后，往这个map中放入了A对应的ObjectFactory，（没印象的话往前面翻几行），此时通过获取到的ObjectFactory.getObject方法进一步调用getEarlyBeanReference这个方法，代码如下：

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
   Object exposedObject = bean;
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
        // 调用SmartInstantiationAwareBeanPostProcessor类型的后置处理器
        // 的getEarlyBeanReference方法来创建早期可以暴露的实例对象
        exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
      }
   }
   return exposedObject;
}

5、这段代码的作用是：如果A类中的方法如果需要被系统定义的一些增强器（如使用AspectJ定义的一些通知）增强的话，则需要为A的实例创建一个代理对象（使用CGLIB的话则是创建一个A的子类A'$'$SPRINGCGLIB'$'$A.class，然后实例化这个子类的对象，记为实例A'$'$SPRINGCGLIB'$'$A@aaa，而实例A'$'$SPRINGCGLIB'$'$A@aaa的属性中将会持有当前创建的A的实例A@aaa的一个引用，然后返回实例A'$'$SPRINGCGLIB'$'$A@aaa，也就是代理对象），如果不需要代理的话，则直接返回实例A@aaa。

6、获取到A的实例对象后（此时获取的是A实例A@aaa的代理对象A'$'$SPRINGCGLIB'$'$A@aaa或就是本身A@aaa），将A的实例对象填充到B实例B@bbb的成员属性aService中，后面再对实例B@bbb进行初始化等其他操作.....略过，最后将B实例B@bbb放入到BeanFactory的singletonObjects中，代码见下下下方。

7、此时B实例B@bbb创建完毕并返回，然后返回到对实例A@aaa的填充成员属性bService的步骤：

继续A实例的处理：

• 获取到新创建的B实例B@bbb之后，将B@bbb填充到A实例A@aaa的bService成员属性中
• 执行A实例A@aaa的初始化方法：

// 执行afterPropertiesSet方法（如果有的话），initMethod(如果有的话)
initializeBean(beanName, exposedObject, mbd); 

• 省略一些判断细节，后面还会调用一次getSingleton方法，如果A实例A@aaa被代理了，放入BeanFactory的singletonObjects这个map对象中的实例就是$$springcglib$$A@aaa，没有被代理放入的就是A@aaa

protected void addSingleton(String beanName, Object singletonObject) {
   synchronized (this.singletonObjects) {
      // 放入singletonObjects
      this.singletonObjects.put(beanName, singletonObject);
      // 从singletonFactories中移除A
      this.singletonFactories.remove(beanName);
      // 从earlySingletonObjects中移除A
      this.earlySingletonObjects.remove(beanName);
      this.registeredSingletons.add(beanName);
   }
}

再次回顾下整体流程：

现在看下来是不是感觉很好理解了，不过还是建议跟着源码走一下，加深印象！~~~