SpringApplication对象的构建及spring.factories的加载时机

构建SpringApplication对象源码:
1、调用启动类的main()方法,该方法中调用SpringApplication的run方法。

@SpringBootApplication
public class SpringbootdemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootdemoApplication.class, args);
    }
}

2、调用SpringApplication的run()方法的重载方法，在发方法内构建了SpringApplication对象

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

3、构建SpringApplication对象。

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        //resourceLoader为null
        this.resourceLoader = resourceLoader;
        //PrimarySources（即启动类）一定不能为null
        Assert.notNull(primarySources, "PrimarySources must not be null");
        //初始化primarySources属性
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        //从Classpath中推断Web应用类型。
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        this.bootstrapRegistryInitializers = new ArrayList<>(
                getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = deduceMainApplicationClass();
    }

构建过程：

接下来我们来详细研究一下上述过程。在构建SpringApplication对象过程中，此时resourceLoader
为null,primarySources一定不为空且需要初始化为启动类SpringbootdemoApplication
。从Classpath中推断出Web应用类型并初始化webApplicationType，通过getSpringFactoriesInstances（）获取Spring工厂实例来初始化bootstrapRegistryInitializers，initializers（List<ApplicationContextInitializer<?>>应用程序上下文初始化器列表), listeners(List

4、从Classpath推断Web应用类型,调用的是WebApplicationType类的deduceFromClasspath（）方法。如果Classpath中包含DispatcherHandler，则表明当前WebApplicationType为REACTIVE；如果既不包含javax.servlet.Servlet也不包含Spring中的ConfigurableWebApplicationContext，则表明当前WebApplicationType为NONE; 上述两种都不是则表明当前WebApplicationType是SERVLET

static WebApplicationType deduceFromClasspath() {
        // 如果org.springframework.web.reactive.DispatcherHandler的class文件存在且可以加载
        //不存在org.springframework.web.servlet.DispatcherServlet
        //不存在org.glassfish.jersey.servlet.ServletContainer
        //则返回REACTIVE表明 该应用程序应作为响应式Web应用程序运行，并应启动嵌入式servlet Web 服务器
        if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
                && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
            return WebApplicationType.REACTIVE;
        }
        //遍历SERVLET 指标类
        //如果不存在javax.servlet.Servlet也不存在org.springframework.web.context.ConfigurableWebApplicationContext
        //则返回NONE表明该应用程序不应作为 Web 应用程序运行，也不应启动嵌入式 Web 服务器
        for (String className : SERVLET_INDICATOR_CLASSES) {
            if (!ClassUtils.isPresent(className, null)) {
                return WebApplicationType.NONE;
            }
        }
        //返回SERVLET表明该应用程序应作为基于servlet的 Web 应用程序运行，并应启动嵌入式 servlet Web 服务器。
        return WebApplicationType.SERVLET;
    }

spring.factories的加载时机
1、在构建SpringApplication中，初始化其属性bootstrapRegistryInitializers属性时进行加载 /META-INF/spring.factories。
2、构建SpringApplication对象时,通过调用getSpringFactoriesInstances(Class type)获取工厂实例。

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        ......
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        this.bootstrapRegistryInitializers = new ArrayList<>(
                getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        ......
    }

3、我们以初始化bootstrapRegistryInitializers为例讲解,getSpringFactoriesInstances(Class type, Class<?>[] parameterTypes, Object… args)中首先获取ClassLoader ，通过SpringFactoriesLoader机制，根据ClassLoader从类路径jar包中加载META-INF/spring.factories下的所有工厂类及其实现类 。

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 classLoader = getClassLoader();
        // 使用SpringFactoriesLoader机制加载出工厂名，并放入Set集合中确保其唯一性。但是在META-INF/spring.factories中并无BootstrapRegistryInitializer所以此处的names的size为0。
        Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        //创建Spring工厂实例（但因为上述names的size为0，所以对于BootstrapRegistryInitializer来说它并不会创建SpringFactory实例）
        List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
        //通过AnnotationAwareOrderComparator对Spring工厂实例排序
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }

4、SpringFactoriesLoader中的loadFactoryNames来加载META-INF/spring.factories下的所有工厂类及其实现类

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        //获取当前使用的ClassLoader
        ClassLoader classLoaderToUse = classLoader;
        if (classLoaderToUse == null) {
            //为空，则获取SpringFactoriesLoader的类加载器
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }
        //org.springframework.boot.BootstrapRegistryInitializer
        String factoryTypeName = factoryType.getName();
        //加载META-INF/spring.factories下的扩展类，没有值的返回一个空列表。
        return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }

5、重点关注SpringFactoriesLoader中的loadSpringFactories(ClassLoader classLoader)，该方法具体实现了从META-INF/spring.factories下加载扩展类。

//工厂类所在位置，在多个jar文件中都有。
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        //检查缓存中是否有工厂类
        Map<String, List<String>> result = cache.get(classLoader);
        if (result != null) {
            return result;
        }
        //缓存中没有，初始化result
        result = new HashMap<>();
        try {
            //加载META-INF/spring.factories下的一系列元素
            Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
            //迭代遍历
            while (urls.hasMoreElements()) {
                //spring-boot-版本号.jar文件中Spring.factories所在的绝对路径
                URL url = urls.nextElement();
                //构建UrlResource
                UrlResource resource = new UrlResource(url);
                //加载该UrlResource中的属性（即Spring.factories中的键值对）
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                for (Map.Entry<?, ?> entry : properties.entrySet()) {
                    //父类工厂类型名
                    String factoryTypeName = ((String) entry.getKey()).trim();
                    //子类工厂实现类名数组（在Spring.factories中多个用逗号分隔）
                    String[] factoryImplementationNames =
                            StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
                    //将工厂类型名，工厂实现类列表放入名为result的 Map<String, List<String>>中，key为工厂类型名，value为工厂实现类列表。
                    for (String factoryImplementationName : factoryImplementationNames) {
                        result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
                                .add(factoryImplementationName.trim());
                    }
                }
            }

            //将result中的所有list都置为包含唯一元素的不可修改的list
            result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
                    .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
            //放入缓存。        
            cache.put(classLoader, result);
        }
        catch (IOException ex) {
            throw new IllegalArgumentException("Unable to load factories from location [" +
                    FACTORIES_RESOURCE_LOCATION + "]", ex);
        }
        return result;
    }

bootstrapRegistryInitializers 的初始化中实现了加载META-INF/spring.factories中工厂扩展类（但是在META-INF/spring.factories并无bootstrapRegistryInitializers ），并将其放入缓存Map<String, List>，其中key为父类工厂名，value为其对应扩展类列表。之后initializers（ApplicationContextInitializer列表）以及listeners（ApplicationListener列表）的初始化都是从该缓存中获取值。

6、接下里我们看一下第三步中的createSpringFactoriesInstances()方法。由于bootstrapRegistryInitializers 在META-INF/spring.factories中并不存在。所以我们只有它返回的instances是空的即它不会创建SpringFactoriesInstances。但是初始化initializers，listeners时，却会。我们看一下具体源码。

private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
            ClassLoader classLoader, Object[] args, Set<String> names) {
        //初始化names.size()大小的list存放创建出来的实例。
        List<T> instances = new ArrayList<>(names.size());
        //遍历传入的工厂扩展类实例名
        for (String name : names) {
            try {
                //通过反射获取instance的Class对象
                Class<?> instanceClass = ClassUtils.forName(name, classLoader);
                //instanceClass是一个type类型，向下，否则抛异常IllegalArgumentException
                Assert.isAssignable(type, instanceClass);
                //获取instanceClass的构造器
                Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
                //通过BeanUtils的instantiateClass（）方法实例化类。
                T instance = (T) BeanUtils.instantiateClass(constructor, args);
                //将实例化出来的类放入instances
                instances.add(instance);
            }
            catch (Throwable ex) {
                throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
            }
        }
        return instances;
    }