Spring源码（4）：三级缓存

循环依靠

两个或两个以上目标互相依靠对方，构成一个依靠环，例如A目标依靠B目标，B目标依靠A目标。

当创立相互依靠的目标时，会构成死循环，例如下图无缓存中的情况。而Spring经过增加缓存，将未完全创立好的A提早暴露在缓存中，当相互依靠的目标B对特点A赋值时，能够直接从缓存中获取A，而不需求再创立A，例如下图有缓存中的情况。

Spring的三级缓存

Spring的三级缓存分别为：

singletonObject：一级缓存，缓存中的bean是现已创立完结的，该bean经历过实例化->特点填充->初始化以及各种的后置处理。因而，一旦需求获取bean时，会优先寻觅一级缓存

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
   Assert.notNull(beanName, "Bean name must not be null");
   synchronized (this.singletonObjects) {
      // ...
      Object singletonObject = this.singletonObjects.get(beanName);
      if (singletonObject == null) {
         // bean创立前操作，符号当时bean正在创立
         beforeSingletonCreation(beanName);
         boolean newSingleton = false;
         try {
            // 创立bean
            singletonObject = singletonFactory.getObject();
            newSingleton = true;
         }
         catch (Exception ex) {
             // ...
         }
         finally {
            if (recordSuppressedExceptions) {
               this.suppressedExceptions = null;
            }
            // bean创立后操作，删去当时bean正在创立
            afterSingletonCreation(beanName);
         }
         if (newSingleton) {
            // 存入一级缓存
            addSingleton(beanName, singletonObject);
         }
      }
      return singletonObject;
   }
}
// 在bean创立完结之后，将bean加入到一级缓存中
protected void addSingleton(String beanName, Object singletonObject) {
   synchronized (this.singletonObjects) {
      // 添加一级缓存
      this.singletonObjects.put(beanName, singletonObject);
      this.singletonFactories.remove(beanName);
      this.earlySingletonObjects.remove(beanName);
      this.registeredSingletons.add(beanName);
   }
}

earlySingletonObjects：二级缓存，该缓存跟一级缓存的区别在于，该缓存所获取到的bean是提早曝光出来的，是还没创立完结的。也便是说获取到的bean只能保证现已进行了实例化，可是特点填充跟初始化还没有做完，因而该bean还没创立完结，时半成品，仅仅能作为指针提早曝光，被其他bean所引证

// 二级缓存是从三级缓存中经过getObject()办法获取的
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   Object singletonObject = this.singletonObjects.get(beanName);
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      singletonObject = this.earlySingletonObjects.get(beanName);
      if (singletonObject == null && allowEarlyReference) {
         synchronized (this.singletonObjects) {
            // Consistent creation of early reference within full singleton lock
            singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
               singletonObject = this.earlySingletonObjects.get(beanName);
               if (singletonObject == null) {
                  ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                  if (singletonFactory != null) {
                     // 三级缓存经过getObject()办法获取半成品bean
                     singletonObject = singletonFactory.getObject();
                     // 寄存二级缓存
                     this.earlySingletonObjects.put(beanName, singletonObject);
                     this.singletonFactories.remove(beanName);
                  }
               }
            }
         }
      }
   }
   return singletonObject;
}

singletonFactories：三级缓存，在bean实例化完之后，特点填充以及初始化之前，假如答应提早曝光，spring会将实例化后的bean提早曝光，也便是把该bean转换成beanFactory并加入到三级缓存。在需求引证提早曝光目标时再经过singletonFactory.getObject()获取。

// 在实例化bean之后，假如答应循环依靠，将未创立完的bean加入到三级缓存
if (earlySingletonExposure) {
   if (logger.isTraceEnabled()) {
      logger.trace("Eagerly caching bean '" + beanName +
            "' to allow for resolving potential circular references");
   }
   // 存入三级缓存
   addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
   Assert.notNull(singletonFactory, "Singleton factory must not be null");
   synchronized (this.singletonObjects) {
      if (!this.singletonObjects.containsKey(beanName)) {
         // 寄存三级缓存
         this.singletonFactories.put(beanName, singletonFactory);
         this.earlySingletonObjects.remove(beanName);
         this.registeredSingletons.add(beanName);
      }
   }
}

三级缓存的运用

当A和B相互依靠时，若先创立实例A，则整个调用进程为：

其中触及缓存和依靠相关首要进程为：

开端创立实例A，符号A为正在创立

protected void beforeSingletonCreation(String beanName) {
   // 将实例A加入到singletonsCurrentlyInCreation中
   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
      throw new BeanCurrentlyInCreationException(beanName);
   }
}

实例化A后，将未赋值和初始化的实例A加入到三级缓存singletonFactories中

addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
   Assert.notNull(singletonFactory, "Singleton factory must not be null");
   synchronized (this.singletonObjects) {
      if (!this.singletonObjects.containsKey(beanName)) {
         // 放入三级缓存
         this.singletonFactories.put(beanName, singletonFactory);
         // 二级缓存删去该bean
         this.earlySingletonObjects.remove(beanName);
         this.registeredSingletons.add(beanName);
      }
   }
}

