springboot启动分析(一)

调用层级图

首先双手奉上调用关系层级图

@SpringBootApplication
    |--@SpringBootConfiguration
    |--@EnableAutoConfiguration
        |--@Import(AutoConfigurationImportSelector.class)
        

SpringApplication#构造函数
    |--new SpringApplication():
        |--deduceWebApplicationType():WebApplicationType
        |--setInitializers():META-INF/spring.factories中注册所有的ApplicationListener
        |--setListeners():
        |--deduceMainApplicationClass():Class<?>
        

SpringApplication#run
    |--SpringApplication#configureHeadlessProperty():
    |--SpringApplication#getRunListeners():返回SpringApplicationRunListeners
        |--SpringApplicationRunListeners#构造函数：是SpringApplicationRunListener的集合。
            |--SpringApplication#getSpringFactoriesInstances():
                |--SpringFactoriesLoader#loadFactoryNames():EventPublishingRunListener从META-INF/spring.factories文件中获取SpringApplicationRunListener,这个时候实例化EventPublishingRunListener
                    |--EventPublishingRunListener#xxxxx:pubilshEvent
    
    |--SpringApplicationRunListeners#starting():
        |--SpringApplicationRunListener#starting()  
    |--DefaultApplicationArguments#构造函数():ApplicationArguments
    |--SpringApplication#prepareEnvironment(listeners,applicationArguments):ConfigurableEnvironment
    |--SpringApplication#configureIgnoreBeanInfo(environment):
    |--SpringApplication#printBanner(environment):
    |--SpringApplication#createApplicationContext():ConfigurableApplicationContext
    |--SpringApplication#getSpringFactoriesInstances():exceptionReporters
    |--SpringApplication#prepareContext()
    |--SpringApplication#refreshContext()
    |--SpringApplication#afterRefresh()
    |--StartupInfoLogger#构造函数()
    |--SpringApplicationRunListeners#started()
    |--SpringApplication#callRunners():
    |--SpringApplicationRunListeners#running()

main函数

SpringApplication.run(SampleBootstrap.class, args)

跟进这个函数，我们看到如下方法：

public static ConfigurableApplicationContext run(Class<?>[] primarySources,
            String[] args) {
        return new SpringApplication(primarySources).run(args);
    }

关于这个我们方法我们拆开来看：
- new SpringApplication();
- SpringApplication.run();

SpringApplicaiton实例化

最终调用的是这个方法：

/**
     * Create a new {@link SpringApplication} instance. The application context will load
     * beans from the specified primary sources (see {@link SpringApplication class-level}
     * documentation for details. The instance can be customized before calling
     * {@link #run(String...)}.
     * @param resourceLoader the resource loader to use
     * @param primarySources the primary bean sources
     * @see #run(Class, String[])
     * @see #setSources(Set)
     */

//第266行：创建一个SpringApplcation的实例
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        //这里resourceLoader是Null的。
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        //primarySources就是启动类，一个set集合，按照目前的的例子来说，就是SampleBootstrap.class
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        //【1】这里是推断应用类型(deduce：推断，大家要有一点英文的基础)。在方法中会根据classload进行推断，然后再逐个根据WEB_ENVIRONMENT_CLASSES这个变量进行推断，最后发现是个servlet。
        this.webApplicationType = deduceWebApplicationType();
        //【2】【3】这里有两个方法：先getSpringFactoriesInstances，后setInitializers
        //做了两件事：
        //1、加载了所有的/META-INF/spring.factories文件中的类
        //2、实例化6个接口，这6个接口是ApplicationContextInitializer的实现类，并放入到一个叫“initializers”的list中
        setInitializers((Collection) getSpringFactoriesInstances(
                ApplicationContextInitializer.class));
        //【4】这个方法将所有的ApplicationListener的实现类实例化到一个list中。
        //复用了上述的一个getSpringFactoriesInstances，这个类直接从cache中取/META-INF/spring.factories中的类。
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        //【5】实例化当前的类
        this.mainApplicationClass = deduceMainApplicationClass();
    }

【1】：这个里面用到了ClassUtils.isPresent(String className, @Nullable ClassLoader classLoader),这个方法用来判断给定的classname是否能被classloader加载。由于classloader为Null，所以本流程走到最后返回的是servlet。顺便说一句，这里有reactive的返回结果，是响应式编程。
【2】：首先看下getSpringFactoriesInstances这个方法：
这个方法结束后，把所有的/META-INF/spring.factories文件中的类加载进了缓存。

