1. 目录

[TOC]

2. 说明

3. 依赖分析

4. 源码解析

4.1. AbstractApplicationContext#refresh()

AbstractApplicationContext#refresh() 是spring容器重要的方法，此方法初始化了spring的上下文，加载了spring的容器。再其他地方需要重新刷新的时候也重建上下文。

上下文刷新，XmlWebApplicationContext继承至AbstractApplicationContext,直接调用的父类方法refresh()
刷新方法真正初始化容器全流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public void refresh() throws BeansException, IllegalStateException {
    //加锁
    synchronized (this.startupShutdownMonitor) {
        //准备刷新，主要添加上下文初始化器
        prepareRefresh();

        //创建beanFactory，完成所有的BeanDefinition的创建添加到Map中
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        //准备BeanFactory，添加相关的配置。
        //添加ApplicationContextAwareProcessor，后续可以使用ApplicationContextAware
        //添加ApplicationListenerDetector监听探测器
        //注册环境配置
        prepareBeanFactory(beanFactory);

        try {
            //添加servlet相关BeanPostProcessor和environment相关
            postProcessBeanFactory(beanFactory);

            // 实例化初始化并调用所有已注册的 BeanDefinitionRegistryProcessor和BeanFactoryPostProcessor的前置方法
            invokeBeanFactoryPostProcessors(beanFactory);

            // 注册所有的BeanPostProcessor
            registerBeanPostProcessors(beanFactory);

            // 没干嘛实际上，暂时不考虑
            initMessageSource();

            // 初始化事件广播器，为监听器准备
            initApplicationEventMulticaster();

            // 没干嘛，不考虑；springboot中会初始化Tomcat
            onRefresh();

            //注册 ApplicationListener 监听器
            registerListeners();

            //先初始化切面LoadTimeWeaverAware，然后冻结BeanDefinition，初始化所有的非懒加载的单例bean
            finishBeanFactoryInitialization(beanFactory);

            //发布事件
            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();
        }
    }
    }

4.2. prepareRefresh() 准备刷新

验证参数，添加上下文监听器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
protected void prepareRefresh() {
    
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);

    if (logger.isDebugEnabled()) {
        if (logger.isTraceEnabled()) {
            logger.trace("Refreshing " + this);
        }
        else {
            logger.debug("Refreshing " + getDisplayName());
        }
    }

    //初始化上下文环境中的所有占位符属性(跳过)
    initPropertySources();

    //验证参数(跳过)
    getEnvironment().validateRequiredProperties();

    // 添加 ApplicationListeners 监听器，走if分支
    if (this.earlyApplicationListeners == null) {
        this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
    }
    else {
        // Reset local application listeners to pre-refresh state.
        this.applicationListeners.clear();
        this.applicationListeners.addAll(this.earlyApplicationListeners);
    }

    //清空
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

4.3. obtainFreshBeanFactory 创建Bean工厂

1
2
3
4
5
6
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    //刷新BeanFactory
    refreshBeanFactory();
    //获取BeanFactory，就把对象中的BeanFactory返回出去
    return getBeanFactory();
}

AbstractRefreshBeanFactory#refreshBeanFactory()只提供了一个抽象方法，具体实现在AbstractRefreshableApplicationContext中

4.3.1. AbstractRefreshableApplicationContext#refreshBeanFactory()

此方法主要用来创建BeanFactory并添加BeanDefinition，然后返回供后续使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
protected final void refreshBeanFactory() throws BeansException {
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        //创建BeanFactory，方法里 new DefaultListableBeanFactory,parentBeanFactory为空
        //`return new DefaultListableBeanFactory(getInternalParentBeanFactory())`
        DefaultListableBeanFactory beanFactory = createBeanFactory();

        //设置ID
        beanFactory.setSerializationId(getId());

        //内部配置是否覆盖BeanDefinition和是否允许循环依赖
        customizeBeanFactory(beanFactory);
        
        //加载BeanDefinitrions，由子类实现，此处比较复杂，单独开一个讲解
        loadBeanDefinitions(beanFactory);

        this.beanFactory = beanFactory;
    }
    catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}

4.4. prepareBeanFactory(beanFactory)准备bean工厂

主要用来加载一些预置的工具类和生命周期类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 设置ClassLoader、表达式解析器等（跳过）
    beanFactory.setBeanClassLoader(getClassLoader());
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    //ApplicationContextAware生命周期函数来源
    //添加ApplicationContextAwareProcessor，此BeanPostProcessor会加入Bean初始化，当Bean初始化时实现了ApplicationContextAware时可以通过setApplicationContext将上下文注入Bean中，
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

    /*
    忽略给定的自动装配依赖接口。
    这通常由应用程序上下文用于注册通过其他方式解析的依赖项，如通过BeanFactoryAware的BeanFactory或通过ApplicationContextAware的ApplicationContext。
    默认情况下，只忽略BeanFactoryAware接口。
    */
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    //注册解析器
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    //注册ApplicationListener监听器检测器，在bean初始化阶段检测到bean为监听器后将其加入监听器集合中
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // 代码织入相关AOP
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // 注册系统默认的Bean，可以先不管
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
}

4.5. postProcessBeanFactory(beanFactory) 子类后处理

这个只留了一个抽象方法，由子类AbstractRefreshableWebApplicationContext实现

AbstractRefreshableWebApplicationContext中和前面的方法差不多，都是往beanFactory中添加相应的配置

