版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woshilijiuyi/article/details/82350057
微信公众号：吉姆餐厅ak
学习更多源码知识，欢迎关注。

SpringBoot2 | SpringBoot启动流程源码分析（一）

SpringBoot2 | SpringBoot启动流程源码分析（二）

SpringBoot2 | @SpringBootApplication注解 自动化配置流程源码分析（三）

SpringBoot2 | SpringBoot Environment源码分析（四）

SpringBoot2 | SpringBoot自定义AutoConfiguration | SpringBoot自定义starter（五）

SpringBoot2 | SpringBoot监听器源码分析 | 自定义ApplicationListener（六）

SpringBoot2 | 条件注解@ConditionalOnBean原理源码深度解析（七）

SpringBoot2 | Spring AOP 原理源码深度剖析（八）

SpringBoot2 | SpingBoot FilterRegistrationBean 注册组件 | FilterChain 责任链源码分析（九）

SpringBoot2 | BeanDefinition 注册核心类 ImportBeanDefinitionRegistrar （十）

SpringBoot2 | Spring 核心扩展接口 | 核心扩展方法总结（十一）

继续上一篇博客的启动流程分析。

在上一篇SpringBoot | SpringBoot2 | SpringBoot2启动流程源码分析（一）中我们提到springBoot启动流程大致有以下7点：

第一步：获取并启动监听器
第二步：构造容器环境
第三步：创建容器
第四步：实例化SpringBootExceptionReporter.class，用来支持报告关于启动的错误
第五步：准备容器
第六步：刷新容器
第七步：刷新容器后的扩展接口
上一篇博客中分析了前面两点，今天继续分析后面四点。

