Spring源码解读--DefaultSingletonBeanRegistry解读

首先看接口的关系：

     

    AliasRegistry 即Bean对应的别名，直接看其实现类的关系：

         

  可以看到是用一个并发Map来存储对应的关系：

   

而关于其的方法，可以看主要的两个方法，即RegisterAlias与getAlias：

     首先看RegisterAlias：

         

public void registerAlias(String name, String alias) {
   Assert.hasText(name, "'name' must not be empty");
   Assert.hasText(alias, "'alias' must not be empty");
    //如果alias对于beanName则直接删除原来的，也就是如果原来有存b->a，现在存b->b，
      则直接删除a->b，并且a->a也保存

   if (alias.equals(name)) {
      this.aliasMap.remove(alias);
   }
   else {
      String registeredName = this.aliasMap.get(alias);
      if (registeredName != null) {
         if (registeredName.equals(name)) {
            // An existing alias - no need to re-register
            return;
         }
         if (!allowAliasOverriding()) {
            throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" +
                  name + "': It is already registered for name '" + registeredName + "'.");
         }
      }
      checkForAliasCircle(name, alias);
      this.aliasMap.put(alias, name);
   }
}

然后上面checkForAliasCircle，即循环检查，

  这里应该从getAliases说起了：

     

public String[] getAliases(String name) {
   List<String> result = new ArrayList<>();
   synchronized (this.aliasMap) {
      retrieveAliases(name, result);
   }
   return StringUtils.toStringArray(result);
}

   这里又有一个自循环：

private void retrieveAliases(String name, List<String> result) {
   this.aliasMap.forEach((alias, registeredName) -> {
      if (registeredName.equals(name)) {
         result.add(alias);
         retrieveAliases(alias, result);
      }
   });
}

即首先通过BeanName获取其别名，再以别名Alias为BeanName获取其别名，（）如下：

     

由此可见，其需要进行循环检查，不然就会进入死循环：

    

   

之后再看接口SingletonBeanRegistry：

    

 

之后即类DefaultSingletonBeanRegistry：

   

     关键是对这些全局变量的操作：

         我们结合具体代码来说明这些全局变量：

           首先：registerSingleton(String beanName, Object singletonObject)；

      

public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
   Assert.notNull(beanName, "Bean name must not be null");
   Assert.notNull(singletonObject, "Singleton object must not be null");
   synchronized (this.singletonObjects) {
      Object oldObject = this.singletonObjects.get(beanName);
      if (oldObject != null) {
         throw new IllegalStateException("Could not register object [" + singletonObject +
               "] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
      }
      addSingleton(beanName, singletonObject);
   }
}

进入addSingleton方法：

            

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);
   }
}

这里涉及到四个全局变量：通过代码可以看到在这里是将一个单例对象singletonObject条件到singletonObjects、registeredSingletons里，这个registeredSingletons通过名字我们可以知道，其就是已经注册过的Bean对象了。但是在这里你们是否有发现一个问题，为什么要用一个registeredSingletons去标识已注册Bean对象，也可以用singletonObjects啊？这里我们可以看有哪些地方有用到这个registeredSingletons（将bean对象添加到singletonObjects只有这里有添加），其中一处使用的地方就是我们刚才说的，还有一处就是：

    

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);
      }
   }
}

这里我们可以看到是将一个singletonFactories添加到singletonFactories中，同时添加到registeredSingletons中，这里我们应该

    可以知道表示已注册的Bean应该有两条线去标识它，即添加singletonObject与singletonFactory时，但其实我们正常创建一个bean它是先添加到singletonFactories里面去的，同时添加到registeredSingletons里，之后会在addSingleton(String beanName, Object singletonObject)再添加一次到registeredSingletons里，不过这次会失败:

   先调用addSingletonFactory方法添加，

     

之后会再调用一次addSingleton

那spring为什么会这样多此一举的设计呢？

    

public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
   Assert.notNull(beanName, "Bean name must not be null");
   Assert.notNull(singletonObject, "Singleton object must not be null");
   synchronized (this.singletonObjects) {
      Object oldObject = this.singletonObjects.get(beanName);
      if (oldObject != null) {
         throw new IllegalStateException("Could not register object [" + singletonObject +
               "] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
      }
      addSingleton(beanName, singletonObject);
   }
}

   我们可以点这个方法看它有哪些方法调用它，我们发现在这个直接添加singletonObject会将spring自己的类添加进去，如：

            

