Spring 容器的创建及刷新

public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            // 刷新前的预处理
            // initPropertySource() 初始化一些属性；子类自定义个性化的属性设置方法
            // getEnvironment().validateRequiredProperties();校验属性合法等
            // earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>(); 保存容器中的一些早期时间
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            // 获取 BeanFactory
            // refreshBeanFactory 刷新BeanFactory
            // 创建了一个 this.beanFactory = new DefaultListableBeanFactory();
            // 设置序列化ID
            // getBeanFactory();返回 GenericApplicationContext 创建的 BeanFactory 对象
            // 将 BeanFactory【DefaultListableBeanFactory】返回
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            // BeanFactory 的预准备工作（BeanFactory 进行一些设置）
            // 设置 BeanFactory的类加载器、支持表达式解析器...
            // 添加部分的 BeanPostProcessor【ApplicationContextAwareProcessor】
            // 设置忽略自动装配的接口 Environment、EmbeddedValueResolverAware、xxx
            // 注册可以解析的自动装配：我们能直接在任何组件中自动注入：BeanFactory、ResourceLoader、ApplicationEventPulisher、ApplicationContext
            // 添加 BeanPostProcessor【ApplicationListenerDetector】
            // 添加编译时的AspectJ
            // 给BeanFactory注册 environment【ConfiguravleEnvironment】、systemProperties【Map<String,Object>】、systemEnvironment【Map<String,Object>】
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                // postProcessBeanFactory(beanFactory);BeanFactory 准备工作完成后进行的后置处理工作
                // 子类通过重写 在BeanFactory串讲并预准备完成以后做进一步设置
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                // 执行 BeanFactory 的后置处理器
                // 在 BeanFactory 标准初始化之后执行的
                // 两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryProcessor
                // 执行 BeanFactoryPostProcessor
                // 获取所有的 BeanDefinitionRegistryPostProcessor
                // 先执行实现 PriorityOrdered 优先级接口的 BeanDefinitionRegistryPostProcessor；postProcessor.postProcessBeanDefinitionRegistry(registry)
                // 在执行实现利润 Orderd 顺序接口的BeanDefinitionRegistryPostProcessor；postProcessor.postProcessBeanDefinitionRegistry(registry)
                // 最后执行没有实现任何优先级或者顺序接口的 顺序接口的 BeanDefinitionRegistryPostProcessor
                // 再执行 BeanFactoryPostProcessor 
                // 获取所有的 BeanFactoryPostProcessor
                // 先执行实现 PriorityOrdered 优先级接口的 BeanFactoryPostProcessor；postProcessor.postProcessBeanFactory(beanFactory);
                // 在执行实现利润 Orderd 顺序接口的 BeanFactoryPostProcessor；postProcessor.postProcessBeanFactory(beanFactory);
                // 最后执行没有实现任何优先级或者顺序接口的 顺序接口的 BeanFactoryPostProcessor
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                // 注册 BeanPostProcessor（Bean的后置处理器）【拦截 Bean 的创建过程】
                // 不同类型的 BeanPostProcessor 在Bea 创建前后的执行时机是不一样的
                // DestructionAwareBeanPostProcessor
                // InstantiationAwareBeanPostProcessor
                // SmartInstantiationAwareBeanPostProcessor
                // MergedBeanDefinitionPostProcessor【internalPostProcessors】
                // 获取所有的 BeanPostProcessor 后置处理器都可以通过 PriorityOrderd 和 Orderd 接口来执行优先级
                // 先注册 PriorityOrderd 优先级接口的BeanPostProcessor；BeanFactory.addBeanPostProcessor(postProcessor)
                // 在注册 Orderd 接口的
                // 最后注册没有实现任何优先级接口的
                // 最终注册 MergedBeanDefinitionPostProcessor
                // 注册一个 ApplicationListenerDetector；来在 Bean 创建完成后检查是否是 ApplicationListener
                // 如果是 applicationContext.addApplicationListener((ApplicationListener<?>) bean);
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                // 初始化MessageSource组件（做国际化功能：消息绑定，消息解析）
                // 获取 BeanFactory
                // 查询容器中是否有 id 为 messageSource ，类型是 MessageSource 的组件
                // 如果有赋值给 messageSource，如果没有就创建一个 DelegatingMessageSOurce；
                // MessageSource：取出国际化配置文件中的某个 key 值；能按照区域信息获取
                // 把创建好的 MessageSource 注册到容器中，以后获取国际化配置文件的值的时候，可以自动注入 MessageSource 使用 getMessage() 方法
                // BeanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME,this.messageSource);
                initMessageSource();

                // Initialize event multicaster for this context.
                // 初始化事件派发器
                // 获取 BeanFactory
                // 从BeanFactory中获取 applicationEventMulticaster 的 ApplicationEventMulticaster
                // 如果没有配置，创建一个 SimpleApplicationEventMulticaster
                // 将创建的 ApplicationEventMulticaster 增加到 BeanFactory中，以后其他组件直接祖丁注入
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                // 留给子容器（子类） 
                // 子类重写这个方法，在容器刷新的时候可以自定义逻辑
                onRefresh();

                // Check for listener beans and register them.
                // 给容器中将所有项目的 ApplicationListener 注册进来
                // 从容器中拿到所有的 ApplicationListener
                // 将每个监听器增加到事件派发器中getApplicationEventMulticaster.addApplicationListenerBean(listenerBeanName)；
                // 派发之前步骤产生的实践
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                // 初始化所有剩下的单实例 bean
                // BeanFactory.preInstantiateSingletons(); 初始化剩下的单实例 bean
                // 获取容器中的所有 bean ，一次进行初始化和创建对象，
                // 获取bean 的定义信息：RootBeanDefinition
                // Bean 不是抽象的，是单实例的，不是懒加载的 
                // 判断是否是工厂 Bean；是否实现 FactoryBean 接口的 Bean
                // 不是工厂 bean 使用 getBean() 创建对象
                // getBean(beanName); ioc.getBean();
                // doGetBean(name,null,null,false);
                // 先获取缓存中保存的单实例Bean，如果能获取到说明这个 Bean 之前被创建国（所有创建国的单实例 Bean 都会被缓存起来） 从 private final Map<String, Objec> singletonObjects = new ConcurrentHashMap<String, Object>(256); 中获取
                // 缓存中获取不到，开始 Bean 的创建流程
                // 标记当前 bean 已经被创建
                // 获取 Bean 的定义信息
                // 获取当前 Bean 依赖的其他 Bean；如果有 按照 getBean() 把依赖的 Bean 先创建出来
                // 启动单实例 Bean  的创建流程
                // ceateBean(beanName, mbd, args);
                // Obejct bean = resolveBeforeInstantiation(beanName, mbdToUse); 让 BeanPostProcessor 先拦截返回代理对象 InstantiationAwareBeanPostProcessor 提前执行 触发 postProcessBeforeInstantiation(); 如果有返回值 在触发 postProcessAfterInstantiation();
                // 如果 InstantiationAwareBeanPostProcessor没有返回代理对象 调用 Object beanInstance = doCreatBean(beanName, mbdToUse, args);
                // 【创建 Bean 实例】 createBeanInstance(beanName, mbd, args);
                // 李瑞勇工厂方法或对象构造器创建 bean 实例
                // applyMergedBeanDefinitionProcessors(mbd, beanType, beanName);
                // 调用 MergedBeanDefinitionPostProcessor 的postProcessMergedBeanDefinition(mbd, beanType, beanName);
                // 【Bean 属性赋值】 populatBean(beanName, mbd, instanceWrapper); 
                // 赋值之前 
                // 拿到 InstantiationBeanPostProcessor 后置处理器 执行 postProcessAfterInstantiation();
                // 拿到 InstantiationBeanPostProcessor 后置处理器 执行 postProcessPropertyValues();
                // 应用 Bean 属性利用 setter方法等赋值 applyPropertyValues(beanName, mbd, bw, pvs);
                // 【Bean 初始化】 initializeBean(beanName, exposedObject, mbd);
                // 【接口的方法】invokeAwareMethods(beanName, bean); 执行 ***Aware  BeanNameAware\BeanClassLoaderAware\BeanFactoryAware
                // 【执行后置处理器初始化之前】applyBeanPostProcesBeforeInitialization(wrapped, beanName); BeanPostProcessor.postProcessBeforeInitialization();
                // 【执行初始化方法】 invokeMethods(beanName, wrappedBean, mbd);
                // 是否是 InitializingBean 接口的实现；执行接口规定的初始化；
                // 是否是 自定义初始化方法
                // 【执行后置处理器初始化之后】applyBeanPostProcesAfterInitialization(wrapped, beanName); BeanPostProcessor.postProcessAfterInitialization;
                // 注册 Bean 的销毁方法
                // addSingleton() 将已创建的bean 添加到缓存中 singletonObjects
                // 检查所有的 Bean 是否是 SmartInitializingSingleton 接口的，如果是就会执行 afterSingletonsInstantiated()
finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                // 完成 BeanFactory 的初始化创建工作
                // inITLifecycleProcessor();初始化和生命周期有关的后置处理器。
                // 如果有实现 LifecycleProcessor 的实现类，可以拦截 BeanFactory 的生命周期 void onRefresh(); void onClose();
                // 如果没有，创建一个默认的 new DefaultLiftcycleProcessor();
                // 拿到生命周期后置处理器，执行 onRefresh();
                // publishEvent(new ContextRefreshedEvent(this)); 发布容器刷新完成事件
                // LiveBeansView.registerApplicationContext(this);
                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();
            }
        }
    }

总结：

/*
1) Spring 容器在启动的时候，贤惠保存所有注册进来的 Bean 定义信息
    1）xml注册 bean；<bean>
    2) 注解注册Bean； @Service @Component @Bean
2) Spring 容器会在何时的实际创建这些 Bean
    1） 用到这个 bean 的时候，利用 getBean 创建 bean；创建好以后保存到容器中
    2） 同意创建剩下的所有 bean 的时候，finishBeanFactoryInItialization()
3） 后置处理器
    每一个 bean 创建完成，都会使用各种后置处理器进行处理，来增强 bean 的功能
    AutowiredAnnotationBeanPostProcessor 处理自动注入
    AnnotationAwareAspectJAutoProxyCreator 来做 AOP 功能
    AsyncAnnotationBeanPostProcessor 异步
4） 事件驱动模型
    ApplicationListener 事件监听
    ApplicationEventMulticaster 事件派发
*/