SpringBoot启动流程分析1--SpringApplication实例化

SpringBoot启动流程解析：SpringApplication实例化与自动配置
原创 已于 2025-08-28 15:22:56 修改 · 1.5k 阅读 · 33 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #后端 #java

于 2024-01-04 19:43:28 首次发布
本文详细分析了SpringBoot2.7.x启动流程中的第一个阶段——SpringApplication实例化过程，涉及primarySources的设置、应用类型推断、初始化器和监听器加载，以及mainApplicationClass的推断。

SpringBoot启动流程分析1–SpringApplication实例化

一、概述

源码基于SpringBoot 2.7.xx版本

1.1 简介

SpringBoot启动流程大致分为两个阶段，第一个阶段是SpringApplication 实例化，第二个阶段为执行 run 方法，本章关注第一阶段

第一个阶段：

  1. 设置primarySources属性
  2. 推断应用类型–WebApplicationType
  3. 加载Spring应用上下文初始化器–ApplicationContextInitializer
  4. 加载Spring应用事件监听器–ApplicationListener
  5. 推断应用引导类–mainApplicationClass

第二阶段：

  1. 初始化引导上下文–bootStrapContext
  2. 创建应用上下文环境–ConfigurableEnvironment
  3. 创建应用上下文–createApplicationContext
  4. 准备应用上下文–prepareContext
  5. 刷新应用上下文–refreshContext
  6. 刷新应用上下文后的扩展接口–afterRefresh(空方法)
  7. 调用ApplicationRunner和CommandLineRunner对应的run方法

1.2 名词解释

  • Instantiation
    实例化，是加载class文件，并在内存中开辟一块内容空间，创建一个属性值为默认值的对象
  • Initialization
    初始化，初始化是对对象的属性进行赋值即属性填充，是在Bean实例化完成后执行的。

二、详解

2.1 mian方法

// 能够扫描Spring组件并自动配置Spring Boot
@SpringBootApplication
public class SpringbootApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootApplication.class, args);
    }
}

在这个类中需要关注的是

  • @SpringBootApplication
  • SpringApplication.run()

关于 @SpringBootApplication 注解，在后面SpringBoot启动流程分析知识点–自动装配的章节会展开去分析。

2.2 SpringApplication的实例化

SpringBoot启动的时候，会创建一个SpringApplication的实例，实例化的时候会做以下几件事：

  1. 把primarySources(启动类Class对象)设置到SpringApplication的primarySources属性中，后续prepareContext方法会根据该属性加载启动类，
    并将启动类注入到容器，后续会根据该类进行包扫描;
  2. 推断应用类型，后面会根据类型初始化对应的环境，一般为WebApplicationType.SERVLET类型;
  3. 实例化classpath下 META-INF/spring.factories中已配置的 ApplicationContextInitializer;
  4. 实例化classpath下 META-INF/spring.factories中已配置的 ApplicationListener;
  5. 根据调用栈，推断出 main 方法的类名，用于发布事件，打印banner。
public class SpringApplication {

    // 调用重载方法
    public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
        return run(new Class<?>[]{primarySource}, args);
    }

    // 两件事:1.实例化SpringApplication 2.执行run方法
    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        new SpringApplication(primarySources);
        return run(args);
    }

    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        // resourceLoader参数默认为null
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        // 1.把primarySources设置到SpringApplication的primarySources属性中--启动类Class对象
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        // 2.推断应用类型，后面会根据类型初始化对应的环境，一般为WebApplicationType.SERVLET类型
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        this.bootstrapRegistryInitializers = new ArrayList<>(
                getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
        // 3.实例化classpath下 META-INF/spring.factories中已配置的 ApplicationContextInitializer
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        // 4.实例化classpath下 META-INF/spring.factories中已配置的 ApplicationListener
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        // 5.根据调用栈，推断出 main 方法的类名
        this.mainApplicationClass = deduceMainApplicationClass();
    }
}

2.3 推断应用类型

