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，能够自动引入这些自动化配置的类，这些类会自动的初始化很多默认值。就此完成了自动化配置工作。