spring boot启动过程

spring已经成为实时上的J2EE标准，spring boot并没有提供太多新的特性，而是发现了大部分的模板配置，没必要重复的配置，而且现在脚本语言大行其道，并且微服务的诞生让更多项目的构建和部署，spring这些大量的配置文件带来很多不必要的工作量。

spring boot顾名思义能够自动化的启动一个应用。以spring-boot-starter-web为例，它其实就是引入了一个组合pom.xml。它引入的pom如下：

<!-- spring web 相关jar-->
    <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- 内置 tomcat 支持  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </dependency>
        <!-- 默认orm 采用hibernate -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>

spring-boot-starter能够引入spring核心的包，包括core, webmvc, aop, context,orm 等等。默认采用了hibernate去完成JPA相关工作。整个自动化过程主要再spring-boot-*包下面。

我们看下spring-boot-starter主要引入了：

<!-- spring boot 核心支持 -->
<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot</artifactId>
        </dependency>
        <!-- spring boot默认配置支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <!-- 默认日志支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- yaml格式支持 -->
        <dependency>
            <groupId>org.yaml</groupId>
            <artifactId>snakeyaml</artifactId>
            <scope>runtime</scope>
        </dependency>

整个自动化启动需要这几个组件。由于篇幅有限，我们通过应用的启动过程来跟踪包的作用。

一般我们应用的入口是SpringApplication，这个在根包下面。
我们启动一个应用如下：

public static void main(String[] args) {
new SpringApplication(ApplicationBoot.class).run(args);
}

它的构造函数：

/**
     * Create a new {@link SpringApplication} instance. The application context will load
     * beans from the specified sources (see {@link SpringApplication class-level}
     * documentation for details. The instance can be customized before calling
     * {@link #run(String...)}.
     * @param sources the bean sources
     * @see #run(Object, String[])
     * @see #SpringApplication(ResourceLoader, Object...)
     */
    public SpringApplication(Object... sources) {
        initialize(sources);
    }

构造一个spring应用实例，从指定的源加载。接着调用initialize()初始化整个应用。源可以是一个或者多个。初始化：

private void initialize(Object[] sources) {
        if (sources != null && sources.length > 0) {
            this.sources.addAll(Arrays.asList(sources));
        }
        this.webEnvironment = deduceWebEnvironment();
        setInitializers((Collection) getSpringFactoriesInstances(
                ApplicationContextInitializer.class));
            // 这里获取所有的ApplicationListener(框架自带或则用户自定义)
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = deduceMainApplicationClass();
    }

这配置初始化的监听器，能够让用户可以跟踪整个应用的加载过程。准备好了就可以调用应用的run(args)函数。

/**
     * Run the Spring application, creating and refreshing a new
     * {@link ApplicationContext}.
     * @param args the application arguments (usually passed from a Java main method)
     * @return a running {@link ApplicationContext}
     */
    public ConfigurableApplicationContext run(String... args) {
        // 计时器，能够跟踪应用的运行时间（主要开发环境用）
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        FailureAnalyzers analyzers = null;
        configureHeadlessProperty();
        // 获取所有监听器，能够在应用的启动阶段收到通知（类似观察者模式）
        SpringApplicationRunListeners listeners = getRunListeners(args);
        listeners.starting();
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args);
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                    applicationArguments);
            // 这里是一个彩蛋，可以在resources文件夹自定义banner.txt来覆盖默认启动的spring LOGO...
            Banner printedBanner = printBanner(environment);
            // 反射创建createApplicationContext容器。spring容器核心，注意这里这个ApplicationContext还是一个不能用的容器，等待后面的启动工作
            context = createApplicationContext();
            analyzers = new FailureAnalyzers(context);
            // 做容器的初始化工作
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);
            // 这里是spring容器启动
            refreshContext(context);
            afterRefresh(context, applicationArguments);
            listeners.finished(context, null);
            stopWatch.stop();
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass)
                        .logStarted(getApplicationLog(), stopWatch);
            }
            return context;
        }
        catch (Throwable ex) {
            handleRunFailure(context, listeners, analyzers, ex);
            throw new IllegalStateException(ex);
        }
    }

上面有两个过程是比较重要的，一个是prepareContext(context, environment, listeners, applicationArguments,printedBanner);一个是refreshContext(context);

对spring加载过程熟悉的读者肯定很熟悉refresh()函数。这个函数定义了整个容器加载的流程，其中包含一些模板方法，但是整个流程的骨架已经清晰可见。我们还是先讲讲prepareContext