具体的判断逻辑如下：

  1. WebApplicationType.REACTIVE
    classpath下 存在org.springframework.web.reactive.DispatcherHandler，
    并且不存在org.springframework.web.servlet.DispatcherServlet和org.glassfish.jersey.servlet.ServletContainer;
  2. WebApplicationType.SERVLET
    classpath下 存在javax.servlet.Servlet和org.springframework.web.context.ConfigurableWebApplicationContext;
  3. WebApplicationType.NONE
    不满足以上条件。
public enum WebApplicationType {

    NONE,
    SERVLET,
    REACTIVE;

    private static final String[] SERVLET_INDICATOR_CLASSES = {"javax.servlet.Servlet",
            "org.springframework.web.context.ConfigurableWebApplicationContext"};
    private static final String WEBMVC_INDICATOR_CLASS = "org.springframework.web.servlet.DispatcherServlet";
    private static final String WEBFLUX_INDICATOR_CLASS = "org.springframework.web.reactive.DispatcherHandler";
    private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";

    /**
     * 判断 应用的类型
     * NONE: 应用程序不是web应用，也不应该用web服务器去启动
     * SERVLET: 应用程序应作为基于servlet的web应用程序运行，并应启动嵌入式servlet web（tomcat）服务器。
     * REACTIVE: 应用程序应作为 reactive web应用程序运行，并应启动嵌入式 reactive web服务器。
     * @return
     */
    static WebApplicationType deduceFromClasspath() {
        if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
                && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
            return WebApplicationType.REACTIVE;
        }
        for (String className : SERVLET_INDICATOR_CLASSES) {
            if (!ClassUtils.isPresent(className, null)) {
                return WebApplicationType.NONE;
            }
        }
        // classpath下 存在javax.servlet.Servlet和org.springframework.web.context.ConfigurableWebApplicationContext
        return WebApplicationType.SERVLET;
    }
}

2.4 加载Spring应用上下文初始化器

实例化classpath下 META-INF/spring.factories中已配置的 ApplicationContextInitializer。

public class SpringApplication {

    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        // ……
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        // ……
    }
    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
        return getSpringFactoriesInstances(type, new Class<?>[]{});
    }

    /**
     * 从META-INF/spring.factories获取指定的Spring的工厂实例
     */
    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
        ClassLoader classLoader = getClassLoader();
        // Use names and ensure unique to protect against duplicates
        // 通过指定的classLoader从 META-INF/spring.factories 的资源文件中读取 key 为 type.getName() 的 value
        // type为接口，value为逗号分割的实现类
        Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        // 创建Spring工厂实例，实际上就是type接口的实例对象
        List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
        // 对Spring工厂实例排序（org.springframework.core.annotation.Order注解指定的顺序）
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }

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

2.4.1 loadFctoryNames()方法

loadFctoryNames(type,classLoader)方法就是从spring.factories中获取类型名称(其实就是一接口及其实现列表)

ApplicationContextInitializer 是Spring框架的类, 这个类的主要目的就是在 ConfigurableApplicationContext 调用refresh()方法之前回调这个类的initialize方法。允许我们对ConfiurableApplicationContext的实例做进一步的设置和处理。例如：通过 ConfigurableApplicationContext 的实例获取容器的环境Environment，从而实现对配置文件的修改完善等工作。

spring-boot中ApplicationContextInitializer的实现如下：

  1. spring-boot
    • DelegatingApplicationContextInitializer
    • ContextIdApplicationContextInitializer
    • ConfigurationWarningsApplicationContextInitializer
    • RSocketPortInfoApplicationContextInitializer
    • ServerPortInfoApplicationContextInitializer
  2. spring-boot-autoconfigure
    • SharedMetadataReaderFactoryContextInitializer
    • ConditionEvaluationReportLoggingListener

如果pom有依赖其他jar中存在spring.factories，则会一同加载进来，并缓存到cache中。

public final class SpringFactoriesLoader {
    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
    static final Map<ClassLoader, Map<String, List<String>>> cache = new ConcurrentReferenceHashMap<>();

