所有文章已迁移至csdn，csdn个人主页https://blog.csdn.net/chaitoudaren

// AbstractBeanFactory.java
// 7. 单例情况下
if (mbd.isSingleton()) {
    /**
     * 核心代码，spring4.x中是这么写的，会更容易理解一点
     * sharedInstance = getSingleton(beanName, new ObjectFactory<object>() {
     *      getObject() {
     *          return createBean(beanName, mbd, args);
     *      }
     *  }
     *  即getSingleton第二个参数为ObjectFactory对象
     */
    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;
        }
    });

    ...
}

这里的写法可能有点绕，首先getSingleton传入2个参数，beanName和一个ObjectFactory对象。spring5.x以后使用了lambda表达式缩写，但是如代码注释，spring4.x的更为直观一些。新建一个ObjectFatory对象，其中ObjectFactory是一个接口，使用了匿名类去实现该接口，并且重写了getObject()方法

获取单例

// DefaultSingletonBeanRegistry.java
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(beanName, "Bean name must not be null");
        // 加个锁
        synchronized (this.singletonObjects) {
            // 1. 尝试从一级缓存中获取
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                if (this.singletonsCurrentlyInDestruction) {
                    throw new BeanCreationNotAllowedException(beanName,
                            "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 + "'");
                }
                // 2. 循环依赖检测的典型做法，如果发现当前bean需要被循环依赖检测且正在创建则抛出异常，否则标识当前的bean正在创建
                beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet<>();
                }
                try {
                    /**
                     * 3. 回调singletonFactory的getObject方法，实际调用AbstractBeanFactory的createBean，而该方法又被子类所实现
                     * 所以实际调用的是AbstractAutowireCapableBeanFactory的createBean方法
                     */
                    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;
                    }
                    // 4. 同样是循环依赖检测的典型做法，如果发现bean处于非创建状态则抛出异常，否则标识bean不在创建状态
                    afterSingletonCreation(beanName);
                }
                if (newSingleton) {
                    addSingleton(beanName, singletonObject);
                }
            }
            return singletonObject;
        }
    }

1. 第一点还是惯用做法，先尝试从一级缓存获取，获取到则可以直接跳过创建
2. 这点在前面章节介绍过，这里再回顾一下。在创建bean之前，需要先检查当前bean是否在创建列表中，如果在创建列表中说明存在循环引用，假设这里不抛出异常将会无限递归创建bean，造成死循环。该步骤对应的是下图的(1. 检测a是否在创建状态)。因为当前是单例模式，因此检测的集合是singletonsCurrentlyInCreation，而当原型模式下则使用propertysCurrentInCreation进行检测

    protected void beforeSingletonCreation(String beanName) {
        // 该beanName没有在排除检查列表中，且已经在创建中，则抛出循环依赖异常
        if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
    }

循环依赖检测.jpg

3. 调用刚刚传入的singletonObjects对象的getObject()方法，这也是创建bean的核心逻辑。创建bean的过程包含了实例化、填充、初始化3大步骤以及多个后置处理器，因此我们单独拿出一节来讲解。详见：spring源码日记12: spring创建Bean
4. 这一步对应上图的第10步，当bean正常创建完成时，记得将当前beanName移出正常创建的列表。

    protected void afterSingletonCreation(String beanName) {
        // 当前beanName不在排除列表中，并且不在单例创建列表中
        if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
            throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
        }
    }