private void prepareContext(ConfigurableApplicationContext context,
            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments, Banner printedBanner) {
        context.setEnvironment(environment);
        // 这里能够干预容器的加载，这是一个protected函数，意思就是可以继承并重写这个函数，如果有必要，你可以在这里做任何容器加载前的事情
        postProcessApplicationContext(context);
        // 调用定义的初始化类，这个在前面的initialize设置的
        applyInitializers(context);
        // 通知监听器
        listeners.contextPrepared(context);
        if (this.logStartupInfo) {
            logStartupInfo(context.getParent() == null);
            logStartupProfileInfo(context);
        }
context.getBeanFactory().registerSingleton("springApplicationArguments",
                applicationArguments);
        if (printedBanner != null) {
            context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
        }

        // Load the sources
        Set<Object> sources = getSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        // 加载bean读取组件，让应用能够读取xml javaConfig等不同形式定义的bean
        load(context, sources.toArray(new Object[sources.size()]));
        // 加载完毕通知监听器
        listeners.contextLoaded(context);
    }

接下来开始加载bean并完成容器的启动工作：refreshContext(context); 可以参考博主另一文章：容器加载

好了，然后整个过程结束，等等，说好的spring boot呢，请不要急。我们一般在source，也就是启动应用的类前面加一个@SpringBootApplication，打开它的源码：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
 // ...
}

它是一个组合注解，还包含了EnableAutoConfiguration。它的字面意思就是自动配置。我很想把它的JavaDoc放出来：

/**
* Enable auto-configuration of the Spring Application Context, attempting to guess and
* configure beans that you are likely to need. Auto-configuration classes are usually
* applied based on your classpath and what beans you have defined. For example, If you
* have {@code tomcat-embedded.jar} on your classpath you are likely to want a
* {@link TomcatEmbeddedServletContainerFactory} (unless you have defined your own
* {@link EmbeddedServletContainerFactory} bean).
*

* Auto-configuration tries to be as intelligent as possible and will back-away as you
* define more of your own configuration. You can always manually {@link #exclude()} any
* configuration that you never want to apply (use {@link #excludeName()} if you don’t
* have access to them). You can also exclude them via the
* {@code spring.autoconfigure.exclude} property. Auto-configuration is always applied
* after user-defined beans have been registered.
*

* The package of the class that is annotated with {@code @EnableAutoConfiguration} has
* specific significance and is often used as a ‘default’. For example, it will be used
* when scanning for {@code @Entity} classes. It is generally recommended that you place
* {@code @EnableAutoConfiguration} in a root package so that all sub-packages and classes
* can be searched.
*

* Auto-configuration classes are regular Spring {@link Configuration} beans. They are
* located using the {@link SpringFactoriesLoader} mechanism (keyed against this class).
* Generally auto-configuration beans are {@link Conditional @Conditional} beans (most
* often using {@link ConditionalOnClass @ConditionalOnClass} and
* {@link ConditionalOnMissingBean @ConditionalOnMissingBean} annotations).
*
* @author Phillip Webb
* @author Stephane Nicoll
* @see ConditionalOnBean
* @see ConditionalOnMissingBean
* @see ConditionalOnClass
* @see AutoConfigureAfter
*/
开启自动配置spring应用，能够尝试去“猜测“你可能需要的配置，自动配置的类会作用在你的类路径基础上。举个例子，如果你有tomcat-embedded.jar,在你的类路径里，你可能会需要TomcatEmbeddedServletContainerFactory和EmbeddedServletContainerFactory这两个bean。
自动配置会尽可能智能的帮助你完成默认配置，你也可能会不希望使用很多默认配置，你可以通过excelude去移除自动配置支持。
注解本身不起任何作用，需要有对应的“注解处理器“。那我们就来找处理@EnableAutoConfiguration的处理器。自动化配置总是在bean定义被注册之后才会应用。在你标注了@EnableAutoConfiguration这个注解的类所在的包（包含子包）能够尽量的使用默认值。例如你扫描包的时候会以这个注解所在的包为根包开始扫描。自动配置类通常也是个spring bean。可以使用@Conditional来控制装配。

注解本身没有什么作用，只是个元数据而已，要配上注解处理器才能真正的起作用。AutoConfigurationImportSelector就是这个处理器.它的selectImports重写了ImportSelector，能够自动引入这些自动化配置的类，这些类会自动的初始化很多默认值。就此完成了自动化配置工作。