第三步：创建容器
context = createApplicationContext();
1
继续跟进该方法：

    protected ConfigurableApplicationContext createApplicationContext() {
        Class<?> contextClass = this.applicationContextClass;
        if (contextClass == null) {
            try {
                switch (this.webApplicationType) {
                case SERVLET:
                    contextClass = Class.forName(DEFAULT_WEB_CONTEXT_CLASS);
                    break;
                case REACTIVE:
                    contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
                    break;
                default:
                    contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
                }
            }
            catch (ClassNotFoundException ex) {
                throw new IllegalStateException(
                        "Unable create a default ApplicationContext, "
                                + "please specify an ApplicationContextClass",
                        ex);
            }
        }
        return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
上面可以看出，这里创建容器的类型 还是根据webApplicationType进行判断的，上一篇已经讲述了该变量如何赋值的过程。因为该类型为SERVLET类型，所以会通过反射装载对应的字节码，如下：

public static final String DEFAULT_WEB_CONTEXT_CLASS = "org.springframework.boot."
            + "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";
1
2
该对象是springBoot2创建的容器，后续所有的操作都会基于该容器。

注意：在 springBoot2版本以前，该容器的名称为 AnnotationConfigServletWebServerApplicationContext，在最新的版本中才改名为 AnnotationConfigServletWebServerApplicationContext。
下面是该类的结构图：

具体作用后面会详细介绍。

第四步：报告错误信息
exceptionReporters = getSpringFactoriesInstances(
                    SpringBootExceptionReporter.class,
                    new Class[] { ConfigurableApplicationContext.class }, context);
1
2
3
这里还是以同样的方式获取 spring.factories文件中的指定类：

exceptionReporters = getSpringFactoriesInstances(
                    SpringBootExceptionReporter.class,
                    new Class[] { ConfigurableApplicationContext.class }, context);
1
2
3
该类主要是在项目启动失败之后，打印log：

    private void reportFailure(Collection<SpringBootExceptionReporter> exceptionReporters,
            Throwable failure) {
        try {
            for (SpringBootExceptionReporter reporter : exceptionReporters) {
                if (reporter.reportException(failure)) {
                    //上报错误log
                    registerLoggedException(failure);
                    return;
                }
            }
        }
        catch (Throwable ex) {
            // Continue with normal handling of the original failure
        }
        if (logger.isErrorEnabled()) {
            logger.error("Application run failed", failure);
            registerLoggedException(failure);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
第五步：准备容器
这一步主要是在容器刷新之前的准备动作。包含一个非常关键的操作：将启动类注入容器，为后续开启自动化配置奠定基础。

prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);
1
2
继续跟进该方法：

private void prepareContext(ConfigurableApplicationContext context,
            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments, Banner printedBanner) {
        //设置容器环境，包括各种变量
        context.setEnvironment(environment);
        //执行容器后置处理
        postProcessApplicationContext(context);
        //执行容器中的ApplicationContextInitializer（包括 spring.factories和自定义的实例）
        applyInitializers(context);
        //发送容器已经准备好的事件，通知各监听器
        listeners.contextPrepared(context);
        //打印log
        if (this.logStartupInfo) {
            logStartupInfo(context.getParent() == null);
            logStartupProfileInfo(context);
        }
        // Add boot specific singleton beans
        //注册启动参数bean，这里将容器指定的参数封装成bean，注入容器
        context.getBeanFactory().registerSingleton("springApplicationArguments",
                applicationArguments);
        //设置banner
        if (printedBanner != null) {
            context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
        }
        // Load the sources
        //获取我们的启动类指定的参数，可以是多个
        Set<Object> sources = getAllSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        //加载我们的启动类，将启动类注入容器
        load(context, sources.toArray(new Object[0]));
        //发布容器已加载事件。
        listeners.contextLoaded(context);
    }
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
来看一下上面的几个核心处理。

1）容器的后置处理：

    protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
        if (this.beanNameGenerator != null) {
            context.getBeanFactory().registerSingleton(
                    AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
                    this.beanNameGenerator);
        }
        if (this.resourceLoader != null) {
            if (context instanceof GenericApplicationContext) {
                ((GenericApplicationContext) context)
                        .setResourceLoader(this.resourceLoader);
            }
            if (context instanceof DefaultResourceLoader) {
                ((DefaultResourceLoader) context)
                        .setClassLoader(this.resourceLoader.getClassLoader());
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
这里默认不执行任何逻辑，因为beanNameGenerator和resourceLoader默认为空。之所以这样做，是springBoot留给我们的扩展处理方式，类似于这样的扩展，spring中也有很多。

2）加载启动指定类（重点）
这里会将我们的启动类加载spring容器beanDefinitionMap中，为后续springBoot 自动化配置奠定基础，springBoot为我们提供的各种注解配置也与此有关。

load(context, sources.toArray(new Object[0]));
1
    protected void load(ApplicationContext context, Object[] sources) {
        if (logger.isDebugEnabled()) {
            logger.debug(
                    "Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
        }
        BeanDefinitionLoader loader = createBeanDefinitionLoader(
                getBeanDefinitionRegistry(context), sources);
        if (this.beanNameGenerator != null) {
            loader.setBeanNameGenerator(this.beanNameGenerator);
        }
        if (this.resourceLoader != null) {
            loader.setResourceLoader(this.resourceLoader);
        }
        if (this.environment != null) {
            loader.setEnvironment(this.environment);
        }
        loader.load();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
这里参数即为我们项目启动时传递的参数：SpringApplication.run(SpringBootApplication.class, args);
由于我们指定了启动类，所以上面也就是加载启动类到容器。

需要注意的是，springBoot2会优先选择groovy加载方式，找不到再选用java方式。或许groovy动态加载class文件的性能更胜一筹。

    private int load(Class<?> source) {
        if (isGroovyPresent()
                && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
            // Any GroovyLoaders added in beans{} DSL can contribute beans here
            GroovyBeanDefinitionSource loader = BeanUtils.instantiateClass(source,
                    GroovyBeanDefinitionSource.class);
            load(loader);
        }
        if (isComponent(source)) {
            //以注解的方式，将启动类bean信息存入beanDefinitionMap
            this.annotatedReader.register(source);
            return 1;
        }
        return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
上面代码中启动类被加载到 beanDefinitionMap中，后续该启动类将作为开启自动化配置的入口，后面一篇文章我会详细的分析，启动类是如何加载，以及自动化配置开启的详细流程。

3）通知监听器，容器已准备就绪

listeners.contextLoaded(context);
1
主还是针对一些日志等监听器的响应处理。

第六步：刷新容器
执行到这里，springBoot相关的处理工作已经结束，接下的工作就交给了spring。

synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            /**
             * 刷新上下文环境
             * 初始化上下文环境，对系统的环境变量或者系统属性进行准备和校验
             * 如环境变量中必须设置某个值才能运行，否则不能运行，这个时候可以在这里加这个校验，
             * 重写initPropertySources方法就好了
             */
            prepareRefresh();
 
            // Tell the subclass to refresh the internal bean factory.
            /**
             * 初始化BeanFactory，解析XML，相当于之前的XmlBeanFactory的操作，
             */
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
            // Prepare the bean factory for use in this context.
            /**
             * 为上下文准备BeanFactory，即对BeanFactory的各种功能进行填充，如常用的注解@Autowired @Qualifier等
             * 设置SPEL表达式#{key}的解析器
             * 设置资源编辑注册器，如PerpertyEditorSupper的支持
             * 添加ApplicationContextAwareProcessor处理器
             * 在依赖注入忽略实现*Aware的接口，如EnvironmentAware、ApplicationEventPublisherAware等
             * 注册依赖，如一个bean的属性中含有ApplicationEventPublisher(beanFactory)，则会将beanFactory的实例注入进去
             */
            prepareBeanFactory(beanFactory);
 
            try {
                // Allows post-processing of the bean factory in context subclasses.
                /**
                 * 提供子类覆盖的额外处理，即子类处理自定义的BeanFactoryPostProcess
                 */
                postProcessBeanFactory(beanFactory);
 
                // Invoke factory processors registered as beans in the context.
                /**
                 * 激活各种BeanFactory处理器,包括BeanDefinitionRegistryBeanFactoryPostProcessor和普通的BeanFactoryPostProcessor
                 * 执行对应的postProcessBeanDefinitionRegistry方法 和  postProcessBeanFactory方法
                 */
                invokeBeanFactoryPostProcessors(beanFactory);
 
                // Register bean processors that intercept bean creation.
                /**
                 * 注册拦截Bean创建的Bean处理器，即注册BeanPostProcessor，不是BeanFactoryPostProcessor，注意两者的区别
                 * 注意，这里仅仅是注册，并不会执行对应的方法，将在bean的实例化时执行对应的方法
                 */
                registerBeanPostProcessors(beanFactory);
 
                // Initialize message source for this context.
                /**
                 * 初始化上下文中的资源文件，如国际化文件的处理等
                 */
                initMessageSource();
 
                // Initialize event multicaster for this context.
                /**
                 * 初始化上下文事件广播器，并放入applicatioEventMulticaster,如ApplicationEventPublisher
                 */
                initApplicationEventMulticaster();
 
                // Initialize other special beans in specific context subclasses.
                /**
                 * 给子类扩展初始化其他Bean
                 */
                onRefresh();
 
                // Check for listener beans and register them.
                /**
                 * 在所有bean中查找listener bean，然后注册到广播器中
                 */
                registerListeners();
 
                // Instantiate all remaining (non-lazy-init) singletons.
                /**
                 * 设置转换器
                 * 注册一个默认的属性值解析器
                 * 冻结所有的bean定义，说明注册的bean定义将不能被修改或进一步的处理
                 * 初始化剩余的非惰性的bean，即初始化非延迟加载的bean
                 */
                finishBeanFactoryInitialization(beanFactory);
 
                // Last step: publish corresponding event.
                /**
                 * 初始化生命周期处理器DefaultLifecycleProcessor，DefaultLifecycleProcessor含有start方法和stop方法，spring启动的时候调用start方法开始生命周期，
                 * spring关闭的时候调用stop方法来结束生命周期，通常用来配置后台程序，启动有一直运行，如一直轮询kafka
                 * 启动所有实现了Lifecycle接口的类
                 * 通过spring的事件发布机制发布ContextRefreshedEvent事件，以保证对应的监听器做进一步的处理，即对那种在spring启动后需要处理的一些类，这些类实现了
                 * ApplicationListener<ContextRefreshedEvent> ,这里就是要触发这些类的执行(执行onApplicationEvent方法)另外，spring的内置Event有ContextClosedEvent、ContextRefreshedEvent、ContextStartedEvent、ContextStoppedEvent、RequestHandleEvent
                 * 完成初始化，通知生命周期处理器lifeCycleProcessor刷新过程，同时发出ContextRefreshEvent通知其他人
                 */
                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
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
refresh方法在spring整个源码体系中举足轻重，是实现 ioc 和 aop的关键。上述流程，不是一篇博文能够展示清楚的，所以这里暂时不做展开。后续会有详细的介绍。

第七步：刷新容器后的扩展接口
protected void afterRefresh(ConfigurableApplicationContext context,
            ApplicationArguments args) {
    }
1
2
3
扩展接口，设计模式中的模板方法，默认为空实现。如果有自定义需求，可以重写该方法。比如打印一些启动结束log，或者一些其它后置处理。

springBoot2启动流程到这里就结束了。后续会对springBoot2的常用注解，及一些核心类进行介绍。

SpringBoot2 | SpringBoot启动流程源码分析（一）

SpringBoot2 | SpringBoot启动流程源码分析（二）

SpringBoot2 | @SpringBootApplication注解 自动化配置流程源码分析（三）

SpringBoot2 | SpringBoot Environment源码分析（四）

SpringBoot2 | SpringBoot自定义AutoConfiguration | SpringBoot自定义starter（五）

SpringBoot2 | SpringBoot监听器源码分析 | 自定义ApplicationListener（六）

SpringBoot2 | 条件注解@ConditionalOnBean原理源码深度解析（七）

文章最后发布于: 2018-09-03 16:01:43

————————————————
版权声明：本文为CSDN博主「张书康」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/woshilijiuyi/article/details/82350057