因为循环依靠，实例A触发实例B加载，符号B为正在创立，并在实例化B后，将未赋值和初始化的实例B加入到三级缓存singletonFactories中（同上）
因为循环依靠，实例B触发实例A加载，在缓存中获取到未创立好的A

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   // 一级缓存中不存在A，回来null
   Object singletonObject = this.singletonObjects.get(beanName);
   // A因为现已符号为正在创立，进入下面的if句子
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      // 二级缓存不存在A，回来null
      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) {
                  // 三级缓存中存在未创立好的实例A，获取到ObjectFactory目标
                  ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                  if (singletonFactory != null) {
                     // 调用getObject()办法，获取到为创立好的实例A
                     singletonObject = singletonFactory.getObject();
                     // 将实例A放入到二级缓存中
                     this.earlySingletonObjects.put(beanName, singletonObject);
                     // 三级缓存中删去实例A
                     this.singletonFactories.remove(beanName);
                  }
               }
            }
         }
      }
   }
   return singletonObject;
}

在B创立好之后，则符号实例B创立完结，并将B加入到一级缓存中

protected void afterSingletonCreation(String beanName) {
   // 将实例B从singletonsCurrentlyInCreation中删去
   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
      throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
   }
}
protected void addSingleton(String beanName, Object singletonObject) {
   synchronized (this.singletonObjects) {
      // 将实例B放入一级缓存
      this.singletonObjects.put(beanName, singletonObject);
      // 三级缓存中删去B
      this.singletonFactories.remove(beanName);
      // 二级缓存中删去B
      this.earlySingletonObjects.remove(beanName);
      this.registeredSingletons.add(beanName);
   }
}

在A创立好之后，则符号实例A创立完结，并将A加入到一级缓存中

AOP和三级缓存

不触及AOP

实例加入到三级缓存，并从三级缓存中获取实例进程如下：

// 添加到三级缓存
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
// 运用三级缓存
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
   singletonObject = singletonFactory.getObject();
   this.earlySingletonObjects.put(beanName, singletonObject);
   this.singletonFactories.remove(beanName);
}

从三级缓存获取到的bean，是经过getEarlyBeanReference()效果之后回来的bean，在不触及AOP时，没有类掩盖完成getEarlyBeanReference()办法，运用getEarlyBeanReference()的默许完成，因而回来的bean便是实例化后的原始bean。

default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
   return bean;
}

触及AOP

当触及到AOP时，AbstractAutoProxyCreator完成了getEarlyBeanReference()办法，回来的bean是经过AOP署理的bean。

public Object getEarlyBeanReference(Object bean, String beanName) {
   Object cacheKey = getCacheKey(bean.getClass(), beanName);
   this.earlyProxyReferences.put(cacheKey, bean);
   // 创立AOP署理
   return wrapIfNecessary(bean, beanName, cacheKey);
}

不触及循环依靠时，bean的AOP署理是在实例化，赋值，初始化之后创立的。而触及循环依靠时，三级缓存中保存的是实例化但未赋值，初始化之后的bean，当经过三级缓存获取实例时，则会提早创立AOP署理：

非循环依靠，在实例化，赋值，初始化之后创立AOP署理
循环依靠，在实例化，未赋值，初始化之后创立AOP署理（提早创立署理）

关于在缓存中提早创立好署理的实例，当赋值，初始化之后，运行至bean的后置处理逻辑，即AbstractAutoProxyCreator的postProcessAfterInitialization办法（正常创立AOP署理逻辑）时，则不会再次创立AOP署理，回来的是不经署理的bean。

// AbstractAutoProxyCreator的后置处理逻辑
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
   if (bean != null) {
      // 因为提早创立了署理并且有缓存，则不再回来署理
      Object cacheKey = getCacheKey(bean.getClass(), beanName);
      if (this.earlyProxyReferences.remove(cacheKey) != bean) {
         return wrapIfNecessary(bean, beanName, cacheKey);
      }
   }
   return bean;
}

再回来赋值和初始化bean的逻辑中，exposedObject作为终究的回来成果，在运用到AOP时，终究回来的都是署理bean

// 原始bean
Object exposedObject = bean;
try {
   // 实例赋值
   populateBean(beanName, mbd, instanceWrapper);
   // 实例初始化（初始化后调用bean的后置处理逻辑，即创立AOP署理）
   // （1）非循环依靠，未提早创立署理，initializeBean回来的是署理bean
   // （2）循环依靠，提早创立署理，initializeBean回来的是原始bean
   exposedObject = initializeBean(beanName, exposedObject, mbd);
}
if (earlySingletonExposure) {
   // 当allowEarlyReference=false时，只能从一级二级缓存中获取实例
   // （1）未提早创立署理时，实例在三级缓存中，getSingleton回来署理null
   // （2）提早创立署理时，实例在二级缓存中，回来署理bean
   Object earlySingletonReference = getSingleton(beanName, false);
   if (earlySingletonReference != null) {
      // 提早创立署理，署理bean在缓存中，所以下面相等
      if (exposedObject == bean) {
         // 将署理bean赋值给exposedObject
         exposedObject = earlySingletonReference;
      }
      // ...
   }
}

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。