/** Cache of singleton objects: bean name to bean instance. */
    /**
     * 一级缓存  这个就是我们大名鼎鼎的缓存池,用于保存我们所有的实例bean
     private final Map<String,Object> singletonObjects = new ConcurrentHashMap<>(256);

    * Cache of singleton factories: bean name to ObjectFactory. *
     * 三级缓存  该map用户缓存key为beanName,value为objectFactory(包装为早期对象)
     singletonFactories = new HashMap<>(16* Cache of early singleton objects: bean name to bean instance. *
     * 二级缓存,用户缓存我们的key为beanName,value是我们的早期对象(此时对象属性还没有...)
     earlySingletonObjects = 16);

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.
        destroySingleton(beanName);
        throw ex;
    }
});

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) {
                if (.singletonsCurrentlyInDestruction) {
                    throw new BeanCreationNotAllowedException(beanName,1)">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 + ' 第二步: 将bean添加到singletonsCurrentlyInCreation中,表示bean正在创建
                beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                boolean recordSuppressedExceptions = (this.suppressedExceptions == );
                 (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet<>();
                }
                 {
                    // 第三步: 这里调用getObject()钩子方法,就会回调匿名函数,调用singletonFactory的createBean()
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                }
                 (IllegalStateException ex) {
                     Has the singleton object implicitly appeared in the meantime ->
                     if yes,proceed with it since the exception indicates that state.
                    singletonObject = (beanName);
                    ) {
                        throw ex;
                    }
                }
                 (BeanCreationException ex) {
                     (recordSuppressedExceptions) {
                        for (Exception suppressedException : .suppressedExceptions) {
                            ex.addRelatedCause(suppressedException);
                        }
                    }
                     ex;
                }
                finally {
                    ;
                    }
                    afterSingletonCreation(beanName);
                }
                 (newSingleton) {
                    addSingleton(beanName,singletonObject);
                }
            }
             singletonObject;
        }
    }

 把我们的早期对象包装成一个singletonFactory对象,该对象提供了getObject()方法,把静态的bean放到三级缓存中去了.
addSingletonFactory(beanName,() -> getEarlyBeanReference(beanName,bean));

protected void addSingletonFactory(String beanName,ObjectFactory<?> singletonFactory) {
        Assert.notNull(singletonFactory,1)">Singleton factory must not be nullif (!.singletonObjects.containsKey(beanName)) {
                 加入到三级缓存中,暴露早期对象用于解决循环依赖.
                this.singletonFactories.put(beanName,singletonFactory);

                 从二级缓存中删除
                .earlySingletonObjects.remove(beanName);

                 添加到已经注册的singleton实例.
                .registeredSingletons.add(beanName);
            }
        }
    }

@Nullable
    protected Object  从一级缓存中获取bean实例对象
        Object singletonObject = (beanName);
        *
         * 如果在第一级的缓存中没有获取到对象,并且singletonsCurrentlyIncreation为true,也就是这个类正在创建.
         * 标明当前是一个循环依赖.
         *
         * 这里有处理循环依赖的问题.-- 我们使用三级缓存解决循环依赖
         */
        null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (.singletonObjects) {
                *
                 * 从二级缓存中拿bean,二级缓存中的对象是一个早期对象
                 * 什么是早期对象?就是bean刚刚调用了构造方法,还没有给bean的属性进行赋值,和初始化,这就是早期对象
                  */

                singletonObject = this.earlySingletonObjects.(beanName);
                 allowEarlyReference) {
                    *
                     * 从三级缓存拿bean,singletonFactories是用来解决循环依赖的关键所在.
                     * 在ios后期的过程中,当bean调用了构造方法的时候,把早期对象包装成一个ObjectFactory对象,暴露在三级缓存中
                      */
                    ObjectFactory<?> singletonFactory = this.singletonFactories.(beanName);
                    if (singletonFactory != ) {
                        /**
                         * 在这里通过暴露的ObjectFactory包装对象. 通过调用他的getObject()方法来获取对象
                         * 在这个环节中会调用getEarlyBeanReference()来进行后置处理
                         */
                        singletonObject = singletonFactory.getObject();
                         把早期对象放置在二级缓存中
                        .earlySingletonObjects.put(beanName,singletonObject);
                         删除三级缓存
                        .singletonFactories.remove(beanName);
                    }
                }
            }
        }
         singletonObject;
    }