//第438行：type->ApplicationContextInitializer类，parameterTypes->new Class<?>[]
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
            Class<?>[] parameterTypes, Object... args) {
        //获取当前的classloader对象：AppClassLoader
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        // Use names and ensure unique to protect against duplicates
        //用给定的classLoader加载继承了ApplicationContextInitializer的工厂类。
        //1、加载所有的/META-INF/spring.factories文件中的类，放入到一个LinkedMultiValueMap中，同时将这个map和对应的classloader放入到一个cache中，这个cache也是map
        //2、返回result，从map中获取给定的类型对应的类，这里是ApplicationContextInitializer类。
        //3、从最终结果来看，这个接口的6个实现类都加载到了这个叫“names”的LinkedHashSet中,如下图2-1
        Set<String> names = new LinkedHashSet<>(
                SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        //【2-1】这个方法很简单，就是实例化刚才到那几个实现了ApplicationContextInitializer接口的6个类，然后放入到一个list中返回。
        List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
                classLoader, args, names);
        //排序，根据Order。这个Comparator继承了OrderComparator
        AnnotationAwareOrderComparator.sort(instances);
        //最后返回排序结果。
        return instances;
    }

init-classloader.png

【2-1】createSpringFactoriesInstances方法，只是实例化刚才到6个类，这里可以学习下如何通过反射来实例化。

private <T> List<T> createSpringFactoriesInstances(Class<T> type,
            Class<?>[] parameterTypes, ClassLoader classLoader, Object[] args,
            Set<String> names) {
        List<T> instances = new ArrayList<>(names.size());
        for (String name : names) {
            try {
                Class<?> instanceClass = ClassUtils.forName(name, classLoader);
                Assert.isAssignable(type, instanceClass);
                Constructor<?> constructor = instanceClass
                        .getDeclaredConstructor(parameterTypes);
                T instance = (T) BeanUtils.instantiateClass(constructor, args);
                instances.add(instance);
            }
            catch (Throwable ex) {
                throw new IllegalArgumentException(
                        "Cannot instantiate " + type + " : " + name, ex);
            }
        }
        return instances;
    }

【3】setInitializers方法(第1203行代码)：
这个方法比较简单，就是把刚才到ApplicationContextInitializer放入到一个initializers的List中。

/**
     * Sets the {@link ApplicationContextInitializer} that will be applied to the Spring
     * {@link ApplicationContext}.
     * @param initializers the initializers to set
     */
    public void setInitializers(
            Collection<? extends ApplicationContextInitializer<?>> initializers) {
        this.initializers = new ArrayList<>();
        this.initializers.addAll(initializers);
    }

【4】实例化的listeners包括如下：

org.springframework.context.ApplicationListener=\
org.springframework.boot.ClearCachesApplicationListener,\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.ConfigFileApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener,\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

ClearCachesApplicationListener: ContextRefreshedEvent
ParentContextCloserApplicationListener: ParentContextAvailableEvent
FileEncodingApplicationListener: ApplicationEnvironmentPreparedEvent
AnsiOutputApplicationListener: ApplicationEnvironmentPreparedEvent
ConfigFileApplicationListener: ApplicationEvent
DelegatingApplicationListener: ApplicationEvent
ClasspathLoggingApplicationListener: ApplicationEvent
LoggingApplicationListener: ApplicationEvent
LiquibaseServiceLocatorApplicationListener: ApplicationStartingEvent

【5】spring运用RuntimeException().getStackTrace()推断出当前运行的类：本例是SampleBootstrap.class，并通过反射实例化。

private Class<?> deduceMainApplicationClass() {
        try {
            StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
            for (StackTraceElement stackTraceElement : stackTrace) {
                if ("main".equals(stackTraceElement.getMethodName())) {
                    return Class.forName(stackTraceElement.getClassName());
                }
            }
        }
        catch (ClassNotFoundException ex) {
            // Swallow and continue
        }
        return null;
    }

到此为止，SpringApplication类实例化完成，这里总结下总共做了几件事情：
1、确定下应用的类型是servlet
2、加载了所有的/META-INF/spring.factories文件中的类
3、实例化了ApplicationContextInitializer的实现类
4、实例化了ApplicationListener的实现类
5、确定了当前运行的类，并实例化通过反射。

关于@SpringBootApplication注解

@SpringBootApplication
    |--@ComponentScan
    |--@SpringBootConfiguration
    |--@EnableAutoConfiguration
        |--@Import(AutoConfigurationImportSelector.class)

我们可以看到，这个注解，内部其实是这三个注解的组合。我们依次来分析这个注解的作用。