springboot情操陶冶-SpringApplication(一)

SpringApplication是所有springboot的入口类，分析此类有助于我们了解springboot的工作机制。本文以2.0.3.REALEASE版本作分析

调用实例如下

package com.example.demospringbootweb;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplicationpublic class DemoSpringbootWebApplication {    public static void main(String[] args) {
        SpringApplication.run(DemoSpringbootWebApplication.class, args);
    }
}

调用的是SpringApplication.run()方法进行应用程序的启动。代码很简单也容易让用户上手，笔者这就进入其具体的类以探瑰宝。

先看下其官方注释，有助于我们入门。由于注释过长，笔者此处只对其主要内容作下翻译总结

1. 可以简单的通过main()函数来辅助启动一个spring应用程序。默认情况下其会按照以下步骤来辅助我们创建的应用

• 创建一个关联的ApplicationContext实例

• 注册CommandLinePropertySource实例暴露命令行的参数作为spring的属性

• 刷新ApplicationContext，并加载所有的单例beans

• 触发实现了CommandLineRunner的实例beans

• AnnotatedBeanDefinitionReader加载指定的类

• XmlBeanDefinitionReader加载XML的配置信息或者GroovyBeanDefinitionReader加载groovy脚本资源

• ClassPathBeanDefinitionScanner扫描指定的包加载相应bean

过于抽象，笔者继续通过源码来对上述的内容进行回顾

    
    @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));        // 推断是否为web环境
        this.webApplicationType = deduceWebApplicationType();        // 加载ApplicationContextInitializer接口类
        setInitializers((Collection) getSpringFactoriesInstances(
                ApplicationContextInitializer.class));        // 加载ApplicationListener接口类
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));        // 推断主函数类
        this.mainApplicationClass = deduceMainApplicationClass();
    }

对上述的注释作下简单的解释

推断是否为web环境，源码如下

    private WebApplicationType deduceWebApplicationType() {        if (ClassUtils.isPresent(REACTIVE_WEB_ENVIRONMENT_CLASS, null)
                && !ClassUtils.isPresent(MVC_WEB_ENVIRONMENT_CLASS, null)) {            return WebApplicationType.REACTIVE;
        }        for (String className : WEB_ENVIRONMENT_CLASSES) {            if (!ClassUtils.isPresent(className, null)) {                return WebApplicationType.NONE;
            }
        }        return WebApplicationType.SERVLET;
    }

从代码层看总共有三种应用类型，也代表了三个环境类型

• WebApplicationType.REACTIVE reactive web应用(classpath环境下须有org.springframework.web.reactive.DispatcherHandler)

• WebApplicationType.SERVLET servlet web应用(classpath环境下存在javax.servlet.Servlet或者org.springframework.web.context.ConfigurableWebApplicationContext)

• WebApplicationType.NONE 简单的JAVA应用(classpath环境不存在上述的类)

推断主函数类，源码如下

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

很简单，就是寻找哪个类下含有main方法，此处和我们常用的启动类不谋而合

找寻相应的接口实现类，源码如下

    private  Collection getSpringFactoriesInstances(Class type,
            Class[] parameterTypes, Object... args) {        // 上下文classLoader
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();        // 通过SpringFactoriesLoader来加载相应的类
        Set names = new linkedHashSet<>(
                SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        List instances = createSpringFactoriesInstances(type, parameterTypes,
                classLoader, args, names);
        AnnotationAwareOrderComparator.sort(instances);        return instances;
    }

进而查看相应的静态方法SpringFactoriesLoader.loadFactoryNames()，源码如下

    public static List loadFactoryNames(Class factoryClass, @Nullable ClassLoader classLoader) {
        String factoryClassName = factoryClass.getName();        // 关键处理类
        return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    }

关键处理类出来了，源码跟上

    private static Map> loadSpringFactories(@Nullable ClassLoader classLoader) {        // 缓存处理
        MultiValueMap result = cache.get(classLoader);        if (result != null) {            return result;
        }        try {            // 找寻所有classpath下的"meta-INF/spring.factories"文件
            Enumeration 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()) {                    // 对含有,的进行分隔并转为list集合
                    List factoryClassNames = Arrays.asList(
                            StringUtils.commaDelimitedListToStringArray((String) entry.getValue()));
                    result.addAll((String) entry.getKey(), factoryClassNames);
                }
            }
            cache.put(classLoader, result);            return result;
        }        catch (IOException ex) {            throw new IllegalArgumentException("Unable to load factories from location [" +
                    FACTORIES_RESOURCE_LOCATION + "]", ex);
        }
    }

