SpringBoot启动类SpringApplication源码

创建一个SpringBoot应用启动类的两个关键点

• 1. 在main方法中调用 SpringApplication.run(Class<?> primarySource, String... args)
• 2. 在启动类上添加@SpringBootApplication注解

下面针对以上两点对SpringApplication源码进行解读，首先来看SpringApplication的静态run方法

/**
     * Static helper that can be used to run a {@link SpringApplication} from the
     * specified source using default settings.
     * @param primarySource the primary source to load
     * @param args the application arguments (usually passed from a Java main method)
     * @return the running {@link ApplicationContext}
     */
    public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
        return run(new Class<?>[] { primarySource }, args);
    }

    /**
     * Static helper that can be used to run a {@link SpringApplication} from the
     * specified sources using default settings and user supplied arguments.
     * @param primarySources the primary sources to load
     * @param args the application arguments (usually passed from a Java main method)
     * @return the running {@link ApplicationContext}
     */
    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        return new SpringApplication(primarySources).run(args);
    }

可以看出第一个静态run方法是对第二个静态run方法的调用，来看看第二个静态run方法，这个方法通过SpringApplication对象的构造方法创建了一个SpringApplication的对象实例，并调用了SpringApplication的实例方法run(args[])。那么SpringApplication构造做了那些工作呢？

/**
     * 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 primarySources the primary bean sources
     * @see #run(Class, String[])
     * @see #SpringApplication(ResourceLoader, Class...)
     * @see #setSources(Set)
     */
    public SpringApplication(Class<?>... primarySources) {
        this(null, primarySources);
    }

    /**
     * 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)
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = deduceMainApplicationClass();
    }

通过上面的代码可以看出SpringApplication主要做了一下几件事情：

• 确定该应用的源。
• 根据类路径中引入的web组件库推断出当前web环境的类型，具体推断过程参考WebApplicationType枚举类的静态deduceFromClasspath()方法。
• 将所有实现了ApplicationContextInitializer接口的实现类进行实例化。
• 将所有实现了ApplicationListener接口的实现类进行实例化。
• 通过当前线程的堆栈信息推断出mainApplicationClass。

下面重点关注ApplicationContextInitializer、ApplicationListener接口实现类的实例化过程。即对SpringApplicationget的SpringFactoriesInstances方法的调用。

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
        return getSpringFactoriesInstances(type, new Class<?>[] {});
    }

    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
        ClassLoader classLoader = getClassLoader();
        // Use names and ensure unique to protect against duplicates
        Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }

实例化的过程利用了java的反射机制，具体实现参考下面的代码。

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;
    }

这段代码就是java反射的具体使用，没有特别需要说明的地方，下面主要分析一下getSpringFactoriesInstances()方法中的SpringFactoriesLoader.loadFactoryNames(type, classLoader)这句代码。

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
    }

    private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        MultiValueMap<String, String> result = cache.get(classLoader);
        if (result != null) {
            return result;
        }

        try {
            Enumeration<URL> urls = (classLoader != null ?
                    classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                    ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
            result = new LinkedMultiValueMap<>();
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                for (Map.Entry<?, ?> entry : properties.entrySet()) {
                    String factoryTypeName = ((String) entry.getKey()).trim();
                    for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
                        result.add(factoryTypeName, factoryImplementationName.trim());
                    }
                }
            }
            cache.put(classLoader, result);
            return result;
        }
        catch (IOException ex) {
            throw new IllegalArgumentException("Unable to load factories from location [" +
                    FACTORIES_RESOURCE_LOCATION + "]", ex);
        }
    }

上面这段源码中Enumeration<URL> urls = (classLoader != null ?classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION))这句代码是一个从spring.factories中加载资源，并将指定类型的资源从Map中取出，这段代码的目的就是取出spring.factories中配置的ApplicationListener接口的实现了类和ApplicationContextInitializer接口实现类的集合，并将其实例化。

构造之后的run()方法解析

public ConfigurableApplicationContext run(String... args) {
                StopWatch stopWatch = new StopWatch();
                stopWatch.start();
                ConfigurableApplicationContext context = null;
                // 创建一个SpringBoot异常报告集合
                Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
                configureHeadlessProperty();
                SpringApplicationRunListeners listeners = getRunListeners(args);
                // 1. 发布一个应用启动事件
                listeners.starting();
                try {
                    ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
                    // 2. 根据当前ClassPath的类型创建一个应用启动环境，并发布一个环境准备事件 listeners.environmentPrepared(environment);
                    ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
                    // 配置启动环境的Bean信息忽略参数
                    configureIgnoreBeanInfo(environment);
                    // 配置应用启动环境的Banner，Banner打印机制是在环境准备完成之后进行的
                    Banner printedBanner = printBanner(environment);
                    // 3. 根据当前ClassPath环境创建ApplicationContext
                    context = createApplicationContext();
                    // 实例化异常报告类
                    exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                            new Class[] { ConfigurableApplicationContext.class }, context);
                    // 4. 准备ApplicationContext,同时发布上下文准备事件和上下文载入事件，这一步同时准备和载入上下文
                    prepareContext(context, environment, listeners, applicationArguments, printedBanner);
                    // 刷新应用上下文
                    refreshContext(context);
                    afterRefresh(context, applicationArguments);
                    stopWatch.stop();
                    if (this.logStartupInfo) {
                        new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
                   // 5. 发布应用启动成功事件              }
                    listeners.started(context);
                    // 调用所有实现了ApplicationRunner接口和CommandRunner接口的实例
                    callRunners(context, applicationArguments);*        }
                catch (Throwable ex) {
                    // 6. 如果整个过程包错，则会发布启动异常的错误报告，并发布启动失败事件
                    handleRunFailure(context, ex, exceptionReporters, listeners);
                    throw new IllegalStateException(ex);
                }
 
                try {
                    // 7.发布应用程序运行中事件
                    listeners.running(context);
                }
                catch (Throwable ex) {
                    handleRunFailure(context, ex, exceptionReporters, null);
                    throw new IllegalStateException(ex);
                }
                return context;
            }

run方法做了一下几件事情

• 开启了应用停止监控
• 配置了headless系统环境
• 实例化了{@link org.springframework.boot.SpringApplicationRunListener}监听器，并在SpringApplication启动过程中发布相应的事件
• 创建并准备了应用启动的环境，如果是Servlet环境则创建StandardServletEnvironment实例，如果是Reactive
  环境则创建StandardReactiveWebEnvironment环境，默认则创建StandardEnvironment环境
• 实例化了{@link org.springframework.boot.SpringBootExceptionReporter}
• 创建并准备了应用上下文环境，并在期间执行了所有{@link ApplicationContextInitializer}的接口实现的调用。
• 刷新了应用上下文环境
• 调用了{@link org.springframework.boot.ApplicationRunner}和{@link org.springframework.boot.CommandLineRunner}实现类的run方法
• 当启动报错时，处理了错误报告

SpringBoot应用上下文的实例化过程，代码如下：

protected ConfigurableApplicationContext createApplicationContext() {
        Class<?> contextClass = this.applicationContextClass;
        if (contextClass == null) {
            try {
                switch (this.webApplicationType) {
                case SERVLET:
                    contextClass = Class.forName(DEFAULT_SERVLET_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);
    }

这段代码通过反射的方式实例化了相应的上下文，本例中我们使用的是webServlet环境所以实例化的是{@link org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext}容器。到此SpringBoot的启动流程差不多就完成了。