spring的循环依赖和三级缓存

1. 什么是循环依赖

   1. A引用了B，而这个时候B也引用了A，那么这种情况实际上就是出现了循环依赖的问题了，实际上也可以把循环依赖称之为循环引用，两个或者两个以上的bean互相持有对方，最终形成闭环
   2. 这里不是函数的循环调用，是对象的相互依赖关系，循环调用其实就是一个死循环，除非有终结条件，否则的话，他就是一个死循环

2. spring的循环依赖

   1. spring的循环依赖有：
      1. 构造器的循环依赖
      2. field属性的循环依赖
   2. 构造器的循环依赖实际上是个无解的操作，只能抛出BeanCurrentlyInCreationException异常，也就是说，这个构造器导致的循环依赖，spring是没有办法来处理的，也只是给抛出了异常

3. spring解决循环依赖

   1. spring的单例对象的初始化主要分为三个步骤
      1. createBeanInstance 实例化
      2. populateBean 填充属性
      3. initializeBean 初始化
   2. createBeanInstance实例化实际上就是调用对象的构造方法实例化对象
   3. populateBean实际上就是对bean的依赖属性进行一个赋值填充
   4. initializeBean则是调用spring xml中的int方法
   5. 但从bean的初始化的过程来看，循环依赖发生的位置就是在createBeanInstance实例化，以及populateBean填充属性中
   6. 发生的循环依赖是：构造器的循环依赖和field属性的循环依赖

4. 三级缓存

   1. singletonObjects：单例对象工厂的cache，用于存放完全初始化好的bean，从该缓存中取出的bean可以直接使用

   2. earlySingletonObjects：提前曝光的单例对象的cache，存放原始的bean对象(尚未填充属性)，用于解决循环依赖

   3. singletonFactories：单例对象的cache，存放bean工厂对象，用于解决循环依赖

      1. private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); //一级缓存
         private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); // 二级缓存
         private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); // 三级缓存
         

5. 对象创建过程

   1. AbstractBeanFactory 中的 doGetBean()方法

      1. protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly)
         

   2. DefaultSingletonBeanRegistry 中的 getSingleton()方法

      1. protected Object getSingleton(String beanName, boolean allowEarlyReference)
         

      2. 在这个方法中，先从一级缓存singletonObjects中去获取，如果获取到就直接return

      3. 如果获取不到，并且对象正在创建中，就再从二级缓存earlySingletonObjects中获取

      4. 如果还是获取不到且允许singletonFactories通过getObject()获取，就从三级缓存singletonFactory.getObject()获取

      5. 如果获取到了，则从singletonFactories中移除，并放入earlySingletonObjects中

      6. 这相当于把三级缓存中的数据剪贴到了二级缓存中

      7. protected Object getSingleton(String beanName, boolean allowEarlyReference) {
           Object singletonObject = this.singletonObjects.get(beanName);
           if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
             singletonObject = this.earlySingletonObjects.get(beanName);
             if (singletonObject == null && allowEarlyReference) {
              ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
              if (singletonFactory != null) {
               singletonObject = singletonFactory.getObject();
               this.earlySingletonObjects.put(beanName, singletonObject);
               this.singletonFactories.remove(beanName);
              }
             }
            }
           }
           return singletonObject;
          }
         

   3. AbstractAutowireCapableBeanFactory 中的 doCreateBean() 方法

      1. protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
         
          //添加到三级缓存
           if (earlySingletonExposure) {
            if (logger.isTraceEnabled()) {
             logger.trace("Eagerly caching bean '" + beanName +
               "' to allow for resolving potential circular references");
            }
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
           }
         

   4. AbstractAutowireCapableBeanFactory 中的 populateBean() 方法进行属性赋值

      1. protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw)
         

   5. AbstractAutowireCapableBeanFactory 中的 initializeBean() 初始化对象

      1. protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
         

6. 解决

   1. spring解决循环依赖的诀窍就在于singletonFactories这个三级cache
   2. 这个cache的类型是ObjectFactory，这里就是解决循环依赖的关键，发生在createBeanInstance之后，也就是说单例对象此时已经被创建出来(调用了构造器)
   3. 这哦对象已经被生产出来了，虽然还不完美(还没有进行初始化的第二步和第三步)，但是已经能被人认出来了(根据对象引用能定位到堆中的对象)，所以spring此时将这个对象提前曝光出来让大家认识，让大家使用

7. 二级缓存到底能不能解决

   1. 二级缓存也是能够实现的，如果自己想要实现，那么就得重写AbstractAutowireCapableBeanFactory的doCreateBean的方法

   2.      //添加到三级缓存
        if (earlySingletonExposure) {
         if (logger.isTraceEnabled()) {
          logger.trace("Eagerly caching bean '" + beanName +
            "' to allow for resolving potential circular references");
         }
         addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
         //从三级缓存中取出立刻放入二级缓存
         getSingleton(beanName, true);
        }
      

   3. 如果要使用二级缓存解决循环依赖，意味着Bean在构造完后就创建代理对象，这样违背了spring的设计原则

   4. spring结合AOP跟Bean的生命周期，是在Bean创建完全之后通过AnnotationAwareAspectAutoProxyCreator这个后置处理器来完成的，在这个后置处理的postPocessAfterInitialization方法中对初始化后的Bean完成AOP代理

   5. 如果出现了循环依赖，那没有办法，只能给Bean先创建代理，但是没有出现循环依赖的情况下，设计之初就是让Bean在生命周期的最后一步完成代理而不是在实例化后就立马完成代理