Spring源码阅读----Spring IoC之finishBeanFactoryInitialization及Spring 如何解决循环依赖

概述

前面我们从registerBeanPostProcessors方法解析的时候，已经提到了finishBeanFactoryInitialization方法。我们先越过中间的消息资源初始化以及事件监听的部分，来解析一下finishBeanFactoryInitialization这个方法，因为我们从前面已经知道Spring IoC最重要部分就在于：obtainFreshBeanFactory、invokeBeanFactoryPostProcessors、registerBeanPostProcessors 和finishBeanFactoryInitialization 这四个方法，而finishBeanFactoryInitialization 又是Spring IoC的核心。
在finishBeanFactoryInitialization 方法里，会实例化所有剩余的非懒加载单例 bean（包括一些内部的 bean、实现了 BeanFactoryPostProcessor 接口的 bean、实现了 BeanPostProcessor 接口的 bean，以及其他的非懒加载单例 bean） ， 之前注册了的BeanPostProcessor 实现类也是在这里被调用执行其方法的。

finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        // Initialize conversion service for this context.
        // 为上下文初始化转换服务
        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
            beanFactory.setConversionService(
                    beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
        }

        // Register a default embedded value resolver if no bean post-processor
        // (such as a PropertyPlaceholderConfigurer bean) registered any before:
        // at this point, primarily for resolution in annotation attribute values.
        // 如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：主要用于注解属性值的解析。
        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
        }

        // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
        // 获取LoadTimeWeaverAware类型的bean名称
        // 遍历初始化LoadTimeWeaverAware Bean实例对象
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        for (String weaverAwareName : weaverAwareNames) {
            getBean(weaverAwareName);
        }

        // Stop using the temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(null);

        // Allow for caching all bean definition metadata, not expecting further changes.
        // 冻结配置，允许缓存所有bean定义元数据，所有bean定义不会被修改或进一步后处理
        beanFactory.freezeConfiguration();

        // Instantiate all remaining (non-lazy-init) singletons.
        //注释1. 实例化所有剩余（非懒加载）单例对象
        beanFactory.preInstantiateSingletons();
    }

执行步骤按方法中的注释往下走，比较清晰，最后到达最后一步实例化。具体来看最后一步的实例化步骤。

注释1. 实例化所有剩余（非懒加载）单例对象 (见源码解析1)
【源码解析1】 beanFactory.preInstantiateSingletons
我们知道beanFactory是DefaultListableBeanFactory类型，所以preInstantiateSingletons方法源码如下:

public void preInstantiateSingletons() throws BeansException {
        if (logger.isTraceEnabled()) {
            logger.trace("Pre-instantiating singletons in " + this);
        }

        // Iterate over a copy to allow for init methods which in turn register new bean definitions.
        // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
        //创建beanDefinitionNames的副本beanNames用于后续的遍历，以允许init等方法注册新的bean定义
        List beanNames = new ArrayList<>(this.beanDefinitionNames);

        // Trigger initialization of all non-lazy singleton beans...
        for (String beanName : beanNames) {

            //注释1. 获取beanName对应的MergedBeanDefinition
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

            // 判断bd这个Bean实例：不是抽象类 && 是单例 && 不是懒加载
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {

                //注释2. 判断beanName对应的bean是否为FactoryBean
                if (isFactoryBean(beanName)) {

                    //注释2-1. getBean('&'+beanName)将得到bean本身
                    //通过getBean(beanName)拿到的是FactoryBean创建的Bean实例
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    if (bean instanceof FactoryBean) {
                        //判断它是不是FactoryBean类型，然后获取FactoryBean实例
                        final FactoryBean factory = (FactoryBean) bean;

                        // 急切初始化标识
                        boolean isEagerInit;
                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            isEagerInit = AccessController.doPrivileged((PrivilegedAction)
                                            ((SmartFactoryBean) factory)::isEagerInit,
                                    getAccessControlContext());
                        }
                        else {
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean) factory).isEagerInit());
                        }

                        //注释2-2. 如果需急切初始化，则通过getBean(beanName)获取bean实例
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                }
                else {
                    //注释2-3 如果beanName对应的bean不是FactoryBean，只是普通Bean，通过getBean(beanName)获取bean实例
                    getBean(beanName);
                }
            }
        }

        // Trigger post-initialization callback for all applicable beans...
        // 注释3. 遍历beanNames，触发post-initialization 回调
        for (String beanName : beanNames) {

            // 获取beanName对应的单例bean实例
            Object singletonInstance = getSingleton(beanName);

            //判断singletonInstance是否实现了SmartInitializingSingleton接口
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;

                    //触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedAction