SpringBoot的启动过程

最新推荐文章于 2025-04-16 18:20:18 发布
最新推荐文章于 2025-04-16 18:20:18 发布
阅读量419 收藏
点赞数
分类专栏： springboot 文章标签： spring java spring boot 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jy317358306/article/details/108819322
版权

SpringBoot的启动过程

springboot项目启动时SpringApplication.run干了什么

在这里插入图片描述
在这里插入图片描述
很明显干了 ，两件事：
(1)实例化了一个SpringApplication,参数为当前项目的启动类的class对象
(2)调用了SpringApplication的run方法，参数为main方法上的String[] args
接下来我们具体去看着两件事儿

1.SpringApplication的构造函数干了啥

![在这里插入图片描述](https://img-blog.csdnimg.cn/20200927000104259.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p5MzE3MzU4MzA2,size_16,color_FFFFFF,t_70#pic_center在这里插入图片描述SpringApplication的构造函数除了指定了一些默认参数主要干了四件事儿：
1）确定当前应用程序的类型
2）初始化Initializers
3）初始化Listeners
4）保存当前程序运行mainApplicationClass 即为当前项目的启动类–TestRunApplication

1.1确定当前应用程序的类型时干了些啥

WebApplicationType为Spring中的一个枚举类，类型有三种
（1）NONE 普通应用程序
（2）SERVLET servlet的Web应用程序
（3）REACTIVE 响应式Reactive的Web应用程序
通过调用WebApplicationType.deduceFromClasspath()去确定应用程序类型
在这里插入图片描述
这个方法就是通过ClassUtils.isPresent(）来判断当前应用程序时啥类型的，那么这个方法又干了啥呢
在这里插入图片描述
看名字，我们就清楚了，实际上就是通过反射尝试着去创建对应的类的实例，
那么类型的判断流程就很清楚了
(1)首先进来先看org.springframework.web.reactive.DispatcherHandler能不能实例化，不能实例化则，认为不是REACTIVE,能实例化则继续加载REACTIVE需要的org.springframework.web.servlet.DispatcherServlet和org.glassfish.jersey.servlet.ServletContainer
（2）如果不能实例化，则默认为当前环境为Servlet,然后去尝试实例化javax.servlet.Servlet和org.springframework.web.context.ConfigurableWebApplicationContext，初始化成功则认为是Servlet,不能初始化，则认为是NONE

1.2初始化Initializers又干了啥呢

(1)首先调用了SpringApplication的getSpringFactoriesInstances方法
getSpringFactoriesInstances这个方法干了啥呢？
（1）通过SpringFactoriesLoader.loadSpringFactories()去加载这些配置文件下的类
1）org/springframework/boot/spring-boot/2.3.4.RELEASE/spring-boot-2.3.4.RELEASE.jar!/META-INF/spring.factories
2）org/springframework/boot/spring-boot-autoconfigure/2.3.4.RELEASE/spring-boot-autoconfigure-2.3.4.RELEASE.jar!/META-INF/spring.factories
3）org/springframework/spring-beans/5.2.9.RELEASE/spring-beans-5.2.9.RELEASE.jar!/META-INF/spring.factories
然后将加载到的类信息放入SpringFactoriesLoader的一个cache变量中
默认加载的类包含
“org.springframework.boot.diagnostics.FailureAnalyzer” -> " size = 21"
“org.springframework.boot.env.EnvironmentPostProcessor” -> " size = 4"
“org.springframework.boot.SpringApplicationRunListener” -> " size = 1"
“org.springframework.context.ApplicationContextInitializer” -> " size = 7"
“org.springframework.boot.env.PropertySourceLoader” -> " size = 2"
“org.springframework.context.ApplicationListener” -> " size = 11"
“org.springframework.boot.diagnostics.FailureAnalysisReporter” -> " size = 1"
“org.springframework.boot.SpringBootExceptionReporter” -> " size = 1"
“org.springframework.boot.autoconfigure.AutoConfigurationImportFilter” -> " size = 3"
“org.springframework.boot.autoconfigure.AutoConfigurationImportListener” -> " size = 1"
“org.springframework.boot.autoconfigure.template.TemplateAvailabilityProvider” -> " size = 5"
“org.springframework.boot.autoconfigure.EnableAutoConfiguration” -> " size = 127"
“org.springframework.beans.BeanInfoFactory” -> " size = 1"
然后通过createSpringFactoriesInstances这个方法指定参数为ApplicationContextInitializer，然后实例化了springboot的jar包下的spring.factories中的七个类
在这里插入图片描述
在这里插入图片描述
黄色字体部分的被实例化了
然后将实例化的实例进行排序返回，赋值给了SpringApplication的List<ApplicationContextInitializer<?>> initializers

1.3初始化Listeners

同初始化Initializers一样，通过ApplicationListener从SpringFactoriesLoader的缓存变量中取到了11个类信息，然后实例化并发返回，赋值给了SpringApplication的List<ApplicationListener<?>> listeners
在这里插入图片描述
org.springframework.boot.ClearCachesApplicationListener
org.springframework.boot.builder.ParentContextCloserApplicationListener
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor
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
org.springframework.boot.autoconfigure.BackgroundPreinitializer

2.调用SpringApplication的run方法

在这里插入图片描述
核心是AbstractApplicationContext这个类

 synchronized(this.startupShutdownMonitor) {
 			//  准备刷新上下文
            this.prepareRefresh();
            // 创建Bean工厂
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            // Bean工厂进一步的准备工作,包含设置类加载器，添加Bean处理器等后面需要用的一些东西
            this.prepareBeanFactory(beanFactory);

            try {
            	// 根据应用程序来确定Bean工厂使用的Bean的处理器
                this.postProcessBeanFactory(beanFactory);
                // 实例化Bean定义处理器并加载Bean定义
                this.invokeBeanFactoryPostProcessors(beanFactory);
                // 注册Bean处理器
                this.registerBeanPostProcessors(beanFactory);
                // 加载国际化等文件
                this.initMessageSource();
                // 初始化容器时间广播器
                this.initApplicationEventMulticaster();
                //  启动容器，web程序使用的是ServletWebServerApplicationContext
                this.onRefresh();
                // 注册监听器
                this.registerListeners();
                // 根据Bean定义实例化Bean
                this.finishBeanFactoryInitialization(beanFactory);
                // 解决Bean的循环引用，发布时间
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }

				// 清除一些Bean实例化过程中使用到的辅助的类
                this.destroyBeans();
                // 设置active标志位
                this.cancelRefresh(var9);
                throw var9;
            } finally {
            	// 清除工具类中的缓存
                this.resetCommonCaches();
            }

        }


```java
/**
 上下文刷新准备
*/
protected void prepareRefresh() {
        this.startupDate = System.currentTimeMillis();
        // 应用上下文是否关闭的标识
        this.closed.set(false);
        // 应用上下文是否活跃的标识
        this.active.set(true);
        // 打印日志
        if (this.logger.isDebugEnabled()) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Refreshing " + this);
            } else {
                this.logger.debug("Refreshing " + this.getDisplayName());
            }
        }

		// 实际啥都没干，实现方法是空的
        this.initPropertySources();
        // 创建标准容器并检验必要属性
        this.getEnvironment().validateRequiredProperties();
        // 添加应用监听器
        if (this.earlyApplicationListeners == null) {
            this.earlyApplicationListeners = new LinkedHashSet(this.applicationListeners);
        } else {
            this.applicationListeners.clear();
            this.applicationListeners.addAll(this.earlyApplicationListeners);
        }
		// 初始化应用时间容器
        this.earlyApplicationEvents = new LinkedHashSet();
    }


/**
创建Bean工厂
*/
protected final void refreshBeanFactory() throws BeansException {
        if (this.hasBeanFactory()) {
            this.destroyBeans();
            this.closeBeanFactory();
        }

        try {
        	// 创建Bean工厂，调用的下面的DefaultListableBeanFactory 这个也是springboot的核心类之一
            DefaultListableBeanFactory beanFactory = this.createBeanFactory();
            beanFactory.setSerializationId(this.getId());
            // 设置是否允许Bean定义的重写和是否允许循环引用
            this.customizeBeanFactory(beanFactory);
            // 加载Bean定义(Bean定义的加载器有四种：1.AbstractXmlApplicationContext 2.AnnotationConfigWebApplicationContext 3.GroovyWebApplicationContext 4.XmlWebApplicationContext)
            // AbstractXmlApplicationContext 加载默认的application.xml文件的
            // AnnotationConfigWebApplicationContext web程序注解加载
            // GroovyWebApplicationContext 支持Groovy语言的 Java用不到
            // XmlWebApplicationContext 专为web程序支持的xml解析器
            this.loadBeanDefinitions(beanFactory);
            this.beanFactory = beanFactory;
        } catch (IOException var2) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var2);
        }
}

public DefaultListableBeanFactory(@Nullable BeanFactory parentBeanFactory) {
        super(parentBeanFactory);
        // 自动装配断言解析器
        this.autowireCandidateResolver = SimpleAutowireCandidateResolver.INSTANCE;
        // 解析依赖的容器
        this.resolvableDependencies = new ConcurrentHashMap(16);
        // Bean定义的Map
        this.beanDefinitionMap = new ConcurrentHashMap(256);
        // Bean定义的Map
        this.mergedBeanDefinitionHolders = new ConcurrentHashMap(256);
        // Bean的名字的容器
        this.allBeanNamesByType = new ConcurrentHashMap(64);
        // 单例Bean名字的容器
        this.singletonBeanNamesByType = new ConcurrentHashMap(64);
        // Bean定义的名字的容器
        this.beanDefinitionNames = new ArrayList(256);
        this.manualSingletonNames = new LinkedHashSet(16);
    }
Spring Boot的启动流程
流楚丶格念的博客
08-24 2万+
- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 创建springbootApplication对象 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- - 1. 创建springbootApplication对象springboot容器初始化操作 2. 获取当前应用的启动类型。2.1 ：通过判断当前classpath是否加载servlet类，返回servlet web启动方式。
Springboot启动过程详解
水w的博客
10-22 1万+
Springboot启动过程详解
Springboot启动流程
热门推荐
zsh2050的专栏
04-30 6万+
一、SpringBoot启动的时候，会构造一个SpringApplication的实例，构造SpringApplication的时候会进行初始化的工作，初始化的时候会做以下几件事： 1、把参数sources设置到SpringApplication属性中，这个sources可以是任何类型的参数. 2、判断是否是web程序，并设置到webEnvironment的boolean属性中. 3、创建并初始化ApplicationInitializer，设置到initializers属性中 。 4、创建并初始化App
Spring Boot 项目的启动流程，图片+文字详细解答(附相关面试题)
m0_70325779的博客
04-16 1541
目录一. 核心简要流程二. 详细流程图三. 启动流程详解3.1 初始化阶段3.2 运行阶段四. 面试题合集4.1 Spring Boot启动流程？4.2 Spring Boot 的自动配置是如何实现的？4.3 如何自定义 Spring Boot 的 Banner？4.4 如何监听 Spring Boot 的启动事件？4.5 Spring Boot 内嵌服务器是如何启动的？4.6 @SpringBootApplication 注解的作用是什么？4.7 Spring Boot 应用启动失败的可能原因及排查方法？
Spring boot 启动过程
zhaohong_bo的专栏
06-18 575
先Mark， https://www.cnblogs.com/trgl/p/7353782.html https://blog.csdn.net/zl1zl2zl3/article/details/79765725 https://blog.csdn.net/u010811939/article/details/80592461 https://www.jianshu.com/p/dc12081b...
Spring Boot启动过程
数据与算法架构提升之路专栏
07-12 397
SpringApplication run方法解析 public ConfigurableApplicationContext run(String... args) { StopWatch stopWatch = new StopWatch(); stopWatch.start(); ConfigurableApplicationContext context = null; ...
SpringBoot 之 启动过程
WuTing的专栏
02-24 1489
通过main方法启动的过程： @SpringBootApplication public class TestApplication extends SpringBootServletInitializer { //通过main方法启动，使用内置服务器 public static void main(String[] args) { SpringApplic...
springboot 启动过程源码分析
11-06
SpringBoot 启动过程源码分析 SpringBoot 的启动原理是基于 JavaConfig 形式的配置，使用 @Configuration 注解标注的启动类来配置 IoC 容器。@SpringBootApplication 注解是 SpringBoot 的核心注解，它包括了三个...
03-SpringBoot启动过程源码解析-周瑜.pdf
10-24
"SpringBoot启动过程源码解析" SpringBoot启动过程可以分为多个阶段，包括构造SpringApplication对象、推测Web应用类型、获取BootstrapRegistryInitializer对象、获取ApplicationContextInitializer对象、获取...
Springboot启动过程记录
09-04
Springboot启动过程记录
02-Spring容器的初始化与SpringBoot启动过程解析-146530475.md
最新发布
05-07
整理总结不易，还望海涵
SpringBoot启动过程
yxdwind的博客
07-26 333
Spring Boot的启动过程
SpringBoot 启动流程
qq_33807380的博客
01-10 8511
方法来启动 Spring Boot 应用程序。该方法接受两个参数，第一个参数是启动类的类对象，第二个参数是主方法的参数。方法中做了一系列操作来完成项目启动所需的初始化Spring容器、启动内置tomcat、启动应用程序以及通知监听者等步骤。总的来说，Spring Boot的启动过程是一个复杂的流程，从启动类的Main方法中调用。启动类必须使用 @SpringBootApplication 注解标记该类。方法开始，然后在SpringApplication对象的。方法来执行项目启动的后续操作。
ApplicationListener与ApplicationEvent 使用及源码解析（上）
恐龙弟旺仔的博客
06-28 2998
Spring提供ApplicationListener用来监听其他bean的事件，使用ApplicationContext容器对事件进行发布后，所有监听该事件的监听器，都将对该事件进行处理 类似于java的监听器模式，只是在实现上略有不同，基本的思想是一致的。   1.基于java.util.Observable实现的监听器     * 被监听者Watched实现如下： // 被监听对...
Spring之SpringBoot启动过程
ooaash的博客
11-09 372
前言 SpringBoot的启动过程比较长，会涉及到其他模块的事件/监听器，这些监听器里又会有自己的逻辑；本文重点集中在启动过程上，对于比较重要的，对全局有影响的监听器也会单独拎出，说明它的作用。文章很长，先给出启动的大致流程： 启动类 @SpringBootApplication public class WebApplication { public static void main(String[] args) { SpringApplication.run(WebAppl
SpringBoot - 启动过程
大后生大大大的博客
07-01 359
SpringBoot的入口是从SpringApplication.run（ ）方法传入我们的主启动类开始的 @SpringBootApplication public class Web01Application { public static void main(String[] args) { ConfigurableApplicationContext run = SpringApplication.run(Web01Application.class, args);
SpringBoot进阶(叁)：Spring Boot启动过程分析
IT全栈 华强工作室
12-06 2351
首先贴一张很不错的图，SpringBoot启动结构图，图片出自SpringBoot启动流程解析。 本文的分析基于Spring Boot 2.1.*，非Spring的代码只有下面这个启动main函数： @SpringBootApplication public class App { public static void main(String[] args) { SpringApplication application = new SpringApplication(AppServ
SpringBoot启动过程。
03-29
SpringBoot启动过程如下： 1. 加载SpringBoot配置文件：SpringBoot会先加载application.properties或application.yml文件中的配置信息，并创建SpringBoot应用程序的上下文环境。 2. 扫描应用程序中的组件：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值