Spring IoC容器初始化

Spring IoC容器的初始化，主要分为三段

1. 启动容器，扫描指定包路径下的Bean，封装BeanDefinition

   启动容器的三种方式：ClassPathXmlApplicationContext、AnnotationConfigApplicationContext、FileSystemXmlApplicationContext； 分别会走不同的扫描方式，最终完成BeanDefinition的封装。

2. 装配BeanFactory

3. 根据SpringBean的生命周期中定义的创建流程，创建Bean对象。无论以哪一种方式启动容器，最终都会交由AbstractApplicationContext类执行refresh方法进行Bean对象的创建

循环依赖

在Spring容器的初始化过程中，绕不开2个及以上Bean对象的相互依赖问题，Spring称之为循环依赖（circular references）

三级缓存

Spring对于循环依赖问题，提供了使用三级缓存的解决策略。分别为

• singletonFactories：三级缓存，存放的是ObjectFactory，注意此处存放的不是bean对象，而是生成bean对象的factory对象。
• earlySingletonObjects：二级缓存，存放的是由三级缓存中ObjectFactory对象执行getObject方法生成的代理对象，完成Spring通过动态代理的方式，对bean中的方法实现增强。此时该代理对象尚未开始属性注入。
• singletonObjects：一级缓存，即最终Spring容器中的单例池，存放最终完成所有属性注入的完整bean对象。

值得注意的是：Spring在初始化Bean的过程中，并不能预先确认该Bean是否存在循环依赖的情况。因此所有Bean对象（无论有无循环依赖），在被实例化之后，属性注入之前，都会被放入三级缓存singletonFactories中，走相同的初始化流程。

初始化Bean处理AutoWired.png

为什么要使用三级缓存

看了一些关于三级缓存的博客，大部分都有描述这个问题。简单回答：需要遵守设计的“单一原则”，各级缓存各司其职。

这又衍生出另一个问题：第三级缓存的存在，到底在设计上有何优雅或者必要之处？

实际上这个三级缓存中的ObjectFactory会在Bean对象第一次属性依赖（注意不一定是循环依赖的情况）注入时，就执行它的getObject方法，获取增强后的代理对象，放入二级缓存中；此后，在每一次循环依赖属性注入时，都会从二级缓存中取得代理对象进行注入。也就是说，如果根本就没有三级缓存，直接执行掉ObjectFactory.getObject方法里的操作，获取代理对象后放入二级缓存中。理论上也是可以的，这样似乎三级缓存就没必要了？不用怀疑ObjectFactory.getObject里的操作的执行时机问题，里面只是一些纯粹的增强。

下图是源码追踪Spring解决循环依赖问题的时序图，也是Spring Bean初始化与属性注入的大致流程：

Spring Bean循环依赖.png

以下源码分析的过程，对不关注的代码进行了删减

通过ClassPathXmlApplicationContext启动容器：

public ClassPathXmlApplicationContext(
            String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
            throws BeansException {

        super(parent);
        // sy 扫描配置文件，封装BeanDefinition对象 -- 所有的启动方式在构造函数中，都会先走配置扫描，做BeanDefinition封装。
        //      之后统一走AbstractApplicationContext：refresh();进行容器初始化
        // ClassPathXmlApplicationContext：setConfigLocations(configLocations);
        // FileSystemXmlApplicationContext：setConfigLocations(configLocations);
        // AnnotationConfigApplicationContext(Class... componentClasses)：register(componentClasses);
        // AnnotationConfigApplicationContext(String... basePackages)：scan(basePackages);
        // -- AbstractApplicationContext：refresh();
        setConfigLocations(configLocations);
        if (refresh) {
            // sy 初始化IoC容器
            refresh();
        }
    }

ClassPathXmlApplicationContext的构造函数最终走AbstractApplicationContext.refresh方法，完成BeanFactory与Bean的建立

AbstractApplicationContext#refresh

public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            // sy 获取BeanFactory
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            // sy 预装配BeanFactory
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                // sy 模板方法
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                // sy 设置工程中实现的BeanFactoryPostProcessors并执行postProcessBeanFactory方法
                // 最终通过DefaultListableBeanFactory.doGetBeanNamesForType遍历beanDefinitionNames获取BeanFactoryPostProcessors。
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                // sy 注册BeanPostProcessors
                // 调用时机：Bean实例化 -> Bean对象属性注入 -> BeanNameAware.setBeanName -> BeanFactoryAware.setBeanFactory -> ApplicationContextAware.setApplicationContext
                //          -> **** BeanPostProcessor.postProcessBeforeInitialization ****
                //              -> InitializingBean.afterPropertiesSet -> 调用xml定制的init-method方法或者Bean中用@PostConstruct注解的方法
                //          -> **** BeanPostProcessor.postProcessAfterInitialization  ****
                //              -> Singleton：放入单例池中，由Spring容器管理; Prototype：交给调用者，由JVM管理
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                // sy 国际化
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                // sy 最终完成IoC注入的调用
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset 'active' flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

执行AbstractApplicationContext#finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        // 初始化Bean
        beanFactory.preInstantiateSingletons();
    }

执行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.
        List beanNames = new ArrayList<>(this.beanDefinitionNames);

        // Trigger initialization of all non-lazy singleton beans...
        // sy 通过遍历封装完毕的BeanDefinition，逐一创建Spring Bean
        for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) {
                    // sy 处理FactoryBean
                    //  从容器中获取FactoryBean时，使用"&"+beanName的原因
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    if (bean instanceof 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());
                        }
                        if (isEagerInit) {
                            // sy 初始化bean
                            getBean(beanName);
                        }
                    }
                }
                else {
                    // sy 初始化bean
                    getBean(beanName);
                }
            }
        }

        // Trigger post-initialization callback for all applicable beans...
        for (String beanName : beanNames) {
            // 逐一从一级缓存、二级缓存、三级缓存中获取实例化对象
            Object singletonInstance = getSingleton(beanName);
            // 对单例bean对象的后置增强
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedAction