SpringBoot 2.1.6 启动原理解析(一)

小白第一次写博客，如果有不足之处烦请各位大佬指正。
用了好久的SpringBoot了，一直不清楚它内部的一些启动原理，如何加载yml文件、如何初始化bean的，今天就记录一下，新建了一个springboot2.1.6的项目，就从一开始启动类中的SpringApplication.run方法开始，这一部分先看看SpringApplication的构造方法

项目名称: DemoAppication

SpringApploication.run

进入SpringApplication.run(DemoApplication.class, args);之后，是一个静态run方法的重载方法,后面如果方法中也是一个重载方法的话就不贴代码了。

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

进入这个重载的run方法以后，它创建一个SpringApplication的对象并调用了run方法返回

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

先看一下这个SpringApplication的构造方法里干了哪些事情

SpringApplication构造方法

进入SpringApplication之后也是一个构造方法的重载，进入这个重载方法之后是SpringApplication私有变量的一些赋值

    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        //resourceLoader -> null
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        //primarySources -> DemoApplication，封装成LinkedHashSet
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        // mainApplicationClass -> DemoApplication
        this.mainApplicationClass = deduceMainApplicationClass();
    }

• webApplicationType有三种类型，分别是NONE(嵌入式)、SERVLET(基于servlet)、REACTIVE(反应式)，根据SpringBoot下的一个工具类ClassUtil判断指定的类是否存在然后确定属于哪种类型，内部调用了Class.forName，如果规定的类不存在的话会报ClassNotFoundException，内部还有一些加载别的类的缓存什么的，不做深入探讨，我这里主要看SERVLET，对其他两种不做深入研究。
• setInitializers 设置初始化器(ApplicationContextInitializer.class )
• setListenerss 设置监听器(ApplicationListener.class)

• getSpringFactoriesInstances(Class clazz) 获取指定类型对象的列表，这里的指定类型指的是初始化器 ApplicationContextInitializer 和监听器 ApplicationListener，先看一下这个方法，比较重要

  getSpringFactoriesInstances

  进入这个方法之后也先是一个重载的方法，然后进入这个重载的方法，方法中主要有四步

    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
        //一、获取类加载器
        ClassLoader classLoader = getClassLoader();
        //二、根据传入的类型获取名称列表
        Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        //三、根据名称列表创建对象
        List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
        //四、给这些对象排个序
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }

下面分别介绍这四个方法

① getClassLoader

getClassLoader 先通过资源加载器 resourceLoader 获取类加载器，resourceLoader在SpringApplication构造方法中设置为 null，则通过ClassUtils.getDefaultClassLoader获取

    public ClassLoader getClassLoader() {
        if (this.resourceLoader != null) {
            return this.resourceLoader.getClassLoader();
        }
        return ClassUtils.getDefaultClassLoader();
    }

ClassUtils中先是获取当前线程的类加载器，如果为null的话就获取加载ClassUtils(也就是本类)的类加载器，如果为null则获取系统的类加载器，然后返回

public static ClassLoader getDefaultClassLoader() {
        ClassLoader cl = null;
        try {
            //当前线程的类加载器
            cl = Thread.currentThread().getContextClassLoader();
        }
        catch (Throwable ex) {
            // Cannot access thread context ClassLoader - falling back...
        }
        if (cl == null) {
            // No thread context class loader -> use class loader of this class.
            cl = ClassUtils.class.getClassLoader();
            if (cl == null) {
                // getClassLoader() returning null indicates the bootstrap ClassLoader
                try {
                    cl = ClassLoader.getSystemClassLoader();
                }
                catch (Throwable ex) {
                    // Cannot access system ClassLoader - oh well, maybe the caller can live with null...
                }
            }
        }
        return cl;
    }

② SpringFactoriesLoader.loadFactoryNames

获取指定类型的名称列表，重载的loadSpringFactories会返回一个Map，然后用指定类型的名称从这个Map中获取对象名称列表。

    public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
        //获取指定类型的名称
        String factoryClassName = factoryClass.getName();
        return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    }

loadSpringFactories中先从缓存中查询，有的话直接返回，没有的话就去遍历 FACTORIES_RESOURCE_LOCATION 路径下的spring.factories文件，将资源文件中的key/value添加到result中，然后将result添加到缓存中。至于result的泛型为什么是<String, String>类型而不是<String, List< String >>类型，俺也不知道，有知道的大佬吗

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

        try {
            //FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
            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 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) {
            throw new IllegalArgumentException("Unable to load factories from location [" +
                    FACTORIES_RESOURCE_LOCATION + "]", ex);
        }
    }

cache类型

private static final Map<ClassLoader, MultiValueMap<String, String>> cache = new ConcurrentReferenceHashMap<>();