1
2
3
4
5
6
7
8
9
10
11
12
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    //添加ServletContextAwareProcessor
    beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));

    //忽略自动配置的接口
    beanFactory.ignoreDependencyInterface(ServletContextAware.class);
    beanFactory.ignoreDependencyInterface(ServletConfigAware.class);

    //注册作用于和环境变量的Bean
    WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
    WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
}

4.6. invokeBeanFactoryPostProcessors 处理执行所有BeanFactoryPostProcessor

实例化并调用所有已注册的BeanFactoryPostProcessor bean，如果给定，则遵循显式顺序。必须在单例实例化之前调用。

1
2
3
4
5
6
7
8
9
10
11
12
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    
    //执行BeanFactoryPostProcessor方法，加载Bean定义，
    //内部先执行BeanDefinitionRegisterPostProcessor对应的，再执行除开它的BeanFactoryPostProcessor
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    
    //添加切面织入的BeanPostProcessor处理器
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

4.6.1. PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()

此类是一个静态方法类，
处理BeanDefinitionRegisterPostProcessor，BeanDefinitionRegisterPostProcessor是在beandefinition加载后bean初始化之前，可以再添加bean的定义，可以在此处加入自定义beandefinition

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    Set<String> processedBeans = new HashSet<>();

    //beanFactory必须要为BeanDefinitionRegistry才可以，我们此处的`DefaultListableBeanFactory`是实现了`BeanDefinitionRegistry`的，大部分的都继承了DefaultListableBeanFactory
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        //不是BeanDefinitionRegistryPostProcessor的BeanFactoryPostProcessor，在BeanDefinitionRegistryPostProcessor执行完了执行
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        //BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                //判断是BeanDefinitionRegistryPostProcessor，则执行其方法，也就是我们实现类的方法
                /*
                public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
                    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
                }
                */
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            }
            else {
                regularPostProcessors.add(postProcessor);
            }
        }

        /*
        此后面内容很多，大部分是排序逻辑，目的就是根据优先级对BeanFactoryPostProcessor排序
        排序完成后按照顺序执行 BeanFactoryPostProcessor ，
        对梳理逻辑意义不大，可以暂时不考虑，以后再看
        */
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        currentRegistryProcessors.clear();

        // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        currentRegistryProcessors.clear();

        // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (!processedBeans.contains(ppName)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                    reiterate = true;
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            currentRegistryProcessors.clear();
        }

        // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }

    else {
        // Invoke factory processors registered with the context instance.
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let the bean factory post-processors apply to them!
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
        }
        else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // Finally, invoke all other BeanFactoryPostProcessors.
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // Clear cached merged bean definitions since the post-processors might have
    // modified the original metadata, e.g. replacing placeholders in values...
    beanFactory.clearMetadataCache();
}

4.7. initMessageSource() 国际化处理

国际化处理，暂不考虑
可以参考博客 Spring中refresh分析之initMessageSource方法详解

4.8. initApplicationEventMulticaster 初始化上下文事件多播器

事件多播器主要处理 ApplicationEvent 与 ApplicationListener 的关系，处理发布订阅的关系

初始化事件多播器，并对其初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //默认不会走if，自定义了ApplicationEventMulticaster才会走
    // APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster"
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        //初始化此ApplicationEventMulticaster
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (logger.isTraceEnabled()) {
            logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    else {
        //默认进入此逻辑，创建一个SimpleApplicationEventMulticaster
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        //注册到beanFactory中
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
        if (logger.isTraceEnabled()) {
            logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
                    "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
        }
    }
}

4.9. onRefresh() 刷新

刷新由子类实现，采用xml方式启动实现类为AbstractRefreshableWebApplicationContext#onRefresh()
也没干嘛，就初始化一个主题资源，影响不大

1
2
3
4
@Override
protected void onRefresh() {
    this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}

4.10. registerListeners 注册监听

将监听器注册到事件多播器中，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
protected void registerListeners() {
    //将所有配置的监听器加入前面创建的事件多播器
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    //从容器中获取到监听器并加入其中，即不是通过配置文件配置的
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    //发布早期事件，普通项目里其实是没有的
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

4.11. finishBeanFactoryInitialization() 完成BeanFactory的刷新

此处才是真正的加载容器中的bean过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // conversionService 相关，一般也没有，暂不考虑
    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));
    }

    //添加路径解析器
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    //先初始化aop代理的bean
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    
    beanFactory.setTempClassLoader(null);
    
    //冻结BeanDefinition，在此之后，不再新加入beanDefinition了
    beanFactory.freezeConfiguration();
    //初始化单例Bean （非常重要，后面单独说）
    beanFactory.preInstantiateSingletons();
}

总结

  1. 准备初始化器ApplciationContextInitializer
  2. 创建BeanFactory并加载所有的BeanDefinition
  3. 添加ApplicationListenerDetector监听探测器(初始化Bean时探测到是ApplicationListener则加入到监听器)、ApplicationContextAwareProcessor上下文注入扩展
  4. 添加servlet相关的BeanPostProcessor
  5. 实例化、初始化所有的BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor并执行
  6. 执行所有的BeanPostProcessor
  7. 添加事件广播器
  8. 添加MessageSource
  9. 添加监听器到事件广播器中
  10. 完成BeanFacroty的创建；初始化切面LoadTimeWeaverAware，冻结BeanDefinition，初始化所有非懒加载的单例bean
  11. 完成刷新；发布上下文刷新完成事件