SpringApplication类初始化过程

@SpringBootApplication
public class DemoApplication {

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

}

SpringApplication 构造方法

springapplication构造方法

 public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        this.sources = new LinkedHashSet();
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        this.addCommandLineProperties = true;
        this.addConversionService = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = new HashSet();
        this.isCustomEnvironment = false;
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        //根据classpath 来进行类型判断
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        //初始化classpath下 META-INF/spring.factories中已配置的ApplicationContextInitializer
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }

SpringApplication(构造方法)---> WebApplicationType.deduceFromClasspath();

返回类型是WebApplicationType的枚举类型， WebApplicationType 有三个枚举，三个枚举的解释如其中注释
具体的判断逻辑如下（逻辑整理前）：
判断是否为响应式编程REACTIVE ，如果不是判断是否含有 SERVLET_INDICATOR_CLASSES即
javax.servlet.Servlet或者org.springframework.web.context.ConfigurableWebApplicationContext
如果不满足则 返回None，如果满足则有返回servlet类型
具体的判断逻辑如下(逻辑整理后)：
WebApplicationType.REACTIVE classpath下存在org.springframework.web.reactive.DispatcherHandler
WebApplicationType.SERVLET classpath下存在javax.servlet.Servlet或者org.springframework.web.context.ConfigurableWebApplicationContext
WebApplicationType.NONE 不满足以上条件。

WebApplicationType.SERVLET classpath

  private static final String[] SERVLET_INDICATOR_CLASSES = new String[]{"javax.servlet.Servlet", "org.springframework.web.context.ConfigurableWebApplicationContext"};

image.png

    static WebApplicationType deduceFromClasspath() {
  // 判断是否为响应式编程
        if (ClassUtils.isPresent("org.springframework.web.reactive.DispatcherHandler", (ClassLoader)null) && !ClassUtils.isPresent("org.springframework.web.servlet.DispatcherServlet", (ClassLoader)null) && !ClassUtils.isPresent("org.glassfish.jersey.servlet.ServletContainer", (ClassLoader)null)) {
            return REACTIVE;
        } else {
     //SERVLET_INDICATOR_CLASSES 即为  private static final String[] SERVLET_INDICATOR_CLASSES = new String[]{"javax.servlet.Servlet", "org.springframework.web.context.ConfigurableWebApplicationContext"};
            String[] var0 = SERVLET_INDICATOR_CLASSES;
            int var1 = var0.length;
//如果不是判断是否含有 SERVLET_INDICATOR_CLASSES 若不包含则返回NONE 否则返回 SERVLET
            for(int var2 = 0; var2 < var1; ++var2) {
                String className = var0[var2];
                if (!ClassUtils.isPresent(className, (ClassLoader)null)) {
                    return NONE;
                }
            }

            return SERVLET;
        }
    }

SpringApplication--> this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));

初始化classpath下 META-INF/spring.factories中已配置的ApplicationContextInitializer

    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
        ClassLoader classLoader = this.getClassLoader();
     //通过指定的classLoader从 META-INF/spring.factories 的资源文件中，
      //读取 key 为 type.getName() 的 value
        Set<String> names = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
       //创建Spring工厂实例
        List<T> instances = this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
        //对Spring工厂实例排序（org.springframework.core.annotation.Order注解指定的顺序）
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }

SpringApplication--> this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));---> this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);

利用反射的方式 获得类的名字，获得构造器，初始化类

 private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, ClassLoader classLoader, Object[] args, Set<String> names) {
        List<T> instances = new ArrayList(names.size());
        Iterator var7 = names.iterator();

        while(var7.hasNext()) {
            String name = (String)var7.next();

            try {
                 // 获得类的名字
                Class<?> instanceClass = ClassUtils.forName(name, classLoader);
                Assert.isAssignable(type, instanceClass);
                //获得构造器
                Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
                //初始化类
                T instance = BeanUtils.instantiateClass(constructor, args);
                instances.add(instance);
            } catch (Throwable var12) {
                throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, var12);
            }
        }
        return instances;
    }

SpringApplication--> this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));---> -->SpringFactoriesLoader.loadFactoryNames(type, classLoader)-->loadSpringFactories(@Nullable ClassLoader classLoader)

使用类加载器加载 META-INF/spring.factories

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

    private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            try {
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryClassName = ((String)entry.getKey()).trim();
                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;

                        for(int var11 = 0; var11 < var10; ++var11) {
                            String factoryName = var9[var11];
                            result.add(factoryClassName, factoryName.trim());
                        }
                    }
                }

                cache.put(classLoader, result);
                return result;
            } catch (IOException var13) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
            }
        }
    }

META-INF/spring.factories
配合之前的@EnableAutoConfiguration注解，以下类自动加载
自动装载配置https://www.jianshu.com/p/30a7a8bca6a5 文章最后部分