• MultiValueMap与通常map区别为一个key可以对应多个value
• ConcurrentReferenceHashMap与ConcurrentHashMap区别为可以指定存放对象的引用级别，默认为软引用。

spring.factories文件在你添加的.jar包中会有，比如mybatis、redis等包


也有SpringBoot默认添加的包，初始化器和监听器是在.m2\repository\org\springframework\boot\spring-boot\2.1.6.RELEASE\spring-boot-2.1.6.RELEASE.jar!\META-INF\spring.factories这个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,\
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.BeanDefinitionOverrideFailureAnalyzer,\
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.NoSuchMethodFailureAnalyzer,\
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

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

BeanUtils.instantiateClass主要是调用setAccessible设置成true，然后newInstance，Kotlin方面没了解过，看源码也是加载classpath下的类，就当不存在就好了，全当成false来看

    public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
        Assert.notNull(ctor, "Constructor must not be null");
        try {
            ReflectionUtils.makeAccessible(ctor);
            return (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ?
                    KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args));
        }
        //...省略catch代码....
    }

④ AnnotationAwareOrderComparator.sort

    public static void sort(List<?> list) {
        if (list.size() > 1) {
            //INSTANCE = new AnnotationAwareOrderComparator();
            list.sort(INSTANCE);
        }
    }

将加载的对象排个序，内部直接使用List的排序，那我们就来看看这个Comparator中的compare是怎么写的吧，在AnnotationAwareOrderComparator找了一圈也没找到compare，那么就看看父类OrderComparator中的comparator，sourceProvider为 null

    @Override
    public int compare(@Nullable Object o1, @Nullable Object o2) {
        return doCompare(o1, o2, null);
    }

    private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderSourceProvider sourceProvider) {
        boolean p1 = (o1 instanceof PriorityOrdered);
        boolean p2 = (o2 instanceof PriorityOrdered);
        if (p1 && !p2) {
            return -1;
        }
        else if (p2 && !p1) {
            return 1;
        }

        int i1 = getOrder(o1, sourceProvider);
        int i2 = getOrder(o2, sourceProvider);
        return Integer.compare(i1, i2);
    }

进入getOrder方法之后再进入重载的方法，通过findOrder方法返回order，findOrder方法返回null则直接返回 Integer.MAX_VALUE

    private int getOrder(@Nullable Object obj, @Nullable OrderSourceProvider sourceProvider) {
        Integer order = null;
        if (obj != null && sourceProvider != null) {
            //...省略代码...
        }
        return (order != null ? order : getOrder(obj));
    }
    
    protected int getOrder(@Nullable Object obj) {
        if (obj != null) {
            Integer order = findOrder(obj);
            if (order != null) {
                return order;
            }
        }
        //int LOWEST_PRECEDENCE = Integer.MAX_VALUE;
        return Ordered.LOWEST_PRECEDENCE;
    }

findOrder方法在AnnotationAwareOrderComparator重写，如果obj实现了Order接口则直接返回实现的order，否则就从@Order或@Priority注解上获取order，都没有的话返回null，具体的实现不在本文中细讲

protected Integer findOrder(Object obj) {
        // 如果obj实现了Order接口则直接返回order
        Integer order = super.findOrder(obj);
        if (order != null) {
            return order;
        }
        /*
        protected Integer findOrder(Object obj) {
            return (obj instanceof Ordered ? ((Ordered) obj).getOrder() : null);
        }
        */

        // 在类上、方法上、注解上检查是否带有 @Order 或 @Priority 来判断order的值
        if (obj instanceof Class) {
            return OrderUtils.getOrder((Class<?>) obj);
        }
        else if (obj instanceof Method) {
            Order ann = AnnotationUtils.findAnnotation((Method) obj, Order.class);
            if (ann != null) {
                return ann.value();
            }
        }
        else if (obj instanceof AnnotatedElement) {
            Order ann = AnnotationUtils.getAnnotation((AnnotatedElement) obj, Order.class);
            if (ann != null) {
                return ann.value();
            }
        }
        else {
            order = OrderUtils.getOrder(obj.getClass());
            if (order == null && obj instanceof DecoratingProxy) {
                order = OrderUtils.getOrder(((DecoratingProxy) obj).getDecoratedClass());
            }
        }

        return order;
    }

再回到一开始的SpringApplication构造方法上来，setInitializers 和 setListeners就是给 SpringApplication中的变量赋值而已，没什么好说的

    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        //resourceLoader -> null
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        //primarySources -> DemoApplication，封装成LinkedHashSet
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        //初始化器初始化 我词穷了，听着真别扭
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        //监听器初始化
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        // mainApplicationClass -> DemoApplication
        this.mainApplicationClass = deduceMainApplicationClass();
    }

deduceMainApplicationClass

确认主方法在的类，原来还有这种方式判断主方法所在的类，学到了

    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的构造方法，未完待续......