Springboot启动流程：构造SpringApplication实例对象

淡淡的烟草味﹌ 2022-12-03 08:39 120阅读 0赞

### Springboot启动流程：构造SpringApplication实例对象 ###

*   *  推断当前应用类型
     *  设置初始化器、监听器
     *  推断当前main方法所在的主类
     *  总结

springboot项目从一个main方法开始，main方法将会调用SpringApplication的run方法开始springboot的启动流程。所以，本文即从构造SpringApplication对象开始。

下面来一起看下run()：

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

run()方法中构造了一个SpringApplication对象实例，然后调用了SpringApplication对象的run()方法并返回一个ConfigurableApplicationContext对象实例。  
**需要注意的是：primarySource是main方法所在的类，该类后续将被作为主要的资源来使用，比如通过该类获取到basePackage；**  
首先看下怎么构造一个SpringApplication对象实例：

public SpringApplication(Class<?>... primarySources) { 
    	this(null, primarySources);
    }
    @SuppressWarnings({  "unchecked", "rawtypes" })
    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) { 
         // 设置资源加载器
         this.resourceLoader = resourceLoader; 
         // 设置主要资源类
         this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
         // 推断当前应用的类型
         this.webApplicationType = WebApplicationType.deduceFromClasspath();
     
         // 设置ApplicationContext的初始化器
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        // 设置Application监听器
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    
        // 推断并设置主类
        this.mainApplicationClass = deduceMainApplicationClass();
    }

构造过程主要包含：

1）推断当前应用类型

2）设置ApplicationContext初始化器、Application监听器

3）根据堆栈来推断当前main方法所在的主类

## 推断当前应用类型 ##

WebApplicationType是一个枚举对象，枚举了可能的应用类型

public enum WebApplicationType { 
     
         /** * 非web应用类型，不启动web容器 */
         NONE,
         /** * 基于Servlet的web应用，将启动Servlet的嵌入式web容器 */
        SERVLET,
        /** * 基于reactive的web应用，将启动reactive的嵌入式web容器 */
        REACTIVE;
    
        // 省略...
    }

deduceFromClasspath方法会推断出当前应用属于以上三个枚举实例的哪一个，具体的判断逻辑如下：

static WebApplicationType deduceFromClasspath() { 
         // 类路径中是否包含DispatcherHandler，且不包含DispatcherServlet，也不包含ServletContainer，那么是reactive应用
         if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
                 && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) { 
             return WebApplicationType.REACTIVE;
         }
         // 如果Servlet或者ConfigurableWebApplicationContext不存在，那么就是非web应用
         for (String className : SERVLET_INDICATOR_CLASSES) { 
             if (!ClassUtils.isPresent(className, null)) { 
                return WebApplicationType.NONE;
            }
        }
        // 否则都是Servlet的web应用
        return WebApplicationType.SERVLET;
    }

推断过程是根据类路径中是否有指示性的类。

## 设置初始化器、监听器 ##

首先看下初始化器：

getSpringFactoriesInstances(ApplicationContextInitializer.class);

一直向下跟踪会找到下面相关的代码：

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) { 
        // 先试着取缓存
        MultiValueMap<String, String> result = cache.get(classLoader);
        if (result != null) { 
            return result;
        }
    
        try { 
            // 获取所有spring.factories的URL
            Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
            result = new LinkedMultiValueMap<>();
            // 遍历URL
            while (urls.hasMoreElements()) { 
                URL url = urls.nextElement();
                UrlResource resource = new UrlResource(url);
                // 加载每个URL中的properties配置
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                // 遍历每个配置
                for (Map.Entry<?, ?> entry : properties.entrySet()) { 
                    String factoryClassName = ((String) entry.getKey()).trim();
                    // 将实现类的配置按照","符号分割开
                    for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) { 
                        // 逐个添加到接口对应的集合当中
                        result.add(factoryClassName, factoryName.trim());
                    }
                }
            }
            // 加入缓存
            cache.put(classLoader, result);
            return result;
        } catch (IOException ex) { 
            // ...
        }
    }

其中`FACTORIES_RESOURCE_LOCATION= "META-INF/spring.factories"`,看到这里就知道要初始化器的时候要加载那些类了吧。  
加载完spring.fatories中类路径到cache中然后让createSpringFactoriesInstances()方法去通过反射去构造出实例对象，具体方法如下：

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

总结一下`getSpringFactoriesInstances(ApplicationContextInitializer.class));`  
这个方法调用将会从META-INF/spring.factories配置文件中找到所有ApplicationContextInitializer接口对应的实现类配置，然后通过反射机制构造出对应的实例对象。

getSpringFactoriesInstances(ApplicationListener.class);

这个方法也是一样的做法，将会获取ApplicationListener接口的所有配置实例对象

总结：上面两个方法都是从spring.factories中加载类路径，并通过反射构造实例对象，那spring.factories中都有什么呢？又有什么用？  
首先看下spring.factories文件：

# 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
    #。。。。
    
    # Application Listeners
    #。。。。。
    
    # Environment Post Processors
    org.springframework.boot.env.EnvironmentPostProcessor=\
    #。。。。。
    
    # Failure Analyzers
    org.springframework.boot.diagnostics.FailureAnalyzer=\
    #。。。。
    
    # FailureAnalysisReporters
    org.springframework.boot.diagnostics.FailureAnalysisReporter=\

我们看到，这个文件配置了多个个key:value格式的数据  
比如：  
1）key是：org.springframework.context.ApplicationContextInitializer

2）value是：org.springframework.context.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,org.springframework.context.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

key声明的是一个接口，value则是这个接口对应的实现类，如果有多个则以","符号分割。

简单来说，`spring.factories文件包含了一些接口相对应的实现类的配置，我们通过这些配置就可以知道接口有哪些可选的实现类，并通过反射获取对应的实例对象`。就像是简单工厂模式一样，也因此spring将这个文件定义为spring.factories这个名字。

## 推断当前main方法所在的主类 ##

下面来看SpringApplication构造函数的最后一步

private Class<?> deduceMainApplicationClass() { 
         try { 
             // 获取堆栈链路
             StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
             // 遍历每一个栈帧信息
             for (StackTraceElement stackTraceElement : stackTrace) { 
                 // 如果该栈帧对应的方法名等于main
                 if ("main".equals(stackTraceElement.getMethodName())) { 
                     // 获取该类的class对象
                    return Class.forName(stackTraceElement.getClassName());
                }
            }
        }
        catch (ClassNotFoundException ex) { 
            // Swallow and continue
        }
        return null;
    }

该方法采用遍历栈帧的方式来判断最终main方法落在哪个栈帧上，并通过forName来获取该类，最后返回给mainApplicationClass，至于这个东西有什么用，跟踪了一下这个变量好像也没什么用，如果有懂得大佬望指点。  
在网上有人提到：这么实现是因为不一定强制要求main方法里面启动SpringApplication, 而且run方法里面传入的也不一定就是main方法所在的类。

## 总结 ##

SpringApplication的实例化，可以看出最主要的就是做了应用类型的推断，后面的Application创建、Environment创建也会基于该类型、以及设置ApplicationContext初始化器、Application监听器。