    public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoaderToUse == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }
        String factoryTypeName = factoryType.getName();
        // 在这里进行返回的时候会进行loadFactories
        return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }

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

        result = new HashMap<>();
        try {
            Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                for (Map.Entry<?, ?> entry : properties.entrySet()) {
                    String factoryTypeName = ((String) entry.getKey()).trim();
                    String[] factoryImplementationNames =
                            StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
                    for (String factoryImplementationName : factoryImplementationNames) {
                        result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
                                .add(factoryImplementationName.trim());
                    }
                }
            }

            // Replace all lists with unmodifiable lists containing unique elements
            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;
    }
}

部分ApplicationContextInitializer作用：

  1. spring-boot
    • DelegatingApplicationContextInitializer：委托（代理）initializer，其核心功能是通过环境变量context.initializer.classes(类的全限定名，多个用,分割)动态加载自定义初始化器，若未指定，则不执行任何操作。这个初始化器的优先级是Spring Boot定义初始化器中优先级别最高的，因此会被第一个执行
    • ContextIdApplicationContextInitializer：给ApplicationContext设置一个ID，即spring.application.name，未设置默认为application
    • ConfigurationWarningsApplicationContextInitializer： 加载ConfigurationWarningsPostProcessor 处理器
    • RSocketPortInfoApplicationContextInitializer
    • ServerPortInfoApplicationContextInitializer：添加监听器, 当服务器启动时(WebServerInitializedEvent事件)将内嵌的Web服务器使用的端口添加进 spring 容器
  2. spring-boot-autoconfigure
    • SharedMetadataReaderFactoryContextInitializer：加载CachingMetadataReaderFactoryPostProcessor 处理器
    • ConditionEvaluationReportLoggingListener：添加监听器，监听ContextRefreshedEvent和ApplicationFailedEvent事件，通过日志输出条件评估报告（如自动配置类加载情况、条件匹配结果等），便于开发者理解应用启动时的配置逻辑。

2.5 加载Spring应用事件监听器

实例化classpath下 META-INF/spring.factories中已配置的 ApplicationListener。

ApplicationListener 的加载过程和上面的 ApplicationContextInitializer 类的加载过程是一样的。

spring-boot中ApplicationListener的实现如下：

  1. spring-boot
    • EnvironmentPostProcessorApplicationListener：主要监听ApplicationEnvironmentPreparedEvent事件，主要用于在Spring应用环境准备阶段加载环境后置处理器–EnvironmentPostProcessor，并按照优先级排序后调用它们的 postProcessEnvironment 方法。该方法允许开发者动态修改环境配置（如添加属性源、调整属性优先级等）。
    • AnsiOutputApplicationListener
    • LoggingApplicationListener
    • DelegatingApplicationListener
    • ParentContextCloserApplicationListener
    • ClearCachesApplicationListener
    • FileEncodingApplicationListener
  2. spring-boot-autoconfigure
    • BackgroundPreinitializer
      在 spring.factories 配置文件中默认定义的 EnvironmentPostProcessor 的实现类（即EnvironmentPostProcessorApplicationListener触发监听事件后调用）：
  • RandomValuePropertySourceEnvironmentPostProcessor：用于动态生成随机值（如字符串、数值、UUID等）并将其注入到环境配置中的组件。
  • SystemEnvironmentPropertySourceEnvironmentPostProcessor：将环境中已保存的操作系统环境变量相关的属性进行替换，将原本保存环境变量的SystemEnvironmentPropertySource实例替换成其子类OriginAwareSystemEnvironmentPropertySource，两者的协作关系是：后置处理器在环境初始化阶段完成替换，而增强后的属性源在运行时提供Origin查询能力。
  • SpringApplicationJsonEnvironmentPostProcessor：解析 spring.application.json 或 SPRING_APPLICATION_JSON 配置的 json 字符串。
  • CloudFoundryVcapEnvironmentPostProcessor：是 Spring Boot 中一个专门用于处理 Cloud Foundry 环境(一个开源 PaaS 云平台)的 EnvironmentPostProcessor。 它的主要作用是从 Cloud Foundry 提供的 VCAP_APPLICATION 和 VCAP_SERVICES 环境变量中读取配置信息，并将这些信息作为属性源添加到 Spring Boot 的 Environment 中。
  • ConfigDataEnvironmentPostProcessor：配置文件解析application.yml，以及application-dev.yml等，每个yml生成一个配置源（替代旧版ConfigFileApplicationListener）
  • DebugAgentEnvironmentPostProcessor
SpringBoot启动流程分析（一）：SpringApplication初始化(基于SpringBoot2.1.9.RELEASE)
记录点滴
06-05 442
1.从SpringApplication开始 @SpringBootApplication public class ApplicationLoader { public static void main(String[] args) { SpringApplication application = new SpringApplication(ApplicationLoader.class); application.run(args); } } 1.
深入理解SpringBoot（一）----SpringBoot的启动流程分析
qq_24428851的博客
09-15 1396
就SpringBoot的启动整个过程而已，还是很清晰的，SpringBoot的套用SpringFramework的机制，为我们自定义实现功能提供了很好的便利，整个的SpringBoot就是重新包装了一个SpringFramework。1、new了一个SpringApplication对象，使用SPI技术加载加载 ApplicationContextInitializer、ApplicationListener 接口实例2、调用SpringApplication.run() 方法。
（三）SpringApplication实例化
yorao4565的博客
01-28 400
SpringApplication实例化
Springboot run方法-SpringApplication实例化过程(一)
qq_36194388的博客
07-27 357
SpringApplication SpringBootApplication应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main方法来启动SpringBoot应用 @SpringBootApplication public class Springboot01DemoApplication { public static void main(String[] args) { SpringApplication.run(Spr
springApplication实例化源码
hshpy的博客
02-22 186
springApplication实例化源码
Springboot run方法-SpringApplication实例化(二)
qq_36194388的博客
07-27 170
SpringApplication实例化初始化创建 SpringApplication实例化初始化创建，核心源码如下 @SuppressWarnings({ "unchecked", "rawtypes" }) public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) { //参数初始化 this.sources = new LinkedHashSet();// this
Springboot启动流程：构造SpringApplication实例对象
蒋蒋
09-02 498
Springboot启动流程：构造ConfigurableApplicationContext对象推断当前应用类型设置初始化器、监听器推断当前main方法所在的主类总结 springboot项目从一个main方法开始，main方法将会调用SpringApplication的run方法开始springboot的启动流程。所以，本文即从构造SpringApplication对象开始。 下面来一起看下run()： public static ConfigurableApplicationContext run(C
03-SpringBoot启动过程源码解析-周瑜.pdf
10-24
SpringBoot启动过程可以分为多个阶段，包括构造SpringApplication对象、推测Web应用类型、获取BootstrapRegistryInitializer对象、获取ApplicationContextInitializer对象、获取ApplicationListener对象、推测出Main...
02-Spring容器的初始化与SpringBoot启动过程解析-146530475.md
05-07
Spring Boot的启动流程则更为简洁，它通过SpringApplication类提供的run方法来启动整个Spring Boot应用。SpringApplication类是Spring Boot的核心类，它封装了Spring应用的启动逻辑，简化了配置和启动过程。run方法...
可能是全网最全的SpringBoot启动流程源码分析（基于 2.1.5 版本）
01-20
使用 Spring Boot 启动一个微服务十分简单，只需要在启动类上调用 SpringApplication 的run方法即可 ...1 run 静态辅助类，可用于运行使用默认配置（即我们添加的一...上面是 SpringApplication实例对象构造方法初始化
Spring Boot－SpringApplication.run方法执行流程详解
了解➔熟悉➔掌握➔精通
10-16 8635
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net SpringApplication 是将一个典型的 Spring 应用启动的流程“模板化”，在没有特殊需求的情况下，默认模板化后的执行流程就可以满足需求。但如果有特殊需求也没关系，SpringApplication 在适当的流程结点开放了一系列不同类型的扩展点，我们可以通过这些扩展点对 SpringBoot 程序的启动和关闭过程进行扩展。 最直接的扩展是 S
springboot中依赖对象实例化问题
左直拳的马桶_日用桶
03-24 1801
一个问题，暴露出不少问题。然后解决这些问题。 一、问题描述 有个SpringBoot项目，启动的时候，读取某对象的属性报错，因为该对象为null。 这个对象使用了@Autowired注解，看上去，是对象实例化的顺序问题。即A里面使用了B，B由容器负责实例化，但A使用B的时候，B却还没来得及注入。 二、问题解决 1、A等B实例化之后再使用B 使用@PostConstruct注解，比如： @Service public class AImpl implements A { @Autowired
专题五：Spring源码之初始化容器上下文
热门推荐
Jeremy程序员
07-01 11万+
目前我们代码进程如下图所示：下一节我们正式进入初始化容器，看看众所周知的Bean Factory到底怎么来的。
Spring的对象实例化
coobee的博客
05-14 1385
Overview Spring实例化对象，主要通过三种方式： @Component applicationContext.xml @Configuration + @Bean @Component 现在开发最常用的方式, 通过标注声明告诉Spring容器，让其扫描时将其实例化。 主要标注为@Component，以及它的别名@Service，@Controller， @Resource， @Repository等。 Spring会扫描@ComponentScan(basePackages={
Spring Boot Application的启动过程 - 加载应用上下文
ttyy1112的专栏
05-21 471
SpringBoot的启动流程，ApplicationContext的初始化过程，BeanFactory的创建过程，Bean的生命周期管理，这些是Spring中最最核心的东西，你认知Spring这么多年了，你真的了解她吗？你不了解她怎么可能获得她的芳心呢？ 从现在开始了解她吧，你越了解她你就越会被她的魔力所吸引，爱上她是你今生最大的福气！ 关键代码 + 简单注解，有问题随时提问，Welcome！
SpringBoot源码解析三部曲（二）——SpringApplication实例化
Murphy_H的博客
02-12 437
目录1、SpringApplication实例化简介2、SpringApplication实例化流程2.1、推断Web应用类型2.2、ApplicationContextInitializer加载2.3、ApplicationListener加载2.4、推断入口类 1、SpringApplication实例化简介 常见启动入口类示例： @SpringBootApplication(exclude = DataSourceAutoConfiguration.class) public class Spring
Spring的实例化和依赖注入时机与延迟实例化
MarkZP
03-05 1683
原文链接：https://blog.youkuaiyun.com/xfx_1994/article/details/103873129?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task Spring的实例化 使用@Autowired可以注入一个bean进来 ...
spring-boot启动源码分析（一）之SpringApplication实例构造
lft18的博客
11-27 1203
spring.factory是spring boot的核心，里面定义了spring boot需要使用的接口，以及对应的实现类。loadSpringFactories(classLoaderToUse)返回的是类加载器加载所有的spring.fatories数据，返回的是Map，key是工厂接口，value是对应实现类列表，所以通过factoryTypeName就可以获得对应的实现类，这里只是类的全限定名。然后对工厂实例进行排序，因为有些实例执行是有顺序要求的。
Spring boot启动流程-bean的实例化和初始化
软件测试入门笔记
04-09 1867
AbstractApplicationContext类的refresh方法中，调用了finishBeanFactoryInitialization(beanFactory)方法，完成了bean factory的初始化，其中就包括bean的实例化和初始化。
请分析下Springboot启动流程，以初始化springapplication和运行springapplication两块分析
最新发布
08-30
我们以初始化SpringApplication和运行SpringApplication两大阶段来分析Spring Boot的启动流程。下面详细展开： ### **1. 初始化SpringApplication阶段** 此阶段主要完成应用类型判断、初始化器和监听器加载等准备...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

fanderboy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值