所以可以知道，registeredSingletons与singletonObjects区别，一个是这个Spring容器的所有单例Bena，而另一个是我们注入的Bean。

   之后我们将目光用到另一个全局变量上：earlySingletonObjects,关于这个我们需要直接跳到DefaultSingletonBeanRegistry的父类AbstractAutowireCapableBeanFactory，看bean实例的创建

doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args){方法中有局部变量earlySingletonExposure：

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
      isSingletonCurrentlyInCreation(beanName));

可以看到它的值是有三个决定的，即是不是单例，允不允许循环调用、还有是不是这个bean正在创建中，可以看我的这篇博客：https://blog.csdn.net/qq_25179481/article/details/89241914；

这个isSingletonCurrentlyInCreation是DefaultSingletonBeanRegistry的方法:

public boolean isSingletonCurrentlyInCreation(String beanName) {
   return this.singletonsCurrentlyInCreation.contains(beanName);
}

这里可以看到在方法

getSingleton(String beanName, ObjectFactory<?> singletonFactory)中是先将:

创建bean对象时先将其加入到：

beforeSingletonCreation(beanName);中

再调用singletonObject = singletonFactory.getObject();

singletonFactory去创建，在这里singletonFactory.getObject();可能就有循环调用了，因为需要完成singletonFactory.getObject();才会调用下一步：

   

finally {
   if (recordSuppressedExceptions) {
      this.suppressedExceptions = null;
   }
   afterSingletonCreation(beanName);
}

将其从全局变量singletonsCurrentlyInCreation清掉表明完成创建：

   

protected void afterSingletonCreation(String beanName) {
   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
      throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
   }
}

    所以在变量：boolean earlySingletonExposure，如果有循环调用:

   

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
      isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
   if (logger.isDebugEnabled()) {
      logger.debug("Eagerly caching bean '" + beanName +
            "' to allow for resolving potential circular references");
   }
   addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

需要提前将这个ObjectFactory

初始化的还没有进行任何赋值的空对象暴露到：

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);
      }
   }
}

  同时我们可以看到在 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));后就会：

if (earlySingletonExposure) {
   if (logger.isDebugEnabled()) {
      logger.debug("Eagerly caching bean '" + beanName +
            "' to allow for resolving potential circular references");
   }
   addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

// Initialize the bean instance.
Object exposedObject = bean;
try {
   populateBean(beanName, mbd, instanceWrapper);
   exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
   if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
      throw (BeanCreationException) ex;
   }
   else {
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
   }
}

if (earlySingletonExposure) {
   Object earlySingletonReference = getSingleton(beanName, false);

    通过populateBean(beanName, mbd, instanceWrapper);去给循环的Bean赋值，然后就会来到最开始的AbstractBeanFactory

:  

@Override
public Object getBean(String name) throws BeansException {
   return doGetBean(name, null, null, false);
}

   

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

   final String beanName = transformedBeanName(name);
   Object bean;

   // Eagerly check singleton cache for manually registered singletons.
   Object sharedInstance = getSingleton(beanName);

                    ....................

在这里就会将前面的addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

       的ObjectFactory的内容创建暴露到earlySingletonObjects：

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);
      }
   }
}

以上这些操作,其实都是AbstractBeanFactory的:

   

public Object getBean(String name) throws BeansException {
   return doGetBean(name, null, null, false);
}

     然后在doGetBean里的：

if (mbd.isSingleton()) {
   sharedInstance = getSingleton(beanName, () -> {
      try {
         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.
         destroySingleton(beanName);
         throw ex;
      }
   });
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}；

这个getSingleton(beanName, () -> {其实就是DefaultSingletonBeanRegistry的

getSingleton(String beanName, ObjectFactory<?> singletonFactory) ;

      

而return createBean(beanName, mbd, args);，就是singletonObject = singletonFactory.getObject();获取bean并赋值的过程，

   现在赋值完成后，就通过addSingleton(beanName, singletonObject);，将其暴露到singletonObjects里，这个时候就真正完成了一个Bean的创建于赋值了。

if (newSingleton) {
   addSingleton(beanName, singletonObject);
}

DefaultSingletonBeanRegistry的getSingleton(String beanName, ObjectFactory<?> singletonFactory)方法摘要：

beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
   this.suppressedExceptions = new LinkedHashSet<>();
}
try {
   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);
}

 

     自此DefaultSingletonBeanRegistry的几个关键的全局变量，就梳理完毕，而其他的关于DependentBean的全局变量，到时候在写下这篇的下部分。个人感觉，对于spring的总流程来说，这个DependentBean的流程，应该没怎么复杂，也不算是构建spring很核心部分的内容，所以不会在这一篇的后面，之后有时间，通过测试demo简单说明一下吧。