由此我们得出结论，classpath环境下所有含meta-INF/spring.factories的文件，里面约定了默认的实现。笔者以spring-boot-2.0.3.REALEASE.jar为例

# PropertySource Loaders
org.springframework.boot.env.PropertySourceLoader=
org.springframework.boot.env.PropertiesPropertySourceLoader,
org.springframework.boot.env.YamlPropertySourceLoader

# Run Listeners
org.springframework.boot.SpringApplicationRunListener=
org.springframework.boot.context.event.EventPublishingRunListener

# Error Reporters
org.springframework.boot.SpringBootExceptionReporter=
org.springframework.boot.diagnostics.FailureAnalyzers

# Application Context Initializers
org.springframework.context.ApplicationContextInitializer=
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,
org.springframework.boot.context.ContextIdApplicationContextInitializer,
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

# Application 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

# Environment Post Processors
org.springframework.boot.env.EnvironmentPostProcessor=
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,
org.springframework.boot.env.SpringApplicationJsonEnvironmentPostProcessor,
org.springframework.boot.env.SystemEnvironmentPropertySourceEnvironmentPostProcessor

# Failure Analyzers
org.springframework.boot.diagnostics.FailureAnalyzer=
org.springframework.boot.diagnostics.analyzer.BeanCurrentlyInCreationFailureAnalyzer,
org.springframework.boot.diagnostics.analyzer.BeanNotOfRequiredTypeFailureAnalyzer,
org.springframework.boot.diagnostics.analyzer.BindFailureAnalyzer,
org.springframework.boot.diagnostics.analyzer.BindValidationFailureAnalyzer,
org.springframework.boot.diagnostics.analyzer.UnboundConfigurationPropertyFailureAnalyzer,
org.springframework.boot.diagnostics.analyzer.ConnectorStartFailureAnalyzer,
org.springframework.boot.diagnostics.analyzer.NoUniqueBeanDefinitionFailureAnalyzer,
org.springframework.boot.diagnostics.analyzer.PortInUseFailureAnalyzer,
org.springframework.boot.diagnostics.analyzer.ValidationExceptionFailureAnalyzer,
org.springframework.boot.diagnostics.analyzer.InvalidConfigurationPropertyNameFailureAnalyzer,
org.springframework.boot.diagnostics.analyzer.InvalidConfigurationPropertyValueFailureAnalyzer

# FailureAnalysisReporters
org.springframework.boot.diagnostics.FailureAnalysisReporter=
org.springframework.boot.diagnostics.LoggingFailureAnalysisReporter

因此SpringApplication构造函数中加载的ApplicationContextInitializer类有如下

• ConfigurationWarningsApplicationContextInitializer (对ComponentScan指定的值为"org"等进行报警输出)

• ContextIdApplicationContextInitializer (创建默认名为application的ContextId对象，也可通过spring.application.name指定)

• DelegatingApplicationContextInitializer (对context.initializer.classes指定的class集合进行加载)

• ServerPortInfoApplicationContextInitializer (将local.server.port设置为指定的web端口，默认为8080)

而加载的ApplicationListener类有如下

• ClearCachesApplicationListener (反射工具缓存清空事件)

• ParentContextCloserApplicationListener (父ApplicationContext关闭事件)

• FileEncodingApplicationListener (系统变量配置的file.encoding值是否与环境变量spring.mandatory-file-encoding一致事件)

• AnsiOutputApplicationListener (控制台彩色输出事件，可通过spring.output.ansi.enabled来指定)

• ConfigFileApplicationListener (读取spring.profile.active/spring.profile.include配置)

• DelegatingApplicationListener (委托事件处理类)

• ClasspathLoggingApplicationListener (打印classpath信息，级别为debug)

• LoggingApplicationListener (日志处理事件)

• LiquibaseServiceLocatorApplicationListener (classpath是否存在liquibase的CustomResolverServiceLocator类判断事件)

由此SpringApplication构造函数完成了一些必要的初始化，重点在于ApplicationContextInitializer和ApplicationListener接口类。并且通过构造函数反射来进行实例化

限于篇幅过长，笔者将对SpringApplication#run()方法的具体解析放于下一章节来分析

作者：南柯问天  出处：http://www.cnblogs.com/question-sky/ 本文版权归本人和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

原文出处：http://www.cnblogs.com/question-sky/p/9366500.html